U
|
G=®d±Q ã @ s d Z ddlZddlZddlZddlZddlZddlmZ ddl m
|
Z
|
ddl m Z ddl mZ ddlmZ dd Zd
|
d Zd d Zdd Zdadd Zdd Zd*ddZd a aadd Zdd Z d+dd Z d d Z d,d d!Z d"d# Z d-d$d%Z!d.d&d'Z"G d(d) d)Z#dS )/zudistutils.util
|
|
Miscellaneous utility functions -- anything that doesn't fit into
|
one of the other *util.py modules.
|
é N)ÚDistutilsPlatformError)Únewer)Úspawn)Úlog)ÚDistutilsByteCompileErrorc C sÚ t jdkrFdtj ¡ kr dS dtj ¡ kr.dS dtj ¡ kr@dS tjS dt jkrZt jd S t jd ksntt d
|
sttjS t ¡ \} }}}}| ¡ d d ¡} | d d¡}| d d¡}| dd
dkrÊd| |f S | dd
dkr,|d dkrÌd} dt
|
|d d |dd
f }dd d }|d |tj 7 }n | dd
d krPdd l m } | S | dd!
d"krd"} t d#tj¡}| |¡}|rÌ| ¡ }n>| dd!
d$krÌddl} ddl}
|
| |
|
j ¡ | ||¡\} }}d%| ||f S )&aú Return a string that identifies the current platform. This is used mainly to
|
distinguish platform-specific build directories and platform-specific built
|
distributions. Typically includes the OS name and version and the
|
architecture (as supplied by 'os.uname()'), although the exact information
|
included depends on the OS; eg. on Linux, the kernel version isn't
|
particularly important.
|
|
Examples of returned values:
|
linux-i586
|
linux-alpha (?)
|
solaris-2.6-sun4u
|
|
Windows will return one of:
|
win-amd64 (64bit Windows on AMD64 (aka x86_64, Intel64, EM64T, etc)
|
win32 (all others - specifically, sys.platform is returned)
|
|
For other non-POSIX platforms, currently just returns 'sys.platform'.
|
|
ÚntÚamd64ú win-amd64z(arm)ú win-arm32z(arm64)z win-arm64Ú_PYTHON_HOST_PLATFORMÚposixÚunameú/Ú ú Ú_ú-Né Úlinuxz%s-%sÚsunosr Ú5Úsolarisz%d.%sé é Ú32bitÚ64bit)iÿÿÿl ÿÿÿÿ z.%sÚaix)Ú aix_platformé Úcygwinz[\d.]+Údarwinz%s-%s-%s)ÚosÚnameÚsysÚversionÚlowerÚplatformÚenvironÚhasattrr ÚreplaceÚintÚmaxsizeZ _aix_supportr ÚreÚcompileÚASCIIÚmatchÚgroupÚ _osx_supportÚdistutils.sysconfigÚget_platform_osxÚ sysconfigÚget_config_vars) ÚosnameÚhostÚreleaser$ ÚmachineÚbitnessr Úrel_reÚmr1 Ú distutils© r> úQD:\z\workplace\VsCode\pyvenv\venv\Lib\site-packages\setuptools/_distutils/util.pyÚget_host_platform sT
|
|
|
|
|
|
þ
|
r@ c C s8 t jdkr.dddd} | t j d¡¡p,t S t S d S )Nr Úwin32r r
|
)Úx86Úx64ÚarmÚVSCMD_ARG_TGT_ARCH)r! r" Úgetr' r@ )ÚTARGET_TO_PLATr> r> r? Ú get_platformb s
|
ýrH c C sz t jdkr| S | s| S | d dkr.td| | d dkrFtd| | d¡}d|krd| d¡ qP|snt jS t jj| S )aÎ Return 'pathname' as a name that will work on the native filesystem,
|
i.e. split it on '/' and put it back together again using the current
|
directory separator. Needed because filenames in the setup script are
|
always supplied in Unix style, and have to be converted to the local
|
convention before we can actually use them in the filesystem. Raises
|
ValueError on non-Unix-ish systems if 'pathname' either starts or
|
ends with a slash.
|
r r z path '%s' cannot be absoluteéÿÿÿÿz path '%s' cannot end with '/'Ú.)r! ÚsepÚ
|
ValueErrorÚsplitÚremoveÚcurdirÚpathÚjoin)ÚpathnameÚpathsr> r> r? Ú convert_pathm s
|
|
rT c C s t jdkr<t j |¡s$t j | |¡S t j | |dd
¡S nNt jdkr|t j |¡\}}|d dkrn|dd
}t j | |¡S tdt j dS )a Return 'pathname' with 'new_root' prepended. If 'pathname' is
|
relative, this is equivalent to "os.path.join(new_root,pathname)".
|
Otherwise, it requires making 'pathname' relative and then joining the
|
two, which is tricky on DOS/Windows and Mac OS.
|
r é Nr r ú\z!nothing known about platform '%s')r! r" rP ÚisabsrQ Ú
|
splitdriver )Únew_rootrR ÚdriverP r> r> r? Ú change_root s
|
|
r[ c C sx t rdS tjdkrZdtjkrZz$ddl} | t ¡ ¡d tjd< W n ttfk
|
rX Y nX dtjkrpt tjd< da dS )aL Ensure that 'os.environ' has all the environment variables we
|
guarantee that users can use in config files, command-line options,
|
etc. Currently this includes:
|
HOME - user's home directory (Unix only)
|
PLAT - description of the current platform, including hardware
|
and OS (see 'get_platform()')
|
Nr ÚHOMEr r ÚPLATrU )
|
Ú_environ_checkedr! r" r' ÚpwdÚgetpwuidÚgetuidÚ ImportErrorÚKeyErrorrH )r_ r> r> r? Ú check_environ s
|
rd c
|
C sV t |fdd}zt d|| ¡W S tk
|
rP } ztd| W 5 d}~X Y nX dS )aà Perform shell/Perl-style variable substitution on 'string'. Every
|
occurrence of '$' followed by a name is considered a variable, and
|
variable is substituted by the value found in the 'local_vars'
|
dictionary, or in 'os.environ' if it's not in 'local_vars'.
|
'os.environ' is first checked/augmented to guarantee that it contains
|
certain values: see 'check_environ()'. Raise ValueError for any
|
variables not found in either 'local_vars' or 'os.environ'.
|
c S s, | d¡}||kr t|| S tj| S d S )NrU )r0 Ústrr! r' )r/ Ú
|
local_varsÚvar_namer> r> r? Ú_substÅ s
|
zsubst_vars.<locals>._substz\$([a-zA-Z_][a-zA-Z_0-9]*)zinvalid variable '$%s'N)rd r, Úsubrc rL )Úsrf rh Úvarr> r> r? Ú
|
subst_vars» s rl úerror: c C s |t | S ©N)re )ÚexcÚprefixr> r> r? Úgrok_environment_errorÔ s rq c C s( t dtj ¡at d¡at d¡ad S )Nz [^\\\'\"%s ]*z'(?:[^'\\]|\\.)*'z"(?:[^"\\]|\\.)*")r, r- ÚstringÚ
|
whitespaceÚ _wordchars_reÚ
|
_squote_reÚ
|
_dquote_rer> r> r> r? Ú _init_regexÝ s
|
rw c C s t dkrt | ¡ } g }d}| rt | |¡}| ¡ }|t| krZ| | d|
¡ q| | tjkr| | d|
¡ | |d
¡ } d}nÔ| | dkrÂ| d|
| |d d
} |d }n¢| | dkrÜt
|
| |¡}n*| | dkröt | |¡}nt d| | |dkr t d| | | ¡ \}}| d|
| |d |d
| |d
} | ¡ d }|t| kr | | ¡ qq |S )
|
a Split a string up according to Unix shell-like rules for quotes and
|
backslashes. In short: words are delimited by spaces, as long as those
|
spaces are not escaped by a backslash, or inside a quoted string.
|
Single and double quotes are equivalent, and the quote characters can
|
be backslash-escaped. The backslash is stripped from any two-character
|
escape sequence, leaving only the escaped character. The quote
|
characters are stripped from any quoted string. Returns a list of
|
words.
|
Nr rV rU ú'ú"z!this can't happen (bad char '%c')z"bad string (mismatched %s quotes?)r )rt rw Ústripr/ ÚendÚlenÚappendrr rs Úlstripru rv Ú RuntimeErrorrL Úspan)rj ÚwordsÚposr< r{ Úbegr> r> r? Ú split_quotedã s@
|
|
,
|
r c C sP |dkr6d| j |f }|dd
dkr6|dd
d }t |¡ |sL| | dS )a Perform some action that affects the outside world (eg. by
|
writing to the filesystem). Such actions are special because they
|
are disabled by the 'dry_run' flag. This method takes care of all
|
that bureaucracy for you; all you have to do is supply the
|
function to call and an argument tuple for it (to embody the
|
"external action" being performed), and an optional message to
|
print.
|
Nz%s%réþÿÿÿz,)r ú))Ú__name__r Úinfo)ÚfuncÚargsÚmsgÚverboseÚdry_runr> r> r? Úexecute s
|
r c C s2 | ¡ } | dkrdS | dkr dS td| f dS )zôConvert a string representation of truth to true (1) or false (0).
|
|
True values are 'y', 'yes', 't', 'true', 'on', and '1'; false values
|
are 'n', 'no', 'f', 'false', 'off', and '0'. Raises ValueError if
|
'val' is anything else.
|
)ÚyÚyesÚtÚtrueÚonÚ1rU )ÚnÚnoÚfÚfalseÚoffÚ0r zinvalid truth value %rN)r% rL )Úvalr> r> r? Ú strtobool3 s r rU c C sT ddl }tjrtd|dkr*do(|dk}|s@z ddlm} | d\}
|
} W n. tk
|
rz ddlm} d| d }
|
} Y nX t d| ¡ |sø|
|
dk r¢t
|
|
|
d ¡} n
|
t | d } | B | d
|
¡ | d tt| ¡d ¡ | d |||||f ¡ W 5 Q R X tjg}| | ¡ ¡ | | ¡ t||d tt
|
j| fd| |d nddlm} | D ]þ}|dd
dkrjqP|dkr|dkrdn|}tjj ||d}n tj |¡}|}|rä|dt |
|krÔt d||f |t |d
}|røt
|
j ||¡}t
|
j |¡}|rP|s t!||r>t d||¡ |sL|||| nt "d||¡ qPdS )a~ Byte-compile a collection of Python source files to .pyc
|
files in a __pycache__ subdirectory. 'py_files' is a list
|
of files to compile; any files that don't end in ".py" are silently
|
skipped. 'optimize' must be one of the following:
|
0 - don't optimize
|
1 - normal optimization (like "python -O")
|
2 - extra optimization (like "python -OO")
|
If 'force' is true, all files are recompiled regardless of
|
timestamps.
|
|
The source filename encoded in each bytecode file defaults to the
|
filenames listed in 'py_files'; you can modify these with 'prefix' and
|
'basedir'. 'prefix' is a string that will be stripped off of each
|
source filename, and 'base_dir' is a directory name that will be
|
prepended (after 'prefix' is stripped). You can supply either or both
|
(or neither) of 'prefix' and 'base_dir', as you wish.
|
|
If 'dry_run' is true, doesn't actually do anything that would
|
affect the filesystem.
|
|
Byte-compilation is either done directly in this interpreter process
|
with the standard py_compile module, or indirectly by writing a
|
temporary script and executing it. Normally, you should let
|
'byte_compile()' figure out to use direct compilation or not (see
|
the source for details). The 'direct' flag is used by the script
|
generated in indirect mode; unless you know what you're doing, leave
|
it set to None.
|
r Nzbyte-compiling is disabled.T)Úmkstempú.py)Úmktempz$writing byte-compilation script '%s'Úwz2from distutils.util import byte_compile
|
files = [
|
z,
|
z]
|
z
|
byte_compile(files, optimize=%r, force=%r,
|
prefix=%r, base_dir=%r,
|
verbose=%r, dry_run=0,
|
direct=1)
|
)r z removing %s)r- éýÿÿÿr )Ú optimizationz1invalid prefix: filename %r doesn't start with %rzbyte-compiling %s to %sz%skipping byte-compilation of %s to %s)#Ú
|
subprocessr# Údont_write_bytecoder Útempfiler rb r r r r! ÚfdopenÚopenÚwriterQ ÚmapÚreprÚ
|
executableÚextendÚ"_optim_args_from_interpreter_flagsr} r r rN Ú
|
py_compiler- Ú importlibÚutilÚcache_from_sourcer| rL rP Úbasenamer Údebug)Úpy_filesÚoptimizeÚforcerp Úbase_dirr r Údirectr£ r Ú script_fdÚ script_namer ÚscriptÚcmdr- ÚfileÚoptÚcfileÚdfileÚ
|
cfile_baser> r> r? Ú byte_compileC sx $
|
|
û
|
ÿ
|
|
ÿ ÿ ÿr c C s | d¡}d}| |¡S )zReturn a version of the string escaped for inclusion in an
|
RFC-822 header, by ensuring there are 8 spaces space after each newline.
|
Ú
|
z
|
)rM rQ )ÚheaderÚlinesrK r> r> r? Ú rfc822_escapeØ s
|
rÆ c C sV | sdS ddl m}m} G dd d|}|dkr8|d}|||d}|j| dd dS )
|
a Invoke 2to3 on a list of Python files.
|
The files should all come from the build area, as the
|
modification is done in-place. To reduce the build time,
|
only files modified since the last invocation of this
|
function should be passed in the files argument.Nr )ÚRefactoringToolÚget_fixers_from_packagec @ s$ e Zd Zdd Zdd Zdd ZdS )z*run_2to3.<locals>.DistutilsRefactoringToolc _ s t j|f| d S rn )r Úerror)Úselfr r Úkwr> r> r? Ú log_errorï s z4run_2to3.<locals>.DistutilsRefactoringTool.log_errorc W s t j|f| d S rn )r r ©rÊ r r r> r> r? Ú log_messageò s z6run_2to3.<locals>.DistutilsRefactoringTool.log_messagec W s t j|f| d S rn )r r³ rÍ r> r> r? Ú log_debugõ s z4run_2to3.<locals>.DistutilsRefactoringTool.log_debugN)r Ú
|
__module__Ú __qualname__rÌ rÎ rÏ r> r> r> r? ÚDistutilsRefactoringToolî s rÒ z lib2to3.fixes)ÚoptionsT)r¨ )Úlib2to3.refactorrÇ rÈ Úrefactor)ÚfilesÚ fixer_namesrÓ ÚexplicitrÇ rÈ rÒ Úrr> r> r? Úrun_2to3â s
|
rÚ c C s ddl m} ddlm} ddlm} | } t ¡ }
|
t | ¡ z | ¡ W 5 t |
|
¡ X | j
|
| j dd
< |r| ¡ D ] } | ¡ } | sqr| | ¡ qrg } | j D ]L} tj || ¡}|tj |¡ |tj | | ¡|dd}|d r| |¡ qtdd | D |||d
|
| S ) zÏRecursively copy a directory, only copying new and changed files,
|
running run_2to3 over all newly copied Python modules afterward.
|
|
If you give a template string, it's parsed like a MANIFEST.in.
|
r )Úmkpath)Ú copy_file)ÚFileListNrU )Úupdatec S s g | ]}| ¡ d ¡r|qS )r )r% Úendswith)Ú.0Úfnr> r> r? Ú
|
<listcomp> s z$copydir_run_2to3.<locals>.<listcomp>)r× rÓ rØ )Údistutils.dir_utilrÛ Údistutils.file_utilrÜ Údistutils.filelistrÝ r! ÚgetcwdÚchdirÚfindallÚallfilesrÖ Ú
|
splitlinesrz Úprocess_template_linerP rQ Údirnamer} rÚ )ÚsrcÚdestÚtemplater× rÓ rØ rÛ rÜ rÝ ÚfilelistrO ÚlineÚcopiedÚfilenameÚoutnameÚresr> r> r? Úcopydir_run_2to3ý s:
|
|
ÿrö c @ s$ e Zd ZdZdZdZdZdd ZdS )Ú Mixin2to3zÀMixin class for commands that run 2to3.
|
To configure 2to3, setup scripts may either change
|
the class variables, or inherit from individual commands
|
to override how 2to3 is invoked.Nc C s t || j| j| jS rn )rÚ r× rÓ rØ )rÊ rÖ r> r> r? rÚ . s zMixin2to3.run_2to3)r rÐ rÑ Ú__doc__r× rÓ rØ rÚ r> r> r> r? r÷ s
|
r÷ )rm )Nr r )r r NNrU r N)NNN)NNNN)$rø r! r, Úimportlib.utilr¯ rr r# Údistutils.errorsr Údistutils.dep_utilr Údistutils.spawnr r= r r r@ rH rT r[ r^ rd rl rq rt ru rv rw r r r r rÆ rÚ rö r÷ r> r> r> r? Ú<module> sN P
|
=
|
ü
|
|
|
ÿ
|
!
|
