iT %SSKrSSKrSSKJrJrJrJr SSKJr SSK J r SSK J r J r JrJrJrJr SSKJr SSKJr SSKJr SS KJrJr SS KJrJrJrJ r J!r!J"r"J#r#J$r$J%r%J&r'J(r(J)r* SS K+J,r- SS K.J/r/ SS K0J1r1 SSK2J3r3 SSK4J5r5J6r6J7r7J8r8 SSK9J:r: SSK;J/\>QSP7r?\@"\?5\A"\?5:Xde\ SrB\"\B5\?:XdeSrCSrD\C\D-rESrF\E\F-rGSrH\G\H-rIS/\IQ7rJ\"S5rK\/S\ S\A\LSS4Sj5rMS\ S\\LS\N\A\ \A\L44S jrOS\ S!\A\LSS4S"jrPS\ S#\BS$\KS\Q\R\S-\T-\U-4S%jrV\/S\ S&\LS\ 4S'j5rWSSSSSSSS(.S\ S#\BS$\K\L-S)\S\T-S-S*\S\T-S-S+\RS-S,\RS-S-\RS-S.\RS-S/\RS-S\R\R\S-\T-\U-4S0jjrY"S1S2\R5rZSSS3S4.S\ S#\BS$\K\L-\R\K-\R\L-S5\S\!-\R\!-S6\\L\ 4\R-S-S7\R\ S-S8\RS\R4S9jjr[\/S\ S:\A\KS!\A\LSS4S;j5r\S\ S#\BS\R\K4S<jr]S\ S\R\K4S=jr^S\ S\R\K4S>jr_S\ S#\BS\R\K4S?jr`\/S@\LSA\\SSB\\SSS4SCj5raSD\LSA\\SS\\L4SEjrb\ SFrc\\dSG'\ SHre\\dSI'\ SJrf\\dSK'SFSL.S\ SA\c\\c-S\R\K4SMjjrgSFSL.S\ SA\c\\c-S\R\K4SNjjrhSHSL.S\ SA\e\\e-S\R\K4SOjjriSJSL.S\ SA\f\\f-S\R\K4SPjjrj\3"\*5SQ5r)SR\*RSS3\)lk\<"5STSSSUSSV.SW\SSX\!SY\SSZ\SS-S[\SS\\SS-S\R\ 4S]jj5r&\'R\&lk\<"5SSS3S^S_.S5\!SY\SSZ\SS-S`\RSa\RS\R\4 Sbjj5rl\"5rm\\dSc'SSd.S\ S#\BS-S\ 4SejjrnSSKorp\pGb"ShSi\5ruS$\KS\u4Sjjrv\ "ST0SkSl_SmSn_So\pR_Sp\pR_Sq\pR_Sr\pR_Ss\pR_St\pR_Su\pR_Sv\pR_Sw\pR_Sx\pGR_Sy\pGR_Sz\pGR_S\pGR_S{\pGR_S|S}_S~\pGR _S\v_S\pGR _S\pGR_S\pGR_S\pGR_S\pGR_S\pGR_S\pGR_S\pGR_S\pGR_S\pGR_S\pGR _S\pGR"_S\pGR$_S\pGR&_S\pGR(_S\pGR*_6rgg!\qa& Sf\R;aSSgKsJtrt \t"5rpGNSrpGNf=f)N)IterableIteratorMappingSequence)Real)SimpleNamespace)AnyLiteral NamedTuple TypeAliasTypeVarget_args)warn)WeakValueDictionary) strategies)HypothesisWarningInvalidArgument) NDIM_MAX BasicIndexBasicIndexStrategyBroadcastableShapesShape array_shapesbroadcastable_shapescheck_argumentcheck_valid_dimsmutually_broadcastable_shapes order_checkvalid_tuple_axes)utils)check_function) next_down)proxies) check_typecheck_valid_boundcheck_valid_integercheck_valid_interval)check_strategy)defines_strategymake_strategies_namespace)2021.122022.122023.122024.122025.12draft)r+r,r-r.r/r0)int8int16int32int64)uint8uint16uint32uint64)float32float64) complex64 complex128boolDataTypexp attributesreturncUVs/sHn[X5(aMUPM nn[U5S:a,SRU5n[SURSU35egs snf)Nr, Array module z$ does not have required attributes: )hasattrlenjoinr__name__)r?r@attr missing_attrsf_attrss Y/var/www/html/ai-image-ml/venv/lib/python3.13/site-packages/hypothesis/extra/array_api.pycheck_xp_attributesrMPse&0Jjd8ITjMJ =A))M*BKK=(LWI V  Ks A!A!c/n/nUHnUR[X55 M X#4$![a URU5 MCf=fN)appendgetattrAttributeError)r?r@ non_stubsstubsrIs rLpartition_attributes_and_stubsrUZsXI E    WR. /    LL  s,A  A rTcdSRU5n[SURSU3[SS9 g)NrCrDz6 does not have the following dtypes in its namespace:  stacklevel)rGrrHr)r?rTf_stubss rLwarn_on_missing_dtypesr[hs8iiG  }%$$+9 .  api_versiondtypec /nURnX$:Xa[$[U[5upVX%;a[ $[U[ 5upxUb X';a[$URU5 URU5 US:a.[U[5upX);a[$URU 5 [U5S:a [X5 [SUSUR35e![a URS5 Nf=f)zReturns builtin type which can have values that are castable to the given dtype, according to :xp-ref:`type promotion rules `. For floating dtypes we always return ``float``, even though ``int`` is also castable. r=r+rdtype=z not recognised in )r=rRrPrU ALL_INT_NAMESint FLOAT_NAMESfloatextend COMPLEX_NAMEScomplexrFr[rrH) r?r]r^rT bool_dtype int_dtypes int_stubs float_dtypes float_stubscomplex_dtypes complex_stubss rLfind_castable_builtin_for_dtyperors EWW  K  ;2}MJ  >r; OL  U2  LL LLY(F  ) %  "N ]# 5zA~r) F5')S'Ub@[#US5 [U[$5(deU "SXM5 Ub [X4SS5 XNS'UbX~S 'OO['[U R(5U R*S 9n[ UR-UTS 9S :H5nU(aS US 'UbX^S'UbXnS'UbXS'U bXS'[ R."SSU R*0UD6$UR!T5n Ucp['[U R(5U R*S 9nUR-[1X5TS 9n[1U5nUR2S :g=(a UR4S :gn[ R6"UUUU R*S-S9$)aReturn a strategy for any value of the given dtype. Values generated are of the Python scalar which is :xp-ref:`promotable ` to ``dtype``, where the values do not exceed its bounds. * ``dtype`` may be a dtype object or the string name of a :xp-ref:`valid dtype `. Compatible ``**kwargs`` are passed to the inferred strategy function for integers and floats. This allows you to customise the min and max values, and exclude non-finite numbers. This is particularly useful when kwargs are passed through from :func:`arrays()`, as it seamlessly handles the ``width`` or other representable bounds for you. iinfofinfoc >US3n[X5 [XR:STSUSUSUR35 [XR:*STSUSUSUR35 g)N_valuer`z requires =z to be at least z to be at most )r%rminmax)prefixvalinfo_objrpr^s rLcheck_valid_minmax'_from_dtype..check_valid_minmaxs~ #$ << UG:dV1SE1A(,, P   << UG:dV1SE O r\rxryrr)rxryr|)widthr^rFrzr{r}r~r)rzr{r|r)rM isinstancestrrvror=stbooleansrbrrrr&r'integersrdrr%rr"smallest_normalbitsasarrayfloatsrgrealimagcomplex_numbers)r?r]r^rxryrzr{r|r}r~builtinrrrkw subnormalftzx builtin_xs ` rL _from_dtypers:Wg./%E*-buEG  ${{} C   I   II{3I{3)S)))))S))))5)35)3Y; L{{YDD E    i 5i.. .. ui 7'{O  i 5i.. .. ui 7$$Y; T'{O  &$3 !!%(=(=">ejjQIrzz)5z9Q>?C(-$%  '{O  %#1  " +}   " +} yy0uzz0R00  "!%(=(=">ejjQI 798 FA I'nn1Iinn6IO!!)+**q.   r\c4^\rSrSrU4SjrSrSrSrU=r$) ArrayStrategyi3c8>[TU]5 XlX0lX@lXPlX`lXpl[R"U5Ul [XU5Ul UR[LaSUlgURUR5UlgrO)super__init__r?elements_strategyr^shapefilluniquemathprod array_sizerorrdr) selfr?r]rr^rrr __class__s rLrArrayStrategy.__init__4sr !2    ))E*6rN !\\6T BHHTZZ'ArrayStrategy.do_draw..ws1::r\)keyztype ztypes zGenerated elements rz* could not be converted to array of dtype z. Consider if elements of z are compatible with .Tg? )rr average_sizez'chose an array index we've already usedz#chose an element we've already usedFz xp.asarray(z, dtype=rrzCould not create array via rDz did not recognise fill value z as NaN - instead got z/. Cannot fill unique array with non-NaN values.)%rr?zerosr^ris_emptydrawrlistsrrrrrrFrtuplesortedtyperrangercumanyrrrsqrtsetmore draw_integerrejectadd enumerateisnanrHreshape)rdataelemsresultrtf_elemstypesf_typesifill_val_ result_obj fill_maskelementsassignedseenrf_exprrs rLdo_drawArrayStrategy.do_draw]s  ?77==4::=> > 99   II**!__!__;; E jjA"4??+$$UXvy$:P:PQ,yy+H,1$//,BC,Bq(,BJC',T__'=>'=!'=I>ww!$//)DIIdoo67 HuH5D--//%%a1)<==OO$MNii 6 67;;d{ (MN HHSM #  Q$ --//  U::F $J/3%%-L0FvjQLL1((fd6L6LM0wwvzz22_ u:?!%jG !%(2eAhZwuRykERTI;VWXGU3UDGU39MN14E aE%(,veWEU%)'/--./))- 5//6i8++/::,a 9   4D>H U&zl(4::,aH%(CF8&LMSTT UsJ)#N= Q-! Q26#Q7 Q*%AQ%)O?>A'Q%%Q*7 R("R##R() rrr^rrrrrr?) rH __module__ __qualname____firstlineno__rrr__static_attributes__ __classcell__)rs@rLrr3s Q6c3c3r\rFrrrrrrrc l^^^^^^^[T/SQ5 [T[R5(aTR UUUUUU4Sj5$[T[ 5(a [ TT5m[T[R5(aTR UUUUUU4Sj5$[T[5(aT4mO$[T[5(d[STS35e[[ST55ST<S35 Tc[TTT5mO#[T[5(a[TTT40TD6m[TS5 TcQ[T[R5(deT(dTR(d[R "5mOTm[TS 5 [#TTTTTTTS 9$) a Returns a strategy for :xp-ref:`arrays `. * ``dtype`` may be a :xp-ref:`valid dtype ` object or name, or a strategy that generates such values. * ``shape`` may be an integer >= 0, a tuple of such integers, or a strategy that generates such values. * ``elements`` is a strategy for values to put in the array. If ``None`` then a suitable value will be inferred based on the dtype, which may give any legal value (including e.g. NaN for floats). If a mapping, it will be passed as ``**kwargs`` to :func:`from_dtype()` when inferring based on the dtype. * ``fill`` is a strategy that may be used to generate a single background value for the array. If ``None``, a suitable default will be inferred based on the other arguments. If set to :func:`~hypothesis.strategies.nothing` then filling behaviour will be disabled entirely and every element will be generated independently. * ``unique`` specifies if the elements of the array should all be distinct from one another; if fill is also set, the only valid values for fill to return are NaN values. Arrays of specified ``dtype`` and ``shape`` are generated for example like this: .. code-block:: pycon >>> from numpy import array_api as xp >>> xps.arrays(xp, xp.int8, (2, 3)).example() Array([[-8, 6, 3], [-6, 4, 6]], dtype=int8) Specifying element boundaries by a :obj:`python:dict` of the kwargs to pass to :func:`from_dtype` will ensure ``dtype`` bounds will be respected. .. code-block:: pycon >>> xps.arrays(xp, xp.int8, 3, elements={"min_value": 10}).example() Array([125, 13, 79], dtype=int8) .. code-block:: pycon >>> xps.arrays(xp, xp.float32, 3, elements=floats(0, 1, width=32)).example() Array([ 0.88974794, 0.77387938, 0.1977879 ], dtype=float32) Array values are generated in two parts: 1. A single value is drawn from the fill strategy and is used to create a filled array. 2. Some subset of the coordinates of the array are populated with a value drawn from the elements strategy (or its inferred form). You can set ``fill`` to :func:`~hypothesis.strategies.nothing` if you want to disable this behaviour and draw a value for every element. By default ``arrays`` will attempt to infer the correct fill behaviour: if ``unique`` is also ``True``, no filling will occur. Otherwise, if it looks safe to reuse the values of elements across multiple coordinates (this will be the case for any inferred strategy, and for most of the builtins, but is not the case for mutable values or strategies built with flatmap, map, composite, etc.) then it will use the elements strategy as the fill, else it will default to having no fill. Having a fill helps Hypothesis craft high quality examples, but its main importance is when the array generated is large: Hypothesis is primarily designed around testing small examples. If you have arrays with hundreds or more elements, having a fill value is essential if you want your tests to run in reasonable time. )rrrallrisfiniterc ">[TTUTTTTS9$Nr_arrays)dr]rrrrr?s rLr_arrays..sgKEH4PVr\c ">[TTTUTTTS9$rr)sr]r^rrrr?s rLrrsgKH4PVr\shape=z! is not a valid shape or strategyc3Z# UH!n[U[5=(a US:v M# g7frNrrb.0rs rL _arrays..'# 95aJq#  )16 )5)+3, but all dimensions must be non-negative integers.rr)r?r]rr^rrr)rMrrSearchStrategyflatmaprrvrbrrrrrrr(has_reusable_valuesnothingr)r?r]r^rrrrs```````rLrrsX P%**++}}    E3  E*%**++}}    E3   u % %ug-NOPP 95 99 5(EF r;6 Hg & &r;BB8Z( |(B$5$56666 55::` objects.)rone_of_boolean_dtypes_numeric_dtypes)r?r]s rL_scalar_dtypesrQs 99_R(/"*J KKr\c[R"UR5$![a [ SUR S35Sef=f)z4Return a strategy for just the boolean dtype object.rDz, does not have a bool dtype in its namespaceN)rjustr=rRrrHr?s rLrrVsJwwrww BKK=(T U  s "%Ach[R"[U5[U5[ U55$)z4Return a strategy for all real-valued dtype objects.)rr_integer_dtypes_unsigned_integer_dtypes_floating_dtypesrs rL _real_dtypesr`s+ 99 $ r\cD[U5nUS:aU[U5-nU$)z0Return a strategy for all numeric dtype objects.r+)r_complex_dtypes)r?r]strats rLrris**6b)9EY $$ Lr\categorysizes valid_sizesc [[U5S:S5 UVs/sH o3U;dM UPM nnSRSU55nSRSU55n[[U5S:HSUSUSUS 35 gs snf) NrzNo sizes passedrCc38# UHn[U5v M g7frOrrrs rLr$check_valid_sizes..zs:kc!ffkc38# UHn[U5v M g7frOr(r)s rLrr*{s> 1A r+z&The following sizes are not valid for z dtypes: z (valid sizes: rr)rrFrG)r#r$r%r invalid_sizes f_valid_sizesf_invalid_sizess rLcheck_valid_sizesr0ss3u:>#45 %>1+)=QM>II:k::Mii> >>O Ma 0 )  ?=/ <?s BB base_namec#.# UH nUU3v M g7frOr)r1r$sizes rLnumeric_dtype_namesr4s D6""s @IntSizer8r9FltSizer9CpxSizer$c[U[5(aU4n[SUS5 [U[ SU55up#[ XU5 [ R"U5$)zReturn a strategy for signed integer dtype objects. ``sizes`` contains the signed integer sizes in bits, defaulting to ``(8, 16, 32, 64)`` which covers all valid sizes. rbr5rrbr0rUr4rr sampled_fromr?r$rrTs rLrrsX%eUO42 u -MFU# ??6 ""r\c[U[5(aU4n[SUS5 [U[ SU55up#[ XU5 [ R"U5$)zReturn a strategy for unsigned integer dtype objects. ``sizes`` contains the unsigned integer sizes in bits, defaulting to ``(8, 16, 32, 64)`` which covers all valid sizes. rbr5uintrBrDs rLrrsX%eUO42  .MFU# ??6 ""r\c[U[5(aU4n[SUS5 [U[ SU55up#[ XU5 [ R"U5$)zReturn a strategy for real-valued floating-point dtype objects. ``sizes`` contains the floating-point sizes in bits, defaulting to ``(32, 64)`` which covers all valid sizes. rbr;rdrBrDs rLrrsX%eUH-2  /MFU# ??6 ""r\c[U[5(aU4n[SUS5 [U[ SU55up#[ XU5 [ R"U5$)zReturn a strategy for complex dtype objects. ``sizes`` contains the complex sizes in bits, defaulting to ``(64, 128)`` which covers all valid sizes. rgr=rBrDs rLr!r!sX%i 22  5 1MFU# ??6 ""r\c[U0UD6$rO)_valid_tuple_axes)argskwargss rLrrs d -f --r\z Return a strategy for permissible tuple-values for the ``axis`` argument in Array API sequential methods e.g. ``sum``, given the specified dimensionality. z rr) base_shapemin_dimsmax_dimsmin_sidemax_side num_shapesrMrNrOrPrQc [UUUUUUS9$)NrRrMrNrOrPrQ)_mutually_broadcastable_shapesrTs rLrrs# *  r\T)rNrO allow_newaxisallow_ellipsisrVrWc [[US5 [[SU55SU<S35 [[US5 [[US5 [[ US5 U(d)[U[ U5:*SUS [ U5S 3S 5 [US5 UcGU(a'[[[ U5U5S -[5nO[[ U5[5n[[ US 5 [U[ 5(deU(d)[U[ U5:*SUS [ U5S 3S 5 [US 5 [SSX5 [UUUUUSS9$)a0Return a strategy for :xp-ref:`valid indices ` of arrays with the specified shape, which may include dimensions of size zero. It generates tuples containing some mix of integers, :obj:`python:slice` objects, ``...`` (an ``Ellipsis``), and ``None``. When a length-one tuple would be generated, this strategy may instead return the element which will index the first axis, e.g. ``5`` instead of ``(5,)``. * ``shape`` is the shape of the array that will be indexed, as a tuple of integers >= 0. This must be at least two-dimensional for a tuple to be a valid index; for one-dimensional arrays use :func:`~hypothesis.strategies.slices` instead. * ``min_dims`` is the minimum dimensionality of the resulting array from use of the generated index. * ``max_dims`` is the maximum dimensionality of the resulting array, defaulting to ``len(shape) if not allow_newaxis else max(len(shape), min_dims) + 2``. * ``allow_ellipsis`` specifies whether ``None`` is allowed in the index. * ``allow_ellipsis`` specifies whether ``...`` is allowed in the index. rc3Z# UH!n[U[5=(a US:v M# g7frrrs rLrindices..r r rr rVrWrNz min_dims=z is larger than len(shape)=zC, but it is impossible for an indexing operation to add dimensions zwhen allow_newaxis=False.rrOz max_dims=dimsrF)rNrOrWrVallow_fewer_indices_than_dims)r$rrrr=rbrFrrrrrrr)rrNrOrVrWs rLindicesr]sc:ueW% 95 99 5(EFt]O4t^%56sHj)  E "z!Ul[@R>Ul[BR>Ul[DR>Ul[FR>U l[HR>U l[JR>U l[LR>U l[NR>U l"U4S0jS1[P5n0S2TR_S3T_S4U_S5U_S6[R_S7U_S8U_S9U _S:U _S;U _S[T_S?[V_S@[X_SA[Z_nTSB:a^[!5SCS*.S+[\[8[\-S[*R,["4U4SDjjj5n[^R>UlUUSE'U"SF0UD6nU[TT4'U$![a U$f=f)Ga/Creates a strategies namespace for the given array module. * ``xp`` is the Array API library to automatically pass to the namespaced methods. * ``api_version`` is the version of the Array API which the returned strategies namespace should conform to. If ``None``, the latest API version which ``xp`` supports will be inferred from ``xp.__array_api_version__``. If a version string in the ``YYYY.MM`` format, the strategies namespace will conform to that version if supported. A :obj:`python:types.SimpleNamespace` is returned which contains all the strategy methods in this module but without requiring the ``xp`` argument. Creating and using a strategies namespace for NumPy's Array API implementation would go like this: .. code-block:: pycon >>> xp.__array_api_version__ # xp is your desired array library '2021.12' >>> xps = make_strategies_namespace(xp) >>> xps.api_version '2021.12' >>> x = xps.arrays(xp.int8, (2, 3)).example() >>> x Array([[-8, 6, 3], [-6, 4, 6]], dtype=int8) >>> x.__array_namespace__() is xp True zIf the standard version you want is not available, please ensure you're using the latest version of Hypothesis, then open an issue if one doesn't already exist.N__array_api_version__rDzf has no attribute __array_api_version__, which is required when inferring api_version. If you believe zF is indeed an Array API module, try explicitly passing an api_version.zxp.__array_api_version__=z(, but it must be a valid version string z. Tz api_version=z4, but it must be None, or a valid version string in Frz#Could not determine whether module z is an Array API libraryrrX)force_reusable_valuesrwr^rxryrzr{r|r}r~rAc (>[T TUUUUUUUUS9 $)Nrw)r) r^rxryrzr{r|r}r~r]r?s rL from_dtype-make_strategies_namespace..from_dtypes0   )+##  r\rrrrrc ">[TTUUUUUS9$rr)r^rrrrr]r?s rLarrays)make_strategies_namespace..arrayss'      r\c>[TT5$rO)rr]r?srL scalar_dtypes0make_strategies_namespace..scalar_dtypessb+..r\c>[T5$rO)rrsrLboolean_dtypes1make_strategies_namespace..boolean_dtypessr""r\c>[T5$rO)rrsrL real_dtypes.make_strategies_namespace..real_dtypessBr\c>[TT5$rO)rrisrLnumeric_dtypes1make_strategies_namespace..numeric_dtypessr;//r\r5r@r$c>[TUS9$Nr@)rr$r?s rLinteger_dtypes1make_strategies_namespace..integer_dtypessr//r\c>[TUS9$rv)rrws rLunsigned_integer_dtypes:make_strategies_namespace..unsigned_integer_dtypess(%88r\r;c>[TUS9$rv)rrws rLfloating_dtypes2make_strategies_namespace..floating_dtypess %00r\cF>^\rSrSrU4Sjr\S5rU4SjrSrU=r $)6make_strategies_namespace..StrategiesNamespaceic`>SHnX!;dM [SUS35e [TU]"S0UD6 g)Nrpr]'z' kwarg requiredr) ValueErrorrr)rrLrIrs rLr?make_strategies_namespace..StrategiesNamespace.__init__s:/%$q.>%?@@0 G  &v &r\cURS$![a,n[SURSURS35UeSnAff=f)NrmzSYou attempted to access 'complex_dtypes', but it is not available for api_version='z' of xp=r)__dict__KeyErrorrRr]rp)rrts rLrmEmake_strategies_namespace..StrategiesNamespace.complex_dtypess` }}%566 $2262B2B1CD))A'  s A'AAc\>URnT(dUSURS3- nSUS3$)Nz, api_version='rzmake_strategies_namespace(rrr)rf_argsinferred_versions rL__repr__?make_strategies_namespace..StrategiesNamespace.__repr__s8YYF#OD,<,<+=Q??/xq9 9r\r) rHrrrrpropertyrmrrr)rrs@rLStrategiesNamespacers& '     : :r\rrpr]rcrfrrjrmrprsrxr{r~rrrr]r+r=c>[TUS9$rv)r!rws rLrm1make_strategies_namespace..complex_dtypess#2U3 3r\rmr)0rrErHrr`rRELEASED_VERSIONSNOMINAL_VERSIONSr__array_namespace__rrrr^r TypeErrorr)r>rbrdr=rr rgrrr r:rr<r__doc__rrrrrrrrrrrrrr]r?r!)r?r]not_available_msgarray namespacercrfrjrmrprsrxr{r~rrLrmrs`` @rLr*r*JsrB %  B/ 0BKK=)L{{m& &   r// 5 >((,==(r'')*)):(;2>O=P R ..  {C ( L[V W    i    D1)-(,!%&*'+#'#' #~ ;% ;%  $;  t   D[ D[   4#:-7 8  2 0D1 BF.2  #~ 1 1( ;;b>O>OPS>TT U{R..u55 #s(#b&7&77$>  $t+        2 $/2,,X6//#B--h7## **84  0B--h7000?0HW--0  8 $00 0?9HW--9  8 $99 081HW--1  8 $11 %,,J__FN*22M,44N&..K,44N,44N&>&F&F#.66O:o:0 { j &      . { . . "#: ? ,  4 ()F 7!F&Y  4= 4 11 4   x ( 4  4 "1!8!8#1 #-f-I *3 b+&'     s6!D < D6 'D32D36E E  W W*)W*sphinx)MockcH\rSrSr%\\S'\\S'\\S'\\S'\\S'Srg) FloatInfoi:repsrrrrN)rHrrrrb__annotations__rdrrr\rLrr:s    r\rc  [R"U5n[[UR5[ UR 5[ UR5[ UR5[ UR55$)aReturns a finfo object compliant with the Array API Ensures all attributes are Python scalars and not NumPy scalars. This lets us ignore corner cases with how NumPy scalars operate, such as NumPy floats breaking our next_down() util. Also ensures the finfo obj has the smallest_normal attribute. NumPy only introduced it in v1.21.1, so we just use the equivalent tiny attribute to keep mocking with older versions working. ) nprrrbrrdrrrtiny)r^_finfos rL mock_finforAsZ%   &**  &**  &**  &++    r\rHmockr`r,r1r2r3r4r5r6r7r8r9r:r;r<nanastypec$URU5$rO)r)rrs rLrris AHHQKr\rrbroadcast_arraysarangeremptyronesrrr logical_orsumnonzerosort unique_valuesanyr)rsyscollections.abcrrrrnumbersrrrtypingr r r r r rwarningsrweakrefr hypothesisrrhypothesis.errorsrrhypothesis.extra._array_helpersrrrrrrrrrrrUrrrJhypothesis.internal.conjecturer rhypothesis.internal.coverager!hypothesis.internal.floatsr"hypothesis.internal.reflectionr#hypothesis.internal.validationr$r%r&r'*hypothesis.strategies._internal.strategiesr(%hypothesis.strategies._internal.utilsr)__all__rrrlistNominalVersion INT_NAMES UINT_NAMESrarc REAL_NAMESrf NUMERIC_NAMESrsr>rrMrrUr[rr=rbrdrgrorvr rrrrrrrrr0r4r:rr<r?rrrr!rr]r^r*numpyr ImportErrormodules unittest.mockrrrr1r2r3r4r5r6r7r8r9r:r;r<bool_rrrrrrrrrrrrrrrrrrmock_xprr\rLrs  AA!''@    7702 FB   L0&00 4(8#9999WX#3333 0 4 J& $ [ ( + ]* & & :  C T#Y 4     !#  49d3i   s49*L *L(*L19*L $*u w &'*LZ    3  3    (%)$(!"&#'##A  A A  c>A U{T! A U{T! A d{A 4KA D[A A A tczE)G34A HM3B%%M3l>B*.~ ~~ c>B--h7 7":K:KC:P P~ ;**51 1 ~ c3h""3"33d: ~  C 4 '~ ~~B *S *$x. *c *t * *LsLLBsm    #3#x}### ]++V_$W%%6E# #'!22#x #&6E# #'!22#x #*6># #'!22#x #&6?# #'!22#x #$ ..      Dj   Dj*+&)G(N(N% F FFDj F  F  Fz"FFT%8$9 !96:a a+d2aaH >J ( y (//'/WW / hh / hh /hh/hh/yy/yy/yy/ / /,,/==/ XX!/$ FF%/(()/*hh+/,-/.,,//2yy3/4 5/6hh7/8hh9/:WW;/> ?/BhhC/DE/F==G/J FFK/N O/RWWS/ViiW/Z FF[/\ FF]/G;3;;& V sX#YYY