iKjCUddlZddlZddlmZddlmZmZmZddlm Z ddl m Z ddl m Z mZmZmZmZddlmZmZmZmZmZmZmZmZmZddlmZmZmZm Z m!Z!m"Z"m#Z#dd l$m%Z%m&Z&m'Z'm(Z(dd l)m*Z*m+Z+m,Z,m-Z-m.Z.dd l/m0Z0m1Z1m2Z2dd l3m4Z4e r dd l5m6Z6ddl7m8Z8eee!zge9fZ:ee;d<deedee ddZ?e ddGddZ@GddeAZBGddZCy) N) defaultdict)CallableIteratorSequence) dataclass) lru_cache) TYPE_CHECKINGAnyLiteral TypeAliascast) ChoiceNodeChoiceT ValueHole choice_equalchoice_from_index choice_keychoice_permittedchoice_to_index choices_key)ConjectureDataConjectureResultSpansStatus_Overrun draw_choiceno_recorded_value)endswith find_integer replace_all startswith)BytesFloatIntegerOrderingString) ChoiceTreeprefix_selection_orderrandom_selection_order)MAX_PRECISE_INTEGER)Random)ConjectureRunnerShrinkPredicateTnodesreturn.c<t|td|DfS)aiReturns 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. c3\K|]$}t|j|j&ywN)rvalue constraints.0nodes l/home/oem/CyberBrain26-unified/.venv/lib/python3.12/site-packages/hypothesis/internal/conjecture/shrinker.py zsort_key..]s! Nodjj$*:*:; Ns*,)lentuple)r.s r8sort_keyr<Is#& E  N NN i)maxsizect}dD]'}|jtj||)|j |j |j fD]}|j||j|j|}tfd|D}|Dcgc] \}}||ks |c}}Scc}}w)uUReturn single-char replacements for ``c`` derived from natural text transformations - case mapping (upper, lower, casefold) and unicode decomposition (NFD, NFKD). We take each individual character of the transformed form so that e.g. ``ß`` can shrink to ``s`` via casefold even though the full case-folded form is two characters. Only candidates which are in ``intervals`` and which have a strictly smaller index in shrink order than ``c`` are returned, sorted by that shrink-order index. Callers must pass a single character that is itself in ``intervals``. )NFKDNFDc3LK|]}|vrj||fywr2)index_from_char_in_shrink_order)r6cand intervalss r8r9z)_natural_simpler_chars..us1  9   2 24 8$?s!$) setupdate unicodedata normalizeupperlowercasefolddiscardrCsorted) crE candidatesform transformed original_idxresultidxrDs ` r8_natural_simpler_charsrVas5J:+//a89: 1779ajjl;' +&'q<D ?? ?s 8 CCTF)slotsfrozenc~eZdZUeed<dZedzed<dZeed<dZe ed<dZ e ed<dZ e ed <dZ e ed <d Z d Zy) ShrinkPassfunctionNname last_prefixrcalls misalignedshrinks deletionscT|j|jj|_yyr2)r\r[__name__selfs r8 __post_init__zShrinkPass.__post_init__s" 99  ..DI r=c,t|jSr2)hashr\res r8__hash__zShrinkPass.__hash__sDIIr=)rd __module__ __qualname__r __annotations__r\strr^r_intr`rarbrgrjr]r=r8rZrZ}sRMD#*KE3NJGSIs/r=rZc eZdZy) StopShrinkingN)rdrkrlr]r=r8rqrqsr=rqc eZdZdZdZdddddeezded zd eeezege fd zd e d e f d Z edZ dZ e defdZe defdZdKdZdeedee eezd zffdZdeede fdZdZdedd fdZe dLdZdKdZdKdZdKdZdededd fd!ZdKd"Z d#Z!ed$Z"d%Z#d&Z$ede%e&e'ffd'Z(dd(d)e)d*e de fd+Z*d,e+e)dd fd-Z,e deed.ffd/Z-e dee.d.ffd0Z/e de0fd1Z1ed2Z2ed3Z3d4Z4d5Z5d6Z6d7Z7e de8efd8Z9d9Z:d:Z;d;ZZ>d?Z?d@Z@dAZAdBZBdCZCdDZDdEZEdFZFdGZGdHZHdIZIdMdJZJy )NShrinkeraA 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). cFfd}j|_t|S)a2It'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 |jjS#t$r/|jjj|cYSwxYwr2)_Shrinker__derived_valuesrdKeyError setdefault)rffns r8acceptz&Shrinker.derived_value..accept$sP O,,R[[99 O,,77 RXNN Os5AA)rdproperty)ryrzs` r8 derived_valuezShrinker.derived_values! O ++r=F)in_target_phaseenginer,initial predicateNallow_transitionexplainr}c||J||_|xsd|_|xsd|_i|_t |j |_||_|jd|_ d|_ |jj|_ |jj|_|j|_t!|j"|j%d|j%d|j%d|j%d |j%d t!|j&t!|j(t!|j*t!|j,t!|j.t!|j0t!|j2t!|j4t!|j6g|_|rd nd|_||_y) aeCreate a shrinker for a particular engine, with a given starting point and predicate. When shrink() is called it will attempt to find a test case for which predicate is True and which is strictly smaller than initial. Note that initial is a ConjectureData object, and predicate takes ConjectureData objects. NcyNTr])datas r8z#Shrinker.__init__..Cr=cyrr])source destinations r8rz#Shrinker.__init__..Drr=rXXXXXXXXXXXXXXXfull)r~_Shrinker__predicate_Shrinker__allow_transitionrvr:choices initial_size shrink_targetclear_change_trackingra max_stall call_count initial_callsmisaligned_countinitial_misalignedcalls_at_last_shrinkrZtry_trivial_spans node_programpass_to_descendant reorder_spansminimize_duplicated_choicesminimize_individual_choicesredistribute_numeric_pairslower_integers_togetherlower_duplicated_charactersnormalize_unicode_chars!widen_to_span_with_recorded_value shrink_passes_Shrinker__extendshould_explain)rfr~rrrrr}s r8__init__zShrinker.__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 8 t33 4 t== >0 (:Iva %r=ciSr2r]res r8cached_calculationszShrinker.cached_calculationsns r=cfd}|S)Nc|jg} j|S#t$r$jj||cYSwxYwr2)rdrrwrx)f cache_keykeysrfs r8rzzShrinker.cached..acceptssW+d+I K// :: K//::9acJJ Ks"*AAr])rfrrzs`` r8cachedzShrinker.cachedrs K r=r/c.|jjS)zWReturn the number of calls that have been made to the underlying test function.)r~rres r8r_zShrinker.calls|s{{%%%r=c.|jjSr2)r~rres r8r`zShrinker.misaligneds{{+++r=c\|j|jz |jk\rtyr2)r_rrrqres r8 check_callszShrinker.check_callss) ::11 1T^^ C  Dr=r.c|dt|j}t||jrytd|Dryt |jt |kry|j j |Dcgc]}|jc}|j}|j}|j||j||ju|fScc}w)N)TNc3^K|]%}t|j|j 'ywr2)rr3r4r5s r8r9z0Shrinker.cached_test_function..s%Td#DJJ0@0@AATs+-)FNextend) r:r.r!anyr<r~cached_test_functionr3rrincorporate_test_datar)rfr.nrTpreviouss r8rzShrinker.cached_test_functions'DJJ( eTZZ ( TeT T  DJJ (5/ 1 11# $QWW $T]]2 %% ""6*  2 22F;; %s>C!c*|j|dSNr)r)rfr.s r8consider_new_nodeszShrinker.consider_new_nodess((/22r=cH|jtjks||jury|j |ret |j t |jj kr/|j|j|r|j|yyyy)zTakes a ConjectureData or Overrun object updates the current shrink_target if this data represents an improvement over it.N) statusrVALIDrrr<r.rupdate_shrink_target)rfrs r8rzShrinker.incorporate_test_datas ;; %1C1C)C    T "$x0B0B0H0H'II''(:(:DA  % %d +BJ #r=msgc:|jj|yr2)r~debug)rfrs r8rzShrinker.debugs #r=c.|jjSr2)r~randomres r8rzShrinker.randoms{{!!!r=c2 |j|j|jj rd}|j t|jjz }|jj|jz }|jj|jz }|jd|d||d|jd|d|d|j d d D]}|jd |r|jd n|jd |jd t!|j"dD]}|j$dk(r|jdk7|k7r&|jd|j&d|j$d||j$d|jd|j(d|j*d||j*d |jd  |j-y#t$r d|_Y wxYw#|jj rd}|j t|jjz }|jj|jz }|jj|jz }|jd|d||d|jd|d|d|j d d D]}|jd |r|jd n|jd |jd t!|j"dD]}|j$dk(r|jdk7|k7r&|jd|j&d|j$d||j$d|jd|j(d|j*d||j*d |jd wwxYw)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. Fc|dk7rdSdS)Nsr]rs r8rzShrinker.shrink..ss"#q&30b0r=z]--------------------- 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:cJ|j |j|jfSr2)r_rbra)ts r8rz!Shrinker.shrink..sxaii&Hr=keyrz * z made z were misaligned, deleting z choiceN)initial_coarse_reduction greedy_shrinkrqrr~report_debug_inforr:rrrrrrrrarNrr_r\r`rbr)rfr total_deletedr_r`usefulpass_s r8shrinkzShrinker.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$ HH,(H/+H,,H//G'Pc|jr|jjsy|jj d5|j dddy#1swYyxYw)Nr)rr arg_spansr~_log_phase_statistics_explainres r8rzShrinker.explainsL""$*<*<*F*F  [[ . .y 9  MMO   s AA"c h ddz_j}jj}jjt t }jjDcic]!}||j|jf#c}jjjdtdjD}tjdD]\}\t!fdt#Dr)t%fd|Dr@t%fd jj&Drkt j)}d }d }t#d t+|zD]} | d z t+|z |dzkDr| t+|krt || } n}g} t#D]l} | } | j,s>t/| j0| j2j4} | j7| } | j9| j:n|dt=| z|dz}jj?|d}|j@tBjDur tGtH|}t+|t+|jk(rtK|jdstM|j|jdD]^\}}|j|jk(sJ|jksJ|jk(sB|jk(sR|j}n tOd|d|j|z|dz}||j9|j|jj?|}|j@tBjDurWtGtH|}n!||j9|j|jur'jj&jQy|j@tBjRur~jU|s|dz }|dk\s|jj&|<t+jj&dkryd }tfd|jD}t#d D]}g}d }|D]b\\}|cxkr ksJdJd|jW|||jWj4jY|}d|jW||djj?|}|jusJ|j@tBjRk(rdjj&d<yjU|s|dz }|dk\sdjj&d<yycc}w)Ndc3&K|] \}}| ywr2r])r6start_s r8r9z$Shrinker._explain.. s#NheQE#Ns)prefixc8|dd|ddz |d|dfSNrrr])kvs r8rz#Shrinker._explain..s."Q%(RU1X2E0F1rRSu/Ur=rc3<K|]}|jywr2) was_forcedr6ir.s r8r9z$Shrinker._explain..sB158&&Bc3^K|]$}t|dxrt|d&ywr2)r!r)r6seenendr.rs r8r9z$Shrinker._explain..s;4v/OHT5;4OOs*-c3nK|],}|(|jkxr|jk.ywr2)rr)r6rOrspansrs r8r9z$Shrinker._explain..%s@=a%'?C58<<,??s25rzor any other generated valuei )r with_valuerrFstrictzExpected matching prefixesrc3bK|]&\}}|jjvr ||f(ywr2)r span_comments)r6kv arg_rangesrfs r8r9z$Shrinker._explain..s:' 1D&&444]A ' ,/z#these chunks must be nonoverlappingzDThe test sometimes passed when commented parts were varied together.zAThe test always failed when commented parts were varied together.)-rrr.rrrlistrrrr~passing_choice_sequencesminvaluesrNitemsallrangerr_explain_candidatesr:rrtyper4rcopyappendr3r;rrrOVERRUNr rrzipNotImplementedErrorclearrrrchoice)rfrrchunks span_indexseen_passing_seqrPn_same_failuresnote n_attempt replacementrr7r3attemptrTspan1span2 result_endn_same_failures_togetherchunks_by_start_indexr new_choicesprev_endlsrrr.rrs` @@@@@r8rzShrinker._explainsC**  ,,""((7B47H#00::  z*00% 2C2G2GH H  ;;??::N#N*:K:K:M#N NO@ )/    $U) j  $J  BeS0ABB,++99  d66ucBCJ O1D"3Z#89F  r>C O3o6IIs:."&z)'<"=K#%K"5#.7$Qx#$/ $ 4+;+;DKK%E$(999#>D#**4::67"&5/E+,>>N99'&9Q==FNN2.7LC$77 uST{;),%++V\\%) P u %{{ekk999${{e333 ;;%/EII4D).J! P22NOO  ..z:;!#$-( :&--fnnU:.NO![[==gFF}}6 !"2F;F:&--fnnU3.GH (:(::&&44::<==FLL0##F+#q(O&#-GK**88DMF Ij \ t!!// 0A 5 #$ &'  ' !  s A)+KH$9  b5.3.U0UU.U0UU.""78E#:;""4;;#5#5b#9:     wxy1 2[[55kBF!D$6$66 66}} ,Z""006'(A-(+s2[&&44T:5 M s2&X/rrzIterator[tuple[ChoiceT, ...]]c # K|j |jj}t fdt ||D}t t fdt ||D}|h}t |jjDchc] }||j||jf"c}}|D]\ } | f||fk(s | z ||z k7rt fdt ||z D|k7r@t fdt ||z D} t | } | |vrq|j| | ycc}ww)aYield deterministic candidate replacements for ``nodes[start:end]``. Random sampling alone misses cases like ``assert n1 == n2``, where the only passing value of ``n1`` is exactly ``n2``'s value. We try substituting values from each other arg slice with matching length and types, which catches such comparisons. Invalid borrowed values just produce an irrelevant test result the outer loop discards. c3<K|]}|jywr2r rs r8r9z/Shrinker._explain_candidates..sFqU1X]]Frc3<K|]}|jywr2r3rs r8r9z/Shrinker._explain_candidates..s'R1a'Rrc3BK|]}|zjywr2r'r6jr.start2s r8r9z/Shrinker._explain_candidates..s IeFQJ',,Ic3BK|]}|zjywr2r)r+s r8r9z/Shrinker._explain_candidates..s QU6A:.44Qr.N) r.rrr;r rrNrrradd)rfrrr target_types current_keyrrrend2borrowedrr.r-s @@r8r zShrinker._explain_candidatess4 ""((FE%4EFF !%'ReS@Q'R"RS &1]595G5G5Q5Q ReAhnneAhll + R ' LFD~%-$-S5[1QIeC%K6HII QeC%K>PQQHh'Cd{ HHSMN  SsBE %E1BEc:|j|jy)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_passesrres r8rzShrinker.greedy_shrinks !!$"4"45r=c$|jy)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_alternativeres r8rz!Shrinker.initial_coarse_reductions $$&r=c,|jjDcgc]}g}}t|jD]<\}}|jt |ks||jj |>ttt|Scc}wr2) rr. enumeraterrr:rr;map)rfrrTrexs r8spans_starting_atzShrinker.spans_starting_ats}"00667"77tzz* +EArxx#f+%rxx ''* +S'(( 8s Bcd}|t|jjkr|jj}||}|jdk(rq|jsd|j dkrT|j ddk(rAt|j tsJ|j|d|||jdfz||dzdzd}||jur||jtjk\rt|jt|k7}|snt|dzt|D]S}|j|}||}|j|jk7s!t|j |j rQd}n|r.t|j D]} |j!|| sn|dz }|t|jjkryy) aThis 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)r:rr.r rr3r4 isinstancerorrrrrr rtry_lower_node_as_alternative) rfrr.r7 zero_attempt changed_shaper, zero_node orig_noders r8r8z Shrinker.reduce_each_alternatives #d((..//&&,,E8D Y&JJ"$$$[1Q6!$**c222 $88"1Iq!!< >>q1uwO   !(:(::$0$++v||;$' (:(:$;s5z$IM(!&q1uc%j!9 &A(4(:(:1(=I(-aI )).. @'7$-OOY5J5J("15 % &%!&tzz!2&A#AA!QG %& FA_#d((..//r=c |jj}|j|d|||j|fz||dzdzry|d|||j|fz}|j}|j|}t dD]}|j j|Dcgc]}|jc}t|} | jtjkr_|j| |D]{} |j| } | j| } | j| j| j } |j|d|| z|| j dz||juszyycc}w)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=r r~rr3r:rrrrrrr)rfrrr.rrrrrrandom_attemptr, initial_span attempt_spancontentss r8rBz&Shrinker.try_lower_node_as_alternative#s""((  " " "1Iq!46 6q1uw G reAhmmqm9;;$$&&q)q A![[=="()Q)#e*>N$$v||3  & &~ 6 &}}Q/ -33A6 )// 0B0B\EUEUV''"1I(51A1A1C+DD$"4"44  *s*F c ttSr2)rr'res r8shrink_pass_choice_treesz!Shrinker.shrink_pass_choice_treesBs :&&r= random_order shrink_passrPc|j}|jry|j}|j}|j}t |j j}jJ|jjj|rt|j}ntj} |j|fd_xj|j|z z c_xj|j|z z c_xj|j|z z c_xj |t |j jz z c_|jj#y#xj|j|z z c_xj|j|z z c_xj|j|z z c_xj |t |j jz z c_|jj#wxYw)NFc&j|Sr2)r[)chooserrQs r8rzShrinker.step..Zs 4 4W =r=T)rN exhaustedrar_r`r:rrr\r~explain_next_call_asr)rr(r^steprbclear_call_explanation) rfrQrPtreeinitial_shrinksrrsizeselection_orders ` r8rWz Shrinker.stepFs,,[9 >>,, !__4%%--.+++ (()9)9: 4T[[AO4[5L5LMO 1&*ii='K #   m!; ;   " "doo8J&J J "   4<->)??%'JrN%&JrNEB 'H KKJ22K 3qr=.c.|jjSr2)rr.res r8r.zShrinker.nodes!!'''r=c.|jjSr2)rrres r8rzShrinker.choicess!!)))r=c.|jjSr2)rrres r8rzShrinker.spansrpr=ctt}|jD] }||jj |"t |S)z A mapping of labels to a list of spans with that label. Spans in the list are ordered by their normal index order. )rrrlabelrdict)rfspans_by_labelr<s r8rvzShrinker.spans_by_labelsC%T*** 0B 288 $ + +B / 0N##r=c8t|jtS)Nr)rNrvrnres r8distinct_labelszShrinker.distinct_labelssd))s33r=c|jjfd}j||jtt dz dzt k(sdzj j k\ryj|fd}|j|d}j |j ksJj |j k\sJ|jjksJjjdj j|j |j zjj dzy)aAttempt 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:tj|dk\S)Nr)r:rv)lrfs r8rz-Shrinker.pass_to_descendant..sC0C0CA0F,G1,Lr=rNcdz}t}|dz|kr2||zdz}|jjk\r|}n|}|dz|kr2dz|Dcgc]}|jjkr|c}Scc}wNrr)r:rr choice_count)lohimidspanancestorrrs r8 descendantsz0Shrinker.pass_to_descendant..descendantssQBUBq&2+Bw1n:##x||3BB q&2+"!a%"-$$x'<'<< s"A;c |jdkDSr)r~)r<s r8rz-Shrinker.pass_to_descendant.. sBOOa)>>>>  JJ' (jj))JNN; <jj( ) r=ctjdkrygtjD]>}j|}|js|j dk7r.j |@syDcgc]'}t|j|jdz )c}t}|dkDsJttD]}|xx|zcc<jdfdtj|fdtj|fd jycc}w) 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_towardsrc||j|jdz|j|jd|zgfS)Nrrr)indexrr4)r7rs r8 offset_nodez6Shrinker.lower_common_node_offset..offset_nodeQs@  Qd&6&67G&H1&LMN r=cjtjtdDcgc]\}}||||zzc}}Scc}}w)NFr)rr r.r) rsignr7rchangedintsrrfsts r8considerz3Shrinker.lower_common_node_offset..considerXs^**HH(+7D'G#D!$D$!a%.9 sAc|dSNrr]rrs r8rz3Shrinker.lower_common_node_offset..ds !Qr=c|dS)Nr`r]rs r8rz3Shrinker.lower_common_node_offset..es !Rr=)r:_Shrinker__changed_nodesrNr.trivialr rabsr3r4rr rr$rr) rfrr7offsetrrrrrs ` @@@@@r8lower_common_node_offsetz!Shrinker.lower_common_node_offsets/B t## $ ) ,,- !A::a=D||tyyI5 NN4  !  NU EIC T--.>?? @ Tzzs4y! A Gv G       v78v89 ""$A s?,EcD|j|_t|_yr2)r"_Shrinker__last_checked_changed_atrF_Shrinker__all_changed_nodesres r8rzShrinker.clear_change_trackinghs)-););&#&5 r=c:|jj|yr2)rr0)rfrs r8 mark_changedzShrinker.mark_changedls   #r=c|j|jur |jS|j}|j}||usJ|j}|j}t |jt |jksJt |t |k7st dt||dDrt|_|jSt |t |k(sJtt||dD]_\}\}}|j|jk(sJt|j|jrE|jj|a|jS)Nc3TK|] \}}|j|jk7"ywr2r')r6n1n2s r8r9z+Shrinker.__changed_nodes..{s&4 #)2rBGGrww 4 s&(Tr)rrrr.r<r:rrrFr:r rr3r0)rf prev_target new_target prev_nodes new_nodesrrrs r8__changed_nodeszShrinker.__changed_nodesosN  ) )T-?-? ?++ +44 '' *,,, && $$  (()H[5F5F,GGGG z?c)n ,4 -0Yt-T4 1 (+uD $''' z?c)n4 44(Z4)PQ 4 8Bww"'')))#BHHbhh7,,003 4 '''r=ct|tsJ|xjdz c_t|j|j |j z dz|_|j |_||_i|_yr}) rArrarbrr_rrrv)rfrs r8rzShrinker.update_shrink_targetsj*&6777   NNTZZ$*C*CCqH %)JJ!' "r=c tfd|Drytj|Dcgc]/}|j|jdz|j |gf1c}}j |d}|y|j urjy|jtjurRjj |Dcgc]}|jc}d}|jtjury|jtjuryttt!|t!|jD]}||}|j|}|j"|j"k(s1|j"d vs@|j$rMt!|j|j&d kDss|j&d }|jd||j| dfD]A} j)|d||j |j&| gz||dzdzs@yt!jt!|jz } | d kry|d j} |d jdz} | | | zfh} j*D]}|j,| kDr|j.| kr$|jt!|j*k\rG|j*|j}|j0Dcgc]}|j,| k\s|}}|j0Dcgc]}|j,| k\s|}}t!|t!|k\s|s| j3|d j,|t!| j,ft5| ddD]#\}}|d|||dz}j)|s#yycc}wcc}wcc}wcc}w)azAttempts 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. c3bK|]&}|jtjk\(ywr2)rr:r.)r6r7rfs r8r9z/Shrinker.try_shrinking_nodes..s"?tzzS_,?rNrrFTrr>bytesstringmax_size)with_constraintsrrr`c|d|dz Srr])xs r8rz.Shrinker.try_shrinking_nodes..sAaD1Q4Kr=)rreverse)rr r.rrrrrrrrr~r3INVALIDr rr:r rr4rrrrchildrenr0rN)rfr.rr7initial_attemptrr attempt_noder truncated lost_nodesrrregions_to_deleter<rrO in_original in_replacedurtry_with_deleteds` r8try_shrinking_nodeszShrinker.try_shrinking_nodess ?? ? % JJQV Wdjj$**q.4999+B*C D W  ++O>V^^ +kk66"12Q267G~~/ >>V^^ +$s3/W]]1CDE $A"1%D"==+L \...II!44 Ol&>&>z&JJ'33J?"&**Yh"7XIJ9O!P $I..'+ II1=1I1I+4&*!a%'23  $ $ $._s7=='99 ?aBioo! "3#345** Bxx%vv}xx3w}}--!--1K&(kkDQWW^1DKD&1&:&:Maggn1MKM;3{#33;  ! !Q%%{C 4D3D'E'K'KL - 4,2GQUV DAq.r2_QR5HH &&'78  e X.3LEMs#4O! O&O+(O+<O0O0c|jjrg}|jjD]^}|jdkDs|js |r|j |ddk\s8|j |j |jf`|s yt|j}t|D] \}}|||= |jt|sy|jjry)aTry removing all nodes 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 ``node_program("X")`` deletion passes, but those are necessarily more conservative and will try deleting each contiguous run of nodes 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. rr`FT) r has_discardsrr~ discardedrrrrr.reversedrr;)rfrr<rrrs r8razShrinker.remove_discarded"s"  --I((.. 9OOa' &"((imB6G*G$$bhh%78  9 4::&G + !1AaCL !**5>:/  --0r=ctt}|jD]5}||jt |j fj |7t|jS)z5Returns a list of nodes grouped (choice_type, value).)rrr.r rr3rr)rf duplicatesr7s r8duplicated_nodeszShrinker.duplicated_nodesMs\!& JJ ID  :djj#9: ; B B4 H IJ%%'((r=programc.tfddS)Nc(j|Sr2) _node_program)rTrrfs r8rz'Shrinker.node_program..WsD..w@r= node_program_)r\)rZ)rfrs``r8rzShrinker.node_programUs @  *  r=c<t|jttjz dzj j syfdt fdj t fdy)Nroriginalc|zz Sr2r])rrrs r8 offset_leftz+Shrinker._node_program..offset_leftksq1u9 r=cLj|jS)Nr)run_node_programr)rrrrfs r8rz(Shrinker._node_program..ps($//NGd6H6H0r=c.j|S)N)rrepeats)r)rrrrrfs r8rz(Shrinker._node_program..ysd++AwST+Ur=)r:rr r.rrr)rfrTrrrrrs` `@@@@r8rzShrinker._node_program[s L NN5TZZ1!4q!89 :$$Q$:L:L$M       %% U r=c|j|j}|Dcgc]}|jr|}}t|dkry|j |ycc}w)aQFind 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)rrrr:minimize_nodes)rfrTr.r7s r8rz$Shrinker.minimize_duplicated_choices|sT(t445#(<$t||<< u:?  E" =s AAcd|jjfd|jjfdjjdtdtffd }t |y)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.c|jdvxrO|jdk(xr=tj|jxst |jt k\ S)N>floatr?r)r mathisnanr3rr*r7s r8can_choose_nodez.can_choose_nodesU 99 44 W$WZZ +Us4::BU/U: r=c2|xr |j Sr2r)r7rs r8rz5Shrinker.redistribute_numeric_pairs..s.Ct||3Cr=c|xr@|j xr1j|jcxkxrjdzkScS)N)rr)r7rnode1s r8rz5Shrinker.redistribute_numeric_pairs..sR%@'@ KK$**? a?@r=rr/cjdk(rjdnd}|t|z kDry|kr| } |z }|z}jdk(rt|tk\ryj j djj|fzj jdzjzj|fzj jdzdzS#t$rYywxYw)Nr?rrFrrr) r r4r OverflowErrorr*rr.rr) rrv1v2mrrnode2rfs r8boostz2Shrinker.redistribute_numeric_pairs..boosts)8=zzY7N!!"23TU 3q>)** >!B UUzzW$R4G)G** =U[[):::,./**U[[1_u{{;<:::,./**U[[1_./ 0 !  s C== D D N)rr.r3roboolr)rfrTrrrrrrs` @@@@@r8rz#Shrinker.redistribute_numeric_pairssu  JJ C  JJ   " S" T" " H Ur=c ||jjdj|jtjdzt t jjdzdzfdj dfdtfdtfdy) Nc>|jdk(xr |j SNr?r rrs r8rz2Shrinker.lower_integers_together..s!&&I"5"Gaii-r=rrHctj|jdk(xrj|j Sr)r.r rrrfs r8rz2Shrinker.lower_integers_together..s4JJqM&&)3TDJJqM.considers** =U[[)::q:9;<**U[[1_u{{;<::q:9;<**U[[1_./ 0 r=c|z Sr2r]rrrs r8rz2Shrinker.lower_integers_together..sx(:;r=c|z Sr2r]rs r8rz2Shrinker.lower_integers_together..sxN(:;r=)rr.r rrr:r4r)rfrTrrrrs` @@@@r8rz Shrinker.lower_integers_togethers JJG  NNekkAos3tzz?EKK!Oa|jdk(xr |j SNrrrs r8rz6Shrinker.lower_duplicated_characters..s!&&H"4"FQYYr=rrcj|jdk(xrTj|j xr8tjtj|jzSr)r.r rrFr3)rrrfs r8rz6Shrinker.lower_duplicated_characters..&sdJJqM&&(2D JJqM111DEKK(3tzz!}/B/B+CC r=rEcz|j|jjj|S)Nr)rr3replacechar_in_shrink_order)r7rcharrEs r8 copy_nodez7Shrinker.lower_duplicated_characters..copy_node4s; 99::--dI4R4RST4UV r=cjjdj|fzjjdzjz|fzjjdzdzSr)rr.r)rrrrrfs r8rz6Shrinker.lower_duplicated_characters..?sd-- =U[[)UA&()**U[[1_u{{;<UA&()**U[[1_./ 0r=N) rr.r rrr:rFr3rNr4r$rrC)rfrTduplicated_charactersrrrErrs` @@@@@r8rz$Shrinker.lower_duplicated_characterss, JJF   NNekkAos3tzz?EKK!Oa...Zs'JK&q!-- *DEs#&)r rr3rs`r8rz2Shrinker.normalize_unicode_chars..Ys1aff(OPwwr=rEcHttj|Sr2)rrVr3)r,rEr7s r8rz2Shrinker.normalize_unicode_chars..asd1$**Q-KLr=Nrr) rr.r4r r:r3rVrrr)rfrTrr new_valuerEr7s @@r8rz Shrinker.normalize_unicode_charsHs~~ JJ  $$[1 NN #djj/ " L 2$**Q-K K 2A4tzz!a%'7JJI&& .sJ)#! $!MM+.!3!GGqL r=c~j|jtuxrj|jdkDSr)rrecorded_valuerr~rs r8rz.s9djjm22:KK/ 1 **Q.r=N) rr.r=rrrrrrrrr~r)rfrTr7span_idxrrs` r8rz*Shrinker.widen_to_span_with_recorded_valuels"~~ JJ  >>  " "4:: .  /  zz(# LL4:: &,,-/ 0ll488:& '  ""4;;#C#CG#LMr=c4djdjdj}tfdDsJdk(rr|dj t z t jt z fdt jt z fdydk(rbj t tjt fdtjt fd yd k(rd usJj d yd k(r tjfd|dydk(r$tjfd|d|dyt)Nrc3lK|]+}|jk(xrt|j-ywr2)r rr3)r6r7 choice_typer3s r8r9z*Shrinker.minimize_nodes..s5  II $ Hdjj%)H H s14r?rc.j|zSr2rrr.rfrs r8rz)Shrinker.minimize_nodes..$225.1:LMr=c.j|z Sr2rrs r8rz)Shrinker.minimize_nodes..rr=rc(j|Sr2rvalr.rfs r8rz)Shrinker.minimize_nodes..D44UC@r=c*j| Sr2rrs r8rz)Shrinker.minimize_nodes..sD44USDAr=booleanTFrc(j|Sr2rrs r8rz)Shrinker.minimize_nodes..rr=min_size)rrc(j|Sr2rrs r8rz)Shrinker.minimize_nodes..rr=rE)rEr) r r3r4r rrr$rr#r"r&r)rfr.r4r rr3s`` @@@r8rzShrinker.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  & %r=c |jtt|j}|j}|jj }|j|}|d|j }t||j |jDcgc]A}|jr|n0|jtd|j|jCc}}||jd} |j||z| zd} |j|uryt| t rJ| j|} | j | j | j} |j#|| z| zyycc}w)Nrrr)rr r:rrr.rr;rrrrr r4rrArr) rfrTrrnr.rrr7rsuffixrnew_spannew_replacements r8rzShrinker.try_trivial_spanssS NN5TZZ1 2!!""((zz!}|$"$**txx8  #4Q 4CSCS#T#   txxz"++F[,@6,IJ1M   T )  g/ 0}}Q'H%mmHNNX\\JO  # #F_$. s 4<<7Gr=Nr?rrcd}tj}|dz|kr>||zdz}j|}|jjk\r|}n|}|dz|kr>|S)Nrrr)r:rrr)rrrrr7rfs r8first_span_after_nodezCShrinker.minimize_individual_choices..first_span_after_node;shBTZZBq&2+Bw1nzz#::+BB q&2+Ir=TFc<j|jdkDSr)rr~rs r8rz6Shrinker.minimize_individual_choices..Psdjjm881<r=)rr.rrr rrr3rrrrr:rrr rrr)rfrTinitial_targetloweredrr"rr7s` @r8rz$Shrinker.minimize_individual_choicess*~~djj*GH++ TF#   ^ 3  99 !  JJ| $yyDJJNy35 6jja)* +  ++G4Q7 O~~ ,7==!S_47==!TZZ!^3 d00000 TZZ   !  >>4- (::/TZZA<D  # #GLdjj$9GDHHJ3tzz?-STUD  # #GLdjj$9GDJJQRNDT.ws|D33HH*-Y)M  &FQA HHU1X^^eAhllC  s9A5chtj|j|jSr2)r<r.rr)rrrs r8rz(Shrinker.reorder_spans..s'(288E!HNNU1X\\#JKr=r) rrrrtr:rrrr%rr )rfrTrrtrOr)rrs` @@@r8rzShrinker.reorder_spansXs&~~djj)t}}-33 MM>qQWW-=> u:? 8=>djj$((+>    #e*  L ??sC%(C%C*cd|t|zt|jkDs|dkryt|j}t|D]S}t tt |D]1\}}||z} | t|k\ry|dk(r|| =%t d|U|j|S)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. rFrzUnrecognised command )r:r.rr rr:rr) rfrrrrrrrcommandr,s r8rzShrinker.run_node_programs s7| c(..1 1QUx~~&w SA&tIg,>'?@ S 7EG $ c> -0Eg[.QRR S S&&w//r=)r/N)r/r+)r)Krdrkrl__doc__r|rrr-rrrrrr{ror_r`rrrr;rrrrrnrrrrrr rrr=r8rBrur r'rNrZrWrr6r.rrrrrvrxrrrrrFrrrrarrrrrrrrrrrrrrr]r=r8rsrss>DL 6!&?&"?& "22?&$d* ?& n'77H$N ORV V?&?&?&B&s&& ,C,, <j)< t%0477 8<43(<33 ,""6p kZ  "  ( D6 '));z>'$sJ*?''EJ Td<\44 +;\4\4|(uZ_-((*w|,**(u(( $ $448 tN%`)$(S((2# GR)V)) C J  B#:L\=B> @"H+NZ;&zGr;s  #88!     ;F&(88(C'Dd'JK)KHZ(U3c3h3G-H0 4@@6 e$%& I O0O0r=