B
    us^"                 @   s  d dl mZmZmZ d dlZd dlZd dlZd dlZd dlZd dl	m
Z
mZmZ d dlmZ d dlmZmZmZ d dlZd dlmZmZ ddd	d
ddddddddgZdd Zdd ZG dd deZdd Zdd
 Zdd Zdd Z d4ddZ!dd  Z"da#da$d5d"d#Z%ej&fd$d%Z'ed!dd&ej&d!fd'dZ(ed!ej&fd(dZ)i a*e+d)ej,Z-ed!d6d,dZ.d-d. Z/d/d0 Z0d1d Z1d2d3 Z2dS )7    )divisionabsolute_importprint_functionN)issubclass_issubsctype
issubdtype)
set_module)ndarrayufuncasarray)
getargspecformatargspecr   r   r   	deprecatedeprecate_with_docget_includeinfosourcewholookforbyte_bounds	safe_evalc              C   sV   ddl } | jdkr.tjtj| jdd}n$ddlm} tjtj|jd}|S )a  
    Return the directory that contains the NumPy \*.h header files.

    Extension modules that need to compile against NumPy should use this
    function to locate the appropriate include directory.

    Notes
    -----
    When using ``distutils``, for example in ``setup.py``.
    ::

        import numpy as np
        ...
        Extension('extension_name', ...
                include_dirs=[np.get_include()])
        ...

    r   Ncoreinclude)	numpyZshow_configospathjoindirname__file__
numpy.corer   )r   dr    r!   [/home/fristb/BIRCH/lib-linux-x86_64/python/lib64/python3.7/site-packages/numpy/lib/utils.pyr      s    
c             C   s
   || _ | S )N)__name__)funcnamer!   r!   r"   _set_function_name5   s    r&   c               @   s"   e Zd ZdZdddZdd ZdS )
_Deprecatez
    Decorator class to deprecate old functions.

    Refer to `deprecate` for details.

    See Also
    --------
    deprecate

    Nc             C   s   || _ || _|| _d S )N)old_namenew_namemessage)selfr(   r)   r*   r!   r!   r"   __init__F   s    z_Deprecate.__init__c                sn  | j }| j}| j}|dkr@y
j}W n tk
r>   j}Y nX |dkrRd|  nd||f  |dk	rr d| 7   fdd}t||}j}|dkr }n| d}	t	|	dd }
|	d 
 r|
d	 | }nRt|	d d }x4|	dd D ]$}t||
krP |t|d 7 }qW ||d }d
 |g}||_y
j}W n tk
r\   Y nX |j| |S )z:
        Decorator call.  Refer to ``decorate``.

        Nz`%s` is deprecated!z%`%s` is deprecated, use `%s` instead!
c                 s   t j tdd | |S )z1`arrayrange` is deprecated, use `arange` instead!   )
stacklevel)warningswarnDeprecationWarning)argskwds)depdocr$   r!   r"   newfuncb   s    z$_Deprecate.__call__.<locals>.newfunc   r    z

)r(   r)   r*   r#   AttributeErrorr&   __doc__
expandtabssplit_get_indentlstriplenr   __dict__update)r+   r$   r3   kwargsr(   r)   r*   r6   doclinesindentskipliner    r!   )r5   r$   r"   __call__K   sJ    




z_Deprecate.__call__)NNN)r#   
__module____qualname__r:   r,   rH   r!   r!   r!   r"   r'   :   s   

r'   c             C   sH   t j}x.| D ]&}t| }|rt|t|| }qW |t jkrDd}|S )zU
    Determines the leading whitespace that could be removed from all the lines.
    r   )sysmaxsizer?   r>   min)rD   rE   rG   contentr!   r!   r"   r=      s    

r=   c              O   s4   | r&| d }| dd } t | ||S t | |S dS )a  
    Issues a DeprecationWarning, adds warning to `old_name`'s
    docstring, rebinds ``old_name.__name__`` and returns the new
    function object.

    This function may also be used as a decorator.

    Parameters
    ----------
    func : function
        The function to be deprecated.
    old_name : str, optional
        The name of the function to be deprecated. Default is None, in
        which case the name of `func` is used.
    new_name : str, optional
        The new name for the function. Default is None, in which case the
        deprecation message is that `old_name` is deprecated. If given, the
        deprecation message is that `old_name` is deprecated and `new_name`
        should be used instead.
    message : str, optional
        Additional explanation of the deprecation.  Displayed in the
        docstring after the warning.

    Returns
    -------
    old_func : function
        The deprecated function.

    Examples
    --------
    Note that ``olduint`` returns a value after printing Deprecation
    Warning:

    >>> olduint = np.deprecate(np.uint)
    DeprecationWarning: `uint64` is deprecated! # may vary
    >>> olduint(6)
    6

    r   r7   N)r'   )r3   rB   fnr!   r!   r"   r      s
    ,c             C   s
   t | dS )N)r*   )r'   )msgr!   r!   r"   <lambda>       rQ   c       
      C   s   | j }|d d }|d }|d }t| jj}| }}|dkrN|| j| 7 }nJx@t||D ]2\}}	|	dk r|||d |	 7 }qZ||d |	 7 }qZW ||7 }||fS )a#  
    Returns pointers to the end-points of an array.

    Parameters
    ----------
    a : ndarray
        Input array. It must conform to the Python-side of the array
        interface.

    Returns
    -------
    (low, high) : tuple of 2 integers
        The first integer is the first byte of the array, the second
        integer is just past the last byte of the array.  If `a` is not
        contiguous it will not use every byte between the (`low`, `high`)
        values.

    Examples
    --------
    >>> I = np.eye(2, dtype='f'); I.dtype
    dtype('float32')
    >>> low, high = np.byte_bounds(I)
    >>> high - low == I.size*I.itemsize
    True
    >>> I = np.eye(2); I.dtype
    dtype('float64')
    >>> low, high = np.byte_bounds(I)
    >>> high - low == I.size*I.itemsize
    True

    datar   stridesshapeNr7   )Z__array_interface__r   dtypeitemsizesizezip)
aZaiZa_dataZastridesZashapeZbytes_aZa_lowZa_highrU   Zstrider!   r!   r"   r      s     c             C   sP  | dkrt  j}|j} g }i }x|  D ]}t| | tr*| | }t|}|| krn|d||   }d}n|||< |}d}dt	t
|j}	t
|j}
|||	|
|jj|g q*W d}d}d}d}xtt|D ]|}|| }|t|d k rt|d }|t|d k rt|d }|t|d k r8t|d }|d r|t|d 7 }qW t|dkrtd|}td|}td|}d	|d
 |d
 |d
 f }t|d dt|d   d  xtt|D ]t}|| }td|d d
|t|d  d  |d d
|t|d  d  |d d
|t|d  d  |d f  qW td|  dS )a%  
    Print the NumPy arrays in the given dictionary.

    If there is no dictionary passed in or `vardict` is None then returns
    NumPy arrays in the globals() dictionary (all NumPy arrays in the
    namespace).

    Parameters
    ----------
    vardict : dict, optional
        A dictionary possibly containing ndarrays.  Default is globals().

    Returns
    -------
    out : None
        Returns 'None'.

    Notes
    -----
    Prints out the name, shape, bytes and type of all of the ndarrays
    present in `vardict`.

    Examples
    --------
    >>> a = np.arange(10)
    >>> b = np.ones(20)
    >>> np.who()
    Name            Shape            Bytes            Type
    ===========================================================
    a               10               80               int64
    b               20               160              float64
    Upper bound on total bytes  =       240

    >>> d = {'x': np.arange(2.0), 'y': np.arange(3.0), 'txt': 'Some str',
    ... 'idx':5}
    >>> np.who(d)
    Name            Shape            Bytes            Type
    ===========================================================
    x               2                16               float64
    y               3                24               float64
    Upper bound on total bytes  =       40

    Nz (%s)r   r7   z x r.      
   zName %s Shape %s Bytes %s Typer8   r-   =   z%s %s %s %s %s %s %s   z'
Upper bound on total bytes  =       %d)rK   	_getframef_back	f_globalskeys
isinstancer	   idr   mapstrrU   nbytesappendrV   r%   ranger?   intmaxprint)vardictframeZstacacher%   varZidvnamestroriginalZshapestrZbytestrZmaxnameZmaxshapeZmaxbyteZ
totalbyteskvalZsp1Zsp2Zsp3Zprvalr!   r!   r"   r     s^    ,




  c       
      C   s   t | }|}| }d}||}xp|D ]h}||kr6d}	n|}	|t | t |	 }||kr|d t | }|d d|d   | }q$||	 | }q$W |S )Nz,  r7   z,
r8   r.   )r?   r<   )
r%   	argumentswidthZ
firstwidthrt   newstrZsepstrarglistZargumentZaddstrr!   r!   r"   _split_linep  s    

r{   r   c             C   s   t | t t g } | j| ji}| jg}| jg}xvt|dkr>P |d}xX| D ]L}t|| t	j
rR|| j}||krR|| j}|| || |||< qRW q0W ||fS )Nr   )
__import__globalslocalsr#   r@   r?   poprc   rd   types
ModuleTyperi   )modulethedictZdictlistZ
totraverseZthisdictxmodnameZmoddictr!   r!   r"   _makenamedict  s"    




r   c       
      C   sx  d}d}dd }t | dt| }t |d|}| j}| jj}td||d td| j|d td	||d td
| j|d td|| jj	|d td|| jj
|d td| jj|d tdt| jjj|f |d tdd|d |dkrtd|tj|f |d d}	nH|dkr2td||f |d tjdk}	ntd||f |d tjdk}	td||	|d td| j |d dS )aO  Provide information about ndarray obj.

    Parameters
    ----------
    obj : ndarray
        Must be ndarray, not checked.
    output
        Where printed output goes.

    Notes
    -----
    Copied over from the numarray module prior to its removal.
    Adapted somewhat as only numpy is an option now.

    Called by info.

    rv   c             S   s   | S )Nr!   )r   r!   r!   r"   rQ     rR   z_info.<locals>.<lambda>	__class__r#   zclass: )filezshape: z	strides: z
itemsize: z	aligned: zcontiguous: z	fortran: zdata pointer: %s%szbyteorder: r8   )endr   )|r]   z%s%s%sF>z%sbig%sbigz
%slittle%slittlez
byteswap: ztype: %sN)getattrtyperT   rV   	byteorderrm   rU   rW   flagsZaligned
contiguousZfortranhexctypesZ_as_parameter_valuerK   )
objoutputextraZticZbpclsnmrT   Zendianbyteswapr!   r!   r"   _info  s8    


r   L   c          	   C   sl  ddl }ddl}t| ds$t| dr,| j} nt| dr<| j} | dkrPtt nt| trjt| |d nt| t	rTt
dkrt|\a
ad}g }xtD ]}ylt
| |  }	t|	|krtd| |d n6|t|	 td	| |d t|	 td
| |d |d7 }W q tk
r   Y qX qW |dkr@td|  |d ntd| |d n|| r| j}
tt|  }t|
| |krt|
||}n|
| }td| d |d t|| |d n|| rZ| j}
d}yZt| dr2tt| jj }|d}t|dkr2d|d  |d< d|dd }W n tk
rJ   Y nX t|
| |krlt|
||}n|
| }td| d |d || }|dkrt| drt|| j|d nt|| |d || }|g krhtd|d xd|D ]\}|d dkrqt| |d}|dk	r<| ||p4d\}}td||f |d qW nt!j"d dk rt| t#j$rtd| j%j|d t|d t| drtt| j&j }|d}t|dkrd|d  |d< d|dd }nd}t| drd| j' }
nd}
t|
| |kr,t|
||}n|
| }td| d |d || j&}|dk	rrt|| j&|d t|| |d nt|| |d n|(| rJ| j}
tt| j }|d}t|dkrd|d  |d< d|dd }nd}t|
| |krt|
||}n|
| }td| d |d t|| |d nt| drht|| |d dS )a  
    Get help information for a function, class, or module.

    Parameters
    ----------
    object : object or str, optional
        Input object or name to get information about. If `object` is a
        numpy object, its docstring is given. If it is a string, available
        modules are searched for matching objects.  If None, information
        about `info` itself is returned.
    maxwidth : int, optional
        Printing width.
    output : file like object, optional
        File like object that the output is written to, default is
        ``stdout``.  The object has to be opened in 'w' or 'a' mode.
    toplevel : str, optional
        Start search at this level.

    See Also
    --------
    source, lookfor

    Notes
    -----
    When used interactively with an object, ``np.info(obj)`` is equivalent
    to ``help(obj)`` on the Python prompt or ``obj?`` on the IPython
    prompt.

    Examples
    --------
    >>> np.info(np.polyval) # doctest: +SKIP
       polyval(p, x)
         Evaluate the polynomial p at x.
         ...

    When using a string for `object` it is possible to get multiple results.

    >>> np.info('fft') # doctest: +SKIP
         *** Found in numpy ***
    Core FFT routines
    ...
         *** Found in numpy.fft ***
     fft(a, n=None, axis=-1)
    ...
         *** Repeat reference found in numpy.fft.fftpack ***
         *** Total of 3 references found. ***

    r   NZ_ppimport_importer_ppimport_module_ppimport_attr)r   z+
     *** Repeat reference found in %s *** )r   z     *** Found in %s ***-r7   zHelp for %s not found.z+
     *** Total of %d references found. ***r8   r-   z()r,   z, (z

Methods:
_Nonez  %s  --  %sr_   zInstance of class: rH   r%   z%sz<name>r:   ))pydocinspecthasattrr   r   r   rd   r	   r   rg   	_namedictr   	_dictlistre   rm   ri   KeyError
isfunctionr#   r   r   r?   r{   getdocisclassr,   __func__r<   r   	ExceptionZ
allmethodsr   ZsplitdocrK   version_infor   ZInstanceTyper   rH   r%   ismethod)objectZmaxwidthr   Ztoplevelr   r   ZnumfoundZobjlistrr   r   r%   rw   argstrrz   Zdoc1methodsmethZthisobjZmethstrotherrC   r!   r!   r"   r     s    4


















c             C   sZ   ddl }y,td||  |d t|| |d W n  tk
rT   td|d Y nX dS )a  
    Print or write to a file the source code for a NumPy object.

    The source code is only returned for objects written in Python. Many
    functions and classes are defined in C and will therefore not return
    useful information.

    Parameters
    ----------
    object : numpy object
        Input object. This can be any object (function, class, module,
        ...).
    output : file object, optional
        If `output` not supplied then source code is printed to screen
        (sys.stdout).  File object must be created with either write 'w' or
        append 'a' modes.

    See Also
    --------
    lookfor, info

    Examples
    --------
    >>> np.source(np.interp)                        #doctest: +SKIP
    In file: /usr/lib/python2.6/dist-packages/numpy/lib/function_base.py
    def interp(x, xp, fp, left=None, right=None):
        """.... (full docstring printed)"""
        if isinstance(x, (float, int, number)):
            return compiled_interp([x], xp, fp, left, right).item()
        else:
            return compiled_interp(x, xp, fp, left, right)

    The source code is only returned for objects written in Python.

    >>> np.source(np.array)                         #doctest: +SKIP
    Not available for this object.

    r   NzIn file: %s
)r   zNot available for this object.)r   rm   getsourcefile	getsourcer   )r   r   r   r!   r!   r"   r     s    )z[a-z0-9_]+\(.*[,=].*\)TFc          	      s  ddl }t||| g }t|   s0dS xL  D ]@\}\}}	}
|	dkrRq:| tfddD r:|| q:W dddddfd	d
 fdd}|j|d dd	 }|dt
| g}x|ddd D ]} | \}	}dd  dD }y(|d  }t|r2|d  }W n tk
rN   d}Y nX |d||f  qW |sv|d |dk	r|d	| n4t
|dkr| }|d	| ntd	| dS )a  
    Do a keyword search on docstrings.

    A list of objects that matched the search is displayed,
    sorted by relevance. All given keywords need to be found in the
    docstring for it to be returned as a result, but the order does
    not matter.

    Parameters
    ----------
    what : str
        String containing words to look for.
    module : str or list, optional
        Name of module(s) whose docstrings to go through.
    import_modules : bool, optional
        Whether to import sub-modules in packages. Default is True.
    regenerate : bool, optional
        Whether to re-generate the docstring cache. Default is False.
    output : file-like, optional
        File-like object to write the output to. If omitted, use a pager.

    See Also
    --------
    source, info

    Notes
    -----
    Relevance is determined only roughly, by checking if the keywords occur
    in the function name, at the start of a docstring, etc.

    Examples
    --------
    >>> np.lookfor('binary representation') # doctest: +SKIP
    Search results for 'binary representation'
    ------------------------------------------
    numpy.binary_repr
        Return the binary representation of the input number as a string.
    numpy.core.setup_common.long_double_representation
        Given a binary dump as given by GNU od -b, look for long double
    numpy.base_repr
        Return a string representation of a number in the given base system.
    ...

    r   N)r   r   c             3   s   | ]}| kV  qd S )Nr!   ).0w)rC   r!   r"   	<genexpr>  s    zlookfor.<locals>.<genexpr>i  i)r$   classr   r   c                s   d}d |  dd d  |t fddD 7 }|tfddD 7 }|t d 7 }||d7 }|d	 d
 7 }|t| d d7 }|S )Nr   r-   r_   c                s   g | ]}| krd qS )   r!   )r   r   )	first_docr!   r"   
<listcomp>&  s    z.lookfor.<locals>.relevance.<locals>.<listcomp>c                s   g | ]}| krd qS )   r!   )r   r   )r%   r!   r"   r   (  s    r^   i.r\   d   i)	r   lowerstripr<   sumr?   getcountrl   )r%   Zdocstrkindindexr)kind_relevancewhats)r   r%   r"   	relevance"  s     zlookfor.<locals>.relevancec                s   | f |   S )Nr!   )rZ   )rp   r   r!   r"   relevance_value2  s    z lookfor.<locals>.relevance_value)keyzSearch results for '%s'r8   r   c             S   s   g | ]}|  r|  qS r!   )r   )r   rG   r!   r!   r"   r   <  s    zlookfor.<locals>.<listcomp>r-   r7   rv   z	%s
    %szNothing found.r\   )r   _lookfor_generate_cacherg   r   r<   itemsallri   sortr   r?   r   _function_signature_research
IndexErrorwriteZgetpagerrm   )whatr   import_modules
regenerater   r   foundr%   	docstringr   r   r   sZ	help_textZixZdoclinesr   Zpagerr!   )rp   rC   r   r   r   r"   r     sJ    /



c          
   C   s  ddl }tjd dkr$ddlm} nddlm} | dkr<d} t| trtyt|  W n tk
rf   i S X tj	|  } n<t| t
st| tri }x| D ]}|t||| qW |S t| tkr|stt|  S i }|tt| < i }d}| j| fg}	x|	r|	d\}
}t||krqd|t|< |d7 }d}||rLd	}y
|j}W n tk
rd   d}Y nX |rlt|d
rlx|jD ]}xt|D ]}tj||}tj||d}tj|r|dr|dd }ntj|r|}nq|dkr qyDtj}tj}z$| t_| t_td|
|f  W d|t_|t_X W n tk
r^   wY nX qW qW xt |D ]\}}y$t!|dd|
|f }t!|dd}W n& t"k
r   d|
|f }d}Y nX d|kr|rd||f }|#|
d s
t|t$rvnqvn$||s.|dks.||ks.qv|	%d|
|f |f qvW nP|&|rd}x>t |D ] \}}|	%d|
|f |f qfW nt|drd}y|'|}W n t"k
r   d}Y nX |dk	r|||f||
< qW |S )a  
    Generate docstring cache for given module.

    Parameters
    ----------
    module : str, None, module
        Module for which to generate docstring cache
    import_modules : bool
        Whether to import sub-modules in packages.
    regenerate : bool
        Re-generate the docstring cache

    Returns
    -------
    cache : dict {obj_full_name: (docstring, kind, index), ...}
        Docstring cache for the module, either cached one (regenerate=False)
        or newly generated.

    r   Nr_   )StringIOr   Tr7   r   r   __path__z__init__.pyz.pyr,   z%s.%sr#   rI   r   r   rH   r$   )(r   rK   r   ior   rd   rg   r|   ImportErrormoduleslisttuplerA   r   re   _lookfor_cachesr#   r   ismodule__all__r9   r   r   r   listdirr   r   isfileendswithstdoutstderrBaseException_getmembersr   	NameError
startswithr
   ri   r   r   )r   r   r   r   r   rp   modseenr   stackr%   itemr   Z_allpthZmod_pathZthis_pyinit_pyZ	to_importZ
old_stdoutZ
old_stderrnvZ	item_namemod_namerC   r!   r!   r"   r   T  s    







 
r   c                sF   dd l }y| }W n* tk
r@    fddt D }Y nX |S )Nr   c                s$   g | ]}t  |r|t |fqS r!   )r   r   )r   r   )r   r!   r"   r     s    z_getmembers.<locals>.<listcomp>)r   
getmembersr   dir)r   r   membersr!   )r   r"   r     s    r   c             C   s   ddl }|| S )a  
    Protected string evaluation.

    Evaluate a string containing a Python literal expression without
    allowing the execution of arbitrary non-literal code.

    Parameters
    ----------
    source : str
        The string to evaluate.

    Returns
    -------
    obj : object
       The result of evaluating `source`.

    Raises
    ------
    SyntaxError
        If the code has invalid Python syntax, or if it contains
        non-literal code.

    Examples
    --------
    >>> np.safe_eval('1')
    1
    >>> np.safe_eval('[1, 2, 3]')
    [1, 2, 3]
    >>> np.safe_eval('{"foo": ("bar", 10.0)}')
    {'foo': ('bar', 10.0)}

    >>> np.safe_eval('import os')
    Traceback (most recent call last):
      ...
    SyntaxError: invalid syntax

    >>> np.safe_eval('open("/home/user/.ssh/id_dsa").read()')
    Traceback (most recent call last):
      ...
    ValueError: malformed node or string: <_ast.Call object at 0x...>

    r   N)astliteral_eval)r   r   r!   r!   r"   r     s    ,c             C   s   | j dkr|S t| |d} t| d }tj|r@|d}|jdkr|dkr|dk	rr| j	tj
|d< |}q| j	tj
}nt| dkrtj
||< |S )aj  
    Utility function to check median result from data for NaN values at the end
    and return NaN in that case. Input result can also be a MaskedArray.

    Parameters
    ----------
    data : array
        Input data to median function
    result : Array or MaskedArray
        Result of median function
    axis : {int, sequence of int, None}, optional
        Axis or axes along which the median was computed.
    out : ndarray, optional
        Output array in which to place the result.
    Returns
    -------
    median : scalar or ndarray
        Median or NaN in axes which contained NaN in the input.
    r   r   ).r   FTN.)rX   npZmoveaxisisnanmaZisMaskedArrayZfilledndimrV   r   nanZcount_nonzeroZravel)rS   resultZaxisoutr   r!   r!   r"   _median_nancheck  s    



r  )N)r   )NTFN)3
__future__r   r   r   r   rK   r   rer0   Znumpy.core.numerictypesr   r   r   Znumpy.core.overridesr   r   r	   r
   r   r   r   numpy.compatr   r   r   r   r&   r   r'   r=   r   r   r   r   r{   r   r   r   r   r   r   r   r   compileIr   r   r   r   r   r  r!   r!   r!   r"   <module>   sR   

K49
i
3 N3 z 
0