|Pؚ Z d Z ddlmZ ddlZddlZddlZddlZddlZddlm Z m
Z
m Z ddl m
Z
ddlmZ ddlmZmZ ddlmZ dd lmZ dd
lmZmZ dd lmZmZm Z m Z d d
l m Z d dl m!Z!m"Z# d dl$m%Z% d dl&m'Z' ddl(m)Z) er ddl*m+Z+ ddl,m-Z- e d Z. e dd Z/ G d d Z0 d\d]d Z1 d\d^d$Z2d_d'Z3d`d*Z4dad,Z5 dbdcd1Z6ddd5Z7ded8Z8dfd:Z9 dbdgd=Z: dbdhdAZ;ddddBdidEZdldNZ? d\dmdRZ@ dndodWZA G dX dY ZB G dZ d[e e.e/f ZCdS )pai Utility functions to expand configuration directives or special values
(such glob patterns).
We can split the process of interpreting configuration files into 2 steps:
1. The parsing the file contents from strings to value objects
that can be understand by Python (for example a string with a comma
separated list of keywords into an actual Python list of strings).
2. The expansion (or post-processing) of these values according to the
semantics ``setuptools`` assign to them (for example a configuration field
with the ``file:`` directive should be expanded from a list of file paths to
a single string with the contents of those files concatenated)
This module focus on the second step, and therefore allow sharing the expansion
functions among several configuration file formats.
**PRIVATE MODULE**: API reserved for setuptools internal usage only.
) annotationsN)IterableIteratorMapping) ConfigParser)iglob)
ModuleSpec all_suffixes)chain)Path)
ModuleType
TracebackType)
TYPE_CHECKINGAnyCallableTypeVar )_static)StrPath same_path)find_package_path)SetuptoolsWarning)DistutilsOptionError)Self) Distribution_K_V_coT) covariantc * e Zd ZdZddZdd
Zdd Zd
S ) StaticModulez>Proxy to a module object that avoids executing arbitrary code.namestrspecr returnNonec t j t j |j }t
| t | ` d S N)
astparsepathlibr origin
read_bytesvarsupdatelocalsself)r0 r! r# modules j/builddir/build/BUILD/cloudlinux-venv-1.0.10/venv/lib/python3.11/site-packages/setuptools/config/expand.py__init__zStaticModule.__init__8 sP 7< 44??AABB T
&((### III !Iterator[tuple[ast.AST, ast.AST]]c # K | j j D ]gt t j rfdj D E d {V 6t t j rj rj j fV hd S )Nc 3 * K | ]
}|j fV d S r' )value).0target statements r2 z1StaticModule._find_assignments..@ s* VV&VY_ 5VVVVVVr4 ) r1 body
isinstancer( Assigntargets AnnAssignr8 r: )r0 r; s @r2 _find_assignmentsz StaticModule._find_assignments= s ) : :I)SZ00
:VVVVIDUVVVVVVVVVVVIs}55
:)/
: ' 9999 : :r4 attrc t fd| D S # t $ r }t | j d |d}~ww xY w)zHAttempt to load an attribute "statically", via :func:`ast.literal_eval`.c 3 K | ]@\ }}t |t j r!|j k *t j | V Ad S r' )r> r( Nameid literal_eval)r9 r: r8 rC s r2 r< z+StaticModule.__getattr__..G sa !FE fch// 5;I4E4E ''4E4E4E4E r4 z has no attribute N)nextrB ExceptionAttributeErrorr! )r0 rC es ` r2 __getattr__zStaticModule.__getattr__D s P %)%;%;%=%=
P P P DI!G!G!G!GHHa O Ps ,0
AAAN)r! r" r# r r$ r% )r$ r5 )rC r" )__name__
__module__ __qualname____doc__r3 rB rM r4 r2 r r 5 s\ HH
: : : : P P P P P Pr4 r patterns
Iterable[str]root_dirStrPath | Noner$ list[str]c
h d}g }pt j | D ]t fd|D r{t j t j }| t fdt |d D t j
t j d }| | |S )a Expand the list of glob patterns, but preserving relative paths.
:param list[str] patterns: List of glob patterns
:param str root_dir: Path to which globs should be relative
(current directory by default)
:rtype: list
> *{}?[]c 3 K | ]}|v V d S r' rR )r9 charr8 s r2 r< z glob_relative.._ s' 99tu}999999r4 c 3 K | ]B}t j | t j d V CdS )/N)ospathrelpathreplacesepr9 rd rU s r2 r< z glob_relative..c sY GOOD(33;;BFCHH r4 T) recursiverb )
rc getcwdanyrd abspathjoinextendsortedr re rf rg append)rS rU glob_charactersexpanded_values glob_pathrd r8 s ` @r2
glob_relativert P s 544OO&29;;H ) ) 9999 999 9 9
) Xu(E(EFFI " " %i4 @ @ @
7??5(33;;BFCHHD " "4 ( ( ( ( r4 filepathsStrPath | Iterable[StrPath]r" c ddl m} t j pt j fd || D }d fdt | D S )zReturn the content of the files concatenated using ``
`` as str
This function is sandboxed and won't reach anything outside ``root_dir``
(By default ``root_dir`` is the current directory).
r )always_iterablec 3 X K | ]$}t j | V %d S r' rc rd rm rh s r2 r< z read_files..} s3 VV4"',,x..VVVVVVr4
c 3 V K | ]#}t | t | V $d S r' )
_assert_local
_read_filerh s r2 r< z read_files..~ sO x ( (4 r4 )more_itertoolsrx rc rd rl rj rm _filter_existing_files)ru rU rx
_filepathss ` r2
read_filesr q s /.....wx 629;;77HVVVV??9;U;UVVVJ 99 *:66 r4 Iterable[StrPath]Iterator[StrPath]c # K | D ]>}t j | r|V &t j d|d ?d S )NzFile z cannot be found)rc rd isfiler emit)ru rd s r2 r r se E E
7>>$ EJJJJ "#C4#C#C#C D D D D E Er4 filepathbytes | StrPathc t | d 5 }| cd d d S # 1 swxY w Y d S )Nzutf-8)encoding)openread)r fs r2 r~ r~ s
h ) ) ) Qvvxx s 377r c t t j | t t j | j vrd| d|d}t | dS )NzCannot access z (or anything outside )T)r rc rd rl parentsr )r rU msgs r2 r} r} sg BGOOH % %&&d27??83L3L.M.M.UUUNxNNNNN"3''' 4r4 attr_desc package_dirMapping[str, str] | Noner c |pt j }| d }| }d | }|pd}t
||| }t || } t t || | }t j | S # t $ r# t || } t | | cY S w xY w)a Reads the value of an attribute from a module.
This function will try to read the attributed statically first
(via :func:`ast.literal_eval`), and only evaluate the module if it fails.
Examples:
read_attr("package.attr")
read_attr("package.module.attr")
:param str attr_desc: Dot-separated string describing how to reach the
attribute (see examples above)
:param dict[str, str] package_dir: Mapping of package names to their
location in disk (represented by paths relative to ``root_dir``).
:param str root_dir: Path to directory containing all the packages in
``package_dir`` (current directory by default).
:rtype: str
.r3 )rc rj stripsplitpoprm _find_module
_find_specgetattrr r attempt_conversionrJ
_load_spec)
r r rU
attrs_path attr_name module_namerd r# r8 r1 s
r2 read_attrr s , &29;;H ""((--J I((:&&K +K [( ; ;D k4 ( (D* [$77CC)%000 * * *D+..vy)))))*s 1B> >*C+*C+r module_pathr c t j | | }|p t j | }|t | |S r' ) importlibutilspec_from_file_location find_specModuleNotFoundError)r r r# s r2 r r sK > 1 1+{ K KD 89>++K88D |!+... Kr4 r# r
c
t | d| }|t j v rt j | S t j | }|t j |< | j J | j | |S )NrN )r sysmodulesr r module_from_specloader exec_module)r# r r! r1 s r2 r r sw 4[ 1 1D s{{4
^
,
,T
2
2F CK ; " " "KF### Mr4
str | Nonec t | |pi | t j fdt D }t d |D d S )a Find the path to the module named ``module_name``,
considering the ``package_dir`` in the build configuration and ``root_dir``.
>>> tmp = getfixture('tmpdir')
>>> _ = tmp.ensure("a/b/c.py")
>>> _ = tmp.ensure("a/b/d/__init__.py")
>>> r = lambda x: x.replace(str(tmp), "tmp").replace(os.sep, "/")
>>> r(_find_module("a.b.c", None, tmp))
'tmp/a/b/c.py'
>>> r(_find_module("f.g.h", {"": "1", "f": "2", "f.g": "3", "f.g.h": "a/b/d"}, tmp))
'tmp/a/b/d/__init__.py'
c 3 j K | ]-} | t j d | fV .dS )r3 Nrz )r9 ext
path_starts r2 r< z _find_module.. s` % %
rw||J8H38H8H I IJ% % % % % %r4 c 3 X K | ]%}t j | !|V &d S r' )rc rd r )r9 xs r2 r< z _find_module.. s5 <>% % % J <z cmdclass.. s+ R R R41aA}Q X66 R R Rr4 )items)r r rU s ``r2 cmdclassr s, S R R R R6<<>> R R RRr4 )
namespacesfill_package_dirrU r dict[str, str] | Nonec
ddl m}m} ddlm} | sddlm} nddlm} |p t j }| ddg }g } |i n|}t | ||
t
d k r9t
fd
d|fD r |
d
d
D ]}
t ||
} |j | fi |} | | | rX| d |
k s?t j | | s | || |
| S ) a Works similarly to :func:`setuptools.find_packages`, but with all
arguments given as keyword arguments. Moreover, ``where`` can be given
as a list (the results will be simply concatenated).
When the additional keyword argument ``namespaces`` is ``True``, it will
behave like :func:`setuptools.find_namespace_packages`` (i.e. include
implicit namespaces as per :pep:`420`).
The ``where`` argument will be considered relative to ``root_dir`` (or the current
working directory when ``root_dir`` is not given).
If the ``fill_package_dir`` argument is passed, this function will consider it as a
similar data structure to the ``package_dir`` configuration parameter add fill-in
any missing package location.
:rtype: list
r )rx unique_everseen)construct_package_dir)
PackageFinder)PEP420PackageFinderwherer Nr c 3 F K | ]}t d | V dS )r N)
_same_path)r9 r searchs r2 r< z find_packages..1 s4 V VJvay!$<$< < V V V V V Vr4 )r rx r setuptools.discoveryr r r rc curdirr listlenall
setdefault
_nest_pathfindrn getrd samefiler. )r r rU kwargsrx r r r r packagesrd package_pathpkgsr s @r2
find_packagesr s 0 @???????:::::: N6666666MMMMMM$29H JJw & &E H - 5rr;K
////%"8"899
:
:F
6{{aC V V V VsHo V V V V V##Bq 222 G G!(D11 !}!,99&99 G $ $ , ,0@0@ x0X0X , # #$9$9$$E$E F F F Or4 parentrd c |dv r| n t j | | }t j | S )N> r r )rc rd rm normpath)r rd s r2 r r @ s; Y&&66BGLL,F,FD
7 D ! !!r4 r8 $Callable | Iterable[str | int] | strc t | r
| n| }t |t r|S t |d r(d t t | S | S )z`When getting the version directly from an attribute,
it should be normalised to string.
__iter__r )callabler> r" hasattrrm map)r8 _values r2 versionr E sk !
2UUWWWUF&#
vz"" *xxC(()));r4 package_datadictc > d| v r| d | d< | S )NrY r )r )r s r2 canonic_package_datar R s+
l'++C00 R r4
data_files list | dictlist[tuple[str, list[str]]]c r t | t r| S fd| D S )zFor compatibility with ``setup.py``, ``data_files`` should be a list
of pairs instead of a dict.
This function also expands glob patterns.
c : g | ]\ }}|t | fS rR )rt )r9 destrS rU s r2
z&canonic_data_files..c s< D(
}Xx001 r4 )r> r r )r rU s `r2 canonic_data_filesr X sT *d## ( . . 0 0 r4 entry-pointstext text_sourcedict[str, dict[str, str]]c t dd }t |_ | | | d | D }| |j d |S )a? Given the contents of entry-points file,
process it into a 2-level dictionary (``dict[str, dict[str, str]]``).
The first level keys are entry-point groups, the second level keys are
entry-point names, and the second level values are references to objects
(that correspond to the entry-point value).
N)=)default_section
delimitersc X i | ]'\ }}|t | (S rR )r r )r9 r r s r2 r z entry_points..v s,
<
<
>> def obtain_mapping():
... print("Running expensive function!")
... return {"key": "value", "other key": "other value"}
>>> mapping = LazyMappingProxy(obtain_mapping)
>>> mapping["key"]
Running expensive function!
'value'
>>> mapping["other key"]
'other value'
obtain_mapping_value Callable[[], Mapping[_K, _V_co]]r$ r% c " || _ d | _ d S r' )_obtainr )r0 r* s r2 r3 zLazyMappingProxy.__init__ s + 15 r4 Mapping[_K, _V_co]c P | j | | _ | j S r' )r r- r s r2 _targetzLazyMappingProxy._target s! ; ,,..DK{r4 keyr r c 6 | | S r' )r0 )r0 r1 s r2 __getitem__z LazyMappingProxy.__getitem__ s ||~~c""r4 intc D t | S r' )r r0 r s r2 __len__zLazyMappingProxy.__len__ s 4<<>>"""r4 Iterator[_K]c D t | S r' )iterr0 r s r2 r zLazyMappingProxy.__iter__ s DLLNN###r4 N)r* r+ r$ r% )r$ r. )r1 r r$ r )r$ r4 )r$ r7 ) rN rO rP rQ r3 r0 r3 r6 r rR r4 r2 r' r' s 6 6 6 6
# # # ## # # #$ $ $ $ $ $r4 r' r' )rS rT rU rV r$ rW )ru rv rU rV r$ r" )ru r r$ r )r r r$ r" )r r rU r" )NN)r r" r r rU rV r$ r )r r" r rV r$ r )r# r r r" r$ r
)r r" r r rU r r$ r )r r" r r rU rV r$ r )r r r r rU rV r$ r )r r rU rV r$ rW )r r rd r r$ r" )r8 r r$ r" )r r r$ r )r r rU rV r$ r )r )r r" r r" r$ r )DrQ
__future__r r( r rc r* r collections.abcr r r configparserr globr importlib.machineryr r
itertoolsr r typesr
r typingr r r r r r _pathr r r discoveryr warningsr distutils.errorsr typing_extensionsr setuptools.distr r r r rt r r r~ r} r r r r r r r r r r r r r r' rR r4 r2 rH s ( # " " " " "
7 7 7 7 7 7 7 7 7 7 % % % % % % 8 8 8 8 8 8 8 8 + + + + + + + + 8 8 8 8 8 8 8 8 8 8 8 8 4 4 4 4 4 4 4 4 ) ) ) ) ) ) ( ( ( ( ( ( 1 1 1 1 1 1 -&&&&&&,,,,,, WT]]4(((P P P P P P P P8 9= D HL (E E E E
-1 #%* %* %* %* %*P D D D D2 -1 #
'
'
'
'
'$ -1 #S S S S S .2 # 4 4 4 4 4 4n" " " "
9= $ #1 $(7 (7 (7 (7 (7 (7 (7 (7V $ $ $ $ $wr5y) $ $ $ $ $r4