Ωd UddlZddlmcmZddlZddlZddlZddl Z ddl Z ddl m Z m Z ddlmZmZmZddlmZddlmZddlmZmZddlmZddlmZdd lmZdd lm Z er dd l!m"Z"dd l#m$Z$d Z%de&de'fdZ(dede'fdZ)de*de'fdZ+de,de'fdZ-de'de'fdZ.e(dZ/e(dZ0edZ1de1de1fdZ2ddd e3e1ddfd!Z4d"e*ejjee1zd#e&dee1fd$Z6ed%d&e7e8d'fde3e7e'e'e8ffd(Z9Gd)d*Z:d+Z;Gd,d-Z<Gd.d/Z=ed0xse j|j~Z@e8eAd1<ed2e8d3e'e8zde8fd4ZBd5e8d3e'e8zde8fd6ZCy)7N) OrderedDictabc)CallableIteratorSequence) lru_cache) FunctionType) TYPE_CHECKINGTypeVar)InvalidArgument)int_from_bytes)next_up) _function_key)ChoiceT)ConjectureDatalnamereturnctj|jj}t |ddS)N)hashlibsha384encodedigestr )rhasheds i/home/oem/CyberBrain26-unified/.venv/lib/python3.12/site-packages/hypothesis/internal/conjecture/utils.pycalc_label_from_namer#s0 ^^DKKM * 1 1 3F &!* %%fct|trtt|dSt|tr t |S t|S#t $rt t |cYSwxYw)NT) ignore_name) isinstancer calc_label_from_hashrtypecalc_label_from_cls Exception)rs rcalc_label_from_callabler&(sa!\"#M!$FGG At "1%% 0'* * 0&tAw/ / 0s AA.-A.clsc,t|jSN)r __qualname__)r's rr$r$6s  0 0 11robjc<ttt|Sr))rstrhash)r+s rr"r":s DI //rlabelsc:d}|D]}|dztz}||z}|S)Nr) LABEL_MASK)r/labells rcombine_labelsr5>s4 E !z)   Lrza sample() in Samplerzone more from many()Tvc|Sr))r7s ridentityr:Ms Hrdatarlsctt|dz D]1}|j|t|dz }||||c||<||<3y)aOShuffle ``ls`` in place, drawing from ``data``. Reversed Fisher-Yates shuffle: swap each element with itself or with a later element. This shrinks i==j for each element, i.e. towards no change, so a shuffled sequence shrinks back to its original order. We don't consider the last element as it's always a no-op. r1N)rangelen draw_integer)r;r<ijs rfisher_yates_shufflerCQsU3r7Q; $   aR1 -!ube 1r!u$rvalues strategy_namecdtjvr\t|tjdjr5|jdk7rgt d|jd|j dt|ttjtjfst d|d|dt|tr|St|S) Nnumpyr1zPOnly one-dimensional arrays are supported for sampling, and the given value has z dimensions (shape z). This array would give samples of array slices instead of elements! Use np.ravel(values) to convert to a one-dimensional array, or tuple(values) if you want to sample slices.zCannot sample from z\ because it is not an ordered collection. Hypothesis goes to some length to ensure that the a strategy has stable results between runs. To replay a saved test case, the sampled values must have the same iteration order on every run - ruling out sets, dicts, etc due to hash randomization. Most cases can simply use `sorted(values)`, but mixed types or special values such as math.nan require careful handling - and note that when shrinking a test case, Hypothesis treats earlier values as simpler.)sysmodulesr!ndarrayndimr shaperrrenumEnumMetar>tuple)rDrEs r check_samplerP^s#++*VS[[5I5Q5Q"R ;;! !++1;;-7J<<.!)) cllDMM J K!&,AANP; ;  &%  =r@weights.ct|}t|Dcgc]}|ddg }}t|}t|}|d}|d}g}g} |D cgc]} | |z  } } g} t | D]Q\}} | |z}| j ||dk(r |||d<*|dkr|j |A| j |St j|t j| |r| rt j|}t j| }||k7}|stjd|fd||fdtjvstj|rtj|nddtjvstj|rtj|nddz}d d |iz}ttj |d}| |}||kD}|stjd |fd ||ftj|d tjvstj|rtj|nd dz}dd|iz}ttj |dx}}||d}d}||u}|sltjd|fd||ftj|tj|dz}dd|iz}ttj |dx}x}}|||d<|| |z ||d<| || |z|z | |<| |dkrt j"||n'| |dk(r |||d<nt j"| ||r| r| r||| j%d<| r|r|||j%d<|rg}|D] \}}} t'|t(}|s ddtjvstjt&rtjt&nddtjvstj|rtj|nddtjvstjt(rtjt(ndtj|dz}ttj |d}g}t'|t(}|}|sd}||u}|}|sddtjvstjt&rtjt&nddtjvstj|rtj|nddtjvstjt(rtjt(ndtj|dz}|j ||stjdfd|fdtjvstj|rtj|ndtj|dz} d d!| iz}!|j |!tj*|diz}"d"d#|"iz}#ttj |#dx}x}x}x}}d}| |u}|stjd$|fd%| |fd&tjvstj| rtj| nd&tj|d'z}dd|iz}ttj |dx}}||j ||| f||kr|j |||| z f|j ||| f|j-|Scc}wcc} w)(Nrr1)!=)z%(py0)s != %(py2)slohipy0py2zassert %(py4)spy4)>)z%(py1)s > %(py3)sone)py1py3zassert %(py5)spy5is)z%(py1)s is %(py4)s)r^r[zassert %(py6)spy6z5assert %(py4)s {%(py4)s = %(py0)s(%(py1)s, %(py2)s) }r!baseint)rYr^rZr[z.%(py6)s {%(py6)s = %(py2)s(%(py3)s, %(py4)s) } alternate)rZr_r[rc)z%(py8)s is %(py11)s)py8py11%(py13)spy13zassert %(py16)spy16is not)z%(py0)s is not %(py3)salternate_chance)rYr_)r?r>sumr# enumerateappendheapqheapifyheappop @pytest_ar_call_reprcompare @py_builtinslocals_should_repr_global_name _safereprAssertionError_format_explanationheappushpopr!re_format_boolopsort)$rRnrAtabletotalnum_typezeror]smalllargew probabilitiesscaled_probabilitiesrnscaledrVrW @py_assert1 @py_format3 @py_format5 @py_assert0 @py_assert2 @py_format4 @py_format6 @py_assert3 @py_format7 new_tablerdrf @py_assert5 @py_assert10 @py_assert9 @py_format12 @py_format14 @py_format15 @py_format17s$ rcompute_sampler_tabler~sT G AFKAh,Oat_,OE,O LEE{H A;D 1+CEE(/01QY0M0(*(7 !A%##F+ Q;E!HQK aZ LLO LLO MM% MM% E ]]5 ! ]]5 !RxrRrrRR#B'-'#----'#---'------#---#-------Ry|#t#|t####|t###|###t#######b ! 1"55b !  $';B'? ? $R   #a ' NN5" % !" % *E"IaL NN5" %% E&  $eiik1   $eiik1 /1I-2 B)i)$$$$$$$$$z$$$z$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$>z)S)>)>)$>Y$->>>>>>>z>>>z>>>>>>)>>>)>>>>>>S>>>S>>>)>>>>)>>>Y$>>>>>>Y>>>Y>>>$>>>>>>>>>>>>>>'++t++++t++++++++++++t+++++++     dD*:; <     is5E/EF G   dI/?@ A BNN {-P1s _& _+cjeZdZUdZeeeeefed<ddde ede fdZ dd d d d edzd efdZ y)Samplera(Sampler based on Vose's algorithm for the alias method. See http://www.keithschwarz.com/darts-dice-coins/ for a good explanation. The general idea is that we store a table of triples (base, alternate, p). base. We then pick a triple uniformly at random, and choose its alternate value with probability p and else choose its base value. The triples are chosen so that the resulting mixture has the right distribution. We maintain the following invariants to try to produce good shrinks: 1. The table is in lexicographic (base, alternate) order, so that choosing an earlier value in the list always lowers (or at least leaves unchanged) the value. 2. base[i] < alternate[i], so that shrinking the draw always results in shrinking the chosen element. rT)observerRrcD||_tt||_yr))rrrOr)selfrRrs r__init__zSampler.__init__s *5>: rN)forcedr;rrrcH |jr|jtdntfd|jD}|j |j||j\}}}d}s|k(xr|dkD}g}|k(} | } | s|} | sQt jd| fd|fdtjvst jrt jnddtjvst j|rt j|nddz} d d | iz} |j| | sXd d d tjvst j|rt j|nd iz} |j| t j|diz}dd|iz}tt j|dx} x}} |j!|||j}|jr|j#|rg}d}|u} | } | s|k(}|} | st jd| fd|fdtjvst jrt jndt j|dz}dd|iz}|j|| st jdfd|fdtjvst j|rt j|nddtjvst jrt jnddz}dd|iz}|j|t j|diz}t j$|fdzd|iz}tt j|dx} x}x} x}}|Sg}d}|u} | } | s|k(}|} | st jd| fd|fdtjvst jrt jndt j|dz}dd|iz}|j|| st jdfd|fdtjvst j|rt j|nddtjvst jrt jnddz}dd|iz}|j|t j|diz}t j$|fdzd|iz}tt j|dx} x}x} x}}|S)Nc3NK|]\}}}|k(s |k(r |dkDr|||fyw)rNr9).0rdrfrnrs r z!Sampler.sample..s?7T9&6T>f &9>NQR>Ry"23s"%rrr==)z%(py2)s == %(py4)srrd)rZr[z%(py6)srcz%(py8)srgforced_use_alternater1zassert %(py11)srhraz%(py2)s is %(py5)srZr`%(py7)spy7)z%(py9)s == %(py11)srf)py9rhrirjz >assert %(py16)srk)r start_spanSAMPLE_IN_SAMPLER_LABELnextrchoicerurvrwrxryrzrqrr{r| draw_boolean stop_span_format_assertmsg)rr;r forced_choicerdrfrnrrrrrr @py_format9 @py_format10r use_alternate @py_assert4rr @py_format8rrrs ` rsamplezSampler.samplesI << OO3 4~ ;?:: -1KK JJ LL-8- )i) $  $*Y#6#O;Ka;O 96T> 9%9 9 9 96T 9 9 9 9 9 96 9 9 96 9 9 9 9 9 9T 9 9 9T 9 9 9 9 9 9 9 9 9 9%9 9 9 9%9 9 9 9 9 9 9 9 9 9 9 9 9)) 'LL* << NN   MT M6T> MY&%8 M M M M6T M M M M M M6 M M M6 M M MT M M M M M M MY& M M M M M MY M M MY M M M M M M& M M M& M M M M M M M M M M69:M M M M M M M M  CT C6T> CTV^ C C C C6T C C C C C C6 C C C6 C C CT C C C C C C CTV C C C C C CT C C CT C C C C C CV C C CV C C C C C C C C C Cfd^ C C C C C C CKr) __name__ __module__r*__doc__listrOrefloat__annotations__rboolrrr9rrrrsc" c3o& ''DH;;T;" **d * *rrzIteration over many() is interleaved with other draws. Are you iterating over several many() objects at once, e.g. with zip()?ceZdZdZddddddedeezd eezd edzd ed dfd ZddZde dzde d dfdZ d e dfdZ d e dfdZddedzd dfdZd efdZddZd efdZy)manyaUtility class for collections. Bundles up the logic we use for "should I keep drawing more values?" and handles starting and stopping spans in the right place. Intended usage is something like: with many(data, ...) as elements: for _ in elements: if not add_stuff_to_result(): elements.reject() Leaving the loop early with ``break``, ``return``, or an exception is supported, and keeps both the span tree and the choice sequence well-formed. NTrr;rmin_sizemax_size average_sizerrrc Zd}||k}||k} ||k} |r| r| stjd|| | fd||||ftj|dtjvstj |rtj|nddtjvstj |rtj|nddtjvstj |rtj|nddz} dd | iz} t tj| dx}x}x} } g} d} || u} | }| s||k}||k}|xr|}|stjd | fd || fd tjvstj |rtj|nd tj| d z}dd|iz} | j| | stjdfd|||fdtjvstj |rtj|ndd tjvstj |rtj|nd dtjvstj |rtj|nddz}dd|iz}| j|tj| diz}dd|iz}t tj|dx}x} x} x} x}}||_ ||_ ||_ ||_ t||z ||z |_d|_d|_d|_||_d|_d|_d|_d|_d|_d|_y)Nr)<=rr)z%(py1)s <= %(py5)sz%(py5)s <= %(py6)sz%(py6)s <= %(py7)srrr)r^r`rcrzassert %(py9)srrarrrrr)rr)z%(py9)s <= %(py12)sz%(py12)s <= %(py13)s)rpy12rjz%(py15)spy15r1zassert %(py18)spy18F)rurvrzrwrxryr{r|rqrrrr; forced_size_calc_p_continue p_continuecount rejections force_stopr_depth _iterated_closed_done _in_element _rejected)rr;rrrrrrrrrrrrr @py_assert11rr @py_format16r @py_format19s rrz many.__init__s08qH88H 88 88888qH 888q888888H888H888888 888 8888888888888888??v~?V!??Vx!?????v??????v???v??????????Vx???????????????V???V??????x???x??????????????     !*<(+BHxDWX  "&    rcj|j td|jj|_|S)NzCannot reuse a many() object.)rr r;depthrs r __enter__zmany.__enter__8s, ;; "!"AB Biioo  rexc_type_c d|_|jjry|jj|j k7r|t t y|j|%|jsd|_ |jyyy)NT) rr;frozenr_expected_depthr _INTERLEAVED_MANY_MSG_finish_elementrr_decide)rrrs r__exit__z many.__exit__>sy 99    99??d224 4%&;<<    DJJ#DO LLN %/ rc|j |jr td|jr tdd|_|j S)Nzmmany() must be used as `with many(...) as elements:` followed by `for _ in elements:`, inside the with-block.z,Cannot iterate over a many() more than once.T)rrr r_iteraters r__iter__z many.__iter__MsM ;; $,,!K  >>!"PQ Q}}rc#TK|j} |jr td|j|j k7rtt |j r|j|jsy|xjdz c_ d|_d|_ dw)NTz,Cannot iterate over many() after exiting it.r1F) r;rr rrrrrrrr)rr;s rrz many._iterateXsyy||%&TUUzzT1133%&;<<$$&<<> JJ!OJ#D "DN sB&B(whycr|jr |jr td|xjdzc_|xjdz c_d|_|jt dd|jzkDr=|j|j kr|jj|yd|_ yy)zReject the current element (i.e. don't count it towards our budget of elements because it's not going to go in the final collection).z>reject() can only be called once per element, inside the loop.r1TrTN) rrr rrmaxrr; mark_invalidr)rrs rrejectz many.rejecths4>>!P  a  1 ??SA N3 3zzDMM) &&s+"& 4rc|j}d}||u}|stjd|fd||fdtjvstj |rtj |ndtj |tj |dz}dd|iz}ttj|dx}x}}|j|jxr |jzS)Nrl)z2%(py2)s {%(py2)s = %(py0)s._depth } is not %(py5)sr)rYrZr`zassert %(py7)sr) rrurvrwrxryrzr{r|rr)rrrrrrs rrzmany._expected_depthzs{{&$&{$&&&&{$&&&&&&t&&&t&&&{&&&$&&&&&&&{{d..?4<<@@rc|jr;d|_|jr'|jj|jyyy)NF)discard)rrr;rrrs rrzmany._finish_element~s?   $D || ##DNN#; rc|jrN|j|jkr5|jj d|jd|j|j r|jj t|j|jk(r|j|jk}nd}|jrg}|j}d}||u}|}|s|j}|j} || k(} | }|stjd|fd||fdtjvstj|rtj|ndtj|tj|dz} dd| iz} |j!| |stjd  fd  fdtjvstj|rtj|ndtj|dtjvstj|rtj|ndtj| d z} d d | iz}|j!|tj"|diz}dd|iz}t%tj&|dx}x}x}x}x}x}x} } d}n]|j|jkrd}nA|j|jk\rd}n%|j|j|jk}|jj(dc}|j_|jj+|j,||j }||j_|s-d|_|j r|jj1|S)Nz stopped with z elements, below min_size=ra)z3%(py4)s {%(py4)s = %(py2)s.forced_size } is %(py7)sr)rZr[rz%(py9)srr)zT%(py13)s {%(py13)s = %(py11)s.count } == %(py17)s {%(py17)s = %(py15)s.forced_size })rhrjrpy17z%(py19)spy19r1zassert %(py22)spy22FTrr)rrrr;rrrONE_FROM_MANY_LABELrrrurvrwrxryrzrqrr{r|unique_element_depthrrrr)rshould_continue forced_resultrr @py_assert6rr @py_assert12 @py_assert16 @py_assert14rr @py_format18 @py_format20 @py_format21 @py_format23rs rrz many._decidesz ??tzzDMM9 II " " |+Edmm_U  << II !4 5 ==DMM )#jj4==8O MRt''Q4Q'4/Q4::QAQAQQ:AQ3QQQQQ'4QQQQQQtQQQtQQQ'QQQ4QQQQQQQ:AQQQQQQQ4QQQ4QQQ:QQQQQQQQQQQQAQQQQQQQQQQQQQQQ % dmm+ $ t}}, % !!- $ T-=-= = 59II4R4RTU 1E4991"ii44$ 5O .3DII *DJ|| ##%r)rrr))rN)rrr*rrerrrrr#objectrrrrr-rrrrr9rrrr s ,"+  Ek d  8  & T  (4. (4. '#*''$AA<%%rrcNeZdZdZdedeezddfdZdedfdZdedfd Z y) invert_manyabThe inversion counterpart of ``many``: the boolean choices that ``many`` would draw around each element. Fixed-size collections draw no booleans at all; variable-size ones draw a continuation boolean before each element (forced while below min_size, but forced draws still consume a choice) and a final False to stop (forced at max_size).rrrNc||k7|_yr)_variable_size)rrrs rrzinvert_many.__init__s&(2r)r.c"|jrdSdS)N)Tr9rrs rmorezinvert_many.mores--w525rc"|jrdSdS)N)Fr9rrs rdonezinvert_many.dones..x6B6r) rrr*rrerrrOrrr9rrr r sHA 33e 336eN+67eN+7rr gSMALLEST_POSITIVE_FLOAT desired_avgrcb ||k}|stjd|fd||fdtjvstj|rtj |nddtjvstj|rtj |nddz}tj ||fdzd|iz}ttj|d}||k(ry d d d |zz z }|d k(s|tjk(rd }||k}d }||k} |r| stjd || fd |||ftj |dtjvstj|rtj |ndtj |dz} tj |dzd| iz} ttj| dx}x}x} }|Sd }||k}d }||k} |r| stjd|| fd|||ftj |dtjvstj|rtj |ndtj |dz} tj |dzd| iz} ttj| dx}x}x} }t|||kDr%|dz}|tkrt}nt|||kDr%d } |t||z dkDr:d }||k}|| k} |r| stjd|| fd||| ftj |dtjvstj|rtj |nddtjvstj| rtj | nddz} tj || fdzd| iz}ttj|dx}x}} || zdz }t|||kr|}n|} |t||z dkDr:d }||k}d }||k} |r| stjd|| fd|||ftj |dtjvstj|rtj |ndtj |dz} tj |dzd| iz} ttj| dx}x}x} }t||} | |k}|sdtjd|fd| |fdtjvstjtrtj tnddtjvstj|rtj |nddtjvstj|rtj |ndtj | dtjvstj|rtj |nddz} dd| iz} ttj| dx} }|S) zCReturn the p_continue which will generate the desired average size.)r)z%(py0)s <= %(py2)srrrXz >assert %(py4)sr[N?r1r)r<)z%(py1)s <= %(py4)s%(py4)s < %(py6)sr)r^r[rcz >assert %(py8)srg)rr)%(py1)s < %(py4)srg-C6?g{Gz?)rz%(py4)s < %(py5)srW)r^r[r`z >assert %(py7)srrT)z9%(py4)s {%(py4)s = %(py0)s(%(py1)s, %(py2)s) } <= %(py6)s_p_continue_to_avg)rYr^rZr[rczassert %(py8)s) rurvrwrxryrzrr{r|mathinfrr)rrrrrrrrrrrrrWrrmids rrrs8 ( ";;;;(;;;;;;;;;;;;;;;;;(;;;(;;;;[($;;;;;;;hSA O,,JQ(dhh..qJ"..J"....qJ...q......J...J......J....... )1z )A)zA ))))1zA)))1))))))z)))z)))A)))z))))))) Z 2[ @f / /0J  Z 2[ @ B *:x@ @4 G4q:"4:"4444q:444q444444:444:4444444444444Z$44444444B!# c8 , ;JB *:x@ @4 G )1z )A)zA ))))1zA)))1))))))z)))z)))A)))z))))))) j( 3B 3{ BBBB 3{BBBBBB BBB BBBBBBjBBBjBBBBBB(BBB(BBB 3BBBBBB{BBB{BBBBBBB rrc8|dk\r|Sdd|z z dz d||zz zS)zBReturn the average_size generated by this p_continue and max_size.r1rr9)rrs rrrs1Q 1z> "Q &1z8/C+C DDr)Dbuiltinsrw_pytest.assertion.rewrite assertionrewriterurMrrrrrH collectionsrrcollections.abcrrr functoolsrtypesr typingr r hypothesis.errorsr hypothesis.internal.compatr hypothesis.internal.floatsr"hypothesis.internal.lambda_sourcesr%hypothesis.internal.conjecture.choicer#hypothesis.internal.conjecture.datarr2r-rerr&r#r$r r"r5rrr6r:rrCEnumrPrOrrrrrr  float_infominrrrrr9rrr2s  (88)-5.<=B &s&s& 0 0S 02T2c20f00CC//FG*+AB CL  a  $/ $T!W $ $ Ohqk ):= a[@ 2?5#4?eCeO>T9U??DBBL< __D77"")!C1C1CC #%#3;#5# #LE5EC%KEEEr