i#%SSKrSSKJr SSKJrJr SSKJr SSKJ r J r J r J r J r SSKJrJrJrJrJrJrJr SSKJrJrJrJrJrJr SSKJrJrJ r J!r! SS K"J#r#J$r$J%r%J&r&J'r' SS K(J)r)J*r*J+r+ SS K,J-r- \ (a SS K.J/r/ SS K0J1r1 \\\-/\24r3\ \4S'S\\S\5\6\5\6S444Sjr7\"SSS9"SS55r8"SS\95r:"SS5r;g)N) defaultdict)CallableSequence) dataclass) TYPE_CHECKINGAnyLiteral TypeAliascast) ChoiceNodeChoiceT choice_equalchoice_from_index choice_keychoice_permittedchoice_to_index)ConjectureDataConjectureResultSpansStatus_Overrun draw_choice)endswith find_integer replace_all startswith)BytesFloatIntegerOrderingString) ChoiceTreeprefix_selection_orderrandom_selection_order)MAX_PRECISE_INTEGER)Random)ConjectureRunnerShrinkPredicateTnodesreturn.c<[U5[SU554$)a5Returns a sort key such that "simpler" choice sequences are smaller than "more complicated" ones. We define sort_key so that x is simpler than y if x is shorter than y or if they have the same length and map(choice_to_index, x) < map(choice_to_index, y). The reason for using this ordering is: 1. If x is shorter than y then that means we had to make fewer decisions in constructing the test case when we ran x than we did when we ran y. 2. If x is the same length as y then replacing a choice with a lower index choice corresponds to replacing it with a simpler/smaller choice. 3. Because choices drawn early in generation potentially get used in more places they potentially have a more significant impact on the final result, so it makes sense to prioritise reducing earlier choices over later ones. c3b# UH%n[URUR5v M' g7fN)rvalue constraints.0nodes f/var/www/html/ai-image-ml/venv/lib/python3.13/site-packages/hypothesis/internal/conjecture/shrinker.py sort_key..Xs$ Nodjj$*:*:;;s-/)lentuple)r)s r3sort_keyr8Ds#& E  N NN TF)slotsfrozenc\rSrSr%\\S'Sr\S-\S'Sr\\S'Sr \ \S'Sr \ \S 'Sr \ \S 'Sr \ \S 'S rS rSrg) ShrinkPass\functionNname last_prefixrcalls misalignedshrinks deletionscVURcURRUlggr-)r@r?__name__selfs r3 __post_init__ShrinkPass.__post_init__hs" 99  ..DI r9c,[UR5$r-)hashr@rIs r3__hash__ShrinkPass.__hash__lsDIIr9r@)rH __module__ __qualname____firstlineno__r__annotations__r@strrBrCintrDrErFrKrO__static_attributes__rAr9r3r=r=\sRMD#*KE3NJGSIs/r9r=c\rSrSrSrg) StopShrinkingprAN)rHrRrSrTrXrAr9r3rZrZpsr9rZc \rSrSrSrSrSS.SSS\\-S \S -S \ \\-\/\ 4S -S \ S \ 4 Sjjr \S5r Sr \S\4Sj5r\S\4Sj5rSFSjrS\\S\\ \\-S -44SjrS\\S\ 4SjrSrS\SS 4Sjr\SGSj5rSFSjrSFSjrSFSjrSr \S 5r!S!r"S"r#\S\$\%\&44S#j5r'SS$.S%\(S&\ S\ 4S'jjr)S(\*\(SS 4S)jr+\S\\S*44S+j5r,\S\\-S*44S,j5r.\S\/4S-j5r0\S.5r1\S/5r2S0r3S1r4S2r5S3r6\S\7\4S4j5r8S5r9S6r:S7r;\S85rS<r?S=r@S>rAS?rBS@rCSArDSBrESCrFSHSDjrGSErHg )IShrinkertaA shrinker is a child object of a ConjectureRunner which is designed to manage the associated state of a particular shrink problem. That is, we have some initial ConjectureData object and some property of interest that it satisfies, and we want to find a ConjectureData object with a shortlex (see sort_key above) smaller choice sequence that exhibits the same property. Currently the only property of interest we use is that the status is INTERESTING and the interesting_origin takes on some fixed value, but we may potentially be interested in other use cases later. However we assume that data with a status < VALID never satisfies the predicate. The shrinker keeps track of a value shrink_target which represents the current best known ConjectureData object satisfying the predicate. It refines this value by repeatedly running *shrink passes*, which are methods that perform a series of transformations to the current shrink_target and evaluate the underlying test function to find new ConjectureData objects. If any of these satisfy the predicate, the shrink_target is updated automatically. Shrinking runs until no shrink pass can improve the shrink_target, at which point it stops. It may also be terminated if the underlying engine throws RunIsComplete, but that is handled by the calling code rather than the Shrinker. ======================= Designing Shrink Passes ======================= Generally a shrink pass is just any function that calls cached_test_function and/or consider_new_nodes a number of times, but there are a couple of useful things to bear in mind. A shrink pass *makes progress* if running it changes self.shrink_target (i.e. it tries a shortlex smaller ConjectureData object satisfying the predicate). The desired end state of shrinking is to find a value such that no shrink pass can make progress, i.e. that we are at a local minimum for each shrink pass. In aid of this goal, the main invariant that a shrink pass much satisfy is that whether it makes progress must be deterministic. It is fine (encouraged even) for the specific progress it makes to be non-deterministic, but if you run a shrink pass, it makes no progress, and then you immediately run it again, it should never succeed on the second time. This allows us to stop as soon as we have run each shrink pass and seen no progress on any of them. This means that e.g. it's fine to try each of N deletions or replacements in a random order, but it's not OK to try N random deletions (unless you have already shrunk at least once, though we don't currently take advantage of this loophole). Shrink passes need to be written so as to be robust against change in the underlying shrink target. It is generally safe to assume that the shrink target does not change prior to the point of first modification - e.g. if you change no bytes at index ``i``, all spans whose start is ``<= i`` still exist, as do all blocks, and the data object is still of length ``>= i + 1``. This can only be violated by bad user code which relies on an external source of non-determinism. When the underlying shrink_target changes, shrink passes should not run substantially more test_function calls on success than they do on failure. Say, no more than a constant factor more. In particular shrink passes should not iterate to a fixed point. This means that shrink passes are often written with loops that are carefully designed to do the right thing in the case that no shrinks occurred and try to adapt to any changes to do a reasonable job. e.g. say we wanted to write a shrink pass that tried deleting each individual choice (this isn't an especially good pass, but it leads to a simple illustrative example), we might do it by iterating over the choice sequence like so: .. code-block:: python i = 0 while i < len(self.shrink_target.nodes): if not self.consider_new_nodes( self.shrink_target.nodes[:i] + self.shrink_target.nodes[i + 1 :] ): i += 1 The reason for writing the loop this way is that i is always a valid index into the current choice sequence, even if the current sequence changes as a result of our actions. When the choice sequence changes, we leave the index where it is rather than restarting from the beginning, and carry on. This means that the number of steps we run in this case is always bounded above by the number of steps we would run if nothing works. Another thing to bear in mind about shrink pass design is that they should prioritise *progress*. If you have N operations that you need to run, you should try to order them in such a way as to avoid stalling, where you have long periods of test function invocations where no shrinks happen. This is bad because whenever we shrink we reduce the amount of work the shrinker has to do in future, and often speed up the test function, so we ideally wanted those shrinks to happen much earlier in the process. Sometimes stalls are inevitable of course - e.g. if the pass makes no progress, then the entire thing is just one long stall, but it's helpful to design it so that stalls are less likely in typical behaviour. The two easiest ways to do this are: * Just run the N steps in random order. As long as a reasonably large proportion of the operations succeed, this guarantees the expected stall length is quite short. The book keeping for making sure this does the right thing when it succeeds can be quite annoying. * When you have any sort of nested loop, loop in such a way that both loop variables change each time. This prevents stalls which occur when one particular value for the outer loop is impossible to make progress on, rendering the entire inner loop into a stall. However, although progress is good, too much progress can be a bad sign! If you're *only* seeing successful reductions, that's probably a sign that you are making changes that are too timid. Two useful things to offset this: * It's worth writing shrink passes which are *adaptive*, in the sense that when operations seem to be working really well we try to bundle multiple of them together. This can often be used to turn what would be O(m) successful calls into O(log(m)). * It's often worth trying one or two special minimal values before trying anything more fine grained (e.g. replacing the whole thing with zero). cH^U4SjnTRUl[U5$)aIt's useful during shrinking to have access to derived values of the current shrink target. This decorator allows you to define these as cached properties. They are calculated once, then cached until the shrink target changes, then recalculated the next time they are used.c>URTR$![a/ URRTRT"U55s$f=fr-)_Shrinker__derived_valuesrHKeyError setdefault)rJfns r3accept&Shrinker.derived_value..acceptsP O,,R[[99 O,,77 RXNN Os6AA)rHproperty)rdres` r3 derived_valueShrinker.derived_values! O ++r9F)in_target_phaseenginer'initial predicateNallow_transitionexplainrjcUcUceXlU=(d SUlU=(d SUl0Ul[ UR 5UlX lUR5 SUl SUl URRUl URRUlURUl[!UR"5UR%S5UR%S5UR%S5UR%S 5UR%S 5[!UR&5[!UR(5[!UR*5[!UR,5[!UR.5[!UR05[!UR25/ UlU(aS OSUlXPlg) a4Create a shrinker for a particular engine, with a given starting point and predicate. When shrink() is called it will attempt to find an example for which predicate is True and which is strictly smaller than initial. Note that initial is a ConjectureData object, and predicate takes ConjectureData objects. NcgNTrA)datas r3#Shrinker.__init__.."sdr9cgrrrA)source destinations r3rtru#sSWr9rXXXXXXXXXXXXXXXfull)rk_Shrinker__predicate_Shrinker__allow_transitionrar6choices initial_size shrink_targetclear_change_trackingrE max_stall call_count initial_callsmisaligned_countinitial_misalignedcalls_at_last_shrinkr=try_trivial_spans node_programpass_to_descendant reorder_spansminimize_duplicated_choicesminimize_individual_choicesredistribute_numeric_pairslower_integers_togetherlower_duplicated_characters shrink_passes_Shrinker__extendshould_explain)rJrkrlrmrnrorjs r3__init__Shrinker.__init__ s|($(8(DDD $;):"2"X7W&(0% ""$ ![[33"&++">">$($6$6! t-- .   g &   g &   g &   g &   g & t.. / t)) * t77 8 t77 8 t66 7 t33 4 t77 80 $:Iva %r9c0$r-rArIs r3cached_calculationsShrinker.cached_calculationsKs r9c^^UU4SjnU$)Nc>UR/TQ7nTRU$![a# TRRX"55s$f=fr-)rHrrbrc)f cache_keykeysrJs r3reShrinker.cached..acceptPsW+d+I K// :: K//::9acJJ Ks"*AArA)rJrres`` r3cachedShrinker.cachedOs K r9r*c.URR$)zOReturn the number of calls that have been made to the underlying test function.)rkrrIs r3rCShrinker.callsYs{{%%%r9c.URR$r-)rkrrIs r3rDShrinker.misaligned_s{{+++r9c^URUR- UR:a[egr-)rCrrrZrIs r3 check_callsShrinker.check_callscs) ::11 1T^^ C  Dr9r)cUS[UR5n[XR5(ag[UR5[U5:ag[ SU55(agUR R UVs/sHo"RPM snURS9nURnURU5 UR5 X@RLU4$s snf)N)TN)FNc3l# UH*n[URUR5(+v M, g7fr-)rr.r/r0s r3r40Shrinker.cached_test_function..ts(Ted#DJJ0@0@AAAes24extend) r6r)rr8anyrkcached_test_functionr.rrincorporate_test_datar)rJr)nresultpreviouss r3rShrinker.cached_test_functiongs'DJJ( eZZ ( ( DJJ (5/ 1  TeT T T 11# $eWWe $T]]2 %% ""6*  2 22F;; %sC)c*URU5S$Nr)r)rJr)s r3consider_new_nodesShrinker.consider_new_nodess((/22r9c`UR[R:dXRLagUR U5(ak[ UR 5[ URR 5:a4URURU5(aURU5 gggg)zzTakes a ConjectureData or Overrun object updates the current shrink_target if this data represents an improvement over it.N) statusrVALIDrrr8r)rupdate_shrink_target)rJrss r3rShrinker.incorporate_test_datas ;; %1C1C)C    T " "$x0B0B0H0H'II''(:(:DAA  % %d +BJ #r9msgc:URRU5 gr-)rkdebug)rJrs r3rShrinker.debugs #r9c.URR$r-)rkrandomrIs r3rShrinker.randoms{{!!!r9cnUR5 UR5 URR (GaSnUR [URR5- nURRUR- nURRUR- nURSUSU"U5SURSUSUSUR S 3 5 S GH nURS 5 U(aURS 5 OURS 5 URS 5 [!UR"SS9HnUR$S:XaMURS:gU:waM*URSUR&SUR$SU"UR$5SURSUR(SUR*SU"UR*5S 35 M GM URS 5 UR-5 g![a SUlGNf=f!URR (GaSnUR [URR5- nURRUR- nURRUR- nURSUSU"U5SURSUSUSUR S 3 5 S GH nURS 5 U(aURS 5 OURS 5 URS 5 [!UR"SS9HnUR$S:XaMURS:gU:waM*URSUR&SUR$SU"UR$5SURSUR(SUR*SU"UR*5S 35 M GM URS 5 ff=f)zRun the full set of shrinks and update shrink_target. This method is "mostly idempotent" - calling it twice is unlikely to have any effect, though it has a non-zero probability of doing so. FcUS:waS$S$)NsrArs r3rShrinker.shrink..ss"#q&30b0r9z]--------------------- Shrink pass profiling --------------------- Shrinking made a total of z callz of which z shrank and z were misaligned. This deleted z choices out of .)TFrzUseful passes:zUseless passes:cJUR*URUR4$r-)rCrFrE)ts r3rt!Shrinker.shrink..sxaii&Hr9keyrz * z made z were misaligned, deleting z choiceN)initial_coarse_reduction greedy_shrinkrZrrkreport_debug_inforr6rrrrrrrrEsortedrrCr@rDrFro)rJr total_deletedrCrDusefulpass_s r3shrinkShrinker.shrinks.   ) ) +    {{,,,1!% 1 1C8J8J8R8R4S S  ..1C1CC![[99DO>O=PPQ S,FJJrN #34 #45JJrN!'**H"!;;!+$!MMQ.69$ "5::,fU[[Mq~FVV`$}}o\%:J:J9KL((-'8%//@R?SSTV",* 2 Y (#(D  ( {{,,,1!% 1 1C8J8J8R8R4S S  ..1C1CC![[99DO>O=PPQ S,FJJrN #34 #45JJrN!'**H"!;;!+$!MMQ.69$ "5::,fU[[Mq~FVV`$}}o\%:J:J9KL((-'8%//@R?SSTV",* 2M-s$ H&&H;7H>:H;;H>>G6P4c  ^^^^TR(aTRR(dgSS-TlTRnTRmTR n[ [5nTRRTRS[TRR5SS9n[TRRSS9GHumm[UUU4SjU55(aM%[UU4SjTRR55(aMVSnS n[S 5GH&nUS - US -:a Mx/n[TT5Hln TU n U R(d8[!U R"U R$TR&S 9n U R)U S9n UR+U R,5 Mn UST[/U5-UTS-n TRR1U SS9n U R2[4R6LaM[9[:U 5n [=U 5[=U R 5:Xa[?U RTTS5(Gd7[AURBU RBSS9HupURDURD:XdeURDT::deURFURF:XdeURDT:XdMaURHT:XdMsURHn O [KS5eUSTU R TU-UTS-n UTT4R+U R TU5 TRR1U 5n U R2[4R6LaGMX[9[:U 5n O#UTT4R+U R TT5 UTRLa'TRRRM5 gU R2[4RNLa GMHTRQU 5(dGMUS- nUS:dGM UTRRTT4' GM GM [=TRR5S::agSn[U4SjURS555n[S 5GHn/nSnUHeuummnUTs=::a T:dS5e S5eURUUUT5 URUTR&RWU55 TnMg TRR1U5n UTRLdeU R2[4RN:XaSTRRS' gTRQU 5(dMUS- nUS:dMSTRRS' g g)Ndr)prefixcUSUS- *U4$NrrrAxs r3rt"Shrinker.explain..sAaD1Q4K.!9Lr9rc3n># UH*n[UTST5=(a [UTTS5v M, g7fr-)rr)r1seenendr)starts r3r4#Shrinker.explain..s:,D4v/OHT5;4OO,s25c3\># UH!upX4S:wdMUT:*=(a TU:*v M# g7f)rrNrA)r1rerrs r3r4rs6=DA6V#(U 'sax'=s ,,zor any other generated valuei )r with_valuerrFstrictzExpected matching prefixesrc3f># UH&upUTRR;dM!X4v M( g7fr-)rslice_comments)r1kvrJs r3r4rHs-' -tqd6H6H6W6W1WFQF~s 1 1z#these chunks must be nonoverlappingzDThe test sometimes passed when commented parts were varied together.rzAThe test always failed when commented parts were varied together.),rr arg_slicesrr)rrlistrkpassing_choice_sequencesminrrrrange was_forcedrtyper/rcopyappendr.r7rrrOVERRUNr rr6rzipspansrlabelrNotImplementedErrorclearrritemsrchoice)rJrrchunksseen_passing_seqn_same_failuresnote n_attempt replacementir2r.attemptrspan1span2 result_endn_same_failures_togetherchunks_by_start_index_ new_choicesprev_endlsrr)rs` @@@r3roShrinker.explainsO""$*<*<*G*G C**  ,,CNtCT  ;;??::ED$6$6$A$A B1 EF@ !    ) )/L JE3 ,  ..==  O1D"3Z r>Oa$77! uc*A 8D?? + IIt'7'7 ! $yyEy:&&tzz2+"&5/E+,>>N99'&9Q==FNN2.7LC$77 uST{;;),%++V\\%)  %{{ekk999${{e333${{ekk999 ;;%/EII4D).J!)22NOO  ..z:;!#$-( E3<(//uZ0PQ![[==gFF}}6 !"2F;FE3<(//uS0IJ (:(::&&55;;===FLL0##F++#q(O&#-JN**995#,GI(5 D t!!00 1Q 6 #$ &' %||~' ! sA)+KH$9 b5.3.U0UU.U0UU.""78E#:;""4;;#5#5b#9: %: [[55kBF!D$6$66 66}} ,Z""11&9''(A-(+s2[&&55f=3r9c:URUR5 g)a Run a full set of greedy shrinks (that is, ones that will only ever move to a better target) and update shrink_target appropriately. This method iterates to a fixed point and so is idempontent - calling it twice will have exactly the same effect as calling it once. N)fixate_shrink_passesrrIs r3rShrinker.greedy_shrinkfs !!$"4"45r9c$UR5 g)aPerforms some preliminary reductions that should not be repeated as part of the main shrink passes. The main reason why these can't be included as part of shrink passes is that they have much more ability to make the test case "worse". e.g. they might rerandomise part of it, significantly increasing the value of individual nodes, which works in direct opposition to the lexical shrinking and will frequently undo its work. N)reduce_each_alternativerIs r3r!Shrinker.initial_coarse_reductionos $$&r9c6URRVs/sHn/PM nn[UR5H=up4UR[ U5:dM X$RR U5 M? [[[U55$s snfr-) rr) enumeraterrr6rr7map)rJrrrexs r3spans_starting_atShrinker.spans_starting_at|sw"006676"67tzz*EAxx#f+%xx ''*+S'(( 8s Bc SnU[URR5:GaURRnX!nURS:XGaUR(GdUR S::GanUR SS:XGaZ[UR [5(deURUSUX!RSS94-X!S-S-5SnX@RLaUbUR[R:a[UR5[U5:gnU(du[US-[U55HYnURUnX&nURUR:wd'[UR UR 5(aMWSn O U(a4[UR 5Hn UR!X5(dM O US- nU[URR5:aGMgg) a}This is a pass that is designed to rerandomise use of the one_of strategy or things that look like it, in order to try to move from later strategies to earlier ones in the branch order. It does this by trying to systematically lower each value it finds that looks like it might be the branch decision for one_of, and then attempts to repair any changes in shape that this causes. rintegerr min_valueNrrT)r6rr)rrr.r/ isinstancerWrrrrrrrtry_lower_node_as_alternative) rJrr)r2 zero_attempt changed_shapej zero_node orig_noders r3r  Shrinker.reduce_each_alternatives #d((..//&&,,E8D Y&JJ"$$$[1Q6!$**c2222 $88"1I!!< >>1uwO   !(:(::$0$++v||;$' (:(:$;s5z$IM(!&q1uc%j!9A(4(:(:1(=I(-I )).. @'7$-OOY5J5J("("15 %":%!&tzz!2A#AA!GG %"3 FA_#d((..///r9c URRnURUSUX1RUS94-X1S-S-5(agUSUX1RUS94-nURnURUn[ S5HnUR RUVs/sHoRPM sn[U5S9n U R[R:aM`URU 5 UH{n URU n U RU n U RU RU R n URUSUU -X;R S-5 XPRLdMz g M gs snf)zAttempt to lower `self.shrink_target.nodes[i]` to `v`, while rerandomising and attempting to repair any subsequent changes to the shape of the test case that this causes.NrrTrF)rr)rrr&rrkrr.r6rrrrrrr)rJrrr)rrlrrrrandom_attemptr/ initial_span attempt_spancontentss r3r,&Shrinker.try_lower_node_as_alternatives""((  " " "1I!46 61uw G  rehmmqm9;;$$&&q)qA![[=="()&Q&)#e*>N$$v||3  & &~ 6&}}Q/ -33A6 )// 0B0B\EUEUV''"1I(51A1A1C+DD"4"44 *s&F c [[5$r-)rr"rIs r3shrink_pass_choice_trees!Shrinker.shrink_pass_choice_treess :&&r9 random_order shrink_passr>c^URTnUR(agURnURnURn[ UR R5nTRceURRTR5 U(a[UR5nO[TR5nURUU4Sj5TlT=RURU- - slT=RURU- - slT=RURU- - slT=R U[ UR R5- - slURR#5 g!T=RURU- - slT=RURU- - slT=RURU- - slT=R U[ UR R5- - slURR#5 f=f)NFc&>TRU5$r-)r?)chooserr?s r3rtShrinker.step..s 4 4W =r9T)r; exhaustedrErCrDr6rrr@rkexplain_next_call_asr$rr#rBsteprFclear_call_explanation) rJr?r>treeinitial_shrinksrrsizeselection_orders ` r3rF Shrinker.steps,,[9 >>,, !__4%%--.+++ (()9)9: 4T[[AO4[5L5LMO 1&*ii='K #   m!; ;   " "doo8J&J J "   4<->)??%'JN%&JNEH KKJ22K 3qgr9.c.URR$r-)rr)rIs r3r)Shrinker.nodesa!!'''r9c.URR$r-)rrrIs r3rShrinker.choiceses!!)))r9c.URR$r-)rrrIs r3rShrinker.spansirbr9c[[5nURH nXRR U5 M" [ U5$)zt A mapping of labels to a list of spans with that label. Spans in the list are ordered by their normal index order. )rrrrrdict)rJspans_by_labelr%s r3riShrinker.spans_by_labelms<%T***B 88 $ + +B /N##r9c2[UR[S9$)Nr)rrirVrIs r3distinct_labelsShrinker.distinct_labelsysd))s33r9c^^^^URTRU4Sj5nTRUmUR[[ T5S- 55mTTmTS-[ T5:Xd TTS-R TR :agTRUT5UUU4Sj5nURUS5nTR UR ::deTR UR :deURTR:deTRTRSTR TRUR UR -TRTR S-5 g)axAttempt to replace each span with a descendant span. This is designed to deal with strategies that call themselves recursively. For example, suppose we had: binary_tree = st.deferred( lambda: st.one_of( st.integers(), st.tuples(binary_tree, binary_tree))) This pass guarantees that we can replace any binary tree with one of its subtrees - each of those will create an interval that the parent could validly be replaced with, and this pass will try doing that. This is pretty expensive - it takes O(len(intervals)^2) - so we run it late in the process when we've got the number of intervals as far down as possible. c:>[TRU5S:$)Nr)r6ri)lrJs r3rt-Shrinker.pass_to_descendant..sC0C0CA0F,G1,Lr9rNc>TS-n[T5nUS-U:a4X-S-nTURTR:aUnOUnUS-U:aM4TTS-UVs/sH!nURTR:dMUPM# sn$s snfNrr)r6rr choice_count)lohimidspanancestorrrs r3 descendants0Shrinker.pass_to_descendant..descendantssQBUBq&2+w1n:##x||3BB q&2+"!a%"--D$$x'<'<<- s B;Bc URS:$r)rt)r%s r3rtrqs BOOa)>>>>  JJ' (jj))JNN; <jj( ) r9c^^^^^^[TR5S::ag/m[TR5HFnTRUnUR(dUR S:waM5TR U5 MH T(dgTVs/sH(n[URURS- 5PM* snm[T5nUS:de[[T55HnTU==U-ss'M TRmSmUUUUU4Sjm[R"UU4Sj5 [R"UU4S j5 TR5 gs snf) aSometimes we find ourselves in a situation where changes to one part of the choice sequence unlock changes to other parts. Sometimes this is good, but sometimes this can cause us to exhibit exponential slow downs! e.g. suppose we had the following: m = draw(integers(min_value=0)) n = draw(integers(min_value=0)) assert abs(m - n) > 1 If this fails then we'll end up with a loop where on each iteration we reduce each of m and n by 2 - m can't go lower because of n, then n can't go lower because of m. This will take us O(m) iterations to complete, which is exponential in the data size, as we gradually zig zag our way towards zero. This can only happen if we're failing to reduce the size of the choice sequence: The number of iterations that reduce the length of the choice sequence is bounded by that length. So what we do is this: We keep track of which nodes are changing, and then if there's some non-zero common offset to them we try and minimize them all at once by lowering that offset. This may not work, and it definitely won't get us out of all possible exponential slow downs (an example of where it doesn't is where the shape of the nodes changes as a result of this bouncing behaviour), but it fails fast when it doesn't work and gets us out of a really nastily slow case when it does. rNr)shrink_towardsrcvURURS-URURSU-S9/4$)Nrrr)indexrr/)r2rs r3 offset_node6Shrinker.lower_common_node_offset..offset_nodes@  Qd&6&67G&H1&LMN r9c>TR[TR[TTSS9VVs/sHup#T"X!X--5PM snn55$s snnf)NFr)rrr)r) rsignr2rchangedintsrrJsts r3consider3Shrinker.lower_common_node_offset..considers]**HH(+7D'G'GGD$D!%.9'G sAc>T"US5$NrrArrs r3rt3Shrinker.lower_common_node_offset..s !Qr9c>T"US5$)NrPrArs r3rtrs !Rr9)r6_Shrinker__changed_nodesrr)trivialrrabsr.r/rrrrrr) rJrr2offsetrrrrrs ` @@@@@r3lower_common_node_offset!Shrinker.lower_common_node_offsets)B t## $ ) ,,-A::a=D||tyyI5 NN4 .  NU MTTC T--.>?? @W Tzzs4y!A Gv G"      v78v89 ""$A s/EcDURUl[5Ulgr-)r"_Shrinker__last_checked_changed_atset_Shrinker__all_changed_nodesrIs r3rShrinker.clear_change_trackings)-););&#&5 r9c:URRU5 gr-)radd)rJrs r3 mark_changedShrinker.mark_changed s   #r9c URURLa UR$URnURnXLdeURnURn[ UR5[ UR5:de[ U5[ U5:wd[ S[X4SS955(a[5UlUR$[ U5[ U5:Xde[[X4SS95HfunupgURUR:Xde[URUR5(aMKURRU5 Mh UR$)Nc3X# UH upURUR:gv M" g7fr-)r)r1n1n2s r3r4+Shrinker.__changed_nodes..s#4 -T62BGGrww -Ts(*Tr)rrrr)r8r6rrrr#rrr.r)rJ prev_target new_target prev_nodes new_nodesrrrs r3__changed_nodesShrinker.__changed_nodessJ  ) )T-?-? ?++ +44 '' ,,, && $$  (()H[5F5F,GGGG z?c)n ,4 -0t-T4 1 1 (+uD $''' z?c)n4 44(Z4)PQ 8Bww"'')))#BHHbhh77,,003 R '''r9c[U[5(deU=RS- sl[URUR UR - S-5UlUR UlXl0Ulgrs) r+rrErRrrCrrra)rJrs r3rShrinker.update_shrink_target(sk*&67777   NNTZZ$*C*CCqH %)JJ!' "r9c ^[U4SjU55(ag[TRUVs/sH,o3RURS-UR US9/4PM. sn5nTR U5SnUcgUTR LaTR5 gUR[RLagUR[RLagURbURupgpTRUnURU:wagUR(agURS;a~URSUS::agTR!USURXCRR UXCRR"SUSS 9/-XCRS-5$[%TR5[%UR5- n U S ::agUS Rn US RS-n XU -41n TR&GHnUR(U :aMUR*U ::aM(UR[%UR&5:aMMUR&URnUR,Vs/sHnUR(U :dMUPM nnUR,Vs/sHnUR(U :dMUPM nn[%U5[%U5:dU(dMU R/US R(U[%U5*R(45 GM [1U S SS 9H)unnUSUUUS-nTR!U5(dM) g gs snfs snfs snf)a2Attempts to replace each node in the nodes list with n. Returns True if it succeeded (which may include some additional modifications to shrink_target). In current usage it is expected that each of the nodes currently have the same value and choice_type, although this is not essential. Note that n must be < the node at min(nodes) or this is not a valid shrink. This method will attempt to do some small amount of work to delete data that occurs after the end of the nodes. This is useful for cases where there is some size dependency on the value of a node. c3f># UH&oR[TR5:v M( g7fr-)rr6r))r1r2rJs r3r4/Shrinker.try_shrinking_nodes..Hs ?zzS_,s.1NrrFT>bytesstringmin_size)with_constraintsrrrPcUSUS- $rrArs r3rt.Shrinker.try_shrinking_nodes..sAaD1Q4Kr9)rreverse)rrr)rrrrrrrrINVALID misaligned_atrrr/rr.r6rrrchildrenrr)rJr)rr2initial_attemptrrattempt_choice_typeattempt_constraints_attempt_forced lost_nodesrrregions_to_deleter%rc in_original in_replacedurtry_with_deleteds` r3try_shrinking_nodesShrinker.try_shrinking_nodes8sZ ?? ? ? % JJQV WQVjj$**q.4999+B*C DQV W  ++O>V^^ + >>V^^ +  ,4%% ME(;::e$Dyy//yy//##J/3Fz3RR!..#Ldjj1' 388-@'6zz'B'H'H A"5j"A(9&jjl3 4  _s7=='99 ?aBioo! "#345**Bxx%vv}xx3w}}--!--1K&(kkDkQWW^1kKD&1&:&:M&:aggn1&:KM;3{#33;  ! !Q%%{C 4D3D'E'K'KL -4,2GQUVDAq.r2_QR5HH &&'788W s XHEMs3M: M?-M?NNc4URR(a/nURRHnnURS:dMUR(dM(U(aUR USS:dMGUR UR UR45 Mp U(dg[UR5n[U5H upEX4U2 M UR[U55(dgURR(aMg)aTry removing all bytes marked as discarded. This is primarily to deal with data that has been ignored while doing rejection sampling - e.g. as a result of an integer range, or a filtered strategy. Such data will also be handled by the adaptive_example_deletion pass, but that pass is necessarily more conservative and will try deleting each interval individually. The common case is that all data drawn and rejected can just be thrown away immediately in one block, so this pass will be much faster than trying each one individually when it works. returns False if there is discarded data and removing it does not work, otherwise returns True. rrPFT) r has_discardsrrt discardedrrrrr)reversedrr7)rJrr%rrrs r3rQShrinker.remove_discardeds   --I((..OOa' &"((imB6G*G$$bhh%78 / 4::&G +aCL,**5>::/  ---0r9c[[5nURH5nXR[ UR 54R U5 M7 [UR55$)z5Returns a list of nodes grouped (choice_type, value).)rrr)rrr.rvalues)rJ duplicatesr2s r3duplicated_nodesShrinker.duplicated_nodessS!& JJD  :djj#9: ; B B4 HJ%%'((r9programc*^^[UU4SjST3S9$)Nc(>TRUT5$r-) _node_program)rBrrJs r3rt'Shrinker.node_program..sD..w@r9 node_program_rQ)r=)rJrs``r3rShrinker.node_programs @  *  r9cF^^^^^^[T5mUR[[TR5T- S-55mTR TTTR S9(dgUU4SjmT"[ UUU4Sj55mTR m[ UUUU4Sj5 g)Nroriginalc>TUT-- $r-rA)rrrs r3 offset_left+Shrinker._node_program..offset_leftsq1u9 r9cF>TRT"U5TTRS9$)Nr)run_node_programr)rrrrJs r3rt(Shrinker._node_program..s&$//NGd6H6H0r9c(>TRTTTUS9$)N)rrepeats)r)rrrrrJs r3rtrsd++AwST+Ur9)r6r}rr)rrr)rJrBrrrrrs` `@@@@r3rShrinker._node_programs L NN5TZZ1!4q!89 :$$Q$:L:L$M       %% U r9cURUR5nUVs/sHo3R(aMUPM nn[U5S::agUR U5 gs snf)aFind choices that have been duplicated in multiple places and attempt to minimize all of the duplicates simultaneously. This lets us handle cases where two values can't be shrunk independently of each other but can easily be shrunk together. For example if we had something like: ls = data.draw(lists(integers())) y = data.draw(integers()) assert y not in ls Suppose we drew y = 3 and after shrinking we have ls = [3]. If we were to replace both 3s with 0, this would be a valid shrink, but if we were to replace either 3 with 0 on its own the test would start passing. It is also useful for when that duplication is accidental and the value of the choices don't matter very much because it allows us to replace more values at once. rN)r}rrr6minimize_nodes)rJrBr)r2s r3r$Shrinker.minimize_duplicated_choices!sS(t445#(<%$||%< u:?  E" =s A"A"c^^^^^^SmURTRU4Sj5mURTRUU4Sj5mTRmTRmS[S[4UUUUU4Sjjn[ U5 g)zIf there is a sum of generated numbers that we need their sum to exceed some bound, lowering one of them requires raising the other. This pass enables that.cURS;=(a^ URS:H=(aC [R"UR5=(d [ UR5[ :(+$)N>floatr)r)rmathisnanr.rr%r2s r3can_choose_node.can_choose_nodeGsU 99 44 W$WZZ +Us4::BU/U: r9cD>T"U5=(a UR(+$r-r)r2rs r3rt5Shrinker.redistribute_numeric_pairs..Ts.Ct||3CCr9c>T"U5=(aN UR(+=(a6 TRURs=:=(a TRS-:*$s $)N)rr)r2rnode1s r3rtrXsQ.<OO#<  djj;;EKK!O; < < TRS:XaTRSOSnU[TU- 5:agTU:aU*nTU- nTU-nTRS:Xa[U5[:agTR TR STRTRUS94-TR TRS-TR-TRUS94-TR TRS-S-5$![a gf=f)Nr)rrFrrr) rr/r OverflowErrorr%rr)rr) rrv1v2mrrnode2rJs r3boost2Shrinker.redistribute_numeric_pairs..boostds)8=zzY7N!!"23TU 3q>)** >!B UUzzW$R4G)G** =U[[):::,./**U[[1_u{{;<:::,./**U[[1_./ 0 !  s C<< D D N)r}r)r.rWboolr)rJrBrrrrrrs` @@@@@r3r#Shrinker.redistribute_numeric_pairs>su  JJ C  JJ <  " S" T" " H Ur9c ^^^^^URTRS5mTRUR[TRS-[ [ TR5TRS-S-55U4Sj5mTR SmUUU4Sjm[UU4Sj5 [UU4Sj5 g) NcPURS:H=(a UR(+$Nr)rrrs r3rt2Shrinker.lower_integers_together..s!&&I"5"Gaii-"Gr9rr4c>TRURS:H=(a TRUR(+$r)r)rrrrJs r3rtrs6$**Q-,, 91 1 0001r9rcT>TRTRSTRTRTRU- S94-TRTRS-TR-TRTRU- S94-TRTRS-S-5$)Nrr)rr)rrr.)rrrrJs r3r2Shrinker.lower_integers_together..considers** =U[[)::q:9;<**U[[1_u{{;<::q:9;<**U[[1_./ 0 r9c>T"TU- 5$r-rArrrs r3rtrsx(:;r9c>T"UT- 5$r-rAr s r3rtrsxN(:;r9)r}r)rrrr6r/r)rJrBrrrrs` @@@@r3r Shrinker.lower_integers_togethers JJG  NNekkAos3tzz?EKK!Oa.s!&&H"4"FQYY"Fr9rrc>TRURS:H=(a] TRUR(+=(a8 [TR5[TRUR5-$r)r)rrrr.)rrrJs r3rtrsa$**Q-,,8@AAVAV=V@ $s4::a=+>+>'??@r9 intervalsct>URURRTTRU55S9$)Nr)rr.replacechar_in_shrink_order)r2rcharrs r3 copy_node7Shrinker.lower_duplicated_characters..copy_nodes; 99::--dI4R4RST4UV r9c>TRTRSTRT"TU54-TRTRS-TR-T"TU54-TRTRS-S-5$r)rr)r)rrrrrJs r3rtrsd-- =U[[)UA&()**U[[1_u{{;<UA&()**U[[1_./ 0r9N) r}r)rrrr6rr.rr/rrindex_from_char_in_shrink_order)rJrBduplicated_charactersrrrrrs` @@@@@r3r$Shrinker.lower_duplicated_characterss, JJF   NNekkAos3tzz?EKK!Oa# UH1nURT:H=(a [URT5v M3 g7fr-)rrr.)r1r2 choice_typer.s r3r4*Shrinker.minimize_nodes..s4  II $ Hdjj%)H Hs9<r)rc.>TRTTU-5$r-rrr)rJrs r3rt)Shrinker.minimize_nodes..$225.1:LMr9c.>TRTTU- 5$r-r"r#s r3rtr$r%r9rc(>TRTU5$r-r"valr)rJs r3rtr$ D44UC@r9c*>TRTU*5$r-r"r(s r3rtr$ sD44USDAr9booleanTFrc(>TRTU5$r-r"r(s r3rtr$r*r9r)rrc(>TRTU5$r-r"r(s r3rtr$r*r9r)rr) rr.r/allrrrrrrr!r)rJr)r/rrr.s`` @@@r3rShrinker.minimize_nodessAhmm aAh**       ) #()9:N  $ $UC0F,G H NNNU*+M  NNNU*+M G #  $ $UCJ 7 LLE @  LLE A I %D= =  $ $UE 2 G # LL@$Z0  H $ MM@%k2$Z0  & %r9c UR[[UR555nURnURR nURUnUSUR n[XER URVs/sHDnUR(aUO-UR[SURUR5S9PMF sn5nXERSn URXh-U -5Sn URULag[U [ 5(aIU RUn U R U R U Rn UR#Xl-U -5 ggs snf)Nrrr)r}rr6rrr)rr7rrrrrr/rr+rr) rJrBrr^r)rxrr2rsuffixrnew_spannew_replacements r3rShrinker.try_trivial_spans$sU NN5TZZ1 2!!""((zz!}|$"**txx8 9D #4Q 4CSCS#T# 9   xxz"++F,@6,IJ1M   T )  g/ 0 0}}Q'H%mmHNNX\\JO  # #F$.Ws 4<<7Gr9Nr)rrc>Sn[TR5nUS-U:a@X-S-nTRUnURTR:aUnOUnUS-U:aM@U$)Nrrr)r6rrr)rurvrwrxr2rJs r3first_span_after_nodeCShrinker.minimize_individual_choices..first_span_after_nodesfBTZZBq&2+w1nzz#::+BB q&2+Ir9TFc<>TRURS:$r)rrtrs r3rtr8sdjjm881>4- ( (::/TZZA<D  # #GLdjj$9GHHJ3tzz?-STUD  # #GLdjj$9GDJJQRNDTTR[TR[TUSS9VVVs/sH4uupnUUTRTURTUR 4PM6 snnn55$s snnnf)NTr)rrr)rrr)indicesrrr endpointsrJrrs r3rt(Shrinker.reorder_spans..s|D33HH*-Y)M  *NIFQA HHU1X^^eAhllC *N   s;A4ch>[TRTURTUR5$r-)r8r)rr)rrrs r3rtrDs%(288E!HNNU1X\\#JKr9r) r}rrrr6rrrr rr)rJrBrxrrrCrrs` @@@r3rShrinker.reorder_spanss&~~djj)t}}-33 MM>MqWW-=M> u:? 8=>jj$((+>    #e*  L ??sC,*C,!C1cpU[U5-[UR5:dUS:ag[UR5n[U5HVn[ [[ U555H2upxX-n U [U5:a gUS:XaXY M%[ SU<35e MX URU5$)aNode programs are a mini-DSL for node rewriting, defined as a sequence of commands that can be run at some index into the nodes Commands are: * "X", delete this node This method runs the node program in ``program`` at node index ``i`` on the ConjectureData ``original``. If ``repeats > 1`` then it will attempt to approximate the results of running it that many times. Returns True if this successfully changes the underlying shrink target, else False. rFr~zUnrecognised command )r6r)rrrr#rr) rJrrrrrrrcommandr/s r3rShrinker.run_node_programs s7| c(..1 1QUx~~&wA&tIg,>'?@ EG $ c> -0Eg[.QRRA &&w//r9)__all_changed_nodes__allow_transition__derived_values__extend__last_checked_changed_at __predicaterrkrrrrrrrrE)r*N)r*r&)r)IrHrRrSrT__doc__rhrrr(rrrrrrgrWrCrDrrr r7rrrrrVrrrrorrr&r r,rhrr"r;r=rFrrr)r rrrrirlrrrrrrrrrQrrrrrrrrrrrrrXrAr9r3r]r]tsDL 6!&=&"=& "22=&$d* =& n'77H$N ORV V=&=&=&~&s&& ,C,, <j)< t%0477 8<03(<33 ,""6pWr6 '));z>'$sJ*?''EJ Td<\44 +;\4\4|(uZ_-((*w|,**(u(( $ $448 tN%`)$(S((2# N`(T)) C J  B#:JX=@; z;&zGr]s #.!  ;F&(88(C'Dd'JK)KHZ(U3c3h3G-H0 e$%& I ~0~0r9