o

6��a��@s�dZd
dl
Z
d
dlZd
dlZd
dlZd
dlmZmZmZ
d
dl	m
Z

eeej
�dd��
�
ZdZdd	�Zeed
�
eed�
e
�dd
�Zdd�Zdd�Ze�d�
Z		ddd�
Z	ddd�
ZdS)z;Implementation of __array_function__ overrides from NEP-18.�N)�
add_docstring�implement_array_function�_get_implementing_args)
�
getargspec�!NUMPY_EXPERIMENTAL_ARRAY_FUNCTION�
ah
like : array_like
        Reference object to allow the creation of arrays which are not
        NumPy arrays. If an array-like passed in as ``like`` supports
        the ``__array_function__`` protocol, the result will be defined
        by it. In this case, it ensures the creation of an array object
        compatible with that passed in via this argument.c

Cs|jdu
r
|j�
d
t�|_|S)Nz${ARRAY_FUNCTION_LIKE})�__doc__�replace�array_function_like_doc)
�
public_api�r�6/usr/lib/python3/dist-packages/numpy/core/overrides.py�set_array_function_like_docs




�ra�
    Implement a function with checks for __array_function__ overrides.

    All arguments are required, and can only be passed by position.

    Parameters
    ----------
    implementation : function
        Function that implements the operation on NumPy array without
        overrides when called like ``implementation(*args, **kwargs)``.
    public_api : function
        Function exposed by NumPy's public API originally called like
        ``public_api(*args, **kwargs)`` on which arguments are now being
        checked.
    relevant_args : iterable
        Iterable of arguments to check for __array_function__ methods.
    args : tuple
        Arbitrary positional arguments originally passed into ``public_api``.
    kwargs : dict
        Arbitrary keyword arguments originally passed into ``public_api``.

    Returns
    -------
    Result from calling ``implementation()`` or an ``__array_function__``
    method, as appropriate.

    Raises
    ------
    TypeError : if no implementation is found.
    ar

    Collect arguments on which to call __array_function__.

    Parameters
    ----------
    relevant_args : iterable of array-like
        Iterable of possibly array-like arguments to check for
        __array_function__ methods.

    Returns
    -------
    Sequence of arguments with __array_function__ methods, in the order in
    which they should be called.
    �ArgSpeczargs varargs keywords defaultscCs�tt
|�
�}tt
|
�
�}|j|jks7|j|jks7|j|jks7t|j�
t|j�
ks7|jd
u
r=t|j�
t|j�
kr=td|�
�
|jd
u
rP|jdt|j�
krRtd�
�
d
Sd
S)z:Verify that a dispatcher function has the right signature.NzGimplementation and dispatcher for %s have different function signatures�
NzBdispatcher functions can only use None for default argument values)	rr�args�varargs�keywords�bool�defaults�len�RuntimeError)�implementation�
dispatcher�implementation_spec�dispatcher_specrrr
�verify_matching_signaturesYs(




�


�
�


�
rc
s�f
d
d�}
|
S)z�Decorator for overriding __module__ on a function or class.

    Example usage::

        @set_module('numpy')
        def example():
            pass

        assert example.__module__ == 'numpy'
    c

s�du
r�|_|Sr)
�
__module__)
�func�
�modulerr
�	decoratorzs


zset_module.<locals>.decoratorr)r r!rrr
�
set_moduleosr"z�
    @functools.wraps(implementation)
    def {name}(*args, **kwargs):
        relevant_args = dispatcher(*args, **kwargs)
        return implement_array_function(
            implementation, {name}, relevant_args, args, kwargs)
    TFcs.ts��
�fd
d�}|S��
��fdd�}|S)a�Decorator for adding dispatch with the __array_function__ protocol.

    See NEP-18 for example usage.

    Parameters
    ----------
    dispatcher : callable
        Function that when called like ``dispatcher(*args, **kwargs)`` with
        arguments from the NumPy function call returns an iterable of
        array-like arguments to check for ``__array_function__``.
    module : str, optional
        __module__ attribute to set on new function, e.g., ``module='numpy'``.
        By default, module is copied from the decorated function.
    verify : bool, optional
        If True, verify the that the signature of the dispatcher and decorated
        function signatures match exactly: all required and optional arguments
        should appear in order with the same names, but the default values for
        all optional arguments should be ``None``. Only disable verification
        if the dispatcher's signature needs to deviate for some particular
        reason, e.g., because the function has a signature like
        ``func(*args, **kwargs)``.
    docs_from_dispatcher : bool, optional
        If True, copy docs from the dispatcher function onto the dispatched
        function, rather than from the implementation. This is useful for
        functions defined in C, which otherwise don't have docstrings.

    Returns
    -------
    Function suitable for decorating the implementation of a NumPy function.
    c

s"�
rt|�j
�
�du
r�|_|Sr)rrr)
r)r�docs_from_dispatcherr rr
r!�s





z*array_function_dispatch.<locals>.decoratorc
st�rt|��
�
rt
|�j�
tj|jd
�
}
t|
ddd�}|�ttd�}t	||�
||j}�du
r5�|_
||_|S)N)
�namez<__array_function__ internals>�exec)�filename�mode)rr�	functoolsr)rrr�_wrapped_func_source�format�__name__�compiler(rr%r�_implementation)r�source�
source_object�scoper�rr#r �verifyrr
r!�s&




�


�


)
�ARRAY_FUNCTION_ENABLED)rr r2r#r!rr1r
�array_function_dispatch�s
!
!r4cs��
��fd
d�}|S)zDLike array_function_dispatcher, but with function arguments flipped.c

st|���d
��
�
S)N)r2r#)
r4)
r�r#rr r2rr
r!�s


��z1array_function_from_dispatcher.<locals>.decoratorr)rr r2r#r!rr5r
�array_function_from_dispatcher�sr6)NTF)NTT)r�collectionsr(�os�textwrap�numpy.core._multiarray_umathrrr�numpy.compat._inspectrr�int�environ�getr3r
r�
namedtuplerrr"�dedentr)r4r6rrrr
�<module>
s<




��		

�#

�
	

�O�