iKj UdZddlZddlZddlZddlZddlmZmZmZddl m Z m Z m Z ddl mZddlmZmZmZmZmZddlmZddlmZdd lmZdd lmZmZdd lmZdd l m!Z!dd l"m#Z#erddl$m%Z%dgZ&edZ'gdZ(e)e*e+d<e eGdde Z,dddddZ-e)e-e,Dcgc]}|j\c}k(sJe Gdde Z/Gdde Z0e Gdde e0Z1Gd d!ejdZ3ddd"dd"d"d"dd"dddd# Z4d$e5fd%Z6e#eddZ7d&e*d'e'd(ee8d$e'fd)Z9d*ed'e8d&e*d$efd+Z:d,e;d$e;fd-Ze/d2ffd3Z?d4e;d$e;fd5Z@d6e8d$e>e1d2ffd7ZAd8e;eBzejdzdzd$e3dzfd9ZCd:e*d$e*fd;ZDGd<d=eEZFGd>deFZGejd?eGd$eeGddffd@ZIeGdAdBee,je>e/dCdDdEe3dFGdBdH ZKeGjdIeKeGjdIeGjJeGdDdddDe1jgJZOeGjdKeOe6reGjdKeGjJePe(ejeGjjjDchc]1}|jejjk(r |j\3c}k(sJycc}wcc}w)LzThe settings module configures runtime options for Hypothesis. Either an explicit settings object can be used or the default object on this module can be modified. N) Collection GeneratorSequence)EnumEnumMetaunique)total_ordering) TYPE_CHECKINGAnyClassVarOptionalTypeVarInvalidArgument)AVAILABLE_PROVIDERS)get_pretty_function_description) check_type try_convert)not_set)note_deprecation)DynamicVariableExampleDatabasesettingsT max_examples derandomizedatabase verbosityphasesstateful_step_countreport_multiple_bugssuppress_health_checkdeadline print_blobbackend all_settingsceZdZdZdZ dZ dZ dZ edZ de fdZ e d dde fd Zd edeffd Zd edefd Zd edefdZxZS) Verbosityz=Options for the |settings.verbosity| argument to |@settings|.quietnormalverbosedebugct|tr?t|ts/ddddd}||vr$td|d||dd d d |||Sy) Nr+r,r-r.)rzPassing Verbosity(zn) as an integer is deprecated. Hypothesis now treats Verbosity values as strings, not integers. Use Verbosity. instead. 2025-11-05Fr1since has_codemod stacklevel isinstanceintboolrclsvalue int_to_names Y/home/oem/CyberBrain26-unified/.venv/lib/python3.12/site-packages/hypothesis/_settings.py _missing_zVerbosity._missing_ast eS !*UD*A%(yWMK # (0%%0%7$8 C' % ;u-..returnc d|jS)Nz Verbosity.nameselfs rA__repr__zVerbosity.__repr__rsDII;''rCr?c(t|jSN)_VERBOSITY_INT_VALUESrG)r?s rA _int_valuezVerbosity._int_valueus$UZZ00rCothercrt|trt| |Stj ||k(SrL)r:r*super__eq__rN)rIrO __class__s rArRzVerbosity.__eq__ys2 eY '7>%( (##D)U22rCctj|}t|trtj|n|}||kDSrLr*rNr:rIrOvalue1value2s rA__gt__zVerbosity.__gt__~s8%%d+0:5)0L%%e,RWrCctj|}t|trtj|n|}||k\SrLrUrVs rA__ge__zVerbosity.__ge__s9%%d+0:5)0L%%e,RWrC)__name__ __module__ __qualname____doc__r+r,r-r. classmethodrBstrrJ staticmethodr;rNr r<rRrYr[ __classcell__rSs@rAr*r*?sH EF G  E  (#(1+1#113C3D3 CD  C D rCr*r0r1r2)r+r,r-r.cPeZdZdZdZ dZ dZ dZ dZ dZ e dZ d e fd Z y ) Phasez:Options for the |settings.phases| argument to |@settings|.explicitreusegeneratetargetshrinkexplainct|trAt|ts1ddddddd}||vr$td|d ||d d d d |||Sy)Nrgrhrirjrkrl)rr0r1r2zPassing Phase(zf) as an integer is deprecated. Hypothesis now treats Phase values as strings, not integers. Use Phase.r3r4Fr1r5r9r=s rArBzPhase._missing_s eS !*UD*A K # $UG,!!,U!3 4I?' % ;u-..rCrDc d|jS)NzPhase.rFrHs rArJzPhase.__repr__s {##rCN)r\r]r^r_rgrhrirjrkrlr`rBrarJrCrArfrfskDH EHFFG.$#$rCrfceZdZfdZxZS)HealthCheckMetactjtjftfdt|DS)Nc3,K|] }|vs| ywrLrq).0x deprecateds rA z+HealthCheckMeta.__iter__..sI!Qj5HAI ) HealthCheck return_valuenot_a_test_methoditerrQ__iter__)rIrxrSs @rArzHealthCheckMeta.__iter__s2!.. 0M0MN Iuw/1IIIrC)r\r]r^rrcrds@rArsrssJJrCrsc|eZdZdZedZdefdZededfdZ dZ dZ dZ d Z d Z d Z d Z d Z dZy)r{a| A |HealthCheck| is proactively raised by Hypothesis when Hypothesis detects that your test has performance problems, which may result in less rigorous testing than you expect. For example, if your test takes a long time to generate inputs, or filters away too many inputs using |assume| or |filter|, Hypothesis will raise a corresponding health check. A health check is a proactive warning, not an error. We encourage suppressing health checks where you have evaluated they will not pose a problem, or where you have evaluated that fixing the underlying issue is not worthwhile. With the exception of |HealthCheck.function_scoped_fixture| and |HealthCheck.differing_executors|, all health checks warn about performance problems, not correctness errors. Disabling health checks ----------------------- Health checks can be disabled by |settings.suppress_health_check|. To suppress all health checks, you can pass ``suppress_health_check=list(HealthCheck)``. .. seealso:: See also the :doc:`/how-to/suppress-healthchecks` how-to. Correctness health checks ------------------------- Some health checks report potential correctness errors, rather than performance problems. * |HealthCheck.function_scoped_fixture| indicates that a function-scoped pytest fixture is used by an |@given| test. Many Hypothesis users expect function-scoped fixtures to reset once per input, but they actually reset once per test. We proactively raise |HealthCheck.function_scoped_fixture| to ensure you have considered this case. * |HealthCheck.differing_executors| indicates that the same |@given| test has been executed multiple times with multiple distinct executors. We recommend treating these particular health checks with more care, as suppressing them may result in an unsound test. c t|trDt|ts4ddddddddd d }||vr$td |d ||d ddd|||Sy)Ndata_too_largefilter_too_muchtoo_slowr|large_base_exampler}function_scoped_fixturediffering_executors nested_given) r0r1r2ro zPassing HealthCheck(zr) as an integer is deprecated. Hypothesis now treats HealthCheck values as strings, not integers. Use HealthCheck.r3r4Fr1r5r9r=s rArBzHealthCheck._missing_s eS !*UD*A#$!'&,)" K # *5'2''25'9&:)E' % ;u-..rCrDcL|jjd|jS)N.)rSr\rGrHs rArJzHealthCheck.__repr__s"..))*!DII;77rCc>tddddttS)NzC`HealthCheck.all()` is deprecated; use `list(HealthCheck)` instead.z 2023-04-16Tr0r5)rlistr{r>s rAallzHealthCheck.all!s%  Q  K  rCrrrr|rr}rrrN)r\r]r^r_r`rBrarJrrrrrr|rr}rrrrqrCrAr{r{s)V48#8!D'!!&N(OH "LI- ,S8J"0 %"LrCr{) metaclassceZdZdZdefdZy)durationz2A timedelta specifically measured in milliseconds.rDcl|jdz}d|t|k(rt|dS|dS)Niztimedelta(milliseconds=)) total_secondsr;)rImss rArJzduration.__repr__s@    !D ((B#b'MR(LANNr(LANNrCN)r\r]r^r_rarJrqrCrArrs<O#OrCrtrue) CI&__TOX_ENVIRONMENT_VARIABLE_ORIGINAL_CITF_BUILDzbamboo.buildKey BUILDKITECIRCLECI CIRRUS_CICODEBUILD_BUILD_IDGITHUB_ACTIONS GITLAB_CIHEROKU_TEST_RUN_IDTEAMCITY_VERSIONrDcJtdtjDS)Nc3K|]7\}}|tjvxr|duxstj||k(9ywrL)osenviron)rvkeyr?s rAryzis_in_ci..sC C rzzIu}H 350HIs=?)any_CI_VARSitemsrqrCrAis_in_cirs# "..* rCrGr?choicesc:||vrd|d|d|}t||S)NzInvalid , z. Valid choices: r)rGr?rmsgs rA_validate_choicesrs3 Gb ):7+Fc"" LrCr>c  ||S#t$r+t|d|ddjd|DdwxYw)N=z( is not a valid value. The options are: rc3FK|]}t|jywrL)reprrG)rvms rAryz'_validate_enum_value..s8qd166l8s!) ValueErrorrjoin)r>r?rGs rA_validate_enum_valuers\5z fAeWII8C889 ;  s 4>rcRtt|d|dkrtd|d|S)NrrFr0z max_examples=zg must be at least one. If you want to disable generation entirely, use phases=[Phase.explicit] instead.rr;r)rs rA_validate_max_examplesrs?sL~6aL+,S S   rCrrcDddlm}| t||r|Std)NrrzArguments to the database setting must be None or an instance of ExampleDatabase. Use one of the database classes in hypothesis.database)hypothesis.databaserr:r)rrs rA_validate_databasers-4:h@   rCr!.cttdtdDtfdttDS)Nr!c3@K|]}tt|dyw)r!rFN)rrf)rvphases rAryz#_validate_phases..s">CUE99c3,K|] }|vs| ywrLrq)rvrr!s rAryz#_validate_phases..sC55F?Crz)rtuplerrf)r!s`rA_validate_phasesrs?  1F GMF CDKC CCrCr"cRtt|d|dkrtd|d|S)Nr"rFr0zstateful_step_count=z must be at least one.r)r"s rA_validate_stateful_step_countrs<s'.CDQ"#6"99O P   rC suppressionsctt|d}|D]B}|tjtjfvs&t d|j ddddDtd|DS) Nr$zThe z= health check is deprecated, because this is always an error.z 2023-03-15Fr1r5c3@K|]}tt|dyw)r$rFN)rr{)rv health_checks rAryz2_validate_suppress_health_check..s%  [,=TUUr)rrr{r|r}rrG)r convertedrs rA_validate_suppress_health_checkrszE<1HII! K44k6S6ST T |(())fg"!   % rCr%c||Std|dt|jd}t|tt frt|t r| t|}t|tjrA|tjdkrtd|dt|jS|#t$rtd|ddwxYw) Nz deadline=z (type zx) must be a timedelta object, an integer or float number of milliseconds, or None to disable the per-test-case deadline. millisecondszi is invalid, because it is too large to represent as a timedelta. Use deadline=None to disable deadlines.rzf is invalid, because it is impossible to meet a deadline <= 0. Use deadline=None to disable deadlines.)seconds) rtyper\r:r;floatr<r OverflowErrordatetime timedeltar)r%invalid_deadline_errors rA_validate_deadliners, H'>&?@" " (S%L) h %( ( X6H (H../ x))!, ,!H<(II  6 6 899   !H<(JJ  s  B<<Cr'c|tvr6|dk(rd}td|d|td|dtt|S)N crosshairz4`pip install "hypothesis[crosshair]"` and try again.zbackend=z is not available. zP is not available - maybe you need to install a plugin? Installed backends: )rrsorted)r'installs rA_validate_backendrsc)) k !LG!HWK7KG9"UV Vwk"))/0C)D(G I   NrCcXeZdZfdZededfdZdededdffd Z d Z xZ S) settingsMetac$t||i|yrL)rQ__init__)r>argskwargsrSs rArzsettingsMeta.__init__s $)&)rCrDrctj}||SttddGtjJtj tjtjJtjS)N_current_profile)default_variabler?getattrrr load_profile)r>vs rAdefaultzsettingsMeta.defaultsk  " " =H 8/ 6 B,,8 88  ! !(";"; <#))5 55%%%rCrGr?Nc|dk(r td|jdstd|d|dt| ||y)Nrz^Cannot assign to the property settings.default - consider using settings.load_profile instead._z"Cannot assign hypothesis.settings.rz - the settings class is immutable. You can change the global default settings with settings.load_profile, or use @settings(...) to decorate your test instead.)AttributeError startswithrQ __setattr__)r>rGr?rSs rArzsettingsMeta.__setattr__)sb 9  @ % 4TF!E9E11  D%(rCcy)Nzhypothesis.settingsrqrs rArJzsettingsMeta.__repr__8s$rC) r\r]r^rpropertyr rraobjectrrJrcrds@rArrsG*&,&& )s )6 )d )%rCrceZdZUdZiZeeedfed<dZ eedzed< d/e e e e e e e e e e e d de dde de d e d d d d edde de dedde ezej"zdzde deddfdZede fdZede fdZed0dZedefdZedeefdZede fdZede fdZedeefdZedej"dzfd Zede fd!Z edefd"Z!d#e"de"fd$Z#d%ed&e$ddffd' Z%defd(Z&defd)Z'e( d/d%ede dd*e)ddfd+Z*e(d%eddfd,Z+e(d%eddfd-Z,e(defd.Z-xZ.S)1ra A settings object controls the following aspects of test behavior: |~settings.max_examples|, |~settings.derandomize|, |~settings.database|, |~settings.verbosity|, |~settings.phases|, |~settings.stateful_step_count|, |~settings.report_multiple_bugs|, |~settings.suppress_health_check|, |~settings.deadline|, |~settings.print_blob|, and |~settings.backend|. A settings object can be applied as a decorator to a test function, in which case that test function will use those settings. A test may only have one settings object applied to it. A settings object can also be passed to |settings.register_profile| or as a parent to another |settings|. Attribute inheritance --------------------- Settings objects are immutable once created. When a settings object is created, it uses the value specified for each attribute. Any attribute which is not specified will inherit from its value in the ``parent`` settings object. If ``parent`` is not passed, any attributes which are not specified will inherit from the current settings profile instead. For instance, ``settings(max_examples=10)`` will have a ``max_examples`` of ``10``, and the value of all other attributes will be equal to its value in the current settings profile. Changes made from activating a new settings profile with |settings.load_profile| will be reflected in settings objects created after the profile was loaded, but not in existing settings objects. .. _builtin-profiles: Built-in profiles ----------------- While you can register additional profiles with |settings.register_profile|, Hypothesis comes with two built-in profiles: ``default`` and ``ci``. By default, the ``default`` profile is active. If the ``CI`` environment variable is set to any value, the ``ci`` profile is active by default. Hypothesis also automatically detects various vendor-specific CI environment variables. The attributes of the currently active settings profile can be retrieved with ``settings()`` (so ``settings().max_examples`` is the currently active default for |settings.max_examples|). The settings attributes for the built-in profiles are as follows: .. code-block:: python default = settings.register_profile( "default", max_examples=100, derandomize=False, database=not_set, # see settings.database for default behavior verbosity=Verbosity.normal, phases=tuple(Phase), stateful_step_count=50, report_multiple_bugs=True, suppress_health_check=(), deadline=duration(milliseconds=200), print_blob=False, backend="hypothesis", ) ci = settings.register_profile( "ci", parent=default, derandomize=True, deadline=None, database=None, print_blob=True, suppress_health_check=[HealthCheck.too_slow], ) You can replace either of the built-in profiles with |settings.register_profile|: .. code-block:: python # run more examples in CI settings.register_profile( "ci", settings.get_profile("ci"), max_examples=1000, ) _profilesNrrparentrrrrr r*r!rfr"r#r$r{r%r&r'rDc d|_|tt|d|tdfvr|tdfvrt d|dd}|xstj |_|tur|j jn t||_ |tur|j jntd|ddg|_ |tur t|}||_d|_|tur|j j nt#t$|d |_|tur|j j(n t+||_|tur|j j.n t1||_|tur|j j4ntd |ddg|_| tur|j j8n t;| |_| tur|j j>n tA| |_!| tur|j jDntd | ddg|_#| tur|j jHn tK| |_&d|_y) NTrFz`. If you are running more than 100k test cases for a test, consider using our :ref:`integration for coverage-guided fuzzing ` - it really shines when given minutes or hours to run. The default max examples is ``100``. .. note:: See :doc:`../explanation/test-case-count` for details on how |max_examples| interacts with other parts of Hypothesis. )rrHs rArzsettings.max_examplessP!!!rCc|jS)ar If True, seed Hypothesis' random number generator using a hash of the test function, so that every run will test the same set of test cases until you update Hypothesis, Python, or the test function. This allows you to `check for regressions and look for bugs `__ using separate settings profiles - for example running quick deterministic tests on every commit, and a longer non-deterministic nightly testing run. The default is ``False``. If running on CI, the default is ``True`` instead. )rrHs rArzsettings.derandomizes   rCcddlm}|j |jtusJ|tS|j 9|jtur|jj n |j|_|j S)a An instance of |ExampleDatabase| in which we will save failing |test cases|, and from which we will load previous failing test cases. If not set, a |DirectoryBasedExampleDatabase| is created in the current working directory under ``.hypothesis/examples``. If this location is unusable, e.g. due to the lack of read or write permissions, Hypothesis will emit a warning and fall back to an |InMemoryExampleDatabase|. If ``None``, no storage will be used. See the :ref:`database documentation ` for a list of database classes, and how to define custom database classes. r) _db_for_path)rr rrrrr)rIr s rArzsettings.database/st 5 >> !>>W, ,,( (  (+/>>W+D''$..  !$$$rCc|jS)a Control the verbosity level of Hypothesis messages. To see what's going on while Hypothesis runs your tests, you can turn up the verbosity setting. .. code-block:: pycon >>> from hypothesis import settings, Verbosity >>> from hypothesis.strategies import lists, integers >>> @given(lists(integers())) ... @settings(verbosity=Verbosity.verbose) ... def f(x): ... assert not any(x) ... f() Test case: [] Failing test case: [-1198601713, -67, 116, -29578] Shrunk test case to [-1198601713] Shrunk test case to [-128] Shrunk test case to [32] Shrunk test case to [1] [1] The four levels are |Verbosity.quiet|, |Verbosity.normal|, |Verbosity.verbose|, and |Verbosity.debug|. |Verbosity.normal| is the default. For |Verbosity.quiet|, Hypothesis will not print anything out, not even the |minimal failing test case|. |Verbosity.debug| is basically |Verbosity.verbose| but a bit more so. You probably don't want it. Verbosity can be passed either as a |Verbosity| enum value, or as the corresponding string value, or as the corresponding integer value. For example: .. code-block:: python # these three are equivalent settings(verbosity=Verbosity.verbose) settings(verbosity="verbose") If you are using :pypi:`pytest`, you may also need to :doc:`disable output capturing for passing tests ` to see verbose output as tests run. )rrHs rAr zsettings.verbosityUsZrCc|jS)a. Control which phases should be run. Hypothesis divides tests into logically distinct phases. - |Phase.explicit|: Running |explicit examples| from |@example|. - |Phase.reuse|: Running |test cases| from the database which previously failed. - |Phase.generate|: Generating new random test cases. - |Phase.target|: Mutating test cases for :ref:`targeted property-based testing `. Requires |Phase.generate|. - |Phase.shrink|: Shrinking |failing test cases|. - |Phase.explain|: Attempting to explain why a failure occurred. Requires |Phase.shrink|. The phases argument accepts a collection with any subset of these. E.g. ``settings(phases=[Phase.generate, Phase.shrink])`` will generate new test cases and shrink them, but will not run explicit examples or reuse previous failures, while ``settings(phases=[Phase.explicit])`` will only run explicit examples from |@example|. Phases can be passed either as a |Phase| enum value, or as the corresponding string value. For example: .. code-block:: python # these two are equivalent settings(phases=[Phase.explicit]) settings(phases=["explicit"]) Following the first failure, Hypothesis will (usually, depending on which |Phase| is enabled) track which lines of code are always run on failing but never on passing inputs. On 3.12+, this uses :mod:`sys.monitoring`, while 3.11 and earlier uses :func:`python:sys.settrace`. For python 3.11 and earlier, we therefore automatically disable the explain phase on PyPy, or if you are using :pypi:`coverage` or a debugger. If there are no clearly suspicious lines of code, :pep:`we refuse the temptation to guess <20>`. After shrinking to a minimal failing test case, Hypothesis will try to find parts of the test case -- e.g. separate args to |@given| -- which can vary freely without changing the result of that minimal failing test case. If the automated experiments run without finding a passing variation, we leave a comment in the final report: .. code-block:: python test_x_divided_by_y( x=0, # or any other generated value y=0, ) Just remember that the *lack* of an explanation sometimes just means that Hypothesis couldn't efficiently find one, not that no explanation (or simpler failing test case) exists. )rrHs rAr!zsettings.phasesst||rCc|jS)a| The maximum number of times to call an additional |@rule| method in :ref:`stateful testing ` before we give up on finding a bug. Note that this setting is effectively multiplicative with max_examples, as each test case will run for a maximum of ``stateful_step_count`` steps. The default stateful step count is ``50``. )rrHs rAr"zsettings.stateful_step_counts(((rCc|jS)a Because Hypothesis runs the test many times, it can sometimes find multiple bugs in a single run. Reporting all of them at once is usually very useful, but replacing the exceptions can occasionally clash with debuggers. If disabled, only the exception with the smallest |minimal failing test case| is raised. The default value is ``True``. )rrHs rAr#zsettings.report_multiple_bugss)))rCc|jS)a Suppress the given |HealthCheck| exceptions. Those health checks will not be raised by Hypothesis. To suppress all health checks, you can pass ``suppress_health_check=list(HealthCheck)``. Health checks can be passed either as a |HealthCheck| enum value, or as the corresponding string value. For example: .. code-block:: python # these two are equivalent settings(suppress_health_check=[HealthCheck.filter_too_much]) settings(suppress_health_check=["filter_too_much"]) Health checks are proactive warnings, not correctness errors, so we encourage suppressing health checks where you have evaluated they will not pose a problem, or where you have evaluated that fixing the underlying issue is not worthwhile. .. seealso:: See also the :doc:`/how-to/suppress-healthchecks` how-to. )rrHs rAr$zsettings.suppress_health_checks2***rCc|jS)a The maximum allowed duration of an individual |test case|, in milliseconds. You can pass an integer, float, or timedelta. If ``None``, the deadline is disabled entirely. We treat the deadline as a soft limit in some cases, where that would avoid flakiness due to timing variability. The default deadline is 200 milliseconds. If running on CI, the default is ``None`` instead. )rrHs rAr%zsettings.deadlines~~rCc|jS)a  If set to ``True``, Hypothesis will print code for |failing test cases| that can be used with |@reproduce_failure| to reproduce the failing test case. The default value is ``False``. If running on CI, the default is ``True`` instead. )rrHs rAr&zsettings.print_blobsrCc|jS)a" .. warning:: EXPERIMENTAL AND UNSTABLE - see :ref:`alternative-backends`. The importable name of a backend which Hypothesis should use to generate primitive types. We support heuristic-random, solver-based, and fuzzing-based backends. )rrHs rAr'zsettings.backends}}rCtestc|}t|std|dtj|rWddlm}t ||r:d}t||dr tdt||d||j_ |Std t|dr(t|}t|d |jd |||_ d|_|S) zMake the settings object (self) an attribute of the test. The settings are later discovered by looking them up on the test itself. zNsettings objects can be called as a decorator with @given, but decorated test=z is not callable.r)RuleBasedStateMachine%_hypothesis_internal_settings_appliedFzhApplying the @settings decorator twice would overwrite the first version; merge their arguments instead.Tzg@settings(...) can only be used as a decorator on functions, or on subclasses of RuleBasedStateMachine.zC has already been decorated with a settings object. Previous: z This: )callablerinspectisclasshypothesis.statefulr issubclassrsetattrTestCaserhasattrr!_hypothesis_internal_use_settingsr)rIr_testr attr_namedescrs rA__call__zsettings.__call__s~!'!%'8:  ??4 A%!67C 4E2)# i.*.' %L 5A B4D9E!'""'"I"I!LM"X'  37/6:3 rCrGr?ct|jds|js tdt|||S)Nrzsettings objects are immutable)rrrrQr)rIrGr?rSs rArzsettings.__setattr__Js5s#D,?,? !AB Bw"4//rCcttfdtD}djdj|S)Nc3nK|],}|dk7sttdkDr|dt|.yw)r'r0rN)lenrr)rvrGrIs rAryz$settings.__repr__..PsA  !S)<%=%AfAgdD), - s25z settings({})r)rr(formatr)rIbitss` rArJzsettings.__repr__Os5 $   $$TYYt_55rCcg}tD]8}t||}|tt|k7s#|j|d|:dj t |t S)Nrr)r)r(rrappendrrr))rIr+rGr?s rA show_changedzsettings.show_changedWs`  1DD$'E.. tfAeY/0 1yy#.//rCrc tt|dtjrPtj r@tjtj tj k7rtddd||s|n t dd|i|tj |<tj |k(rtj|yy) aP Register a settings object as a settings profile, under the name ``name``. The ``parent`` and ``kwargs`` arguments to this method are as for |settings|. If a settings profile already exists under ``name``, it will be overwritten. Registering a profile with the same name as the currently active profile will cause those changes to take effect in the active profile immediately, and do not require reloading the profile. Registered settings profiles can be retrieved later by name with |settings.get_profile|. rGzCannot register a settings profile when the current settings differ from the current profile (usually due to an @settings decorator). Register profiles at module level instead.z 2025-11-15F)r6r7Nrrq) rrarr?rrrrr)rGrrs rAregister_profilezsettings.register_profile_s& 3f%  " ")) &&(*<*>> settings.load_profile("myprofile") >>> settings.get_current_profile_name() 'myprofile' )rrrqrCrAget_current_profile_namez!settings.get_current_profile_names"((444(((rCrL)rDzExampleDatabase | None)/r\r]r^r_rr dictra__annotations__rrr r;r<rrrrrrrrrr*r rfr!r"r#r{r$r%r&r'rr%rrrJr.rbr r0r3rr6rcrds@rArr<sJTl24IxS*_-.3-1hsTz*1(,\$$#07!(&-#*%,;B++4 (,,t3   D     -Q-1-^00F0t0 6#60c0(,+(+($+(+(  +(+(Z S# S* S S<3<4<< )c ) )rCsc#hKtj|5|dddy#1swYyxYwwrL)r with_value)r9s rAlocal_settingsr<s-  $ $Q 's2& 2/2dF2Trqr hypothesisr)rr%rr&r$ci)Xr_ contextlibrrrcollections.abcrrrenumrrr functoolsr typingr r r r rhypothesis.errorsr(hypothesis.internal.conjecture.providersrhypothesis.internal.reflectionrhypothesis.internal.validationrrhypothesis.utils.conventionsrhypothesis.utils.deprecationr!hypothesis.utils.dynamicvariablesrrr__all__rr(rrar8r*rMrGrfrsr{rrrr<rrrrrr;rrrrrrrrrrrrcontextmanagerr<r,rr0rrrset signaturer parametersvalueskind Parameter KEYWORD_ONLY)r ps00rArXs"  ;;''$IJB09=3 , CL  d3i E E E R#$qQK !"y&Q)y~~&QQQQ=$D=$=$@JhJ f$/ffROx!!O .2 "$9?8J#78>Cx7GAc&33 ()    DZ.D53DDss & U;PSCS=T  !EkH...5! _!< s s %4%Dt )t )n h9XtT-A#B   < 3 '   )W-i ###   &//0  $# : $###  < W  x00 1 < < C C E vv""///FFg"'Rf"s .L6L