zpPddlZddlmcmZddlZddlmZddl m Z ddl m Z m Z mZddlmZddlmZmZddlmZddlmZdd lmZmZdd lmZmZmZmZm Z m!Z!m"Z"m#Z#m$Z$m%Z%m&Z&dd l'm(Z(m)Z)m*Z*dd l+m,Z,dd l-m.Z.m/Z/ddl0m1Z1m2Z2e3e4ze zezZ5Gdde/e3Z6e1e2d d&de3dzde3dzde/e3fdZ7Gdde/e4Z8e1e2d d&dddddddde5dzde5dzde9dzde9dzde9dzde d d!e9d"e9de/e4fd#Z:Gd$d%e/e4Z;y)'N)Decimal)Fraction)AnyLiteralcast)reject) CannotInvertInvalidArgument)ChoiceT)ConjectureData)get_float_predicate_boundsget_integer_predicate_bounds) SMALLEST_SUBNORMALfloat_of float_to_int int_to_float is_negative next_downnext_down_normalnext_upnext_up_normalsign_aware_ltewidth_smallest_normals) check_typecheck_valid_boundcheck_valid_interval)nothing)SampledFromStrategySearchStrategy) cacheabledefines_strategycxeZdZdedzdedzddffd ZdefdZdedefdZd e de e d ffd Z fd Z xZS) IntegersStrategystartNendreturnc t|g}t|t}|}|sd}||u}|}|sddt j vst jtrt jtnddt j vst j|rt j|nddt j vst jtrt jtndt j|dz}|j||st jdfd|fdt j vst j|rt j|ndt j|dz} d d | iz} |j| t j|d iz} d d | iz} tt j| dx}x}x}x}}g}t|t}|}|sd}||u}|}|sddt j vst jtrt jtnddt j vst j|rt j|nddt j vst jtrt jtndt j|dz}|j||st jd|fd||fdt j vst j|rt j|ndt j|dz} d d | iz} |j| t j|d iz} d d | iz} tt j| dx}x}x}x}}g}d} || u}|}|sd}||u}|}|s||k}|}|st jd|fd|| fdt j vst j|rt j|ndt j| dz}dd|iz}|j||sGt jd|fd|fdt j vst j|rt j|ndt j|dz}dd|iz} |j| |st jdfd||fdt j vst j|rt j|nddt j vst j|rt j|nddz}dd|iz}|j|t j|d iz}dd|iz}tt j|dx}x}x}x} x}x}}||_||_y)Nz.%(py6)s {%(py6)s = %(py2)s(%(py3)s, %(py4)s) } isinstancer$int)py2py3py4py6)is)z%(py8)s is %(py11)s)py8py11z%(py13)spy13zassert %(py16)spy16r%)z%(py2)s is %(py5)s)r*py5z%(py7)spy7)z%(py9)s is %(py12)s)py9py12z%(py14)spy14)<=)z%(py16)s <= %(py18)s)r3py18z%(py20)spy20zassert %(py23)spy23)super__init__r(r) @py_builtinslocals @pytest_ar_should_repr_global_name _safereprappend_call_reprcompare_format_boolopAssertionError_format_explanationr$r%)selfr$r% @py_assert1 @py_assert5 @py_assert0 @py_assert10 @py_assert9 @py_format7 @py_format12 @py_format14 @py_format15 @py_format17 @py_assert4 @py_assert3 @py_assert11 @py_assert17 @py_format6 @py_format8 @py_format13 @py_format19 @py_format21 @py_format22 @py_format24 __class__s l/home/oem/CyberBrain26-unified/.venv/lib/python3.12/site-packages/hypothesis/strategies/_internal/numbers.pyr>zIntegersStrategy.__init__6s7 6z%%6%6%$6$666666z666z666666%666%666666666666%6666%666$666666666666$666666666666662z#s#2#2#d2sd{222222z222z222222#222#222222s222s222#2222#222sd222222s222s222d22222222222222;;u};t;t ;u|;;;;u;;;;;;u;;;u;;;;;;;;;;t;;;;;;;;;;;;t;;;;;;;u;;;;;;u;;;u;;;;;;;;;;;;;;;;;;;;;;; c|j |jy|jd|jdS|jd|jdSd|jd|jdS)Nz integers()zintegers(min_value=)zintegers(max_value=z integers(, )r$r%rIs r`__repr__zIntegersStrategy.__repr__>so :: $(("2 88 ( A6 6 :: ( !4 44::,b !44radatac.d}|j`|jT|j|jz dkDr8|jd|jdzd|jdz d|jdi}|j|j|j|S)Ng?r2g?) min_value max_valueweights)r%r$ draw_integer)rIrgrls r`do_drawzIntegersStrategy.do_drawGs HH  &4::%+ W Q1 w7 G  jjDHHg!  ravalue.c8t|trt|trt|d|j)||jkrt|d|j|j )||j kDrt|d|j |fS)Nz is not an integerz is below min_value=z is above max_value=)r(r)boolr r$r%rIros r`_invertzIntegersStrategy._invertZs%%E4)@%*<=> > :: !edjj&8%*>tzznMN N 88 EDHH$4%*>txxlKL Lxrac|tjur|S|tjtjfvr t St |\}}|j |j}}d|vr"t|d|tj n|}d|vr!t|d|tjn|}||j k7s||jk7r%||||kDr t St|||}||St|5|S)Nrjrk)mathisfiniteisinfisnanrrr$r%maxinfmintyper=filter)rI condition constraintspredr$r%r_s r`r}zIntegersStrategy.filtercs  %K TZZ0 09 8C TZZs + % K0u}488)RWXE + %k+.CKSQC DJJ #/ S_y 4:eS)D <Kw~d##ra)__name__ __module__ __qualname__r)r>strrfr rnrtupler rsr} __classcell__r_s@r`r#r#5sjcDjsTzd5#5 N s &SU7C<%8$$rar#T)force_reusable_valuesrjrkr&c>t|dt|dt||dd|4|t|k7rtd|dt |dt|}|4|t|k7rtd|dt |dt|}t ||S)aMReturns a strategy which generates integers. If min_value is not None then all values will be >= min_value. If max_value is not None then all values will be <= max_value Examples from this strategy will shrink towards zero, and negative values will also shrink towards positive (i.e. -n may be replaced by +n). rjrk min_value=z of type z- cannot be exactly represented as an integer. max_value=)rrr)r r|r#)rjrks r`integersrysi-i-I{KH I &!YM4 ?2EF??  N  I &!YM4 ?2EF??  N Iy 11rac zeZdZdZeddedededeffdZdefd Z d e defd Z d e de ed ffdZfdZxZS) FloatStrategyz&A strategy for floating point numbers.)smallest_nonzero_magnituderjrk allow_nanrc2t |t|t}|s ddt j vst jtrt jtnddt j vst j|rt j|nddt j vst jtrt jtndt j|dz}tt j|d}d}||k\}|st jd|fd||fd t j vst j|rt j|nd t j|d z} t jd d zd | iz} tt j| dx}}|dk(r td||_||_||_||_y)N5assert %(py4)s {%(py4)s = %(py0)s(%(py1)s, %(py2)s) }r(rrqpy0py1r*r,)>=)z%(py0)s >= %(py3)sr)rr+z$programmer error if this is negativez >assert %(py5)sr4a_Got allow_subnormal=True, but we can't represent subnormal floats right now, in violation of the IEEE-754 floating-point specification. This is usually because something was compiled with -ffast-math or a similar option, which sets global processor state. See https://simonbyrne.github.io/notes/fastmath/ for a more detailed writeup - and good luck!)r=r>r(rqr?r@rArBrCrGrHrE_format_assertmsgFloatingPointErrorrjrkrr) rIrjrkrrrU @py_format5 @py_assert2rJ @py_format4rXr_s r`r>zFloatStrategy.__init__s7 )T********z***z******)***)******T***T**********-0X)S0XXX)SXXXXXX)XXX)XXXSXXX2XXXXXXX % ,$+ #""*D'rar&c |jjd|jd|jd|jd|j d j ddS)Nz(self.min_value=z, self.max_value=z, self.allow_nan=z", self.smallest_nonzero_magnitude=rczself.)r_rrjrkrrreplaceres r`rfzFloatStrategy.__repr__sa~~&&''8(99KDNN;LM~~B$"A"A!C1 F ''2  rargc||j|j|j|j|jS)Nrjrkrr) draw_floatrjrkrr)rIrgs r`rnzFloatStrategy.do_draws6nnnnnn'+'F'F   raro.ct|turt|dtj|r|j std||fSdt |cxkr|jkrnnt|d|jt|j|rt||js(t|d|jd|jd|fS)Nz is not a floatzNaN not permitted by rz" below smallest_nonzero_magnitude=z outside [rd]) r|floatr rurxrabsrrrjrkrrs r`rszFloatStrategy._inverts ;e #%/:; ; ::e >>"%:4(#CDD8O s5z ;D;; ;)=2257 dnne4N 4>>= ):dnn%7r$..9K1M xrac |tjurett|jt t dt|jtt dd|jS|tjurhtj tjfDcgc]&}|j|cxkr|jkrnn|(c}x}r t|StS|tjur |j s tSt#St%|\}}|st&|Q|St|j+dtj |j}t|j+dtj|j}|j |cxkrdkrnnd}n$d|cxkr|jkrnn |j}|j |cxkrdkrnn|j }nd|cxkr|jkrnnd }||kDr tS||jkDsB|j|kDs3|j rFtj |ks|tjkrt-|||d|j}||St&|Q|Scc}w) N-infrzFrrjrkrr)rurvrryrjrrr{rkrrrwrzrrrxr NanStrategyr r=r}getr|) rIr~xpermitted_infsrr min_bound max_boundr_s r`r}zFloatStrategy.filtersF  % dnngeFm.DEdnnie .EF+/+J+J    " 88)TXX.">>Q8$..8"~ +>::9   ">>y = 6yA T7>$' '  dhhY?P   TXX>O   + + +i ;! ;I  rrfr rnrrr rsr}rrs@r`rrs0-?EE E  E%*E:#  N u SU7C<%8(5$5$rar@F)rallow_infinityallow_subnormalwidth exclude_min exclude_maxrrrr rrrc ptt|dtt|d|t|duxr|du}n|r||td|ddvrtddttdt t |d t |d tjd d d k(r td |r@tddk(r0ddl m } |} | r d| d| d| d} nd} td|d| ||} } |,t|}t|t } | s ddt#j$vst'j(trt'j*tndd t#j$vst'j(|rt'j*|nd dt#j$vst'j(t rt'j*t ndt'j*| dz}t-t'j.|d} |,t|}t|t } | s ddt#j$vst'j(trt'j*tndd t#j$vst'j(|rt'j*|nd dt#j$vst'j(t rt'j*t ndt'j*| dz}t-t'j.|d} || k7rtd| dd|d || k7rtd!| dd"|d |r#||tj0k(rtd#||r$||tj0 k(rtd$||duxs|}||s | || krt3||%}|| k(r|| k(}d}| |k(}|r|st'j4d&||fd'|| |fd t#j$vst'j(|rt'j*|nd d(t#j$vst'j(| rt'j*| nd(t'j*|d)z}d*d+|iz}t-t'j.|dx}x}}t7| }|sd,d-t#j$vst'j(t6rt'j*t6nd-d(t#j$vst'j(| rt'j*| nd(t'j*|d.z}t-t'j.|d}t7|}| }|sd/d-t#j$vst'j(t6rt'j*t6nd-d t#j$vst'j(|rt'j*|nd t'j*|d.z}t-t'j.|dx}}t3||%}|| kD}|st'j4d0|fd1|| fd t#j$vst'j(|rt'j*|nd d(t#j$vst'j(| rt'j*| nd(d2z}d3d4|iz}t-t'j.|d}||s | || kDrt9||%}|| k(r|| k(}d}| |k(}|r|st'j4d&||fd'|| |fd t#j$vst'j(|rt'j*|nd d5t#j$vst'j(| rt'j*| nd5t'j*|d)z}d*d+|iz}t-t'j.|dx}x}}t7|}|sd,d-t#j$vst'j(t6rt'j*t6nd-d t#j$vst'j(|rt'j*|nd t'j*|d.z}t-t'j.|d}t7| }| }|sd/d-t#j$vst'j(t6rt'j*t6nd-d5t#j$vst'j(| rt'j*| nd5t'j*|d.z}t-t'j.|dx}}t9||%}|| k}|st'j4d6|fd7|| fd t#j$vst'j(|rt'j*|nd d5t#j$vst'j(| rt'j*| nd5d2z}d3d4|iz}t-t'j.|d}|tj0 k(rd}|tj0k(rd}||cxk(xrdk(ncxrt7|xr t7| }|.|,||kDs|r%d8d9| d:| }|s|r |d;|d<|z }t||t|duxs|du}n|r||td=|d>|tj0k(r-| tj0k(r td?td@| dA|tj0 k(r.| tj0 k(r tdBtdC| dDt;}|<|'|%||k(r| |cxkxr|knc}n!||kxr|| kD}n|||k}n ||| kD}ndE}|r8|||k\rtdF|dGdH|||| krtdI|dJdK| | t!dL}| t!dM}|s= min_value`` (or ``> min_value`` if ``exclude_min``). - If max_value is not None, all values will be ``<= max_value`` (or ``< max_value`` if ``exclude_max``). - If min_value or max_value is not None, it is an error to enable allow_nan. - If both min_value and max_value are not None, it is an error to enable allow_infinity. - If inferred values range does not include subnormal values, it is an error to enable allow_subnormal. Where not explicitly ruled out by the bounds, :wikipedia:`subnormals `, infinities, and NaNs are possible values generated by this strategy. The width argument specifies the maximum number of bits of precision required to represent the generated float. Valid values are 16, 32, or 64. Passing ``width=32`` will still use the builtin 64-bit :class:`~python:float` class, but always for values which can be exactly represented as a 32-bit float. The exclude_min and exclude_max argument can be used to generate numbers from open or half-open intervals, by excluding the respective endpoints. Excluding either signed zero will also exclude the other. Attempting to exclude an endpoint which is None will raise an error; use ``allow_infinity=False`` to generate finite floats. You can however use e.g. ``min_value=-math.inf, exclude_min=True`` to exclude only one infinite endpoint. Examples from this strategy have a complicated and hard to explain shrinking behaviour, but it tries to improve "human readability". Finite numbers will be preferred to infinity and infinity will be preferred to NaN. rrNzCannot have allow_nan=z, with min_value or max_valuerz Got width=z<, but the only valid values are the integers 16, 32, and 64.rjrkg?ra Your Python install can't represent -0.0, which is required by the IEEE-754 floating-point specification. This is probably because it was compiled with an unsafe option like -ffast-math; for a more detailed explanation see https://simonbyrne.github.io/notes/fastmath/r)rr)identify_ftz_culpritszThis seems to be because the `z` package was compiled with -ffast-math or a similar option, which sets global processor state - see https://simonbyrne.github.io/notes/fastmath/ for details. If you don't know why z is installed, `pipdeptree -rp z(` will show which packages depend on it.zThis is usually because something was compiled with -ffast-math or a similar option, which sets global processor state. See https://simonbyrne.github.io/notes/fastmath/ for a more detailed writeup - and good luck!zGot allow_subnormal=zq, but we can't represent subnormal floats right now, in violation of the IEEE-754 floating-point specification. rr(rrrz3 cannot be exactly represented as a float of width z - use min_value=z instead.rz - use max_value=zCannot exclude min_value=zCannot exclude max_value=)r)==r)z%(py0)s == %(py3)sz%(py3)s == %(py5)smin_arg)rr+r4zassert %(py7)sr5z,assert %(py3)s {%(py3)s = %(py0)s(%(py1)s) }r)rrr+z0assert not %(py3)s {%(py3)s = %(py0)s(%(py1)s) })>)z%(py0)s > %(py2)s)rr*zassert %(py4)sr,max_arg)<)z%(py0)s < %(py2)sz There are no z--bit floating-point values between min_value=z and max_value=z, exclude_min=z and exclude_max=zCannot have allow_infinity=z#, with both min_value and max_valuez+allow_infinity=False excludes min_value=infz!exclude_min=True turns min_value=z# into inf, but allow_infinity=Falsez,allow_infinity=False excludes max_value=-infz!exclude_max=True turns max_value=z$ into -inf, but allow_infinity=FalseTz(allow_subnormal=True, but minimum value z excludes values below floatz's smallest positive normal z(allow_subnormal=True, but maximum value z excludes values above floatz's smallest negative normal rrzrrrr&cP t|S#t$r tYywxYw)N)r OverflowErrorr)rrs r`downcastzfloats..downcasts) 5))   s %%)$rrqr rrr)rrucopysignrr_hypothesis_ftz_detectorr Exceptionrr(rr?r@rArBrCrGrHrzrrErrrryr{rrrmap)rjrkrrrrrrrftz_pkgftz_msgrrrUrassumed_allow_subnormalrJrTrrXrYr @py_format3bad_zero_boundsmsgsmallest_normalrresultrs ` r`floatsrs `t[-0t[-0d*@yD/@A  -1F 7YL8UVWW L 5(/ /   $c%j 1Ei-i- }}S$3&  K  73e49 C +-G 0 :)*1 1P)C E +  !#?$%&i )  !)WGY. )U++++++++z+++z++++++)+++)++++++U+++U++++++++++Y. )U++++++++z+++z++++++)+++)++++++U+++U++++++++++G $w0i\ <  G $w0i\ <   )Y$((-B : |<== )Y488)-C : |<==-5H+ G0C" u.E   , ,1 ,1, , , , ,91 , , , , , ,9 , , ,9 , , , , , , , , , , , ,1 , , , , , , ,w' '' ' ' ' ' '; ' ' '; ' ' ' ' ' 'w ' ' 'w ' ' '' ' ' ' ' ' '"9- --- -- - - - - -{ - - -{ - - - - - -9 - - -9 - - -- - - - - - -&52II7""""y7""""""y"""y""""""7"""7"""""""+ G0C$ u.E   , ,1 ,1, , , , ,91 , , , , , ,9 , , ,9 , , , , , , , , , , , ,1 , , , , , , ,y) )) ) ) ) ) ); ) ) ); ) ) ) ) ) )y ) ) )y ) ) )) ) ) ) ) ) )"7+ +++ ++ + + + + +{ + + +{ + + + + + +7 + + +7 + + ++ + + + + + +(52II7""""y7""""""y"""y""""""7"""7"""""""TXXI DHH  Y#!# '  " 'I& &   !  "o E7# ?7+ ?  + _ ~%7;.9 9Cc""i4/D93DE   Y%:!.~//RS  dhh  dhh !"OP P/{;' '   txxi  txxi !"PQ Q/{;' '  -U3O  Y%:I%#2"2Y"P"P/PI@P4P  "'/9O  "'?*::O"O  Y/%A!:9+F..3W5,,;+<>   Y?2B%B!:9+F..3W5,-<,<+=?  &M %L  75=#9:  9U5\#:; i '' '''''':''':''''''i'''i'''''''''''' ''''''' i '' '''''':''':''''''i'''i'''''''''''' '''''''-?+#= F rz  %  H% Mk G s~&& ~54~5c:eZdZdZdedefdZdedee dffdZ y) rz4Strategy for sampling the space of nan float values.rgr&ct|jdz}ttj}|j dd}t ||z|zS)N?r)r) draw_booleanrrunanrmr)rIrgsign_bitnan_bits mantissa_bitss r`rnzNanStrategy.do_draw)sQt((*+r1)))!Y7 Hx/-?@@raro.ct|trtj|st |dt |}t |dz |dzfS)Nz is not NaNrr)r(rrurxr rrq)rIrobitss r`rszNanStrategy._invert1sL%'tzz%/@%+67 7E"TRZ $-"899raN) rrrrr rrnrrr rsrar`rr&s7>ANAuA:S:U7C<%8:rar)NN)<builtinsr?_pytest.assertion.rewrite assertionrewriterArudecimalr fractionsrtypingrrrhypothesis.controlrhypothesis.errorsr r %hypothesis.internal.conjecture.choicer #hypothesis.internal.conjecture.datar hypothesis.internal.filteringr rhypothesis.internal.floatsrrrrrrrrrrrhypothesis.internal.validationrrr$hypothesis.strategies._internal.miscr*hypothesis.strategies._internal.strategiesrr%hypothesis.strategies._internal.utilsr r!r)rRealr#rrrqrrrrar`rs %%%;9>     9N U{X'A$~c*A$H -  2Tz2Tz2C2. 2Dw$N5)w$t -!!J""&#'!#Jd{Jd{Jd{ J 4K J D[ J : JJJEJ. JZ:.':ra