HEX
Server: Apache
System: Linux pdx1-shared-a1-38 6.6.104-grsec-jammy+ #3 SMP Tue Sep 16 00:28:11 UTC 2025 x86_64
User: mmickelson (3396398)
PHP: 8.1.31
Disabled: NONE
$ pwd: /lib/python3/dist-packages/numpy/distutils/__pycache__/
Upload Files
File: //lib/python3/dist-packages/numpy/distutils/__pycache__/misc_util.cpython-310.pyc
o

6��a�T�@sHddlZddlZddlZddlZddlZddlZddlZddlZddlZddl	Z	ddl
Z
ddlZddl
mZddlZddlmZe�ZgZdd�Ze�e�gd�ZGdd�d�Zd	d
�Zdd�Zd
d�Zdd�Zd�dd�Zdd�Zd�dd�Zdd�Z dd�Z!dd�Z"d�dd �Z#d�d!d"�Z$d#d$�Z%e%�r�e&dd%d&d'd(d)d*d+d,d-�	Z'd�d/d0�Z(nd�d1d0�Z(d2d3�Z)d4d5�Z*d6d7�Z+d8d9�Z,d:d;�Z-d<d=�Z.d>d?�Z/d@dA�Z0dBdC�Z1dDdE�Z2dFdG�Z3e�4dHej5�j6Z7e�4dIej5�j6Z8e�4dJej5�j6Z9e�4dKej5�j6Z:dLdM�Z;dNdO�Z<dPdQ�Z=dRdS�Z>dTdU�Z?dVdW�Z@dXdY�ZAdZd[�ZBd\d]�ZCd^d_�ZDd`da�ZEdbdc�ZFddde�ZGdfdg�ZHdhdi�ZIdjdk�ZJdldm�ZKdndo�ZLdpdq�ZMdrds�ZNd�dtdu�ZOdvdw�ZPdxdy�ZQd�dzd{�ZRGd|d}�d}�ZSifd~d�ZTd�d��ZUd�d��ZVd�d�d��ZWd�d�d��ZXd�d��ZYd�d�d��ZZd�d��Z[d�d��Z\d�d��Z]d�d��Z^d�d��Z_d�d�hZ`d�d��Zad�d��ZbdS)��N)�local)�DistutilsErrorc	Cs:tdurtD]}zt�|�WqtyYqwdSdS�N)�_tmpdirs�shutil�rmtree�OSError)�d�r
�;/usr/lib/python3/dist-packages/numpy/distutils/misc_util.py�clean_up_temporary_directorys��r)+�
Configuration�get_numpy_include_dirs�default_config_dict�dict_append�
appendpath�generate_config_py�get_cmd�allpath�get_mathlibs�terminal_has_colors�red_text�
green_text�yellow_text�	blue_text�	cyan_text�	cyg2win32�mingw32�all_strings�
has_f_sources�has_cxx_sources�filter_sources�get_dependencies�is_local_src_dir�get_ext_source_files�get_script_files�get_lib_source_files�get_data_files�dot_join�	get_frame�
minrelpath�njoin�is_sequence�	is_string�as_list�gpaths�get_language�
quote_args�get_build_architecture�get_info�get_pkg_info�get_num_build_jobs�sanitize_cxx_flags�exec_mod_from_locationc@seZdZdZdd�ZdS)�InstallableLiba�
    Container to hold information on an installable library.

    Parameters
    ----------
    name : str
        Name of the installed library.
    build_info : dict
        Dictionary holding build information.
    target_dir : str
        Absolute path specifying where to install the library.

    See Also
    --------
    Configuration.add_installed_library

    Notes
    -----
    The three parameters are stored as attributes with the same names.

    cCs||_||_||_dSr)�name�
build_info�
target_dir)�selfr9r:r;r
r
r�__init__Es
zInstallableLib.__init__N)�__name__�
__module__�__qualname__�__doc__r=r
r
r
rr8/sr8cCs�ddlm}z	tt�d��}Wn
tyt��}Ynwt|d�}t	tj
�d|��}|�}|dur4|St|�
d�dd�t|�
d�dd�t|�
d	�dd�f}td
d�|D��rY|Stdd�|D��S)
a�
    Get number of parallel build jobs set by the --parallel command line
    argument of setup.py
    If the command did not receive a setting the environment variable
    NPY_NUM_BUILD_JOBS is checked. If that is unset, return the number of
    processors on the system, with a maximum of 8 (to prevent
    overloading the system if there a lot of CPUs).

    Returns
    -------
    out : int
        number of parallel jobs that can be run

    r��get_distribution��NPY_NUM_BUILD_JOBSN�build�parallel�	build_ext�
build_clibcss�|]}|duVqdSrr
��.0�xr
r
r�	<genexpr>js�z%get_num_build_jobs.<locals>.<genexpr>css�|]	}|dur|VqdSrr
rJr
r
rrMms�)�numpy.distutils.corerC�len�os�sched_getaffinity�AttributeError�multiprocessing�	cpu_count�min�int�environ�get�getattr�get_command_obj�all�max)rCrT�envjobs�dist�cmdattrr
r
rr5Ks$�
�r5cCsFt|�}tt|��D]}||}d|vr |ddvr d|||<q
|S)N� rz"'z"%s")�list�rangerO)�args�i�ar
r
rr1os�r1cCs|�d�}tjj|�S)zDConvert a /-separated pathname to one using the OS's path separator.�/)�splitrP�path�join)r9�splittedr
r
rrys
rcCs�tj�tj�|��}tj�tj�|��}t|�t|�kr|S||kr$dS||dt|��krN|t|�tjfvsDJt||t|�f���|t|�dd�}|S)z$Return path relative to parent_path.�N�)rPrh�realpath�abspathrO�sep�repr)rh�parent_path�pd�apathr
r
r�rel_path~s,rtcCs�ztd|j|j�}tj�tj�|��}Wn1tyEtd|j|j�}t|�t	j
|}t|d�r=tj�tj�|j��}ntj�d�}Ynw|durOt
||�}|pRdS)z�Return path of the module given a frame object from the call stack.

    Returned path is relative to parent_path when given,
    otherwise it is absolute path.
    �__file__r>�.N)�eval�	f_globals�f_localsrPrh�dirnamern�	NameError�
__import__�sys�modules�hasattrrurt)�framerq�caller_filer	�caller_name�modr
r
r�get_path_from_frame�s

��
r�cGszg}|D]}t|�r|�t|��qt|�sJ�|�|�q|}|s%d}ntjj|�}tjjdkr9|�dtjj�}t	|�S)a2Join two or more pathname components +
    - convert a /-separated pathname to one using the OS's path separator.
    - resolve `..` and `.` from path.

    Either passing n arguments as in njoin('a','b'), or a sequence
    of n names as in njoin(['a','b']) is handled, or a mixture of such arguments.
    rkrf)
r,�appendr+r-rPrhriro�replacer*)rh�paths�p�joinedr
r
rr+�sr+c	Cs�|durtj�|d�}n t�}|D]}tj�|d�}tj�|�r$|}nqtd|f��t|��+}g}d}|D]}|�|�rR|t|�d��	�}|rR|�
|�d��q7Wd�|S1s^wY|S)z/Return the MATHLIB line from numpyconfig.h
    Nz_numpyconfig.hz1_numpyconfig.h not found in numpy include dirs %rz#define MATHLIB�,)rPrhrir�existsr�open�
startswithrO�strip�extendrg)	rh�config_file�dirs�fn�fid�mathlibs�s�line�valuer
r
rr�s4��

��
��rcCs�t|�s|Sd|vr|S|�tj�}|r+z|�dd�}Wn	ty%Ynw||=|sd}|rZz|�d|�}Wn	ty@Ynw||ddkrN|d7}n
||=||d=d}|s/|s^dStj�|�S)z$Resolve `..` and '.' from path.
    rvrlz..rk)r-rgrPro�index�
ValueErrorri)rh�lrd�jr
r
rr*�s8���
�
r*cCstt�|��S)z}sorts output of python glob for https://bugs.python.org/issue30461
    to allow extensions to have reproducible build results)�sorted�glob)�fileglobr
r
r�sorted_glob�sr�cCsBt|�sJtt|����g}t|�rJt|���|D]}t|�r�d|vs(d|vrSt|�}tt||��}|r;|�|�q|rC|�|�q|rJ|�|�td||f�qt||�}t	j
�|�rd|�|�qt	j
�|�rp|�|�n|rw|�|�t	j
�|�s�td||f�qt|�r�|�t|||��q|�|�qdd�|D�S)N�*�?z#could not resolve pattern in %r: %rznon-existing path in %r: %rcSsg|]}t|��qSr
)r*�rKr�r
r
r�
<listcomp>%�z_fix_paths.<locals>.<listcomp>)
r,rp�typer-r�r+r�r��printrPrhr��
_fix_paths)r��
local_path�include_non_existing�	new_paths�nr��p2�n2r
r
rr�sB
�

��r�rkTcCst|�r|f}t|||�S)z:Apply glob to paths and prepend local_path if needed.
    )r-r�)r�r�r�r
r
rr/'sr/cCsLttd�st��t_t�tj�tj||tj|d�\}}t�	|d�}||fS)N�tempdir)�suffix�prefix�dir�text�w)
r�_tdata�tempfile�mkdtempr�rr��mkstemprP�fdopen)r�r�r�r�r9�for
r
r�make_temp_file.s


�r�cCs�tjdkrdtjvrdSttjd�rgtj��rgzEddl}|��|�	d�dkrT|�	d�dkrW|�
d�dur<|�
d�dusQ|�
d	�durJ|�
d
�dusQ|�
d�durZWdSWdSWdSWdStyfYdSwdS)
N�cygwin�	USE_COLORr�isatty�colors�pairs�setf�setb�setaf�setab�scprl)r}�platformrPrWr�stdoutr��curses�	setupterm�tigetnum�tigetstr�	Exception)r�r
r
rr;s2	�
�	���rrl�������	)	�black�red�green�yellow�blue�magenta�cyan�white�defaultFcCsxg}|r	|�d�|rdt�|��d�}|�t|��|r/dt�|��d�}|�t|��|r:dd�|�|fS|S)N�1�r�(r�z[%sm%s�;)r��
_colour_codesrX�lower�strri)r��fg�bg�bold�seq�fgcode�bgcoder
r
r�colour_textYs
r�cCs|Srr
)r�r�r�r
r
rr�hscC�
t|d�S)Nr��r��r�r
r
r�default_textk�
r�cCr�)Nr�r�r�r
r
rrmr�rcCr�)Nr�r�r�r
r
rror�rcCr�)Nr�r�r�r
r
rrqr�rcCr�)Nr�r�r�r
r
rrsr�rcCr�)Nr�r�r�r
r
rrur�rcCs8tjdkr|�d�r|ddtj�|dd��}|S)Nr�z	/cygdrive�
�:�)r}r�r�rPrh�normcase)rhr
r
rrzs rcCs:tjdkrtj�dd�dkrdStj�dd�dkrdSdS)	z0Return true when using mingw32 environment.
    �win32�OSTYPErk�msysT�MSYSTEM�MINGW32F)r}r�rPrWrXr
r
r
rrs
rcCs:tj�d�}|dkrttj|d|d��}|Sd}|S)zGReturn version of MSVC runtime library, as defined by __MSC_VER__ macrozMSC v.���r�r�N)r}�version�findrV)�msc_pos�msc_verr
r
r�msvc_runtime_version�s�r�cCs&t�}|r|dkr
d|Sd|SdS)zFReturn name of MSVC runtime library if Python was built with MSVC >= 7�zmsvcr%izvcruntime%iN)�msvc_runtime_major)�verr
r
r�msvc_runtime_library�srcCs ddddddd��t�d�}|S)	zFReturn major version of MSVC runtime coded like get_build_msvc_version�F�G�P�Z�dr�)iiixi�i@ilN)rXr�)�majorr
r
rr��s�
�r�z.*\.(cpp|cxx|cc)\Zz.*\.(f90|f95|f77|for|ftn|f)\Zz.*\.(f90|f95)\Zz\s*module\s*(?P<name>[\w_]+)cCsjt|�sgSg}t|d��}|D]}t|�}|r"|�d�}|�|�qWd�|S1s.wY|S)zRReturn a list of Fortran f90 module names that
    given source file defines.
    �rr9N)�
f90_ext_matchr��f90_module_name_match�groupr�)�sourcer~�fr��mr9r
r
r�_get_f90_modules�s

��
��rcCs
t|t�Sr)�
isinstancer�r�r
r
rr-�r�r-cCs|D]	}t|�sdSqdS)z4Return True if all items in lst are string objects. FT�r-)�lst�itemr
r
rr��
�rcCs0t|�rdSzt|�WdStyYdSw)NFT)r-rOr��r�r
r
rr,�s
��r,cCst|�od|vpd|vS)Nr�r�rr�r
r
r�is_glob_pattern�srcCst|�rt|�S|gSr)r,rarr
r
rr.�sr.cCs:d}|D]}t|t�rt|�rd}|St|�rd}q|S)z2Determine language value (c,f77,f90) from sources N�f90�f77)rr�r	�fortran_ext_match)�sources�languagerr
r
rr0�s
��r0cC�|D]	}t|�rdSqdS)z.Return True if sources contains Fortran files TF)r�rrr
r
rr�rrcCr)z*Return True if sources contains C++ files TF)�
cxx_ext_matchrr
r
rr �rr cCspg}g}g}g}|D]'}t|�r"t|�}|r|�|�q
|�|�q
t|�r,|�|�q
|�|�q
||||fS)ztReturn four lists of filenames containing
    C, C++, Fortran, and Fortran 90 module sources,
    respectively.
    )rrr�r)r�	c_sources�cxx_sources�	f_sources�fmodule_sourcesrr~r
r
rr!�sr!cCs.g}|D]}ttj�|d��}|�|�q|S)Nz*.h)r�rPrhrir�)�directory_list�headersr	�headr
r
r�_get_headers
s
r&cCsDg}|D]}tj�|�}|ddkr|d|vr|�|d�q|S)Nrrk)rPrhrgr�)�list_of_sources�direcsr
r	r
r
r�_get_directoriess�r)cCs6d}|d�|�7}|d�|�7}|d�|�d7}|S)zb
    Return commandline representation used to determine if a file needs
    to be recompiled
    z
commandline: r`�
�ri)�cc_args�extra_postargs�pp_opts�cmdliner
r
r�_commandline_dep_strings
r0cCstt|��Sr)r&r))rr
r
rr"*sr"cCs�t|�sdStj�|�}tj�t��|g�}|t|�d��tj�}|r.|ds.|dd�}|r8|ddkr8dStj�	|�}tj�
|�S)z1Return true if directory is local directory.
    FNrrlrF)r-rPrhrn�commonprefix�getcwdrOrgrori�isdir)�	directory�abs_dir�c�new_dirr
r
rr#.sr#c#sx�dddd��t�d�}tj|dd�D]&\}}}�fdd�|D�}||dd�<|D]}|�|�s8tj�||�Vq)qdS)Nrl��CVS�.svnrF�(?:[~#]|\.py[co]|\.o)$T��topdownc�g|]}|�vr|�qSr
r
�rKr	��pruned_directoriesr
rr�A�z(general_source_files.<locals>.<listcomp>)�re�compilerP�walk�searchrhri)�top_path�prune_file_pat�dirpath�dirnames�	filenames�prunedr
r
r@r�general_source_files=s�

���rMc
#s��gd��t�d��tj|dd�D]K\}}}�fdd�|D�}||dd�<|D]4}tj�||��t�|�}g}t���D]}tj��|�}	tj�|	�rU��	|	�sU|�
|	�q<||fVq'q|�t�|�}��fdd�t���D�}d	d�|D�}||fVdS)
zJReturn a directory name relative to top_path and
    files contained.
    r8r;Tr<cr>r
r
r?r@r
rr�NrBz4general_source_directories_files.<locals>.<listcomp>Ncs$g|]}��|�stj��|��qSr
)rFrPrhri�rKr
)�dpathrHr
rr�[s�cS�g|]
}tj�|�r|�qSr
)rPrh�isfilerNr
r
rr�]�)rCrDrPrErhrirt�listdirrQrFr�)
rGrIrJrKrLr	�rpath�filesr
r�r
)rOrHrAr� general_source_directories_filesGs,�


��	
rVcCsng}dd�|jD�}|�|�|�t|��|jD]}t|�r)|�tt|���qtj�	|�r4|�
|�q|S)NcS�g|]}t|�r|�qSr
r�rK�_mr
r
rr�drBz(get_ext_source_files.<locals>.<listcomp>)rr�r"�dependsr#rarMrPrhrQr�)�extrKrr	r
r
rr$as


�r$cCsdd�|D�}|S)NcSrWr
rrXr
r
rr�orBz$get_script_files.<locals>.<listcomp>r
)�scriptsr
r
rr%nsr%cCs�g}|d�dg�}dd�|D�}|�|�|�t|��|d�dg�}|D]}t|�r7|�tt|���q'tj�|�rB|�	|�q'|S)NrlrcSrWr
rrXr
r
rr�urBz(get_lib_source_files.<locals>.<listcomp>rZ)
rXr�r"r#rarMrPrhrQr�)�librKrrZr	r
r
rr&rs

�r&cCs�tj��}|�dd�}|dur|�dd�}|sKtj�d�s#tj�d�r'd}|Stj�d�r1d	}|Stj�d
�r;d}|Sd|vrK|�d
|�d�dd�}|S)a;Return the correct file extension for shared libraries.

    Parameters
    ----------
    is_python_ext : bool, optional
        Whether the shared library is a Python extension.  Default is False.

    Returns
    -------
    so_ext : str
        The shared library extension.

    Notes
    -----
    For Python shared libs, `so_ext` will typically be '.so' on Linux and OS X,
    and '.pyd' on Windows.  For Python >= 3.2 `so_ext` has a tag prepended on
    POSIX systems according to PEP 3149.  For Python 3.2 this is implemented on
    Linux, but not on OS X.

    �
EXT_SUFFIXN�SOrk�linux�gnukfreebsdz.so�darwinz.dylib�winz.dll�SOABIrvrl)�	distutils�	sysconfig�get_config_varsrXr}r�r�r�)�
is_python_ext�confvars�so_extr
r
r�get_shared_lib_extension�s&

��
��rkcCs�t|�r|gS|d}g}|D]1}t|d�rqt|�r%|�tt|���qt|�r;tj�|�r5|�	|�qt
d|�qtt|���|S)Nrl�__call__zNot existing data file:)
r-rr#r�rarMrPrhrQr�r��	TypeErrorrp)�datarrKr�r
r
rr'�s
r'cGsd�dd�|D��S)NrvcSsg|]}|r|�qSr
r
)rKrer
r
rr��r�zdot_join.<locals>.<listcomp>r+)rcr
r
rr(�sr(cCsNzt�|d�WSty&t��dj}t|d�D]}|j}q|YSw)z:Return frame object from call stack with given level.
    rlr�)r}�	_getframerR�exc_info�tb_framerb�f_back)�levelr��_r
r
rr)�s�r)c@s�eZdZgd�ZddgZddgZgZ						dXd	d
�Zdd�Zd
d�Z	dd�Z
dd�Zdd�Z	dYdd�Z
	dYdd�Z			dZdd�Z		d[dd�Zdd�Zd d!�Zd"d#�Zd$d%�Zd&d'�Zd(d)�Zd*d+�Zd,d-�Zd.d/�Zd0d1�Zd2d3�Zd\d4d5�Zd\d6d7�Zd8d9�Zd:d;�Zd<d=�Z d>d?�Z!d@dA�Z"dBdC�Z#dDdE�Z$dFdG�Z%dHdI�Z&dJdK�Z'd]dLdM�Z(d^dOdP�Z)d^dQdR�Z*d_dTdU�Z+dVdW�Z,dS)`r
)
�packages�ext_modules�
data_files�include_dirs�	librariesr$r\�
py_modules�installed_libraries�
define_macros�package_dir�installed_pkg_configr9r�Nrl�setup.pyc	Ks|t||�|_d|_t|�}t||�|_|dur|j}d|_|dur%|j}ntj�t	|j|��r5t	|j|�}tj�|p;d�sDt
d|f��||_||_tjj
|j�d��|_|jdd�|_|jdd�|_|jD]}	t�|�|	g��}
t||	t|
��qh|jD]}	t�|�|	i��}
t||	|
�q|j|j}|jdd�|_|��D]/}	|	|vr�q�||	}t||	|�t|t�r�|j�|	�q�t|t�r�|j�|	�q�|j�|	�q�tj�t	|d��r�|j �|j�||j!|j<tddddd�|_"d}
t#dd	�D])}zt|�}Wnt
�yYnwzt$d
|j%|j&�}
Wn
t'�y"Yq�wt|
|j(��r9|
j"d�r9|j)di|
j"��||_*dS)
a�Construct configuration instance of a package.

        package_name -- name of the package
                        Ex.: 'distutils'
        parent_name  -- name of the parent package
                        Ex.: 'numpy'
        top_path     -- directory of the toplevel package
                        Ex.: the directory where the numpy package source sits
        package_path -- directory of package. Will be computed by magic from the
                        directory of the caller module if not specified
                        Ex.: the directory where numpy.distutils is
        caller_level -- frame level to caller namespace, internal parameter.
        Nrkrvz%r is not a directory�__init__.pyF)�ignore_setup_xxx_py�assume_default_configuration�delegate_options_to_subpackages�quietrlr�r<r�r
)+r(r9r�r)r�r�rPrhr3r+r�rG�package_pathrirg�path_in_package�
_list_keys�	list_keys�
_dict_keys�	dict_keys�copyrX�setattrr.�_extra_keys�
extra_keys�keysrrar��dictr�rur}�optionsrbrwrxryr{�	__class__�set_options�
setup_name)r<�package_name�parent_namerGr��caller_levelr��attrs�caller_framer��v�
known_keysre�caller_instancerdr
r
r
rr=�s|



���
zConfiguration.__init__cCsB|��i}|j|j|j}|D]
}t||�}|r|||<q|S)z�
        Return a dictionary compatible with the keyword arguments of distutils
        setup function.

        Examples
        --------
        >>> setup(**config.todict())                           #doctest: +SKIP
        )�_optimize_data_filesr�r�r�rY)r<r	r�r�rer
r
r�todict>s

�zConfiguration.todictcCs|jdst|�dSdS)Nr�)r�r��r<�messager
r
r�infoQs
�zConfiguration.infocCstj�d|f�dS)NzWarning: %s
)r}�stderr�writer�r
r
r�warnUszConfiguration.warncKs6|��D]\}}||jvr||j|<qtd|��dS)z�
        Configure Configuration instance.

        The following options are available:
         - ignore_setup_xxx_py
         - assume_default_configuration
         - delegate_options_to_subpackages
         - quiet

        zUnknown option: N)�itemsr�r�)r<r��keyr�r
r
rr�Xs

�zConfiguration.set_optionscCsddlm}|�S)z2Return the distutils distribution object for self.rrB)rNrC)r<rCr
r
rrCiszConfiguration.get_distributioncCs�|�d�}t|jg|�}dd�t|�D�}g}|D]4}tj�t|d��s&qd|�tj�vr/qd�|�tj�t	|�d��}	|j
|	||dd�}
|�|
�q|S)NrvcSrPr
)rPrhr3rXr
r
rr�srRz:Configuration._wildcard_get_subpackage.<locals>.<listcomp>r�rFrl�r�r�)rgr+r�r�rPrhrQrorirO�get_subpackager�)r<�subpackage_namer�r�r��subpackage_pathr��config_listr	r�r6r
r
r�_wildcard_get_subpackagens 
 �z&Configuration._wildcard_get_subpackagecCs&tj�dtj�|��z�tj�tj�|��d}t|j||�}t	d�
|�d��|�}t|d�sH|j
ds;|�d|�t|||j||dd�}	n#t|g|�d�dd	��}
|
f}|jjjdkrf||jf}|j|�}	|	jt||�kr�|�d
t||�|	jf�Wtjd=|	SWtjd=|	Stjd=w)Nrrtrv�
configurationr�zCAssuming default configuration (%s does not define configuration())rl�r�r�z*Subpackage %r configuration returned as %r)r}rh�insertrPrz�splitext�basenamer(r9r7rirgrr�r�r
rGr��__code__�co_argcount)r<�setup_pyr�r�r�r�r�r��setup_module�config�pnrcr
r
r� _get_configuration_from_setup_py�s>�

��
��
�z.Configuration._get_configuration_from_setup_pycCsL|dur|durtd��tj�|�}|�d�}|dur)d|vr)|j|||dd�Sd|vs6Jt|||f���|durCt|jg|�}nt|g|dd��}|�	|g�d}t||j
�}|jd	sntj�|�snt|d
|�}tj�|�s�|jds�|�
dtj�|�|f�t|||j||dd�}n|j|||||dd�}|r�|gSgS)
aReturn list of subpackage configurations.

        Parameters
        ----------
        subpackage_name : str or None
            Name of the subpackage to get the configuration. '*' in
            subpackage_name is handled as a wildcard.
        subpackage_path : str
            If None, then the path is assumed to be the local path plus the
            subpackage_name. If a setup.py file is not found in the
            subpackage_path, then a default configuration is used.
        parent_name : str
            Parent name.
        Nz;either subpackage_name or subpackage_path must be specifiedrvr�rlr�r�rr�zsetup_%s.pyr�zEAssuming default configuration (%s/{setup_%s,setup}.py was not found))r�rPrhr�rgr�rpr+r�r�r�r�rQr�rzr
rGr�)r<r�r�r�r�r�r�r�r
r
rr��sT�
�
�
���zConfiguration.get_subpackageFc	Cs�|rd}n|j}|j|||dd�}|s|�d�|D]/}|}t|t�r'|��}t|t�s4Jtt|����|�	d|�
d�|jf�|jdi|��q|��}|dur[|�d|�dSdS)	aAdd a sub-package to the current Configuration instance.

        This is useful in a setup.py script for adding sub-packages to a
        package.

        Parameters
        ----------
        subpackage_name : str
            name of the subpackage
        subpackage_path : str
            if given, the subpackage path such as the subpackage is in
            subpackage_path / subpackage_name. If None,the subpackage is
            assumed to be located in the local path / subpackage_name.
        standalone : bool
        Nr�r�z0No configuration returned, assuming unavailable.z Appending %s configuration to %sr9zTdistutils distribution has been initialized, it may be too late to add a subpackage r
)
r9r�r�rr
r�r�rpr�r�rXrrC)	r<r�r��
standaloner�r�r�r	r^r
r
r�add_subpackage�s0�

�
��zConfiguration.add_subpackagec
s�t|�r	|\�}nd�t|�r��fdd�|D�dSt|�s&td|f���durBtj�|�r;��tj�|�|f�S��||f�S�j|dd�}t	|��rt	��r�t
���tj�}|�
�ttt|�d��}|�
�|D]	}||sw||=qn|D]|}tj�|�s�td|�qzt|�j�}|�tj�}|�
�g}	d	}|D]9}
t	|
�r�|t|�kr�td
�|f��|	�||�n|
||ks�Jt|
|||�||f���|	�|
�|d7}q�||d�r��d||f�|	�
���tj�|	�|f�qzdS|D]	}���|f�q�dSt	���rJt�������}|du�r%|jdu�r%|j}n�j}|D]}tt|��D]\}
}tj��j�|
�}|�||f��q2�q*dS)a�Recursively add files under data_path to data_files list.

        Recursively add files under data_path to the list of data_files to be
        installed (and distributed). The data_path can be either a relative
        path-name, or an absolute path-name, or a 2-tuple where the first
        argument shows where in the install directory the data directory
        should be installed to.

        Parameters
        ----------
        data_path : seq or str
            Argument can be either

                * 2-sequence (<datadir suffix>, <path to data directory>)
                * path to data directory where python datadir suffix defaults
                  to package dir.

        Notes
        -----
        Rules for installation paths::

            foo/bar -> (foo/bar, foo/bar) -> parent/foo/bar
            (gun, foo/bar) -> parent/gun
            foo/* -> (foo/a, foo/a), (foo/b, foo/b) -> parent/foo/a, parent/foo/b
            (gun, foo/*) -> (gun, foo/a), (gun, foo/b) -> gun
            (gun/*, foo/*) -> parent/gun/a, parent/gun/b
            /foo/bar -> (bar, /foo/bar) -> parent/bar
            (gun, /foo/bar) -> parent/gun
            (fun/*/gun/*, sun/foo/bar) -> parent/fun/foo/gun/bar

        Examples
        --------
        For example suppose the source directory contains fun/foo.dat and
        fun/bar/car.dat:

        >>> self.add_data_dir('fun')                       #doctest: +SKIP
        >>> self.add_data_dir(('sun', 'fun'))              #doctest: +SKIP
        >>> self.add_data_dir(('gun', '/full/path/to/fun'))#doctest: +SKIP

        Will install data-files to the locations::

            <package install directory>/
              fun/
                foo.dat
                bar/
                  car.dat
              sun/
                foo.dat
                bar/
                  car.dat
              gun/
                foo.dat
                car.dat

        Ncsg|]	}���|f��qSr
)�add_data_dirr��r	r<r
rr�Gsz.Configuration.add_data_dir.<locals>.<listcomp>znot a string: %rF�r�rlzNot a directory, skippingrzcannot fill pattern %r with %rz,mismatch of pattern_list=%s and path_list=%s)r,r-rmrPrh�isabsr�r�r�rrrgro�reverserarbrOr3r�rtr�r�r�rpr�rirCrwrVr�)r<�	data_pathr��pattern_list�rlrdrhrT�	path_list�target_listr�r^rw�d1r
�target_pathr
r�rr�
s|8

�
�(

����zConfiguration.add_data_dircCs^i}|jD]\}}||vrt�||<|D]	}||�|�qqdd�|��D�|jdd�<dS)NcSsg|]
\}}|t|�f�qSr
)ra)rKr�rUr
r
rr��rRz6Configuration._optimize_data_files.<locals>.<listcomp>)rw�set�addr�)r<�	data_dictr�rUr
r
r
rr��s
� z"Configuration._optimize_data_filescGst|�dkr|D]}|�|�qdSt|�dksJ�t|d�r'|d\}}nd}t|�r0|}n%t|�rMt|�dkr?|d}n|D]	}|�||f�qAdSttt|����|duryt|d�rad}ntj	�
|�rjd}ntj	�|�}|�||f�dS|j|dd�}t
|�r�t
|�r�|�tj�}|��|D]=}|�tj�}|��|��g}	d}
|D]}t
|�r�|	�||
�|
d7}
q�|	�|�q�|	��|�tj�|	�|f�q�dS|�||f�dSt
|�r�Jt||f���|��}|dur�|jdur�|j}
n|j}
|
�tj	�|j|�|f�dS)a�Add data files to configuration data_files.

        Parameters
        ----------
        files : sequence
            Argument(s) can be either

                * 2-sequence (<datadir prefix>,<path to data file(s)>)
                * paths to data files where python datadir prefix defaults
                  to package dir.

        Notes
        -----
        The form of each element of the files sequence is very flexible
        allowing many combinations of where to get the files from the package
        and where they should ultimately be installed on the system. The most
        basic usage is for an element of the files argument sequence to be a
        simple filename. This will cause that file from the local path to be
        installed to the installation path of the self.name package (package
        path). The file argument can also be a relative path in which case the
        entire relative path will be installed into the package directory.
        Finally, the file can be an absolute path name in which case the file
        will be found at the absolute path name but installed to the package
        path.

        This basic behavior can be augmented by passing a 2-tuple in as the
        file argument. The first element of the tuple should specify the
        relative path (under the package install directory) where the
        remaining sequence of files should be installed to (it has nothing to
        do with the file-names in the source distribution). The second element
        of the tuple is the sequence of files that should be installed. The
        files in this sequence can be filenames, relative paths, or absolute
        paths. For absolute paths the file will be installed in the top-level
        package installation directory (regardless of the first argument).
        Filenames and relative path names will be installed in the package
        install directory under the path name given as the first element of
        the tuple.

        Rules for installation paths:

          #. file.txt -> (., file.txt)-> parent/file.txt
          #. foo/file.txt -> (foo, foo/file.txt) -> parent/foo/file.txt
          #. /foo/bar/file.txt -> (., /foo/bar/file.txt) -> parent/file.txt
          #. ``*``.txt -> parent/a.txt, parent/b.txt
          #. foo/``*``.txt`` -> parent/foo/a.txt, parent/foo/b.txt
          #. ``*/*.txt`` -> (``*``, ``*``/``*``.txt) -> parent/c/a.txt, parent/d/b.txt
          #. (sun, file.txt) -> parent/sun/file.txt
          #. (sun, bar/file.txt) -> parent/sun/file.txt
          #. (sun, /foo/bar/file.txt) -> parent/sun/file.txt
          #. (sun, ``*``.txt) -> parent/sun/a.txt, parent/sun/b.txt
          #. (sun, bar/``*``.txt) -> parent/sun/a.txt, parent/sun/b.txt
          #. (sun/``*``, ``*``/``*``.txt) -> parent/sun/c/a.txt, parent/d/b.txt

        An additional feature is that the path to a data-file can actually be
        a function that takes no arguments and returns the actual path(s) to
        the data-files. This is useful when the data files are generated while
        building the package.

        Examples
        --------
        Add files to the list of data_files to be included with the package.

            >>> self.add_data_files('foo.dat',
            ...     ('fun', ['gun.dat', 'nun/pun.dat', '/tmp/sun.dat']),
            ...     'bar/cat.dat',
            ...     '/full/path/to/can.dat')                   #doctest: +SKIP

        will install these data files to::

            <package install directory>/
             foo.dat
             fun/
               gun.dat
               nun/
                 pun.dat
             sun.dat
             bar/
               car.dat
             can.dat

        where <package install directory> is the package (or sub-package)
        directory such as '/usr/lib/python2.4/site-packages/mypackage' ('C:
        \Python2.4 \Lib \site-packages \mypackage') or
        '/usr/lib/python2.4/site- packages/mypackage/mysubpackage' ('C:
        \Python2.4 \Lib \site-packages \mypackage \mysubpackage').
        rlNrrlrkFr�)rO�add_data_filesr,r-rmrpr�rrPrhr�rzr�rrgror��popr�rirCrwr�)r<rUr
r	�filepatr�r�rhr�r�rdr�r^rwr
r
rr��shX


�zConfiguration.add_data_filescCs@|��}|durt|d�sg|_|j�|�dS|j�|�dS)z�Add define macros to configuration

        Add the given sequence of macro name and value duples to the beginning
        of the define_macros list This list will be visible to all extension
        modules of the current package.
        Nr|)rCrr|r�)r<�macrosr^r
r
r�add_define_macros%s
zConfiguration.add_define_macroscG�J|�|�}|��}|dur|jdurg|_|j�|�dS|j�|�dS)z�Add paths to configuration include directories.

        Add the given sequence of paths to the beginning of the include_dirs
        list. This list will be visible to all extension modules of the
        current package.
        N)r�rCrxr�)r<r�rxr^r
r
r�add_include_dirs5�

zConfiguration.add_include_dirscs�g�|D]6�t��r��fdd�����D�qt�ttf�r%t��dkr+tt������fdd����d�D�q���}|durS|j	durKg|_	|j	�
��dS�j	�
��dS)a�Add installable headers to configuration.

        Add the given sequence of files to the beginning of the headers list.
        By default, headers will be installed under <python-
        include>/<self.name.replace('.','/')>/ directory. If an item of files
        is a tuple, then its first argument specifies the actual installation
        location relative to the <python-include> path.

        Parameters
        ----------
        files : str or seq
            Argument(s) can be either:

                * 2-sequence (<includedir suffix>,<path to header file(s)>)
                * path(s) to header file(s) where python includedir suffix will
                  default to package name.
        csg|]
}���j|f��qSr
)r�r9r�)r$r<r
rr�ZrRz-Configuration.add_headers.<locals>.<listcomp>r�csg|]}���d|f��qS�r)r�r�)r$rhr
rr�^srlN)r-r�r�tuplerarOrmrprCr$r�)r<rUr^r
)r$rhr<r�add_headersEs 
zConfiguration.add_headerscOs|�dd�}t||j|d�S)a�Apply glob to paths and prepend local_path if needed.

        Applies glob.glob(...) to each path in the sequence (if needed) and
        pre-pends the local_path if needed. Because this is called on all
        source lists, this allows wildcard characters to be specified in lists
        of sources for extension modules and libraries and scripts and allows
        path-names be relative to the source directory.

        r�T)r�r�)rXr/r�)r<r��kwsr�r
r
rr�gs

�zConfiguration.pathscCs4|��D]}||}|dvr|�|�}|||<qdS)N)rrZrx�library_dirs�module_dirs�
extra_objects)r�r�)r<�kw�kr��new_vr
r
r�_fix_paths_dictvs
��zConfiguration._fix_paths_dictcKs�t�|�}t|j|�|d<||d<d|vr<|d}|d=t|t�r$|g}|D]}t|t�s3Jt|���t|fi|��q&|�|�|�dg�}g}g|d<|D]k}	t|	t	�r]|�|	d�d|	vr�|	�
dd�\}
}tj�
t|j|��}tj�|�r�|jd|dd	�}t|t�r�|��}d
d�|�dg�D�D]}
|
�
dd�d
}||
kr�|�dd�t|fi|��nq�qO|�|	�qO||d|d<|j|�dg�|d<d
dlm}|di|��}|j�|�|��}|dur�|�d|�|S)a�Add extension to configuration.

        Create and add an Extension instance to the ext_modules list. This
        method also takes the following optional keyword arguments that are
        passed on to the Extension constructor.

        Parameters
        ----------
        name : str
            name of the extension
        sources : seq
            list of the sources. The list of sources may contain functions
            (called source generators) which must take an extension instance
            and a build directory as inputs and return a source file or list of
            source files or None. If None is returned then no sources are
            generated. If the Extension instance has no sources after
            processing all source generators, then no extension module is
            built.
        include_dirs :
        define_macros :
        undef_macros :
        library_dirs :
        libraries :
        runtime_library_dirs :
        extra_objects :
        extra_compile_args :
        extra_link_args :
        extra_f77_compile_args :
        extra_f90_compile_args :
        export_symbols :
        swig_opts :
        depends :
            The depends list contains paths to files or directories that the
            sources of the extension module depend on. If any path in the
            depends list is newer than the extension module, then the module
            will be rebuilt.
        language :
        f2py_options :
        module_dirs :
        extra_info : dict or list
            dict or list of dict of keywords to be appended to keywords.

        Notes
        -----
        The self.paths(...) method is applied to all lists that may contain
        paths.
        r9r�
extra_inforyrl�@Nr�r�cSsg|]}|d�qSr�r
)rKr�r
r
rr��r�z/Configuration.add_extension.<locals>.<listcomp>�__OF__rr|��	ExtensionzTdistutils distribution has been initialized, it may be too late to add an extension r
)r�r(r9rr�rprr�rXr�rgrPrhrnr+r�r3r�r
r�r�r�r|rNr�rvrCr�)r<r9rr��ext_argsr�r�ry�libnames�libname�lname�lpathr6r��llnamer�r[r^r
r
r�
add_extension~s`
0


�
���zConfiguration.add_extensioncKs6|�||d|�|��}|dur|�d|�dSdS)a�
        Add library to configuration.

        Parameters
        ----------
        name : str
            Name of the extension.
        sources : sequence
            List of the sources. The list of sources may contain functions
            (called source generators) which must take an extension instance
            and a build directory as inputs and return a source file or list of
            source files or None. If None is returned then no sources are
            generated. If the Extension instance has no sources after
            processing all source generators, then no extension module is
            built.
        build_info : dict, optional
            The following keys are allowed:

                * depends
                * macros
                * include_dirs
                * extra_compiler_args
                * extra_f77_compile_args
                * extra_f90_compile_args
                * f2py_options
                * language

        NzQdistutils distribution has been initialized, it may be too late to add a library )�_add_libraryrCr�)r<r9rr:r^r
r
r�add_library�s
��zConfiguration.add_librarycCs@t�|�}||d<d|vrg|d<|�|�|j�||f�dS)z\Common implementation for add_library and add_installed_library. Do
        not use directlyrrZN)r�r�ryr��r<r9r�install_dirr:r
r
rr�	s

zConfiguration._add_librarycCs@|si}tj�|j|�}|�||||�|j�t|||��dS)aQ
        Similar to add_library, but the specified library is installed.

        Most C libraries used with `distutils` are only used to build python
        extensions, but libraries built through this method will be installed
        so that they can be reused by third-party packages.

        Parameters
        ----------
        name : str
            Name of the installed library.
        sources : sequence
            List of the library's source files. See `add_library` for details.
        install_dir : str
            Path to install the library, relative to the current sub-package.
        build_info : dict, optional
            The following keys are allowed:

                * depends
                * macros
                * include_dirs
                * extra_compiler_args
                * extra_f77_compile_args
                * extra_f90_compile_args
                * f2py_options
                * language

        Returns
        -------
        None

        See Also
        --------
        add_library, add_npy_pkg_config, get_info

        Notes
        -----
        The best way to encode the options required to link against the specified
        C libraries is to use a "libname.ini" file, and use `get_info` to
        retrieve the required options (see `add_npy_pkg_config` for more
        information).

        N)rPrhrir�r�r{r�r8r�r
r
r�add_installed_librarys
,z#Configuration.add_installed_librarycCs\|duri}tj�|j|�}|j|jvr"|j|j�|||f�dS|||fg|j|j<dS)a 
        Generate and install a npy-pkg config file from a template.

        The config file generated from `template` is installed in the
        given install directory, using `subst_dict` for variable substitution.

        Parameters
        ----------
        template : str
            The path of the template, relatively to the current package path.
        install_dir : str
            Where to install the npy-pkg config file, relatively to the current
            package path.
        subst_dict : dict, optional
            If given, any string of the form ``@key@`` will be replaced by
            ``subst_dict[key]`` in the template file when installed. The install
            prefix is always available through the variable ``@prefix@``, since the
            install prefix is not easy to get reliably from setup.py.

        See also
        --------
        add_installed_library, get_info

        Notes
        -----
        This works for both standard installs and in-place builds, i.e. the
        ``@prefix@`` refer to the source directory for in-place builds.

        Examples
        --------
        ::

            config.add_npy_pkg_config('foo.ini.in', 'lib', {'foo': bar})

        Assuming the foo.ini.in file has the following content::

            [meta]
            Name=@foo@
            Version=1.0
            Description=dummy description

            [default]
            Cflags=-I@prefix@/include
            Libs=

        The generated file will have the following content::

            [meta]
            Name=bar
            Version=1.0
            Description=dummy description

            [default]
            Cflags=-Iprefix_dir/include
            Libs=

        and will be installed as foo.ini in the 'lib' subpath.

        When cross-compiling with numpy distutils, it might be necessary to
        use modified npy-pkg-config files.  Using the default/generated files
        will link with the host libraries (i.e. libnpymath.a).  For
        cross-compilation you of-course need to link with target libraries,
        while using the host Python installation.

        You can copy out the numpy/core/lib/npy-pkg-config directory, add a
        pkgdir value to the .ini files and set NPY_PKG_CONFIG_PATH environment
        variable to point to the directory with the modified npy-pkg-config
        files.

        Example npymath.ini modified for cross-compilation::

            [meta]
            Name=npymath
            Description=Portable, core math library implementing C99 standard
            Version=0.1

            [variables]
            pkgname=numpy.core
            pkgdir=/build/arm-linux-gnueabi/sysroot/usr/lib/python3.7/site-packages/numpy/core
            prefix=${pkgdir}
            libdir=${prefix}/lib
            includedir=${prefix}/include

            [default]
            Libs=-L${libdir} -lnpymath
            Cflags=-I${includedir}
            Requires=mlib

            [msvc]
            Libs=/LIBPATH:${libdir} npymath.lib
            Cflags=/INCLUDE:${includedir}
            Requires=mlib

        N)rPrhrir�r9r~r�)r<�templater��
subst_dictr
r
r�add_npy_pkg_configLs_
��z Configuration.add_npy_pkg_configcGr�)z�Add scripts to configuration.

        Add the sequence of files to the beginning of the scripts list.
        Scripts will be installed under the <prefix>/bin/ directory.

        N)r�rCr\r�)r<rUr\r^r
r
r�add_scripts�r�zConfiguration.add_scriptsc
Ks|jD]}t||�}|�|�|g��q|jD]}t||�}|�|�|i��q|j|j|j}|��D]S}||vrit||d�}|rJ|||krJq5|�d||||�dd�f�t	||||�|j�
|�q5||jvr~|�d|t||�||f�q5||vr�q5td|��dS)Nz"Inheriting attribute %r=%r from %rr9r�z*Ignoring attempt to set %r (from %r to %r)zDon't know about key=%r)
r�rYr�rXr��updater�r�r�r�r�r�r�)r<r�r�rer�r
r
rr�s0



�
��zConfiguration.dict_appendcCsvddlm}|j|j|j}d}|d|jd7}|��|D]}t||d�}|r4|d|||�f7}q |d7}|S)Nr)�pformatz<-----
zConfiguration of z:
z%s = %s
z----->)�pprintr�r�r�r�r9�sortrY)r<r�r�r�r�rer
r
r�__str__�s�zConfiguration.__str__cCsJtd�}|��d|_d|_tj�d�}|r#tj�d|g�}|tjd<|S)zF
        Returns the numpy.distutils config command instance.
        r�r�PATHrv)	r�ensure_finalized�dump_source�noisyrPrWrX�pathsepri)r<�cmd�old_pathrhr
r
r�get_config_cmd�s
zConfiguration.get_config_cmdcCstd�}|��|jS)zh
        Return a path to a temporary directory where temporary files should be
        placed.
        rF)rr��
build_temp)r<r�r
r
r�get_build_temp_dir�sz Configuration.get_build_temp_dircC�d}|��}|j|dd�}|S)aSCheck for availability of Fortran 77 compiler.

        Use it inside source generating function to ensure that
        setup distribution instance has been initialized.

        Notes
        -----
        True if a Fortran 77 compiler is available (because a simple Fortran 77
        code was able to be compiled successfully).
        �/
        subroutine simple
        end
        r��lang�r��try_compile�r<�simple_fortran_subroutine�
config_cmd�flagr
r
r�	have_f77c�zConfiguration.have_f77ccCr)aRCheck for availability of Fortran 90 compiler.

        Use it inside source generating function to ensure that
        setup distribution instance has been initialized.

        Notes
        -----
        True if a Fortran 90 compiler is available (because a simple Fortran
        90 code was able to be compiled successfully)
        rrrrrr
r
r�	have_f90crzConfiguration.have_f90ccCsht|�r|\}}t||j|jd�dSddlm}t||�s$Jt|���|j�|j�|j�|j�dS)zEAppend libraries, include_dirs to extension or library item.
        )ryrxrr�N)	r,rryrxrNr�rrpr�)r<�extlib�lib_namer:r�r
r
r�	append_to*s
�zConfiguration.append_toc	Csz
tjdg|d�}WntjtfyYnwt�d|�}|r&t|�d��Stj	dkr9t
j�dd�r9t
|dd	�}nt
|d
d	�}t
j�|�r�t|��}|��}Wd�n1sXwY|dd�dkrvt�d
|�}|rtt|�d��SdSt�d|�}|r�t|�d��SdS)z+Return path's SVN revision number.
        �
svnversion��cwd�(?P<revision>\d+)�revisionr��SVN_ASP_DOT_NET_HACKN�_svn�entriesr:r�z<?xmlzrevision="(?P<revision>\d+)"zdir[\n\r]+(?P<revision>\d+))�
subprocess�check_output�CalledProcessErrorrrC�matchrVrr}r�rPrWrXr+rhrQr��readrF)r<rh�outputrrr
�fstrr
r
r�_get_svn_revision8s0�

��zConfiguration._get_svn_revisionc

Cs8ztjgd�|d�}WntjtfyYnwt�d|�}|r't|�d��St|dd�}t|dd�}t	j
�|�r�d}t|��}|�
���}Wd�n1sPwYi}	t|d	��1}|D]&}
|
��dd
�\}}||krq|}zt|�}Wn	ty�Yq_w||	|<q_Wd�n1s�wY|	�|�SdS)z1Return path's Mercurial revision number.
        )�hg�identifyz--numrrrz.hg�branchzbranch.cacheNrr�)rrrrrCrrVrr+rPrhrQr�rr�rgr�rX)
r<rhrr�	branch_fn�branch_cache_fn�branch0r
�	revision0�
branch_mapr��branch1�	revision1r
r
r�_get_hg_revisionUsB
��
��
��
zConfiguration._get_hg_revisioncCs�t|dd�}|dur|S|dur d|j�d�ddddd	g}n|g}|dur5dd
|j�d�ddg}n|g}|D]y}t|j|�}tj�|�r�d}tj�tj�	|��d
}	t
|j|	�}
z
td�|
�d��|�}Wnt
y�}z|�t|��d}WYd}~nd}~ww|dur�q:|D]}
t||
d�}|dur�nq�z|��d}Wn	ty�Ynw|dur�nq:|dur�||_|S|�|j�}|dur�|�|j�}|dur�t|�}||_|S)a�Try to get version string of a package.

        Return a version string of the current package or None if the version
        information could not be detected.

        Notes
        -----
        This method scans files named
        __version__.py, <packagename>_version.py, version.py, and
        __svn_version__.py for string variables version, __version__, and
        <packagename>_version, until a version number is found.
        r�Nz__version__.pyrvr�z_version.pyz
version.py�__svn_version__.py�__hg_version__.py�__version__�_version)z.py�Urlrrt)rYr9rgr+r�rPrhrQr�r�r(r7ri�ImportErrorr�r��get_versionsrRr�r r+)r<�version_file�version_variabler�rU�version_varsr
r�r�r9r��version_module�ererr
r
r�get_version{sr
��������zConfiguration.get_versionTc�Vt�jd�����j��tj���s�durdS����fdd�}��d|�f�dS)aAppends a data function to the data_files list that will generate
        __svn_version__.py file to the current package directory.

        Generate package __svn_version__.py file from SVN revision number,
        it will be removed after python exits but will be available
        when sdist, etc commands are executed.

        Notes
        -----
        If __svn_version__.py existed before, nothing is done.

        This is
        intended for working with source directories that are in an SVN
        repository.
        r,Nc�tj���s/t��}��d�|f�t�d��}|�d|�Wd�n1s*wY��jf�fdd�	}t�|��S)N�Creating %s (version=%r)r��
version = %r
c�p�r6z
t�|�|d|�Wn	tyYnwzt�|d�|d|d�WdSty5YdSwdS�Nzremoved r6�rP�remover�r
r���deleter
r�rm_file��&�zSConfiguration.make_svn_version_py.<locals>.generate_svn_version_py.<locals>.rm_file�	rPrhrQr�r�r�r��atexit�register�r�r
rD�rCrr<�targetr
r�generate_svn_version_py���
zBConfiguration.make_svn_version_py.<locals>.generate_svn_version_pyrk)r+r�r rPrhrQr�)r<rCrLr
rJr�make_svn_version_py�sz!Configuration.make_svn_version_pycr9)aAppends a data function to the data_files list that will generate
        __hg_version__.py file to the current package directory.

        Generate package __hg_version__.py file from Mercurial revision,
        it will be removed after python exits but will be available
        when sdist, etc commands are executed.

        Notes
        -----
        If __hg_version__.py existed before, nothing is done.

        This is intended for working with source directories that are
        in an Mercurial repository.
        r-Ncr:)Nr;r�r<cr=r>r?rArBr
rrDrEzQConfiguration.make_hg_version_py.<locals>.generate_hg_version_py.<locals>.rm_filerFrIrJr
r�generate_hg_version_pyrMz@Configuration.make_hg_version_py.<locals>.generate_hg_version_pyrk)r+r�r+rPrhrQr�)r<rCrOr
rJr�make_hg_version_py�sz Configuration.make_hg_version_py�
__config__cCs|j�|j|tf�dS)z�Generate package __config__.py file containing system_info
        information used during building the package.

        This file is installed to the
        package installation directory.

        N)rzr�r9r)r<r9r
r
r�make_config_pyszConfiguration.make_config_pycGs6ddlm}m}i}|D]}||fi||���q|S)z�Get resources information.

        Return information (from system_info.get_info) for all of the names in
        the argument list in a single dictionary.
        rl)r3r)�system_infor3r)r<�namesr3r�	info_dictrer
r
rr3"s
zConfiguration.get_info)NNNNrlr)rl)NNrl)NFr�NN)T)rQ)-r>r?r@r�r�r��numpy_include_dirsr=r�r�r�r�rCr�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�rr�r�rrr
rr r+r8rNrPrRr3r
r
r
rr
�sr
�a
�
�"
�>
�+y	"g$

3k
	
&
L
)
(
r
cCsN||vr#ddl}|jj}|durddlm}|d��|�|�}|||<||S)Nr)�DistutilsInternalErrorz+setup distribution instance not initialized)�distutils.core�core�_setup_distribution�distutils.errorsrXrZ)�cmdname�_cacherer^rXr�r
r
rr/s�
rcCs(tjdd�}|sddl}|��g}|S)Nr)r
rW�numpy�get_include)rxr_r
r
rr;s

rcCsDtj�d�}|dur|Stj�d�}tj�tj�|j	�ddd�}|S)a�Return the path where to find the npy-pkg-config directory.

    If the NPY_PKG_CONFIG_PATH environment variable is set, the value of that
    is returned.  Otherwise, a path inside the location of the numpy module is
    returned.

    The NPY_PKG_CONFIG_PATH can be useful when cross-compiling, maintaining
    customized npy-pkg-config .ini files for the cross-compilation
    environment, and using them when cross-compiling.

    �NPY_PKG_CONFIG_PATHNr_rZr]znpy-pkg-config)
rPrWrX�	importlib�util�	find_specrhrirz�origin)r	�specr
r
r�get_npy_pkg_dirDs�rgcCs0ddlm}|r|�t��nt�g}|||�S)a�
    Return library info for the given package.

    Parameters
    ----------
    pkgname : str
        Name of the package (should match the name of the .ini file, without
        the extension, e.g. foo for the file foo.ini).
    dirs : sequence, optional
        If given, should be a sequence of additional directories where to look
        for npy-pkg-config files. Those directories are searched prior to the
        NumPy directory.

    Returns
    -------
    pkginfo : class instance
        The `LibraryInfo` instance containing the build information.

    Raises
    ------
    PkgNotFound
        If the package is not found.

    See Also
    --------
    Configuration.add_npy_pkg_config, Configuration.add_installed_library,
    get_info

    r)�read_config)�numpy.distutils.npy_pkg_configrhr�rg)�pkgnamer�rhr
r
rr4Xs

r4cCsfddlm}t||�}||���}||�����D]\}}||�|�q|d|d<|d=|d=|S)a9
    Return an info dict for a given C library.

    The info dict contains the necessary options to use the C library.

    Parameters
    ----------
    pkgname : str
        Name of the package (should match the name of the .ini file, without
        the extension, e.g. foo for the file foo.ini).
    dirs : sequence, optional
        If given, should be a sequence of additional directories where to look
        for npy-pkg-config files. Those directories are searched prior to the
        NumPy directory.

    Returns
    -------
    info : dict
        The dictionary with build information.

    Raises
    ------
    PkgNotFound
        If the package is not found.

    See Also
    --------
    Configuration.add_npy_pkg_config, Configuration.add_installed_library,
    get_pkg_info

    Examples
    --------
    To get the necessary information for the npymath library from NumPy:

    >>> npymath_info = np.distutils.misc_util.get_info('npymath')
    >>> npymath_info                                    #doctest: +SKIP
    {'define_macros': [], 'libraries': ['npymath'], 'library_dirs':
    ['.../numpy/core/lib'], 'include_dirs': ['.../numpy/core/include']}

    This info dict can then be used as input to a `Configuration` instance::

      config.add_extension('foo', sources=['foo.c'], extra_info=npymath_info)

    r)�parse_flagsr�r|�ignored)rirkr4�cflags�libsr�r�)rjr�rk�pkg_infor�r�r�r
r
rr3~s-
r3cCs*ddl}z|jWdStyYdSw)NrTF)�builtins�__NUMPY_SETUP__rR)rpr
r
r�is_bootstrapping�s�rrcCs:ddl}|jd||||||fdd�t|||�}|��S)zqReturn a configuration dictionary for usage in
    configuration() function defined in file setup_<name>.py.
    rNzXUse Configuration(%r,%r,top_path=%r) instead of deprecated default_config_dict(%r,%r,%r)r�)�
stacklevel)�warningsr�r
r�)r9r�r�rtr6r
r
rr�s���rcKsR|��D]"\}}||vr"||}t|t�r|||<q||�|�q|||<qdSr)r�rr�r�)r	r�r�r��ovr
r
rr�s


�rcCs(tjjdkr|�dtjj�}|�dtjj�}d}tj�|�r�tj�|�d}tj�tj�|��d}tj�|�\}}tj�||g�}tj�|dt	|��|t	|�d��|ksltj�|dt	|��|t	|�d��|krrtj�
|�}|t	|�d�}tj�|�r�|dd�}n|}tj�t|||��S)Nrfrkrrl)
rPrhror�r��
splitdrivernr1rirOrz�normpathr+)r�rh�drive�	absprefix�	pathdriver	�subpathr
r
rr�s$**�rcCs�ddlm}ddlm}|tj�|��t|d��D}|�dtj�	t
jd��|�d�|�d�|�t�
d��|j��D]
\}}|�d	||f�q?|�t�
d
��Wd�|S1s`wY|S)z�Generate config.py file containing system_info information
    used during building the package.

    Usage:
        config['py_modules'].append((packagename, '__config__',generate_config_py))
    r)rS)�mkpathr�z'# This file is generated by numpy's %s
zH# It contains system_info results at the time of building this package.
z__all__ = ["get_info","show"]

a�
            import os
            import sys

            extra_dll_dir = os.path.join(os.path.dirname(__file__), '.libs')

            if sys.platform == 'win32' and os.path.isdir(extra_dll_dir):
                if sys.version_info >= (3, 8):
                    os.add_dll_directory(extra_dll_dir)
                else:
                    os.environ.setdefault('PATH', '')
                    os.environ['PATH'] += os.pathsep + extra_dll_dir

            z%s=%r
a�
            def get_info(name):
                g = globals()
                return g.get(name, g.get(name + "_info", {}))

            def show():
                """
                Show libraries in the system on which NumPy was built.

                Print information about various resources (libraries, library
                directories, include directories, etc.) in the system on which
                NumPy was built.

                See Also
                --------
                get_include : Returns the directory containing NumPy C
                              header files.

                Notes
                -----
                Classes specifying the information to be printed are defined
                in the `numpy.distutils.system_info` module.

                Information may include:

                * ``language``: language used to write the libraries (mostly
                  C or f77)
                * ``libraries``: names of libraries found in the system
                * ``library_dirs``: directories containing the libraries
                * ``include_dirs``: directories containing library header files
                * ``src_dirs``: directories containing library source files
                * ``define_macros``: preprocessor macros used by
                  ``distutils.setup``
                * ``baseline``: minimum CPU features required
                * ``found``: dispatched features supported in the system
                * ``not found``: dispatched features that are not supported
                  in the system

                Examples
                --------
                >>> import numpy as np
                >>> np.show_config()
                blas_opt_info:
                    language = c
                    define_macros = [('HAVE_CBLAS', None)]
                    libraries = ['openblas', 'openblas']
                    library_dirs = ['/usr/local/lib']
                """
                from numpy.core._multiarray_umath import (
                    __cpu_features__, __cpu_baseline__, __cpu_dispatch__
                )
                for name,info_dict in globals().items():
                    if name[0] == "_" or type(info_dict) is not type({}): continue
                    print(name + ":")
                    if not info_dict:
                        print("  NOT AVAILABLE")
                    for k,v in info_dict.items():
                        v = str(v)
                        if k == "sources" and len(v) > 200:
                            v = v[:60] + " ...\n... " + v[-60:]
                        print("    %s = %s" % (k,v))

                features_found, features_not_found = [], []
                for feature in __cpu_dispatch__:
                    if __cpu_features__[feature]:
                        features_found.append(feature)
                    else:
                        features_not_found.append(feature)

                print("Supported SIMD extensions in this NumPy install:")
                print("    baseline = %s" % (','.join(__cpu_baseline__)))
                print("    found = %s" % (','.join(features_found)))
                print("    not found = %s" % (','.join(features_not_found)))

                    N)�numpy.distutils.system_inforS�distutils.dir_utilr|rPrhrzr�r�r�r}�argv�textwrap�dedent�
saved_resultsr�)rKrSr|r
r�rdr
r
rr�s


�c�crcCs|jdkstd|j��|jS)zdReturn version major and minor of compiler instance if it is
    MSVC, raise an exception otherwise.�msvcz"Compiler instance is not msvc (%s))�
compiler_typer��_MSVCCompiler__version)�compilerr
r
r�msvc_versionc	s

�r�cCsddlm}|�S)Nr�r2)�distutils.msvccompilerr2r�r
r
rr2k	sr2z%-Werror=implicit-function-declarationz-std=c99cCsdd�|D�S)z=
    Some flags are valid for C but not C++. Prune them.
    cSsg|]}|tvr|�qSr
)�_cxx_ignore_flags)rKr
r
r
rr�y	rBz&sanitize_cxx_flags.<locals>.<listcomp>r
)�cxxflagsr
r
rr6u	sr6cCs*tj�||�}tj�|�}|j�|�|S)z�
    Use importlib machinery to import a module `modname` from the file
    `modfile`. Depending on the `spec.loader`, the module may not be
    registered in sys.modules.
    )rbrc�spec_from_file_location�module_from_spec�loader�exec_module)�modname�modfilerf�foor
r
rr7|	sr7r)rkT)rkrkT)NNFrV)Fr�)NNN)crPrCr}r�r�rGr�rrrSr��importlib.utilrb�	threadingr�tlocalrer\rr�rrrH�__all__r8r5r1rrtr�r+rr*r�r�r/r�rr�r�r�r�rrrrrrrr�rr�rD�Irrrr	r
rr-rr,rr.r0rr r!r&r)r0r"r#rMrVr$r%r&rkr'r(r)r
rrrgr4r3rrrrrrr�r2r�r6r7r
r
r
r�<module>s�
$



%



�

		
	


/
f	

&<
o
@ Telegram