iKj UddlZddlmZmZddlmZmZddlmZddl m Z m Z m Z m Z ddlmZmZmZmZddlmZddlmZmZmZmZmZmZmZmZmZdd l m!Z!m"Z"m#Z#dd l$m%Z%dd l&m'Z'm(Z(m)Z)m*Z*e rdd l+m,Z,e-eeddfe.ee/efZ0e e1d <GddeZ2e3Z4e3e5e1d<eddGddZ6dededede7de8f dZ9eddGddZ:eddGddZ;d Zd'e?d(e?dee?ddffd)Z@dededeeddffd*ZAeddGd+d,ZBGd-d.ZCGd/d0e"ZDy)1N) GeneratorSet) dataclassfield)Random) TYPE_CHECKINGFinal TypeAliascast) FlakyReplayFlakyStrategyDefinitionHypothesisExceptionStopTest)floats) BooleanConstraintsBytesConstraintsChoiceConstraintsTChoiceT ChoiceTypeTFloatConstraintsIntegerConstraintsStringConstraintschoice_from_index)ConjectureData DataObserverStatus)InterestingOrigin)count_between_floats float_to_int int_to_floatsign_aware_lte)RepresentationPrinterChildrenCacheValueTc eZdZy)PreviouslyUnseenBehaviourN)__name__ __module__ __qualname__l/home/oem/CyberBrain26-unified/.venv/lib/python3.12/site-packages/hypothesis/internal/conjecture/datatree.pyr%r%4sr*r%EMPTYT)slotsfrozenc0eZdZUdZded<dddeddfd Zy) KilledzRepresents a transition to part of the tree which has been marked as "killed", meaning we want to treat it as not worth exploring, so it will be treated as if it were completely explored for the purposes of exhaustion.TreeNode next_nodepr"cyclereturnNc2|dusJ|jdy)NFr0)textselfr3r4s r+ _repr_pretty_zKilled._repr_pretty_Ds~~ xr*)r&r'r(__doc____annotations__boolr:r)r*r+r0r0;s* 6tr*r0 choice_typevalue constraintsforcedr5c&|rdnd}|d||d|S)Nz [forced] r))r>r?r@rA forced_markers r+ _node_prettyrFIs($*KrM]!E9]O1[M BBr*FcveZdZUdZeed<eed<edZe e dfed<e de fd Z d d d edd fdZy )BranchzSRepresents a transition where multiple choices can be made as to what to drawn.r@r>F)reprr1childrenr5cTt|j|j}|dkDsJ|S)Nr)compute_max_childrenr>r@)r9 max_childrens r+rMzBranch.max_children]s.+D,<,N>NO ar*r3r"r4Nc |dusJt|jjD]\}\}}|dkDr|j|j t |j ||jd|jd5|j|j|dddy#1swYxYw)NFrrA) enumeraterJitemsbreak_r7rFr>r@indentpretty)r9r3r4ir?childs r+r:zBranch._repr_pretty_cs~~!*4==+>+>+@!A A~u1u FFT--ud6F6FuU !       s "B88C )r&r'r(r;rr<rrrJdictrpropertyintrMr=r:r)r*r+rHrHTsb$#*/U*;Hd7J&'; c  6  t    r*rHc@eZdZUdZeed<edzed<dddeddfd Zy) Conclusionz,Represents a transition to a finished state.statusNinteresting_originr3r"r4r5c|dusJ|j}|dn2d|jjd|jd|j}|j d|j |dy)NFrCz, z at :z Conclusion ())r^exc_typer&filenamelinenor7r])r9r3r4oorigins r+r:zConclusion._repr_pretty_wsn~~  # #)B2ajj&9&9%:$qzzl!AHH:!V  dkk_VHA67r*) r&r'r(r;rr<rr=r:r)r*r+r\r\ps06 N)D00868t88r*r\i!MAX_CHILDREN_EFFECTIVELY_INFINITE alphabet_sizemin_sizemax_sizecdk(rydk(r||z dzS|tjz}|tjtkDrtSfd}||||dz z |dzS)Nrc|dzzdz SNrlr))nrhs r+Sz"_count_distinct_strings..SsQ'!++r*)mathlogrg)rhrirjlog_max_sized_childrenrps` r+_count_distinct_stringsrts} ! ("Q&&"*DHH],C!C !DHH-N$O O4 4, hK!HqL/ )ad 22r*cB|dk(rBtt|}|d}|d}| |ddzdz S| |||z dzS|du|duk7sJddzS|dk(r!tt|}|d }|d ks|d k\ryy|d k(r$tt|}t d |d|dS|dk(r6tt |}|d}|d}|d}t t |||S|dk(rtt|}|d}|d} |d} t|| } t|tj|  } t| tj| } | | kDr| S| t| | z} t|drtd| r| dz } t|drtd| r| dz } | Std|)Ninteger min_value max_valuerPrlbooleanr3g;g?bytesrirj)rhrirjstring intervalsfloatsmallest_nonzero_magnitudezunhandled choice_type )r rrrrtrlenrrmaxflt next_downminr!NotImplementedError)r>r@rwrxr3rirjr min_value_f max_value_frcount min_point max_points r+rLrLsi-{;  ,  ,  !2c6A:   Y%:y(1, , T!yD'8999#v  !-{;   ?aN3  +[9 & , ,   ,k: z*z* , &i.8h    +[9 !+. !+. %01M%N"$[+> cmm4N&O%OP  S]]3M%NO y L %i;; +t ,k1R QJE +s +sK0P QJE  6{mD EEr*abc#rKtt|t|dzD]}t|ywrn)rangerr )rrros r+_floats_betweenrs3 <?LOa$7 81os57c#TK|dk7r*tt||D]}t|||ytt|}|d}|d}|d}t |drt d|rdt |drt d|rdt j|rat j|r"t|| }t||Ed{yt| |Ed{t||Ed{yt||}t||Ed{y7P7<7*7 w)Nrrwrxrrr) rrLrr rr!r is_negativerrr)r>r@indexrwrxrrrs r+ all_childrenrs7g/ [IJ EE#E; D D E+[9  ,  , %01M%N" )T *~dI/NJ )S )nS).LI ??9 %y) ,F+FG +9i@@@+,F+F RRR*+EyQQQI'ABI&y)< < <ASQ =sHC D(D D(%D"&D(9D$: D(D&D("D($D(&D(cFeZdZUdZeeZeeed<eeZ ee ed<eeZ ee ed<eddZ eedzed <dZeezezdzed <eddZeed <ed eefd Zded dfdZdddeded dfdZd efdZddded dfdZy)r1u A node, or collection of directly descended nodes, in a DataTree. We store the DataTree as a radix tree (https://en.wikipedia.org/wiki/Radix_tree), which means that nodes that are the only child of their parent are collapsed into their parent to save space. Conceptually, you can unfold a single TreeNode storing n values in its lists into a sequence of n nodes, each a child of the last. In other words, (constraints[i], values[i], choice_types[i]) corresponds to the single node at index i. Note that if a TreeNode represents a choice (i.e. the nodes cannot be compacted via the radix tree definition), then its lists will be empty and it will store a `Branch` representing that choce in its `transition`. Examples -------- Consider sequentially drawing a boolean, then an integer. data.draw_boolean() data.draw_integer(1, 3) If we draw True and then 2, the tree may conceptually look like this. ┌──────┐ │ root │ └──┬───┘ ┌──┴───┐ │ True │ └──┬───┘ ┌──┴───┐ │ 2 │ └──────┘ But since 2 is the only child of True, we will compact these nodes and store them as a single TreeNode. ┌──────┐ │ root │ └──┬───┘ ┌────┴──────┐ │ [True, 2] │ └───────────┘ If we then draw True and then 3, True will have multiple children and we can no longer store this compacted representation. We would call split_at(0) on the [True, 2] node to indicate that we need to add a choice at 0-index node (True). ┌──────┐ │ root │ └──┬───┘ ┌──┴───┐ ┌─┤ True ├─┐ │ └──────┘ │ ┌─┴─┐ ┌─┴─┐ │ 2 │ │ 3 │ └───┘ └───┘ )default_factoryr@values choice_typesNF)defaultinit_TreeNode__forced transition is_exhaustedr5c>|jstS|jSN)rr,r9s r+rAzTreeNode.forceds}}L}}r*rVcd|cxkrt|jksJJ|jt|_|jj |y)z: Note that the draw at node i was forced. rN)rrrsetadd)r9rVs r+ mark_forcedzTreeNode.mark_forcedsKA(DKK(((((( == EDM !r* new_valuerc ||jvr9tjd|j|d|j|d|d|j rJ|j|}t |j|dzd|j|dzd|j|dzd|j}t|j||j|||i|_|jP|jDchc]}||kDs ||z dz c}|_ |jDchc] }||ks | c}|_ |j|j|d=|j|d=|j|d=t|jt|jcxk(rt|jcxk(r|k(sJJycc}wcc}w) z Splits the tree so that it can incorporate a decision at the draw call corresponding to the node at position i. Raises FlakyStrategyDefinition if node i was forced. The z value was forced to z+ in the first run, but the second run drew z. rlN)rr@rr)r@r>rJ) rAr with_detailrrrr1r@rrHrcheck_exhaustedr)r9rVrkeyrWjs r+split_atzTreeNode.split_ats  )55t((+,,A;;q>$%!}C)  $$$$kk!n**1q573((Q1;;q1uw'   !((+))!,5\  == $15HA!a%a!eaiHEN(, ?1QQ?DM    ab ! KKO   QR 4;;3t'7'7#8WC@Q@Qz+TreeNode.check_exhausted..s('(ANN(s) rrrrAr isinstancer\r0rJrMallrs r+rzTreeNode.check_exhausteds$!!+DKK C $44$//J+?@$(!    T__--.$//2N2NN$'(,0OO,D,D,K,K,M(%!   r*r3r"r4c z|dusJd}tt|j|j|jdD]g\}\}}}|j |5|dkDr|j |jt|||||jvddd|dz }i|j |5t|jdkDr|j |j|j|jn|jddddy#1swYxYw#1swYyxYw)NFrTstrictrOrPunknown) rQziprr@rrTrSr7rFrArrrU)r9r3r4rTrVr>r@r?s r+r:zTreeNode._repr_pretty_ s~~4= !!4#3#3T[[ N5  0A0 [%&! q5HHJ #UKT[[@P  aKF XXf  "4;;!# *)y!  " "   " "sAD%:A"D1%D. 1D:)r&r'r(r;rlistr@rr<rrrrrrrZrrHr\r0rr=rYrrArobjectrrr:r)r*r+r1r1Is <@-2$,GK()G!$7FDM7&+D&AL${#A !&d ?Hc#ho?7;J#f,t3:u59L$9 C ST7;%X#%XV%Xt%XN*!*!X"6"t""r*r1c eZdZdZddZedefdZdede e dffdZ d Z d e ddfd Zd Zd ededede fdZd edede defdZd edede dede f dZd edede de ddf dZdddeddfdZy)DataTreeu A DataTree tracks the structured history of draws in some test function, across multiple ConjectureData objects. This information is used by ConjectureRunner to generate novel prefixes of this tree (see generate_novel_prefix). A novel prefix is a sequence of draws which the tree has not seen before, and therefore the ConjectureRunner has not generated as an input to the test function before. DataTree tracks the following: - Drawn choices in the choice sequence - ConjectureData.draw_integer() - ConjectureData.draw_float() - ConjectureData.draw_string() - ConjectureData.draw_boolean() - ConjectureData.draw_bytes() - Test conclusions (with some Status, e.g. Status.VALID) - ConjectureData.conclude_test() A DataTree is — surprise — a *tree*. A node in this tree is either a choice draw with some value, a test conclusion with some Status, or a special `Killed` value, which denotes that further draws may exist beyond this node but should not be considered worth exploring when generating novel prefixes. A node is a leaf iff it is a conclusion or Killed. A branch from node A to node B indicates that we have previously seen some sequence (a, b) of draws, where a and b are the values in nodes A and B. Similar intuition holds for conclusion and Killed nodes. Examples -------- To see how a DataTree gets built through successive sets of draws, consider the following code that calls through to some ConjecutreData object `data`. The first call can be either True or False, and the second call can be any integer in the range [1, 3]. data.draw_boolean() data.draw_integer(1, 3) To start, the corresponding DataTree object is completely empty. ┌──────┐ │ root │ └──────┘ We happen to draw True and then 2 in the above code. The tree tracks this. (2 also connects to a child Conclusion node with Status.VALID since it's the final draw in the code. I'll omit Conclusion nodes in diagrams for brevity.) ┌──────┐ │ root │ └──┬───┘ ┌──┴───┐ │ True │ └──┬───┘ ┌──┴───┐ │ 2 │ └──────┘ This is a very boring tree so far! But now we happen to draw False and then 1. This causes a split in the tree. Remember, DataTree tracks history over all invocations of a function, not just one. The end goal is to know what invocations haven't been tried yet, after all. ┌──────┐ ┌───┤ root ├───┐ │ └──────┘ │ ┌──┴───┐ ┌─┴─────┐ │ True │ │ False │ └──┬───┘ └──┬────┘ ┌─┴─┐ ┌─┴─┐ │ 2 │ │ 1 │ └───┘ └───┘ If we were to ask DataTree for a novel prefix at this point, it might generate any of (True, 1), (True, 3), (False, 2), or (False, 3). Note that the novel prefix stops as soon as it generates a novel node. For instance, if we had generated a novel prefix back when the tree was only root -> True -> 2, we could have gotten any of (True, 1), (True, 3), or (False). But we could *not* have gotten (False, n), because both False and n were novel at that point, and we stop at the first novel node — False. I won't belabor this example. Here's what the tree looks like when fully explored: ┌──────┐ ┌──────┤ root ├──────┐ │ └──────┘ │ ┌──┴───┐ ┌─┴─────┐ ┌──┤ True ├──┐ ┌───┤ False ├──┐ │ └──┬───┘ │ │ └──┬────┘ │ ┌─┴─┐ ┌─┴─┐ ┌─┴─┐ ┌─┴─┐ ┌─┴─┐ ┌─┴─┐ │ 1 │ │ 2 │ │ 3 │ │ 1 │ │ 2 │ │ 3 │ └───┘ └───┘ └───┘ └───┘ └───┘ └───┘ You could imagine much more complicated trees than this arising in practice, and indeed they do. In particular, the tree need not be balanced or 'nice' like the tree above. For instance, b = data.draw_boolean() if b: data.draw_integer(1, 3) results in a tree with the entire right part lopped off, and False leading straight to a conclusion node with Status.VALID. As another example, n = data.draw_integers() assume(n >= 3) data.draw_string() results in a tree with the 0, 1, and 2 nodes leading straight to a conclusion node with Status.INVALID, and the rest branching off into all the possibilities of draw_string. Notes ----- The above examples are slightly simplified and are intended to convey intuition. In practice, there are some implementation details to be aware of. - In draw nodes, we store the constraints used in addition to the value drawn. E.g. the node corresponding to data.draw_float(min_value=1.0, max_value=1.5) would store {"min_value": 1.0, "max_value": 1.5, ...} (default values for other constraints omitted). The constraints parameters have the potential to change both the range of possible outputs of a node, and the probability distribution within that range, so we need to use these when drawing in DataTree as well. We draw values using these constraints when (1) generating a novel value for a node and (2) choosing a random child when traversing the tree. - For space efficiency, rather than tracking the full tree structure, we store DataTree as a radix tree. This is conceptually equivalent (radix trees can always be "unfolded" to the full tree) but it means the internal representation may differ in practice. See TreeNode for more information. r5Nc0t|_i|_yr)r1root_children_cachers r+__init__zDataTree.__init__s&j CEr*c.|jjS)zr Returns True if every node is exhausted, and therefore the tree has been fully explored. )rrrs r+rzDataTree.is_exhausteds yy%%%r*random.c  |jrJg dtdtddf fd }|j} |jrJt t |j |j|jdD]\}\}}}||jvr |||"d} |d kr |j||| } n|j||t|| } | |k7r ||| n$|d z }|j||| t| lt cSt!|j"t$t&frJ|j" t S|j"} t!| t(sJd} |d kr* |j| j*| j| } n2|j| j*| jt| | } | j,| } | js|| j*| | }n|d z }|j| j*| j| t|  |dk7sNt1| j,| j2ks,t5d| j,jDsJ^#t$r |d z }YwxYw#t$r |d z }YHwxYw#t.$r!|| j*| t cYSwxYw)aAGenerate a short random string that (after rewriting) is not a prefix of any choice sequence previously added to the tree. The resulting prefix is essentially arbitrary - it would be nice for it to be uniform at random, but previous attempts to do that have proven too expensive. r>choicer5Ncl|dk(rt|tsJt|}j|y)Nr)rrZr append)r>rprefixs r+ append_choicez5DataTree.generate_novel_prefix..append_choices1g%!&#...%f- MM& !r*Trr rrl)rr)rWric36K|]}|j ywrrrs r+rz1DataTree.generate_novel_prefix..+sP!q~~-Ps)rrrrrQrrr@rrA_drawr_draw_from_cacheid _reject_childtuplerrr\r0rHr>rJKeyErrorrrMany) r9rr current_noderVr>r@r?attempts node_valuebranchrWrs @r+generate_novel_prefixzDataTree.generate_novel_prefixs@$$$$ "{ "G " " yy #00 008A -- ,, '' 9, )44Ke +++!+u5 H#r> )-1ZZ$/V.8." *.)>)> + +$&|$4'- *?*J&.)+zB! A **''", "< 0 +1@!=(Y, )\","9"9J;OP PP&&.V}$!,,Fff- --Hr>!%)ZZ"..0B0B6&0& "&!6!6****vJ% "7"J )"OOJ7E))!&"4"4jA#(LA ""&&&&$6 #$6??+f.A.AAPv7M7M7OPPQEo($,)!)A  ( )R$! A  ! )!&"4"4jA =()s6"J6(J&J;J#"J#&J87J8;'K%$K%ctj|} |j||j|jfS#t $r|dfcYSwxYw)aUse previously seen ConjectureData objects to return a tuple of the rewritten choice sequence and the status we would get from running that with the test function. If the status cannot be predicted from the existing values it will be None.N)r for_choicessimulate_test_functionchoicesr]r%)r9rdatas r+rewritezDataTree.rewrite.sS ))'2 #  ' ' -LL$++. .( #T? " #s(A AArcv|j}dddfd } tt|j|j|j dD]/\}\}}}|||||j vr|nd}||k7s+tt|jtr3|j} j| j| jn|jtt|jtrL||jj|jj} |jj |}nLt|jt$sJj&j)|jj*}{#t"$r } t| d} ~ wwxYw#t,$rYywxYw)zRun a simulated version of the test function recorded by this tree. Note that this does not currently call ``stop_span`` or ``start_span`` as these are not currently recorded in the tree. This will likely change in future.NT)rAconvert_forcedc|dk(r| |r t|}td|}|di|d|i}|dk(r t|}|S)Nrdraw_rAr))r getattrr)r>r@rAr draw_funcr?rs r+drawz-DataTree.simulate_test_function..drawAsXg%&*<%f-k]&;rJrr0observer kill_branchr2r) r9rnoderrVr>r@previousrterrs ` r+rzDataTree.simulate_test_function:s yy59$  ?H))4+;+;T[[QUV@ 8;A; [(##+, +;xA H}77 8dooz:A&&qxx1E1EF__,338T__88$//:U:UVAA#77:&doov>>>MM--/??44D3($A7S@A    s>A!F,:B1F,,FAF, F)F$$F))F,, F87F8ct|Sr)TreeRecordingObserverrs r+ new_observerzDataTree.new_observerjs $T**r*r>r@clddlm}||||}|dk(rt|tsJt |}|S)Nr) draw_choicerr)#hypothesis.internal.conjecture.datarrrr)r9r>r@rrr?s r+rzDataTree._drawms? DKVD ' !eU+ ++ 'E r*rc||jvr*t||}g}t}|||f|j|<|j|Sr)rrr)r9r>r@r generatorrJrejecteds r+_get_children_cachezDataTree._get_children_cachesR d** *$[+>I&(H%(UH)2Hh(GD  %##C((r*c|j|||\}}}t|dkrO|D]J}|dk(rt|tsJt |}||vr*|j |t|dk\sJn|j |S)Nrdr)rrrrrrr) r9r>r@rrrrJrrs r+rzDataTree._draw_from_caches)-(@(@ #)A) % 8X x=3  ')%a///$QA="x=C' }}X&&r*rWc|j|||\}}}|j|||vr|j|yy)Nr)rrremove)r9r>r@rWr _generatorrJrs r+rzDataTree._reject_childsQ*.)A)A #*B* & Hh  U" H  OOE " r*r3r"r4cF|dusJ|j|jy)NF)rUrr8s r+r:zDataTree._repr_pretty_s~~ r*r5N)r&r'r(r;rrYr=rrrrrrrrrrrrr#rrrr:r)r*r+rr"s=M^F&d&&nFnuWc\7Jn` #.>.d.`+ (    .)&)5G)QX) )(' '('  '  ' '<# #(#  #  # #>6tr*rc eZdZdefdZdedededdfdZde dede ddfd Z de dede ddfd Zdedededdfd Zdedededdfd Zd ededededdf dZddZdededzddfdZddZy)rtreec|j|_|j|_d|_|jg|_d|_y)NrF)r_root _current_node_index_in_current_node_trailkilled)r9rs r+rzTreeRecordingObserver.__init__s:YY '+yy+,#'+'9'9&: ! r*r? was_forcedr@r5Nc.|jd|||y)Nrvr r@ draw_valuer9r?r r@s r+ draw_integerz"TreeRecordingObserver.draw_integer  u  r*c.|jd|||y)Nrrrrs r+ draw_floatz TreeRecordingObserver.draw_float :;Wr*c.|jd|||y)Nr~rrrs r+ draw_stringz!TreeRecordingObserver.draw_strings %JKXr*c.|jd|||y)Nr|rrrs r+ draw_bytesz TreeRecordingObserver.draw_bytesrr*c.|jd|||y)Nr{rrrs r+ draw_booleanz"TreeRecordingObserver.draw_booleanrr*r>c|j}|xjdz c_|j}t|tr t |}t |j t |jcxk(rt |jk(sJJ|t |jkr||j|k7s||j |k7r2tj|j||j ||||r'||jvrtjd|d||j|k7r|j|||t |jk(sJt}t|jt sJ||jj"|<||_d|_n|j}||jj%||j j%||jj%||r|j'|t)||dk(r|s|j||t|jt sJ|jj"||_d|_nt|t*r4|j,t.j0k7sJtjdt|t sJ|||j2k7s||j k7r,tj|j2|j || |j"||_d|_|j8d|jur&|j8j%|jyy#t4$r,|j"j7|t|_Y}wxYw)NrlrzK value was forced to a specific value but was not forced on the first run. rrz2The second run drew more data than the first run. )r rrrrrr@rrr from_mismatchrArrr1rrHrJrrrLr\r]rOVERRUNr>r setdefaultr ) r9r>r?r r@rVrnew_nodetranss r+rz TreeRecordingObserver.draw_valuesV  ' ' ##q(#!! eU # 'E4##$DKK(8RC@Q@Q A& a5 1C ,,,,#:!$//6:::2:((/%-"./+OOE}!!((5  '' 4 ""5)$$Q'$)kBaG&MM!uM5%doov>>>)-)A)A%)HD&23D/E:.||v~~555.99I"%07%70%"3"33{eFWFW7W1??))))##  V).)>D&/0+ ;;r?$"4"4 4 KK  t11 2 5 V).)B)B5(*)UD&Vs9N2O  O cT|jryd|_|jt|jjks:|jj 9t |jj tstjd|jj 2tt|j_|j|jj j|_d|_|jj|jy)z5Mark this part of the tree as not worth re-exploring.NT^The second run stopped drawing earlier than the first run, which continued to draw more data. r)r r rrrrrr0r rr1(_TreeRecordingObserver__update_exhaustedr2r rrs r+rz!TreeRecordingObserver.kill_branchhs ;;   & &T-?-?-F-F)G G    ) ) 5t11<D   )  # # %!//::DD&'# 4--.r*r]r^c |tjk(ry|j}|j}|t |j kst |jtrtjdt||}|j|j|k7rt |jtr|jjtjk7s|jtjk7ru|jj}|j}t!d|jjj"d|d|jj"d|||f||_||j$dusJ|j't |j dkDs|j'sJ|j(s|j+yy)zvSays that ``status`` occurred at node ``node``. This updates the node if necessary and checks for consistency.Nr%z9Inconsistent results from replaying a test case! last: z from z this: rr)rr r rrrrrrHr rr\r] INTERESTINGVALIDr^r namer rr r&)r9r]r^rVrnew_transition old_origin new_origins r+rz#TreeRecordingObserver.conclude_tests V^^ #   ' '!! s4;; :doov#F)557  $F,>? ?? &4??n+L$//:6&&&*<*<<!((FLL8!__?? +>> !#55::;6*N-4499:& N , -DOt{{2&&& 4;;!#t';';'==={{  # # %r*c\t|jD]}|jryyr)reversedr r)r9rs r+__update_exhaustedz(TreeRecordingObserver.__update_exhausteds+$++& A $$&  r*r)r&r'r(rrrZr=rrrrrstrrrr|rrrrrrrrrrrrr&r)r*r+rrs?"X"  )- NX X YY)-YNX X   *. =O  d3 d3d3  d3 ( d3 d3L/0*&*&2Cd2J*& *&Xr*r)Erqcollections.abcrr dataclassesrrrrtypingrr r r hypothesis.errorsr r rrhypothesis.internalrr%hypothesis.internal.conjecture.choicerrrrrrrrrrrrrhypothesis.internal.escalationrhypothesis.internal.floatsrrr r!hypothesis.vendor.prettyr"rrrr#r<r% frozensetr,rZr0r=r1rFrHr\rgrtrLrrrr1rrr)r*r+r<s' *(88 .   UT<>!& gtT!"DM3w<?"Y  3 " y~# d#  $ CC C$C  C  C e$  % 6 d# 8 8$ 8L1;!5::%3c%3S%3C%3TW%3PLFLF+=LFLFnu9UD$5F+G (=(=+=(=wd"#(=V e$U"U"%U"puup YLYr*