iKjL UddlZddlZddlmZmZmZmZddlmZddl m Z ddl m Z m Z mZmZmZmZmZddlmZddlmZddlmZdd lmZmZdd lmZmZm Z m!Z!m"Z"m#Z#m$Z$m%Z%m&Z&m'Z(m)Z)m*Z+dd l,m-Z.dd l/m0Z0dd l1m2Z2ddl3m4Z4ddl5m6Z6m7Z7m8Z8m9Z9ddl:m;Z;ddldZ?ge?dZ@eAe@eBe@k(sJe dZCeeCe@k(sJdZDdZEeDeEzZFdZGeFeGzZHdZIeHeIzZJdgeJZKedZLe0de deBeMddfdZNde deeMdeOeBe eBeMffd ZPde d!eBeMddfd"ZQde d#eCd$eLdeReSeTzeUzeVzfd%ZWe0de d&eMde fd'ZXdddddddd(de d#eCd$eLeMzd)eTeUzdzd*eTeUzdzd+eSdzd,eSdzd-eSdzd.eSdzd/eSdzdejeSeTzeUzeVzfd0ZZGd1d2ejZ[ddd3d4de d#eCd$eLeMzejeLzejeMzd5eTe"zeje"zd6eeMe fejzdzd7eje dzd8eSdejfd9Z\e0de d:eBeLd!eBeMddfd;Z]de d#eCdejeLfd<Z^de dejeLfd=Z_de dejeLfd>Z`de d#eCdejeLfd?Zae0d@eMdAeeTdBeeTddfdCZbdDeMdAeeTdeeMfdEZce dFZdeeedG<e dHZfeeedI<e dJZgeeedK<dFdLde dAedeedzdejeLfdMZhdFdLde dAedeedzdejeLfdNZidHdLde dAefeefzdejeLfdOZjdJdLde dAegeegzdejeLfdPZke4e+dQZ*dRe+jdSe*_le=dTdddUddVdWeTdXe"dYeTdZeTdzd[eTd\eTdzdeje!fd]Z'e(je'_le=ddd3d^d_d5e"dYeTdZeTdzd`eSdaeSdejef dbZmeZneeedc<dddde d#eCdzde fdeZo ddlpZqeqGdhdieZvd$eLdevfdjZwe dTidkdldmdndoeqjdpeqjdqeqjdreqjdseqjdteqjdueqjdveqjdweqjdxeqjdyeqjdzeqjdeqjd{eqj d|d}d~eqj dewdeqjdeqjdeqjdeqjdeqjdeqjdeqjdeqjdeqjdeqj deqj"deqj$deqj&deqj(deqj*deqj,Zyy#er$r"dfejvrddgltmuZueuZqndZqYwxYw)N)IterableIteratorMappingSequence)Real)SimpleNamespace)AnyLiteral NamedTuple TypeAliasTypeVarcastget_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/r0r1)int8int16int32int64)uint8uint16uint32uint64)float32float64) complex64 complex128boolDataTypexp attributesreturnc|Dcgc]}t||r|}}t|dkDr,dj|}td|jd|ycc}w)Nr, Array module z$ does not have required attributes: )hasattrlenjoinr__name__)r@rAattr missing_attrsf_attrss _/home/oem/CyberBrain26-unified/.venv/lib/python3.12/site-packages/hypothesis/extra/array_api.pycheck_xp_attributesrNQsf&0JdD8ITJMJ =A))M*BKK=(LWI V  Ks AAcg}g}|D]} |jt|| ||fS#t$r|j|YAwxYwN)appendgetattrAttributeError)r@rA non_stubsstubsrJs rMpartition_attributes_and_stubsrV[saI E    WR. / e   LL  s,A A rUcjdj|}td|jd|tdy)NrDrEz6 does not have the following dtypes in its namespace:  stacklevel)rHrrIr)r@rUf_stubss rMwarn_on_missing_dtypesr\is8iiG  }%$$+9 .  api_versiondtypecg} |j}||k(rtS t|t\}}||vrt St|t \}}| ||vrtS|j||j||dkDr.t|t\} } || vrtS|j| t|dkDr t||td|d|j#t$r|jdYwxYw)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>rSrQrV ALL_INT_NAMESint FLOAT_NAMESfloatextend COMPLEX_NAMEScomplexrGr\rrI) r@r^r_rU bool_dtype int_dtypes int_stubs float_dtypes float_stubscomplex_dtypes complex_stubss rMfind_castable_builtin_for_dtyperpss  EWW J K  ;2}MJ   >r; OL+  Ul2  LL LLY(F  ) %  N "N ]# 5zA~r5) F5')C?namec|tvr t||Sdj t}t|d|d#t$r"}td|jd|d|d}~wwxYw)NrEz does not have dtype z in its namespacerDz0 is not a valid Array API data type (pick from: )) DTYPE_NAMESrRrSrrIrH)r@rqef_valid_dtypess rMdtype_from_namerws { 2t$ $ ;/fD^DTTU V   ! },A$GXY  s < A'A""A' min_value max_value allow_nanallow_infinityallow_subnormal exclude_min exclude_maxryrzr{r|r}r~rct|ddgttr t|t ||} fd} | t urt jS| tur|j} | | j}| | j}t|dt|dt|tsJt|tsJ| d|| | d|| t||ddt j||S| tur|j!} i}|-t#|dt|t$sJ| d|| ||d<|=t#|dt|t$sJ| d|| |t||dd||d<|||d <nPt't| j(| j* }t |j-| d k(}|rd |d <|||d<|||d<|||d<| | |d<t j.dd| j*i|S|j!} |rt't| j(| j* }|j-t1|| }t1|}|j2d k7xr|j4d k7}t j6|||| j*dzS)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 |d}t||t||jk\dd|d|d|jt||jkdd|d|d|jy)N_valueraz requires =z to be at least z to be at most )r&rminmax)prefixvalinfo_objrqr_s rMcheck_valid_minmaxz'_from_dtype..check_valid_minmaxs #t$ 8<< UG:dV1SE1A(,, P   8<< UG:dV1SE O r]ryrzrr)ryrzr})widthr_rFr{r|r~rr)r{r|r}r)rN isinstancestrrwrpr>stbooleansrcrrrr'r(integersrerr&rr#smallest_normalbitsasarrayfloatsrhrealimagcomplex_numbers)r@r^r_ryrzr{r|r}r~rbuiltinrrrkw subnormalftzx builtin_xs ` rM _from_dtypers:Wg./%E*-b+uEG  ${{} C   I   II{3I{3)S))))S)))5)U35)U3Y ; L{{Y)DD E   i 5i. .. ui 7'B{O  i 5i. .. ui 7$$Y ; T'B{O  &$3B !!%(=(=">ejjQIrzz)5z9Q>?C(-$%  'B{O  %#1B  " +B}   " +B} yy0uzz0R00  "!%(=(=">ejjQI 79i8 FA I'nn1Iinn6IO!!)+**q.   r]c*eZdZfdZdZdZxZS) ArrayStrategycBt|||_||_||_||_||_||_tj||_ t||||_ |jturd|_y|j|j|_yrP)super__init__r@elements_strategyr_shapefilluniquemathprod array_sizerprrer) selfr@r^rr_rrr __class__s rMrzArrayStrategy.__init__5s !2    ))E*6r;N !\\6T BHHTZZz'ArrayStrategy.do_draw..xs 1::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=rszCould not create array via rEz did not recognise fill value z as NaN - instead got z/. Cannot fill unique array with non-NaN values.)$rr@zerosr_ris_emptydrawrlistsrrrrrrGrtuplesortedtyperrangersetcumanyrrrsqrt draw_integerrejectadd enumerateisnanrIreshape)rdataelemsresultruf_elemstypesf_typesifill_val_ result_obj fill_maskassignedseenelementsrf_exprrs rMdo_drawzArrayStrategy.do_draw^s9  ?77==4::=> > 99   II**!__!__;; E djjA"4??+ R$$U1Xvay$:P:PQ Ryy+H,1$//,BCq(CJC',T__'=>!>I>uH5D!$//)DIIdoo67  )!)A))!T__q-@AAH} (QR ))D$:$:;C{{$;$OO,QR$ $'JqMLLO#(IaL) )8 U4::F $J/ N3Q%%-L0FvjQLL ((fd6L6LM Nwwvtzz22[ u:?!%jG !%(2eAhZwuRykERTI;VWXGU3DG339MN14E aE%(,veWEU%)'/--./))- 5//6i8++/::,a 9   4D> ) )< U&zl(4::,aH%(CF8&LMSTT UsW''M)? P8! P=!B&Q'Q) P52AP05OA)P00P5Q  Q?"Q::Q?)rI __module__ __qualname__rrr __classcell__)rs@rMrr4s Q6a3r]rFrrrrrrrc  tgdttjrj fdStt r t ttjrj fdSttrfnttstddttdDddtnttrtfitdAttjsJs jstj ntd t# S) 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 (t|SNr_arrays)dr^rrrrr@s rMrz_arrays..sgKEH4PVr]c (t|Srr)sr^r_rrrr@s rMrz_arrays..sgKH4PVr]shape=z! is not a valid shape or strategyc3JK|]}t|txr|dk\ywrNrrc.0rs rM z_arrays..&# 9aJq#  )16 ) 9!#3, but all dimensions must be non-negative integers.rr)r@r^rr_rrr)rNrrSearchStrategyflatmaprrwrcrrrrrrr)has_reusable_valuesnothingr)r@r^r_rrrrs```````rMrrsxX P%**+}}    E3 E*%**+}}    E3  u %ug-NOPP 95 99 5(EF r;6 Hg &r;BB8Z( |(B$5$5666 55::` objects.)rone_of_boolean_dtypes_numeric_dtypes)r@r^s rM_scalar_dtypesrPs 99_R(/"k*J KKr]c tj|jS#t$rt d|j ddwxYw)z4Return a strategy for just the boolean dtype object.rEz, does not have a bool dtype in its namespaceN)rjustr>rSrrIr@s rMr r UsJwwrww BKK=(T U  s !$Acftjt|t|t |S)z4Return a strategy for all real-valued dtype objects.)rr _integer_dtypes_unsigned_integer_dtypes_floating_dtypesrs rM _real_dtypesr_s+ 99 $ r]cBt|}|dkDr|t|z}|S)z0Return a strategy for all numeric dtype objects.r,)r_complex_dtypes)r@r^strats rMr r hs**6b)9EY $$ Lr]categorysizes valid_sizesc  tt|dkDd|Dcgc] }||vs| }}djd|D}djd|D}tt|dk(d|d|d|d ycc}w) NrzNo sizes passedrDc32K|]}t|ywrPrrrs rMrz$check_valid_sizes..ys:c!f:c32K|]}t|ywrPrr s rMrz$check_valid_sizes..zs>1A>r!z&The following sizes are not valid for z dtypes: z (valid sizes: rs)rrGrH)rrrr invalid_sizes f_valid_sizesf_invalid_sizess rMcheck_valid_sizesr&rs3u:>#45 %>1+)=Q>M>II:k::Mii> >>O Ma 0 )  ?=/ <?s BB base_namec#*K|D] }|| ywrPr)r'rsizes rMnumeric_dtype_namesr*s$# D6""#s @IntSizer.r/FltSizer/CpxSizerct|tr|f}td|dt|t d|\}}t |||t j|S)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. rcr+rrcr&rVr*r r sampled_fromr@rrrUs rMrrsY%eUO42 u -MFEVU# ??6 ""r]ct|tr|f}td|dt|t d|\}}t |||t j|S)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. rcr+uintr8r:s rMrrsY%eUO42  .MFEVU# ??6 ""r]ct|tr|f}td|dt|t d|\}}t |||t j|S)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. rcr1rer8r:s rMrrsY%eUH-2  /MFEVU# ??6 ""r]ct|tr|f}td|dt|t d|\}}t |||t j|S)zReturn a strategy for complex dtype objects. ``sizes`` contains the complex sizes in bits, defaulting to ``(64, 128)`` which covers all valid sizes. rhr3r8r:s rMrrsY%i 22  5 1MFEVU# ??6 ""r]ct|i|SrP)_valid_tuple_axes)argskwargss rMr r s 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_shapesrCrDrErFrGc$t||||||S)NrHrCrDrErFrG)_mutually_broadcastable_shapesrJs rMrrs# *  r]T)rDrE allow_newaxisallow_ellipsisrLrMc tt|dttd|Dd|dtt|dtt|dtt |d|s)t|t |kd|d t |d d t|d|B|r'ttt ||d zt}ntt |t}tt |d t|t sJ|s)t|t |kd|d t |d d t|d tdd||t|||||dS)atReturn 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. rc3JK|]}t|txr|dk\ywrrrs rMrzindices..rrrrrLrMrDz min_dims=z is larger than len(shape)=zC, but it is impossible for an indexing operation to add dimensions zwhen allow_newaxis=False.rrEz max_dims=dimsrF)rDrErMrLallow_fewer_indices_than_dims)r%rrrr>rcrGrrrrrrr)rrDrErLrMs rMindicesrRsb:ueW% 95 99 5(EFt]O4t^%56sHj)  E "z!t<t>zdt.j0t&ffd/} t@jB|_!tDjB|_!tFjB|_!tHjB|_!tJjB| _!tLjB| _!tNjB| _!tPjB| _!tRjB| _!Gfd0d1tT}id2jd3d4|d5|d6tVd7|d8|d9| d:| d;| d<| d=| d>tXd?tZd@t\dAt^}dBkDr[t%dCd*d+t`t<t`zdt.j0t&ffdD}tbjB|_!||dE<|dFi|} |tf<|S#t"$rY|SwxYw)GaCreates 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__rEzf 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 libraryrrY)force_reusable_valuesrxr_ryrzr{r|r}r~rrBc .t |||||||| S)Nrx)r) r_ryrzr{r|r}r~rr^r@s rM from_dtypez-make_strategies_namespace..from_dtypes0   )+##  r]rrrrrc (t|||||Srr)r_rrrrr^r@s rMarraysz)make_strategies_namespace..arrayss'      r]ctSrP)rr^r@srM scalar_dtypesz0make_strategies_namespace..scalar_dtypessb+..r]ctSrP)r rsrMboolean_dtypesz1make_strategies_namespace..boolean_dtypessr""r]ctSrP)rrsrM real_dtypesz.make_strategies_namespace..real_dtypessBr]ctSrP)r r\srMnumeric_dtypesz1make_strategies_namespace..numeric_dtypessr;//r]r+r6rct|SNr6)rrr@s rMinteger_dtypesz1make_strategies_namespace..integer_dtypessr//r]ct|Sre)rrfs rMunsigned_integer_dtypesz:make_strategies_namespace..unsigned_integer_dtypess(%88r]r1ct|Sre)rrfs rMfloating_dtypesz2make_strategies_namespace..floating_dtypess %00r]c:eZdZfdZedZfdZxZS)6make_strategies_namespace..StrategiesNamespacecXdD]}||vstd|dt|di|y)Nrqr^'z' kwarg requiredr) ValueErrorrr)rrBrJrs rMrz?make_strategies_namespace..StrategiesNamespace.__init__sC/ Av%$q.>%?@@ A G  &v &r]c |jdS#t$r,}td|jd|jd|d}~wwxYw)NrnzSYou attempted to access 'complex_dtypes', but it is not available for api_version='z' of xp=r)__dict__KeyErrorrSr^rq)rrus rMrnzEmake_strategies_namespace..StrategiesNamespace.complex_dtypess` }}%566 $2262B2B1CD))A'  s A'AAcR|j}s|d|jdz }d|dS)Nz, api_version='rpzmake_strategies_namespace(rsro)rf_argsinferred_versions rM__repr__z?make_strategies_namespace..StrategiesNamespace.__repr__s8YYF#OD,<,<+=Q??/xq9 9r])rIrrrpropertyrnrxr)rrws@rMStrategiesNamespacerms& '     : :r]rzrqr^rXrZrr]r_rarcrgrirkr rrrRr,r3ct|Sre)rrfs rMrnz1make_strategies_namespace..complex_dtypess#2U3 3r]rnr)2rrFrIrrUrRELEASED_VERSIONSrNominalVersionNOMINAL_VERSIONSr__array_namespace__rrrrSrt TypeErrorr*r?rcrer>rrrhrrr r0rr2r__doc__rrr rr rrrrrr rrrRr5r)r@r^not_available_msgarray namespacerXrZr]r_rarcrgrirkrzrBrnrws`` @rMr+r+IsoB %  B/ 0BKK=)L{{m& &   r// 5 >((,==(r'')*)):(;2>O=P R >2+C+CD  {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; D7)D43D47E E 9 W WWsphinx)Mockc@eZdZUeed<eed<eed<eed<eed<y) FloatInforepsrrrN)rIrrrc__annotations__rerr]rMrr9s    r]rc tj|}tt|jt |j t |jt |jt |jS)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. ) nprrrcrrerrrtiny)r__finfos rM mock_finfor@sZ%   &**  &**  &**  &++    r]rImockrUr-r2r3r4r5r6r7r8r9r:r;r<r=nanastypec$|j|SrP)r)rrs rMrrhsAHHQKr]rrbroadcast_arraysarangeremptyronesrrr logical_orsumnonzerosort unique_valuesanyr)rsyscollections.abcrrrrnumbersrrrtypingr r r r r rrwarningsrweakrefr hypothesisrrhypothesis.errorsrrhypothesis.extra._array_helpersrrrrrrrrrrrKrr r@hypothesis.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__r|r~rlistr} INT_NAMES UINT_NAMESrbrd REAL_NAMESrg NUMERIC_NAMESrtr?rrNrrVr\rr>rcrerhrprwrrrrr rr rr r&r*r0rr2r5rrrrrrRrSr+numpyr ImportErrormodules unittest.mockrrrr2r3r4r5r6r7r8r9r:r;r<r=bool_rrrrrrrrrrrrrrrrrrmock_xprr]rMrs  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 HK3B%%K3h>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 s#W<<#X#"X#