Ti"UdZddlZddlZddlZddlZddlZddlmZmZm Z ddlm Z ddl m Z ddl mZddlmZmZmZddlZddlmZddlmZdd lmZmZmZmZmZ m!Z"m#Z$m%Z&m'Z(m)Z*m+Z,dd l-m.Z.dd l/m0Z0gd Z1ej23d dZ4e5e6ze7d <ej23ddZ8e4e8dZ9eZ:ee7d<e:ej;zZ;ee7d<dee;de e:fdZ d(ddddde;dededdzde6dzdedzd e6d!e6de:fd"Z?dd#d$e:dedzde:fd%Z@e d&ZAe ee7d'<e deded(fd)ZBd[d*ZCd+d+d+d+d,d-ZDd.ZEd+d+d+d+d/dd0d1ZFddd+d+d+d+d/dd2d3ZGd+d+d+d+d/d+dd4d5ZHd\d7ZId]d9ZJd:ede5fd;ZKd$e:dede6fd<ZLdededzfd=ZMddd>dd?d$e:d@eNeOeNzdzdAe6dBeNePzdedzde:f dCZQdd#d$e:dedzde:fdDZRd[dEZSddFdGZTdddHdIZUd[dJe:dedzde:fdKZVdLZWdMZXdNZYejZdOGdPdQZ[ d^dSZ\dTZ]ddRdRddddRdRdd+dU dVZ^ddWdXZ_ddWdYZ`ddWdZZaiZbdS)_a6Utility functions to use Python Array API compatible libraries. For the context about the Array API see: https://data-apis.org/array-api/latest/purpose_and_scope.html The SciPy use case of the Array API is described on the following page: https://data-apis.org/array-api/latest/use_cases.html#use-case-scipy N) GeneratorIterableIterator)contextmanager) ContextVar) ModuleType)AnyLiteral TypeAlias)array_api_compat) is_array_api_obj is_lazy_arraysizenumpydeviceis_numpy_namespaceis_cupy_namespaceis_torch_namespaceis_jax_namespaceis_dask_namespaceis_array_api_strict_namespace)issparse) FunctionDoc)_asarrayarray_namespaceassert_almost_equalassert_array_almost_equal default_xp eager_warnsr is_marrayis_array_api_strict is_complexis_cupyis_jaxis_numpyis_torchSCIPY_ARRAY_API SCIPY_DEVICEscipy_namespace_forxp_assert_closexp_assert_equalxp_assert_lessxp_copy xp_devicexp_ravelxp_sizexp_unsupported_param_msgxp_vector_normxp_capabilitiesxp_result_type xp_promoter'Fr(cpu)r'r(Array ArrayLikearraysreturnc#dK|D]}|t|rd}t|t|tjjrt dt|tjrt dt|tjtj zrX|j }tj |tj s2tj |tj st d|dt|r|V tj|}n#t $rt dwxYw|j }tj |tj s4tj |tj sd|d}t ||jr|VdS) aRaise exceptions on known-bad subclasses. Discard 0-dimensional ArrayLikes and convert 1+-dimensional ArrayLikes to numpy. The following subclasses are not supported and raise and error: - `numpy.ma.MaskedArray` - `numpy.matrix` - NumPy arrays which do not have a boolean or numerical dtype - Any array-like which is neither array API compatible nor coercible by NumPy - Any array-like which is coerced by NumPy to an unsupported dtype NzSparse arrays/matrices are not supported by this function. Perhaps one of the `scipy.sparse.linalg` functions would work instead.z8Inputs of type `numpy.ma.MaskedArray` are not supported.z0Inputs of type `numpy.matrix` are not supported.zAn argument has dtype `z3`; only boolean and numerical dtypes are supported.zCAn argument is neither array API compatible nor coercible by NumPy.z1An argument was coerced to an unsupported dtype `)r ValueError isinstancenpma MaskedArray TypeErrormatrixndarraygenericdtype issubdtypenumberbool_r asanyarrayndim)r9arraymsgrEmessages m/var/www/development/aibuddy-work/election-extract/venv/lib/python3.11/site-packages/scipy/_lib/_array_api.py_compliance_scipyrODs** =  E?? ")CS// ! eRU. / / XVWW W eRY ' ' PNOO O eRZ"*4 5 5 UKEM%33 Ur}UBH7U7U U!T%!T!T!TUUU E " " KKKK 7 e,, 7 7 7!6777 7KEM%33 )r}UBH7U7U )HHHH (((z  U**s D,,ErKxpcx|||sd}t|dS)zCheck for NaNs or Infs.z#array must not contain infs or NaNsN)allisfiniter<)rKrPrLs rN _check_finiterT|s= 66"++e$$ % %3ooctdstStt|}|rt j|StS)a1Get the array API compatible namespace for the arrays xs. Parameters ---------- *arrays : sequence of array_like Arrays used to infer the common namespace. Returns ------- namespace : module Common namespace. Notes ----- Thin wrapper around `array_api_compat.array_namespace`. 1. Check for the global switch: SCIPY_ARRAY_API. This can also be accessed dynamically through ``_GLOBAL_CONFIG['SCIPY_ARRAY_API']``. 2. `_compliance_scipy` raise exceptions on known-bad subclasses. See its definition for more details. When the global switch is False, it defaults to the `numpy` namespace. In that case, there is no compliance check. This is a convenience to ease the adoption. Otherwise, arrays must comply with the new rules. r')_GLOBAL_CONFIG np_compatlistrOr r)r9 api_arrayss rNrrsL4 + ,'//00J=/<< rU)rP check_finitesubokrEorder)KACFcopyr[r\c|t|}t|rO|durtj||||}n|rtj|||}n|tj|||}nd ||||}nJ#t $r=t|d}||||}YnwxYw|rt|||S)a`SciPy-specific replacement for `np.asarray` with `order`, `check_finite`, and `subok`. Memory layout parameter `order` is not exposed in the Array API standard. `order` is only enforced if the input array implementation is NumPy based, otherwise `order` is just silently ignored. `check_finite` is also not a keyword in the array API standard; included here for convenience rather than that having to be a separate function call inside SciPy functions. `subok` is included to allow this function to preserve the behaviour of `np.asanyarray` for NumPy based inputs. NT)r]rEr\)r]rE)rErb)rr%r>rKrIasarrayrArT)rKrEr]rbrPr[r\ coerced_xps rNrrs0 z U # #|| F 4<<HU%uEJJJEE  @M%uEBBBEEJuE???EE FJJuEJ==EE F F F(A77J&&uE&EEEEE F!eR   Ls1B ACCrPxcH|t|}t|d|S)a3 Copies an array. Parameters ---------- x : array xp : array_namespace Returns ------- copy : array Copied array Notes ----- This copy function does not offer all the semantics of `np.copy`, i.e. the `subok` and `order` keywords are not used. NT)rbrP)rrrhrPs rNr-r-s+, z Q   ADR ( ( ((rU _default_xp_default_xp_ctxvar)NNNc#Kt|} dVt|dS#t|wxYw)aIn all ``xp_assert_*`` and ``assert_*`` function calls executed within this context manager, test by default that the array namespace is the provided across all arrays, unless one explicitly passes the ``xp=`` parameter or ``check_namespace=False``. Without this context manager, the default value for `xp` is the namespace for the desired array (the second parameter of the tests). N)rlsetreset)rPtokens rNrrs^  " "2 & &E(   '''''  ''''s >Acddl}d}t|rtjS|||S)z@pytest.warns context manager, but only if x is not a lazy array.rNF)match)pytestr contextlib nullcontextwarns)rh warning_typerrrs__thread_safe__s rNrrsGMMMOQ(%''' << E< 2 22rUTcheck_namespace check_dtype check_shapecheck_0dcd}|: t}n#t$rt|}YnwxYw|rt |||t |r|rdt |dt |}||r||s4||s||r J|||}||}|r,d|j d|j }|j |j ks J||rct|r(| | d|j d|j }|j |j ks J|| ||j }|||fS)NTz$Array-ness does not match: Actual: z Desired: zdtypes do not match. Actual: Desired: zShapes do not match. Actual: )rlget LookupErrorr_assert_matching_namespacer%typeisscalarrerEis_daskcompute_chunk_sizesshape broadcast_to) actualdesiredrPrzr{r|r}__tracebackhide___msgs rN _strict_checkrs z *#''))BB * * * ))BBB *8"67B777||QQ=<<==-1']]==V$$ QW)=)= Q F++ Q46KK4H4H Q QLP Q Q QZZ  Fjj!!G3X XXXX|w},,,d,,,3 2;; *  & & ( ( (  ' ' ) ) )X XXXX|w},,,d,,,oogv|44G 7B s  <<cd}t|}d|jd|j}||ks J|t|}d|jd|j}||ks J|dS)NTzNamespace of desired array does not match expectations set by the `default_xp` context manager or by the `xp`pytest fixture. Desired array's space: z Expected namespace: z=Namespace of actual and desired arrays do not match. Actual: r)r__name__)rrrPrdesired_arr_spaceractual_arr_spaces rNrr;s'00 1'8&@ 1 1$&;  1 1D  " " "D " " "&v.. &'0 & &  & &D r ! ! !4 ! ! ! ! !rU)rzr{r|r}err_msgrPc Jd}t|||||||\}}}t|r|j|||St |r+|dkrdn|}|j||dddd|St j|||S)NTry)rrrFrtolatol equal_nanr{rL)rr#testingassert_array_equalr& assert_closer>) rrrzr{r|r}rrPrs rNr+r+Ms'_[FGR r{{Gz,,VWg,NNN "G"R--$$Wz&&vwQQRV38g'GG G : ( (' ( J JJrU)rrrzr{r|r}rrPc d} t||| ||||\}}} | |jd} |(| r&| |jjdzdz}n|d}t | r| j|||||St| r+|dkrdn|}| j ||||dd | Stj|||||S) NTry real floatingcomplex floating?gHz>)rrrrFr) risdtyperEfinfoepsr#rassert_allcloser&rr>) rrrrrzr{r|r}rrPrfloatings rNr*r*csA''[(FGR zz&,(MNNH ||xx %%)3.2 r{{Wz))&'/3W*FF F "W!R--$$Wz&&vwT155g'WW W : % %fgD+/ & B BBrU)rzr{r|r}rverboserPc d} t|||||||\}}}t|r|j||||St |rH|jjdkr|}|jjdkr|}tj||||S)NTry)rrr6) rr#rassert_array_lessr&rrr6r>) rrrzr{r|r}rrrPrs rNr,r,s'_[FGR r{{$z++FG4;W,NN N "$ =  & &ZZ\\F > % ' 'kkmmG : ' '07 ( J JJrUcDddd| zz}}t||g|R||ddd|SzPBackwards compatible replacement. In new code, use xp_assert_close instead. rg? F)rrr{r|r*rrdecimalargskwdsrrs rNrrWCgX&$D 67 *  * * $4UPU * *$( * **rUcDddd| zz}}t||g|R||ddd|Srrrs rNrrrrUparamcd|dS)Nz Providing z$ is only supported for numpy arrays.)rs rNr1r1s E E E EErUc8||jdS)Nr)rrErjs rNr"r"s ::ag1 2 22rUct|r ddl}|jSt|r ddl}|jSt |r|SdS)aReturn the `scipy`-like namespace of a non-NumPy backend That is, return the namespace corresponding with backend `xp` that contains `scipy` sub-namespaces like `linalg` and `special`. If no such namespace exists, return ``None``. Useful for dispatching. rN)r#cupyxscipyr$jaxr&)rPrrs rNr)r)sZr{{ { bzz y|| 4rU)axiskeepdimsordrPrrrcd|t|n|}trtt|dr|j||||S|dkrt d||||z||dzStj ||||S)Nlinalg)rrrrzonly the Euclidean norm (`ord=2`) is currently supported in `xp_vector_norm` for backends not implementing the `linalg` extension.)rrr)rrr) rr'hasattrr vector_normr<sumconjr>norm)rhrrrrPs rNr2r2s "z   rBH 2x M9((c(RR Raxx !66"''!**q.th6GGL Ly~~aSth~GGGrUcT|t|n|}||dS)N))rreshaperjs rNr/r/s. "z   rB ::a  rUc|t|n|}tt|j}||||c||<||<|||}|SN)rrYrangerJ permute_dims)aaxis1axis2rPaxess rN xp_swapaxesrsa!z   rB af  D#E{DKDKe 4  A HrU)force_floatingcfd|D}d|D}|r|dtr!jdkrd|D}j|S j|S#t$r|sg}|D]i}t j|r|n|}t|d|} |dr||jjg|tRcYSwxYw)a Returns the dtype that results from applying type promotion rules (see Array API Standard Type Promotion Rules) to the arguments. Augments standard `result_type` in a few ways: - There is a `force_floating` argument that ensures that the result type is floating point, even when all args are integer. - When a TypeError is raised (e.g. due to an unsupported promotion) and `force_floating=True`, we define a custom rule: use the result type of the default float and any other floats passed. See https://github.com/scipy/scipy/pull/22695/files#r1997905891 for rationale. - This function accepts array-like iterables, which are immediately converted to the namespace's arrays before result type calculation. Consequently, the result dtype may be different when an argument is `1.` vs `[1.]`. Typically, this function will be called shortly after `array_namespace` on a subset of the arguments passed to `array_namespace`. c`g|]*}tj|rt|dn|+ST)r\rPr>iterabler.0argrPs rN z"xp_result_type.. L   24S1A1A JXc" - - - -s   rUcg|]}||Srrrrs rNrz"xp_result_type.. <<.sD333 '.c61&=&=&B&B333rUrEr) appendr% __version__ result_typerAr>rrerrxp_default_dtype)rrPr args_not_none float_argsr arg_arrayrEs ` rNr4r4s(       D<.;rrU)rrPc>g|]}|t|dn|S)NT)rEr\rP)r)rrrErPs rNrzxp_promote..@sE   ?BoXcdr : : : :SV   rUrrcg|]}||Srrrs rNrzxp_promote..FrrUch|] }|j Sr)rrs rN zxp_promote..Is 1 1 1Cci 1 1 1rUz/Array shapes are incompatible for broadcasting.Nr\T) r4lentupler>broadcast_shapesrr<rr%rrEastype) rrrPrrshapesrerMoutrkwargsrEs ` @rNr5r5)s$       D DB G G GE        D 8d))Q,,tAwwE$KK7<> ! ! ! " 4rUcd|jvS)z=Returns True if `xp` is an MArray namespace; False otherwise.marray)rrgs rNr r s r{ ""rU)reprcteZdZUedzed<edzed<ejeZee ed<dZ dZ dS)_XPSphinxCapabilityNr6gpu)default_factorywarningsc|dS|sdS|jr>>#6>>>JurUc|||j}||j}|dd|dS)N20z )rr6r )rr6r s rN__str__z_XPSphinxCapability.__str__sBll48$$ll48$$$$$C$$$$rU) r __module__ __qualname__bool__annotations__ dataclassesfieldrYrstrrrrrUrNr r sx  +++DAAAHd3iAAA   %%%%%rUr rc t|}tddtddtddtddtdd|rgndgtdd|rdgngd} t|t|zD])\} } | | } | jd| _| jd| _*| D]@\} } |r%| |dhzvr| jd| _| jd| _,|r| |vr| jd| _A|D]'\} } | | } | j| (| S) NT)r6r zno JIT)r6r rzcomputes graph)rarray_api_strictcupytorch jax.numpy dask.arrayFr)rnr rYr6r itemsrr) skip_backendsxfail_backendscpu_onlynp_only exceptionsallow_dask_computejax_jitrreason capabilitiesmodule_backendwarnings rN_make_sphinx_capabilitiesr5sZJ%4888/DdCCC#$777$4888(Tt"2RR 444*d+=E&''2GGG  L-((4+?+??  v& ; "GK ; "GK'--//    vZ7)%;;;{&# {&#  & 22w{7NGK#))v&(((( rUc d|d|dd|dd|dd|d d |d d }tj|S) Nz `aG` has experimental support for Python Array API Standard compatible backends in addition to NumPy. Please consider testing these features by setting an environment variable ``SCIPY_ARRAY_API=1`` and providing CuPy, PyTorch, JAX, or Dask arrays as array arguments. The following combinations of backend and device (or other capability) are supported. ==================== ==================== ==================== Library CPU GPU ==================== ==================== ==================== NumPy rz CuPy r#z PyTorch r$z JAX r%z Dask r&z} ==================== ==================== ==================== See :ref:`dev-arrayapi` for more information. )textwrapdedent)fun_namer0notes rN_make_capabilities_noter;s   (0  (/  (0  ( 4  ( 5   D& ?4  rU) capabilities_tabler(r)r*r+r/r,rr-r.c x tnt|||||||| | tdi  fd} | S)aDecorator for a function that states its support among various Array API compatible backends. This decorator has two effects: 1. It allows tagging tests with ``@make_xp_test_case`` or ``make_xp_pytest_param`` (see below) to automatically generate SKIP/XFAIL markers and perform additional backend-specific testing, such as extra validation for Dask and JAX; 2. It automatically adds a note to the function's docstring, containing a table matching what has been tested. See Also -------- make_xp_test_case make_xp_pytest_param array_api_extra.testing.lazy_xp_function N) r(r)r*r+r/r,r-r.rc|<t|j}t|}|d|t |ddd} ||_n#t$rYnwxYw|S)NNotes r)r;rrrr split__doc__AttributeError)fr:docr0r<sphinx_capabilitiess rN decoratorz"xp_capabilities..decorator&s!-1&qz3FGG!nn G D!!!#hhnnT1%%a( AII    D  s0A88 BBr)xp_capabilities_tabledictr5) r<r(r)r*r+r/r,rr-r.rGr0rFs ` @@rNr3r3sB4F3M//1#%-   L4CClCC rUr<cv |tn|}ddl}ddlm}g}|D]}|| d} d} dr0||jd|| dr0||jd||  d D]4\}}||j|| 5 d D]4\}}||j|| 5 fd dD} ||fi| |S)Nr)lazy_xp_functionr,r/r*T)r*r,r/r+)r+r,r/r()r/r)c"i|] }|| Srr)rkr0s rN z)_make_xp_pytest_marks..Qs5CCC,q/CCCrU)r-r.)rHrs"scipy._lib.array_api_extra.testingrLrmarkskip_xp_backendsxfail_xp_backends) r<funcsrsrLmarksfuncr,r/mod_name lazy_kwargsr0s @rN_make_xp_pytest_marksrY9s3E3M//1MMMCCCCCC E..)$/ !,/ h'  # F LL55*V6EE F F F  " E LL55F6DD E E E!-_ = P P Hf LL55hv5NN O O O O ,-= > Q Q Hf LL66x6OO P P P PCCCC ACCC ------ LrUc>|tn|} t|d|ifdS)Nr<c2tjd|S)Nc||Srr)rDgs rNz5make_xp_test_case....msaaddrU) functoolsreduce)rVrUs rNr^z#make_xp_test_case..ms ():):E4HHrU)rHrY)r<rTrUs @rNmake_xp_test_caseraXs@3E3M//1" "5 P=O P PE H H H HHrUcZddl}t||}|j|g|R||jdS)aiVariant of ``make_xp_test_case`` that returns a pytest.param for a function, with all necessary skip_xp_backends and xfail_xp_backends marks applied:: @pytest.mark.parametrize( "func", [make_xp_pytest_param(f1), make_xp_pytest_param(f2)] ) def test(func, xp): ... The above is equivalent to:: @pytest.mark.parametrize( "func", [ pytest.param(f1, marks=[ pytest.mark.skip_xp_backends(...), pytest.mark.xfail_xp_backends(...), ...]), pytest.param(f2, marks=[ pytest.mark.skip_xp_backends(...), pytest.mark.xfail_xp_backends(...), ...]), ) def test(func, xp): ... Parameters ---------- func : Callable Function to be tested. It must be decorated with ``@xp_capabilities``. *args : Any, optional Extra pytest parameters for the use case, e.g.:: @pytest.mark.parametrize("func,verb", [ make_xp_pytest_param(f1, "hello"), make_xp_pytest_param(f2, "world")]) def test(func, verb, xp): # iterates on (func=f1, verb="hello") # and (func=f2, verb="world") See Also -------- xp_capabilities make_xp_test_case array_api_extra.testing.lazy_xp_function rNrJ)rUid)rsrYrr)rVr<rrsrUs rNmake_xp_pytest_paramrdpsGXMMM !$;M N N NE 6< Ct C C5T] C C CCrUr)r)r) rrFFrFTrN)crBrtrr_osr7collections.abcrrrr contextvarsrtypesrtypingr r r rr> numpy.typingnpt scipy._libr scipy._lib.array_api_compatr rrr0rXrr.rr%rr#rr&rr$rrrr!scipy._lib._sparserscipy._lib._docscraper__all__environrr'r rrr(rWr7r8rOrTrrr-rlrrrrr+r*r,rrr1r"r)intrfloatr2r/rr4r5rrrr dataclassr r5r;r3rYrardrHrrUrNrus 9999999999%%%%%%""""""**********''''''                          ('''''------   !jnn->FFtFFFz~~ne44 '  ys}, 9,,,5hy15huo5555pJ4$U$z$$$$R48 , !%",,,,,)*T1,Tk ,   ,,, ,,,,^26)))u)Z$.)%))))8.8Z -F-FJz*FFF (: (),<"= ( ( ( ( 3333#'Dd%%%%%P((($9=$ $tRDKKKKK,.24 $$4BBBBB@8<#dBQUJJJJJ.********FCFCFFFF3%3Z3D3333J:+<048$)&'+/ HHHeHuSz)D0H!He H"D( H5: HHHH46:    d!2 e        *//A/A/A/A/Ad!&e;1;1;1;1;1|  U  T(9 U       ### E"""%%%%%%%#"%0&(.0&* 0000f!!!8R E$2 dAAAAAH6:>26IIIII0:>/D/D/D/D/DfrU