iKj( UdZddlZddlZddlZddlZddlmZmZmZm Z ddlm Z m Z ddl m Z ddlmZddlmZddlmZmZmZmZmZmZmZmZmZmZdd lmZdd l m!Z!m"Z"m#Z$dd l%m&Z&m'Z'dd l(m)Z)m*Z*dd l+m,Z,m-Z-m.Z.ddl/m0Z0m1Z1ddl2m3Z3ddl4m5Z5ddl6m7Z7ddl8m9Z9ddl:m;Z;mZ>m?Z?m@Z@mAZAddlBmCZCddlDmEZEmFZFddlGmHZHmIZIddlJmKZKmLZLmMZMmNZNmOZOmPZPmQZQddlRmSZSddlTmUZUer!ddlmVZVddlWmXZXGddejZZedZ[e7d Z\ee]e^d!<d"e_d#e`fd$ZaGd%d&ZbGd'd(Zcdddd)d*edd+d,e$dzd-e]d.eeefe`fdzd#ed/f d0Zgddd1d*edd+d,e$dzd-e]d#dfd2ZhGd3d4edZie d5d56Gd7d8ZjGd9d+ei:Zke d5d;6Gd<d=ZlejZneeNee^d><Gd?d@eMZoGdAdBeNeKZpdCepeKd#eNeKfdDZqe d5d56GdEdFeeKZrdGe[d#ere[fdHZsdIZtdJZudKZvdLZwdMZxedNereKeKzfZyeeyeKgeyeKfZzdOed#effdPZ{edNdQdRe epeKdSddTeNd#ezeKfdUZ|edNdVdSepeKdRebdTeNd#ezeKfdWZ|edNdNdXdSddRebdTeNd#eed/ged/ffdYZ|dZdd[dRe epeKebzdSepeKdzdTeNd#ezeKeed/ged/fzfd\Z|edNdQdRe epeKdSddTeNd#ezeKfd]Z}edNdVdSepeKdRebdTeNd#ezeKfd^Z}edNdNdXdSddRebdTeNd#eed/ged/ffd_Z}dZdd[dRe epeKebzdSepeKdzdTeNd#ezeKeed/ged/fzfd`Z}e d5d56GdadbZ~dceege`fd#ee)ge)ffddZe d5d56GdedfZd;dgdhe`d#ee)ge)ffdiZGdjdkeNZy)laThis module provides support for a stateful style of testing, where tests attempt to find a sequence of operations that cause a breakage rather than just a single value. Notably, the set of steps available at any point may depend on the execution to date. N)CallableIterableIteratorSequence) dataclassfield) lru_cache)StringIO) perf_counter) TYPE_CHECKINGAnyClassVarFinalLiteralNever TypeGuardTypeVarcastoverload) strategies) HealthCheck Verbositysettings)_current_build_contextcurrent_build_context)TestFuncgiven)FlakyStrategyDefinitionInvalidArgumentInvalidDefinition)add_notebatched) BUFFER_SIZE)gc_cumulative_time)calc_label_from_name)fail_health_check)PredicateCountsobservability_enabled)function_digestget_pretty_function_descriptionnicereprproxies) check_type)current_verbosityreport) FeatureFlagsFeatureStrategy)Ex OneOfStrategySampledFromStrategySearchStrategycheck_strategycurrent_filter_call_sitefilter_not_satisfied)note_deprecation)RepresentationPrinter) defaultdict)ConjectureDatac&eZdZUeeed<ddZy)_StateMachineTestCaserNcyNselfs X/home/oem/CyberBrain26-unified/.venv/lib/python3.12/site-packages/hypothesis/stateful.pyrunTestz_StateMachineTestCase.runTestVreturnN)__name__ __module__ __qualname__rSettings__annotations__rErArGrDr>r>Ss8$$&rGr>Tzanother state machine stepSTATE_MACHINE_RUN_LABELobjrIcht|tr d|cxkrdkryt|txs|duS)zm Returns True if two separately created instances of v will have the same id (due to interning). TN) isinstanceintbool)rQs rD _is_singletonrX]s:#sc 0S 0!1 c4 /C4K/rGceZdZdZy)_OmittedArgumentzmSentinel class to prevent overlapping overloads in type hints. See comments above the overloads of @rule.N)rJrKrL__doc__rArGrDrZrZks%rGrZcZeZdZ d dddeddzdedfdZded edefd Zdedefd Zy) TestCasePropertyNrQzRuleBasedStateMachine | NonetypRuleBasedStateMachinerIr>cD| t|}|J|jSr@)type _to_test_case)rCrQr^s rD__get__zTestCaseProperty.__get__qs+ ?s)C  ""rGvaluectd)NzCannot set TestCaseAttributeError)rCrQrds rD__set__zTestCaseProperty.__set__{s233rGctd)NzCannot delete TestCaserf)rCrQs rD __delete__zTestCaseProperty.__delete__~s566rGr@)rJrKrLrarcrrhrjrArGrDr]r]psf59# +#) *T 1# % & #4544547e77rGr]r _min_steps _flaky_statestate_machine_factoryr_rrlrm).Nc$( jjttdttdttddkrtddxsittjfd}t|jj_t!d d|_t!d d|_d |_|S#t$rtdt t YwxYw) Nz'state_machine_factory.TestCase.settingsdeadlinesuppress_health_checkrrlrz _min_steps=z must be non-negative.c h |j}tt|d|_j|_t j xsttjk\g_ fd} |d|jjd|j|jj}d} j!t"d}||k\rd}n |krd}nj$dt&zkDrd}t)}t+}j-d | rn|d z }dd <|j.r|j.Dcgc]H}t1j2t1j4|t1j6|j8J} }j;t1j<| \}}|j.j?|nj;|j@\}}dd <d |jBj} jDjG| dt+|z } jD| xxt)|z | z z cc<s tIr2|jKD cic]\} } | |jM| }} } tO} tQ|}tS|jKD]\} } tU| tVr|jX| jZ|| <3tU| tRsDt]d| DsW| Dcgc]}|jX|jZc}|| <d|jBj}t)}t+}|jB|fi|}t+|z } j|xxt)|z | z z cc<|j^rUtU|t`r'|jc|j^|jdnU|jc|j^|gn7|5tgd|jBjhd|tjjls tIr||jo|| |j|jjq |d|jsycc}wcc} } wcc}w#s tIr||jo||wwxYw#|d|jswxYw)Nzstate_machine_factory()cVr t|jj|yr@)r/_stateful_repr_partsappend)scd print_stepss rDoutputzAget_state_machine_test..run_state_machine..outputs!q  # # * *1 -rGzstate = ()rTFg?g>)pforcedselecting_rulezgenerate:rule:gc3<K|]}t|tywr@rU VarReference.0items rD zDget_state_machine_test..run_state_machine..s9?CJt\:9z execute:rule:z.run_state_machines ! !)>)@('3LM&,.,H,H) " # , , V0A0Cy0V #% . b  Xg//889< =  $ $Xvr7M7M N 44II 56  ) $I*, %IYY# "34!%I)^ -/??VI?>Q 26 -.33%,$D$D"  "''$-1F1Ft~~1VW"J""$:)>!?JD$44;;DA!#)@)@!AJD$16 -.-dmm.D.D-EF  ((S9.08;  j)\^j-H9-TT) "7"9@D %8<170033%M% ""P:D $TZZ\ 2Y1%a6&-&=&=aff&EDG'40S9GH96WX&Xdw'>'>tyy'I&XDG Y,DMM,B,B+CDE(NE13H*T]]7;d;F 2 4x ?I**51\^e5Ki5WW1||%fo>#;;DLL&--X#;;DLL6(S+)$##'==#=#=">j T'44 #&;&=w11$ vNO((62;Q;QR s*L % &    A"&%'Y,#&;&=w11$ vNO '> % &    sf?CTA S$C.TS!. T>H x+T Ux:.sJ -A~ J<7MNOO%2L  2779ssn -.  ++K7>>73DKKTD@?D; [ XT+EVWH Xs'C))#DD)rrlcddi}t||||} |y#t$r}|dr t|dd}~wwxYw)apRun a state machine definition as a test, either silently doing nothing or printing a minimal breaking program and raising an exception. state_machine_factory is anything which returns an instance of RuleBasedStateMachine when called with no arguments - it can be a class or a function. settings will be used to control the execution of the test. rFrkzwwhile selecting a rule to run. This is usually caused by a flaky precondition, or a bundle that was unexpectedly empty.N)rrr!)rnrrl flaky_statestate_machine_testerrs rDrun_state_machine_as_testrs_$U+K/   " ' ( Q  s =8=c,eZdZdededdffd ZxZS)StateMachineMetarrdrINc |dk(r]t|trMd|jd}td|jd|d|jd|d|jd t |||S) Nr settings()z Assigning z .settings = z does nothing. Assign to .TestCase.settings, or use @ as a decorator on the  class.)rUrM show_changedrgrJsuper __setattr__)clsrrddescrrs rDrzStateMachineMeta.__setattr__@s : *UH"= 2 2 45Q7E S\\N,ug>ll^#?wG,,w0  w"4//rG)rJrKrLstrr r __classcell__rs@rDrr?s"0s030400rGrT)slotsfrozenc>eZdZUeded<eded<eded<y) _SetupStateRulerules Invariant invariants initializersN)rJrKrLrrNrArGrDrrKs! <[!!v,rGrceZdZUdZiZeeeefe d<e de d<e de d<ee e dfe d<e je e d <e e e d <ee efe d <d e d <d%dZdZde fdZdZdede e fdZde de dfdZedefdZdddedede fdZdZdedee gefd ee efddfd!Zd%d"Ze Z!ee"ded#fd$Z#y)&r_aA RuleBasedStateMachine gives you a structured way to define state machines. The idea is that a state machine carries the system under test and some supporting data. This data can be stored in instance variables or divided into Bundles. The state machine has a set of rules which may read data from bundles (or just from normal strategies), push data onto bundles, change the state of the machine, or verify properties. At any given point a random applicable rule will be executed. _setup_state_per_classrrrrrbundlesnames_counters names_listrz!defaultdict[str, PredicateCounts]rrINc |j}|js"tdt|jdt t t|jdx}trAt|j}d|jd}td|d|d|d |d |j|_|j|_ |jj|_ i|_tj |_g|_i|_t)|_t-|j*t.j0 |_t5||_y) NzState machine z defines no rulesrrrzAssigning settings = z. as a class attribute does nothing. Assign to rrr)context) setup_staterr rarJrUvarsgetrMrrrcopyrr collectionsCounterrrrr _RuleBasedStateMachine__streamr:rrd_RuleBasedStateMachine__printer RuleStrategyr)rCrrwtnamers rD__init__zRuleBasedStateMachine.__init__hsM&&(   # d!4!4 55FG  4T +// ;;aX FJ''E 013E#'w/"G#?wG)  !&& %00(3(@(@(E(E(G% )113!  . MM#9#?#?  ,D1rGc|t|tr |jSt|trAt d|Dr/ddj |Dcgc]}|jc}zdzS|j jd|j jdd|j_ d|j_ |jjj|jj||jj|j j!Scc}w)Nc3<K|]}t|tywr@rrs rDrz6RuleBasedStateMachine._pretty_print..s- /3Jt\ *- r[, ]r)rUrrrrjoinrseektruncater output_width buffer_widthbufferclearprettyflushgetvalue)rCrdrs rDrz#RuleBasedStateMachine._pretty_prints e\ *::  t $- 7<- * %#@$DII#@AACG G 1 q!&'#&'# ##% e$ }}%%''$AsD9 c^t|jdt|jdS)N(r)rarJr+rrBs rD__repr__zRuleBasedStateMachine.__repr__s*t*%%&a(>'?qAArGc|d|j|}|j|xxdz cc<|jj||S)N_r~)rrrv)rCtargetrs rD _new_namezRuleBasedStateMachine._new_namesK81T0089: F#q(# v& rGnc^t|j}||k\sJ|j||z dSr@)lenr)rCrlen_s rD _last_namesz!RuleBasedStateMachine._last_namess14??#qyytaxz**rGrc:|jj|gSr@)rr)rCrs rDbundlezRuleBasedStateMachine.bundles||&&tR00rGc |j|S#t$rYnwxYwg}g}g}tj|D]\}}t |t d}t |t d}t |td}||j|||j|||j|t |td||tt|dt|||} | |j|<| S)Nz has been decorated with @precondition, but not @rule (or @invariant), which is not allowed. A precondition must be combined with a rule or an invariant, since it has no effect alone.)rrr) rKeyErrorinspect getmembersr RULE_MARKERINITIALIZE_RULE_MARKERINVARIANT_MARKERrvPRECONDITIONS_MARKERr _rule_qualnamer) rrrr_namefr initializer invariantstates rDrz!RuleBasedStateMachine.setup_states( --c2 2   #% &( **3/ HE11k40D!!%;TBK#3T:I T"&##K0$!!),/6BL%'%a()*44! .lz +0""3' s  rrrc$d}g}|jr!t|trt|jnd}t|j|z}|j |}t|trt|jdk(r(|D cgc]} d| d } } dj | dz}n|jrutt||} dj | d} | dz}| ddD]*} dj | }|j|dz| z,ndj |dz}dj d|jD}|d |jjd|d }d j |g|zScc} w) Nr~r z,)z = rrc30K|]\}}|d|yw)=NrA)rrrs rDrz3RuleBasedStateMachine._repr_step..s=1A3as=sstate.r ) rrUrrrrrrr"rvrrrJ)rCrrroutput_assignmentextra_assignment_linesnumber_of_resultsnumber_of_last_names last_namesroutput_per_targetnames_per_targetfirst_target_outputother_target_namesother_target_outputargs output_lines rDrz RuleBasedStateMachine._repr_steps!# <<&0&IFMM"q $'t||#47H#H ))*>?J&/2v}}%*BL(M$1TF"(M%(M(- 3D(E(M%]](,GJ@Q,R'S$*.))4DQ4G*H'(;e(C%.>qr.B*.2ii8J.K+.55/%7:MM %*JJz$:U$B!yy= ==*+6$--2H2H1I4&PQR yy+)??@@%)Ns F cF|D]}|D]}|j|}|fd}t|s/|jjj t ||||j |<|jj |gjt|y)Nc$|j|Sr@)text)rQr|cyclers rDprinterz>RuleBasedStateMachine._add_results_to_targets..printers66$<'rG) rrXrsingleton_pprintersridrrrvr)rCrresultsrrrr>s rDrz-RuleBasedStateMachine._add_results_to_targetss OF! O~~f-04( %V,NN66AA"V*gV-3$$T* ''3::<;MN O OrGrrzruntimesc 4jD]}jr |jstfd|jDs<|j j }tjs'|jtjk\s tr |d|dt}|j }|d|xxt|z z cc<|t|d|j jd|dt j" y)Nc3.K|] }|ywr@rA)rprecondrCs rDrz9RuleBasedStateMachine.check_invariants.. sHwt}Hsr,r{zexecute:invariant:z9The return value of an @invariant is always ignored, but rz instead of None)rrcheck_during_initr preconditionsrrJrr verbosityrrr(r r&rLrr)rCrrzrBinvarrrrs` rDrz&RuleBasedStateMachine.check_invariantss __ E,,U5L5LHE4G4GHH>>**D%'00%%8(*vR() NE^^D)F )$0 1\^e5K K 1!!O~~223:fZH&& ,, ! rGcy)z}Called after a run has finished executing to clean up any necessary state. Does nothing by default. NrArBs rDrzRuleBasedStateMachine.teardownrFrGr>cGfddtj}jdz|_jdz|_t d|S)NcVeZdZedeeZfdZde_We_ y)ARuleBasedStateMachine._to_test_case..StateMachineTestCaseNrpc4t|jy)N)r)rr)rCrs rDrEzIRuleBasedStateMachine._to_test_case..StateMachineTestCase.runTest-s)# FrGT) rJrKrLrMrrrrEis_hypothesis_test_hypothesis_state_machine_class)rsrDStateMachineTestCaserM*s,T+EVWH G*.G &69G 3rGrQz .TestCaseztype[_StateMachineTestCase])unittestrrJrLr)rrQs` rDrbz#RuleBasedStateMachine._to_test_case'sL :8#4#4 :), {(B%,/,<,<{,J)13GHHrGrH)$rJrKrLr[rrrrarrNrrrrr rrrrrVrr classmethodrrrrMrobjectfloatrrr]rr rbrArGrDr_r_RsACHT$ *;%<=B <[!! #tN++ ,,'',,S #s(^#BB2>( B#B +S+T#Y+ 1314#71%K%%NAvASA#A#A@O #'sEz"   <  !H Id#:; I IrG) metaclassFceZdZUeed<eed<eed<eed<edZeded<edd Ze d zed <edd Z e d zed <ede Z e eefed<dZde fdZdZy )rrrrrGF)init)Bundle.rN)rXdefault _cached_hash _cached_repr)rXdefault_factoryarguments_strategiescpg}t|jjD]~\}}t|trZ|j |t d|jD}t |j|j||j}||j|<t||_ y)Nc3*K|] ^}}|dk( yw)filterNrA)rrrs rDrz%Rule.__post_init__..Ms&)1DH$&sconsumedraw_referencestransformations) sortedrrrUrYrvr_transformationsrrcr^tupler)rCrrrrds rD __post_init__zRule.__post_init__Cs4>>//12 -DAq!V$q! #&&565G5G&#FFII$3$%$6$6  ,-D % %a (# -$W~ rGrIc d|jtj|Dcgc]F}t||jr.|jdt t||jH}}|j jddj|d|_|jScc}w)Nr+r rr) r\ dataclassesfieldsrrr*rrJr)rCrbitss rDrz Rule.__repr__Ys    $)//54,::,a2743LMNPD $(>>#:#:";1TYYt_L#*>$%>L#*>+0eT+R$sCx.R&, !# ! !rGr self_strategyc,eZdZdZfdZfdZxZS)_BundleSampleraA single draw from the current contents of a Bundle. A Bundle's elements are only known at draw time, so Bundle.do_draw constructs a throwaway instance of this strategy for each draw, passing (position, reference) pairs as the elements. The throwaway instance is also what makes bundle draws thread-safe: Bundle and its Rule-created copies are shared by every instance of the machine class, so per-draw state must live here and never on them. c8t||||||_y)N force_reprre)rrr)rCrelementsrvrers rDrz_BundleSampler.__init__s%  _   rGc|\}}t||jj|j|}|t urt S|||fS)N)r)r _transformrrrr8)rCelementrposition referencerrs rDryz_BundleSampler._transformsY &)# LL ( ( 8t$  ) )' ')V,,rG)rJrKrLr[rryrrs@rDrsrsws  - -rGrsceZdZUdZeed<eed<eed<eddddd dededed d e e ed e e ge fed zfdfdd f dZ edddddedededd e e ed e e ge fed zfdfdd f dZ dddddededed e e ed e e ge fed zfdfdd f fdZ ddde fdZd ddZedd de e ge fdd fdZede e gefddfdZde e ge fddfdZedd de e ge fdd fd Zede e geefddfd!Zede e ge fdd"fd#Zde e ge fddfd$Zd%Zdefd&Zd'e e gefdedfd(Zdddefd)Zdefd*ZxZS)+rYabA collection of values for use in stateful testing. Bundles are a kind of strategy where values can be added by rules, and (like any strategy) used as inputs to future rules. The ``name`` argument they are passed is the they are referred to internally by the state machine; no two bundles may have the same name. It is idiomatic to use the attribute being assigned to as the name of the Bundle:: class MyStateMachine(RuleBasedStateMachine): keys = Bundle("keys") Bundles can contain the same value more than once; this becomes relevant when using :func:`~hypothesis.stateful.consumes` to remove values again. If the ``consume`` argument is set to True, then all values that are drawn from this bundle will be consumed (as above) when requested. Bundles may be used with |.filter| and |.map| like any other strategy, and this composes with :func:`~hypothesis.stateful.consumes` in either order - e.g. ``consumes(b.filter(fn))`` and ``consumes(b).filter(fn)`` are equivalent, and only ever consume the value which was actually drawn. rrcrdFrArcrerCzBundle[VarReference]Tre)ramapN.rIcyr@rArCrrcrdres rDrzBundle.__init__rGrbcyr@rArs rDrzBundle.__init__rrGcZt|||_||_||_||_yr@)rrrrcrdrg)rCrrcrdrers rDrzBundle.__init__s.   . /rGrr<c(|jt}|j|j}|s|j d|jt |t t|ddd|j|j}|j|}|tur$|j d||jtd|\}}}|jr|j||j r td|S|S)NzCannot draw from empty bundle ruz'Aborted test because unable to satisfy locationztuple[int, VarReference, Any]r2)rrqrr mark_invalidrsr enumerate _base_reprrgdo_filtered_drawr8last_rejected_filter_locationrrcpoprd) rCrrrsamplerrr{r|rds rDdo_drawzBundle.do_draws))M* *    >tyymL M !  6" #DbD )( 11   ))$/ ) )   9$B;;=  &**I6%R")U << JJx (,(<(rGz Bundle[Any]c&|jd|S)Nr)_Bundle__with_transformrs rDrz Bundle.map s$$UD11rG conditioncyr@rArCrs rDraz Bundle.filter rrGcyr@rArs rDraz Bundle.filtersNQrGz Bundle[Ex]cyr@rArs rDraz Bundle.filtersFIrGc:|jd|tS)Nrar)rr7rs rDraz Bundle.filters%$$ i*B*D%  rGcF|jrdnd}d|j|dS)Nz, consume=Truer)z Bundle(name=r)rcr)rCrcs rDrzBundle._base_reprs'&*ll"dii]7)155rGcldjd|jD}|j|zS)Nr)c3HK|]\}}}d|dt|dyw).r rN)r*)rrr$rs rDrz"Bundle.__repr__..s4 avQ6q9:! <  ")rrgr)rC transformss rDrzBundle.__repr__s7WW "33   :--rGrecurcy)NFrA)rCrs rD calc_is_emptyzBundle.calc_is_empty$srGcv|jt}t|j|j Sr@)rrqrWrr)rCrrs rDis_currently_emptyzBundle.is_currently_empty(s-))M*tyy1222rGc0td|jfS)NrY)rorrBs rDrpzBundle.__hash__/s Xtyy)**rG)rJrKrLr[rrNrWrrrhrr rr2rrrrOrarrrrrrVrprrs@rDrYrYs 4 I M   $    !   '/*HcUCZ,@#*L Ms R     */     !   '/*HbT3Y,?tK Lc Q     % 00 0  0  '/*HcUCZ,@#*L Ms R 0 0 H,HH>59 %$%,4cUCZ,@% %%>"q)>k>>2#,22%$%193%*1E% %%Q"y|); <QQQ I"s 3I II "s 3  6.#.8SE4K#8WU^3'73D3+#+rGrYrc|t|ts tdt|jd|jS)a When introducing a rule in a RuleBasedStateMachine, this function can be used to mark bundles from which each value used in a step with the given rule should be removed. This function returns a strategy object that can be manipulated and combined like any other. For example, a rule declared with ``@rule(value1=b1, value2=consumes(b2), value3=lists(consumes(b3)))`` will consume a value from Bundle ``b2`` and several values from Bundle ``b3`` to populate ``value2`` and ``value3`` each time it is executed. z)Argument to be consumed must be a bundle.Tr~)rUrY TypeErrorrrg)rs rDconsumesr8s3 ff %CDD &++tV=T=T UUrGc4eZdZUeedfed<deefdZy)r.rrIc,t|jSr@)iterrrBs rD__iter__zMultipleResults.__iter__NsDKK  rGN)rJrKrLrhr2rNrrrArGrDrrJs "c'N!(2,!rGrr8ct|S)aThis function can be used to pass multiple results to the target(s) of a rule. Just use ``return multiple(result1, result2, ...)`` in your rule. It is also possible to use ``return multiple()`` with no arguments in order to end a rule without passing any result. )r)r8s rDrrRs 4  rGc ||rtd|d|dg||d|f}g}|D]}t|ts0d}t|tr|dz }t||t |fzt|trF|j rt d|jdd d d |j}t|trF|j|t|S) z4Single validator and converter for target arguments.zPassing both targets=z and target=z is redundant - pass targets=z instead.zBGot invalid target %r of type %r, but all targets must be Bundles.z It looks like you passed `one_of(a, b)` or `a | b` as a target. You should instead pass `targets=(a, b)` to add the return value of this rule to both the `a` and `b` bundles, or define a rule for each target if it should be added to exactly one.zUsing consumes(z`) doesn't makes sense in this context. This will be an error in a future version of Hypothesis.z 2021-09-08F)since has_codemod stacklevel) rrUrYr3rarcr9rrvrh)rrconverted_targetstmsgs rD_convert_targetsr\s  !'{,vjI,,>g,>v,>+AL ) $!V$VC!]+6"#DG "45 5F#yy %affX.OO& % AF#   #-$. " ##rGhypothesis_stateful_rule#hypothesis_stateful_initialize_rule!hypothesis_stateful_preconditionshypothesis_stateful_invariant.r$c>|jjddS)Nz .r)rLrsplit)r$s rDr"r"s >>  -b 11rG)rrrkwargsc yr@rArrrs rDrr rG)rc yr@rArrrs rDrrrG)rrc yr@rArs rDrr .accept..rule_wrapperd%f% %rG rr r r"rrr!rr,setattrr$ existing_ruleexisting_initialize_rulerGrrrrs` rDacceptzrule..accepts 1& -#!!$%&++   ;5 #*1.Dd#K  $#!!$%&  $ /#!!$%&55   #7< %'    &  &  k40rGrrr6rrrrrrrs ` @rDrrsB2)&9 "1qq!"!F MrGc yr@rArs rD initializer rrGc yr@rArs rDrrrrGc yr@rArs rDrrrrGc xt||jD]\}}t||fd}|S)aDecorator for RuleBasedStateMachine. An initialize decorator behaves like a rule, but all ``@initialize()`` decorated methods will be called before any ``@rule()`` decorated methods, in an arbitrary order. Each ``@initialize()`` method will be called exactly once per run, unless one raises an exception - after which only the ``.teardown()`` method will be run. ``@initialize()`` methods may not have preconditions. rcttdrttdttd}tt d}|ttd|ttdtt d}|rttdt|}tfd}t|t ||S)Nz is used with both @initialize and @invariant, which is not allowed. A function may be either an initialization rule or an invariant, but not both.rzA has been decorated with @initialize twice, which is not allowed.rA has been decorated with both @initialize and @precondition, which is not allowed. An initialization rule runs unconditionally and may not have a precondition.rc|i|Sr@rArs rDrz0initialize..accept..rule_wrapperUrrGrrs` rDrzinitialize..accept4s! 1& -#!!$%&66   ;5 #*1.Dd#K  $#!!$%&55  $ /#!!$%&((  #7< #!!$%&HH  %'    &  &  4d;rGrrs ` @rDrr"sB)&9 "1qq!"&P MrGceZdZUeed<y)rrN)rJrKrLrrNrArGrDrr_s IrGrrEcfd}|S)aDecorator to apply a precondition for rules in a RuleBasedStateMachine. Specifies a precondition for a rule to be considered as a valid step in the state machine, which is more efficient than using :func:`~hypothesis.assume` within the rule. The ``precond`` function will be called with the instance of RuleBasedStateMachine and should return True or False. Usually it will need to look at attributes on that instance. For example:: class MyTestMachine(RuleBasedStateMachine): state = 1 @precondition(lambda self: self.state != 0) @rule(numerator=integers()) def divide_with(self, numerator): self.state = numerator / self.state If multiple preconditions are applied to a single rule, it is only considered a valid step when all of them return True. Preconditions may be applied to invariants as well as rules. c tfd}ttd}|tt dtt d}tt d}|=|Jtj|g|j}t|t ||S|=|Jtj|g|j}t|t ||St|tgttd|S)Nc|i|Sr@rArs rDprecondition_wrapperz=precondition..decorator..precondition_wrapper~rrGr)rGrA) r,rrr r"rr rkreplacerGrr!)r$rrrr&new_rule new_invariantrEs` rD decoratorzprecondition..decorator}sB  &  &$+1.Dd#K # /#!!$%&HH  q+t,A/6  $ $$"**$Bd&8&8$B'$BH (+x @$# "< <'//)L9+B+B)LG)LM (*:M J$# $$@'!126@@  $#rGrA)rErs` rD preconditionrfs."$H rGc8eZdZUeed<eed<eed<defdZy)rrrGrFrIcdt|jd|jd|jg}ddj |dS)Nz function=zself.preconditions=zself.check_during_init=z Invariant(rr)r*rrGrFr)rCpartss rDrzInvariant.__repr__s[7 FG H"t!!# $&t%%' (  DIIe,-Q//rGN)rJrKrLr rNrWrrrArGrDrrsM0#0rGr)rFrFc4ttdfd}|S)apDecorator to apply an invariant for rules in a RuleBasedStateMachine. The decorated function will be run after every rule and can raise an exception to indicate failed invariants. For example:: class MyTestMachine(RuleBasedStateMachine): state = 1 @invariant() def is_nonzero(self): assert self.state != 0 By default, invariants are only checked after all :func:`@initialize() ` rules have been run. Pass ``check_during_init=True`` for invariants which can also be checked during initialization. rFcVttdsttdrtt dtt d}|tt dtt d}t|}tfd}t|t ||S)NzI has been decorated with both @invariant and @rule, which is not allowed.z@ has been decorated with @invariant twice, which is not allowed.rA)rrGrFc|i|Sr@rArs rDinvariant_wrapperz4invariant..accept..invariant_wrapperrrG) rrrr r"r r!rr,r)r$existing_invariantrGrIrrFs` rDrzinvariant..accepts 1k4 (GA7Mt,T#!!$%&// %Q(8$?  )#!!$%&((  #7< '/   &  & !#3U;  rG)r-rW)rFrs` rDr&r&s&t&(;<!4 MrGc eZdZUeed<eded<eeed<ee ed<ee ed<deddffd Z e e d eedeedeeee ffd Zdefd Zd Zdddee eeefffdZde defdZxZS)rrrr rule_namesrules_strategyenabled_rules_strategyrINc2t|||_|jt |\|_}|_tjt|d|f|_ d|_ |j j|j|_y)N)at_least_one_ofz enabled ruleskey)rrr _setup_forrarrrsharedr1r_feature_flagsra_rule_is_enabled_enabled_rules_strategy)rCrrrs rDrzRuleStrategy.__init__s}  6:ood7m6T3 J 3&(ii J 7 '*' #48'+':':'A'A$BWBW'X$rG machine_typec|jjj}|jdt d|D}||t j |fS)Nct|jt|j|jj fSr@)rfrrrrrJ)rs rDz)RuleStrategy._setup_for..s.t||$DNN# &&rGrc3HK|]}|jjywr@)rrJ)rrs rDrz*RuleStrategy._setup_for..sBqqzz22Br)rrrsort frozensetr sampled_from)rrrrs rDrzRuleStrategy._setup_forsa((*00557    BEBB z2??5#9::rGcv|jjd|jjjdS)Nz (machine=z({...})))rrJrrBs rDrzRuleStrategy.__repr__s2..))*)DLL4J4J4S4S3TT^__rGc|jJ|j|xr/|jj|jjSr@)ris_valid is_enabledrrJ)rCr s rDrzRuleStrategy._rule_is_enabledsE""...}}QWD$7$7$B$B1::CVCV$WWrGrr<c jtfdjDs[djjDcgc]}|jjc}}dj d|}t |d|jj_ |jj}i}|jjD]\}} |j|||<||fScc}w#t$r1}|jj} t|d|d|d| d}~wwxYw)Nc3@K|]}j|ywr@)r)rrrCs rDrz'RuleStrategy.do_draw..&s>44==&>srz#No progress can be made from state z<, because no available rule had a True precondition. rules: zwhile generating z from z for rule )anyrrrrJrr rrrrr^r Exceptionr!) rCrrrrrrstratrrnames ` rDrzRuleStrategy.do_draw%s->4::>>II$**M$t}}55MNE5dll5EFBBGJ $C(d 2"ii(C(CDyy556 11779 HAu #yy/ !  i  %N  .. 1!fUIZPUwWX sC3C88 D2,D--D2rc|jD])}|jj|jr)y|jj}|jj j d|jjd}|jD]=}||j}|dt|}||j||r=yy)NFz, rule ,z precondition )rT) rrrrrrrLrrJrGr* update_count)rCrb predicatesdescpred meets_precondwheres rDrzRuleStrategy.is_valid;s A<<&&qvv. \\;; ,,((556gdmm>T>T=UUVW&& D .MfN+J4+P*QRE u  * *] * C   rG)rJrKrLr_rNrr rr5rr0rrSr rarhrrrrr rrWrrrs@rDrrs "" <#"4((*<88Y 5Y$Y"; 56; tF|Ys^^D-AA B;;2`#`X!,!tT#s(^7K1L!,TdrGr)r[rrkrrRcollections.abcrrrrrr functoolsr ior timer typingr r rrrrrrrrrrrhypothesis._settingsrrrrMhypothesis.controlrrhypothesis.corerrhypothesis.errorsrrr hypothesis.internal.compatr!r"%hypothesis.internal.conjecture.enginer#)hypothesis.internal.conjecture.junkdrawerr$$hypothesis.internal.conjecture.utilsr%hypothesis.internal.healthcheckr&!hypothesis.internal.observabilityr'r(hypothesis.internal.reflectionr)r*r+r,hypothesis.internal.validationr-hypothesis.reportingr.r/,hypothesis.strategies._internal.featureflagsr0r1*hypothesis.strategies._internal.strategiesr2r3r4r5r6r7r8hypothesis.utils.deprecationr9hypothesis.vendor.prettyr:r;#hypothesis.internal.conjecture.datar<rr>rOrPrVrNrTrWrXrZr]rarrrrrrr_rrunnerrqrsrYrrrrrrr!r  _RuleType _RuleWrapperr"rrrrrr&rrArGrDr:sCBB(   (MML+ 9=HE=T 6:V::'B' 1 1'  CL&:;W&XsX 0v 0$ 0%% 77*!%+/ Z 78ZoZ Z sDy/D( Z i Z@!%  78o   @ 0t 0 d#$ cI&6cIL e$8!8!%8!v-6BIIK u^C()7-(-@^+^B ^+BVVBZVN2$6V$ d#!hrl!$!!A!/!,!"$J) >:2 S/"-22 3 2267 2c2c2F  fRj !   "   7:bz$4FT"    #? ?? ? x "#Xi%889 ? ?8: $@ fRj !$4 4@ 2J @ @ "(9"5!68K!KLL @H  fRj !   "   7:bz$4FT"    #? ?? ? x "#Xi%889 ? ?8: $: fRj !$4 4: 2J : : "(9"5!68K!KLL :z d#$ ;(C5$;/;HhZ=Q4R;| d# 0 0$ 0,1/D/Xxj(>R5S/dd>drG