← Back
Editing: _backend.cpython-311.pyc
� d�cP � �� � d dl Z d dlZd dlZd dlZddlmZ d dlZd dlZd dlZe j de j d f Z e j e j e j e j ge j e j e j f f Z ddlmZmZmZmZmZ g d�Zd� Zd � Zd � Zd � Zd � Z ej ee� � ej ej e� � ej ee� � ej ee� � d � Zej d� � � Zej d� � � Z d� Z d(de de de de j e j fd�Z d)d�Z!d� Z"d� Z#d)dd�d�Z$d � Z%d*d �Z& G d � d � � Z'd!� Z(d"� Z)d#� Z*d$� Z+d dd%�d&�Z,d dd%�d'�Z-dS )+� N� )�_uarray.)� Dispatchable.)�BackendNotImplementedError� _Function�_SkipBackendContext�_SetBackendContext� _BackendState)� set_backend�set_global_backend� skip_backend�register_backend�determine_backend�determine_backend_multi�clear_backends�create_multimethod�generate_multimethodr r r �wrap_single_convertor� wrap_single_convertor_instance� all_of_type�mark_as� set_state� get_state� reset_stater r r c � � dd l } |� | � � }|� d� � }|}|D ]}t ||� � }�|�t j ||� � }|S # t t f$ r}ddlm } ||�d }~ww xY w)Nr �.)�UnpicklingError) � importlib� import_module�split�getattr�types� MethodType� ImportError�AttributeError�pickler ) �mod_name�qname�self_r �module�func�q�er s �=/usr/lib/python3/dist-packages/scipy/_lib/_uarray/_backend.py�unpickle_functionr/ 1 s� � �����%��(�(��2�2��� � �C� � ����� $� $�A��4��#�#�D�D� � ��#�D�%�0�0�D�� �� � � (� %� %� %�*�*�*�*�*�*� �1�$�����%���s �AA � A?�1 A:�:A?c �, � t | dd � � }t | dd � � }t | dd � � } t |||� � }n# t j $ r d }Y nw xY w|| ur(t j d� | |� � � � �t |||ffS )N� __module__� __qualname__�__self__z/Can't pickle {}: it's not the same object as {})r! r/ r& r � PicklingError�format)r+ r' r( r) �tests r. �pickle_functionr7 E s� � ��t�\�4�0�0�H� �D�.�$� /� /�E� �D�*�d� +� +�E�� ��5�%�8�8���� � !� � � ��������� �4����"� =� D� D�T�4� P� P� � � � �x��� 6� 6�6s �A �A�Ac �L � t j j | � � � fS �N)r r � _unpickle�_pickle)�states r. � pickle_stater= W s � � � � *�E�M�M�O�O� ;�;� c �8 � t | � � � fS r9 )r r; ��ctxs r. �pickle_set_backend_contextrB [ s � � �s�{�{�}�}� ,�,r> c �8 � t | � � � fS r9 )r r; r@ s r. �pickle_skip_backend_contextrD _ s � � �� � � � � -�-r> c �( � t j � � S )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 r � r> r. r r i s � � � � � � r> c # �z K � t t � � � � 5 dV � ddd� � dS # 1 swxY w Y dS )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)r r rF r> r. r r w s� � � � � �9�;�;� � � � � ����� � � � � � � � � � � ���� � � � � � s �0�4�4c # � K � t � � }t j | � � dV � t j |d� � dS # t j |d� � w xY w)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)r r r )r< � old_states r. r r � sb � � � � � � �I� ��e� � � �+� ������)�T�*�*�*�*�*����)�T�*�*�*�*���s �A �Ac � � �� � �fd�}|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 | g��R i ���S r9 )r )�a�args�kwargss ��r. �wrapperz#create_multimethod.<locals>.wrapper� s! �� �#�A�7��7�7�7��7�7�7r> rF )rM rN rO s `` r. r r � s) ��� � 8� 8� 8� 8� 8� 8� �Nr> �argument_extractor�argument_replacer�domain�defaultc �z � t | � � \ }}}t | |||||� � }t j || � � 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 � functools�update_wrapper)rP rQ rR rS � kw_defaults� arg_defaults�opts�ua_funcs r. r r � sQ � �| '3�3E�&F�&F�#�K� �t�������� � �G� � #�G�-?� @� @�@r> Fc � � | j d||f S # t $ r i | _ Y nt $ r Y nw xY wt | ||� � }|| 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)� __ua_cache__r% �KeyErrorr )�backend�coerce�onlyrA s r. r r � s� � �$ ��#�E�6�4�$7�8�8�� � "� "� "� !�� � � � � � � � �� ���� �W�f�d� 3� 3�C�03�G�����,�-� �Js � �1� 1�1c � � | j d S # t $ r i | _ Y nt $ r Y nw xY wt | � � }|| j d< |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` rA s r. r r sv � � ��#�F�+�+�� � "� "� "� !�� � � � � � � � �� ���� �g� &� &�C�#&�G��� � �Js � �.� .�.c � � t j | � � }i }g }t � � }|j � � � D ]\ }}|j t j j ur |j ||< |j t j j t j j fv r|� |j � � |� |� � ��|t |� � |fS r9 )�inspect� signaturer] � parameters�itemsrS � Parameter�empty�kind�POSITIONAL_ONLY�POSITIONAL_OR_KEYWORD�append�add�tuple)�f�sigrX rY rZ �k�vs r. rU rU 3 s� � � � �A� � �C��K��L� �5�5�D���$�$�&�&� � ���1� �9�G� -� 3� 3� 3� �Y�K��N� �6� � � -� � � 3� � � � � � �� � *� *� *� ���� � � � � ��l�+�+�T� 1�1r> )�try_lastc �4 � t j | |||� � 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)r r )r` ra rb rv s r. r r E s" � �@ � �w���h�?�?�?�?�?r> c �. � t j | � � 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)r r )r` s r. r r h s � � � �W�%�%�%�%�%r> Tc �2 � t j | ||� � 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)r r )rR � registered�globalss r. r r x s � �8 ��6�:�w�7�7�7�7�7r> c �* � e Zd ZdZdd�Zd� Zd� ZeZdS )r a� 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 <Dispatchable: type=<class 'str'>, 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. Tc �0 � || _ || _ || _ d S r9 )�value�type� coercible)�selfr~ � dispatch_typer� s r. �__init__zDispatchable.__init__� s � ��� �!�� �"����r> c �* � | j | j f| S r9 )r r~ )r� �indexs r. � __getitem__zDispatchable.__getitem__� s � �� �4�:�&�u�-�-r> c �h � d� t | � � j | j | j � � S )Nz <{0}: type={1!r}, value={2!r}>)r5 r �__name__r~ )r� s r. �__str__zDispatchable.__str__� s. � �/�6�6� ��J�J� ���D�J� � � r> N)T)r� r1 r2 �__doc__r� r� r� �__repr__rF r> r. r r � sQ � � � � � �� �6#� #� #� #� .� .� .� � � � �H�H�Hr> r c �8 � t j t | �� � S )z� Creates a utility function to mark something as a specific type. Examples -------- >>> mark_int = mark_as(int) >>> mark_int(1) <Dispatchable: type=<class 'int'>, value=1> �r� )rV �partialr r� s r. r r � s � � � �\� � G� G� G�Gr> c � � � � fd�}|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) (<Dispatchable: type=<class 'str'>, value='a'>, <Dispatchable: type=<class 'int'>, value=1>) c �J �� � t j � � � �� fd�� � }|S )Nc �J �� �| i |��}t �fd�|D � � � � S )Nc 3 �f �K � | ]+}t |t � � st |�� � n|V � �,d S r9 �� isinstancer )�.0�arg�arg_types �r. � <genexpr>z<all_of_type.<locals>.outer.<locals>.inner.<locals>.<genexpr>� sZ �� � � � � � � "�#�|�4�4�� �S�(�+�+�+��� � � � � r> )rq )rM rN �extracted_argsr� r+ s ��r. �innerz)all_of_type.<locals>.outer.<locals>.inner� sQ �� � !�T�4� 2�6� 2� 2�N�� � � � � *� � � � � � r> �rV �wraps)r+ r� r� s ` �r. �outerzall_of_type.<locals>.outer� s> ��� � � �� � � � � � � � � � � � r> rF )r� r� s ` r. r r � s# �� � � � � � � �Lr> c �F � � t j � � � � fd�� � }|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). c � �� g }| D ]G} �|j |j |o|j � � }|t u r t c S |� |� � �H|S r9 �r~ r r� �NotImplementedro )� dispatchablesra � converted�d�c�convert_singles �r. �__ua_convert__z-wrap_single_convertor.<locals>.__ua_convert__� si �� �� � � � �A� ��q�w����0F�1�;�G�G�A��N�"�"�%�%�%�%� � � �Q� � � � ��r> r� �r� r� s ` r. r r � �; �� � �_�^�$�$� � � � � %�$� � �r> c �F � � t j � � � � fd�� � }|S )r� c � �� g }|D ]H} �| |j |j |o|j � � }|t u r t c S |� |� � �I|S r9 r� )r� r� ra r� r� r� r� s �r. r� z6wrap_single_convertor_instance.<locals>.__ua_convert__ sk �� �� � � � �A� ��t�Q�W�a�f�f�6L���M�M�A��N�"�"�%�%�%�%� � � �Q� � � � ��r> r� r� s ` r. r r r� r> )rb ra c �v � t | ||� � f}t j |||� � }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 <MarkingGlossary>`". 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 �ra rb )r r r r )r~ r� rR rb ra r� r` s r. r r sB � �H "�%� ��?�?�A�M��'�� �v�F�F�G� �w�v�D� 9� 9� 9�9r> c � �� d|v r1|� d� � �t �fd�| D � � � � } n7t | � � } t d� | D � � � � st d� � �t |� � dk r"t d� |� � � � �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 <MarkingGlossary>`". 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 r� c 3 �f �K � | ]+}t |t � � r|nt |�� � V � �,d S r9 r� )r� r� � disp_types �r. r� z*determine_backend_multi.<locals>.<genexpr>� sT �� � � � � �� �A�|�,�,� L�A�A�,�q�)�2L�2L� � � � � � r> c 3 �@ K � | ]}t |t � � V � �d S r9 r� )r� r� s r. r� z*determine_backend_multi.<locals>.<genexpr>� s, � � � �F�F�1�:�a� �.�.�F�F�F�F�F�Fr> z6dispatchables must be instances of uarray.Dispatchabler z)Received unexpected keyword arguments: {}r� ) �poprq �all� TypeError�lenr5 r r r )r� rR rb ra rN r` r� s @r. r r i s� �� �L �&� � ��J�J��/�/� � � � � � �"� � � � � � � � �m�,�,� ��F�F� �F�F�F�F�F� V�� T�U�U� U� �6�{�{�a����C�J�J�6�R�R�S�S�S��'�� �v�F�F�G� �w�v�D� 9� 9� 9�9r> r9 )FF)TF).�typingr" rf rV � r �copyregr& � contextlib�Callable�Tuple�ArgumentExtractorType�Dict�ArgumentReplacerTyper r r r r �__all__r/ r7 r= rB rD r �contextmanagerr r r �str�Optionalr r r rU r r r r r r r r r r rF r> r. �<module>r� s� �� � � � � � � � � ���� � � � � � � � � � � ���� � � � � � � � � ���V�\�:M�-N�(N�O� � �� �\�6�;�� �-�v�|�F�L�&�+�<U�/V�V�� �� � � � � � � � � � � � � � � � ��4%� %� %�(7� 7� 7�$<� <� <�-� -� -�.� .� .� ���y�/� *� *� *� ���w�$�l� 3� 3� 3� ���!�#=� >� >� >� ���"�$?� @� @� @� � � � �� � � �� � ��+� +� ��+�"� � �2 15� HA� HA�-�HA�+�HA� �HA� �_�V�_� -� HA� HA� HA� HA�V� � � �<� � �82� 2� 2�$ @�e� @� @� @� @� @�F &� &� &� 8� 8� 8� 8�>)� )� )� )� )� )� )� )�X H� H� H�� � �:� � �2� � �2 =A�� G:� G:� G:� G:� G:�V $(��V:� V:� V:� V:� V:� V:� V:r>
Save File
Cancel