!jR zddlZddlZddlZddlZddlmZddlZddlZddlZddl Z ddlm Z m Z m Z m Z mZgdZejdedfZejeeegeeeffZdZd Zd Zd Zd Zeje eejejeeje eeje ed ZejdZejdZdZ d(dedededejdzfdZ d)dZ!dZ"dZ#d)dddZ$dZ%d*dZ&Gdd Z'd!Z(d"Z)d#Z*d$Z+ddd%d&Z,ddd%d'Z-dS)+N)_uarray)BackendNotImplementedError _Function_SkipBackendContext_SetBackendContext _BackendState) set_backendset_global_backend skip_backendregister_backenddetermine_backenddetermine_backend_multiclear_backendscreate_multimethodgenerate_multimethodrr Dispatchablewrap_single_convertorwrap_single_convertor_instance all_of_typemark_as set_state get_state reset_stater rr.)r.cddl} ||}|d}|}|D]}t||}|t j||}|S#t tf$r}ddlm }||d}~wwxYw)Nr.)UnpicklingError) importlib import_modulesplitgetattrtypes MethodType ImportErrorAttributeErrorpickler) mod_nameqnameself_rmodulefuncqers IC:\Projects\DSCons\.venv\Lib\site-packages\scipy\_lib\_uarray\_backend.pyunpickle_functionr/1s%((22 C   $ $A4##DD  #D%00D  (%%%******1$%sAA A?1 A::A?ct|dd}t|dd}t|dd} t|||}n#tj$rd}YnwxYw||urtjd|d|t|||ffS)N __module__ __qualname____self__z Can't pickle z: it's not the same object as )r!r/r&r PicklingError)r+r'r(r)tests r.pickle_functionr6Est\400H D.$ / /E D*d + +E 5%88  ! 4" FD F F F F    x6 66sAAAcLtjj|fSN)rr _unpickle_pickle)states r. pickle_stater<Ws  *EMMOO ;;c8t|fSr8)rr:ctxs r.pickle_set_backend_contextrA[s s{{}} ,,r=c8t|fSr8)rr:r?s r.pickle_skip_backend_contextrC_s  --r=c(tjS)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. )rrr=r.rris    r=c#zKtt5dVddddS#1swxYwYdS)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)rrrEr=r.rrws 9;;   s 044c#Kt}tj| dVtj|ddS#tj|dwxYw)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)rrr)r; old_states r.rrsb I e+ )T*****)T****s AAcfd}|S)au 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$t|gRiSr8)r)aargskwargss r.wrapperz#create_multimethod..wrappers!#A7777777r=rE)rLrMrNs`` r.rrs)888888 Nr=argument_extractorargument_replacerdomaindefaultczt|\}}}t||||||}tj||S)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)rOrPrQrR kw_defaults arg_defaultsoptsua_funcs r.rrsQB'33E&F&F#Kt G  #G-? @ @@r=Fctj} |j|d||fS#t$r i|_Ynt$rYnwxYwt |||}||j|d||f<|S)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__r%KeyErrorr)backendcoerceonlytidr@s r.r r s$  ! # #C #C$<== """!       Wfd 3 3C58GeVT12 Js&A AActj} |j|dfS#t$r i|_Ynt$rYnwxYwt |}||j|df<|S)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_r%r`r)rardr@s r.r r s  ! # #C #CK00 """!       g & &C(+Gf% Js$A AActj|}i}g}t}|jD]\}}|jtjjur |j||<|jtjj tjj fvr| |j| ||t||fSr8)inspect signaturer\ parametersitemsrR ParameteremptykindPOSITIONAL_ONLYPOSITIONAL_OR_KEYWORDappendaddtuple)fsigrWrXrYkvs r.rTrT8s  A  CKL 55D$$&&1 9G-3 3 3YKN 6   -   3       * * *  l++T 11r=)try_lastc4tj||||dS)ae 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)rr )rarbrcrxs r.r r Js"@ wh?????r=c.tj|dS)a0 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)rr )ras r.r r ms W%%%%%r=Tc2tj|||dS)al 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)rr)rQ registeredglobalss r.rr}s8 6:w77777r=c*eZdZdZddZdZdZeZdS)ra 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. Tc0||_||_||_dSr8)valuetype coercible)selfr dispatch_typers r.__init__zDispatchable.__init__s ! "r=c*|j|jf|Sr8)rr)rindexs r. __getitem__zDispatchable.__getitem__s 4:&u--r=cRdt|jd|jd|jdS)N)r__name__r)rs r.__str__zDispatchable.__str__s0S4::&SStySSDJSSSSr=N)T)rr1r2__doc__rrr__repr__rEr=r.rrsT6#### ...TTTHHHr=rc8tjt|S)z Creates a utility function to mark something as a specific type. Examples -------- >>> mark_int = mark_as(int) >>> mark_int(1) , value=1> r)rUpartialrrs r.rrs  \ G G GGr=cfd}|S)a$ 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>) cJtjfd}|S)NcJ|i|}tfd|DS)Nc3fK|]+}t|tst|n|V,dSr8 isinstancer).0argarg_types r. z.outer..inner..sZ"#|44 S(+++r=)rs)rLrMextracted_argsrr+s r.innerz)all_of_type..outer..innersQ!T42622N*  r=rUwraps)r+rrs` r.outerzall_of_type..outers>            r=rE)rrs` r.rrs#      Lr=cFtjfd}|S) 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). cg}|D]G}|j|j|o|j}|tur tcS||H|Sr8rrrNotImplementedrq) dispatchablesrb converteddcconvert_singles r.__ua_convert__z-wrap_single_convertor..__ua_convert__si   Aqw0F1;GGAN""%%%%   Q    r=rrrs` r.rr;_^$$    %$  r=cFtjfd}|S)rcg}|D]H}||j|j|o|j}|tur tcS||I|Sr8r)rrrbrrrrs r.rz6wrap_single_convertor_instance..__ua_convert__sk   AtQWaff6LMMAN""%%%%   Q    r=rrs` r.rr rr=)rcrbcvt|||f}tj|||}t|||S)a Set 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 rbrc)rrrr )rrrQrcrbrras r.rr#sBH"%??AM' vFFG wvD 9 9 99r=c vd|vr1|dtfd|D}n7t|}td|Dstdt |dkrtd|t j|||}t|||S)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 rc3fK|]+}t|tr|nt|V,dSr8r)rr disp_types r.rz*determine_backend_multi..sT  A|,, LAA,q)2L2L      r=c3@K|]}t|tVdSr8r)rrs r.rz*determine_backend_multi..s,FF1:a..FFFFFFr=z6dispatchables must be instances of uarray.Dispatchablerz'Received unexpected keyword arguments: r)poprsall TypeErrorlenrrr )rrQrcrbrMrars @r.rrmsL&  JJ//     "     m,, FF FFFFF VTUU U 6{{aJ&JJKKK' vFFG wvD 9 9 99r=r8)FF)TF).typingr"rhrUrcopyregr& contextlibr]rrrrr __all__CallablersArgumentExtractorTypedictArgumentReplacerTyper/r6r<rArCrcontextmanagerrrrstrrr r rTr r rrrrrrrrrEr=r.rs     2U3F-G(GH D%%t ,,%%%(777$<<<---...y/***w$l333!#=>>>"$?@@@        +++"2'+ KAKA-KA+KA KA_t # KAKAKAKA\>:222$ @e @ @ @ @ @F & & & 8888>''''''''T H H H<22=AG:G:G:G:G:V$(V:V:V:V:V:V:V:r=