+ Yj3P^RIt^RIt^RIt^RIt^RIHt^RIt^RIt^RIt^RI t ^RIH t H t H t H t Ht.R#Ot]P R]R$,3,t]P ]]].]]]3,3,tRtRtRtR tR t]P!] ]4]P!]P]4]P!] ]4]P!] ]4R t]P6R 4t]P6R 4tRtR%RRlltR&Rlt Rt!Rt"R&RR/Rllt#Rt$R'Rlt%!RR4t&Rt'Rt(Rt)Rt*RRR R/R!lt+RRR R/R"lt,R#)(N)_uarray)BackendNotImplementedError _Function_SkipBackendContext_SetBackendContext _BackendState Dispatchable.c^RIpVPV4pVPR4pTpVFp\WV4pK Ve\P !WR4pV# \ \3dp^RIH pYhRp?ii;i)rN.)UnpicklingError) importlib import_modulesplitgetattrtypes MethodType ImportErrorAttributeErrorpickler ) mod_nameqnameself_r modulefuncqer s &&& \/home/luca/screen-checking/.venv/lib/python3.14/site-packages/scipy/_lib/_uarray/_backend.pyunpickle_functionr1s|%((2 C A4#D  ##D0D  (%*$%sAAA8+A33A8c\VRR4p\VRR4p\VRR4p\WV4pW@Jd\P!RV RV 24h\WV33# \PdRpLDi;i) __module__N __qualname____self__z Can't pickle z: it's not the same object as )rrrr PicklingError)rrrrtests& rpickle_functionr%Est\40H D.$ /E D*d +E %8 ""D6!?v F   x6 66  ! !s A A:9A:cV\PPVP43#N)rr _unpickle_pickle)states&r pickle_stater+Ws  * *EMMO ;;c.\VP43#r')rr)ctxs&rpickle_set_backend_contextr0[s s{{} ,,r,c.\VP43#r')rr)r.s&rpickle_skip_backend_contextr2_s  --r,c,\P!4#)z Returns an opaque object containing the current state of all the backends. Can be used for synchronization between threads/processes. See Also -------- set_state Sets the state returned by this function. )r get_stater,rr4r4is    r,c#"\\44;_uu_4RxRRR4R# +'giR#;i5i)z Returns a context manager that resets all state once exited. See Also -------- set_state Context manager that sets the backend state. get_state Gets a state to be set by this context manager. N) set_stater4r5r,r reset_stater8ws% 9;      sA- A > Ac#"\4p\P!V4Rx\P!VR4R# \P!TR4i;i5i)z A context manager that sets the state of the backends to one returned by :obj:`get_state`. See Also -------- get_state Gets a state to be set by this context manager. NT)r4rr7)r* old_states& rr7r7sD I e+ )T*)T*s!AAAAAcaaVV3RlpV#)aM Creates a decorator for generating multimethods. This function creates a decorator that can be used with an argument extractor in order to generate a multimethod. Other than for the argument extractor, all arguments are passed on to :obj:`generate_multimethod`. See Also -------- generate_multimethod Generates a multimethod. c"<\V.SO5/SB#r')generate_multimethod)aargskwargss&rwrapper#create_multimethod..wrappers#A7777r,r5)r?r@rAsjl rcreate_multimethodrCs8 Nr,c jV^8dQhR\R\R\R\PR,/#)argument_extractorargument_replacerdomaindefaultN)ArgumentExtractorTypeArgumentReplacerTypestrtypingCallable)formats"r __annotate__rPsEKAKA-KA+KA KA__t # KAr,cj\V4wrEp\VVVVVV4p\P!Wp4#)a# Generates a multimethod. Parameters ---------- argument_extractor : ArgumentExtractorType A callable which extracts the dispatchable arguments. Extracted arguments should be marked by the :obj:`Dispatchable` class. It has the same signature as the desired multimethod. argument_replacer : ArgumentReplacerType A callable with the signature (args, kwargs, dispatchables), which should also return an (args, kwargs) pair with the dispatchables replaced inside the args/kwargs. domain : str A string value indicating the domain of this multimethod. default: Optional[Callable], optional The default implementation of this multimethod, where ``None`` (the default) specifies there is no default implementation. Examples -------- In this example, ``a`` is to be dispatched over, so we return it, while marking it as an ``int``. The trailing comma is needed because the args have to be returned as an iterable. >>> def override_me(a, b): ... return Dispatchable(a, int), Next, we define the argument replacer that replaces the dispatchables inside args/kwargs with the supplied ones. >>> def override_replacer(args, kwargs, dispatchables): ... return (dispatchables[0], args[1]), {} Next, we define the multimethod. >>> overridden_me = generate_multimethod( ... override_me, override_replacer, "ua_examples" ... ) Notice that there's no default implementation, unless you supply one. >>> overridden_me(1, "a") Traceback (most recent call last): ... uarray.BackendNotImplementedError: ... >>> overridden_me2 = generate_multimethod( ... override_me, override_replacer, "ua_examples", default=lambda x, y: (x, y) ... ) >>> overridden_me2(1, "a") (1, 'a') See Also -------- uarray See the module documentation for how to override the method by creating backends. ) get_defaultsr functoolsupdate_wrapper)rFrGrHrI kw_defaults arg_defaultsoptsua_funcs&&&& rr=r=sDB'33E&F#Kt G  # #G @@r,Fc\P!4pVPVRW3,# \d /TnM\dMi;i\ YT4pY@PTRY3&T#)a A context manager that sets the preferred backend. Parameters ---------- backend The backend to set. coerce Whether or not to coerce to a specific backend's types. Implies ``only``. only Whether or not this should be the last backend to try. See Also -------- skip_backend: A context manager that allows skipping of backends. set_global_backend: Set a single, global backend for a domain. set) threading get_native_id __ua_cache__rKeyErrorr)backendcoerceonlytidr/s&&& r set_backendrcsy$  ! ! #C ##C$<== "!     Wd 3C58eV12 Js-AA A Ac\P!4pVPVR3,# \d /TnM\dMi;i\ T4pY PTR3&T#)a A context manager that allows one to skip a given backend from processing entirely. This allows one to use another backend's code in a library that is also a consumer of the same backend. Parameters ---------- backend The backend to skip. See Also -------- set_backend: A context manager that allows setting of backends. set_global_backend: Set a single, global backend for a domain. skip)r[r\r]rr^r)r_rbr/s& r skip_backendrfsq  ! ! #C ##CK00 "!     g &C(+f% Js,A A  A  A c\P!V4p/p.p\4pVPP 4FwrVVP \P PJdVP W%&VP\P P\P P39dVPVP 4VPV4K V\V4V3#r')inspect signaturerZ parametersitemsrI ParameteremptykindPOSITIONAL_ONLYPOSITIONAL_OR_KEYWORDappendaddtuple)fsigrUrVrWkvs& rrRrR8s   A CKL 5D$$& 99G--33 3YYKN 66    - -    3 3      *  ' l+T 11r,try_lastc4\P!WW#4R#)a This utility method replaces the default backend for permanent use. It will be tried in the list of backends automatically, unless the ``only`` flag is set on a backend. This will be the first tried backend outside the :obj:`set_backend` context manager. Note that this method is not thread-safe. .. warning:: We caution library authors against using this function in their code. We do *not* support this use-case. This function is meant to be used only by users themselves, or by a reference implementation, if one exists. Parameters ---------- backend The backend to register. coerce : bool Whether to coerce input types when trying this backend. only : bool If ``True``, no more backends will be tried if this fails. Implied by ``coerce=True``. try_last : bool If ``True``, the global backend is tried after registered backends. See Also -------- set_backend: A context manager that allows setting of backends. skip_backend: A context manager that allows skipping of backends. N)rset_global_backend)r_r`rarxs&&&$rrzrzJs@ w?r,c2\P!V4R#)a  This utility method sets registers backend for permanent use. It will be tried in the list of backends automatically, unless the ``only`` flag is set on a backend. Note that this method is not thread-safe. Parameters ---------- backend The backend to register. N)rregister_backend)r_s&rr|r|ms W%r,Tc4\P!WV4R#)a This utility method clears registered backends. .. warning:: We caution library authors against using this function in their code. We do *not* support this use-case. This function is meant to be used only by users themselves. .. warning:: Do NOT use this method inside a multimethod call, or the program is likely to crash. Parameters ---------- domain : Optional[str] The domain for which to de-register backends. ``None`` means de-register for all domains. registered : bool Whether or not to clear registered backends. See :obj:`register_backend`. globals : bool Whether or not to clear global backends. See :obj:`set_global_backend`. See Also -------- register_backend : Register a backend globally. set_global_backend : Set a global backend. N)rclear_backends)rH registeredglobalss&&&rr~r~}s8 6w7r,c>a]tRtRtoRtRRltRtRt]tRt Vt R#) r ia A utility class which marks an argument with a specific dispatch type. Attributes ---------- value The value of the Dispatchable. type The type of the Dispatchable. Examples -------- >>> x = Dispatchable(1, str) >>> x , value=1> See Also -------- all_of_type Marks all unmarked parameters of a function. mark_as Allows one to create a utility function to mark as a given type. c*WnW nW0nR#r')valuetype coercible)selfr dispatch_typers&&&&r__init__Dispatchable.__init__s ! "r,c@VPVP3V,#r')rr)rindexs&&r __getitem__Dispatchable.__getitem__s 4::&u--r,clR\V4P RVP: RVP: R2#))r__name__r)rs&r__str__Dispatchable.__str__s14:&&'wtyym8DJJ>QRSSr,)rrrN)T) rr r!__firstlineno____doc__rrr__repr____static_attributes____classdictcell__) __classdict__s@rr r s!6# .THr,c:\P!\VR7#)z Creates a utility function to mark something as a specific type. Examples -------- >>> mark_int = mark_as(int) >>> mark_int(1) , value=1> r)rSpartialr rs&rmark_asrs   \ GGr,caV3RlpV#)z Marks all unmarked arguments as a given type. Examples -------- >>> @all_of_type(str) ... def f(a, b): ... return a, Dispatchable(b, int) >>> f('a', 1) (, value='a'>, , value=1>) cJ<a\P!S4VV3Rl4pV#)cx<S!V/VBp\;QJd.V3RlV4FNK 5#!V3RlV44#)c3l<"TF)p\V\4'g \VS4MTxK+ R#5ir' isinstancer ).0argarg_types& r .outer..inner..s:*C"#|44S(+*14)rs)r?r@extracted_argsrrs*, rinner)all_of_type..outer..innersH!4262N5* 5 5*  r,rSwraps)rrrsf routerall_of_type..outers%      r,r5)rrsf r all_of_typers  Lr,cFa\P!S4V3Rl4pV#) Wraps a ``__ua_convert__`` defined for a single element to all elements. If any of them return ``NotImplemented``, the operation is assumed to be undefined. Accepts a signature of (value, type, coerce). c<.pVFXpS!VPVPT;'d VP4pV\Jd \u#VP V4KZ V#r'rrrNotImplementedrq) dispatchablesr` converteddcconvert_singles&& r__ua_convert__-wrap_single_convertor..__ua_convert__sX Aqww0F0F1;;GAN"%%   Q  r,rrrsf rwrap_single_convertorr(__^$ %  r,cFa\P!S4V3Rl4pV#)rc<.pVFXpS!YPVPT;'d VP4pV\Jd \u#VP V4KZ V#r'r)rrr`rrrrs&&& rr6wrap_single_convertor_instance..__ua_convert__sX AtWWafff6L6LMAN"%%   Q  r,rrsf rwrap_single_convertor_instancer rr,rar`cd\WV43p\P!W%V4p\WdVR7#)aJSet the backend to the first active backend that supports ``value`` This is useful for functions that call multimethods without any dispatchable arguments. You can use :func:`determine_backend` to ensure the same backend is used everywhere in a block of multimethod calls. Parameters ---------- value The value being tested dispatch_type The dispatch type associated with ``value``, aka ":ref:`marking `". domain: string The domain to query for backends and set. coerce: bool Whether or not to allow coercion to the backend's types. Implies ``only``. only: bool Whether or not this should be the last backend to try. See Also -------- set_backend: For when you know which backend to set Notes ----- Support is determined by the ``__ua_convert__`` protocol. Backends not supporting the type must return ``NotImplemented`` from their ``__ua_convert__`` if they don't support input of that type. Examples -------- Suppose we have two backends ``BackendA`` and ``BackendB`` each supporting different types, ``TypeA`` and ``TypeB``. Neither supporting the other type: >>> with ua.set_backend(ex.BackendA): ... ex.call_multimethod(ex.TypeB(), ex.TypeB()) Traceback (most recent call last): ... uarray.BackendNotImplementedError: ... Now consider a multimethod that creates a new object of ``TypeA``, or ``TypeB`` depending on the active backend. >>> with ua.set_backend(ex.BackendA), ua.set_backend(ex.BackendB): ... res = ex.creation_multimethod() ... ex.call_multimethod(res, ex.TypeA()) Traceback (most recent call last): ... uarray.BackendNotImplementedError: ... ``res`` is an object of ``TypeB`` because ``BackendB`` is set in the innermost with statement. So, ``call_multimethod`` fails since the types don't match. Instead, we need to first find a backend suitable for all of our objects. >>> with ua.set_backend(ex.BackendA), ua.set_backend(ex.BackendB): ... x = ex.TypeA() ... with ua.determine_backend(x, "mark", domain="ua_examples"): ... res = ex.creation_multimethod() ... ex.call_multimethod(res, x) TypeA r`ra)r rdetermine_backendrc)rrrHrar`rr_s&&$$$ rrr#s3H"%?AM''vFG wD 99r,c aRV9dEVPR4o\;QJd.V3RlV4FNK 5M!V3RlV44pMP\V4p\;QJdRV4F 'dK RM RM !RV44'g \R4h\ V4^8wd\RV 24h\ P !WV4p\WSVR7#) a Set a backend supporting all ``dispatchables`` This is useful for functions that call multimethods without any dispatchable arguments. You can use :func:`determine_backend_multi` to ensure the same backend is used everywhere in a block of multimethod calls involving multiple arrays. Parameters ---------- dispatchables: Sequence[Union[uarray.Dispatchable, Any]] The dispatchables that must be supported domain: string The domain to query for backends and set. coerce: bool Whether or not to allow coercion to the backend's types. Implies ``only``. only: bool Whether or not this should be the last backend to try. dispatch_type: Optional[Any] The default dispatch type associated with ``dispatchables``, aka ":ref:`marking `". See Also -------- determine_backend: For a single dispatch value set_backend: For when you know which backend to set Notes ----- Support is determined by the ``__ua_convert__`` protocol. Backends not supporting the type must return ``NotImplemented`` from their ``__ua_convert__`` if they don't support input of that type. Examples -------- :func:`determine_backend` allows the backend to be set from a single object. :func:`determine_backend_multi` allows multiple objects to be checked simultaneously for support in the backend. Suppose we have a ``BackendAB`` which supports ``TypeA`` and ``TypeB`` in the same call, and a ``BackendBC`` that doesn't support ``TypeA``. >>> with ua.set_backend(ex.BackendAB), ua.set_backend(ex.BackendBC): ... a, b = ex.TypeA(), ex.TypeB() ... with ua.determine_backend_multi( ... [ua.Dispatchable(a, "mark"), ua.Dispatchable(b, "mark")], ... domain="ua_examples" ... ): ... res = ex.creation_multimethod() ... ex.call_multimethod(res, a, b) TypeA This won't call ``BackendBC`` because it doesn't support ``TypeA``. We can also use leave out the ``ua.Dispatchable`` if we specify the default ``dispatch_type`` for the ``dispatchables`` argument. >>> with ua.set_backend(ex.BackendAB), ua.set_backend(ex.BackendBC): ... a, b = ex.TypeA(), ex.TypeB() ... with ua.determine_backend_multi( ... [a, b], dispatch_type="mark", domain="ua_examples" ... ): ... res = ex.creation_multimethod() ... ex.call_multimethod(res, a, b) TypeA rc3l<"TF)p\V\4'dTM \VS4xK+ R#5ir'r)rr disp_types& rr*determine_backend_multi..s0 "A|,,A,q)2L L"rc3B"TFp\V\4xK R#5ir'r)rrs& rrrsF 1:a.. sFTz6dispatchables must be instances of uarray.Dispatchablez'Received unexpected keyword arguments: r)poprsall TypeErrorlenrrrc)rrHrar`r@r_rs&$$$, @rdetermine_backend_multirmsL& JJ/  "  "  m, sF FsssF FFFTU U 6{aA&JKK''vFG wD 99r,)rcrzrfr|rrr~rCr=rrr rrrrr7r4r8rrr)r .r')FF)TF)-rMrrhrSrcopyregr contextlibr[rrrrr__all__rNrsrJdictrKrr%r+r0r2r4contextmanagerr8r7rCr=rcrfrRrzr|r~r rrrrrrr5r,rrs   2U3F-G(GH D%%t ,,%(7$<-.y/*w$$l3!#=>"$?@     ++"*KA\>:2$ @e @F & 8>''T H<22G:DG:G:TV:#'V:05V:r,