B 0d- @s\ddlZddlZddlZddlmZddlZddlZddlZejdej dfZ ejej ej ej gej ej ej ffZ ddlm Z mZmZmZddd d d d d ddddddg ZddZddZeeeeejdd Zd(e e eejejddd Zd)ddZdd ZddZd*d dZd!d Zd+d#d ZGd$ddZ d%dZ!d&dZ"d'dZ#dS),N)_uarray.) Dispatchable.)BackendNotImplementedError _Function_SkipBackendContext_SetBackendContext set_backendset_global_backend skip_backendregister_backendclear_backendscreate_multimethodgenerate_multimethodrrrwrap_single_convertor all_of_typemark_asc Cs^ddl}y||}t||}|Sttfk rX}zddlm}||Wdd}~XYnXdS)Nr)UnpicklingError) importlib import_modulegetattr ImportErrorAttributeErrorpickler)mod_nameqnamermodulefuncerrM/var/www/html/venv/lib/python3.7/site-packages/scipy/_lib/_uarray/_backend.pyunpickle_function&s   r!cCsht|dd}t|dd}yt||}Wntjk r@d}YnX||k r\td||t||ffS)N __module__ __qualname__z/Can't pickle {}: it's not the same object as {})rr!rr PicklingErrorformat)rrrtestrrr pickle_function3s   r'csfdd}|S)ao 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. cst|fS)N)r)a)argskwargsrr wrapperVsz#create_multimethod..wrapperr)r)r*r+r)r)r*r rHs)argument_extractorargument_replacerdomaindefaultcCs,t|\}}}t||||||}t||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.backend.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)r,r-r.r/ kw_defaults arg_defaultsoptsZua_funcrrr r\s=FcCs^y|jd||fStk r*i|_Yntk r<YnXt|||}||jd||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) __ua_cache__rKeyErrorr)backendcoerceonlyctxrrr r s  cCsNy |jdStk r$i|_Yntk r6YnXt|}||jd<|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)r7rr8r)r9r<rrr r s   cCst|}i}g}t}xZ|jD]L\}}|jtjjk rD|j||<|jtjj tjj fkrf| |j| |q$W|t ||fS)N)inspect signaturer6 parametersitemsr/ ParameteremptykindPOSITIONAL_ONLYPOSITIONAL_OR_KEYWORDappendaddtuple)fsigr3r4r5kvrrr r0s    r0cCst|||dS)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. See Also -------- set_backend : A context manager that allows setting of backends. skip_backend : A context manager that allows skipping of backends. N)rr )r9r:r;rrr r scCst|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 )r9rrr r s TcCst|||dS)ap 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 the 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 )r. registeredglobalsrrr r sc@s.eZdZdZd ddZddZddZeZd S) 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. TcCs||_||_||_dS)N)valuetype coercible)selfrP dispatch_typerRrrr __init__YszDispatchable.__init__cCs|j|jf|S)N)rQrP)rSindexrrr __getitem__^szDispatchable.__getitem__cCsdt|j|j|jS)Nz<{0}: type={1!r}, value={2!r}>)r%rQ__name__rP)rSrrr __str__aszDispatchable.__str__N)T)rXr"r#__doc__rUrWrY__repr__rrrr r=s  cCstjt|dS)z Creates a utility function to mark something as a specific type. Examples -------- >>> mark_int = mark_as(int) >>> mark_int(1) , value=1> )rT)r1partialr)rTrrr ris csfdd}|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>) cstfdd}|S)Ncs ||}tfdd|DS)Nc3s&|]}t|tst|n|VqdS)N) isinstancer).0arg)arg_typerr sz.outer..inner..)rI)r)r*Zextracted_args)r`rrr inners  z)all_of_type..outer..inner)r1wraps)rrb)r`)rr outers zall_of_type..outerr)r`rdr)r`r rvs cstfdd}|S)z 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). csBg}x8|D]0}|j|j|o |j}|tkr0tS||q W|S)N)rPrQrRNotImplementedrG)Z dispatchablesr:Z converteddc)convert_singlerr __ua_convert__s z-wrap_single_convertor..__ua_convert__)r1rc)rhrir)rhr rs  )N)FF)FF)TF)$typingr>r1rcopyregatexitrCallableTupleZArgumentExtractorTypeDictZArgumentReplacerTyperrrr__all__r!r'registerZclear_all_globalsrstrOptionalrr r r0r r r rrrrrrrr sN $   F   ,