i <SSKJrJr SSKJr SSKJr SSKJr SSK J r SSK J r SSK JrJrJrJr SSKJr SS KJr \"S 5r\(aSS KJr "S S \5rS\S\S\4Sjr"SS5r"SS5rg))CallableIterator)Enum)Random) TYPE_CHECKING) SortedList) choices_key)ConjectureDataConjectureResultStatus_Overrun)LazySequenceCopy)sort_keyz-inf)ConjectureRunnerc$\rSrSrSrSrSrSrSrg)DominanceRelation"rN) __name__ __module__ __qualname____firstlineno__ NO_DOMINANCEEQUALLEFT_DOMINATESRIGHT_DOMINATES__static_attributes__rd/var/www/html/ai-image-ml/venv/lib/python3.13/site-packages/hypothesis/internal/conjecture/pareto.pyrr"sL ENOr!rleftrightreturnc[UR5n[UR5nX#:Xa[R$X2:aE[ XS9nU[R :Xa[R $U[R:XdeU$X#:deURUR:a[R$URRUR5(d[R$UR[R:Xa7URb*URUR:wa[R$[UR5[UR5-HZnURR!U["5nURR!U["5nXv:dMJ[Rs $ [R $)a+Returns the dominance relation between ``left`` and ``right``, according to the rules that one ConjectureResult dominates another if and only if it is better in every way. The things we currently consider to be "better" are: * Something that is smaller in shrinking order is better. * Something that has higher status is better. * Each ``interesting_origin`` is treated as its own score, so if two interesting examples have different origins then neither dominates the other. * For each target observation, a higher score is better. In "normal" operation where there are no bugs or target observations, the pareto front only has one element (the smallest valid test case), but for more structured or failing tests it can be useful to track, and future work will depend on it more.)r#r$)rnodesrr dominancerrrstatustagsissubsetr INTERESTINGinteresting_originsettarget_observationsgetNO_SCORE)r#r$left_key right_keyresulttarget left_score right_scores r"r(r()s& #H%I &&&2 &55 5$44 4 .;;; ;;M    {{U\\! --- ::  tyy ) ) --- v)))  $ $ 0  # #u'?'? ? ---d../#e6O6O2PP--11&(C //33FHE  #$11 1 Q  + ++r!c\rSrSrSrS\SS4SjrS\\-\ -S\ 4Sjr S \ \/S4SS4S jr S\S\ 4S jrS\\4S jrS \S\4SjrS\4SjrS\SS4SjrSrg) ParetoFronthaMaintains an approximate pareto front of ConjectureData objects. That is, we try to maintain a collection of objects such that no element of the collection is pareto dominated by any other. In practice we don't quite manage that, because doing so is computationally very expensive. Instead we maintain a random sample of data objects that are "rarely" dominated by any other element of the collection (roughly, no more than about 10%). Only valid test cases are considered to belong to the pareto front - any test case with a status less than valid is discarded. Note that the pareto front is potentially quite large, and currently this will store the entire front in memory. This is bounded by the number of valid examples we run, which is max_examples in normal execution, and currently we do not support workflows with large max_examples which have large values of max_examples very well anyway, so this isn't a major issue. In future we may weish to implement some sort of paging out to disk so that we can work with larger fronts. Additionally, because this is only an approximate pareto front, there are scenarios where it can be much larger than the actual pareto front. There isn't a huge amount we can do about this - checking an exact pareto front is intrinsically quadratic. "Most" of the time we should be relatively close to the true pareto front, say within an order of magnitude, but it's not hard to construct scenarios where this is not the case. e.g. suppose we enumerate all valid test cases in increasing shortlex order as s_1, ..., s_n, ... and have scores f and g such that f(s_i) = min(i, N) and g(s_i) = 1 if i >= N, then the pareto front is the set {s_1, ..., S_N}, but the only element of the front that will dominate s_i when i > N is S_N, which we select with probability 1 / N. A better data structure could solve this, but at the cost of more expensive operations and higher per element memory use, so we'll wait to see how much of a problem this is in practice before we try that. randomr%NcJXl/Ul[SS9UlSUlg)Nc,[UR5$N)rr')ds r"&ParetoFront.__init__..s (177+r!)key)_ParetoFront__random _ParetoFront__eviction_listenersrfront_ParetoFront__pending)selfr;s r"__init__ParetoFront.__init__s' NP!3=+4  37r!dataclUR[R:ag[U[5(aeUR 5n[U[5(aeUR (dUR RU5 gXR ;agUR RU5 URbeXl[UR 5n/nUR RU5nSnUS-[U5:aUS:aURRUS-[U55nURU5n[X5nU[ R":wdeU[ R$:XaUR'U5 SnOUS- nUS-[U5:aUS:aMU/n US:Ga8[U 5S:Ga(UR)X@RR+SU55 X$nSn SnU[U 5:aXn [X{5nU[ R$:XaDU (d Sn XyU'US- nOU SXsX'U S'U R5 UR'U 5 O@U[ R":XaUR'U5 O!IIaL 0/?????+:::$$Y/ HMHa%#e*$B Jq&S_r1 1mm33Aq9:!H #( #j/)" A#I1C/>>>//3,,5qMFA!+2 * :JM:b>'NN,!((+ 1 A AA!((3 1 7 77Q-#j/)0%%i0QAq&S_r1D Q::%!DNTDNs C1L*9DL* +L*;'L** L3fc:URRU5 g)zRegister a listener function that will be called with data when it gets removed from the front because something else dominates it.N)rDrV)rGrds r"on_evictParetoFront.on_evicts !!((+r!c[U[[45(dgUR5n[U[5(agX R ;$)NF)rOr r rPr rE)rGrJr4s r" __contains__ParetoFront.__contains__sA$1A BCC! fh ' '##r!c,[UR5$r>)iterrErGs r"__iter__ParetoFront.__iter__sDJJr!r[c URU$r>)rE)rGr[s r" __getitem__ParetoFront.__getitem__szz!}r!c,[UR5$r>)rSrErms r"__len__ParetoFront.__len__s4::r!cURRU5 XRLaURH nU"U5 M gg![a gf=fr>)rEremove ValueErrorrFrD)rGrJrds r"rYParetoFront._removesU  JJ  d # ~~ %..$/ &   sA AA)__eviction_listeners __pending__randomrE)rrrr__doc__rrHr r r boolrQrrfobjectrirrnintrqrtrYr rr!r"r9r9hs!F7v7$7j")99HDj"j"X,($4#5t#;<,, $$D$ (#34 S%5,r!r9c,\rSrSrSrSSjrSSjrSrg) ParetoOptimiseri#aClass for managing optimisation of the pareto front. That is, given the current best known pareto front, this class runs an optimisation process that attempts to bring it closer to the actual pareto front. Currently this is fairly basic and only handles pareto optimisation that works by reducing the test case in the shortlex order. We expect it will grow more powerful over time. NcxXlURRceURRUlgr>)_ParetoOptimiser__engine pareto_frontrE)rGengines r"rHParetoOptimiser.__init__-s. }}))555"&--"<"< r!c^[5n[TR5S- nSnUS:GaTRR(dTR(de[ U[TR5S- 5nTRUn[ UR5U;aUS-nMXCLdeUnU4SjnTRRXES9nUR[ UR55 TRRRU5nUS:aTRR(dMgggg)Nrrcx>[X5[R:XaTRR U5 gg)aOShrink to data that strictly pareto dominates the current best value we've seen, which is the current target of the shrinker. Note that during shrinking we may discover other smaller examples that this function will reject and will get added to the front. This is fine, because they will be processed on later iterations of this loop.TF)r(rrrErY)source destinationrGs r"allow_transition-ParetoOptimiser.run..allow_transitionLs3[15F5U5UU JJ&&v.r!)r) r.rSrErinteresting_examplesminr choicesshrinkrQ bisect_left)rGseenr[prevr5rshrunks` r"runParetoOptimiser.run2su  Oa 1fT]]??:: :As4::*+AZZ]F6>>*d2Q% %%D $]]))&)TF HH[0 1   ,,V4AO1fT]]???f?fr!)__enginerE)rrr%N)r%N)rrrrr}rHrr rr!r"rr#s= 75r!rN)collections.abcrrenumrr;rtypingrsortedcontainersr%hypothesis.internal.conjecture.choicer #hypothesis.internal.conjecture.datar r r r )hypothesis.internal.conjecture.junkdrawerr'hypothesis.internal.conjecture.shrinkerrfloatr1%hypothesis.internal.conjecture.enginerrr(r9rrr!r"rs~/ '= G< =F<,$<,-=<,BS<,~xxvF5F5r!