Warning: file_get_contents(https://raw.githubusercontent.com/Den1xxx/Filemanager/master/languages/ru.json): failed to open stream: HTTP request failed! HTTP/1.1 404 Not Found
in /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php on line 88
Warning: Cannot modify header information - headers already sent by (output started at /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php:88) in /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php on line 215
Warning: Cannot modify header information - headers already sent by (output started at /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php:88) in /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php on line 216
Warning: Cannot modify header information - headers already sent by (output started at /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php:88) in /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php on line 217
Warning: Cannot modify header information - headers already sent by (output started at /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php:88) in /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php on line 218
Warning: Cannot modify header information - headers already sent by (output started at /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php:88) in /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php on line 219
Warning: Cannot modify header information - headers already sent by (output started at /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php:88) in /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php on line 220
PK ! :vU5 U5 unixccompiler.pynu [ """distutils.unixccompiler
Contains the UnixCCompiler class, a subclass of CCompiler that handles
the "typical" Unix-style command-line C compiler:
* macros defined with -Dname[=value]
* macros undefined with -Uname
* include search directories specified with -Idir
* libraries specified with -lllib
* library search directories specified with -Ldir
* compile handled by 'cc' (or similar) executable with -c option:
compiles .c to .o
* link static library handled by 'ar' command (possibly with 'ranlib')
* link shared library handled by 'cc -shared'
"""
import os, sys, re
from distutils import sysconfig
from distutils.dep_util import newer
from distutils.ccompiler import \
CCompiler, gen_preprocess_options, gen_lib_options
from distutils.errors import \
DistutilsExecError, CompileError, LibError, LinkError
from distutils import log
if sys.platform == 'darwin':
import _osx_support
# XXX Things not currently handled:
# * optimization/debug/warning flags; we just use whatever's in Python's
# Makefile and live with it. Is this adequate? If not, we might
# have to have a bunch of subclasses GNUCCompiler, SGICCompiler,
# SunCCompiler, and I suspect down that road lies madness.
# * even if we don't know a warning flag from an optimization flag,
# we need some way for outsiders to feed preprocessor/compiler/linker
# flags in to us -- eg. a sysadmin might want to mandate certain flags
# via a site config file, or a user might want to set something for
# compiling this module distribution only via the setup.py command
# line, whatever. As long as these options come from something on the
# current system, they can be as system-dependent as they like, and we
# should just happily stuff them into the preprocessor/compiler/linker
# options and carry on.
class UnixCCompiler(CCompiler):
compiler_type = 'unix'
# These are used by CCompiler in two places: the constructor sets
# instance attributes 'preprocessor', 'compiler', etc. from them, and
# 'set_executable()' allows any of these to be set. The defaults here
# are pretty generic; they will probably have to be set by an outsider
# (eg. using information discovered by the sysconfig about building
# Python extensions).
executables = {'preprocessor' : None,
'compiler' : ["cc"],
'compiler_so' : ["cc"],
'compiler_cxx' : ["cc"],
'linker_so' : ["cc", "-shared"],
'linker_exe' : ["cc"],
'archiver' : ["ar", "-cr"],
'ranlib' : None,
}
if sys.platform[:6] == "darwin":
executables['ranlib'] = ["ranlib"]
# Needed for the filename generation methods provided by the base
# class, CCompiler. NB. whoever instantiates/uses a particular
# UnixCCompiler instance should set 'shared_lib_ext' -- we set a
# reasonable common default here, but it's not necessarily used on all
# Unices!
src_extensions = [".c",".C",".cc",".cxx",".cpp",".m"]
obj_extension = ".o"
static_lib_extension = ".a"
shared_lib_extension = ".so"
dylib_lib_extension = ".dylib"
static_lib_format = shared_lib_format = dylib_lib_format = "lib%s%s"
if sys.platform == "cygwin":
exe_extension = ".exe"
def _fix_lib_args(self, libraries, library_dirs, runtime_library_dirs):
"""Remove standard library path from rpath"""
libraries, library_dirs, runtime_library_dirs = super(
self.__class__, self)._fix_lib_args(libraries, library_dirs,
runtime_library_dirs)
libdir = sysconfig.get_config_var('LIBDIR')
if runtime_library_dirs and (libdir in runtime_library_dirs):
runtime_library_dirs.remove(libdir)
return libraries, library_dirs, runtime_library_dirs
def preprocess(self, source, output_file=None, macros=None,
include_dirs=None, extra_preargs=None, extra_postargs=None):
fixed_args = self._fix_compile_args(None, macros, include_dirs)
ignore, macros, include_dirs = fixed_args
pp_opts = gen_preprocess_options(macros, include_dirs)
pp_args = self.preprocessor + pp_opts
if output_file:
pp_args.extend(['-o', output_file])
if extra_preargs:
pp_args[:0] = extra_preargs
if extra_postargs:
pp_args.extend(extra_postargs)
pp_args.append(source)
# We need to preprocess: either we're being forced to, or we're
# generating output to stdout, or there's a target output file and
# the source file is newer than the target (or the target doesn't
# exist).
if self.force or output_file is None or newer(source, output_file):
if output_file:
self.mkpath(os.path.dirname(output_file))
try:
self.spawn(pp_args)
except DistutilsExecError as msg:
raise CompileError(msg)
def _compile(self, obj, src, ext, cc_args, extra_postargs, pp_opts):
compiler_so = self.compiler_so
if sys.platform == 'darwin':
compiler_so = _osx_support.compiler_fixup(compiler_so,
cc_args + extra_postargs)
try:
self.spawn(compiler_so + cc_args + [src, '-o', obj] +
extra_postargs)
except DistutilsExecError as msg:
raise CompileError(msg)
def create_static_lib(self, objects, output_libname,
output_dir=None, debug=0, target_lang=None):
objects, output_dir = self._fix_object_args(objects, output_dir)
output_filename = \
self.library_filename(output_libname, output_dir=output_dir)
if self._need_link(objects, output_filename):
self.mkpath(os.path.dirname(output_filename))
self.spawn(self.archiver +
[output_filename] +
objects + self.objects)
# Not many Unices required ranlib anymore -- SunOS 4.x is, I
# think the only major Unix that does. Maybe we need some
# platform intelligence here to skip ranlib if it's not
# needed -- or maybe Python's configure script took care of
# it for us, hence the check for leading colon.
if self.ranlib:
try:
self.spawn(self.ranlib + [output_filename])
except DistutilsExecError as msg:
raise LibError(msg)
else:
log.debug("skipping %s (up-to-date)", output_filename)
def link(self, target_desc, objects,
output_filename, output_dir=None, libraries=None,
library_dirs=None, runtime_library_dirs=None,
export_symbols=None, debug=0, extra_preargs=None,
extra_postargs=None, build_temp=None, target_lang=None):
objects, output_dir = self._fix_object_args(objects, output_dir)
fixed_args = self._fix_lib_args(libraries, library_dirs,
runtime_library_dirs)
libraries, library_dirs, runtime_library_dirs = fixed_args
lib_opts = gen_lib_options(self, library_dirs, runtime_library_dirs,
libraries)
if not isinstance(output_dir, (str, type(None))):
raise TypeError("'output_dir' must be a string or None")
if output_dir is not None:
output_filename = os.path.join(output_dir, output_filename)
if self._need_link(objects, output_filename):
ld_args = (objects + self.objects +
lib_opts + ['-o', output_filename])
if debug:
ld_args[:0] = ['-g']
if extra_preargs:
ld_args[:0] = extra_preargs
if extra_postargs:
ld_args.extend(extra_postargs)
self.mkpath(os.path.dirname(output_filename))
try:
if target_desc == CCompiler.EXECUTABLE:
linker = self.linker_exe[:]
else:
linker = self.linker_so[:]
if target_lang == "c++" and self.compiler_cxx:
# skip over environment variable settings if /usr/bin/env
# is used to set up the linker's environment.
# This is needed on OSX. Note: this assumes that the
# normal and C++ compiler have the same environment
# settings.
i = 0
if os.path.basename(linker[0]) == "env":
i = 1
while '=' in linker[i]:
i += 1
linker[i] = self.compiler_cxx[i]
if sys.platform == 'darwin':
linker = _osx_support.compiler_fixup(linker, ld_args)
self.spawn(linker + ld_args)
except DistutilsExecError as msg:
raise LinkError(msg)
else:
log.debug("skipping %s (up-to-date)", output_filename)
# -- Miscellaneous methods -----------------------------------------
# These are all used by the 'gen_lib_options() function, in
# ccompiler.py.
def library_dir_option(self, dir):
return "-L" + dir
def _is_gcc(self, compiler_name):
return "gcc" in compiler_name or "g++" in compiler_name
def runtime_library_dir_option(self, dir):
# XXX Hackish, at the very least. See Python bug #445902:
# http://sourceforge.net/tracker/index.php
# ?func=detail&aid=445902&group_id=5470&atid=105470
# Linkers on different platforms need different options to
# specify that directories need to be added to the list of
# directories searched for dependencies when a dynamic library
# is sought. GCC on GNU systems (Linux, FreeBSD, ...) has to
# be told to pass the -R option through to the linker, whereas
# other compilers and gcc on other systems just know this.
# Other compilers may need something slightly different. At
# this time, there's no way to determine this information from
# the configuration data stored in the Python installation, so
# we use this hack.
compiler = os.path.basename(sysconfig.get_config_var("CC"))
if sys.platform[:6] == "darwin":
# MacOSX's linker doesn't understand the -R flag at all
return "-L" + dir
elif sys.platform[:5] == "hp-ux":
if self._is_gcc(compiler):
return ["-Wl,+s", "-L" + dir]
return ["+s", "-L" + dir]
elif sys.platform[:7] == "irix646" or sys.platform[:6] == "osf1V5":
return ["-rpath", dir]
else:
if self._is_gcc(compiler):
# gcc on non-GNU systems does not need -Wl, but can
# use it anyway. Since distutils has always passed in
# -Wl whenever gcc was used in the past it is probably
# safest to keep doing so.
if sysconfig.get_config_var("GNULD") == "yes":
# GNU ld needs an extra option to get a RUNPATH
# instead of just an RPATH.
return "-Wl,--enable-new-dtags,-R" + dir
else:
return "-Wl,-R" + dir
else:
# No idea how --enable-new-dtags would be passed on to
# ld if this system was using GNU ld. Don't know if a
# system like this even exists.
return "-R" + dir
def library_option(self, lib):
return "-l" + lib
def find_library_file(self, dirs, lib, debug=0):
shared_f = self.library_filename(lib, lib_type='shared')
dylib_f = self.library_filename(lib, lib_type='dylib')
static_f = self.library_filename(lib, lib_type='static')
if sys.platform == 'darwin':
# On OSX users can specify an alternate SDK using
# '-isysroot', calculate the SDK root if it is specified
# (and use it further on)
cflags = sysconfig.get_config_var('CFLAGS')
m = re.search(r'-isysroot\s+(\S+)', cflags)
if m is None:
sysroot = '/'
else:
sysroot = m.group(1)
for dir in dirs:
shared = os.path.join(dir, shared_f)
dylib = os.path.join(dir, dylib_f)
static = os.path.join(dir, static_f)
if sys.platform == 'darwin' and (
dir.startswith('/System/') or (
dir.startswith('/usr/') and not dir.startswith('/usr/local/'))):
shared = os.path.join(sysroot, dir[1:], shared_f)
dylib = os.path.join(sysroot, dir[1:], dylib_f)
static = os.path.join(sysroot, dir[1:], static_f)
# We're second-guessing the linker here, with not much hard
# data to go on: GCC seems to prefer the shared library, so I'm
# assuming that *all* Unix C compilers do. And of course I'm
# ignoring even GCC's "-static" option. So sue me.
if os.path.exists(dylib):
return dylib
elif os.path.exists(shared):
return shared
elif os.path.exists(static):
return static
# Oops, didn't find it in *any* of 'dirs'
return None
PK ! [ __init__.pynu [ """distutils
The main package for the Python Module Distribution Utilities. Normally
used from a setup script as
from distutils.core import setup
setup (...)
"""
import sys
__version__ = sys.version[:sys.version.index(' ')]
PK ! 1}@ }@ cygwinccompiler.pynu [ """distutils.cygwinccompiler
Provides the CygwinCCompiler class, a subclass of UnixCCompiler that
handles the Cygwin port of the GNU C compiler to Windows. It also contains
the Mingw32CCompiler class which handles the mingw32 port of GCC (same as
cygwin in no-cygwin mode).
"""
# problems:
#
# * if you use a msvc compiled python version (1.5.2)
# 1. you have to insert a __GNUC__ section in its config.h
# 2. you have to generate a import library for its dll
# - create a def-file for python??.dll
# - create a import library using
# dlltool --dllname python15.dll --def python15.def \
# --output-lib libpython15.a
#
# see also http://starship.python.net/crew/kernr/mingw32/Notes.html
#
# * We put export_symbols in a def-file, and don't use
# --export-all-symbols because it doesn't worked reliable in some
# tested configurations. And because other windows compilers also
# need their symbols specified this no serious problem.
#
# tested configurations:
#
# * cygwin gcc 2.91.57/ld 2.9.4/dllwrap 0.2.4 works
# (after patching python's config.h and for C++ some other include files)
# see also http://starship.python.net/crew/kernr/mingw32/Notes.html
# * mingw32 gcc 2.95.2/ld 2.9.4/dllwrap 0.2.4 works
# (ld doesn't support -shared, so we use dllwrap)
# * cygwin gcc 2.95.2/ld 2.10.90/dllwrap 2.10.90 works now
# - its dllwrap doesn't work, there is a bug in binutils 2.10.90
# see also http://sources.redhat.com/ml/cygwin/2000-06/msg01274.html
# - using gcc -mdll instead dllwrap doesn't work without -static because
# it tries to link against dlls instead their import libraries. (If
# it finds the dll first.)
# By specifying -static we force ld to link against the import libraries,
# this is windows standard and there are normally not the necessary symbols
# in the dlls.
# *** only the version of June 2000 shows these problems
# * cygwin gcc 3.2/ld 2.13.90 works
# (ld supports -shared)
# * mingw gcc 3.2/ld 2.13 works
# (ld supports -shared)
import os
import sys
import copy
from subprocess import Popen, PIPE, check_output
import re
from distutils.ccompiler import gen_preprocess_options, gen_lib_options
from distutils.unixccompiler import UnixCCompiler
from distutils.file_util import write_file
from distutils.errors import DistutilsExecError, CompileError, UnknownFileError
from distutils import log
from distutils.version import LooseVersion
from distutils.spawn import find_executable
def get_msvcr():
"""Include the appropriate MSVC runtime library if Python was built
with MSVC 7.0 or later.
"""
msc_pos = sys.version.find('MSC v.')
if msc_pos != -1:
msc_ver = sys.version[msc_pos+6:msc_pos+10]
if msc_ver == '1300':
# MSVC 7.0
return ['msvcr70']
elif msc_ver == '1310':
# MSVC 7.1
return ['msvcr71']
elif msc_ver == '1400':
# VS2005 / MSVC 8.0
return ['msvcr80']
elif msc_ver == '1500':
# VS2008 / MSVC 9.0
return ['msvcr90']
elif msc_ver == '1600':
# VS2010 / MSVC 10.0
return ['msvcr100']
else:
raise ValueError("Unknown MS Compiler version %s " % msc_ver)
class CygwinCCompiler(UnixCCompiler):
""" Handles the Cygwin port of the GNU C compiler to Windows.
"""
compiler_type = 'cygwin'
obj_extension = ".o"
static_lib_extension = ".a"
shared_lib_extension = ".dll"
static_lib_format = "lib%s%s"
shared_lib_format = "%s%s"
exe_extension = ".exe"
def __init__(self, verbose=0, dry_run=0, force=0):
UnixCCompiler.__init__(self, verbose, dry_run, force)
status, details = check_config_h()
self.debug_print("Python's GCC status: %s (details: %s)" %
(status, details))
if status is not CONFIG_H_OK:
self.warn(
"Python's pyconfig.h doesn't seem to support your compiler. "
"Reason: %s. "
"Compiling may fail because of undefined preprocessor macros."
% details)
self.gcc_version, self.ld_version, self.dllwrap_version = \
get_versions()
self.debug_print(self.compiler_type + ": gcc %s, ld %s, dllwrap %s\n" %
(self.gcc_version,
self.ld_version,
self.dllwrap_version) )
# ld_version >= "2.10.90" and < "2.13" should also be able to use
# gcc -mdll instead of dllwrap
# Older dllwraps had own version numbers, newer ones use the
# same as the rest of binutils ( also ld )
# dllwrap 2.10.90 is buggy
if self.ld_version >= "2.10.90":
self.linker_dll = "gcc"
else:
self.linker_dll = "dllwrap"
# ld_version >= "2.13" support -shared so use it instead of
# -mdll -static
if self.ld_version >= "2.13":
shared_option = "-shared"
else:
shared_option = "-mdll -static"
# Hard-code GCC because that's what this is all about.
# XXX optimization, warnings etc. should be customizable.
self.set_executables(compiler='gcc -mcygwin -O -Wall',
compiler_so='gcc -mcygwin -mdll -O -Wall',
compiler_cxx='g++ -mcygwin -O -Wall',
linker_exe='gcc -mcygwin',
linker_so=('%s -mcygwin %s' %
(self.linker_dll, shared_option)))
# cygwin and mingw32 need different sets of libraries
if self.gcc_version == "2.91.57":
# cygwin shouldn't need msvcrt, but without the dlls will crash
# (gcc version 2.91.57) -- perhaps something about initialization
self.dll_libraries=["msvcrt"]
self.warn(
"Consider upgrading to a newer version of gcc")
else:
# Include the appropriate MSVC runtime library if Python was built
# with MSVC 7.0 or later.
self.dll_libraries = get_msvcr()
def _compile(self, obj, src, ext, cc_args, extra_postargs, pp_opts):
"""Compiles the source by spawning GCC and windres if needed."""
if ext == '.rc' or ext == '.res':
# gcc needs '.res' and '.rc' compiled to object files !!!
try:
self.spawn(["windres", "-i", src, "-o", obj])
except DistutilsExecError as msg:
raise CompileError(msg)
else: # for other files use the C-compiler
try:
self.spawn(self.compiler_so + cc_args + [src, '-o', obj] +
extra_postargs)
except DistutilsExecError as msg:
raise CompileError(msg)
def link(self, target_desc, objects, output_filename, output_dir=None,
libraries=None, library_dirs=None, runtime_library_dirs=None,
export_symbols=None, debug=0, extra_preargs=None,
extra_postargs=None, build_temp=None, target_lang=None):
"""Link the objects."""
# use separate copies, so we can modify the lists
extra_preargs = copy.copy(extra_preargs or [])
libraries = copy.copy(libraries or [])
objects = copy.copy(objects or [])
# Additional libraries
libraries.extend(self.dll_libraries)
# handle export symbols by creating a def-file
# with executables this only works with gcc/ld as linker
if ((export_symbols is not None) and
(target_desc != self.EXECUTABLE or self.linker_dll == "gcc")):
# (The linker doesn't do anything if output is up-to-date.
# So it would probably better to check if we really need this,
# but for this we had to insert some unchanged parts of
# UnixCCompiler, and this is not what we want.)
# we want to put some files in the same directory as the
# object files are, build_temp doesn't help much
# where are the object files
temp_dir = os.path.dirname(objects[0])
# name of dll to give the helper files the same base name
(dll_name, dll_extension) = os.path.splitext(
os.path.basename(output_filename))
# generate the filenames for these files
def_file = os.path.join(temp_dir, dll_name + ".def")
lib_file = os.path.join(temp_dir, 'lib' + dll_name + ".a")
# Generate .def file
contents = [
"LIBRARY %s" % os.path.basename(output_filename),
"EXPORTS"]
for sym in export_symbols:
contents.append(sym)
self.execute(write_file, (def_file, contents),
"writing %s" % def_file)
# next add options for def-file and to creating import libraries
# dllwrap uses different options than gcc/ld
if self.linker_dll == "dllwrap":
extra_preargs.extend(["--output-lib", lib_file])
# for dllwrap we have to use a special option
extra_preargs.extend(["--def", def_file])
# we use gcc/ld here and can be sure ld is >= 2.9.10
else:
# doesn't work: bfd_close build\...\libfoo.a: Invalid operation
#extra_preargs.extend(["-Wl,--out-implib,%s" % lib_file])
# for gcc/ld the def-file is specified as any object files
objects.append(def_file)
#end: if ((export_symbols is not None) and
# (target_desc != self.EXECUTABLE or self.linker_dll == "gcc")):
# who wants symbols and a many times larger output file
# should explicitly switch the debug mode on
# otherwise we let dllwrap/ld strip the output file
# (On my machine: 10KB < stripped_file < ??100KB
# unstripped_file = stripped_file + XXX KB
# ( XXX=254 for a typical python extension))
if not debug:
extra_preargs.append("-s")
UnixCCompiler.link(self, target_desc, objects, output_filename,
output_dir, libraries, library_dirs,
runtime_library_dirs,
None, # export_symbols, we do this in our def-file
debug, extra_preargs, extra_postargs, build_temp,
target_lang)
# -- Miscellaneous methods -----------------------------------------
def object_filenames(self, source_filenames, strip_dir=0, output_dir=''):
"""Adds supports for rc and res files."""
if output_dir is None:
output_dir = ''
obj_names = []
for src_name in source_filenames:
# use normcase to make sure '.rc' is really '.rc' and not '.RC'
base, ext = os.path.splitext(os.path.normcase(src_name))
if ext not in (self.src_extensions + ['.rc','.res']):
raise UnknownFileError("unknown file type '%s' (from '%s')" % \
(ext, src_name))
if strip_dir:
base = os.path.basename (base)
if ext in ('.res', '.rc'):
# these need to be compiled to object files
obj_names.append (os.path.join(output_dir,
base + ext + self.obj_extension))
else:
obj_names.append (os.path.join(output_dir,
base + self.obj_extension))
return obj_names
# the same as cygwin plus some additional parameters
class Mingw32CCompiler(CygwinCCompiler):
""" Handles the Mingw32 port of the GNU C compiler to Windows.
"""
compiler_type = 'mingw32'
def __init__(self, verbose=0, dry_run=0, force=0):
CygwinCCompiler.__init__ (self, verbose, dry_run, force)
# ld_version >= "2.13" support -shared so use it instead of
# -mdll -static
if self.ld_version >= "2.13":
shared_option = "-shared"
else:
shared_option = "-mdll -static"
# A real mingw32 doesn't need to specify a different entry point,
# but cygwin 2.91.57 in no-cygwin-mode needs it.
if self.gcc_version <= "2.91.57":
entry_point = '--entry _DllMain@12'
else:
entry_point = ''
if self.gcc_version < '4' or is_cygwingcc():
no_cygwin = ' -mno-cygwin'
else:
no_cygwin = ''
self.set_executables(compiler='gcc%s -O -Wall' % no_cygwin,
compiler_so='gcc%s -mdll -O -Wall' % no_cygwin,
compiler_cxx='g++%s -O -Wall' % no_cygwin,
linker_exe='gcc%s' % no_cygwin,
linker_so='%s%s %s %s'
% (self.linker_dll, no_cygwin,
shared_option, entry_point))
# Maybe we should also append -mthreads, but then the finished
# dlls need another dll (mingwm10.dll see Mingw32 docs)
# (-mthreads: Support thread-safe exception handling on `Mingw32')
# no additional libraries needed
self.dll_libraries=[]
# Include the appropriate MSVC runtime library if Python was built
# with MSVC 7.0 or later.
self.dll_libraries = get_msvcr()
# Because these compilers aren't configured in Python's pyconfig.h file by
# default, we should at least warn the user if he is using a unmodified
# version.
CONFIG_H_OK = "ok"
CONFIG_H_NOTOK = "not ok"
CONFIG_H_UNCERTAIN = "uncertain"
def check_config_h():
"""Check if the current Python installation appears amenable to building
extensions with GCC.
Returns a tuple (status, details), where 'status' is one of the following
constants:
- CONFIG_H_OK: all is well, go ahead and compile
- CONFIG_H_NOTOK: doesn't look good
- CONFIG_H_UNCERTAIN: not sure -- unable to read pyconfig.h
'details' is a human-readable string explaining the situation.
Note there are two ways to conclude "OK": either 'sys.version' contains
the string "GCC" (implying that this Python was built with GCC), or the
installed "pyconfig.h" contains the string "__GNUC__".
"""
# XXX since this function also checks sys.version, it's not strictly a
# "pyconfig.h" check -- should probably be renamed...
from distutils import sysconfig
# if sys.version contains GCC then python was compiled with GCC, and the
# pyconfig.h file should be OK
if "GCC" in sys.version:
return CONFIG_H_OK, "sys.version mentions 'GCC'"
# let's see if __GNUC__ is mentioned in python.h
fn = sysconfig.get_config_h_filename()
try:
config_h = open(fn)
try:
if "__GNUC__" in config_h.read():
return CONFIG_H_OK, "'%s' mentions '__GNUC__'" % fn
else:
return CONFIG_H_NOTOK, "'%s' does not mention '__GNUC__'" % fn
finally:
config_h.close()
except IOError as exc:
return (CONFIG_H_UNCERTAIN,
"couldn't read '%s': %s" % (fn, exc.strerror))
RE_VERSION = re.compile(b'(\d+\.\d+(\.\d+)*)')
def _find_exe_version(cmd):
"""Find the version of an executable by running `cmd` in the shell.
If the command is not found, or the output does not match
`RE_VERSION`, returns None.
"""
executable = cmd.split()[0]
if find_executable(executable) is None:
return None
out = Popen(cmd, shell=True, stdout=PIPE).stdout
try:
out_string = out.read()
finally:
out.close()
result = RE_VERSION.search(out_string)
if result is None:
return None
# LooseVersion works with strings
# so we need to decode our bytes
return LooseVersion(result.group(1).decode())
def get_versions():
""" Try to find out the versions of gcc, ld and dllwrap.
If not possible it returns None for it.
"""
commands = ['gcc -dumpversion', 'ld -v', 'dllwrap --version']
return tuple([_find_exe_version(cmd) for cmd in commands])
def is_cygwingcc():
'''Try to determine if the gcc that would be used is from cygwin.'''
out_string = check_output(['gcc', '-dumpmachine'])
return out_string.strip().endswith(b'cygwin')
PK ! _H% debug.pynu [ import os
# If DISTUTILS_DEBUG is anything other than the empty string, we run in
# debug mode.
DEBUG = os.environ.get('DISTUTILS_DEBUG')
PK ! K0 0 text_file.pynu [ """text_file
provides the TextFile class, which gives an interface to text files
that (optionally) takes care of stripping comments, ignoring blank
lines, and joining lines with backslashes."""
import sys, os, io
class TextFile:
"""Provides a file-like object that takes care of all the things you
commonly want to do when processing a text file that has some
line-by-line syntax: strip comments (as long as "#" is your
comment character), skip blank lines, join adjacent lines by
escaping the newline (ie. backslash at end of line), strip
leading and/or trailing whitespace. All of these are optional
and independently controllable.
Provides a 'warn()' method so you can generate warning messages that
report physical line number, even if the logical line in question
spans multiple physical lines. Also provides 'unreadline()' for
implementing line-at-a-time lookahead.
Constructor is called as:
TextFile (filename=None, file=None, **options)
It bombs (RuntimeError) if both 'filename' and 'file' are None;
'filename' should be a string, and 'file' a file object (or
something that provides 'readline()' and 'close()' methods). It is
recommended that you supply at least 'filename', so that TextFile
can include it in warning messages. If 'file' is not supplied,
TextFile creates its own using 'io.open()'.
The options are all boolean, and affect the value returned by
'readline()':
strip_comments [default: true]
strip from "#" to end-of-line, as well as any whitespace
leading up to the "#" -- unless it is escaped by a backslash
lstrip_ws [default: false]
strip leading whitespace from each line before returning it
rstrip_ws [default: true]
strip trailing whitespace (including line terminator!) from
each line before returning it
skip_blanks [default: true}
skip lines that are empty *after* stripping comments and
whitespace. (If both lstrip_ws and rstrip_ws are false,
then some lines may consist of solely whitespace: these will
*not* be skipped, even if 'skip_blanks' is true.)
join_lines [default: false]
if a backslash is the last non-newline character on a line
after stripping comments and whitespace, join the following line
to it to form one "logical line"; if N consecutive lines end
with a backslash, then N+1 physical lines will be joined to
form one logical line.
collapse_join [default: false]
strip leading whitespace from lines that are joined to their
predecessor; only matters if (join_lines and not lstrip_ws)
errors [default: 'strict']
error handler used to decode the file content
Note that since 'rstrip_ws' can strip the trailing newline, the
semantics of 'readline()' must differ from those of the builtin file
object's 'readline()' method! In particular, 'readline()' returns
None for end-of-file: an empty string might just be a blank line (or
an all-whitespace line), if 'rstrip_ws' is true but 'skip_blanks' is
not."""
default_options = { 'strip_comments': 1,
'skip_blanks': 1,
'lstrip_ws': 0,
'rstrip_ws': 1,
'join_lines': 0,
'collapse_join': 0,
'errors': 'strict',
}
def __init__(self, filename=None, file=None, **options):
"""Construct a new TextFile object. At least one of 'filename'
(a string) and 'file' (a file-like object) must be supplied.
They keyword argument options are described above and affect
the values returned by 'readline()'."""
if filename is None and file is None:
raise RuntimeError("you must supply either or both of 'filename' and 'file'")
# set values for all options -- either from client option hash
# or fallback to default_options
for opt in self.default_options.keys():
if opt in options:
setattr(self, opt, options[opt])
else:
setattr(self, opt, self.default_options[opt])
# sanity check client option hash
for opt in options.keys():
if opt not in self.default_options:
raise KeyError("invalid TextFile option '%s'" % opt)
if file is None:
self.open(filename)
else:
self.filename = filename
self.file = file
self.current_line = 0 # assuming that file is at BOF!
# 'linebuf' is a stack of lines that will be emptied before we
# actually read from the file; it's only populated by an
# 'unreadline()' operation
self.linebuf = []
def open(self, filename):
"""Open a new file named 'filename'. This overrides both the
'filename' and 'file' arguments to the constructor."""
self.filename = filename
self.file = io.open(self.filename, 'r', errors=self.errors)
self.current_line = 0
def close(self):
"""Close the current file and forget everything we know about it
(filename, current line number)."""
self.file.close()
self.file = None
self.filename = None
self.current_line = None
def gen_error(self, msg, line=None):
outmsg = []
if line is None:
line = self.current_line
outmsg.append(self.filename + ", ")
if isinstance(line, (list, tuple)):
outmsg.append("lines %d-%d: " % tuple(line))
else:
outmsg.append("line %d: " % line)
outmsg.append(str(msg))
return "".join(outmsg)
def error(self, msg, line=None):
raise ValueError("error: " + self.gen_error(msg, line))
def warn(self, msg, line=None):
"""Print (to stderr) a warning message tied to the current logical
line in the current file. If the current logical line in the
file spans multiple physical lines, the warning refers to the
whole range, eg. "lines 3-5". If 'line' supplied, it overrides
the current line number; it may be a list or tuple to indicate a
range of physical lines, or an integer for a single physical
line."""
sys.stderr.write("warning: " + self.gen_error(msg, line) + "\n")
def readline(self):
"""Read and return a single logical line from the current file (or
from an internal buffer if lines have previously been "unread"
with 'unreadline()'). If the 'join_lines' option is true, this
may involve reading multiple physical lines concatenated into a
single string. Updates the current line number, so calling
'warn()' after 'readline()' emits a warning about the physical
line(s) just read. Returns None on end-of-file, since the empty
string can occur if 'rstrip_ws' is true but 'strip_blanks' is
not."""
# If any "unread" lines waiting in 'linebuf', return the top
# one. (We don't actually buffer read-ahead data -- lines only
# get put in 'linebuf' if the client explicitly does an
# 'unreadline()'.
if self.linebuf:
line = self.linebuf[-1]
del self.linebuf[-1]
return line
buildup_line = ''
while True:
# read the line, make it None if EOF
line = self.file.readline()
if line == '':
line = None
if self.strip_comments and line:
# Look for the first "#" in the line. If none, never
# mind. If we find one and it's the first character, or
# is not preceded by "\", then it starts a comment --
# strip the comment, strip whitespace before it, and
# carry on. Otherwise, it's just an escaped "#", so
# unescape it (and any other escaped "#"'s that might be
# lurking in there) and otherwise leave the line alone.
pos = line.find("#")
if pos == -1: # no "#" -- no comments
pass
# It's definitely a comment -- either "#" is the first
# character, or it's elsewhere and unescaped.
elif pos == 0 or line[pos-1] != "\\":
# Have to preserve the trailing newline, because it's
# the job of a later step (rstrip_ws) to remove it --
# and if rstrip_ws is false, we'd better preserve it!
# (NB. this means that if the final line is all comment
# and has no trailing newline, we will think that it's
# EOF; I think that's OK.)
eol = (line[-1] == '\n') and '\n' or ''
line = line[0:pos] + eol
# If all that's left is whitespace, then skip line
# *now*, before we try to join it to 'buildup_line' --
# that way constructs like
# hello \\
# # comment that should be ignored
# there
# result in "hello there".
if line.strip() == "":
continue
else: # it's an escaped "#"
line = line.replace("\\#", "#")
# did previous line end with a backslash? then accumulate
if self.join_lines and buildup_line:
# oops: end of file
if line is None:
self.warn("continuation line immediately precedes "
"end-of-file")
return buildup_line
if self.collapse_join:
line = line.lstrip()
line = buildup_line + line
# careful: pay attention to line number when incrementing it
if isinstance(self.current_line, list):
self.current_line[1] = self.current_line[1] + 1
else:
self.current_line = [self.current_line,
self.current_line + 1]
# just an ordinary line, read it as usual
else:
if line is None: # eof
return None
# still have to be careful about incrementing the line number!
if isinstance(self.current_line, list):
self.current_line = self.current_line[1] + 1
else:
self.current_line = self.current_line + 1
# strip whitespace however the client wants (leading and
# trailing, or one or the other, or neither)
if self.lstrip_ws and self.rstrip_ws:
line = line.strip()
elif self.lstrip_ws:
line = line.lstrip()
elif self.rstrip_ws:
line = line.rstrip()
# blank line (whether we rstrip'ed or not)? skip to next line
# if appropriate
if (line == '' or line == '\n') and self.skip_blanks:
continue
if self.join_lines:
if line[-1] == '\\':
buildup_line = line[:-1]
continue
if line[-2:] == '\\\n':
buildup_line = line[0:-2] + '\n'
continue
# well, I guess there's some actual content there: return it
return line
def readlines(self):
"""Read and return the list of all logical lines remaining in the
current file."""
lines = []
while True:
line = self.readline()
if line is None:
return lines
lines.append(line)
def unreadline(self, line):
"""Push 'line' (a string) onto an internal buffer that will be
checked by future 'readline()' calls. Handy for implementing
a parser with line-at-a-time lookahead."""
self.linebuf.append(line)
PK ! 1xE xE fancy_getopt.pynu [ """distutils.fancy_getopt
Wrapper around the standard getopt module that provides the following
additional features:
* short and long options are tied together
* options have help strings, so fancy_getopt could potentially
create a complete usage summary
* options set attributes of a passed-in object
"""
import sys, string, re
import getopt
from distutils.errors import *
# Much like command_re in distutils.core, this is close to but not quite
# the same as a Python NAME -- except, in the spirit of most GNU
# utilities, we use '-' in place of '_'. (The spirit of LISP lives on!)
# The similarities to NAME are again not a coincidence...
longopt_pat = r'[a-zA-Z](?:[a-zA-Z0-9-]*)'
longopt_re = re.compile(r'^%s$' % longopt_pat)
# For recognizing "negative alias" options, eg. "quiet=!verbose"
neg_alias_re = re.compile("^(%s)=!(%s)$" % (longopt_pat, longopt_pat))
# This is used to translate long options to legitimate Python identifiers
# (for use as attributes of some object).
longopt_xlate = str.maketrans('-', '_')
class FancyGetopt:
"""Wrapper around the standard 'getopt()' module that provides some
handy extra functionality:
* short and long options are tied together
* options have help strings, and help text can be assembled
from them
* options set attributes of a passed-in object
* boolean options can have "negative aliases" -- eg. if
--quiet is the "negative alias" of --verbose, then "--quiet"
on the command line sets 'verbose' to false
"""
def __init__(self, option_table=None):
# The option table is (currently) a list of tuples. The
# tuples may have 3 or four values:
# (long_option, short_option, help_string [, repeatable])
# if an option takes an argument, its long_option should have '='
# appended; short_option should just be a single character, no ':'
# in any case. If a long_option doesn't have a corresponding
# short_option, short_option should be None. All option tuples
# must have long options.
self.option_table = option_table
# 'option_index' maps long option names to entries in the option
# table (ie. those 3-tuples).
self.option_index = {}
if self.option_table:
self._build_index()
# 'alias' records (duh) alias options; {'foo': 'bar'} means
# --foo is an alias for --bar
self.alias = {}
# 'negative_alias' keeps track of options that are the boolean
# opposite of some other option
self.negative_alias = {}
# These keep track of the information in the option table. We
# don't actually populate these structures until we're ready to
# parse the command-line, since the 'option_table' passed in here
# isn't necessarily the final word.
self.short_opts = []
self.long_opts = []
self.short2long = {}
self.attr_name = {}
self.takes_arg = {}
# And 'option_order' is filled up in 'getopt()'; it records the
# original order of options (and their values) on the command-line,
# but expands short options, converts aliases, etc.
self.option_order = []
def _build_index(self):
self.option_index.clear()
for option in self.option_table:
self.option_index[option[0]] = option
def set_option_table(self, option_table):
self.option_table = option_table
self._build_index()
def add_option(self, long_option, short_option=None, help_string=None):
if long_option in self.option_index:
raise DistutilsGetoptError(
"option conflict: already an option '%s'" % long_option)
else:
option = (long_option, short_option, help_string)
self.option_table.append(option)
self.option_index[long_option] = option
def has_option(self, long_option):
"""Return true if the option table for this parser has an
option with long name 'long_option'."""
return long_option in self.option_index
def get_attr_name(self, long_option):
"""Translate long option name 'long_option' to the form it
has as an attribute of some object: ie., translate hyphens
to underscores."""
return long_option.translate(longopt_xlate)
def _check_alias_dict(self, aliases, what):
assert isinstance(aliases, dict)
for (alias, opt) in aliases.items():
if alias not in self.option_index:
raise DistutilsGetoptError(("invalid %s '%s': "
"option '%s' not defined") % (what, alias, alias))
if opt not in self.option_index:
raise DistutilsGetoptError(("invalid %s '%s': "
"aliased option '%s' not defined") % (what, alias, opt))
def set_aliases(self, alias):
"""Set the aliases for this option parser."""
self._check_alias_dict(alias, "alias")
self.alias = alias
def set_negative_aliases(self, negative_alias):
"""Set the negative aliases for this option parser.
'negative_alias' should be a dictionary mapping option names to
option names, both the key and value must already be defined
in the option table."""
self._check_alias_dict(negative_alias, "negative alias")
self.negative_alias = negative_alias
def _grok_option_table(self):
"""Populate the various data structures that keep tabs on the
option table. Called by 'getopt()' before it can do anything
worthwhile.
"""
self.long_opts = []
self.short_opts = []
self.short2long.clear()
self.repeat = {}
for option in self.option_table:
if len(option) == 3:
long, short, help = option
repeat = 0
elif len(option) == 4:
long, short, help, repeat = option
else:
# the option table is part of the code, so simply
# assert that it is correct
raise ValueError("invalid option tuple: %r" % (option,))
# Type- and value-check the option names
if not isinstance(long, str) or len(long) < 2:
raise DistutilsGetoptError(("invalid long option '%s': "
"must be a string of length >= 2") % long)
if (not ((short is None) or
(isinstance(short, str) and len(short) == 1))):
raise DistutilsGetoptError("invalid short option '%s': "
"must a single character or None" % short)
self.repeat[long] = repeat
self.long_opts.append(long)
if long[-1] == '=': # option takes an argument?
if short: short = short + ':'
long = long[0:-1]
self.takes_arg[long] = 1
else:
# Is option is a "negative alias" for some other option (eg.
# "quiet" == "!verbose")?
alias_to = self.negative_alias.get(long)
if alias_to is not None:
if self.takes_arg[alias_to]:
raise DistutilsGetoptError(
"invalid negative alias '%s': "
"aliased option '%s' takes a value"
% (long, alias_to))
self.long_opts[-1] = long # XXX redundant?!
self.takes_arg[long] = 0
# If this is an alias option, make sure its "takes arg" flag is
# the same as the option it's aliased to.
alias_to = self.alias.get(long)
if alias_to is not None:
if self.takes_arg[long] != self.takes_arg[alias_to]:
raise DistutilsGetoptError(
"invalid alias '%s': inconsistent with "
"aliased option '%s' (one of them takes a value, "
"the other doesn't"
% (long, alias_to))
# Now enforce some bondage on the long option name, so we can
# later translate it to an attribute name on some object. Have
# to do this a bit late to make sure we've removed any trailing
# '='.
if not longopt_re.match(long):
raise DistutilsGetoptError(
"invalid long option name '%s' "
"(must be letters, numbers, hyphens only" % long)
self.attr_name[long] = self.get_attr_name(long)
if short:
self.short_opts.append(short)
self.short2long[short[0]] = long
def getopt(self, args=None, object=None):
"""Parse command-line options in args. Store as attributes on object.
If 'args' is None or not supplied, uses 'sys.argv[1:]'. If
'object' is None or not supplied, creates a new OptionDummy
object, stores option values there, and returns a tuple (args,
object). If 'object' is supplied, it is modified in place and
'getopt()' just returns 'args'; in both cases, the returned
'args' is a modified copy of the passed-in 'args' list, which
is left untouched.
"""
if args is None:
args = sys.argv[1:]
if object is None:
object = OptionDummy()
created_object = True
else:
created_object = False
self._grok_option_table()
short_opts = ' '.join(self.short_opts)
try:
opts, args = getopt.getopt(args, short_opts, self.long_opts)
except getopt.error as msg:
raise DistutilsArgError(msg)
for opt, val in opts:
if len(opt) == 2 and opt[0] == '-': # it's a short option
opt = self.short2long[opt[1]]
else:
assert len(opt) > 2 and opt[:2] == '--'
opt = opt[2:]
alias = self.alias.get(opt)
if alias:
opt = alias
if not self.takes_arg[opt]: # boolean option?
assert val == '', "boolean option can't have value"
alias = self.negative_alias.get(opt)
if alias:
opt = alias
val = 0
else:
val = 1
attr = self.attr_name[opt]
# The only repeating option at the moment is 'verbose'.
# It has a negative option -q quiet, which should set verbose = 0.
if val and self.repeat.get(attr) is not None:
val = getattr(object, attr, 0) + 1
setattr(object, attr, val)
self.option_order.append((opt, val))
# for opts
if created_object:
return args, object
else:
return args
def get_option_order(self):
"""Returns the list of (option, value) tuples processed by the
previous run of 'getopt()'. Raises RuntimeError if
'getopt()' hasn't been called yet.
"""
if self.option_order is None:
raise RuntimeError("'getopt()' hasn't been called yet")
else:
return self.option_order
def generate_help(self, header=None):
"""Generate help text (a list of strings, one per suggested line of
output) from the option table for this FancyGetopt object.
"""
# Blithely assume the option table is good: probably wouldn't call
# 'generate_help()' unless you've already called 'getopt()'.
# First pass: determine maximum length of long option names
max_opt = 0
for option in self.option_table:
long = option[0]
short = option[1]
l = len(long)
if long[-1] == '=':
l = l - 1
if short is not None:
l = l + 5 # " (-x)" where short == 'x'
if l > max_opt:
max_opt = l
opt_width = max_opt + 2 + 2 + 2 # room for indent + dashes + gutter
# Typical help block looks like this:
# --foo controls foonabulation
# Help block for longest option looks like this:
# --flimflam set the flim-flam level
# and with wrapped text:
# --flimflam set the flim-flam level (must be between
# 0 and 100, except on Tuesdays)
# Options with short names will have the short name shown (but
# it doesn't contribute to max_opt):
# --foo (-f) controls foonabulation
# If adding the short option would make the left column too wide,
# we push the explanation off to the next line
# --flimflam (-l)
# set the flim-flam level
# Important parameters:
# - 2 spaces before option block start lines
# - 2 dashes for each long option name
# - min. 2 spaces between option and explanation (gutter)
# - 5 characters (incl. space) for short option name
# Now generate lines of help text. (If 80 columns were good enough
# for Jesus, then 78 columns are good enough for me!)
line_width = 78
text_width = line_width - opt_width
big_indent = ' ' * opt_width
if header:
lines = [header]
else:
lines = ['Option summary:']
for option in self.option_table:
long, short, help = option[:3]
text = wrap_text(help, text_width)
if long[-1] == '=':
long = long[0:-1]
# Case 1: no short option at all (makes life easy)
if short is None:
if text:
lines.append(" --%-*s %s" % (max_opt, long, text[0]))
else:
lines.append(" --%-*s " % (max_opt, long))
# Case 2: we have a short option, so we have to include it
# just after the long option
else:
opt_names = "%s (-%s)" % (long, short)
if text:
lines.append(" --%-*s %s" %
(max_opt, opt_names, text[0]))
else:
lines.append(" --%-*s" % opt_names)
for l in text[1:]:
lines.append(big_indent + l)
return lines
def print_help(self, header=None, file=None):
if file is None:
file = sys.stdout
for line in self.generate_help(header):
file.write(line + "\n")
def fancy_getopt(options, negative_opt, object, args):
parser = FancyGetopt(options)
parser.set_negative_aliases(negative_opt)
return parser.getopt(args, object)
WS_TRANS = {ord(_wschar) : ' ' for _wschar in string.whitespace}
def wrap_text(text, width):
"""wrap_text(text : string, width : int) -> [string]
Split 'text' into multiple lines of no more than 'width' characters
each, and return the list of strings that results.
"""
if text is None:
return []
if len(text) <= width:
return [text]
text = text.expandtabs()
text = text.translate(WS_TRANS)
chunks = re.split(r'( +|-+)', text)
chunks = [ch for ch in chunks if ch] # ' - ' results in empty strings
lines = []
while chunks:
cur_line = [] # list of chunks (to-be-joined)
cur_len = 0 # length of current line
while chunks:
l = len(chunks[0])
if cur_len + l <= width: # can squeeze (at least) this chunk in
cur_line.append(chunks[0])
del chunks[0]
cur_len = cur_len + l
else: # this line is full
# drop last chunk if all space
if cur_line and cur_line[-1][0] == ' ':
del cur_line[-1]
break
if chunks: # any chunks left to process?
# if the current line is still empty, then we had a single
# chunk that's too big too fit on a line -- so we break
# down and break it up at the line width
if cur_len == 0:
cur_line.append(chunks[0][0:width])
chunks[0] = chunks[0][width:]
# all-whitespace chunks at the end of a line can be discarded
# (and we know from the re.split above that if a chunk has
# *any* whitespace, it is *all* whitespace)
if chunks[0][0] == ' ':
del chunks[0]
# and store this line in the list-of-all-lines -- as a single
# string, of course!
lines.append(''.join(cur_line))
return lines
def translate_longopt(opt):
"""Convert a long option name to a valid Python identifier by
changing "-" to "_".
"""
return opt.translate(longopt_xlate)
class OptionDummy:
"""Dummy class just used as a place to hold command-line option
values as instance attributes."""
def __init__(self, options=[]):
"""Create a new OptionDummy instance. The attributes listed in
'options' will be initialized to None."""
for opt in options:
setattr(self, opt, None)
if __name__ == "__main__":
text = """\
Tra-la-la, supercalifragilisticexpialidocious.
How *do* you spell that odd word, anyways?
(Someone ask Mary -- she'll know [or she'll
say, "How should I know?"].)"""
for w in (10, 20, 30, 40):
print("width: %d" % w)
print("\n".join(wrap_text(text, w)))
print()
PK ! / archive_util.pynu [ """distutils.archive_util
Utility functions for creating archive files (tarballs, zip files,
that sort of thing)."""
import os
from warnings import warn
import sys
try:
import zipfile
except ImportError:
zipfile = None
from distutils.errors import DistutilsExecError
from distutils.spawn import spawn
from distutils.dir_util import mkpath
from distutils import log
def make_tarball(base_name, base_dir, compress="gzip", verbose=0, dry_run=0):
"""Create a (possibly compressed) tar file from all the files under
'base_dir'.
'compress' must be "gzip" (the default), "compress", "bzip2", or None.
Both "tar" and the compression utility named by 'compress' must be on
the default program search path, so this is probably Unix-specific.
The output tar file will be named 'base_dir' + ".tar", possibly plus
the appropriate compression extension (".gz", ".bz2" or ".Z").
Returns the output filename.
"""
tar_compression = {'gzip': 'gz', 'bzip2': 'bz2', None: '', 'compress': ''}
compress_ext = {'gzip': '.gz', 'bzip2': '.bz2', 'compress': '.Z'}
# flags for compression program, each element of list will be an argument
if compress is not None and compress not in compress_ext.keys():
raise ValueError(
"bad value for 'compress': must be None, 'gzip', 'bzip2' "
"or 'compress'")
archive_name = base_name + '.tar'
if compress != 'compress':
archive_name += compress_ext.get(compress, '')
mkpath(os.path.dirname(archive_name), dry_run=dry_run)
# creating the tarball
import tarfile # late import so Python build itself doesn't break
log.info('Creating tar archive')
if not dry_run:
tar = tarfile.open(archive_name, 'w|%s' % tar_compression[compress])
try:
tar.add(base_dir)
finally:
tar.close()
# compression using `compress`
if compress == 'compress':
warn("'compress' will be deprecated.", PendingDeprecationWarning)
# the option varies depending on the platform
compressed_name = archive_name + compress_ext[compress]
if sys.platform == 'win32':
cmd = [compress, archive_name, compressed_name]
else:
cmd = [compress, '-f', archive_name]
spawn(cmd, dry_run=dry_run)
return compressed_name
return archive_name
def make_zipfile(base_name, base_dir, verbose=0, dry_run=0):
"""Create a zip file from all the files under 'base_dir'.
The output zip file will be named 'base_name' + ".zip". Uses either the
"zipfile" Python module (if available) or the InfoZIP "zip" utility
(if installed and found on the default search path). If neither tool is
available, raises DistutilsExecError. Returns the name of the output zip
file.
"""
zip_filename = base_name + ".zip"
mkpath(os.path.dirname(zip_filename), dry_run=dry_run)
# If zipfile module is not available, try spawning an external
# 'zip' command.
if zipfile is None:
if verbose:
zipoptions = "-r"
else:
zipoptions = "-rq"
try:
spawn(["zip", zipoptions, zip_filename, base_dir],
dry_run=dry_run)
except DistutilsExecError:
# XXX really should distinguish between "couldn't find
# external 'zip' command" and "zip failed".
raise DistutilsExecError(("unable to create zip file '%s': "
"could neither import the 'zipfile' module nor "
"find a standalone zip utility") % zip_filename)
else:
log.info("creating '%s' and adding '%s' to it",
zip_filename, base_dir)
if not dry_run:
try:
zip = zipfile.ZipFile(zip_filename, "w",
compression=zipfile.ZIP_DEFLATED)
except RuntimeError:
zip = zipfile.ZipFile(zip_filename, "w",
compression=zipfile.ZIP_STORED)
for dirpath, dirnames, filenames in os.walk(base_dir):
for name in filenames:
path = os.path.normpath(os.path.join(dirpath, name))
if os.path.isfile(path):
zip.write(path, path)
log.info("adding '%s'" % path)
zip.close()
return zip_filename
ARCHIVE_FORMATS = {
'gztar': (make_tarball, [('compress', 'gzip')], "gzip'ed tar-file"),
'bztar': (make_tarball, [('compress', 'bzip2')], "bzip2'ed tar-file"),
'ztar': (make_tarball, [('compress', 'compress')], "compressed tar file"),
'tar': (make_tarball, [('compress', None)], "uncompressed tar file"),
'zip': (make_zipfile, [],"ZIP file")
}
def check_archive_formats(formats):
"""Returns the first format from the 'format' list that is unknown.
If all formats are known, returns None
"""
for format in formats:
if format not in ARCHIVE_FORMATS:
return format
return None
def make_archive(base_name, format, root_dir=None, base_dir=None, verbose=0,
dry_run=0):
"""Create an archive file (eg. zip or tar).
'base_name' is the name of the file to create, minus any format-specific
extension; 'format' is the archive format: one of "zip", "tar", "ztar",
or "gztar".
'root_dir' is a directory that will be the root directory of the
archive; ie. we typically chdir into 'root_dir' before creating the
archive. 'base_dir' is the directory where we start archiving from;
ie. 'base_dir' will be the common prefix of all files and
directories in the archive. 'root_dir' and 'base_dir' both default
to the current directory. Returns the name of the archive file.
"""
save_cwd = os.getcwd()
if root_dir is not None:
log.debug("changing into '%s'", root_dir)
base_name = os.path.abspath(base_name)
if not dry_run:
os.chdir(root_dir)
if base_dir is None:
base_dir = os.curdir
kwargs = {'dry_run': dry_run}
try:
format_info = ARCHIVE_FORMATS[format]
except KeyError:
raise ValueError("unknown archive format '%s'" % format)
func = format_info[0]
for arg, val in format_info[1]:
kwargs[arg] = val
try:
filename = func(base_name, base_dir, **kwargs)
finally:
if root_dir is not None:
log.debug("changing back to '%s'", save_cwd)
os.chdir(save_cwd)
return filename
PK ! (> dist.pynu [ """distutils.dist
Provides the Distribution class, which represents the module distribution
being built/installed/distributed.
"""
import sys, os, re
from email import message_from_file
try:
import warnings
except ImportError:
warnings = None
from distutils.errors import *
from distutils.fancy_getopt import FancyGetopt, translate_longopt
from distutils.util import check_environ, strtobool, rfc822_escape
from distutils import log
from distutils.debug import DEBUG
# Regex to define acceptable Distutils command names. This is not *quite*
# the same as a Python NAME -- I don't allow leading underscores. The fact
# that they're very similar is no coincidence; the default naming scheme is
# to look for a Python module named after the command.
command_re = re.compile (r'^[a-zA-Z]([a-zA-Z0-9_]*)$')
class Distribution:
"""The core of the Distutils. Most of the work hiding behind 'setup'
is really done within a Distribution instance, which farms the work out
to the Distutils commands specified on the command line.
Setup scripts will almost never instantiate Distribution directly,
unless the 'setup()' function is totally inadequate to their needs.
However, it is conceivable that a setup script might wish to subclass
Distribution for some specialized purpose, and then pass the subclass
to 'setup()' as the 'distclass' keyword argument. If so, it is
necessary to respect the expectations that 'setup' has of Distribution.
See the code for 'setup()', in core.py, for details.
"""
# 'global_options' describes the command-line options that may be
# supplied to the setup script prior to any actual commands.
# Eg. "./setup.py -n" or "./setup.py --quiet" both take advantage of
# these global options. This list should be kept to a bare minimum,
# since every global option is also valid as a command option -- and we
# don't want to pollute the commands with too many options that they
# have minimal control over.
# The fourth entry for verbose means that it can be repeated.
global_options = [('verbose', 'v', "run verbosely (default)", 1),
('quiet', 'q', "run quietly (turns verbosity off)"),
('dry-run', 'n', "don't actually do anything"),
('help', 'h', "show detailed help message"),
]
# 'common_usage' is a short (2-3 line) string describing the common
# usage of the setup script.
common_usage = """\
Common commands: (see '--help-commands' for more)
setup.py build will build the package underneath 'build/'
setup.py install will install the package
"""
# options that are not propagated to the commands
display_options = [
('help-commands', None,
"list all available commands"),
('name', None,
"print package name"),
('version', 'V',
"print package version"),
('fullname', None,
"print -"),
('author', None,
"print the author's name"),
('author-email', None,
"print the author's email address"),
('maintainer', None,
"print the maintainer's name"),
('maintainer-email', None,
"print the maintainer's email address"),
('contact', None,
"print the maintainer's name if known, else the author's"),
('contact-email', None,
"print the maintainer's email address if known, else the author's"),
('url', None,
"print the URL for this package"),
('license', None,
"print the license of the package"),
('licence', None,
"alias for --license"),
('description', None,
"print the package description"),
('long-description', None,
"print the long package description"),
('platforms', None,
"print the list of platforms"),
('classifiers', None,
"print the list of classifiers"),
('keywords', None,
"print the list of keywords"),
('provides', None,
"print the list of packages/modules provided"),
('requires', None,
"print the list of packages/modules required"),
('obsoletes', None,
"print the list of packages/modules made obsolete")
]
display_option_names = [translate_longopt(x[0]) for x in display_options]
# negative options are options that exclude other options
negative_opt = {'quiet': 'verbose'}
# -- Creation/initialization methods -------------------------------
def __init__ (self, attrs=None):
"""Construct a new Distribution instance: initialize all the
attributes of a Distribution, and then use 'attrs' (a dictionary
mapping attribute names to values) to assign some of those
attributes their "real" values. (Any attributes not mentioned in
'attrs' will be assigned to some null value: 0, None, an empty list
or dictionary, etc.) Most importantly, initialize the
'command_obj' attribute to the empty dictionary; this will be
filled in with real command objects by 'parse_command_line()'.
"""
# Default values for our command-line options
self.verbose = 1
self.dry_run = 0
self.help = 0
for attr in self.display_option_names:
setattr(self, attr, 0)
# Store the distribution meta-data (name, version, author, and so
# forth) in a separate object -- we're getting to have enough
# information here (and enough command-line options) that it's
# worth it. Also delegate 'get_XXX()' methods to the 'metadata'
# object in a sneaky and underhanded (but efficient!) way.
self.metadata = DistributionMetadata()
for basename in self.metadata._METHOD_BASENAMES:
method_name = "get_" + basename
setattr(self, method_name, getattr(self.metadata, method_name))
# 'cmdclass' maps command names to class objects, so we
# can 1) quickly figure out which class to instantiate when
# we need to create a new command object, and 2) have a way
# for the setup script to override command classes
self.cmdclass = {}
# 'command_packages' is a list of packages in which commands
# are searched for. The factory for command 'foo' is expected
# to be named 'foo' in the module 'foo' in one of the packages
# named here. This list is searched from the left; an error
# is raised if no named package provides the command being
# searched for. (Always access using get_command_packages().)
self.command_packages = None
# 'script_name' and 'script_args' are usually set to sys.argv[0]
# and sys.argv[1:], but they can be overridden when the caller is
# not necessarily a setup script run from the command-line.
self.script_name = None
self.script_args = None
# 'command_options' is where we store command options between
# parsing them (from config files, the command-line, etc.) and when
# they are actually needed -- ie. when the command in question is
# instantiated. It is a dictionary of dictionaries of 2-tuples:
# command_options = { command_name : { option : (source, value) } }
self.command_options = {}
# 'dist_files' is the list of (command, pyversion, file) that
# have been created by any dist commands run so far. This is
# filled regardless of whether the run is dry or not. pyversion
# gives sysconfig.get_python_version() if the dist file is
# specific to a Python version, 'any' if it is good for all
# Python versions on the target platform, and '' for a source
# file. pyversion should not be used to specify minimum or
# maximum required Python versions; use the metainfo for that
# instead.
self.dist_files = []
# These options are really the business of various commands, rather
# than of the Distribution itself. We provide aliases for them in
# Distribution as a convenience to the developer.
self.packages = None
self.package_data = {}
self.package_dir = None
self.py_modules = None
self.libraries = None
self.headers = None
self.ext_modules = None
self.ext_package = None
self.include_dirs = None
self.extra_path = None
self.scripts = None
self.data_files = None
self.password = ''
# And now initialize bookkeeping stuff that can't be supplied by
# the caller at all. 'command_obj' maps command names to
# Command instances -- that's how we enforce that every command
# class is a singleton.
self.command_obj = {}
# 'have_run' maps command names to boolean values; it keeps track
# of whether we have actually run a particular command, to make it
# cheap to "run" a command whenever we think we might need to -- if
# it's already been done, no need for expensive filesystem
# operations, we just check the 'have_run' dictionary and carry on.
# It's only safe to query 'have_run' for a command class that has
# been instantiated -- a false value will be inserted when the
# command object is created, and replaced with a true value when
# the command is successfully run. Thus it's probably best to use
# '.get()' rather than a straight lookup.
self.have_run = {}
# Now we'll use the attrs dictionary (ultimately, keyword args from
# the setup script) to possibly override any or all of these
# distribution options.
if attrs:
# Pull out the set of command options and work on them
# specifically. Note that this order guarantees that aliased
# command options will override any supplied redundantly
# through the general options dictionary.
options = attrs.get('options')
if options is not None:
del attrs['options']
for (command, cmd_options) in options.items():
opt_dict = self.get_option_dict(command)
for (opt, val) in cmd_options.items():
opt_dict[opt] = ("setup script", val)
if 'licence' in attrs:
attrs['license'] = attrs['licence']
del attrs['licence']
msg = "'licence' distribution option is deprecated; use 'license'"
if warnings is not None:
warnings.warn(msg)
else:
sys.stderr.write(msg + "\n")
# Now work on the rest of the attributes. Any attribute that's
# not already defined is invalid!
for (key, val) in attrs.items():
if hasattr(self.metadata, "set_" + key):
getattr(self.metadata, "set_" + key)(val)
elif hasattr(self.metadata, key):
setattr(self.metadata, key, val)
elif hasattr(self, key):
setattr(self, key, val)
else:
msg = "Unknown distribution option: %s" % repr(key)
if warnings is not None:
warnings.warn(msg)
else:
sys.stderr.write(msg + "\n")
self.finalize_options()
def get_option_dict(self, command):
"""Get the option dictionary for a given command. If that
command's option dictionary hasn't been created yet, then create it
and return the new dictionary; otherwise, return the existing
option dictionary.
"""
dict = self.command_options.get(command)
if dict is None:
dict = self.command_options[command] = {}
return dict
def dump_option_dicts(self, header=None, commands=None, indent=""):
from pprint import pformat
if commands is None: # dump all command option dicts
commands = sorted(self.command_options.keys())
if header is not None:
self.announce(indent + header)
indent = indent + " "
if not commands:
self.announce(indent + "no commands known yet")
return
for cmd_name in commands:
opt_dict = self.command_options.get(cmd_name)
if opt_dict is None:
self.announce(indent +
"no option dict for '%s' command" % cmd_name)
else:
self.announce(indent +
"option dict for '%s' command:" % cmd_name)
out = pformat(opt_dict)
for line in out.split('\n'):
self.announce(indent + " " + line)
# -- Config file finding/parsing methods ---------------------------
def find_config_files(self):
"""Find as many configuration files as should be processed for this
platform, and return a list of filenames in the order in which they
should be parsed. The filenames returned are guaranteed to exist
(modulo nasty race conditions).
There are three possible config files: distutils.cfg in the
Distutils installation directory (ie. where the top-level
Distutils __inst__.py file lives), a file in the user's home
directory named .pydistutils.cfg on Unix and pydistutils.cfg
on Windows/Mac, and setup.cfg in the current directory.
"""
files = []
check_environ()
# Where to look for the system-wide Distutils config file
sys_dir = os.path.dirname(sys.modules['distutils'].__file__)
# Look for the system config file
sys_file = os.path.join(sys_dir, "distutils.cfg")
if os.path.isfile(sys_file):
files.append(sys_file)
# What to call the per-user config file
if os.name == 'posix':
user_filename = ".pydistutils.cfg"
else:
user_filename = "pydistutils.cfg"
# And look for the user config file
user_file = os.path.join(os.path.expanduser('~'), user_filename)
if os.path.isfile(user_file):
files.append(user_file)
# All platforms support local setup.cfg
local_file = "setup.cfg"
if os.path.isfile(local_file):
files.append(local_file)
return files
def parse_config_files(self, filenames=None):
from configparser import ConfigParser
# Ignore install directory options if we have a venv
if sys.prefix != sys.base_prefix:
ignore_options = [
'install-base', 'install-platbase', 'install-lib',
'install-platlib', 'install-purelib', 'install-headers',
'install-scripts', 'install-data', 'prefix', 'exec-prefix',
'home', 'user', 'root']
else:
ignore_options = []
ignore_options = frozenset(ignore_options)
if filenames is None:
filenames = self.find_config_files()
if DEBUG:
self.announce("Distribution.parse_config_files():")
parser = ConfigParser()
for filename in filenames:
if DEBUG:
self.announce(" reading %s" % filename)
parser.read(filename)
for section in parser.sections():
options = parser.options(section)
opt_dict = self.get_option_dict(section)
for opt in options:
if opt != '__name__' and opt not in ignore_options:
val = parser.get(section,opt)
opt = opt.replace('-', '_')
opt_dict[opt] = (filename, val)
# Make the ConfigParser forget everything (so we retain
# the original filenames that options come from)
parser.__init__()
# If there was a "global" section in the config file, use it
# to set Distribution options.
if 'global' in self.command_options:
for (opt, (src, val)) in self.command_options['global'].items():
alias = self.negative_opt.get(opt)
try:
if alias:
setattr(self, alias, not strtobool(val))
elif opt in ('verbose', 'dry_run'): # ugh!
setattr(self, opt, strtobool(val))
else:
setattr(self, opt, val)
except ValueError as msg:
raise DistutilsOptionError(msg)
# -- Command-line parsing methods ----------------------------------
def parse_command_line(self):
"""Parse the setup script's command line, taken from the
'script_args' instance attribute (which defaults to 'sys.argv[1:]'
-- see 'setup()' in core.py). This list is first processed for
"global options" -- options that set attributes of the Distribution
instance. Then, it is alternately scanned for Distutils commands
and options for that command. Each new command terminates the
options for the previous command. The allowed options for a
command are determined by the 'user_options' attribute of the
command class -- thus, we have to be able to load command classes
in order to parse the command line. Any error in that 'options'
attribute raises DistutilsGetoptError; any error on the
command-line raises DistutilsArgError. If no Distutils commands
were found on the command line, raises DistutilsArgError. Return
true if command-line was successfully parsed and we should carry
on with executing commands; false if no errors but we shouldn't
execute commands (currently, this only happens if user asks for
help).
"""
#
# We now have enough information to show the Macintosh dialog
# that allows the user to interactively specify the "command line".
#
toplevel_options = self._get_toplevel_options()
# We have to parse the command line a bit at a time -- global
# options, then the first command, then its options, and so on --
# because each command will be handled by a different class, and
# the options that are valid for a particular class aren't known
# until we have loaded the command class, which doesn't happen
# until we know what the command is.
self.commands = []
parser = FancyGetopt(toplevel_options + self.display_options)
parser.set_negative_aliases(self.negative_opt)
parser.set_aliases({'licence': 'license'})
args = parser.getopt(args=self.script_args, object=self)
option_order = parser.get_option_order()
log.set_verbosity(self.verbose)
# for display options we return immediately
if self.handle_display_options(option_order):
return
while args:
args = self._parse_command_opts(parser, args)
if args is None: # user asked for help (and got it)
return
# Handle the cases of --help as a "global" option, ie.
# "setup.py --help" and "setup.py --help command ...". For the
# former, we show global options (--verbose, --dry-run, etc.)
# and display-only options (--name, --version, etc.); for the
# latter, we omit the display-only options and show help for
# each command listed on the command line.
if self.help:
self._show_help(parser,
display_options=len(self.commands) == 0,
commands=self.commands)
return
# Oops, no commands found -- an end-user error
if not self.commands:
raise DistutilsArgError("no commands supplied")
# All is well: return true
return True
def _get_toplevel_options(self):
"""Return the non-display options recognized at the top level.
This includes options that are recognized *only* at the top
level as well as options recognized for commands.
"""
return self.global_options + [
("command-packages=", None,
"list of packages that provide distutils commands"),
]
def _parse_command_opts(self, parser, args):
"""Parse the command-line options for a single command.
'parser' must be a FancyGetopt instance; 'args' must be the list
of arguments, starting with the current command (whose options
we are about to parse). Returns a new version of 'args' with
the next command at the front of the list; will be the empty
list if there are no more commands on the command line. Returns
None if the user asked for help on this command.
"""
# late import because of mutual dependence between these modules
from distutils.cmd import Command
# Pull the current command from the head of the command line
command = args[0]
if not command_re.match(command):
raise SystemExit("invalid command name '%s'" % command)
self.commands.append(command)
# Dig up the command class that implements this command, so we
# 1) know that it's a valid command, and 2) know which options
# it takes.
try:
cmd_class = self.get_command_class(command)
except DistutilsModuleError as msg:
raise DistutilsArgError(msg)
# Require that the command class be derived from Command -- want
# to be sure that the basic "command" interface is implemented.
if not issubclass(cmd_class, Command):
raise DistutilsClassError(
"command class %s must subclass Command" % cmd_class)
# Also make sure that the command object provides a list of its
# known options.
if not (hasattr(cmd_class, 'user_options') and
isinstance(cmd_class.user_options, list)):
raise DistutilsClassError(("command class %s must provide " +
"'user_options' attribute (a list of tuples)") % \
cmd_class)
# If the command class has a list of negative alias options,
# merge it in with the global negative aliases.
negative_opt = self.negative_opt
if hasattr(cmd_class, 'negative_opt'):
negative_opt = negative_opt.copy()
negative_opt.update(cmd_class.negative_opt)
# Check for help_options in command class. They have a different
# format (tuple of four) so we need to preprocess them here.
if (hasattr(cmd_class, 'help_options') and
isinstance(cmd_class.help_options, list)):
help_options = fix_help_options(cmd_class.help_options)
else:
help_options = []
# All commands support the global options too, just by adding
# in 'global_options'.
parser.set_option_table(self.global_options +
cmd_class.user_options +
help_options)
parser.set_negative_aliases(negative_opt)
(args, opts) = parser.getopt(args[1:])
if hasattr(opts, 'help') and opts.help:
self._show_help(parser, display_options=0, commands=[cmd_class])
return
if (hasattr(cmd_class, 'help_options') and
isinstance(cmd_class.help_options, list)):
help_option_found=0
for (help_option, short, desc, func) in cmd_class.help_options:
if hasattr(opts, parser.get_attr_name(help_option)):
help_option_found=1
if callable(func):
func()
else:
raise DistutilsClassError(
"invalid help function %r for help option '%s': "
"must be a callable object (function, etc.)"
% (func, help_option))
if help_option_found:
return
# Put the options from the command-line into their official
# holding pen, the 'command_options' dictionary.
opt_dict = self.get_option_dict(command)
for (name, value) in vars(opts).items():
opt_dict[name] = ("command line", value)
return args
def finalize_options(self):
"""Set final values for all the options on the Distribution
instance, analogous to the .finalize_options() method of Command
objects.
"""
for attr in ('keywords', 'platforms'):
value = getattr(self.metadata, attr)
if value is None:
continue
if isinstance(value, str):
value = [elm.strip() for elm in value.split(',')]
setattr(self.metadata, attr, value)
def _show_help(self, parser, global_options=1, display_options=1,
commands=[]):
"""Show help for the setup script command-line in the form of
several lists of command-line options. 'parser' should be a
FancyGetopt instance; do not expect it to be returned in the
same state, as its option table will be reset to make it
generate the correct help text.
If 'global_options' is true, lists the global options:
--verbose, --dry-run, etc. If 'display_options' is true, lists
the "display-only" options: --name, --version, etc. Finally,
lists per-command help for every command name or command class
in 'commands'.
"""
# late import because of mutual dependence between these modules
from distutils.core import gen_usage
from distutils.cmd import Command
if global_options:
if display_options:
options = self._get_toplevel_options()
else:
options = self.global_options
parser.set_option_table(options)
parser.print_help(self.common_usage + "\nGlobal options:")
print('')
if display_options:
parser.set_option_table(self.display_options)
parser.print_help(
"Information display options (just display " +
"information, ignore any commands)")
print('')
for command in self.commands:
if isinstance(command, type) and issubclass(command, Command):
klass = command
else:
klass = self.get_command_class(command)
if (hasattr(klass, 'help_options') and
isinstance(klass.help_options, list)):
parser.set_option_table(klass.user_options +
fix_help_options(klass.help_options))
else:
parser.set_option_table(klass.user_options)
parser.print_help("Options for '%s' command:" % klass.__name__)
print('')
print(gen_usage(self.script_name))
def handle_display_options(self, option_order):
"""If there were any non-global "display-only" options
(--help-commands or the metadata display options) on the command
line, display the requested info and return true; else return
false.
"""
from distutils.core import gen_usage
# User just wants a list of commands -- we'll print it out and stop
# processing now (ie. if they ran "setup --help-commands foo bar",
# we ignore "foo bar").
if self.help_commands:
self.print_commands()
print('')
print(gen_usage(self.script_name))
return 1
# If user supplied any of the "display metadata" options, then
# display that metadata in the order in which the user supplied the
# metadata options.
any_display_options = 0
is_display_option = {}
for option in self.display_options:
is_display_option[option[0]] = 1
for (opt, val) in option_order:
if val and is_display_option.get(opt):
opt = translate_longopt(opt)
value = getattr(self.metadata, "get_"+opt)()
if opt in ['keywords', 'platforms']:
print(','.join(value))
elif opt in ('classifiers', 'provides', 'requires',
'obsoletes'):
print('\n'.join(value))
else:
print(value)
any_display_options = 1
return any_display_options
def print_command_list(self, commands, header, max_length):
"""Print a subset of the list of all commands -- used by
'print_commands()'.
"""
print(header + ":")
for cmd in commands:
klass = self.cmdclass.get(cmd)
if not klass:
klass = self.get_command_class(cmd)
try:
description = klass.description
except AttributeError:
description = "(no description available)"
print(" %-*s %s" % (max_length, cmd, description))
def print_commands(self):
"""Print out a help message listing all available commands with a
description of each. The list is divided into "standard commands"
(listed in distutils.command.__all__) and "extra commands"
(mentioned in self.cmdclass, but not a standard command). The
descriptions come from the command class attribute
'description'.
"""
import distutils.command
std_commands = distutils.command.__all__
is_std = {}
for cmd in std_commands:
is_std[cmd] = 1
extra_commands = []
for cmd in self.cmdclass.keys():
if not is_std.get(cmd):
extra_commands.append(cmd)
max_length = 0
for cmd in (std_commands + extra_commands):
if len(cmd) > max_length:
max_length = len(cmd)
self.print_command_list(std_commands,
"Standard commands",
max_length)
if extra_commands:
print()
self.print_command_list(extra_commands,
"Extra commands",
max_length)
def get_command_list(self):
"""Get a list of (command, description) tuples.
The list is divided into "standard commands" (listed in
distutils.command.__all__) and "extra commands" (mentioned in
self.cmdclass, but not a standard command). The descriptions come
from the command class attribute 'description'.
"""
# Currently this is only used on Mac OS, for the Mac-only GUI
# Distutils interface (by Jack Jansen)
import distutils.command
std_commands = distutils.command.__all__
is_std = {}
for cmd in std_commands:
is_std[cmd] = 1
extra_commands = []
for cmd in self.cmdclass.keys():
if not is_std.get(cmd):
extra_commands.append(cmd)
rv = []
for cmd in (std_commands + extra_commands):
klass = self.cmdclass.get(cmd)
if not klass:
klass = self.get_command_class(cmd)
try:
description = klass.description
except AttributeError:
description = "(no description available)"
rv.append((cmd, description))
return rv
# -- Command class/object methods ----------------------------------
def get_command_packages(self):
"""Return a list of packages from which commands are loaded."""
pkgs = self.command_packages
if not isinstance(pkgs, list):
if pkgs is None:
pkgs = ''
pkgs = [pkg.strip() for pkg in pkgs.split(',') if pkg != '']
if "distutils.command" not in pkgs:
pkgs.insert(0, "distutils.command")
self.command_packages = pkgs
return pkgs
def get_command_class(self, command):
"""Return the class that implements the Distutils command named by
'command'. First we check the 'cmdclass' dictionary; if the
command is mentioned there, we fetch the class object from the
dictionary and return it. Otherwise we load the command module
("distutils.command." + command) and fetch the command class from
the module. The loaded class is also stored in 'cmdclass'
to speed future calls to 'get_command_class()'.
Raises DistutilsModuleError if the expected module could not be
found, or if that module does not define the expected class.
"""
klass = self.cmdclass.get(command)
if klass:
return klass
for pkgname in self.get_command_packages():
module_name = "%s.%s" % (pkgname, command)
klass_name = command
try:
__import__ (module_name)
module = sys.modules[module_name]
except ImportError:
continue
try:
klass = getattr(module, klass_name)
except AttributeError:
raise DistutilsModuleError(
"invalid command '%s' (no class '%s' in module '%s')"
% (command, klass_name, module_name))
self.cmdclass[command] = klass
return klass
raise DistutilsModuleError("invalid command '%s'" % command)
def get_command_obj(self, command, create=1):
"""Return the command object for 'command'. Normally this object
is cached on a previous call to 'get_command_obj()'; if no command
object for 'command' is in the cache, then we either create and
return it (if 'create' is true) or return None.
"""
cmd_obj = self.command_obj.get(command)
if not cmd_obj and create:
if DEBUG:
self.announce("Distribution.get_command_obj(): " \
"creating '%s' command object" % command)
klass = self.get_command_class(command)
cmd_obj = self.command_obj[command] = klass(self)
self.have_run[command] = 0
# Set any options that were supplied in config files
# or on the command line. (NB. support for error
# reporting is lame here: any errors aren't reported
# until 'finalize_options()' is called, which means
# we won't report the source of the error.)
options = self.command_options.get(command)
if options:
self._set_command_options(cmd_obj, options)
return cmd_obj
def _set_command_options(self, command_obj, option_dict=None):
"""Set the options for 'command_obj' from 'option_dict'. Basically
this means copying elements of a dictionary ('option_dict') to
attributes of an instance ('command').
'command_obj' must be a Command instance. If 'option_dict' is not
supplied, uses the standard option dictionary for this command
(from 'self.command_options').
"""
command_name = command_obj.get_command_name()
if option_dict is None:
option_dict = self.get_option_dict(command_name)
if DEBUG:
self.announce(" setting options for '%s' command:" % command_name)
for (option, (source, value)) in option_dict.items():
if DEBUG:
self.announce(" %s = %s (from %s)" % (option, value,
source))
try:
bool_opts = [translate_longopt(o)
for o in command_obj.boolean_options]
except AttributeError:
bool_opts = []
try:
neg_opt = command_obj.negative_opt
except AttributeError:
neg_opt = {}
try:
is_string = isinstance(value, str)
if option in neg_opt and is_string:
setattr(command_obj, neg_opt[option], not strtobool(value))
elif option in bool_opts and is_string:
setattr(command_obj, option, strtobool(value))
elif hasattr(command_obj, option):
setattr(command_obj, option, value)
else:
raise DistutilsOptionError(
"error in %s: command '%s' has no such option '%s'"
% (source, command_name, option))
except ValueError as msg:
raise DistutilsOptionError(msg)
def reinitialize_command(self, command, reinit_subcommands=0):
"""Reinitializes a command to the state it was in when first
returned by 'get_command_obj()': ie., initialized but not yet
finalized. This provides the opportunity to sneak option
values in programmatically, overriding or supplementing
user-supplied values from the config files and command line.
You'll have to re-finalize the command object (by calling
'finalize_options()' or 'ensure_finalized()') before using it for
real.
'command' should be a command name (string) or command object. If
'reinit_subcommands' is true, also reinitializes the command's
sub-commands, as declared by the 'sub_commands' class attribute (if
it has one). See the "install" command for an example. Only
reinitializes the sub-commands that actually matter, ie. those
whose test predicates return true.
Returns the reinitialized command object.
"""
from distutils.cmd import Command
if not isinstance(command, Command):
command_name = command
command = self.get_command_obj(command_name)
else:
command_name = command.get_command_name()
if not command.finalized:
return command
command.initialize_options()
command.finalized = 0
self.have_run[command_name] = 0
self._set_command_options(command)
if reinit_subcommands:
for sub in command.get_sub_commands():
self.reinitialize_command(sub, reinit_subcommands)
return command
# -- Methods that operate on the Distribution ----------------------
def announce(self, msg, level=log.INFO):
log.log(level, msg)
def run_commands(self):
"""Run each command that was seen on the setup script command line.
Uses the list of commands found and cache of command objects
created by 'get_command_obj()'.
"""
for cmd in self.commands:
self.run_command(cmd)
# -- Methods that operate on its Commands --------------------------
def run_command(self, command):
"""Do whatever it takes to run a command (including nothing at all,
if the command has already been run). Specifically: if we have
already created and run the command named by 'command', return
silently without doing anything. If the command named by 'command'
doesn't even have a command object yet, create one. Then invoke
'run()' on that command object (or an existing one).
"""
# Already been here, done that? then return silently.
if self.have_run.get(command):
return
log.info("running %s", command)
cmd_obj = self.get_command_obj(command)
cmd_obj.ensure_finalized()
cmd_obj.run()
self.have_run[command] = 1
# -- Distribution query methods ------------------------------------
def has_pure_modules(self):
return len(self.packages or self.py_modules or []) > 0
def has_ext_modules(self):
return self.ext_modules and len(self.ext_modules) > 0
def has_c_libraries(self):
return self.libraries and len(self.libraries) > 0
def has_modules(self):
return self.has_pure_modules() or self.has_ext_modules()
def has_headers(self):
return self.headers and len(self.headers) > 0
def has_scripts(self):
return self.scripts and len(self.scripts) > 0
def has_data_files(self):
return self.data_files and len(self.data_files) > 0
def is_pure(self):
return (self.has_pure_modules() and
not self.has_ext_modules() and
not self.has_c_libraries())
# -- Metadata query methods ----------------------------------------
# If you're looking for 'get_name()', 'get_version()', and so forth,
# they are defined in a sneaky way: the constructor binds self.get_XXX
# to self.metadata.get_XXX. The actual code is in the
# DistributionMetadata class, below.
class DistributionMetadata:
"""Dummy class to hold the distribution meta-data: name, version,
author, and so forth.
"""
_METHOD_BASENAMES = ("name", "version", "author", "author_email",
"maintainer", "maintainer_email", "url",
"license", "description", "long_description",
"keywords", "platforms", "fullname", "contact",
"contact_email", "license", "classifiers",
"download_url",
# PEP 314
"provides", "requires", "obsoletes",
)
def __init__(self, path=None):
if path is not None:
self.read_pkg_file(open(path))
else:
self.name = None
self.version = None
self.author = None
self.author_email = None
self.maintainer = None
self.maintainer_email = None
self.url = None
self.license = None
self.description = None
self.long_description = None
self.keywords = None
self.platforms = None
self.classifiers = None
self.download_url = None
# PEP 314
self.provides = None
self.requires = None
self.obsoletes = None
def read_pkg_file(self, file):
"""Reads the metadata values from a file object."""
msg = message_from_file(file)
def _read_field(name):
value = msg[name]
if value == 'UNKNOWN':
return None
return value
def _read_list(name):
values = msg.get_all(name, None)
if values == []:
return None
return values
metadata_version = msg['metadata-version']
self.name = _read_field('name')
self.version = _read_field('version')
self.description = _read_field('summary')
# we are filling author only.
self.author = _read_field('author')
self.maintainer = None
self.author_email = _read_field('author-email')
self.maintainer_email = None
self.url = _read_field('home-page')
self.license = _read_field('license')
if 'download-url' in msg:
self.download_url = _read_field('download-url')
else:
self.download_url = None
self.long_description = _read_field('description')
self.description = _read_field('summary')
if 'keywords' in msg:
self.keywords = _read_field('keywords').split(',')
self.platforms = _read_list('platform')
self.classifiers = _read_list('classifier')
# PEP 314 - these fields only exist in 1.1
if metadata_version == '1.1':
self.requires = _read_list('requires')
self.provides = _read_list('provides')
self.obsoletes = _read_list('obsoletes')
else:
self.requires = None
self.provides = None
self.obsoletes = None
def write_pkg_info(self, base_dir):
"""Write the PKG-INFO file into the release tree.
"""
with open(os.path.join(base_dir, 'PKG-INFO'), 'w',
encoding='UTF-8') as pkg_info:
self.write_pkg_file(pkg_info)
def write_pkg_file(self, file):
"""Write the PKG-INFO format data to a file object.
"""
version = '1.0'
if (self.provides or self.requires or self.obsoletes or
self.classifiers or self.download_url):
version = '1.1'
file.write('Metadata-Version: %s\n' % version)
file.write('Name: %s\n' % self.get_name() )
file.write('Version: %s\n' % self.get_version() )
file.write('Summary: %s\n' % self.get_description() )
file.write('Home-page: %s\n' % self.get_url() )
file.write('Author: %s\n' % self.get_contact() )
file.write('Author-email: %s\n' % self.get_contact_email() )
file.write('License: %s\n' % self.get_license() )
if self.download_url:
file.write('Download-URL: %s\n' % self.download_url)
long_desc = rfc822_escape(self.get_long_description())
file.write('Description: %s\n' % long_desc)
keywords = ','.join(self.get_keywords())
if keywords:
file.write('Keywords: %s\n' % keywords )
self._write_list(file, 'Platform', self.get_platforms())
self._write_list(file, 'Classifier', self.get_classifiers())
# PEP 314
self._write_list(file, 'Requires', self.get_requires())
self._write_list(file, 'Provides', self.get_provides())
self._write_list(file, 'Obsoletes', self.get_obsoletes())
def _write_list(self, file, name, values):
for value in values:
file.write('%s: %s\n' % (name, value))
# -- Metadata query methods ----------------------------------------
def get_name(self):
return self.name or "UNKNOWN"
def get_version(self):
return self.version or "0.0.0"
def get_fullname(self):
return "%s-%s" % (self.get_name(), self.get_version())
def get_author(self):
return self.author or "UNKNOWN"
def get_author_email(self):
return self.author_email or "UNKNOWN"
def get_maintainer(self):
return self.maintainer or "UNKNOWN"
def get_maintainer_email(self):
return self.maintainer_email or "UNKNOWN"
def get_contact(self):
return self.maintainer or self.author or "UNKNOWN"
def get_contact_email(self):
return self.maintainer_email or self.author_email or "UNKNOWN"
def get_url(self):
return self.url or "UNKNOWN"
def get_license(self):
return self.license or "UNKNOWN"
get_licence = get_license
def get_description(self):
return self.description or "UNKNOWN"
def get_long_description(self):
return self.long_description or "UNKNOWN"
def get_keywords(self):
return self.keywords or []
def get_platforms(self):
return self.platforms or ["UNKNOWN"]
def get_classifiers(self):
return self.classifiers or []
def get_download_url(self):
return self.download_url or "UNKNOWN"
# PEP 314
def get_requires(self):
return self.requires or []
def set_requires(self, value):
import distutils.versionpredicate
for v in value:
distutils.versionpredicate.VersionPredicate(v)
self.requires = value
def get_provides(self):
return self.provides or []
def set_provides(self, value):
value = [v.strip() for v in value]
for v in value:
import distutils.versionpredicate
distutils.versionpredicate.split_provision(v)
self.provides = value
def get_obsoletes(self):
return self.obsoletes or []
def set_obsoletes(self, value):
import distutils.versionpredicate
for v in value:
distutils.versionpredicate.VersionPredicate(v)
self.obsoletes = value
def fix_help_options(options):
"""Convert a 4-tuple 'help_options' list as found in various command
classes to the 3-tuple form required by FancyGetopt.
"""
new_options = []
for help_tuple in options:
new_options.append(help_tuple[0:3])
return new_options
PK ! 薊_( _( extension.pynu [ """distutils.extension
Provides the Extension class, used to describe C/C++ extension
modules in setup scripts."""
import os
import sys
import warnings
# This class is really only used by the "build_ext" command, so it might
# make sense to put it in distutils.command.build_ext. However, that
# module is already big enough, and I want to make this class a bit more
# complex to simplify some common cases ("foo" module in "foo.c") and do
# better error-checking ("foo.c" actually exists).
#
# Also, putting this in build_ext.py means every setup script would have to
# import that large-ish module (indirectly, through distutils.core) in
# order to do anything.
class Extension:
"""Just a collection of attributes that describes an extension
module and everything needed to build it (hopefully in a portable
way, but there are hooks that let you be as unportable as you need).
Instance attributes:
name : string
the full name of the extension, including any packages -- ie.
*not* a filename or pathname, but Python dotted name
sources : [string]
list of source filenames, relative to the distribution root
(where the setup script lives), in Unix form (slash-separated)
for portability. Source files may be C, C++, SWIG (.i),
platform-specific resource files, or whatever else is recognized
by the "build_ext" command as source for a Python extension.
include_dirs : [string]
list of directories to search for C/C++ header files (in Unix
form for portability)
define_macros : [(name : string, value : string|None)]
list of macros to define; each macro is defined using a 2-tuple,
where 'value' is either the string to define it to or None to
define it without a particular value (equivalent of "#define
FOO" in source or -DFOO on Unix C compiler command line)
undef_macros : [string]
list of macros to undefine explicitly
library_dirs : [string]
list of directories to search for C/C++ libraries at link time
libraries : [string]
list of library names (not filenames or paths) to link against
runtime_library_dirs : [string]
list of directories to search for C/C++ libraries at run time
(for shared extensions, this is when the extension is loaded)
extra_objects : [string]
list of extra files to link with (eg. object files not implied
by 'sources', static library that must be explicitly specified,
binary resource files, etc.)
extra_compile_args : [string]
any extra platform- and compiler-specific information to use
when compiling the source files in 'sources'. For platforms and
compilers where "command line" makes sense, this is typically a
list of command-line arguments, but for other platforms it could
be anything.
extra_link_args : [string]
any extra platform- and compiler-specific information to use
when linking object files together to create the extension (or
to create a new static Python interpreter). Similar
interpretation as for 'extra_compile_args'.
export_symbols : [string]
list of symbols to be exported from a shared extension. Not
used on all platforms, and not generally necessary for Python
extensions, which typically export exactly one symbol: "init" +
extension_name.
swig_opts : [string]
any extra options to pass to SWIG if a source file has the .i
extension.
depends : [string]
list of files that the extension depends on
language : string
extension language (i.e. "c", "c++", "objc"). Will be detected
from the source extensions if not provided.
optional : boolean
specifies that a build failure in the extension should not abort the
build process, but simply not install the failing extension.
"""
# When adding arguments to this constructor, be sure to update
# setup_keywords in core.py.
def __init__(self, name, sources,
include_dirs=None,
define_macros=None,
undef_macros=None,
library_dirs=None,
libraries=None,
runtime_library_dirs=None,
extra_objects=None,
extra_compile_args=None,
extra_link_args=None,
export_symbols=None,
swig_opts = None,
depends=None,
language=None,
optional=None,
**kw # To catch unknown keywords
):
if not isinstance(name, str):
raise AssertionError("'name' must be a string")
if not (isinstance(sources, list) and
all(isinstance(v, str) for v in sources)):
raise AssertionError("'sources' must be a list of strings")
self.name = name
self.sources = sources
self.include_dirs = include_dirs or []
self.define_macros = define_macros or []
self.undef_macros = undef_macros or []
self.library_dirs = library_dirs or []
self.libraries = libraries or []
self.runtime_library_dirs = runtime_library_dirs or []
self.extra_objects = extra_objects or []
self.extra_compile_args = extra_compile_args or []
self.extra_link_args = extra_link_args or []
self.export_symbols = export_symbols or []
self.swig_opts = swig_opts or []
self.depends = depends or []
self.language = language
self.optional = optional
# If there are unknown keyword options, warn about them
if len(kw) > 0:
options = [repr(option) for option in kw]
options = ', '.join(sorted(options))
msg = "Unknown Extension options: %s" % options
warnings.warn(msg)
def read_setup_file(filename):
"""Reads a Setup file and returns Extension instances."""
from distutils.sysconfig import (parse_makefile, expand_makefile_vars,
_variable_rx)
from distutils.text_file import TextFile
from distutils.util import split_quoted
# First pass over the file to gather "VAR = VALUE" assignments.
vars = parse_makefile(filename)
# Second pass to gobble up the real content: lines of the form
# ... [ ...] [ ...] [ ...]
file = TextFile(filename,
strip_comments=1, skip_blanks=1, join_lines=1,
lstrip_ws=1, rstrip_ws=1)
try:
extensions = []
while True:
line = file.readline()
if line is None: # eof
break
if _variable_rx.match(line): # VAR=VALUE, handled in first pass
continue
if line[0] == line[-1] == "*":
file.warn("'%s' lines not handled yet" % line)
continue
line = expand_makefile_vars(line, vars)
words = split_quoted(line)
# NB. this parses a slightly different syntax than the old
# makesetup script: here, there must be exactly one extension per
# line, and it must be the first word of the line. I have no idea
# why the old syntax supported multiple extensions per line, as
# they all wind up being the same.
module = words[0]
ext = Extension(module, [])
append_next_word = None
for word in words[1:]:
if append_next_word is not None:
append_next_word.append(word)
append_next_word = None
continue
suffix = os.path.splitext(word)[1]
switch = word[0:2] ; value = word[2:]
if suffix in (".c", ".cc", ".cpp", ".cxx", ".c++", ".m", ".mm"):
# hmm, should we do something about C vs. C++ sources?
# or leave it up to the CCompiler implementation to
# worry about?
ext.sources.append(word)
elif switch == "-I":
ext.include_dirs.append(value)
elif switch == "-D":
equals = value.find("=")
if equals == -1: # bare "-DFOO" -- no value
ext.define_macros.append((value, None))
else: # "-DFOO=blah"
ext.define_macros.append((value[0:equals],
value[equals+2:]))
elif switch == "-U":
ext.undef_macros.append(value)
elif switch == "-C": # only here 'cause makesetup has it!
ext.extra_compile_args.append(word)
elif switch == "-l":
ext.libraries.append(value)
elif switch == "-L":
ext.library_dirs.append(value)
elif switch == "-R":
ext.runtime_library_dirs.append(value)
elif word == "-rpath":
append_next_word = ext.runtime_library_dirs
elif word == "-Xlinker":
append_next_word = ext.extra_link_args
elif word == "-Xcompiler":
append_next_word = ext.extra_compile_args
elif switch == "-u":
ext.extra_link_args.append(word)
if not value:
append_next_word = ext.extra_link_args
elif suffix in (".a", ".so", ".sl", ".o", ".dylib"):
# NB. a really faithful emulation of makesetup would
# append a .o file to extra_objects only if it
# had a slash in it; otherwise, it would s/.o/.c/
# and append it to sources. Hmmmm.
ext.extra_objects.append(word)
else:
file.warn("unrecognized argument '%s'" % word)
extensions.append(ext)
finally:
file.close()
return extensions
PK ! ,n:Q :Q util.pynu [ """distutils.util
Miscellaneous utility functions -- anything that doesn't fit into
one of the other *util.py modules.
"""
import os
import re
import imp
import sys
import string
from distutils.errors import DistutilsPlatformError
from distutils.dep_util import newer
from distutils.spawn import spawn
from distutils import log
from distutils.errors import DistutilsByteCompileError
def get_platform ():
"""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. for IRIX
the architecture isn't particularly important (IRIX only runs on SGI
hardware), but for Linux the kernel version isn't particularly
important.
Examples of returned values:
linux-i586
linux-alpha (?)
solaris-2.6-sun4u
irix-5.3
irix64-6.2
Windows will return one of:
win-amd64 (64bit Windows on AMD64 (aka x86_64, Intel64, EM64T, etc)
win-ia64 (64bit Windows on Itanium)
win32 (all others - specifically, sys.platform is returned)
For other non-POSIX platforms, currently just returns 'sys.platform'.
"""
if os.name == 'nt':
# sniff sys.version for architecture.
prefix = " bit ("
i = sys.version.find(prefix)
if i == -1:
return sys.platform
j = sys.version.find(")", i)
look = sys.version[i+len(prefix):j].lower()
if look == 'amd64':
return 'win-amd64'
if look == 'itanium':
return 'win-ia64'
return sys.platform
# Set for cross builds explicitly
if "_PYTHON_HOST_PLATFORM" in os.environ:
return os.environ["_PYTHON_HOST_PLATFORM"]
if os.name != "posix" or not hasattr(os, 'uname'):
# XXX what about the architecture? NT is Intel or Alpha,
# Mac OS is M68k or PPC, etc.
return sys.platform
# Try to distinguish various flavours of Unix
(osname, host, release, version, machine) = os.uname()
# Convert the OS name to lowercase, remove '/' characters
# (to accommodate BSD/OS), and translate spaces (for "Power Macintosh")
osname = osname.lower().replace('/', '')
machine = machine.replace(' ', '_')
machine = machine.replace('/', '-')
if osname[:5] == "linux":
# At least on Linux/Intel, 'machine' is the processor --
# i386, etc.
# XXX what about Alpha, SPARC, etc?
return "%s-%s" % (osname, machine)
elif osname[:5] == "sunos":
if release[0] >= "5": # SunOS 5 == Solaris 2
osname = "solaris"
release = "%d.%s" % (int(release[0]) - 3, release[2:])
# We can't use "platform.architecture()[0]" because a
# bootstrap problem. We use a dict to get an error
# if some suspicious happens.
bitness = {2147483647:"32bit", 9223372036854775807:"64bit"}
machine += ".%s" % bitness[sys.maxsize]
# fall through to standard osname-release-machine representation
elif osname[:4] == "irix": # could be "irix64"!
return "%s-%s" % (osname, release)
elif osname[:3] == "aix":
return "%s-%s.%s" % (osname, version, release)
elif osname[:6] == "cygwin":
osname = "cygwin"
rel_re = re.compile (r'[\d.]+', re.ASCII)
m = rel_re.match(release)
if m:
release = m.group()
elif osname[:6] == "darwin":
import _osx_support, distutils.sysconfig
osname, release, machine = _osx_support.get_platform_osx(
distutils.sysconfig.get_config_vars(),
osname, release, machine)
return "%s-%s-%s" % (osname, release, machine)
# get_platform ()
def convert_path (pathname):
"""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.
"""
if os.sep == '/':
return pathname
if not pathname:
return pathname
if pathname[0] == '/':
raise ValueError("path '%s' cannot be absolute" % pathname)
if pathname[-1] == '/':
raise ValueError("path '%s' cannot end with '/'" % pathname)
paths = pathname.split('/')
while '.' in paths:
paths.remove('.')
if not paths:
return os.curdir
return os.path.join(*paths)
# convert_path ()
def change_root (new_root, pathname):
"""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.
"""
if os.name == 'posix':
if not os.path.isabs(pathname):
return os.path.join(new_root, pathname)
else:
return os.path.join(new_root, pathname[1:])
elif os.name == 'nt':
(drive, path) = os.path.splitdrive(pathname)
if path[0] == '\\':
path = path[1:]
return os.path.join(new_root, path)
elif os.name == 'os2':
(drive, path) = os.path.splitdrive(pathname)
if path[0] == os.sep:
path = path[1:]
return os.path.join(new_root, path)
else:
raise DistutilsPlatformError("nothing known about platform '%s'" % os.name)
_environ_checked = 0
def check_environ ():
"""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()')
"""
global _environ_checked
if _environ_checked:
return
if os.name == 'posix' and 'HOME' not in os.environ:
import pwd
os.environ['HOME'] = pwd.getpwuid(os.getuid())[5]
if 'PLAT' not in os.environ:
os.environ['PLAT'] = get_platform()
_environ_checked = 1
def subst_vars (s, local_vars):
"""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'.
"""
check_environ()
def _subst (match, local_vars=local_vars):
var_name = match.group(1)
if var_name in local_vars:
return str(local_vars[var_name])
else:
return os.environ[var_name]
try:
return re.sub(r'\$([a-zA-Z_][a-zA-Z_0-9]*)', _subst, s)
except KeyError as var:
raise ValueError("invalid variable '$%s'" % var)
# subst_vars ()
def grok_environment_error (exc, prefix="error: "):
# Function kept for backward compatibility.
# Used to try clever things with EnvironmentErrors,
# but nowadays str(exception) produces good messages.
return prefix + str(exc)
# Needed by 'split_quoted()'
_wordchars_re = _squote_re = _dquote_re = None
def _init_regex():
global _wordchars_re, _squote_re, _dquote_re
_wordchars_re = re.compile(r'[^\\\'\"%s ]*' % string.whitespace)
_squote_re = re.compile(r"'(?:[^'\\]|\\.)*'")
_dquote_re = re.compile(r'"(?:[^"\\]|\\.)*"')
def split_quoted (s):
"""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.
"""
# This is a nice algorithm for splitting up a single string, since it
# doesn't require character-by-character examination. It was a little
# bit of a brain-bender to get it working right, though...
if _wordchars_re is None: _init_regex()
s = s.strip()
words = []
pos = 0
while s:
m = _wordchars_re.match(s, pos)
end = m.end()
if end == len(s):
words.append(s[:end])
break
if s[end] in string.whitespace: # unescaped, unquoted whitespace: now
words.append(s[:end]) # we definitely have a word delimiter
s = s[end:].lstrip()
pos = 0
elif s[end] == '\\': # preserve whatever is being escaped;
# will become part of the current word
s = s[:end] + s[end+1:]
pos = end+1
else:
if s[end] == "'": # slurp singly-quoted string
m = _squote_re.match(s, end)
elif s[end] == '"': # slurp doubly-quoted string
m = _dquote_re.match(s, end)
else:
raise RuntimeError("this can't happen (bad char '%c')" % s[end])
if m is None:
raise ValueError("bad string (mismatched %s quotes?)" % s[end])
(beg, end) = m.span()
s = s[:beg] + s[beg+1:end-1] + s[end:]
pos = m.end() - 2
if pos >= len(s):
words.append(s)
break
return words
# split_quoted ()
def execute (func, args, msg=None, verbose=0, dry_run=0):
"""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.
"""
if msg is None:
msg = "%s%r" % (func.__name__, args)
if msg[-2:] == ',)': # correct for singleton tuple
msg = msg[0:-2] + ')'
log.info(msg)
if not dry_run:
func(*args)
def strtobool (val):
"""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.
"""
val = val.lower()
if val in ('y', 'yes', 't', 'true', 'on', '1'):
return 1
elif val in ('n', 'no', 'f', 'false', 'off', '0'):
return 0
else:
raise ValueError("invalid truth value %r" % (val,))
def byte_compile (py_files,
optimize=0, force=0,
prefix=None, base_dir=None,
verbose=1, dry_run=0,
direct=None):
"""Byte-compile a collection of Python source files to either .pyc
or .pyo 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 (generate .pyc)
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.
"""
# nothing is done if sys.dont_write_bytecode is True
if sys.dont_write_bytecode:
raise DistutilsByteCompileError('byte-compiling is disabled.')
# First, if the caller didn't force us into direct or indirect mode,
# figure out which mode we should be in. We take a conservative
# approach: choose direct mode *only* if the current interpreter is
# in debug mode and optimize is 0. If we're not in debug mode (-O
# or -OO), we don't know which level of optimization this
# interpreter is running with, so we can't do direct
# byte-compilation and be certain that it's the right thing. Thus,
# always compile indirectly if the current interpreter is in either
# optimize mode, or if either optimization level was requested by
# the caller.
if direct is None:
direct = (__debug__ and optimize == 0)
# "Indirect" byte-compilation: write a temporary script and then
# run it with the appropriate flags.
if not direct:
try:
from tempfile import mkstemp
(script_fd, script_name) = mkstemp(".py")
except ImportError:
from tempfile import mktemp
(script_fd, script_name) = None, mktemp(".py")
log.info("writing byte-compilation script '%s'", script_name)
if not dry_run:
if script_fd is not None:
script = os.fdopen(script_fd, "w")
else:
script = open(script_name, "w")
script.write("""\
from distutils.util import byte_compile
files = [
""")
# XXX would be nice to write absolute filenames, just for
# safety's sake (script should be more robust in the face of
# chdir'ing before running it). But this requires abspath'ing
# 'prefix' as well, and that breaks the hack in build_lib's
# 'byte_compile()' method that carefully tacks on a trailing
# slash (os.sep really) to make sure the prefix here is "just
# right". This whole prefix business is rather delicate -- the
# problem is that it's really a directory, but I'm treating it
# as a dumb string, so trailing slashes and so forth matter.
#py_files = map(os.path.abspath, py_files)
#if prefix:
# prefix = os.path.abspath(prefix)
script.write(",\n".join(map(repr, py_files)) + "]\n")
script.write("""
byte_compile(files, optimize=%r, force=%r,
prefix=%r, base_dir=%r,
verbose=%r, dry_run=0,
direct=1)
""" % (optimize, force, prefix, base_dir, verbose))
script.close()
cmd = [sys.executable, script_name]
if optimize == 1:
cmd.insert(1, "-O")
elif optimize == 2:
cmd.insert(1, "-OO")
spawn(cmd, dry_run=dry_run)
execute(os.remove, (script_name,), "removing %s" % script_name,
dry_run=dry_run)
# "Direct" byte-compilation: use the py_compile module to compile
# right here, right now. Note that the script generated in indirect
# mode simply calls 'byte_compile()' in direct mode, a weird sort of
# cross-process recursion. Hey, it works!
else:
from py_compile import compile
for file in py_files:
if file[-3:] != ".py":
# This lets us be lazy and not filter filenames in
# the "install_lib" command.
continue
# Terminology from the py_compile module:
# cfile - byte-compiled file
# dfile - purported source filename (same as 'file' by default)
if optimize >= 0:
cfile = imp.cache_from_source(file, debug_override=not optimize)
else:
cfile = imp.cache_from_source(file)
dfile = file
if prefix:
if file[:len(prefix)] != prefix:
raise ValueError("invalid prefix: filename %r doesn't start with %r"
% (file, prefix))
dfile = dfile[len(prefix):]
if base_dir:
dfile = os.path.join(base_dir, dfile)
cfile_base = os.path.basename(cfile)
if direct:
if force or newer(file, cfile):
log.info("byte-compiling %s to %s", file, cfile_base)
if not dry_run:
compile(file, cfile, dfile)
else:
log.debug("skipping byte-compilation of %s to %s",
file, cfile_base)
# byte_compile ()
def rfc822_escape (header):
"""Return a version of the string escaped for inclusion in an
RFC-822 header, by ensuring there are 8 spaces space after each newline.
"""
lines = header.split('\n')
sep = '\n' + 8 * ' '
return sep.join(lines)
# 2to3 support
def run_2to3(files, fixer_names=None, options=None, explicit=None):
"""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."""
if not files:
return
# Make this class local, to delay import of 2to3
from lib2to3.refactor import RefactoringTool, get_fixers_from_package
class DistutilsRefactoringTool(RefactoringTool):
def log_error(self, msg, *args, **kw):
log.error(msg, *args)
def log_message(self, msg, *args):
log.info(msg, *args)
def log_debug(self, msg, *args):
log.debug(msg, *args)
if fixer_names is None:
fixer_names = get_fixers_from_package('lib2to3.fixes')
r = DistutilsRefactoringTool(fixer_names, options=options)
r.refactor(files, write=True)
def copydir_run_2to3(src, dest, template=None, fixer_names=None,
options=None, explicit=None):
"""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.
"""
from distutils.dir_util import mkpath
from distutils.file_util import copy_file
from distutils.filelist import FileList
filelist = FileList()
curdir = os.getcwd()
os.chdir(src)
try:
filelist.findall()
finally:
os.chdir(curdir)
filelist.files[:] = filelist.allfiles
if template:
for line in template.splitlines():
line = line.strip()
if not line: continue
filelist.process_template_line(line)
copied = []
for filename in filelist.files:
outname = os.path.join(dest, filename)
mkpath(os.path.dirname(outname))
res = copy_file(os.path.join(src, filename), outname, update=1)
if res[1]: copied.append(outname)
run_2to3([fn for fn in copied if fn.lower().endswith('.py')],
fixer_names=fixer_names, options=options, explicit=explicit)
return copied
class Mixin2to3:
'''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.'''
# provide list of fixers to run;
# defaults to all from lib2to3.fixers
fixer_names = None
# options dictionary
options = None
# list of fixers to invoke even though they are marked as explicit
explicit = None
def run_2to3(self, files):
return run_2to3(files, self.fixer_names, self.options, self.explicit)
PK ! \[J [J cmd.pynu [ """distutils.cmd
Provides the Command class, the base class for the command classes
in the distutils.command package.
"""
import sys, os, re
from distutils.errors import DistutilsOptionError
from distutils import util, dir_util, file_util, archive_util, dep_util
from distutils import log
class Command:
"""Abstract base class for defining command classes, the "worker bees"
of the Distutils. A useful analogy for command classes is to think of
them as subroutines with local variables called "options". The options
are "declared" in 'initialize_options()' and "defined" (given their
final values, aka "finalized") in 'finalize_options()', both of which
must be defined by every command class. The distinction between the
two is necessary because option values might come from the outside
world (command line, config file, ...), and any options dependent on
other options must be computed *after* these outside influences have
been processed -- hence 'finalize_options()'. The "body" of the
subroutine, where it does all its work based on the values of its
options, is the 'run()' method, which must also be implemented by every
command class.
"""
# 'sub_commands' formalizes the notion of a "family" of commands,
# eg. "install" as the parent with sub-commands "install_lib",
# "install_headers", etc. The parent of a family of commands
# defines 'sub_commands' as a class attribute; it's a list of
# (command_name : string, predicate : unbound_method | string | None)
# tuples, where 'predicate' is a method of the parent command that
# determines whether the corresponding command is applicable in the
# current situation. (Eg. we "install_headers" is only applicable if
# we have any C header files to install.) If 'predicate' is None,
# that command is always applicable.
#
# 'sub_commands' is usually defined at the *end* of a class, because
# predicates can be unbound methods, so they must already have been
# defined. The canonical example is the "install" command.
sub_commands = []
# -- Creation/initialization methods -------------------------------
def __init__(self, dist):
"""Create and initialize a new Command object. Most importantly,
invokes the 'initialize_options()' method, which is the real
initializer and depends on the actual command being
instantiated.
"""
# late import because of mutual dependence between these classes
from distutils.dist import Distribution
if not isinstance(dist, Distribution):
raise TypeError("dist must be a Distribution instance")
if self.__class__ is Command:
raise RuntimeError("Command is an abstract class")
self.distribution = dist
self.initialize_options()
# Per-command versions of the global flags, so that the user can
# customize Distutils' behaviour command-by-command and let some
# commands fall back on the Distribution's behaviour. None means
# "not defined, check self.distribution's copy", while 0 or 1 mean
# false and true (duh). Note that this means figuring out the real
# value of each flag is a touch complicated -- hence "self._dry_run"
# will be handled by __getattr__, below.
# XXX This needs to be fixed.
self._dry_run = None
# verbose is largely ignored, but needs to be set for
# backwards compatibility (I think)?
self.verbose = dist.verbose
# Some commands define a 'self.force' option to ignore file
# timestamps, but methods defined *here* assume that
# 'self.force' exists for all commands. So define it here
# just to be safe.
self.force = None
# The 'help' flag is just used for command-line parsing, so
# none of that complicated bureaucracy is needed.
self.help = 0
# 'finalized' records whether or not 'finalize_options()' has been
# called. 'finalize_options()' itself should not pay attention to
# this flag: it is the business of 'ensure_finalized()', which
# always calls 'finalize_options()', to respect/update it.
self.finalized = 0
# XXX A more explicit way to customize dry_run would be better.
def __getattr__(self, attr):
if attr == 'dry_run':
myval = getattr(self, "_" + attr)
if myval is None:
return getattr(self.distribution, attr)
else:
return myval
else:
raise AttributeError(attr)
def ensure_finalized(self):
if not self.finalized:
self.finalize_options()
self.finalized = 1
# Subclasses must define:
# initialize_options()
# provide default values for all options; may be customized by
# setup script, by options from config file(s), or by command-line
# options
# finalize_options()
# decide on the final values for all options; this is called
# after all possible intervention from the outside world
# (command-line, option file, etc.) has been processed
# run()
# run the command: do whatever it is we're here to do,
# controlled by the command's various option values
def initialize_options(self):
"""Set default values for all the options that this command
supports. Note that these defaults may be overridden by other
commands, by the setup script, by config files, or by the
command-line. Thus, this is not the place to code dependencies
between options; generally, 'initialize_options()' implementations
are just a bunch of "self.foo = None" assignments.
This method must be implemented by all command classes.
"""
raise RuntimeError("abstract method -- subclass %s must override"
% self.__class__)
def finalize_options(self):
"""Set final values for all the options that this command supports.
This is always called as late as possible, ie. after any option
assignments from the command-line or from other commands have been
done. Thus, this is the place to code option dependencies: if
'foo' depends on 'bar', then it is safe to set 'foo' from 'bar' as
long as 'foo' still has the same value it was assigned in
'initialize_options()'.
This method must be implemented by all command classes.
"""
raise RuntimeError("abstract method -- subclass %s must override"
% self.__class__)
def dump_options(self, header=None, indent=""):
from distutils.fancy_getopt import longopt_xlate
if header is None:
header = "command options for '%s':" % self.get_command_name()
self.announce(indent + header, level=log.INFO)
indent = indent + " "
for (option, _, _) in self.user_options:
option = option.translate(longopt_xlate)
if option[-1] == "=":
option = option[:-1]
value = getattr(self, option)
self.announce(indent + "%s = %s" % (option, value),
level=log.INFO)
def run(self):
"""A command's raison d'etre: carry out the action it exists to
perform, controlled by the options initialized in
'initialize_options()', customized by other commands, the setup
script, the command-line, and config files, and finalized in
'finalize_options()'. All terminal output and filesystem
interaction should be done by 'run()'.
This method must be implemented by all command classes.
"""
raise RuntimeError("abstract method -- subclass %s must override"
% self.__class__)
def announce(self, msg, level=1):
"""If the current verbosity level is of greater than or equal to
'level' print 'msg' to stdout.
"""
log.log(level, msg)
def debug_print(self, msg):
"""Print 'msg' to stdout if the global DEBUG (taken from the
DISTUTILS_DEBUG environment variable) flag is true.
"""
from distutils.debug import DEBUG
if DEBUG:
print(msg)
sys.stdout.flush()
# -- Option validation methods -------------------------------------
# (these are very handy in writing the 'finalize_options()' method)
#
# NB. the general philosophy here is to ensure that a particular option
# value meets certain type and value constraints. If not, we try to
# force it into conformance (eg. if we expect a list but have a string,
# split the string on comma and/or whitespace). If we can't force the
# option into conformance, raise DistutilsOptionError. Thus, command
# classes need do nothing more than (eg.)
# self.ensure_string_list('foo')
# and they can be guaranteed that thereafter, self.foo will be
# a list of strings.
def _ensure_stringlike(self, option, what, default=None):
val = getattr(self, option)
if val is None:
setattr(self, option, default)
return default
elif not isinstance(val, str):
raise DistutilsOptionError("'%s' must be a %s (got `%s`)"
% (option, what, val))
return val
def ensure_string(self, option, default=None):
"""Ensure that 'option' is a string; if not defined, set it to
'default'.
"""
self._ensure_stringlike(option, "string", default)
def ensure_string_list(self, option):
"""Ensure that 'option' is a list of strings. If 'option' is
currently a string, we split it either on /,\s*/ or /\s+/, so
"foo bar baz", "foo,bar,baz", and "foo, bar baz" all become
["foo", "bar", "baz"].
"""
val = getattr(self, option)
if val is None:
return
elif isinstance(val, str):
setattr(self, option, re.split(r',\s*|\s+', val))
else:
if isinstance(val, list):
ok = all(isinstance(v, str) for v in val)
else:
ok = False
if not ok:
raise DistutilsOptionError(
"'%s' must be a list of strings (got %r)"
% (option, val))
def _ensure_tested_string(self, option, tester, what, error_fmt,
default=None):
val = self._ensure_stringlike(option, what, default)
if val is not None and not tester(val):
raise DistutilsOptionError(("error in '%s' option: " + error_fmt)
% (option, val))
def ensure_filename(self, option):
"""Ensure that 'option' is the name of an existing file."""
self._ensure_tested_string(option, os.path.isfile,
"filename",
"'%s' does not exist or is not a file")
def ensure_dirname(self, option):
self._ensure_tested_string(option, os.path.isdir,
"directory name",
"'%s' does not exist or is not a directory")
# -- Convenience methods for commands ------------------------------
def get_command_name(self):
if hasattr(self, 'command_name'):
return self.command_name
else:
return self.__class__.__name__
def set_undefined_options(self, src_cmd, *option_pairs):
"""Set the values of any "undefined" options from corresponding
option values in some other command object. "Undefined" here means
"is None", which is the convention used to indicate that an option
has not been changed between 'initialize_options()' and
'finalize_options()'. Usually called from 'finalize_options()' for
options that depend on some other command rather than another
option of the same command. 'src_cmd' is the other command from
which option values will be taken (a command object will be created
for it if necessary); the remaining arguments are
'(src_option,dst_option)' tuples which mean "take the value of
'src_option' in the 'src_cmd' command object, and copy it to
'dst_option' in the current command object".
"""
# Option_pairs: list of (src_option, dst_option) tuples
src_cmd_obj = self.distribution.get_command_obj(src_cmd)
src_cmd_obj.ensure_finalized()
for (src_option, dst_option) in option_pairs:
if getattr(self, dst_option) is None:
setattr(self, dst_option, getattr(src_cmd_obj, src_option))
def get_finalized_command(self, command, create=1):
"""Wrapper around Distribution's 'get_command_obj()' method: find
(create if necessary and 'create' is true) the command object for
'command', call its 'ensure_finalized()' method, and return the
finalized command object.
"""
cmd_obj = self.distribution.get_command_obj(command, create)
cmd_obj.ensure_finalized()
return cmd_obj
# XXX rename to 'get_reinitialized_command()'? (should do the
# same in dist.py, if so)
def reinitialize_command(self, command, reinit_subcommands=0):
return self.distribution.reinitialize_command(command,
reinit_subcommands)
def run_command(self, command):
"""Run some other command: uses the 'run_command()' method of
Distribution, which creates and finalizes the command object if
necessary and then invokes its 'run()' method.
"""
self.distribution.run_command(command)
def get_sub_commands(self):
"""Determine the sub-commands that are relevant in the current
distribution (ie., that need to be run). This is based on the
'sub_commands' class attribute: each tuple in that list may include
a method that we call to determine if the subcommand needs to be
run for the current distribution. Return a list of command names.
"""
commands = []
for (cmd_name, method) in self.sub_commands:
if method is None or method(self):
commands.append(cmd_name)
return commands
# -- External world manipulation -----------------------------------
def warn(self, msg):
log.warn("warning: %s: %s\n" %
(self.get_command_name(), msg))
def execute(self, func, args, msg=None, level=1):
util.execute(func, args, msg, dry_run=self.dry_run)
def mkpath(self, name, mode=0o777):
dir_util.mkpath(name, mode, dry_run=self.dry_run)
def copy_file(self, infile, outfile, preserve_mode=1, preserve_times=1,
link=None, level=1):
"""Copy a file respecting verbose, dry-run and force flags. (The
former two default to whatever is in the Distribution object, and
the latter defaults to false for commands that don't define it.)"""
return file_util.copy_file(infile, outfile, preserve_mode,
preserve_times, not self.force, link,
dry_run=self.dry_run)
def copy_tree(self, infile, outfile, preserve_mode=1, preserve_times=1,
preserve_symlinks=0, level=1):
"""Copy an entire directory tree respecting verbose, dry-run,
and force flags.
"""
return dir_util.copy_tree(infile, outfile, preserve_mode,
preserve_times, preserve_symlinks,
not self.force, dry_run=self.dry_run)
def move_file (self, src, dst, level=1):
"""Move a file respecting dry-run flag."""
return file_util.move_file(src, dst, dry_run=self.dry_run)
def spawn(self, cmd, search_path=1, level=1):
"""Spawn an external command respecting dry-run flag."""
from distutils.spawn import spawn
spawn(cmd, search_path, dry_run=self.dry_run)
def make_archive(self, base_name, format, root_dir=None, base_dir=None):
return archive_util.make_archive(base_name, format, root_dir, base_dir,
dry_run=self.dry_run)
def make_file(self, infiles, outfile, func, args,
exec_msg=None, skip_msg=None, level=1):
"""Special case of 'execute()' for operations that process one or
more input files and generate one output file. Works just like
'execute()', except the operation is skipped and a different
message printed if 'outfile' already exists and is newer than all
files listed in 'infiles'. If the command defined 'self.force',
and it is true, then the command is unconditionally run -- does no
timestamp checks.
"""
if skip_msg is None:
skip_msg = "skipping %s (inputs unchanged)" % outfile
# Allow 'infiles' to be a single string
if isinstance(infiles, str):
infiles = (infiles,)
elif not isinstance(infiles, (list, tuple)):
raise TypeError(
"'infiles' must be a string, or a list or tuple of strings")
if exec_msg is None:
exec_msg = "generating %s from %s" % (outfile, ', '.join(infiles))
# If 'outfile' must be regenerated (either because it doesn't
# exist, is out-of-date, or the 'force' flag is true) then
# perform the action that presumably regenerates it
if self.force or dep_util.newer_group(infiles, outfile):
self.execute(func, args, exec_msg, level)
# Otherwise, print the "skip" message
else:
log.debug(skip_msg)
# XXX 'install_misc' class not currently used -- it was the base class for
# both 'install_scripts' and 'install_data', but they outgrew it. It might
# still be useful for 'install_headers', though, so I'm keeping it around
# for the time being.
class install_misc(Command):
"""Common base class for installing some files in a subdirectory.
Currently used by install_data and install_scripts.
"""
user_options = [('install-dir=', 'd', "directory to install the files to")]
def initialize_options (self):
self.install_dir = None
self.outfiles = []
def _install_dir_from(self, dirname):
self.set_undefined_options('install', (dirname, 'install_dir'))
def _copy_files(self, filelist):
self.outfiles = []
if not filelist:
return
self.mkpath(self.install_dir)
for f in filelist:
self.copy_file(f, self.install_dir)
self.outfiles.append(os.path.join(self.install_dir, f))
def get_outputs(self):
return self.outfiles
PK ! ư * __pycache__/file_util.cpython-36.opt-2.pycnu [ 3
\ @ sV d dl Z d dlmZ d dlmZ ddddZdd
d Zdd
dZdddZdd Z dS ) N)DistutilsFileError)logZcopyingz hard linkingzsymbolically linking)Nhardsym i c N C s d }d }zvyt | d}W n4 tk
rN } ztd| |jf W Y d d }~X nX tjj|rytj| W n4 tk
r } ztd||jf W Y d d }~X nX yt |d}W n4 tk
r } ztd||jf W Y d d }~X nX xy|j|}W n6 tk
r* } ztd| |jf W Y d d }~X nX |s4P y|j | W q tk
rx } ztd||jf W Y d d }~X qX qW W d |r|j
|r|j
X d S )Nrbzcould not open '%s': %szcould not delete '%s': %swbzcould not create '%s': %sz could not read from '%s': %szcould not write to '%s': %s) openOSErrorr strerrorospathexistsunlinkreadwriteclose)srcdst buffer_sizeZfsrcZfdsteZbuf r +/usr/lib64/python3.6/distutils/file_util.py_copy_file_contents sF $ """*r c C s ddl m} ddlm} m}
m} m} tjj | s %sr r ) Zdistutils.dep_utilr statr r r r r r
isfiler isdirjoinbasenamedirnamer debug _copy_actionKeyError
ValueErrorinfor samefilelinkr
symlinkr utimechmod)r r Z
preserve_modeZpreserve_timesupdater, verbosedry_runr r r r r diractionstr r r copy_fileC sT !
r6 c ( C s ddl m}m}m}m}m} dd l} |dkr:tjd| | |rB|S || sVt d| ||rrt
j j ||| }n||rt d| |f |||st d| |f d}
yt
j
| | W nP tk
r
} z2| j\} }
| | jkrd }
nt d
| ||
f W Y d d } ~ X nX |
rt| ||d yt
j| W nh tk
r } zJ| j\} }
yt
j| W n tk
rp Y nX t d | || |
f W Y d d } ~ X nX |S )
Nr )r r! r" r$ r% r zmoving %s -> %sz#can't move '%s': not a regular filez0can't move '%s': destination '%s' already existsz2can't move '%s': destination '%s' not a valid pathFTz couldn't move '%s' to '%s': %s)r1 zAcouldn't move '%s' to '%s' by copy/delete: delete '%s' failed: %s)Zos.pathr r! r" r$ r% errnor r* r r r
r# renamer
argsZEXDEVr6 r )r r r1 r2 r r! r" r$ r% r7 Zcopy_itr Znummsgr r r move_file sR
"
"r; c
C s: t | d}z x|D ]}|j|d qW W d |j X d S )Nw
)r r r )filenamecontentsfliner r r
write_file s
rB @ )rC )r r r Nr r )r r )
r Zdistutils.errorsr Z distutilsr r' r r6 r; rB r r r r s
3
c
=PK ! Fӎ # # $ __pycache__/cmd.cpython-36.opt-2.pycnu [ 3
\J @ sn d dl Z d dlZd dlZd dlmZ d dlmZmZmZm Z m
Z
d dlm Z G dd dZ G dd de Z
dS ) N)DistutilsOptionError)utildir_util file_util archive_utildep_util)logc @ s e Zd Zg Zdd Zdd Zdd Zdd Zd d
ZdBd
dZ dd Z
dCddZ dd Z dDddZ
dEddZdd ZdFd d Zd d Zd d! Zd"d# Zd$d% ZdGd&d'ZdHd)d*Zd+d, Zd-d. Zd/d0 ZdId1d2ZdJd4d5ZdKd6d7Z dLd8d9Z dMd:d;Z dNdd?Z dPd@dAZ!d S )QCommandc C sb ddl m} t||s td| jtkr0td|| _| j d | _ |j
| _
d | _ d| _ d| _
d S )Nr ) Distributionz$dist must be a Distribution instancez Command is an abstract class)Zdistutils.distr
isinstance TypeError __class__r RuntimeError distributioninitialize_optionsZ_dry_runverboseforcehelp finalized)selfZdistr
r %/usr/lib64/python3.6/distutils/cmd.py__init__/ s
zCommand.__init__c C s< |dkr0t | d| }|d kr*t | j|S |S nt|d S )Ndry_run_)getattrr AttributeError)r attrZmyvalr r r __getattr___ s zCommand.__getattr__c C s | j s| j d| _ d S )N )r finalize_options)r r r r ensure_finalizedi s zCommand.ensure_finalizedc C s t d| j d S )Nz,abstract method -- subclass %s must override)r r
)r r r r r { s
zCommand.initialize_optionsc C s t d| j d S )Nz,abstract method -- subclass %s must override)r r
)r r r r r s zCommand.finalize_optionsN c C s ddl m} |d kr d| j }| j|| tjd |d }x\| jD ]R\}}}|j|}|d dkrp|d d
}t| |}| j|d||f tjd qDW d S ) Nr )
longopt_xlatezcommand options for '%s':)levelz r =z%s = %sr& ) Zdistutils.fancy_getoptr# get_command_nameannouncer INFO user_options translater )r headerindentr# optionr valuer r r dump_options s
zCommand.dump_optionsc C s t d| j d S )Nz,abstract method -- subclass %s must override)r r
)r r r r run s
z Command.runr c C s t j || d S )N)r )r msgr$ r r r r( s zCommand.announcec C s& ddl m} |r"t| tjj d S )Nr )DEBUG)Zdistutils.debugr3 printsysstdoutflush)r r2 r3 r r r debug_print s zCommand.debug_printc C sB t | |}|d kr"t| || |S t|ts>td|||f |S )Nz '%s' must be a %s (got `%s`))r setattrr strr )r r. whatdefaultvalr r r _ensure_stringlike s
zCommand._ensure_stringlikec C s | j |d| d S )Nstring)r> )r r. r< r r r
ensure_string s zCommand.ensure_stringc C sp t | |}|d krd S t|tr6t| |tjd| n6t|trTtdd |D }nd}|sltd||f d S )Nz,\s*|\s+c s s | ]}t |tV qd S )N)r r: ).0vr r r s z-Command.ensure_string_list..Fz''%s' must be a list of strings (got %r)) r r r: r9 resplitlistallr )r r. r= okr r r ensure_string_list s
zCommand.ensure_string_listc C s8 | j |||}|d k r4|| r4td| ||f d S )Nzerror in '%s' option: )r> r )r r. Ztesterr; Z error_fmtr< r= r r r _ensure_tested_string s z Command._ensure_tested_stringc C s | j |tjjdd d S )Nfilenamez$'%s' does not exist or is not a file)rJ ospathisfile)r r. r r r ensure_filename s zCommand.ensure_filenamec C s | j |tjjdd d S )Nzdirectory namez)'%s' does not exist or is not a directory)rJ rL rM isdir)r r. r r r ensure_dirname s zCommand.ensure_dirnamec C s t | dr| jS | jjS d S )N command_name)hasattrrR r
__name__)r r r r r' s
zCommand.get_command_namec G sJ | j j|}|j x0|D ](\}}t| |d krt| |t|| qW d S )N)r get_command_objr! r r9 )r Zsrc_cmdZ option_pairsZ src_cmd_objZ
src_optionZ
dst_optionr r r set_undefined_options s
z Command.set_undefined_optionsc C s | j j||}|j |S )N)r rU r! )r commandZcreateZcmd_objr r r get_finalized_command$ s z Command.get_finalized_commandr c C s | j j||S )N)r reinitialize_command)r rW Zreinit_subcommandsr r r rY 0 s z Command.reinitialize_commandc C s | j j| d S )N)r run_command)r rW r r r rZ 4 s zCommand.run_commandc C s6 g }x,| j D ]"\}}|d ks$|| r |j| q W |S )N) sub_commandsappend)r ZcommandsZcmd_namemethodr r r get_sub_commands; s
zCommand.get_sub_commandsc C s t jd| j | d S )Nzwarning: %s: %s
)r warnr' )r r2 r r r r_ K s z Command.warnc C s t j|||| jd d S )N)r )r executer )r funcargsr2 r$ r r r r` N s zCommand.execute c C s t j||| jd d S )N)r )r mkpathr )r namemoder r r rd Q s zCommand.mkpathc C s t j||||| j || jdS )N)r )r copy_filer r )r infileoutfile
preserve_modepreserve_timeslinkr$ r r r rg T s
zCommand.copy_filec C s t j|||||| j | jdS )N)r )r copy_treer r )r rh ri rj rk Zpreserve_symlinksr$ r r r rm ] s
zCommand.copy_treec C s t j||| jdS )N)r )r move_filer )r srcdstr$ r r r rn f s zCommand.move_filec C s ddl m} |||| jd d S )Nr )spawn)r )Zdistutils.spawnrq r )r cmdZ search_pathr$ rq r r r rq j s z
Command.spawnc C s t j||||| j||dS )N)r ownergroup)r make_archiver )r Z base_nameformatZroot_dirZbase_dirrs rt r r r ru o s zCommand.make_archivec C s |d krd| }t |tr"|f}nt |ttfs8td|d krRd|dj|f }| jsdtj||rv| j |||| n
t
j | d S )Nz skipping %s (inputs unchanged)z9'infiles' must be a string, or a list or tuple of stringszgenerating %s from %sz, ) r r: rF tupler joinr r Z newer_groupr` r debug)r Zinfilesri ra rb Zexec_msgZskip_msgr$ r r r make_fileu s
zCommand.make_file)Nr" )r )N)N)N)r )r )Nr )rc )r r Nr )r r r r )r )r r )NNNN)NNr )"rT
__module__ __qualname__r[ r r r! r r r0 r1 r( r8 r> r@ rI rJ rO rQ r' rV rX rY rZ r^ r_ r` rd rg rm rn rq ru rz r r r r r sD 0
r c @ s2 e Zd Zd
gZdd Zdd Zdd Zd
d Zd S ) install_misc install-dir=d!directory to install the files toc C s d | _ g | _d S )N) install_diroutfiles)r r r r r s z install_misc.initialize_optionsc C s | j d|df d S )NZinstallr )rV )r dirnamer r r _install_dir_from s z install_misc._install_dir_fromc C sR g | _ |sd S | j| j x2|D ]*}| j|| j | j jtjj| j| q W d S )N)r rd r rg r\ rL rM rx )r Zfilelistfr r r _copy_files s
zinstall_misc._copy_filesc C s | j S )N)r )r r r r get_outputs s zinstall_misc.get_outputsN)r~ r r )rT r{ r| r* r r r r r r r r r} s
r} )r5 rL rD Zdistutils.errorsr Z distutilsr r r r r r r r} r r r r s PK ! 樤,4 4 ( __pycache__/_msvccompiler.cpython-36.pycnu [ 3
\KT @ s d Z ddlZddlZddlZddlZddlZddlmZmZm Z m
Z
m Z ddl m
Z
mZ ddlmZ ddlmZ ddlmZ dd Zd
d Zd d
Zdd ZdddZdddZedgZ G dd de
Z dS )a distutils._msvccompiler
Contains MSVCCompiler, an implementation of the abstract CCompiler class
for Microsoft Visual Studio 2015.
The module is compatible with VS 2015 and later. You can find legacy support
for older versions in distutils.msvc9compiler and distutils.msvccompiler.
N)DistutilsExecErrorDistutilsPlatformError CompileErrorLibError LinkError) CCompilergen_lib_options)log) get_platform)countc $ C s y t jt jdt jt jB d} W n tk
r< tjd dS X d}d }| xt D ]}yt j | |\}}}W n tk
r P Y nX |rT|t j
krTt j j
|rTytt|}W n ttfk
r wTY nX |dkrT||krT|| }}qTW W d Q R X ||fS )Nz'Software\Microsoft\VisualStudio\SxS\VC7)accessz Visual C++ is not registeredr )NN)winregZ OpenKeyExHKEY_LOCAL_MACHINEZKEY_READZKEY_WOW64_32KEYOSErrorr debugr Z EnumValueZREG_SZospathisdirintfloat
ValueError TypeError)key best_versionbest_dirivvc_dirZvtversion r //usr/lib64/python3.6/distutils/_msvccompiler.py _find_vc2015 s0
r" c
s dd l dd l} d }d }g fdd}| j|d}|j |j xD ]~\}}}}d|krLtjj|ddd} tjj| sqLy td d
|j d D }
W n t
t fk
r wLY nX |
|krL|
| }}qLW y |d }W n t k
r d }Y nX ||fS )
Nr c s j j d S )N)extendfindallr )_distutils_findvs all_packagesr r! _getallD s z _find_vc2017.._getall)targetz1Microsoft.VisualStudio.Component.VC.Tools.x86.x64ZVCZ AuxiliaryZBuildc s s | ]}t |V qd S )N)r ).0r r r r! P s z _find_vc2017...)r )
r% threadingZThreadstartjoinr r r tuplesplitr r
IndexError) r, r r r' tnameZ version_strr Zpackagesr r r )r% r& r! _find_vc2017: s2
r4 c C s
t \}}d }d| krdnd}|rztjj|ddddddd }y d
d l}|j|d d d }W n tttfk
rx d }Y nX |st \}}|rtjj|d|dd }|st j
d dS tjj|d}tjj |st j
d| dS | ptjj | rt j
d| d }||fS )Namd64Zx64x86z..ZredistZMSVCz**zMicrosoft.VC141.CRTzvcruntime140.dllr T) recursive zMicrosoft.VC140.CRTz$No suitable Visual C++ version foundz
vcvarsall.batz%s cannot be found)NN)NN) r4 r r r. glob ImportErrorr LookupErrorr" r r isfile) plat_specr r vcruntimeZvcruntime_platZvcredistr: vcvarsallr r r! _find_vcvarsall[ s6
rA c C s t jdr dd t jj D S t| \}}|s6tdy&tjdj|| tj dj
ddd }W n@ tj k
r } z"t j
|j td
j|jW Y d d }~X nX d d d d
|j D D }|r||d< |S )NZDISTUTILS_USE_SDKc S s i | ]\}}||j qS r )lower)r) r valuer r r!
s z _get_vc_env..z Unable to find vcvarsall.batzcmd /u /c "{}" {} && set)stderrzutf-16lereplace)errorszError executing {}c S s$ i | ] \}}}|r|r||j qS r )rB )r) r _rC r r r! rD s c s s | ]}|j d V qdS )=N) partition)r) liner r r! r* s z _get_vc_env..py_vcruntime_redist)r getenvenvironitemsrA r
subprocessZ check_outputformatZSTDOUTdecodeZCalledProcessErrorr erroroutputcmd
splitlines)r> r@ r? outexcenvr r r! _get_vc_env} s(
rZ c C sN |st jdjt j}x2|D ]*}t jjt jj|| }t jj|r |S q W | S )at Return path to an MSVC executable program.
Tries to find the program in several places: first, one of the
MSVC program search paths from the registry; next, the directories
in the PATH environment variable. If any of those work, return an
absolute path that is known to exist. If none of them work, just
return the original program name, 'exe'.
r )r rM r0 pathsepr r. abspathr= )Zexepathspfnr r r! _find_exe s
r` r6 Z x86_amd64)Zwin32z win-amd64zvcruntime140.dllc
s e Zd ZdZdZi ZdgZdddgZdgZdgZ ee e e Z
d Z d
Z d Z
d Zd
ZZdZd*ddZd+ddZd,ddZd-ddZd.ddZd/d d Zd d Z fd d!Zd"d# Zd$d% Zd&d' Z d0d(d)Z Z S )1 MSVCCompilerzwConcrete class that implements an interface to Microsoft Visual C++,
as defined by the CCompiler abstract class.Zmsvcz.cz.ccz.cppz.cxxz.rcz.mcz.resz.objz.libz.dllz%s%sz.exer c C s t j| ||| d | _d| _d S )NF)r __init__ plat_name initialized)selfverboseZdry_runZforcer r r! rb s zMSVCCompiler.__init__Nc C sN | j std|d kr t }|tkr8tdjttt| }t|}|sTtd|jdd| _ | j j
t j }t
d|| _t
d|| _t
d|| _t
d || _t
d
|| _t
d || _|jd d| _x2|jd
dj
t j D ]}|r| j|jt j qW x6|jddj
t j D ] }|r| j|jt j qW d | _dddddg| _| jj| jrZdnd ddddddg| _ dddg}| js|j d% dddd g}|d&| _ |d'| _ |d(| _ |d)| _!|| _"|| _#t$j%d f| j t$j%d#f| j t$j%d$f| j t$j&d f| j t$j&d#f| j t$j&d$f| j!t$j'd f| j"t$j'd#f| j"t$j'd$f| j#i | _(d$| _ d S )*Nzdon't init multiple timesz --plat-name must be one of {}z7Unable to find a compatible Visual Studio installation.r zcl.exezlink.exezlib.exezrc.exezmc.exezmt.exerL includelibz/nologoz/Oxz/W3z/GLz/DNDEBUGz/MDz/MTz/Odz/MDdz/Ziz/D_DEBUGz/INCREMENTAL:NOz/LTCG/nodefaultlib:libucrt.libucrt.libz /DEBUG:FULL/MANIFEST:EMBED,ID=1/DLL/MANIFEST:EMBED,ID=2/MANIFESTUAC:NOFT)rj rk )rl )rl )rm rn ro )rm rn ro ))rd AssertionErrorr
PLAT_TO_VCVARSr rQ r/ rZ get_pathsr0 r r[ r` cclinkerri rcmcZmt_vcruntime_redistZadd_include_dirrstripsepZadd_library_dirZpreprocess_optionscompile_optionsappendcompile_options_debugr# Z ldflags_exeZldflags_exe_debugZldflags_sharedZldflags_shared_debugZldflags_staticZldflags_static_debugr Z
EXECUTABLEZ
SHARED_OBJECTZSHARED_LIBRARY_ldflags)re rc r> Zvc_envr] dirldflagsZ
ldflags_debugr r r!
initialize sb
zMSVCCompiler.initializerg c sT fddj D fddjj D p4d fdd}tt||S )Nc s i | ] } j |qS r )
obj_extension)r) ext)re r r! rD 8 s z1MSVCCompiler.object_filenames..c s i | ] } j |qS r )
res_extension)r) r )re r r! rD 9 s rg c s t jj| \}}r"t jj|}n2t jj|\}}|jt jjt jjfrT|dd }yt jj| | S t k
r t
dj | Y nX d S )Nr8 z Don't know how to compile {}) r r splitextbasename
splitdrive
startswithrz altsepr. r< r rQ )r^ baser rH )ext_map
output_dir strip_dirr r!
make_out_path> s z4MSVCCompiler.object_filenames..make_out_path)src_extensions_rc_extensions_mc_extensionslistmap)re Zsource_filenamesr r r r )r r re r r! object_filenames3 s
z MSVCCompiler.object_filenamesc C s | j s| j | j||||||} | \}}
}} } |p6g }
|
jd |rT|
j| j n |
j| j d}x |
D ]}y| | \}}W n tk
r wlY nX |rtj j
|}|| j krd| }nD|| j krd| }d}n*|| j
krB|}d| }y | j| jg| ||g W ql tk
r< } zt|W Y d d }~X qlX qln|| jkrtj j|}tj j|}y\| j| jd|d||g tj jtj j|\}}tj j||d }| j| jd| |g W ql tk
r } zt|W Y d d }~X qlX qlntd
j||| jg|
| }|r$|jd |j| |jd | |j| y| j| W ql tk
r } zt|W Y d d }~X qlX qlW |
S )
Nz/cFz/Tcz/TpTz/foz-hz-rz.rcz"Don't know how to compile {} to {}z/EHscz/Fo)rd r Z_setup_compiler| r# r} r{ KeyErrorr r r\
_c_extensions_cpp_extensionsr spawnrv r r r dirnamerw r r r. rQ rt )re Zsourcesr ZmacrosZ include_dirsr
extra_preargsextra_postargsZdependsZ compile_infoobjectsZpp_optsZbuildZ compile_optsZ add_cpp_optsobjsrcr Z input_optZ
output_optmsgZh_dirZrc_dirr rH Zrc_fileargsr r r! compileT sn
zMSVCCompiler.compilec C s | j s| j | j||\}}| j||d}| j||r|d| g }|rJy,tjd| jdj| | j | jg| W q t
k
r } zt |W Y d d }~X qX n tjd| d S )N)r z/OUT:zExecuting "%s" %s zskipping %s (up-to-date)) rd r _fix_object_argslibrary_filename
_need_linkr r ri r. r r r ) re r Zoutput_libnamer r target_langoutput_filenameZlib_argsr r r r! create_static_lib s z MSVCCompiler.create_static_libc C s | j s| j | j||\}}| j|||}|\}}}|rL| jdt| t| |||}|d k rptjj ||}| j
||r| j || f }dd |pg D }|| | | d| g }tjj |d } |d k r tjj
tjj|\}}tjj | | j|}|jd| |
r |
|d d< | r.|j| tjj tjj|}| j| y6tjd| jdj | | j| jg| | j| W n, tk
r } zt|W Y d d }~X nX n tjd | d S )
Nz5I don't know what to do with 'runtime_library_dirs': c S s g | ] }d | qS )z/EXPORT:r )r) Zsymr r r!
s z%MSVCCompiler.link..z/OUT:r z/IMPLIB:zExecuting "%s" %sr zskipping %s (up-to-date))rd r r Z
_fix_lib_argswarnstrr r r r. r r~ r r r r r| r# r\ Zmkpathr r ru r _copy_vcruntimer r )re Z target_descr r r Z librariesZ library_dirsZruntime_library_dirsZexport_symbolsr r r Z
build_tempr Z
fixed_argsZlib_optsr Z export_optsZld_argsZdll_nameZdll_extZ implib_filer r r r! link sN
zMSVCCompiler.linkc C s` | j }| stjj| r d S tjj|j tkr6d S tjd| t j
||}tj |t j
d S )Nz Copying "%s")rx r r r= r rB
_BUNDLED_DLLSr r shutilcopychmodstatS_IWRITE)re r r? r r r! r s z MSVCCompiler._copy_vcruntimec s4 t jd}z| jt jd< t j|S |t jd< X d S )Nr )r rM rs rN superr )re rU Zold_path) __class__r r! r s
zMSVCCompiler.spawnc C s d| S )Nz /LIBPATH:r )re r r r r! library_dir_option& s z MSVCCompiler.library_dir_optionc C s t dd S )Nz:don't know how to set runtime library search path for MSVC)r )re r r r r! runtime_library_dir_option) s z'MSVCCompiler.runtime_library_dir_optionc C s
| j |S )N)r )re ri r r r! library_option- s zMSVCCompiler.library_optionc C s` |r|d |g}n|g}xB|D ]6}x0|D ](}t jj|| j|}t jj|r(|S q(W q W d S d S )NZ_d)r r r. r r= )re dirsri r Z try_namesr r3 Zlibfiler r r! find_library_file0 s
z MSVCCompiler.find_library_file)r r r )N)r rg )NNNr NNN)Nr N)
NNNNNr NNNN)r ) __name__
__module__ __qualname____doc__Z
compiler_typeZ executablesr r r r r r r Zstatic_lib_extensionZshared_lib_extensionZstatic_lib_formatZshared_lib_formatZ
exe_extensionrb r r r r r r r r r r r
__classcell__r r )r r! ra sN
T
[
9 ra )N) r r r r rP r Zdistutils.errorsr r r r r Zdistutils.ccompilerr r Z distutilsr Zdistutils.utilr
itertoolsr r" r4 rA rZ r` rq frozensetr ra r r r r! s& !"
PK ! f $ __pycache__/file_util.cpython-36.pycnu [ 3
\ @ sZ d Z ddlZddlmZ ddlmZ ddddZdd d ZdddZdddZ dd Z
dS )zFdistutils.file_util
Utility functions for operating on single files.
N)DistutilsFileError)logZcopyingz hard linkingzsymbolically linking)Nhardsym i c N C s d}d}zvyt | d}W n4 tk
rN } ztd| |jf W Y dd}~X nX tjj|rytj| W n4 tk
r } ztd||jf W Y dd}~X nX yt |d}W n4 tk
r } ztd||jf W Y dd}~X nX xy|j|}W n6 tk
r* } ztd| |jf W Y dd}~X nX |s4P y|j | W q tk
rx } ztd||jf W Y dd}~X qX qW W d|r|j
|r|j
X dS ) a5 Copy the file 'src' to 'dst'; both must be filenames. Any error
opening either file, reading from 'src', or writing to 'dst', raises
DistutilsFileError. Data is read/written in chunks of 'buffer_size'
bytes (default 16k). No attempt is made to handle anything apart from
regular files.
Nrbzcould not open '%s': %szcould not delete '%s': %swbzcould not create '%s': %sz could not read from '%s': %szcould not write to '%s': %s) openOSErrorr strerrorospathexistsunlinkreadwriteclose)srcdst buffer_sizeZfsrcZfdsteZbuf r +/usr/lib64/python3.6/distutils/file_util.py_copy_file_contents sF $ """*r c C s ddl m} ddlm} m}
m} m} tjj | s %sr r ) Zdistutils.dep_utilr statr r r r r r
isfiler isdirjoinbasenamedirnamer debug _copy_actionKeyError
ValueErrorinfor samefilelinkr
symlinkr utimechmod)r r Z
preserve_modeZpreserve_timesupdater, verbosedry_runr r r r r diractionstr r r copy_fileC sT !
r6 c ( C s ddl m}m}m}m}m} ddl} |dkr:tjd| | |rB|S || sVt d| ||rrt
j j ||| }n||rt d| |f |||st d| |f d }
yt
j
| | W nP tk
r
} z2| j\} }
| | jkrd
}
nt d | ||
f W Y dd} ~ X nX |
rt| ||d yt
j| W nh tk
r } zJ| j\} }
yt
j| W n tk
rp Y nX t d
| || |
f W Y dd} ~ X nX |S )a% Move a file 'src' to 'dst'. If 'dst' is a directory, the file will
be moved into it with the same name; otherwise, 'src' is just renamed
to 'dst'. Return the new full name of the file.
Handles cross-device moves on Unix using 'copy_file()'. What about
other systems???
r )r r! r" r$ r% Nr zmoving %s -> %sz#can't move '%s': not a regular filez0can't move '%s': destination '%s' already existsz2can't move '%s': destination '%s' not a valid pathFTz couldn't move '%s' to '%s': %s)r1 zAcouldn't move '%s' to '%s' by copy/delete: delete '%s' failed: %s)Zos.pathr r! r" r$ r% errnor r* r r r
r# renamer
argsZEXDEVr6 r )r r r1 r2 r r! r" r$ r% r7 Zcopy_itr Znummsgr r r move_file sR
"
"r; c
C s: t | d}z x|D ]}|j|d qW W d|j X dS )z{Create a file with the specified name and write 'contents' (a
sequence of strings without line terminators) to it.
w
N)r r r )filenamecontentsfliner r r
write_file s
rB @ )rC )r r r Nr r )r r ) __doc__r Zdistutils.errorsr Z distutilsr r' r r6 r; rB r r r r s
3
c
=PK ! EC C . __pycache__/msvc9compiler.cpython-36.opt-1.pycnu [ 3
\w @ sT d Z ddlZddlZddlZddlZddlmZmZmZm Z m
Z
ddl m Z m
Z
mZ ddlmZ ddlmZ ddlZejZejZejZejZej ej ej ej fZ ej!dkoej"d&kZ#e#rd
Z$d Z%d Z&n d
Z$dZ%dZ&ddddZ'G dd dZ(G dd dZ)dd Z*dd Z+d d Z,d d Z-d'd d!Z.e* Z/e/d"k r@ed#e/ G d$d% d%e Z0dS )(a distutils.msvc9compiler
Contains MSVCCompiler, an implementation of the abstract CCompiler class
for the Microsoft Visual Studio 2008.
The module is compatible with VS 2005 and VS 2008. You can find legacy support
for older versions of VS in distutils.msvccompiler.
N)DistutilsExecErrorDistutilsPlatformError CompileErrorLibError LinkError) CCompilergen_preprocess_optionsgen_lib_options)log) get_platformwin32 z1Software\Wow6432Node\Microsoft\VisualStudio\%0.1fz5Software\Wow6432Node\Microsoft\Microsoft SDKs\Windowsz,Software\Wow6432Node\Microsoft\.NETFrameworkz%Software\Microsoft\VisualStudio\%0.1fz)Software\Microsoft\Microsoft SDKs\Windowsz Software\Microsoft\.NETFrameworkx86amd64Zia64)r z win-amd64zwin-ia64c @ sP e Zd ZdZdd ZeeZdd ZeeZdd ZeeZdd Ze eZd
S ) Regz2Helper class to read values from the registry
c C s: x,t D ]$}| j||}|r||kr|| S qW t|d S )N)HKEYS read_valuesKeyError)clspathkeybased r //usr/lib64/python3.6/distutils/msvc9compiler.py get_valueA s
z
Reg.get_valuec C sn yt ||}W n tk
r" dS X g }d}x z$(FrameworkVersion))
r@ r; NET_BASEr r WINSDK_BASEr r r r r r r9 )r= r> pr hr r r r r r< s.
zMacroExpander.load_macrosc C s( x"| j j D ]\}}|j||}q W |S )N)r9 itemsreplace)r= r1 r% vr r r sub s zMacroExpander.subN)r2 r3 r4 r? r@ r< rI r r r r r8 { s r8 c C s d} t jj| }|d kr dS |t| }t j|d jdd\}}t|dd d }|dkrf|d7 }t|dd d }|dkrd
}|dkr|| S dS )
zReturn the version of MSVC that was used to build Python.
For Python 2.3 and up, the version number is included in
sys.version. For earlier versions, assume the compiler is MSVC 6.
zMSC v.r N r
g $@r )sysr> findlensplitint)prefixr$ r1 restZ majorVersionZ minorVersionr r r get_build_version s rW c C s4 g }x*| D ]"}t jj|}||kr
|j| q
W |S )znReturn a list of normalized paths with duplicates removed.
The current order of paths is maintained.
)osr normpathr! )pathsZ
reduced_pathsrD Znpr r r normalize_and_reduce_paths s
r[ c C s@ | j tj}g }x |D ]}||kr|j| qW tjj|}|S )z8Remove duplicate values of an environment variable.
)rS rX pathsepr! join)ZvariableZoldListZnewListr$ Z newVariabler r r removeDuplicates s
r^ c
C s t | }ytjd| d}W n" tk
r> tjd d}Y nX | sTtjj| rd| }tj j
|d}|rtjj|rtjj |tj tj d}tjj
|}tjj|stjd| dS ntjd| |stjd dS tjj |d
}tjj|r|S tjd dS ) zFind the vcvarsall.bat file
At first it tries to find the productdir of VS 2008 in the registry. If
that fails it falls back to the VS90COMNTOOLS env var.
z %s\Setup\VCrA z%Unable to find productdir in registryNzVS%0.f0COMNTOOLSZVCz%s is not a valid directoryz Env var %s is not set or invalidzNo productdir foundz
vcvarsall.batz Unable to find vcvarsall.bat)r: r r r r
debugrX r isdirenvirongetr] pardirabspathisfile)r> r; rA ZtoolskeyZtoolsdir vcvarsallr r r find_vcvarsall s2
rg c C s8 t | }td}i }|dkr$tdtjd|| tjd||f tjtjd }z|j \}}|j d
krvt|j
d |j
d }xr|j d D ]d}t j
|}d
|krq|j }|j d
d\} }
| j } | |kr|
jtjr|
dd }
t|
|| < qW W d|jj |jj X t|t|kr4ttt|j |S )zDLaunch vcvarsall.bat and read the settings from its environment
includeliblibpathr Nz Unable to find vcvarsall.batz'Calling 'vcvarsall.bat %s' (version=%s)z
"%s" %s & set)stdoutstderrr r.
=r )rh ri rj r rN ) rg setr r
r_
subprocessPopenPIPEZ communicatewaitr- rS r r) stripr( endswithrX r\ r^ rk closerl rR
ValueErrorstrlistkeys) r> Zarchrf Z interestingresultpopenrk rl liner r+ r r r query_vcvarsall s<
r~ g @z(VC %0.1f is not supported by this modulec
@ s e Zd ZdZdZi ZdgZdddgZdgZdgZ ee e e Z
d Z d
Z d Z
d Zd
ZZdZd.ddZd/ddZd0ddZd1ddZd2ddZd3d d Zd d Zd d! Zd"d# Zd$d% Zd&d' Z d(d) Z d4d*d+Z d,d- Z dS )5 MSVCCompilerzwConcrete class that implements an interface to Microsoft Visual C++,
as defined by the CCompiler abstract class.Zmsvcz.cz.ccz.cppz.cxxz.rcz.mcz.resz.objz.libz.dllz%s%sz.exer c C s8 t j| ||| t| _d| _g | _d | _d | _d| _d S )Nz Software\Microsoft\VisualStudioF) r r? VERSION_MSVCCompiler__versionZ_MSVCCompiler__root_MSVCCompiler__paths plat_name_MSVCCompiler__arch initialized)r= verboseZdry_runZforcer r r r? J s zMSVCCompiler.__init__Nc C s |d krt }d$}||kr(td|f dtjkrfdtjkrf| jdrfd| _d| _d | _d
| _d | _ n|t ksx|dkrt
| }nt
t d t
| }t t |}|d
j
tj| _|d tjd< |d tjd< t| jdkrtd| j | jd| _| jd| _| jd | _| jd
| _| jd | _ y,x&tjd
j
dD ]}| jj| q|| j
kr>|}d| }y"| j| jg| |g |g W qh tk
r8 } zt|W Y d d }~X qhX qhn|| jkr tj j|}tj j|}yl| j| jgd|d|g |g tj jtj j|\}}tj j||d }| j| jgd| g |g W qh tk
r } zt|W Y d d }~X qhX qhntd||f d | }y&| j| jg|
| ||g | W qh tk
rj } zt|W Y d d }~X qhX qhW |
S )
Nz/cz/Tcz/Tpz/foz-hz-rz.rcz"Don't know how to compile %s to %sz/Fo)r r Z_setup_compiler! extendr r r rX r rd
_c_extensions_cpp_extensionsr spawnr r r r dirnamer r r r] r )r= Zsourcesr r9 Z include_dirsr_
extra_preargsextra_postargsZdependsZ compile_infoobjectsZpp_optsZbuildZ compile_optsobjsrcr Z input_optZ
output_optmsgZh_dirZrc_dirr r Zrc_filer r r compile sj
zMSVCCompiler.compilec C s | j s| j | j||\}}| j||d}| j||r|d| g }|rJy| j| jg| W q tk
r } zt|W Y d d }~X qX n t j
d| d S )N)r z/OUT:zskipping %s (up-to-date)) r r _fix_object_argslibrary_filename
_need_linkr ri r r r
r_ ) r= r Zoutput_libnamer r_ target_langoutput_filenameZlib_argsr r r r create_static_lib s z MSVCCompiler.create_static_libc C sX | j s| j | j||\}}| j|||}|\}}}|rL| jdt| t| |||}|d k rptjj ||}| j
||rH|t j kr| r| j
dd }q| jdd }n| r| j
}n| j}g }x |pg D ]}|jd| qW || | | d| g }tjj|d } |d k rPtjjtjj|\}}tjj | | j|}|jd| | j|| | |
rp|
|d d< | r|j| | jtjj| y| j| jg| W n, tk
r } zt|W Y d d }~X nX | j||}|d k rT|\}}d||f }y| jdd d
||g W n, tk
rD } zt|W Y d d }~X nX n t j d | d S ) Nz5I don't know what to do with 'runtime_library_dirs': r z/EXPORT:z/OUT:r z/IMPLIB:z-outputresource:%s;%szmt.exez-nologoz -manifestzskipping %s (up-to-date)) r r r Z
_fix_lib_argswarnrx r rX r r] r r
EXECUTABLEr r r! r r r r manifest_setup_ldargsr Zmkpathr r r r manifest_get_embed_infor
r_ ) r= target_descr r r Z librariesZ library_dirsZruntime_library_dirsZexport_symbolsr_ r r
build_tempr Z
fixed_argsZlib_optsZldflagsZ export_optsZsymld_argsZdll_nameZdll_extZ implib_filer ZmfinfoZ
mffilenamemfidZout_argr r r link8 sl
zMSVCCompiler.linkc C s, t jj|t jj|d }|jd| d S )Nz .manifestz/MANIFESTFILE:)rX r r] r r! )r= r r r
temp_manifestr r r r s z"MSVCCompiler.manifest_setup_ldargsc C s` x,|D ] }|j dr|jddd }P qW d S |tjkr>d}nd}| j|}|d krXd S ||fS )Nz/MANIFESTFILE::r r
)
startswithrS r r _remove_visual_c_ref)r= r r argr r r r r r s
z$MSVCCompiler.manifest_get_embed_infoc C s yt |}z |j }W d |j X tjdtj}tj|d|}d}tj|d|}tjdtj}tj||d krrd S t |d}z|j| |S |j X W n t k
r Y nX d S )NzU|)r z*\s*zI|)w)
openreadrv rer DOTALLrI searchwriteOSError)r= Z
manifest_fileZ
manifest_fZ manifest_bufpatternr r r r s.
z!MSVCCompiler._remove_visual_c_refc C s d| S )Nz /LIBPATH:r )r= dirr r r library_dir_option s z MSVCCompiler.library_dir_optionc C s t dd S )Nztjd jdD ]*}tjjtjj||}tjj|rH|S qHW |S )a Return path to an MSVC executable program.
Tries to find the program in several places: first, one of the
MSVC program search paths from the registry; next, the directories
in the PATH environment variable. If any of those work, return an
absolute path that is known to exist. If none of them work, just
return the original program name, 'exe'.
ZPathr )r rX r r] rd re ra rS )r= ZexerD fnr r r r s zMSVCCompiler.find_exe)r r r )N)r r )NNNr NNN)Nr N)
NNNNNr NNNN)r ) r2 r3 r4 r5 Z
compiler_typeZ executablesr r r r r r r Zstatic_lib_extensionZshared_lib_extensionZstatic_lib_formatZshared_lib_formatZ
exe_extensionr? r r r r r r r r r r r r r r r r r r , sR
X
V
R +
r l )r )1r5 rX rp rP r Zdistutils.errorsr r r r r Zdistutils.ccompilerr r r Z distutilsr
Zdistutils.utilr winregZ OpenKeyExr ZEnumKeyr Z EnumValuer' errorr Z
HKEY_USERSHKEY_CURRENT_USERHKEY_LOCAL_MACHINEZHKEY_CLASSES_ROOTr platformmaxsizeZ NATIVE_WIN64r: rC rB r r r8 rW r[ r^ rg r~ r r r r r r sN >. #
)
PK ! *& ( __pycache__/version.cpython-36.opt-1.pycnu [ 3
\90 @ s> d Z ddlZG dd dZG dd deZG dd deZdS ) a Provides classes to represent module version numbers (one class for
each style of version numbering). There are currently two such classes
implemented: StrictVersion and LooseVersion.
Every version number class implements the following interface:
* the 'parse' method takes a string and parses it to some internal
representation; if the string is an invalid version number,
'parse' raises a ValueError exception
* the class constructor takes an optional string argument which,
if supplied, is passed to 'parse'
* __str__ reconstructs the string that was passed to 'parse' (or
an equivalent string -- ie. one that will generate an equivalent
version number instance)
* __repr__ generates Python code to recreate the version number instance
* _cmp compares the current instance with either another instance
of the same class or a string (which will be parsed to an instance
of the same class, thus must follow the same rules)
Nc @ sJ e Zd ZdZdddZdd Zdd Zd d
Zd d Zd
d Z dd Z
dS )VersionzAbstract base class for version numbering classes. Just provides
constructor (__init__) and reproducer (__repr__), because those
seem to be the same for all version numbering classes; and route
rich comparisons to _cmp.
Nc C s |r| j | d S )N)parse)selfvstring r )/usr/lib64/python3.6/distutils/version.py__init__& s zVersion.__init__c C s d| j jt| f S )Nz %s ('%s')) __class____name__str)r r r r __repr__* s zVersion.__repr__c C s | j |}|tkr|S |dkS )Nr )_cmpNotImplemented)r othercr r r __eq__- s
zVersion.__eq__c C s | j |}|tkr|S |dk S )Nr )r
r )r r r r r r __lt__3 s
zVersion.__lt__c C s | j |}|tkr|S |dkS )Nr )r
r )r r r r r r __le__9 s
zVersion.__le__c C s | j |}|tkr|S |dkS )Nr )r
r )r r r r r r __gt__? s
zVersion.__gt__c C s | j |}|tkr|S |dkS )Nr )r
r )r r r r r r __ge__E s
zVersion.__ge__)N) r
__module__ __qualname____doc__r r r r r r r r r r r r s
r c @ s< e Zd ZdZejdejejB Zdd Z dd Z
dd Z d S )
StrictVersiona? Version numbering for anal retentives and software idealists.
Implements the standard interface for version number classes as
described above. A version number consists of two or three
dot-separated numeric components, with an optional "pre-release" tag
on the end. The pre-release tag consists of the letter 'a' or 'b'
followed by a number. If the numeric components of two version
numbers are equal, then one with a pre-release tag will always
be deemed earlier (lesser) than one without.
The following are valid version numbers (shown in the order that
would be obtained by sorting according to the supplied cmp function):
0.4 0.4.0 (these two are equivalent)
0.4.1
0.5a1
0.5b3
0.5
0.9.6
1.0
1.0.4a3
1.0.4b1
1.0.4
The following are examples of invalid version numbers:
1
2.7.2.2
1.3.a4
1.3pl1
1.3c4
The rationale for this version numbering system will be explained
in the distutils documentation.
z)^(\d+) \. (\d+) (\. (\d+))? ([ab](\d+))?$c C s | j j|}|s td| |jddddd\}}}}}|rTttt|||g| _nttt||gd | _|r|d t|f| _nd | _d S ) Nzinvalid version number '%s' r )r )
version_rematch
ValueErrorgrouptuplemapintversion
prerelease)r r r majorminorZpatchr' Zprerelease_numr r r r s zStrictVersion.parsec C sb | j d dkr*djtt| j dd }ndjtt| j }| jr^|| jd t| jd }|S )Nr r .r )r& joinr$ r r' )r r r r r __str__ s zStrictVersion.__str__c C s t |trt|}| j|jkr2| j|jk r.dS dS | j rF|j rFdS | jrX|j rXdS | j rj|jrjdS | jr|jr| j|jkrdS | j|jk rdS dS n d S )Nr r r- r- )
isinstancer r r& r' )r r r r r r
s&
zStrictVersion._cmpN) r
r r r recompileVERBOSEASCIIr r r, r
r r r r r ] s #
r c @ sH e Zd ZdZejdejZdddZdd Z dd Z
d
d Z d d
Z dS ) LooseVersiona Version numbering for anarchists and software realists.
Implements the standard interface for version number classes as
described above. A version number consists of a series of numbers,
separated by either periods or strings of letters. When comparing
version numbers, the numeric components will be compared
numerically, and the alphabetic components lexically. The following
are all valid version numbers, in no particular order:
1.5.1
1.5.2b2
161
3.10a
8.02
3.4j
1996.07.12
3.2.pl0
3.1.1.6
2g6
11g
0.960923
2.2beta29
1.13++
5.5.kw
2.0b1pl0
In fact, there is no such thing as an invalid version number under
this scheme; the rules for comparison are simple and predictable,
but may not always give the results you want (for some definition
of "want").
z(\d+ | [a-z]+ | \.)Nc C s |r| j | d S )N)r )r r r r r r . s zLooseVersion.__init__c C sb || _ dd | jj|D }x:t|D ].\}}yt|||< W q& tk
rR Y q&X q&W || _d S )Nc S s g | ]}|r|d kr|qS )r* r ).0xr r r
8 s z&LooseVersion.parse..)r component_resplit enumerater% r! r& )r r Z
componentsiobjr r r r 3 s
zLooseVersion.parsec C s | j S )N)r )r r r r r, C s zLooseVersion.__str__c C s dt | S )NzLooseVersion ('%s'))r )r r r r r G s zLooseVersion.__repr__c C sF t |trt|}| j|jkr"dS | j|jk r2dS | j|jkrBdS d S )Nr r r- )r. r r3 r& )r r r r r r
K s
zLooseVersion._cmp)N)
r
r r r r/ r0 r1 r7 r r r, r r
r r r r r3 s
r3 )r r/ r r r3 r r r r s
> /PK ! 6b b ' __pycache__/errors.cpython-36.opt-1.pycnu [ 3
\
@ s8 d Z G dd deZG dd deZG dd deZG dd deZG d d
d
eZG d d d eZG d
d deZG dd deZ G dd deZ
G dd deZ G dd deZ G dd deZ
G dd deZG dd d eZG d d d eZG d d d eZG d!d" d"eZG d#d$ d$eZG d%d& d&eZd'S )(a distutils.errors
Provides exceptions used by the Distutils modules. Note that Distutils
modules may raise standard exceptions; in particular, SystemExit is
usually raised for errors that are obviously the end-user's fault
(eg. bad command-line arguments).
This module is safe to use in "from ... import *" mode; it only exports
symbols whose names start with "Distutils" and end with "Error".c @ s e Zd ZdZdS )DistutilsErrorz The root of all Distutils evil.N)__name__
__module__ __qualname____doc__ r r (/usr/lib64/python3.6/distutils/errors.pyr s r c @ s e Zd ZdZdS )DistutilsModuleErrorzUnable to load an expected module, or to find an expected class
within some module (in particular, command modules and classes).N)r r r r r r r r r s r c @ s e Zd ZdZdS )DistutilsClassErrorzSome command class (or possibly distribution class, if anyone
feels a need to subclass Distribution) is found not to be holding
up its end of the bargain, ie. implementing some part of the
"command "interface.N)r r r r r r r r r s r c @ s e Zd ZdZdS )DistutilsGetoptErrorz7The option table provided to 'fancy_getopt()' is bogus.N)r r r r r r r r r
s r
c @ s e Zd ZdZdS )DistutilsArgErrorzaRaised by fancy_getopt in response to getopt.error -- ie. an
error in the command line usage.N)r r r r r r r r r s r c @ s e Zd ZdZdS )DistutilsFileErrorzAny problems in the filesystem: expected file not found, etc.
Typically this is for problems that we detect before OSError
could be raised.N)r r r r r r r r r $ s r c @ s e Zd ZdZdS )DistutilsOptionErrora Syntactic/semantic errors in command options, such as use of
mutually conflicting options, or inconsistent options,
badly-spelled values, etc. No distinction is made between option
values originating in the setup script, the command line, config
files, or what-have-you -- but if we *know* something originated in
the setup script, we'll raise DistutilsSetupError instead.N)r r r r r r r r r
* s r
c @ s e Zd ZdZdS )DistutilsSetupErrorzqFor errors that can be definitely blamed on the setup script,
such as invalid keyword arguments to 'setup()'.N)r r r r r r r r r 3 s r c @ s e Zd ZdZdS )DistutilsPlatformErrorzWe don't know how to do something on the current platform (but
we do know how to do it on some platform) -- eg. trying to compile
C files on a platform not supported by a CCompiler subclass.N)r r r r r r r r r 8 s r c @ s e Zd ZdZdS )DistutilsExecErrorz`Any problems executing an external program (such as the C
compiler, when compiling C files).N)r r r r r r r r r > s r c @ s e Zd ZdZdS )DistutilsInternalErrorzoInternal inconsistencies or impossibilities (obviously, this
should never be seen if the code is working!).N)r r r r r r r r r C s r c @ s e Zd ZdZdS )DistutilsTemplateErrorz%Syntax error in a file list template.N)r r r r r r r r r H s r c @ s e Zd ZdZdS )DistutilsByteCompileErrorzByte compile error.N)r r r r r r r r r K s r c @ s e Zd ZdZdS )CCompilerErrorz#Some compile/link operation failed.N)r r r r r r r r r O s r c @ s e Zd ZdZdS )PreprocessErrorz.Failure to preprocess one or more C/C++ files.N)r r r r r r r r r R s r c @ s e Zd ZdZdS ) CompileErrorz2Failure to compile one or more C/C++ source files.N)r r r r r r r r r U s r c @ s e Zd ZdZdS )LibErrorzKFailure to create a static library from one or more C/C++ object
files.N)r r r r r r r r r X s r c @ s e Zd ZdZdS ) LinkErrorz]Failure to link one or more C/C++ object files into an executable
or shared library file.N)r r r r r r r r r \ s r c @ s e Zd ZdZdS )UnknownFileErrorz(Attempt to process an unknown file type.N)r r r r r r r r r ` s r N)r Exceptionr r r r
r r r
r r r r r r r r r r r r r r r r s& PK ! DA8 8 - __pycache__/msvccompiler.cpython-36.opt-1.pycnu [ 3
\\ @ s d Z ddlZddlZddlmZmZmZmZmZ ddl m
Z
m Z m Z ddl
mZ dZy,ddlZdZeZejZejZejZejZW nh ek
r y4ddlZddl Z dZe ZejZejZejZejZW n ek
r ej d Y nX Y nX erej ej ej ej!fZ"d d
Z#d d Z$d
d Z%G dd dZ&dd Z'dd Z(dd Z)G dd de
Z*e' dkrej+d e*Z,ddl-m*Z* dd l-m&Z& dS ) zdistutils.msvccompiler
Contains MSVCCompiler, an implementation of the abstract CCompiler class
for the Microsoft Visual Studio.
N)DistutilsExecErrorDistutilsPlatformError CompileErrorLibError LinkError) CCompilergen_preprocess_optionsgen_lib_options)logFTzWarning: Can't read registry to find the necessary compiler setting
Make sure that Python modules winreg, win32api or win32con are installed.c C sn yt | |}W n tk
r" dS X g }d}x|| j
kr>|}d| }y"| j| jg| |g |g W qh tk
r8 } zt|W Y d d }~X qhX qhn|| jkr tj j|}tj j|}yl| j| jgd|d|g |g tj jtj j|\}}tj j||d }| j| jgd| g |g W qh tk
r } zt|W Y d d }~X qhX qhntd||f d | }y&| j| jg|
| ||g | W qh tk
rj } zt|W Y d d }~X qhX qhW |
S )
Nz/cz/Tcz/Tpz/foz-hz-rz.rcz"Don't know how to compile %s to %sz/Fo)rX rk Z_setup_compiler extendrh rg r/ rM r- abspath
_c_extensions_cpp_extensionsrr spawnrb r r rt dirnamerc rm rq rf r` )r) Zsourcesrv r' Z include_dirsdebug
extra_preargsextra_postargsZdependsZ compile_infoobjectsZpp_optsZbuildZ compile_optsobjsrcrw Z input_optZ
output_optmsgZh_dirZrc_dirr _Zrc_filer r r compileW sj
zMSVCCompiler.compilec C s | j s| j | j||\}}| j||d}| j||r|d| g }|rJy| j| jg| W q tk
r } zt|W Y d d }~X qX n t j
d| d S )N)rv z/OUT:zskipping %s (up-to-date)) rX rk _fix_object_argslibrary_filename
_need_linkr} rZ r r r
r ) r) r Zoutput_libnamerv r target_langoutput_filenameZlib_argsr r r r create_static_lib s z MSVCCompiler.create_static_libc C s | j s| j | j||\}}| j|||}|\}}}|rL| jdt| t| |||}|d k rptjj ||}| j
||r|t j kr| r| j
dd }q| jdd }n| r| j
}n| j}g }x |pg D ]}|jd| qW || | | d| g }|d k rLtjjtjj|\}}tjj tjj|d | j|}|jd| |
r^|
|d d< | rn|j| | jtjj| y| j| jg| W n, tk
r } zt|W Y d d }~X nX n tjd| d S )Nz5I don't know what to do with 'runtime_library_dirs': r z/EXPORT:z/OUT:r z/IMPLIB:zskipping %s (up-to-date)) rX rk r Z
_fix_lib_argswarnstrr rM r- rf r r Z
EXECUTABLErj ri r rm rq r~ r ry Zmkpathr} ra r r r
r )r) Z target_descr r rv Z librariesZ library_dirsZruntime_library_dirsZexport_symbolsr r r Z
build_tempr Z
fixed_argsZlib_optsZldflagsZ export_optsZsymZld_argsZdll_nameZdll_extZ implib_filer r r r link sV
zMSVCCompiler.linkc C s d| S )Nz /LIBPATH:r )r) dirr r r library_dir_option s z MSVCCompiler.library_dir_optionc C s t dd S )Nztjd jdD ]*}tjjtjj||}tjj|rH|S qHW |S )a Return path to an MSVC executable program.
Tries to find the program in several places: first, one of the
MSVC program search paths from the registry; next, the directories
in the PATH environment variable. If any of those work, return an
absolute path that is known to exist. If none of them work, just
return the original program name, 'exe'.
ZPathr\ )r] rM r- rf rz isfiler^ rD )r) Zexer1 fnr r r r_ 5 s zMSVCCompiler.find_exex86c C s t sg S |d }| jdkr,d| j| jf }nd| j|f }xHtD ]@}t||}|r@| jdkrr| jj|| jdS || jdS q@W | jdkrx,tD ]$}t|d| j dk r| jd P qW g S )
zGet a list of devstudio directories (include, lib or path).
Return a list of strings. The list will be empty if unable to
access the registry or appropriate registry keys not found.
z dirsrR z6%s\%0.1f\VC\VC_OBJECTS_PLATFORM_INFO\Win32\Directoriesz?%s\6.0\Build System\Components\Platforms\Win32 (%s)\Directoriesr\ r: z%s\6.0NzIt seems you have Visual Studio 6 installed, but the expected registry settings are not present.
You must at least run the Visual Studio GUI once so that these entries are created.)
_can_read_regrS rU r, r rV r6 rD r )r) r- platformr r r r r r rd K s(
zMSVCCompiler.get_msvc_pathsc C s6 |dkr| j d}n
| j |}|r2dj|tj|< dS )zSet environment variable 'name' to an MSVC path type value.
This is equivalent to a SET command prior to execution of spawned
commands.
rZ Zlibraryr\ N)rd rf rM r^ )r) r r1 r r r re o s
z MSVCCompiler.set_path_env_var)r r r )r rl )NNNr NNN)Nr N)
NNNNNr NNNN)r )r ) r7 r8 r9 __doc__Z
compiler_typeZ executablesr{ r| rr rt rp rs ru Zstatic_lib_extensionZshared_lib_extensionZstatic_lib_formatZshared_lib_formatZ
exe_extensionr+ rk rx r r r r r r r r_ rd re r r r r rQ sP
B
V
F
$rQ g @z3Importing new compiler from distutils.msvc9compiler)rQ )r& ).r rA rM Zdistutils.errorsr r r r r Zdistutils.ccompilerr r r Z distutilsr
r winregZhkey_modZ OpenKeyExr ZEnumKeyr Z EnumValuer errorr
ImportErrorZwin32apiZwin32coninfoZ
HKEY_USERSHKEY_CURRENT_USERHKEY_LOCAL_MACHINEZHKEY_CLASSES_ROOTr, r r r r& rH rL rP rQ r ZOldMSVCCompilerZdistutils.msvc9compilerr r r r s^
-
9
PK ! GPX
X
% __pycache__/core.cpython-36.opt-2.pycnu [ 3
\" @ s d dl Z d dlZd dlmZ d dlT d dlmZ d dlmZ d dl m
Z
d dl m Z dZ
d d
Zdadad3Zd4Zd.d/ Zd5d1d2ZdS )6 N)DEBUG)*) Distribution)Command)
PyPIRCCommand) Extensionzusage: %(script)s [global_opts] cmd1 [cmd1_opts] [cmd2 [cmd2_opts] ...]
or: %(script)s --help [cmd1 cmd2 ...]
or: %(script)s --help-commands
or: %(script)s cmd --help
c C s t jj| }tt S )N)ospathbasenameUSAGEvars) script_nameZscript r &/usr/lib64/python3.6/distutils/core.py gen_usage s r distclassr
script_argsoptionsnameversionauthor author_email
maintainermaintainer_emailurllicense descriptionlong_descriptionkeywords platforms classifiers download_urlrequiresprovides obsoletessources include_dirs
define_macros undef_macros library_dirs librariesruntime_library_dirs
extra_objectsextra_compile_argsextra_link_args swig_optsexport_symbolsdependslanguagec , K s | j d}|r| d= nt}d| kr8tjjtjd | d< d| krRtjdd | d< y|| a}W nL tk
r } z0d| krt d| nt d| d |f W Y d d }~X nX t
d kr|S |j t rt
d
|j t
d kr|S y |j }W n: tk
r* } z t t|jd | W Y d d }~X nX t rBt
d
|j t
dkrP|S |ry |j W n tk
r t dY n tk
r } z0t rtjjd|f nt d|f W Y d d }~X nB ttfk
r } z t r nt dt| W Y d d }~X nX |S )Nr r
r r r zerror in setup command: %sz error in %s setup command: %sinitz%options (after parsing config files):configz
error: %sz%options (after parsing command line): commandlineZ interruptedz
error: %s
z error: %szerror: )getr r r r
sysargv_setup_distributionZDistutilsSetupError
SystemExit_setup_stop_afterZparse_config_filesr printZdump_option_dictsZparse_command_lineZDistutilsArgErrorr r
Z run_commandsKeyboardInterruptOSErrorstderrwriteZDistutilsErrorZCCompilerErrorstr)ZattrsklassZdistmsgokexcr r r setup9 s` %
" (
"rG runc C s |d krt d|f |atjj }d| i}yZzH| tjd< |d k rP|tjdd < t| d }t|j | W d Q R X W d |t_d aX W n tk
r Y nX t d krt
d
| t S ) Nr4 r5 r6 rH z"invalid value for 'stop_after': %r__file__r r3 rbzZ'distutils.core.setup()' was never called -- perhaps '%s' is not a Distutils setup script?)r4 r5 r6 rH )
ValueErrorr< r8 r9 copyopenexecreadr; r: RuntimeError)r
r Z
stop_afterZ save_argvgfr r r run_setup s(
rS )r r
r r r r r r r r r r r r r r r r! r" r# r$ )r r% r& r' r( r) r* r+ r, r- r. r/ r0 r1 r2 )NrH )r r8 Zdistutils.debugr Zdistutils.errorsZdistutils.distr Z
distutils.cmdr Zdistutils.configr Zdistutils.extensionr r r r< r: Zsetup_keywordsZextension_keywordsrG rS r r r r s0 qPK ! yk ) __pycache__/__init__.cpython-36.opt-2.pycnu [ 3
\ @ s" d dl Z e jde jjd ZdS ) N )sysversionindex __version__ r r */usr/lib64/python3.6/distutils/__init__.py s PK ! (ߟ
' __pycache__/config.cpython-36.opt-1.pycnu [ 3
\ @ s< d Z ddlZddlmZ ddlmZ dZG dd deZdS )zdistutils.pypirc
Provides the PyPIRCCommand class, the base class for the command classes
that uses .pypirc in the distutils.command package.
N)RawConfigParser)CommandzE[distutils]
index-servers =
pypi
[pypi]
username:%s
password:%s
c @ sh e Zd ZdZdZdZdZdZddde fdgZdgZ d
d Z
d d
Z dd Z dd Z
dd Zdd ZdS )
PyPIRCCommandz;Base command that knows how to handle the .pypirc file
z https://upload.pypi.org/legacy/pypiNz repository=rz url of repository [default: %s]
show-response&display full response text from serverc C s t jjt jjddS )zReturns rc file path.~z.pypirc)ospathjoin
expanduser)self r (/usr/lib64/python3.6/distutils/config.py _get_rc_file& s zPyPIRCCommand._get_rc_filec C sH | j }tjtj|tjtjB dd}|jt||f W dQ R X dS )z Creates a default .pypirc file.i wN)r r
fdopenopenO_CREATO_WRONLYwriteDEFAULT_PYPIRC)r usernamepasswordrcfr r r
_store_pypirc* s zPyPIRCCommand._store_pypircc C s | j }tjj|r| jd| | jp.| j}| jp:| j}t }|j
| |j }d|krR|j dd}dd |j
dD }|g krd|krdg}ni S x|D ]}d|i} |j |d | d < xHd
| jfd | jfdfD ].\}
} |j||
r|j ||
| |
< q| | |
< qW |dkr.|| jdfkr.| j| d
< | S | d |ksH| d
|kr| S qW nRd|krd}|j|d
r||j |d
}n| j}|j |d |j |d ||| jdS i S )zReads the .pypirc file.zUsing PyPI login from %sZ distutilsz
index-serversc S s g | ]}|j d kr|j qS ) )strip).0serverr r r
> s z.PyPIRCCommand._read_pypirc..
r r! r
repositoryrealmr Nz server-login)r r r$ r! r% )r N)r r
r existsZannouncer$ DEFAULT_REPOSITORYr%
DEFAULT_REALMr readsectionsgetsplitZ
has_option) r r r$ r% configr* Z
index_serversZ_serversr! Zcurrentkeydefaultr r r _read_pypirc0 sX
zPyPIRCCommand._read_pypircc C s8 ddl }|jdd}|j|d jdd}|j j|S )z%Read and decode a PyPI HTTP response.r Nz content-typez
text/plain charsetascii)cgiZ getheaderZ parse_headerr+ r) decode)r Zresponser4 Z content_typeencodingr r r _read_pypi_responseq s z!PyPIRCCommand._read_pypi_responsec C s d| _ d| _d| _dS )zInitialize options.Nr )r$ r% Z
show_response)r r r r initialize_optionsx s z PyPIRCCommand.initialize_optionsc C s( | j dkr| j| _ | jdkr$| j| _dS )zFinalizes options.N)r$ r' r% r( )r r r r finalize_options~ s
z PyPIRCCommand.finalize_options)r Nr )__name__
__module__ __qualname____doc__r' r( r$ r% Z user_optionsZboolean_optionsr r r0 r7 r8 r9 r r r r r s" Ar )r= r
Z configparserr Z
distutils.cmdr r r r r r r s
PK ! nQ Q - __pycache__/bcppcompiler.cpython-36.opt-1.pycnu [ 3
\W: @ sx d Z ddlZddlmZmZmZmZmZmZ ddl m
Z
m Z m Z ddl
mZ ddlmZ ddlmZ G dd d e
ZdS )
zdistutils.bcppcompiler
Contains BorlandCCompiler, an implementation of the abstract CCompiler class
for the Borland C++ compiler.
N)DistutilsExecErrorDistutilsPlatformError CompileErrorLibError LinkErrorUnknownFileError) CCompilergen_preprocess_optionsgen_lib_options)
write_file)newer)logc
@ s e Zd ZdZdZi ZdgZdddgZee ZdZ dZ
d Z d
Z Z
d Zd d
dZd ddZd ddZd ddZd!ddZd"ddZd#dd ZdS )$ BCPPCompilerzConcrete class that implements an interface to the Borland C/C++
compiler, as defined by the CCompiler abstract class.
Zbcppz.cz.ccz.cppz.cxxz.objz.libz.dllz%s%sz.exer c C s t j| ||| d| _d| _d| _d | _ddddg| _ddddg| _d d
dd g| _d d
dd g| _ g | _
d
dd g| _ d
dd d g| _ d S )
Nz bcc32.exez ilink32.exeztlib.exez/tWMz/O2z/qz/g0z/Odz/Tpdz/Gnz/xz/r)
r __init__cclinkerlibZpreprocess_optionscompile_optionscompile_options_debugldflags_sharedldflags_shared_debugZldflags_static ldflags_exeldflags_exe_debug)selfverboseZdry_runforce r ./usr/lib64/python3.6/distutils/bcppcompiler.pyr 5 s zBCPPCompiler.__init__Nc C s | j ||||||\}} }}
} |p$g } | jd |rB| j| j n | j| j xD| D ]:}
y| |
\}}W n tk
r wVY nX tjj|}tjj|
}
| j tjj
|
|dkrqV|dkry| j dd|
|g W qV t k
r } zt
|W Y d d }~X qVX qV|| jkrd}n|| jkr,d}nd}d|
}y,| j | jg| |
||g | |g W qV t k
r } zt
|W Y d d }~X qVX qVW | S ) Nz-cz.resz.rcZbrcc32z-fo z-Pz-o)Z_setup_compileappendextendr r KeyErrorospathnormpathmkpathdirnamespawnr r
_c_extensions_cpp_extensionsr )r Zsources
output_dirmacros include_dirsdebug
extra_preargsextra_postargsZdependsobjectspp_optsZbuildZ compile_optsobjsrcextmsgZ input_optZ
output_optr r r compileQ sF
( zBCPPCompiler.compilec C s | j ||\}}| j||d}| j||r~|dg| }|r:y| j| jg| W q tk
rz } zt|W Y d d }~X qX n tjd| d S )N)r* z/uzskipping %s (up-to-date)) _fix_object_argslibrary_filename
_need_linkr' r r r r
r- ) r r0 Zoutput_libnamer* r- target_langoutput_filenameZlib_argsr5 r r r create_static_lib s z BCPPCompiler.create_static_libc C s | j ||\}}| j|||\}}}|r8tjdt| |d k rNtjj||}| j||r|t j
krd}| r~| j d d }q| j d d }n&d}| r| j
d d }n| jd d }|d krd}ntjj|\}}tjj|\}}tjj|d }tjj|d| }dg}x&|pg D ]}|jd||f qW | jt||fd | ttjj|}|g}g }xF|D ]>}tjjtjj|\}}|d
kr|j| n
|j| qfW x$|D ] } |jd tjj| qW |jd |j| |jd
|g |jd x<|D ]4} | j|| | } | d kr(|j| n
|j| q W |jd |jd |jd
|g |jd
|j| |
r|
|d d< | r|j| | jtjj| y| j| j g| W n, t k
r } zt | W Y d d } ~ X nX n tj d| d S )Nz7I don't know what to do with 'runtime_library_dirs': %sZc0w32Zc0d32r r z%s.defZEXPORTSz %s=_%sz
writing %sz.resz/L%sz/L.,z,,Zimport32Zcw32mtzskipping %s (up-to-date)) r7 Z
_fix_lib_argsr
warnstrr" r# joinr9 r Z
EXECUTABLEr r r r splitsplitextr& r Zexecuter mapr$ normcaser find_library_filer% r' r r r r- ) r Z target_descr0 r; r* Z librariesZ library_dirsZruntime_library_dirsZexport_symbolsr- r. r/ Z
build_tempr: Z startup_objZld_argsZdef_fileheadtailmodnamer4 Ztemp_dircontentsZsymZobjects2Z resourcesfilebaselr libfiler5 r r r link s|
zBCPPCompiler.linkc C sv |r"|d }|d |d ||f}n |d |f}xB|D ]6}x0|D ](}t jj|| j|}t jj|r>|S q>W q4W d S d S )NZ_dZ_bcpp)r" r# r@ r8 exists) r dirsr r- ZdlibZ try_namesdirnamerM r r r rE 4 s
z BCPPCompiler.find_library_filer c C s |d kr d}g }x|D ]}t jjt jj|\}}|| jddg krTtd||f |rdt jj|}|dkr|jt jj||| q|dkr|jt jj||d q|jt jj||| j qW |S )Nr z.rcz.resz"unknown file type '%s' (from '%s'))
r" r# rB rD src_extensionsr basenamer r@
obj_extension)r Zsource_filenamesZ strip_dirr* Z obj_namesZsrc_namerK r4 r r r object_filenamesN s"
z BCPPCompiler.object_filenamesc C s | j d ||\}}}t||}dg| } |d k r>| jd| |rN|| d d< |r\| j| | j| | js~|d ks~t||r|r| jtjj | y| j
| W n2 t k
r }
zt |
t
|
W Y d d }
~
X nX d S )Nz cpp32.exez-or )Z_fix_compile_argsr r r r r r% r" r# r& r' r printr ) r sourceZ output_filer+ r, r. r/ _r1 Zpp_argsr5 r r r
preprocessi s$
zBCPPCompiler.preprocess)r r r )NNNr NNN)Nr N)
NNNNNr NNNN)r )r r )NNNNN)__name__
__module__ __qualname____doc__Z
compiler_typeZ executablesr( r) rS rU Zstatic_lib_extensionZshared_lib_extensionZstatic_lib_formatZshared_lib_formatZ
exe_extensionr r6 r< rN rE rV rZ r r r r r sJ
B
|
r )r^ r" Zdistutils.errorsr r r r r r Zdistutils.ccompilerr r r
Zdistutils.file_utilr Zdistutils.dep_utilr Z distutilsr
r r r r r s
PK ! q) ) ' __pycache__/fancy_getopt.cpython-36.pycnu [ 3
\xE @ s d Z ddlZddlZddlZddlZddlT dZejde Zejdeef Z e
j ddZ G d d
d
Z
d d Zd
d ejD Zdd Zdd ZG dd dZedkrdZx2d D ]*Zede ed jeee e qW dS ) a6 distutils.fancy_getopt
Wrapper around the standard getopt module that provides the following
additional features:
* short and long options are tied together
* options have help strings, so fancy_getopt could potentially
create a complete usage summary
* options set attributes of a passed-in object
N)*z[a-zA-Z](?:[a-zA-Z0-9-]*)z^%s$z ^(%s)=!(%s)$-_c @ s e Zd ZdZd ddZdd Zdd Zd d d
Zd d Zd
d Z dd Z
dd Z dd Z dd Z
d!ddZdd Zd"dd Zd#d d ZdS )$ FancyGetopta Wrapper around the standard 'getopt()' module that provides some
handy extra functionality:
* short and long options are tied together
* options have help strings, and help text can be assembled
from them
* options set attributes of a passed-in object
* boolean options can have "negative aliases" -- eg. if
--quiet is the "negative alias" of --verbose, then "--quiet"
on the command line sets 'verbose' to false
Nc C sN || _ i | _| j r| j i | _i | _g | _g | _i | _i | _i | _ g | _
d S )N) option_table option_index _build_indexaliasnegative_alias
short_opts long_opts
short2long attr_name takes_arg option_order)selfr r ./usr/lib64/python3.6/distutils/fancy_getopt.py__init__) s zFancyGetopt.__init__c C s, | j j x | jD ]}|| j |d < qW d S )Nr )r clearr )r optionr r r r Q s
zFancyGetopt._build_indexc C s || _ | j d S )N)r r )r r r r r set_option_tableV s z FancyGetopt.set_option_tablec C s< || j krtd| n |||f}| jj| || j |< d S )Nz'option conflict: already an option '%s')r DistutilsGetoptErrorr append)r long_optionZ short_optionZ help_stringr r r r
add_optionZ s
zFancyGetopt.add_optionc C s
|| j kS )zcReturn true if the option table for this parser has an
option with long name 'long_option'.)r )r r r r r
has_optionc s zFancyGetopt.has_optionc C s
|j tS )zTranslate long option name 'long_option' to the form it
has as an attribute of some object: ie., translate hyphens
to underscores.) translate
longopt_xlate)r r r r r
get_attr_nameh s zFancyGetopt.get_attr_namec C s` t |tstxL|j D ]@\}}|| jkr= 2N z:invalid short option '%s': must a single character or None=:z>invalid negative alias '%s': aliased option '%s' takes a valuezginvalid alias '%s': inconsistent with aliased option '%s' (one of them takes a value, the other doesn'tzEinvalid long option name '%s' (must be letters, numbers, hyphens onlyr/ r/ )r r r
r repeatr len
ValueErrorr strr r r r
getr
longopt_rematchr r )r r longshorthelpr0 Zalias_tor r r _grok_option_table s^
z FancyGetopt._grok_option_tablec C s |dkrt jdd }|dkr*t }d}nd}| j dj| j}ytj||| j\}}W n, tjk
r } zt |W Y dd}~X nX x|D ]\}}t
|dkr|d dkr| j |d }n,t
|dkr|dd d kst |dd }| j
j|} | r| }| j| sB|d
ks"t d | jj|} | r>| }d}nd}| j| }
|rt| jj|
dk rtt||
dd }t||
| | jj||f qW |r||fS |S dS ) a Parse command-line options in args. Store as attributes on object.
If 'args' is None or not supplied, uses 'sys.argv[1:]'. If
'object' is None or not supplied, creates a new OptionDummy
object, stores option values there, and returns a tuple (args,
object). If 'object' is supplied, it is modified in place and
'getopt()' just returns 'args'; in both cases, the returned
'args' is a modified copy of the passed-in 'args' list, which
is left untouched.
Nr, TF r+ r r z-- z boolean option can't have value)sysargv OptionDummyr: joinr getoptr errorZDistutilsArgErrorr1 r
r" r r4 r r
r r0 getattrsetattrr r ) r argsobjectZcreated_objectr Zoptsmsgr% valr attrr r r rA sF
zFancyGetopt.getoptc C s | j dkrtdn| j S dS )zReturns the list of (option, value) tuples processed by the
previous run of 'getopt()'. Raises RuntimeError if
'getopt()' hasn't been called yet.
Nz!'getopt()' hasn't been called yet)r RuntimeError)r r r r get_option_order s
z FancyGetopt.get_option_orderc C sx d}xV| j D ]L}|d }|d }t|}|d dkr<|d }|dk rL|d }||kr |}q W |d d d }d}|| } d| }
|r|g} nd g} x| j D ]}|dd
\}}} t| | }
|d dkr|dd }|dkr|
r| jd |||
d f n| jd ||f n:d
||f }|
r<| jd |||
d f n| jd| x$|
dd D ]}| j|
| qXW qW | S )zGenerate help text (a list of strings, one per suggested line of
output) from the option table for this FancyGetopt object.
r r, r- N r+ N r; zOption summary:r) z --%-*s %sz
--%-*s z%s (-%s)z --%-*sr/ r/ r/ )r r1 wrap_textr )r headerZmax_optr r7 r8 lZ opt_widthZ
line_widthZ
text_widthZ
big_indentlinesr9 textZ opt_namesr r r
generate_help sF
zFancyGetopt.generate_helpc C s4 |d krt j}x | j|D ]}|j|d qW d S )N
)r= stdoutrS write)r rO fileliner r r
print_helph s zFancyGetopt.print_help)N)NN)NN)N)NN)__name__
__module__ __qualname____doc__r r r r r r r& r' r( r: rA rK rS rY r r r r r s
(
M
=
Or c C s t | }|j| |j||S )N)r r( rA )optionsZ negative_optrF rE parserr r r fancy_getopto s
r` c C s i | ]}d t |qS )r; )ord).0Z_wscharr r r
u s rc c C s" | dkr g S t | |kr | gS | j } | jt} tjd| }dd |D }g }x|r g }d}xZ|rt |d }|| |kr|j|d |d= || }q`|r|d d dkr|d
= P q`W |r
|dkr|j|d d| |d |d |d< |d d dkr
|d= |jdj| qPW |S ) zwrap_text(text : string, width : int) -> [string]
Split 'text' into multiple lines of no more than 'width' characters
each, and return the list of strings that results.
Nz( +|-+)c S s g | ] }|r|qS r r )rb Zchr r r
s z wrap_text..r r, r; r< r/ r/ )r1
expandtabsr WS_TRANSresplitr r@ )rR widthZchunksrQ Zcur_lineZcur_lenrP r r r rN w s:
rN c C s
| j tS )zXConvert a long option name to a valid Python identifier by
changing "-" to "_".
)r r )r% r r r translate_longopt s rj c @ s e Zd ZdZg fddZdS )r? z_Dummy class just used as a place to hold command-line option
values as instance attributes.c C s x|D ]}t | |d qW dS )zkCreate a new OptionDummy instance. The attributes listed in
'options' will be initialized to None.N)rD )r r^ r% r r r r s
zOptionDummy.__init__N)rZ r[ r\ r] r r r r r r? s r? __main__zTra-la-la, supercalifragilisticexpialidocious.
How *do* you spell that odd word, anyways?
(Someone ask Mary -- she'll know [or she'll
say, "How should I know?"].)
( z width: %drT )rl rm rn ro )r] r= stringrg rA Zdistutils.errorsZ longopt_patcompiler5 Z neg_alias_rer3 maketransr r r` Z
whitespacerf rN rj r? rZ rR wprintr@ r r r r s* T6
PK ! & __pycache__/debug.cpython-36.opt-1.pycnu [ 3
\ @ s d dl Z e jjdZdS ) NZDISTUTILS_DEBUG)osenvirongetDEBUG r r '/usr/lib64/python3.6/distutils/debug.py s PK ! D;^A A * __pycache__/ccompiler.cpython-36.opt-2.pycnu [ 3
\7 @ s d dl Z d dlZd dlZd dlT d dlmZ d dlmZ d dlm Z d dl
m Z m Z d dl
mZmZ d dlmZ G d d
d
Zd,Zd-ddZd.d/d0d1d2d Zd!d" Zd3d#d$Zd%d& Zd'd( ZdS )4 N)*)spawn) move_file)mkpath)newer_pairwise newer_group) split_quotedexecute)logc
@ s e Zd ZdZdZdZdZdZdZdZ dZ
ddddddZ dddgZ dpddZ
d d
Zd d Zd
d Zdd ZdqddZdd Zdd Zdd Zdd Zdd Zd d Zd d Zd!d" Zd#d$ Zd%d& Z d'd( Z d)d* Z d+d, Z d-d. Z drd/d0Z!d1d2 Z"d3d4 Z#d5d6 Z$d7d8 Z%dsd9d:Z&dtd;d<Z'd=d> Z(dud?d@Z)dAZ*dBZ+dCZ,dvdDdEZ-dwdFdGZ.dxdHdIZ/dydJdKZ0dLdM Z1dNdO Z2dPdQ Z3dzdRdSZ4d{dTdUZ5d|dWdXZ6d}dYdZZ7d~d[d\Z8dd^d_Z9ddadbZ:dcdd Z;dedf Zdkdl Z?ddndoZ@dS ) CCompilerNczc++Zobjc)z.cz.ccz.cppz.cxxz.mr c C sf || _ || _|| _d | _g | _g | _g | _g | _g | _g | _ x$| j
j D ]}| j || j
| qHW d S )N)
dry_runforceverbose
output_dirmacros include_dirs libraries library_dirsruntime_library_dirsobjects executableskeysset_executable)selfr r
r key r +/usr/lib64/python3.6/distutils/ccompiler.py__init__U s zCCompiler.__init__c K s@ x:|D ]2}|| j kr(td|| jjf | j||| qW d S )Nz$unknown executable '%s' for class %s)r
ValueError __class____name__r )r kwargsr r r r set_executablesy s
zCCompiler.set_executablesc C s, t |tr t| |t| n t| || d S )N)
isinstancestrsetattrr )r r valuer r r r s
zCCompiler.set_executablec C s0 d}x&| j D ] }|d |kr |S |d7 }q W d S )Nr )r )r nameidefnr r r _find_macro s zCCompiler._find_macroc C sd x^|D ]V}t |toFt|dkoFt |d ts:|d d koFt |d tstd| d d qW d S )Nr( r z invalid macro definition '%s': z.must be tuple (string,), (string, string), or z(string, None))r( r- )r$ tuplelenr% TypeError)r Z definitionsr+ r r r _check_macro_definitions s
z"CCompiler._check_macro_definitionsc C s. | j |}|d k r| j|= | jj||f d S )N)r, r append)r r) r' r* r r r define_macro s
zCCompiler.define_macroc C s0 | j |}|d k r| j|= |f}| jj| d S )N)r, r r2 )r r) r* Zundefnr r r undefine_macro s
zCCompiler.undefine_macroc C s | j j| d S )N)r r2 )r dirr r r add_include_dir s zCCompiler.add_include_dirc C s |d d | _ d S )N)r )r dirsr r r set_include_dirs s zCCompiler.set_include_dirsc C s | j j| d S )N)r r2 )r libnamer r r add_library s zCCompiler.add_libraryc C s |d d | _ d S )N)r )r Zlibnamesr r r
set_libraries s zCCompiler.set_librariesc C s | j j| d S )N)r r2 )r r5 r r r add_library_dir s zCCompiler.add_library_dirc C s |d d | _ d S )N)r )r r7 r r r set_library_dirs s zCCompiler.set_library_dirsc C s | j j| d S )N)r r2 )r r5 r r r add_runtime_library_dir s z!CCompiler.add_runtime_library_dirc C s |d d | _ d S )N)r )r r7 r r r set_runtime_library_dirs s z"CCompiler.set_runtime_library_dirsc C s | j j| d S )N)r r2 )r objectr r r add_link_object s zCCompiler.add_link_objectc C s |d d | _ d S )N)r )r r r r r set_link_objects( s zCCompiler.set_link_objectsc C s |d kr| j }nt|ts"td|d kr2| j}n"t|trL|| jpFg }ntd|d krd| j}n*t|ttfrt|| jpg }ntd|d krg }| j|d|d}t ||}i } xRt
t |D ]B}
||
} ||
} t j
j| d }
| jt j
j| | |
f| | < qW ||||| fS )Nz%'output_dir' must be a string or Nonez/'macros' (if supplied) must be a list of tuplesz6'include_dirs' (if supplied) must be a list of stringsr ) strip_dirr r( )r r$ r% r0 r listr r. object_filenamesgen_preprocess_optionsranger/ ospathsplitextr dirname)r Zoutdirr ZincdirssourcesdependsZextrar pp_optsbuildr* srcobjextr r r _setup_compile6 s8
zCCompiler._setup_compilec C s0 |dg }|r dg|d d< |r,||d d< |S )Nz-cz-gr r )r rN debugZbeforecc_argsr r r _get_cc_argsa s
zCCompiler._get_cc_argsc C s |d kr| j }nt|ts"td|d kr2| j}n"t|trL|| jpFg }ntd|d krd| j}n*t|ttfrt|| jpg }ntd|||fS )Nz%'output_dir' must be a string or Nonez/'macros' (if supplied) must be a list of tuplesz6'include_dirs' (if supplied) must be a list of strings)r r$ r% r0 r rD r r. )r r r r r r r _fix_compile_argsj s
zCCompiler._fix_compile_argsc C s | j ||d}|i fS )N)r )rE )r rL r rM r r r r
_prep_compile s zCCompiler._prep_compilec C sH t |ttfstdt|}|d kr.| j}nt |ts@td||fS )Nz,'objects' must be a list or tuple of stringsz%'output_dir' must be a string or None)r$ rD r. r0 r r% )r r r r r r _fix_object_args s
zCCompiler._fix_object_argsc C s |d kr| j }n*t|ttfr2t|| j p,g }ntd|d krJ| j}n*t|ttfrlt|| jpfg }ntd|d kr| j}n*t|ttfrt|| jpg }ntd|||fS )Nz3'libraries' (if supplied) must be a list of stringsz6'library_dirs' (if supplied) must be a list of stringsz>'runtime_library_dirs' (if supplied) must be a list of strings)r r$ rD r. r0 r r )r r r r r r r
_fix_lib_args s& zCCompiler._fix_lib_argsc C s2 | j r
dS | jr t||dd}n
t||}|S d S )NTnewer)Zmissing)r r
r )r r output_filer[ r r r
_need_link s
zCCompiler._need_linkc C s t |ts|g}d }t| j}x^|D ]V}tjj|\}}| jj|}y | jj |}||k rb|}|}W q$ t
k
rx Y q$X q$W |S )N) r$ rD r/ language_orderrH rI rJ language_mapgetindexr ) r rL Zlangra sourcebaserR ZextlangZextindexr r r detect_language s
zCCompiler.detect_languagec C s d S )Nr )r rb r\ r r
extra_preargsextra_postargsr r r
preprocess s zCCompiler.preprocessc C sz | j ||||||\}} }}
} | j|
||} xH| D ]@}
y| |
\}}W n tk
r\ w2Y nX | j|
||| ||
q2W | S )N)rS rV KeyError_compile)r rL r r r rT re rf rM r rN rO rU rQ rP rR r r r compile s 6
zCCompiler.compilec C s d S )Nr )r rQ rP rR rU rf rN r r r ri C s zCCompiler._compilec C s d S )Nr )r r output_libnamer rT target_langr r r create_static_libI s zCCompiler.create_static_libZ
shared_objectZshared_library
executablec C s t d S )N)NotImplementedError)r Z target_descr output_filenamer r r r export_symbolsrT re rf
build_temprl r r r linki s 9zCCompiler.linkc
C s2 | j tj|| j|dd||||||| |
| |
d S )Nshared)lib_type)rs r SHARED_LIBRARYlibrary_filename)
r r rk r r r r rq rT re rf rr rl r r r link_shared_lib s
zCCompiler.link_shared_libc
C s( | j tj||||||||| |
| |
d S )N)rs r
SHARED_OBJECT)
r r rp r r r r rq rT re rf rr rl r r r link_shared_object s
z CCompiler.link_shared_objectc C s. | j tj|| j|||||d ||| d |
d S )N)rs r
EXECUTABLEexecutable_filename) r r Zoutput_prognamer r r r rT re rf rl r r r link_executable s
zCCompiler.link_executablec C s t d S )N)ro )r r5 r r r library_dir_option s z CCompiler.library_dir_optionc C s t d S )N)ro )r r5 r r r runtime_library_dir_option s z$CCompiler.runtime_library_dir_optionc C s t d S )N)ro )r libr r r library_option s zCCompiler.library_optionc C s dd l }|d krg }|d kr g }|d kr,g }|d kr8g }|jd|dd\}}tj|d} z.x|D ]}
| jd|
q`W | jd| W d | j X y| j|g|d} W n tk
r d S X y| j| d
||d W n t t
fk
r d S X dS ) Nr z.cT)textwz#include "%s"
z+main (int argc, char **argv) {
%s();
}
)r Fza.out)r r ) tempfileZmkstemprH fdopenwritecloserj Z CompileErrorr} Z LinkErrorr0 ) r funcnameZincludesr r r r fdZfnamefZinclr r r r has_function s8
zCCompiler.has_functionc C s t d S )N)ro )r r7 r rT r r r find_library_file# s zCCompiler.find_library_file c C s |d kr d}g }x|D ]|}t jj|\}}t jj|d }|t jj|d }|| jkrhtd||f |rxt jj|}|jt jj ||| j
qW |S )Nr r( z"unknown file type '%s' (from '%s')) rH rI rJ
splitdriveisabssrc_extensionsZUnknownFileErrorbasenamer2 join
obj_extension)r Zsource_filenamesrC r Z obj_namesZsrc_namerc rR r r r rE N s
zCCompiler.object_filenamesc C s$ |rt jj|}t jj||| j S )N)rH rI r r shared_lib_extension)r r rC r r r r shared_object_filename_ s z CCompiler.shared_object_filenamec C s( |rt jj|}t jj||| jp"d S )Nr )rH rI r r
exe_extension)r r rC r r r r r| e s z CCompiler.executable_filenamestaticc
C s` |d krt dt| |d }t| |d }tjj|\}}|||f } |rPd}tjj||| S )
Nr rt dylib
xcode_stubz?'lib_type' must be "static", "shared", "dylib", or "xcode_stub"Z _lib_formatZ_lib_extensionr )r rt r r )r getattrrH rI splitr )
r r9 ru rC r ZfmtrR r5 rc filenamer r r rw k s zCCompiler.library_filenamer( c C s t j| d S )N)r
rT )r msglevelr r r announce~ s zCCompiler.announcec C s ddl m} |rt| d S )Nr )DEBUG)Zdistutils.debugr print)r r r r r r debug_print s zCCompiler.debug_printc C s t jjd| d S )Nz warning: %s
)sysstderrr )r r r r r warn s zCCompiler.warnc C s t |||| j d S )N)r r
)r funcargsr r r r r r s zCCompiler.executec C s t || jd d S )N)r
)r r
)r cmdr r r r s zCCompiler.spawnc C s t ||| jdS )N)r
)r r
)r rP dstr r r r s zCCompiler.move_file c C s t ||| jd d S )N)r
)r r
)r r) moder r r r s zCCompiler.mkpath)r r r )N)N)NNNNN)NNNr NNN)Nr N)
NNNNNr NNNN)
NNNNNr NNNN)
NNNNNr NNNN)NNNNr NNN)NNNN)r )r r )r r )r r )r r r )r( )Nr( )r )Ar!
__module__ __qualname__Z
compiler_typer r Zstatic_lib_extensionr Zstatic_lib_formatZshared_lib_formatr r_ r^ r r# r r, r1 r3 r4 r6 r8 r: r; r< r= r> r? rA rB rS rV rW rX rY rZ r] rd rg rj ri rm ry rv r{ rs rx rz r} r~ r r r r rE r r| rw r r r r r r r r r r r r s
$
+
"
B
4
*
+
r cygwin.*unixposixntmsvcc C sV | d krt j} |d kr tj}x4tD ],\}}tj||d k sJtj|| d k r"|S q"W dS )Nr )rH r) r platform_default_compilersrematch)osnamer patterncompilerr r r get_default_compiler s
r
unixccompiler
UnixCCompiler standard UNIX-style compiler
_msvccompiler MSVCCompilerMicrosoft Visual C++cygwinccompilerCygwinCCompiler'Cygwin port of GNU C Compiler for Win32Mingw32CCompiler(Mingw32 port of GNU C Compiler for Win32 bcppcompiler BCPPCompilerBorland C++ Compiler)r r cygwinZmingw32Zbcppc C s\ ddl m} g }x,tj D ] }|jd| d t| d f qW |j | |}|jd d S )Nr ) FancyGetoptz compiler=r- z List of available compilers:)Zdistutils.fancy_getoptr compiler_classr r2 sortZ
print_help)r Z compilersr Zpretty_printerr r r show_compilers s r c C s | d krt j} y"|d kr t| }t| \}}}W n8 tk
rh d| }|d k r\|d| }t|Y nX y*d| }t| tj| } t | | }
W nB t
k
r t d| Y n$ tk
r t d||f Y nX |
d ||S )Nz5don't know how to compile C/C++ code on platform '%s'z with '%s' compilerz
distutils.z4can't compile C/C++ code: unable to load module '%s'zBcan't compile C/C++ code: unable to find class '%s' in module '%s') rH r) r r rh ZDistutilsPlatformError
__import__r modulesvars ImportErrorZDistutilsModuleError) Zplatr r r
r Z module_name
class_nameZlong_descriptionr moduleklassr r r new_compiler s2
r c C s g }x| D ]}t |to2dt| ko.dkn s@td| t|dkr`|jd|d q
t|dkr
|d d kr|jd|d q
|jd| q
W x|D ]}|jd| qW |S ) Nr( r- zPbad macro definition '%s': each element of 'macros' list must be a 1- or 2-tuplez-U%sr z-D%sz-D%s=%sz-I%s)r$ r. r/ r0 r2 )r r rN Zmacror5 r r r rF
s
&
rF c C s g }x |D ]}|j | j| q
W x4|D ],}| j|}t|trJ|| }q(|j | q(W x^|D ]V}tjj|\}} |r| j|g| }
|
r|j |
q| j d| q^|j | j
| q^W |S )Nz6no library file corresponding to '%s' found (skipping)) r2 r~ r r$ rD rH rI r r r r ) r r r r Zlib_optsr5 optr Zlib_dirZlib_nameZlib_filer r r gen_lib_options7 s$
r r r r r r r )r r r )NN)r r r )r r r )r r r )r r r )r r r )NNr r r )r rH r Zdistutils.errorsZdistutils.spawnr Zdistutils.file_utilr Zdistutils.dir_utilr Zdistutils.dep_utilr r Zdistutils.utilr r Z distutilsr
r r r r r r rF r r r r r sB
--PK ! W6= __pycache__/log.cpython-36.pycnu [ 3
\ @ sl d Z dZdZdZdZdZddlZG dd d Ze Zej Z ej
Z
ej Z ej Z ej
Z
ejZd
d Zd d
ZdS )z,A simple log mechanism styled after PEP 282. Nc @ sP e Zd ZefddZdd Zdd Zdd Zd d
Zd d Z d
d Z
dd Z dS )Logc C s
|| _ d S )N) threshold)selfr r
%/usr/lib64/python3.6/distutils/log.py__init__ s z Log.__init__c C s |t ttttfkr"tdt| || jkr|r8|| }|tttfkrNtj }ntj
}y|j d| W n: t k
r |j
}|j|dj|}|j d| Y nX |j d S )Nz%s wrong log levelz%s
backslashreplace)DEBUGINFOWARNERRORFATAL
ValueErrorstrr sysstderrstdoutwriteUnicodeEncodeErrorencodingencodedecodeflush)r levelmsgargsstreamr r
r
r _log s
zLog._logc G s | j ||| d S )N)r" )r r r r r
r
r log' s zLog.logc G s | j t|| d S )N)r" r )r r r r
r
r debug* s z Log.debugc G s | j t|| d S )N)r" r )r r r r
r
r info- s zLog.infoc G s | j t|| d S )N)r" r )r r r r
r
r warn0 s zLog.warnc G s | j t|| d S )N)r" r )r r r r
r
r error3 s z Log.errorc G s | j t|| d S )N)r" r )r r r r
r
r fatal6 s z Log.fatalN) __name__
__module__ __qualname__r r r" r# r$ r% r& r' r( r
r
r
r r s r c C s t j}| t _|S )N) _global_logr )r oldr
r
r
set_thresholdA s r. c C s8 | dkrt t n"| dkr$t t n| dkr4t t d S )Nr r r )r. r r r )vr
r
r
set_verbosityG s
r0 )__doc__r r r r r r r r, r# r$ r% r& r' r( r. r0 r
r
r
r s +PK ! e o ' __pycache__/config.cpython-36.opt-2.pycnu [ 3
\ @ s8 d dl Z d dlmZ d dlmZ dZG dd deZdS ) N)RawConfigParser)CommandzE[distutils]
index-servers =
pypi
[pypi]
username:%s
password:%s
c @ sd e Zd ZdZdZdZdZddde fdgZdgZd d
Z d d Z
d
d Z dd Z dd Z
dd ZdS )
PyPIRCCommandz https://upload.pypi.org/legacy/pypiNz repository=rz url of repository [default: %s]
show-response&display full response text from serverc C s t jjt jjddS )N~z.pypirc)ospathjoin
expanduser)self r (/usr/lib64/python3.6/distutils/config.py _get_rc_file& s zPyPIRCCommand._get_rc_filec C sH | j }tjtj|tjtjB dd}|jt||f W d Q R X d S )Ni w)r r
fdopenopenO_CREATO_WRONLYwriteDEFAULT_PYPIRC)r usernamepasswordrcfr r r
_store_pypirc* s zPyPIRCCommand._store_pypircc C s | j }tjj|r| jd| | jp.| j}| jp:| j}t }|j
| |j }d|krR|j dd}dd |j
dD }|g krd|krdg}ni S x|D ]}d|i} |j |d | d < xHd
| jfd | jfdfD ].\}
} |j||
r|j ||
| |
< q| | |
< qW |dkr.|| jdfkr.| j| d
< | S | d |ksH| d
|kr| S qW nRd
|krd
}|j|d
r||j |d
}n| j}|j |d |j |d ||| jdS i S )NzUsing PyPI login from %sZ distutilsz
index-serversc S s g | ]}|j d kr|j qS ) )strip).0serverr r r
> s z.PyPIRCCommand._read_pypirc..
r r! r
repositoryrealmr z server-login)r r r$ r! r% )r N)r r
r existsZannouncer$ DEFAULT_REPOSITORYr%
DEFAULT_REALMr readsectionsgetsplitZ
has_option) r r r$ r% configr* Z
index_serversZ_serversr! Zcurrentkeydefaultr r r _read_pypirc0 sX
zPyPIRCCommand._read_pypircc C s8 dd l }|jdd}|j|d jdd}|j j|S )Nr z content-typez
text/plain charsetascii)cgiZ getheaderZ parse_headerr+ r) decode)r Zresponser4 Z content_typeencodingr r r _read_pypi_responseq s z!PyPIRCCommand._read_pypi_responsec C s d | _ d | _d| _d S )Nr )r$ r% Z
show_response)r r r r initialize_optionsx s z PyPIRCCommand.initialize_optionsc C s( | j d kr| j| _ | jd kr$| j| _d S )N)r$ r' r% r( )r r r r finalize_options~ s
z PyPIRCCommand.finalize_options)r Nr )__name__
__module__ __qualname__r' r( r$ r% Z user_optionsZboolean_optionsr r r0 r7 r8 r9 r r r r r s Ar )r
Z configparserr Z
distutils.cmdr r r r r r r s
PK ! 0Ah ( __pycache__/version.cpython-36.opt-2.pycnu [ 3
\90 @ s: d dl Z G dd dZG dd deZG dd deZdS ) Nc @ sF e Zd ZdddZdd Zdd Zdd Zd
d Zd d
Zdd Z dS )VersionNc C s |r| j | d S )N)parse)selfvstring r )/usr/lib64/python3.6/distutils/version.py__init__& s zVersion.__init__c C s d| j jt| f S )Nz %s ('%s')) __class____name__str)r r r r __repr__* s zVersion.__repr__c C s | j |}|tkr|S |dkS )Nr )_cmpNotImplemented)r othercr r r __eq__- s
zVersion.__eq__c C s | j |}|tkr|S |dk S )Nr )r
r )r r r r r r __lt__3 s
zVersion.__lt__c C s | j |}|tkr|S |dkS )Nr )r
r )r r r r r r __le__9 s
zVersion.__le__c C s | j |}|tkr|S |dkS )Nr )r
r )r r r r r r __gt__? s
zVersion.__gt__c C s | j |}|tkr|S |dkS )Nr )r
r )r r r r r r __ge__E s
zVersion.__ge__)N)
r
__module__ __qualname__r r r r r r r r r r r r s
r c @ s8 e Zd ZejdejejB Zdd Zdd Z dd Z
dS )
StrictVersionz)^(\d+) \. (\d+) (\. (\d+))? ([ab](\d+))?$c C s | j j|}|s td| |jddddd\}}}}}|rTttt|||g| _nttt||gd | _|r|d t|f| _nd | _d S ) Nzinvalid version number '%s' r )r )
version_rematch
ValueErrorgrouptuplemapintversion
prerelease)r r r majorminorZpatchr& Zprerelease_numr r r r s zStrictVersion.parsec C sb | j d dkr*djtt| j dd }ndjtt| j }| jr^|| jd t| jd }|S )Nr r .r )r% joinr# r r& )r r r r r __str__ s zStrictVersion.__str__c C s t |trt|}| j|jkr2| j|jk r.dS dS | j rF|j rFdS | jrX|j rXdS | j rj|jrjdS | jr|jr| j|jkrdS | j|jk rdS dS n d S )Nr r r, r, )
isinstancer r r% r& )r r r r r r
s&
zStrictVersion._cmpN) r
r r recompileVERBOSEASCIIr r r+ r
r r r r r ] s
%
r c @ sD e Zd ZejdejZd
ddZdd Zdd Z d d
Z
d d Z dS ) LooseVersionz(\d+ | [a-z]+ | \.)Nc C s |r| j | d S )N)r )r r r r r r . s zLooseVersion.__init__c C sb || _ dd | jj|D }x:t|D ].\}}yt|||< W q& tk
rR Y q&X q&W || _d S )Nc S s g | ]}|r|d kr|qS )r) r ).0xr r r
8 s z&LooseVersion.parse..)r component_resplit enumerater$ r r% )r r Z
componentsiobjr r r r 3 s
zLooseVersion.parsec C s | j S )N)r )r r r r r+ C s zLooseVersion.__str__c C s dt | S )NzLooseVersion ('%s'))r )r r r r r G s zLooseVersion.__repr__c C sF t |trt|}| j|jkr"dS | j|jk r2dS | j|jkrBdS d S )Nr r r, )r- r r2 r% )r r r r r r
K s
zLooseVersion._cmp)N) r
r r r. r/ r0 r6 r r r+ r r
r r r r r2 s !
r2 )r. r r r2 r r r r s > /PK ! f7 - __pycache__/archive_util.cpython-36.opt-2.pycnu [ 3
\F! @ s@ d dl Z d dlmZ d dlZy d dlZW n ek
r@ dZY nX d dlmZ d dlm Z d dl
m Z d dl m
Z
yd dlmZ W n ek
r dZY nX yd dlmZ W n ek
r dZY nX d d
Zd d Zd ddZd!ddZed"gdfed#gdfed$gdfed%gdfed&gdfeg dfdZd d Zd'd d ZdS )( N)warn)DistutilsExecError)spawn)mkpath)log)getpwnam)getgrnamc C sN t d ks| d krd S y t | }W n tk
r8 d }Y nX |d k rJ|d S d S )N )r KeyError)nameresult r
./usr/lib64/python3.6/distutils/archive_util.py_get_gid s
r c C sN t d ks| d krd S y t | }W n tk
r8 d }Y nX |d k rJ|d S d S )Nr )r r
)r r r
r
r _get_uid+ s
r gzipc s. dddddd}dddd d
}|d k r:||j kr:td | d } |d
krZ| |j|d7 } ttjj| |d dd l}
tj d t
t fdd} |s|
j | d|| } z| j
|| d W d | j X |d
kr*tdt | || }
tjdkr|| |
g}n
|d| g}t||d |
S | S )NZgzbz2xz )r bzip2r Ncompressz.gzz.bz2z.xzz.Z)r r r r zKbad value for 'compress': must be None, 'gzip', 'bzip2', 'xz' or 'compress'z.tarr )dry_runr zCreating tar archivec s, d k r | _ | _d k r(| _| _| S )N)gidZgnameuiduname)Ztarinfo)r groupownerr r
r _set_uid_gida s z"make_tarball.._set_uid_gidzw|%s)filterz 'compress' will be deprecated.Zwin32z-f)keys
ValueErrorgetr ospathdirnametarfiler infor r openaddcloser PendingDeprecationWarningsysplatformr ) base_namebase_dirr verboser r r Ztar_compressionZ compress_extZ archive_namer% r tarZcompressed_namecmdr
)r r r r r make_tarball7 s<
r2 c C s | d }t tjj||d td krp|r.d}nd}ytd|||g|d W n tk
rj td| Y nX n:tjd|| |sytj |dtj
d }W n& t k
r tj |dtj d }Y nX |tj
krtjjtjj|d
}|j|| tjd | xtj|D ]\}} }
x>| D ]6} tjjtjj|| d
}|j|| tjd | qW xJ|
D ]B} tjjtjj|| }tjj|rV|j|| tjd | qVW qW |j |S ) Nz.zip)r z-rz-rqzipzkunable to create zip file '%s': could neither import the 'zipfile' module nor find a standalone zip utilityz#creating '%s' and adding '%s' to itw)Z compressionr z adding '%s')r r" r# r$ zipfiler r r r& ZZipFileZ ZIP_DEFLATED RuntimeErrorZ
ZIP_STOREDcurdirnormpathjoinwritewalkisfiler) ) r- r. r/ r Z zip_filenameZ
zipoptionsr3 r# dirpathZdirnames filenamesr r
r
r make_zipfile sJ
r? r zgzip'ed tar-filer zbzip2'ed tar-filer zxz'ed tar-filezcompressed tar filezuncompressed tar filezZIP file)ZgztarZbztarZxztarZztarr0 r3 c C s x| D ]}|t kr|S qW d S )N)ARCHIVE_FORMATS)Zformatsformatr
r
r check_archive_formats s
rB c C s t j }|d k r6tjd| t jj| } |s6t j| |d krDt j}d|i} y t| }
W n t k
rx t
d| Y nX |
d } x |
d D ]\} }
|
| | < qW |dkr|| d< || d< z| | |f| }W d |d k rtjd | t j| X |S )
Nzchanging into '%s'r zunknown archive format '%s'r r3 r r zchanging back to '%s') r" getcwdr debugr# abspathchdirr7 r@ r
r )r- rA Zroot_dirr. r/ r r r Zsave_cwdkwargsZ format_infofuncargvalfilenamer
r
r make_archive s2
rM )r r r NN)r r )r r )r r )r r )r r )r N)NNr r NN)r" warningsr r+ r5 ImportErrorZdistutils.errorsr Zdistutils.spawnr Zdistutils.dir_utilr Z distutilsr pwdr Zgrpr r r r2 r? r@ rB rM r
r
r
r s@
G
=
PK ! 4Sc r@ normcaseZsrc_extensionsr rA rC rB
obj_extension)r/ Zsource_filenamesZ strip_dirrE Z obj_namesZsrc_namebaser6 r r r object_filenames s
z CygwinCCompiler.object_filenames)r r r )
NNNNNr NNNN)r rH )__name__
__module__ __qualname____doc__r+ rL Zstatic_lib_extensionZshared_lib_extensionZstatic_lib_formatZshared_lib_formatZ
exe_extensionr$ r9 rD rN r r r r r Y s
;
Kr c @ s e Zd ZdZdZdddZdS )Mingw32CCompilerz@ Handles the Mingw32 port of the GNU C compiler to Windows.
Zmingw32r c C sx t j| ||| | jdkr d}nd}| jdkr4d}nd}t rFtd| jdd d
d d | j||f d
g | _t | _d S )Nz2.13z-sharedz
-mdll -staticz2.91.57z--entry _DllMain@12rH z1Cygwin gcc cannot be used with --compiler=mingw32z gcc -O -Wallzgcc -mdll -O -Wallz g++ -O -Wallr z%s %s %s)r r r! r" r# )
r r$ r* r) is_cygwingccr
r- r, r. r )r/ r0 r1 r2 r3 Z entry_pointr r r r$ s&
zMingw32CCompiler.__init__N)r r r )rO rP rQ rR r+ r$ r r r r rS s rS okznot okZ uncertainc C s ddl m} dtjkr tdfS | j }y@t|}z(d|j krJtd| fS td| fS W d|j X W n. t
k
r } zt d ||j f fS d}~X nX dS )
aw Check if the current Python installation appears amenable to building
extensions with GCC.
Returns a tuple (status, details), where 'status' is one of the following
constants:
- CONFIG_H_OK: all is well, go ahead and compile
- CONFIG_H_NOTOK: doesn't look good
- CONFIG_H_UNCERTAIN: not sure -- unable to read pyconfig.h
'details' is a human-readable string explaining the situation.
Note there are two ways to conclude "OK": either 'sys.version' contains
the string "GCC" (implying that this Python was built with GCC), or the
installed "pyconfig.h" contains the string "__GNUC__".
r ) sysconfigZGCCzsys.version mentions 'GCC'Z__GNUC__z'%s' mentions '__GNUC__'z '%s' does not mention '__GNUC__'Nzcouldn't read '%s': %s)
distutilsrV r r r& get_config_h_filenameopenreadCONFIG_H_NOTOKcloseOSErrorCONFIG_H_UNCERTAINstrerror)rV fnconfig_hexcr r r r% H s
r% s (\d+\.\d+(\.\d+)*)c C sl | j d }t|dkr dS t| dtdj}z |j }W d|j X tj|}|dkrZdS t |j
dj S )zFind the version of an executable by running `cmd` in the shell.
If the command is not found, or the output does not match
`RE_VERSION`, returns None.
r NT)shellstdoutr ) splitr r r rd rZ r\
RE_VERSIONsearchr groupdecode)cmd
executableout
out_stringresultr r r _find_exe_versionu s
ro c C s dddg} t dd | D S )zg Try to find out the versions of gcc, ld and dllwrap.
If not possible it returns None for it.
zgcc -dumpversionzld -vzdllwrap --versionc S s g | ] }t |qS r )ro ).0rj r r r
s z get_versions..)tuple)Zcommandsr r r r( s
r( c C s t ddg} | j jdS )z>Try to determine if the gcc that would be used is from cygwin.r z -dumpmachines cygwin)r stripendswith)rm r r r rT s rT )'rR r= r r;
subprocessr r r reZdistutils.ccompilerr r Zdistutils.unixccompilerr Zdistutils.file_utilr Zdistutils.errorsr r
r r rW r
Zdistutils.versionr Zdistutils.spawnr r r rS r& r[ r^ r% compilerf ro r( rT r r r r s0 ) ;1+
PK ! OS
* __pycache__/text_file.cpython-36.opt-2.pycnu [ 3
\0 @ s" d dl Z d dlZG dd dZdS ) Nc @ sp e Zd ZddddddddZdddZdd Zd
d Zdd d
ZdddZdddZ dd Z
dd Z dd Z dS ) TextFile r strict)strip_comments skip_blanks lstrip_ws rstrip_ws
join_lines
collapse_joinerrorsNc K s |d kr|d krt dx>| jj D ]0}||krBt| ||| q$t| || j| q$W x&|j D ]}|| jkrbtd| qbW |d kr| j| n|| _|| _d| _g | _ d S )Nz7you must supply either or both of 'filename' and 'file'z invalid TextFile option '%s'r )
RuntimeErrordefault_optionskeyssetattrKeyErroropenfilenamefile current_linelinebuf)selfr r Zoptionsopt r +/usr/lib64/python3.6/distutils/text_file.py__init__N s
zTextFile.__init__c C s& || _ tj| j d| jd| _d| _d S )Nr)r r )r ior r r r )r r r r r r o s z
TextFile.openc C s$ | j }d | _ d | _d | _|j d S )N)r r r close)r r r r r r v s
zTextFile.closec C sj g }|d kr| j }|j| jd t|ttfrD|jdt| n|jd| |jt| dj|S )Nz, z
lines %d-%d: z line %d: )r appendr
isinstancelisttuplestrjoin)r msglineZoutmsgr r r gen_error s zTextFile.gen_errorc C s t d| j|| d S )Nzerror: )
ValueErrorr' )r r% r& r r r error s zTextFile.errorc C s t jjd| j|| d d S )Nz warning:
)sysstderrwriter' )r r% r& r r r warn s z
TextFile.warnc C s | j r | j d }| j d = |S d}x| jj }|dkr:d }| jr|r|jd}|d
krXnX|dksp||d dkr|d dkrdpd}|d| | }|j dkrq$n |jdd}| jo|r |d kr| jd |S | j r|j
}|| }t | j t
r | j d d | j d< n| j | j d g| _ n:|d kr.d S t | j t
rN| j d d | _ n | j d | _ | jrt| jrt|j }n"| jr|j
}n| jr|j }|dks|dkr| jrq$| jr|d dkr|d d }q$|dd d
kr|dd d }q$|S d S )Nr r #r \r* z\#z2continuation line immediately precedes end-of-file z\
r2 r2 r2 r2 r2 r3 )r r readliner findstripreplacer r. r
lstripr r r! r r rstripr )r r& Z buildup_lineposZeolr r r r4 sf
zTextFile.readlinec C s, g }x"| j }|d kr|S |j| qW d S )N)r4 r )r linesr& r r r readlines s zTextFile.readlinesc C s | j j| d S )N)r r )r r& r r r
unreadline s zTextFile.unreadline)NN)N)N)N)
__name__
__module__ __qualname__r
r r r r' r) r. r4 r< r= r r r r r
s ;
!
x
r )r+ r r r r r r s PK ! n7#Fā ā * __pycache__/ccompiler.cpython-36.opt-1.pycnu [ 3
\7 @ s d Z ddlZddlZddlZddlT ddlmZ ddlmZ ddl m
Z
ddl m Z m
Z
ddlmZmZ dd lmZ G d
d d Zd-Zd.ddZd/d0d1d2d3d!Zd"d# Zd4d$d%Zd&d' Zd(d) ZdS )5zdistutils.ccompiler
Contains CCompiler, an abstract base class that defines the interface
for the Distutils compiler abstraction model. N)*)spawn) move_file)mkpath)newer_pairwise newer_group) split_quotedexecute)logc
@ s e Zd ZdZdZdZdZdZdZdZ dZ
dZ ddddddZ dddgZ
dqdd Zd
d Zd d
Zdd Zdd ZdrddZdd Zdd Zdd Zdd Zd d Zd d Zd d! Zd"d# Zd$d% Z d&d' Z d(d) Z d*d+ Z d,d- Z d.d/ Z!dsd0d1Z"d2d3 Z#d4d5 Z$d6d7 Z%d8d9 Z&dtd:d;Z'dudd? Z)dvd@dAZ*dBZ+dCZ,dDZ-dwdEdFZ.dxdGdHZ/dydIdJZ0dzdKdLZ1dMdN Z2dOdP Z3dQdR Z4d{dSdTZ5d|dUdVZ6d}dXdYZ7d~dZd[Z8dd\d]Z9dd_d`Z:ddbdcZ;ddde Zdjdk Z?dldm Z@ddodpZAdS ) CCompilera Abstract base class to define the interface that must be implemented
by real compiler classes. Also has some utility methods used by
several compiler classes.
The basic idea behind a compiler abstraction class is that each
instance can be used for all the compile/link steps in building a
single project. Thus, attributes common to all of those compile and
link steps -- include directories, macros to define, libraries to link
against, etc. -- are attributes of the compiler instance. To allow for
variability in how individual files are treated, most of those
attributes may be varied on a per-compilation or per-link basis.
Nczc++Zobjc)z.cz.ccz.cppz.cxxz.mr c C sf || _ || _|| _d | _g | _g | _g | _g | _g | _g | _ x$| j
j D ]}| j || j
| qHW d S )N)
dry_runforceverbose
output_dirmacros include_dirs libraries library_dirsruntime_library_dirsobjects executableskeysset_executable)selfr r
r key r +/usr/lib64/python3.6/distutils/ccompiler.py__init__U s zCCompiler.__init__c K s@ x:|D ]2}|| j kr(td|| jjf | j||| qW dS )a Define the executables (and options for them) that will be run
to perform the various stages of compilation. The exact set of
executables that may be specified here depends on the compiler
class (via the 'executables' class attribute), but most will have:
compiler the C/C++ compiler
linker_so linker used to create shared objects and libraries
linker_exe linker used to create binary executables
archiver static library creator
On platforms with a command-line (Unix, DOS/Windows), each of these
is a string that will be split into executable name and (optional)
list of arguments. (Splitting the string is done similarly to how
Unix shells operate: words are delimited by spaces, but quotes and
backslashes can override this. See
'distutils.util.split_quoted()'.)
z$unknown executable '%s' for class %sN)r
ValueError __class____name__r )r kwargsr r r r set_executablesy s
zCCompiler.set_executablesc C s, t |tr t| |t| n t| || d S )N)
isinstancestrsetattrr )r r valuer r r r s
zCCompiler.set_executablec C s0 d}x&| j D ] }|d |kr |S |d7 }q W d S )Nr )r )r nameidefnr r r _find_macro s zCCompiler._find_macroc C sd x^|D ]V}t |toFt|dkoFt |d ts:|d dkoFt |d tstd| d d qW dS ) zEnsures that every element of 'definitions' is a valid macro
definition, ie. either (name,value) 2-tuple or a (name,) tuple. Do
nothing if all definitions are OK, raise TypeError otherwise.
r( Nr z invalid macro definition '%s': z.must be tuple (string,), (string, string), or z(string, None))r( r- )r$ tuplelenr% TypeError)r Z definitionsr+ r r r _check_macro_definitions s
z"CCompiler._check_macro_definitionsc C s. | j |}|dk r| j|= | jj||f dS )a_ Define a preprocessor macro for all compilations driven by this
compiler object. The optional parameter 'value' should be a
string; if it is not supplied, then the macro will be defined
without an explicit value and the exact outcome depends on the
compiler used (XXX true? does ANSI say anything about this?)
N)r, r append)r r) r' r* r r r define_macro s
zCCompiler.define_macroc C s0 | j |}|dk r| j|= |f}| jj| dS )a Undefine a preprocessor macro for all compilations driven by
this compiler object. If the same macro is defined by
'define_macro()' and undefined by 'undefine_macro()' the last call
takes precedence (including multiple redefinitions or
undefinitions). If the macro is redefined/undefined on a
per-compilation basis (ie. in the call to 'compile()'), then that
takes precedence.
N)r, r r2 )r r) r* Zundefnr r r undefine_macro s
zCCompiler.undefine_macroc C s | j j| dS )zAdd 'dir' to the list of directories that will be searched for
header files. The compiler is instructed to search directories in
the order in which they are supplied by successive calls to
'add_include_dir()'.
N)r r2 )r dirr r r add_include_dir s zCCompiler.add_include_dirc C s |dd | _ dS )ay Set the list of directories that will be searched to 'dirs' (a
list of strings). Overrides any preceding calls to
'add_include_dir()'; subsequence calls to 'add_include_dir()' add
to the list passed to 'set_include_dirs()'. This does not affect
any list of standard include directories that the compiler may
search by default.
N)r )r dirsr r r set_include_dirs s zCCompiler.set_include_dirsc C s | j j| dS )a Add 'libname' to the list of libraries that will be included in
all links driven by this compiler object. Note that 'libname'
should *not* be the name of a file containing a library, but the
name of the library itself: the actual filename will be inferred by
the linker, the compiler, or the compiler class (depending on the
platform).
The linker will be instructed to link against libraries in the
order they were supplied to 'add_library()' and/or
'set_libraries()'. It is perfectly valid to duplicate library
names; the linker will be instructed to link against libraries as
many times as they are mentioned.
N)r r2 )r libnamer r r add_library s zCCompiler.add_libraryc C s |dd | _ dS )zSet the list of libraries to be included in all links driven by
this compiler object to 'libnames' (a list of strings). This does
not affect any standard system libraries that the linker may
include by default.
N)r )r Zlibnamesr r r
set_libraries s zCCompiler.set_librariesc C s | j j| dS )a' Add 'dir' to the list of directories that will be searched for
libraries specified to 'add_library()' and 'set_libraries()'. The
linker will be instructed to search for libraries in the order they
are supplied to 'add_library_dir()' and/or 'set_library_dirs()'.
N)r r2 )r r5 r r r add_library_dir s zCCompiler.add_library_dirc C s |dd | _ dS )zSet the list of library search directories to 'dirs' (a list of
strings). This does not affect any standard library search path
that the linker may search by default.
N)r )r r7 r r r set_library_dirs s zCCompiler.set_library_dirsc C s | j j| dS )zlAdd 'dir' to the list of directories that will be searched for
shared libraries at runtime.
N)r r2 )r r5 r r r add_runtime_library_dir s z!CCompiler.add_runtime_library_dirc C s |dd | _ dS )zSet the list of directories to search for shared libraries at
runtime to 'dirs' (a list of strings). This does not affect any
standard search path that the runtime linker may search by
default.
N)r )r r7 r r r set_runtime_library_dirs s z"CCompiler.set_runtime_library_dirsc C s | j j| dS )zAdd 'object' to the list of object files (or analogues, such as
explicitly named library files or the output of "resource
compilers") to be included in every link driven by this compiler
object.
N)r r2 )r objectr r r add_link_object s zCCompiler.add_link_objectc C s |dd | _ dS )zSet the list of object files (or analogues) to be included in
every link to 'objects'. This does not affect any standard object
files that the linker may include by default (such as system
libraries).
N)r )r r r r r set_link_objects( s zCCompiler.set_link_objectsc C s |dkr| j }nt|ts"td|dkr2| j}n"t|trL|| jpFg }ntd|dkrd| j}n*t|ttfrt|| jpg }ntd|dkrg }| j|d|d}t ||}i } xRt
t |D ]B}
||
} ||
} t j
j| d }
| jt j
j| | |
f| | < qW ||||| fS )z;Process arguments and decide which source files to compile.Nz%'output_dir' must be a string or Nonez/'macros' (if supplied) must be a list of tuplesz6'include_dirs' (if supplied) must be a list of stringsr ) strip_dirr r( )r r$ r% r0 r listr r. object_filenamesgen_preprocess_optionsranger/ ospathsplitextr dirname)r Zoutdirr ZincdirssourcesdependsZextrar pp_optsbuildr* srcobjextr r r _setup_compile6 s8
zCCompiler._setup_compilec C s0 |dg }|r dg|d d< |r,||d d< |S )Nz-cz-gr r )r rN debugZbeforecc_argsr r r _get_cc_argsa s
zCCompiler._get_cc_argsc C s |dkr| j }nt|ts"td|dkr2| j}n"t|trL|| jpFg }ntd|dkrd| j}n*t|ttfrt|| jpg }ntd|||fS )a' Typecheck and fix-up some of the arguments to the 'compile()'
method, and return fixed-up values. Specifically: if 'output_dir'
is None, replaces it with 'self.output_dir'; ensures that 'macros'
is a list, and augments it with 'self.macros'; ensures that
'include_dirs' is a list, and augments it with 'self.include_dirs'.
Guarantees that the returned values are of the correct type,
i.e. for 'output_dir' either string or None, and for 'macros' and
'include_dirs' either list or None.
Nz%'output_dir' must be a string or Nonez/'macros' (if supplied) must be a list of tuplesz6'include_dirs' (if supplied) must be a list of strings)r r$ r% r0 r rD r r. )r r r r r r r _fix_compile_argsj s
zCCompiler._fix_compile_argsc C s | j ||d}|i fS )a+ Decide which souce files must be recompiled.
Determine the list of object files corresponding to 'sources',
and figure out which ones really need to be recompiled.
Return a list of all object files and a dictionary telling
which source files can be skipped.
)r )rE )r rL r rM r r r r
_prep_compile s zCCompiler._prep_compilec C sH t |ttfstdt|}|dkr.| j}nt |ts@td||fS )zTypecheck and fix up some arguments supplied to various methods.
Specifically: ensure that 'objects' is a list; if output_dir is
None, replace with self.output_dir. Return fixed versions of
'objects' and 'output_dir'.
z,'objects' must be a list or tuple of stringsNz%'output_dir' must be a string or None)r$ rD r. r0 r r% )r r r r r r _fix_object_args s
zCCompiler._fix_object_argsc C s |dkr| j }n*t|ttfr2t|| j p,g }ntd|dkrJ| j}n*t|ttfrlt|| jpfg }ntd|dkr| j}n*t|ttfrt|| jpg }ntd|||fS )a; Typecheck and fix up some of the arguments supplied to the
'link_*' methods. Specifically: ensure that all arguments are
lists, and augment them with their permanent versions
(eg. 'self.libraries' augments 'libraries'). Return a tuple with
fixed versions of all arguments.
Nz3'libraries' (if supplied) must be a list of stringsz6'library_dirs' (if supplied) must be a list of stringsz>'runtime_library_dirs' (if supplied) must be a list of strings)r r$ rD r. r0 r r )r r r r r r r
_fix_lib_args s& zCCompiler._fix_lib_argsc C s2 | j r
dS | jr t||dd}n
t||}|S dS )zjReturn true if we need to relink the files listed in 'objects'
to recreate 'output_file'.
Tnewer)ZmissingN)r r
r )r r output_filer[ r r r
_need_link s
zCCompiler._need_linkc C s t |ts|g}d}t| j}x^|D ]V}tjj|\}}| jj|}y | jj |}||k rb|}|}W q$ t
k
rx Y q$X q$W |S )z|Detect the language of a given file, or list of files. Uses
language_map, and language_order to do the job.
N) r$ rD r/ language_orderrH rI rJ language_mapgetindexr ) r rL Zlangra sourcebaserR ZextlangZextindexr r r detect_language s
zCCompiler.detect_languagec C s dS )a Preprocess a single C/C++ source file, named in 'source'.
Output will be written to file named 'output_file', or stdout if
'output_file' not supplied. 'macros' is a list of macro
definitions as for 'compile()', which will augment the macros set
with 'define_macro()' and 'undefine_macro()'. 'include_dirs' is a
list of directory names that will be added to the default list.
Raises PreprocessError on failure.
Nr )r rb r\ r r
extra_preargsextra_postargsr r r
preprocess s zCCompiler.preprocessc C sz | j ||||||\}} }}
} | j|
||} xH| D ]@}
y| |
\}}W n tk
r\ w2Y nX | j|
||| ||
q2W | S )aK Compile one or more source files.
'sources' must be a list of filenames, most likely C/C++
files, but in reality anything that can be handled by a
particular compiler and compiler class (eg. MSVCCompiler can
handle resource files in 'sources'). Return a list of object
filenames, one per source filename in 'sources'. Depending on
the implementation, not all source files will necessarily be
compiled, but all corresponding object filenames will be
returned.
If 'output_dir' is given, object files will be put under it, while
retaining their original path component. That is, "foo/bar.c"
normally compiles to "foo/bar.o" (for a Unix implementation); if
'output_dir' is "build", then it would compile to
"build/foo/bar.o".
'macros', if given, must be a list of macro definitions. A macro
definition is either a (name, value) 2-tuple or a (name,) 1-tuple.
The former defines a macro; if the value is None, the macro is
defined without an explicit value. The 1-tuple case undefines a
macro. Later definitions/redefinitions/ undefinitions take
precedence.
'include_dirs', if given, must be a list of strings, the
directories to add to the default include file search path for this
compilation only.
'debug' is a boolean; if true, the compiler will be instructed to
output debug symbols in (or alongside) the object file(s).
'extra_preargs' and 'extra_postargs' are implementation- dependent.
On platforms that have the notion of a command-line (e.g. Unix,
DOS/Windows), they are most likely lists of strings: extra
command-line arguments to prepand/append to the compiler command
line. On other platforms, consult the implementation class
documentation. In any event, they are intended as an escape hatch
for those occasions when the abstract compiler framework doesn't
cut the mustard.
'depends', if given, is a list of filenames that all targets
depend on. If a source file is older than any file in
depends, then the source file will be recompiled. This
supports dependency tracking, but only at a coarse
granularity.
Raises CompileError on failure.
)rS rV KeyError_compile)r rL r r r rT re rf rM r rN rO rU rQ rP rR r r r compile s 6
zCCompiler.compilec C s dS )z Compile 'src' to product 'obj'.Nr )r rQ rP rR rU rf rN r r r ri C s zCCompiler._compilec C s dS )a& Link a bunch of stuff together to create a static library file.
The "bunch of stuff" consists of the list of object files supplied
as 'objects', the extra object files supplied to
'add_link_object()' and/or 'set_link_objects()', the libraries
supplied to 'add_library()' and/or 'set_libraries()', and the
libraries supplied as 'libraries' (if any).
'output_libname' should be a library name, not a filename; the
filename will be inferred from the library name. 'output_dir' is
the directory where the library file will be put.
'debug' is a boolean; if true, debugging information will be
included in the library (note that on most platforms, it is the
compile step where this matters: the 'debug' flag is included here
just for consistency).
'target_lang' is the target language for which the given objects
are being compiled. This allows specific linkage time treatment of
certain languages.
Raises LibError on failure.
Nr )r r output_libnamer rT target_langr r r create_static_libI s zCCompiler.create_static_libZ
shared_objectZshared_library
executablec C s t dS )au Link a bunch of stuff together to create an executable or
shared library file.
The "bunch of stuff" consists of the list of object files supplied
as 'objects'. 'output_filename' should be a filename. If
'output_dir' is supplied, 'output_filename' is relative to it
(i.e. 'output_filename' can provide directory components if
needed).
'libraries' is a list of libraries to link against. These are
library names, not filenames, since they're translated into
filenames in a platform-specific way (eg. "foo" becomes "libfoo.a"
on Unix and "foo.lib" on DOS/Windows). However, they can include a
directory component, which means the linker will look in that
specific directory rather than searching all the normal locations.
'library_dirs', if supplied, should be a list of directories to
search for libraries that were specified as bare library names
(ie. no directory component). These are on top of the system
default and those supplied to 'add_library_dir()' and/or
'set_library_dirs()'. 'runtime_library_dirs' is a list of
directories that will be embedded into the shared library and used
to search for other shared libraries that *it* depends on at
run-time. (This may only be relevant on Unix.)
'export_symbols' is a list of symbols that the shared library will
export. (This appears to be relevant only on Windows.)
'debug' is as for 'compile()' and 'create_static_lib()', with the
slight distinction that it actually matters on most platforms (as
opposed to 'create_static_lib()', which includes a 'debug' flag
mostly for form's sake).
'extra_preargs' and 'extra_postargs' are as for 'compile()' (except
of course that they supply command-line arguments for the
particular linker being used).
'target_lang' is the target language for which the given objects
are being compiled. This allows specific linkage time treatment of
certain languages.
Raises LinkError on failure.
N)NotImplementedError)r Z target_descr output_filenamer r r r export_symbolsrT re rf
build_temprl r r r linki s 9zCCompiler.linkc
C s2 | j tj|| j|dd||||||| |
| |
d S )Nshared)lib_type)rs r SHARED_LIBRARYlibrary_filename)
r r rk r r r r rq rT re rf rr rl r r r link_shared_lib s
zCCompiler.link_shared_libc
C s( | j tj||||||||| |
| |
d S )N)rs r
SHARED_OBJECT)
r r rp r r r r rq rT re rf rr rl r r r link_shared_object s
z CCompiler.link_shared_objectc C s. | j tj|| j|||||d ||| d |
d S )N)rs r
EXECUTABLEexecutable_filename) r r Zoutput_prognamer r r r rT re rf rl r r r link_executable s
zCCompiler.link_executablec C s t dS )zkReturn the compiler option to add 'dir' to the list of
directories searched for libraries.
N)ro )r r5 r r r library_dir_option s z CCompiler.library_dir_optionc C s t dS )zsReturn the compiler option to add 'dir' to the list of
directories searched for runtime libraries.
N)ro )r r5 r r r runtime_library_dir_option s z$CCompiler.runtime_library_dir_optionc C s t dS )zReturn the compiler option to add 'lib' to the list of libraries
linked into the shared library or executable.
N)ro )r libr r r library_option s zCCompiler.library_optionc C s ddl }|dkrg }|dkr g }|dkr,g }|dkr8g }|jd|dd\}}tj|d} z.x|D ]}
| jd|
q`W | jd| W d| j X y| j|g|d } W n tk
r d
S X y| j| d ||d W n t t
fk
r d
S X dS )
zReturn a boolean indicating whether funcname is supported on
the current platform. The optional arguments can be used to
augment the compilation environment.
r Nz.cT)textwz#include "%s"
z+main (int argc, char **argv) {
%s();
}
)r Fza.out)r r ) tempfileZmkstemprH fdopenwritecloserj Z CompileErrorr} Z LinkErrorr0 ) r funcnameZincludesr r r r fdZfnamefZinclr r r r has_function s8
zCCompiler.has_functionc C s t dS )aH Search the specified list of directories for a static or shared
library file 'lib' and return the full path to that file. If
'debug' true, look for a debugging version (if that makes sense on
the current platform). Return None if 'lib' wasn't found in any of
the specified directories.
N)ro )r r7 r rT r r r find_library_file# s zCCompiler.find_library_file c C s |d kr d}g }x|D ]|}t jj|\}}t jj|d }|t jj|d }|| jkrhtd||f |rxt jj|}|jt jj ||| j
qW |S )Nr r( z"unknown file type '%s' (from '%s')) rH rI rJ
splitdriveisabssrc_extensionsZUnknownFileErrorbasenamer2 join
obj_extension)r Zsource_filenamesrC r Z obj_namesZsrc_namerc rR r r r rE N s
zCCompiler.object_filenamesc C s$ |rt jj|}t jj||| j S )N)rH rI r r shared_lib_extension)r r rC r r r r shared_object_filename_ s z CCompiler.shared_object_filenamec C s( |rt jj|}t jj||| jp"d S )Nr )rH rI r r
exe_extension)r r rC r r r r r| e s z CCompiler.executable_filenamestaticc
C s` |d krt dt| |d }t| |d }tjj|\}}|||f } |rPd}tjj||| S )
Nr rt dylib
xcode_stubz?'lib_type' must be "static", "shared", "dylib", or "xcode_stub"Z _lib_formatZ_lib_extensionr )r rt r r )r getattrrH rI splitr )
r r9 ru rC r ZfmtrR r5 rc filenamer r r rw k s zCCompiler.library_filenamer( c C s t j| d S )N)r
rT )r msglevelr r r announce~ s zCCompiler.announcec C s ddl m} |rt| d S )Nr )DEBUG)Zdistutils.debugr print)r r r r r r debug_print s zCCompiler.debug_printc C s t jjd| d S )Nz warning: %s
)sysstderrr )r r r r r warn s zCCompiler.warnc C s t |||| j d S )N)r r
)r funcargsr r r r r r s zCCompiler.executec C s t || jd d S )N)r
)r r
)r cmdr r r r s zCCompiler.spawnc C s t ||| jdS )N)r
)r r
)r rP dstr r r r s zCCompiler.move_file c C s t ||| jd d S )N)r
)r r
)r r) moder r r r s zCCompiler.mkpath)r r r )N)N)NNNNN)NNNr NNN)Nr N)
NNNNNr NNNN)
NNNNNr NNNN)
NNNNNr NNNN)NNNNr NNN)NNNN)r )r r )r r )r r )r r r )r( )Nr( )r )Br!
__module__ __qualname____doc__Z
compiler_typer r Zstatic_lib_extensionr Zstatic_lib_formatZshared_lib_formatr r_ r^ r r# r r, r1 r3 r4 r6 r8 r: r; r< r= r> r? rA rB rS rV rW rX rY rZ r] rd rg rj ri rm ry rv r{ rs rx rz r} r~ r r r r rE r r| rw r r r r r r r r r r r r s
$
+
"
B
4
*
+
r cygwin.*unixposixntmsvcc C sV | dkrt j} |dkr tj}x4tD ],\}}tj||dk sJtj|| dk r"|S q"W dS )ak Determine the default compiler to use for the given platform.
osname should be one of the standard Python OS names (i.e. the
ones returned by os.name) and platform the common value
returned by sys.platform for the platform in question.
The default values are os.name and sys.platform in case the
parameters are not given.
Nr )rH r) r platform_default_compilersrematch)osnamer patterncompilerr r r get_default_compiler s
r
unixccompiler
UnixCCompiler standard UNIX-style compiler
_msvccompiler MSVCCompilerMicrosoft Visual C++cygwinccompilerCygwinCCompiler'Cygwin port of GNU C Compiler for Win32Mingw32CCompiler(Mingw32 port of GNU C Compiler for Win32 bcppcompiler BCPPCompilerBorland C++ Compiler)r r cygwinZmingw32Zbcppc C s\ ddl m} g }x,tj D ] }|jd| dt| d f qW |j | |}|jd dS )zyPrint list of available compilers (used by the "--help-compiler"
options to "build", "build_ext", "build_clib").
r ) FancyGetoptz compiler=Nr- z List of available compilers:)Zdistutils.fancy_getoptr compiler_classr r2 sortZ
print_help)r Z compilersr Zpretty_printerr r r show_compilers s r c C s | dkrt j} y"|dkr t| }t| \}}}W n8 tk
rh d| }|dk r\|d| }t|Y nX y*d| }t| tj| } t | | }
W nB t
k
r t d| Y n$ tk
r t d||f Y nX |
d||S )a[ Generate an instance of some CCompiler subclass for the supplied
platform/compiler combination. 'plat' defaults to 'os.name'
(eg. 'posix', 'nt'), and 'compiler' defaults to the default compiler
for that platform. Currently only 'posix' and 'nt' are supported, and
the default compilers are "traditional Unix interface" (UnixCCompiler
class) and Visual C++ (MSVCCompiler class). Note that it's perfectly
possible to ask for a Unix compiler object under Windows, and a
Microsoft compiler object under Unix -- if you supply a value for
'compiler', 'plat' is ignored.
Nz5don't know how to compile C/C++ code on platform '%s'z with '%s' compilerz
distutils.z4can't compile C/C++ code: unable to load module '%s'zBcan't compile C/C++ code: unable to find class '%s' in module '%s') rH r) r r rh ZDistutilsPlatformError
__import__r modulesvars ImportErrorZDistutilsModuleError) Zplatr r r
r Z module_name
class_nameZlong_descriptionr moduleklassr r r new_compiler s2
r c C s g }x| D ]}t |to2dt| ko.dkn s@td| t|dkr`|jd|d q
t|dkr
|d dkr|jd|d q
|jd| q
W x|D ]}|jd | qW |S )
a Generate C pre-processor options (-D, -U, -I) as used by at least
two types of compilers: the typical Unix compiler and Visual C++.
'macros' is the usual thing, a list of 1- or 2-tuples, where (name,)
means undefine (-U) macro 'name', and (name,value) means define (-D)
macro 'name' to 'value'. 'include_dirs' is just a list of directory
names to be added to the header file search path (-I). Returns a list
of command-line options suitable for either Unix compilers or Visual
C++.
r( r- zPbad macro definition '%s': each element of 'macros' list must be a 1- or 2-tuplez-U%sr Nz-D%sz-D%s=%sz-I%s)r$ r. r/ r0 r2 )r r rN Zmacror5 r r r rF
s
&
rF c C s g }x |D ]}|j | j| q
W x4|D ],}| j|}t|trJ|| }q(|j | q(W x^|D ]V}tjj|\}} |r| j|g| }
|
r|j |
q| j d| q^|j | j
| q^W |S )ac Generate linker options for searching library directories and
linking with specific libraries. 'libraries' and 'library_dirs' are,
respectively, lists of library names (not filenames!) and search
directories. Returns a list of command-line options suitable for use
with some compiler (depending on the two format strings passed in).
z6no library file corresponding to '%s' found (skipping)) r2 r~ r r$ rD rH rI r r r r ) r r r r Zlib_optsr5 optr Zlib_dirZlib_nameZlib_filer r r gen_lib_options7 s$
r r r r r r r )r r r )NN)r r r )r r r )r r r )r r r )r r r )NNr r r )r r rH r Zdistutils.errorsZdistutils.spawnr Zdistutils.file_utilr Zdistutils.dir_utilr Zdistutils.dep_utilr r Zdistutils.utilr r Z distutilsr
r r r r r r rF r r r r r sD
--PK ! (ߟ
! __pycache__/config.cpython-36.pycnu [ 3
\ @ s< d Z ddlZddlmZ ddlmZ dZG dd deZdS )zdistutils.pypirc
Provides the PyPIRCCommand class, the base class for the command classes
that uses .pypirc in the distutils.command package.
N)RawConfigParser)CommandzE[distutils]
index-servers =
pypi
[pypi]
username:%s
password:%s
c @ sh e Zd ZdZdZdZdZdZddde fdgZdgZ d
d Z
d d
Z dd Z dd Z
dd Zdd ZdS )
PyPIRCCommandz;Base command that knows how to handle the .pypirc file
z https://upload.pypi.org/legacy/pypiNz repository=rz url of repository [default: %s]
show-response&display full response text from serverc C s t jjt jjddS )zReturns rc file path.~z.pypirc)ospathjoin
expanduser)self r (/usr/lib64/python3.6/distutils/config.py _get_rc_file& s zPyPIRCCommand._get_rc_filec C sH | j }tjtj|tjtjB dd}|jt||f W dQ R X dS )z Creates a default .pypirc file.i wN)r r
fdopenopenO_CREATO_WRONLYwriteDEFAULT_PYPIRC)r usernamepasswordrcfr r r
_store_pypirc* s zPyPIRCCommand._store_pypircc C s | j }tjj|r| jd| | jp.| j}| jp:| j}t }|j
| |j }d|krR|j dd}dd |j
dD }|g krd|krdg}ni S x|D ]}d|i} |j |d | d < xHd
| jfd | jfdfD ].\}
} |j||
r|j ||
| |
< q| | |
< qW |dkr.|| jdfkr.| j| d
< | S | d |ksH| d
|kr| S qW nRd|krd}|j|d
r||j |d
}n| j}|j |d |j |d ||| jdS i S )zReads the .pypirc file.zUsing PyPI login from %sZ distutilsz
index-serversc S s g | ]}|j d kr|j qS ) )strip).0serverr r r
> s z.PyPIRCCommand._read_pypirc..
r r! r
repositoryrealmr Nz server-login)r r r$ r! r% )r N)r r
r existsZannouncer$ DEFAULT_REPOSITORYr%
DEFAULT_REALMr readsectionsgetsplitZ
has_option) r r r$ r% configr* Z
index_serversZ_serversr! Zcurrentkeydefaultr r r _read_pypirc0 sX
zPyPIRCCommand._read_pypircc C s8 ddl }|jdd}|j|d jdd}|j j|S )z%Read and decode a PyPI HTTP response.r Nz content-typez
text/plain charsetascii)cgiZ getheaderZ parse_headerr+ r) decode)r Zresponser4 Z content_typeencodingr r r _read_pypi_responseq s z!PyPIRCCommand._read_pypi_responsec C s d| _ d| _d| _dS )zInitialize options.Nr )r$ r% Z
show_response)r r r r initialize_optionsx s z PyPIRCCommand.initialize_optionsc C s( | j dkr| j| _ | jdkr$| j| _dS )zFinalizes options.N)r$ r' r% r( )r r r r finalize_options~ s
z PyPIRCCommand.finalize_options)r Nr )__name__
__module__ __qualname____doc__r' r( r$ r% Z user_optionsZboolean_optionsr r r0 r7 r8 r9 r r r r r s" Ar )r= r
Z configparserr Z
distutils.cmdr r r r r r r s
PK ! c - __pycache__/fancy_getopt.cpython-36.opt-2.pycnu [ 3
\xE @ s d dl Z d dlZd dlZd dlZd dlT dZejde Zejdeef Ze j
ddZ G dd d Z d
d Z
d d
ejD Zdd Zdd ZG dd dZedkrdZx2d D ]*Zede edjeee e qW dS ) N)*z[a-zA-Z](?:[a-zA-Z0-9-]*)z^%s$z ^(%s)=!(%s)$-_c @ s e Zd Zd ddZdd Zdd Zd dd Zd
d Zd d
Zdd Z dd Z
dd Z dd Z d ddZ
dd Zd!ddZd"d d ZdS )# FancyGetoptNc C sN || _ i | _| j r| j i | _i | _g | _g | _i | _i | _i | _ g | _
d S )N) option_table option_index _build_indexaliasnegative_alias
short_opts long_opts
short2long attr_name takes_arg option_order)selfr r ./usr/lib64/python3.6/distutils/fancy_getopt.py__init__) s zFancyGetopt.__init__c C s, | j j x | jD ]}|| j |d < qW d S )Nr )r clearr )r optionr r r r Q s
zFancyGetopt._build_indexc C s || _ | j d S )N)r r )r r r r r set_option_tableV s z FancyGetopt.set_option_tablec C s< || j krtd| n |||f}| jj| || j |< d S )Nz'option conflict: already an option '%s')r DistutilsGetoptErrorr append)r long_optionZ short_optionZ help_stringr r r r
add_optionZ s
zFancyGetopt.add_optionc C s
|| j kS )N)r )r r r r r
has_optionc s zFancyGetopt.has_optionc C s
|j tS )N) translate
longopt_xlate)r r r r r
get_attr_nameh s zFancyGetopt.get_attr_namec C sR xL|j D ]@\}}|| jkr.td|||f || jkr
td|||f q
W d S )Nz(invalid %s '%s': option '%s' not definedz0invalid %s '%s': aliased option '%s' not defined)itemsr r )r aliasesZwhatr optr r r _check_alias_dictn s
z FancyGetopt._check_alias_dictc C s | j |d || _d S )Nr )r# r )r r r r r set_aliasesx s zFancyGetopt.set_aliasesc C s | j |d || _d S )Nznegative alias)r# r
)r r
r r r set_negative_aliases} s z FancyGetopt.set_negative_aliasesc C s g | _ g | _| jj i | _x| jD ]}t|dkrH|\}}}d}n(t|dkrb|\}}}}ntd|f t|t st|dk rt
d| |d kpt|t ot|dkst
d| || j|< | j j | |d d kr|r|d
}|dd }d| j |< nF| j
j|}|d k rB| j | r8t
d ||f || j d< d| j |< | jj|}|d k r| j | | j | krt
d ||f tj|st
d
| | j|| j|< |r&| jj | || j|d < q&W d S )N r zinvalid option tuple: %r z9invalid long option '%s': must be a string of length >= 2 z:invalid short option '%s': must a single character or None=:z>invalid negative alias '%s': aliased option '%s' takes a valuezginvalid alias '%s': inconsistent with aliased option '%s' (one of them takes a value, the other doesn'tzEinvalid long option name '%s' (must be letters, numbers, hyphens onlyr, r, )r r r
r repeatr len
ValueError
isinstancestrr r r r
getr
longopt_rematchr r )r r longshorthelpr- Zalias_tor r r _grok_option_table s^
z FancyGetopt._grok_option_tablec C sr |d krt jdd }|d kr*t }d}nd}| j dj| j}ytj||| j\}}W n, tjk
r } zt |W Y d d }~X nX x|D ]\}}t
|dkr|d dkr| j |d }n |dd }| j j
|} | r| }| j| s
| jj
|} | r| }d}nd}| j| }
|r<| jj
|
d k r sB
zFancyGetopt.getoptc C s | j d krtdn| j S d S )Nz!'getopt()' hasn't been called yet)r RuntimeError)r r r r get_option_order s
z FancyGetopt.get_option_orderc C sx d}xV| j D ]L}|d }|d }t|}|d dkr<|d }|d k rL|d }||kr |}q W |d d d }d}|| } d| }
|r|g} ndg} x| j D ]}|d d \}}} t| | }
|d dkr|dd }|d kr|
r| jd
|||
d f n| jd ||f n:d ||f }|
r<| jd
|||
d f n| jd
| x$|
dd D ]}| j|
| qXW qW | S )Nr r) r* r( N r9 zOption summary:r& z --%-*s %sz
--%-*s z%s (-%s)z --%-*sr, r, r, )r r. wrap_textr )r headerZmax_optr r5 r6 lZ opt_widthZ
line_widthZ
text_widthZ
big_indentlinesr7 textZ opt_namesr r r
generate_help sF
zFancyGetopt.generate_helpc C s4 |d krt j}x | j|D ]}|j|d qW d S )N
)r: stdoutrP write)r rL fileliner r r
print_helph s zFancyGetopt.print_help)N)NN)NN)N)NN)__name__
__module__ __qualname__r r r r r r r# r$ r% r8 r> rH rP rV r r r r r s
(
M
=
Or c C s t | }|j| |j||S )N)r r% r> )optionsZ negative_optrC rB parserr r r fancy_getopto s
r\ c C s i | ]}d t |qS )r9 )ord).0Z_wscharr r r
u s r_ c C s" | d kr g S t | |kr | gS | j } | jt} tjd| }dd |D }g }x|r g }d}xZ|rt |d }|| |kr|j|d |d= || }q`|r|d d dkr|d = P q`W |r
|dkr|j|d d| |d |d |d< |d d dkr
|d= |jdj| qPW |S )
Nz( +|-+)c S s g | ] }|r|qS r r )r^ Zchr r r
s z wrap_text..r r) r9 r, r, )r.
expandtabsr WS_TRANSresplitr r= )rO widthZchunksrN Zcur_lineZcur_lenrM r r r rK w s:
rK c C s
| j tS )N)r r )r" r r r translate_longopt s rg c @ s e Zd Zg fddZdS )r< c C s x|D ]}t | |d qW d S )N)rA )r rZ r" r r r r s
zOptionDummy.__init__N)rW rX rY r r r r r r< s r< __main__zTra-la-la, supercalifragilisticexpialidocious.
How *do* you spell that odd word, anyways?
(Someone ask Mary -- she'll know [or she'll
say, "How should I know?"].)
( z width: %drQ )ri rj rk rl )r: stringrd r> Zdistutils.errorsZ longopt_patcompiler3 Z neg_alias_rer1 maketransr r r\ Z
whitespacerc rK rg r< rW rO wprintr= r r r r s( T6
PK ! &
) __pycache__/filelist.cpython-36.opt-2.pycnu [ 3
\ 2 @ s d dl Z d dlZd dlZd dlZd dlmZ d dlmZmZ d dl m
Z
G dd dZ dd Z e j
fd d
Zd d ZdddZdS ) N) convert_path)DistutilsTemplateErrorDistutilsInternalError)logc @ sx e Zd Zd ddZdd ZejfddZdd Zd
d Z d d
Z
dd Z dd Z dd Z
dd Zd ddZd ddZdS ) FileListNc C s d | _ g | _d S )N)allfilesfiles)selfwarn debug_print r */usr/lib64/python3.6/distutils/filelist.py__init__ s zFileList.__init__c C s
|| _ d S )N)r )r r r r r
set_allfiles# s zFileList.set_allfilesc C s t || _d S )N)findallr )r dirr r r
r & s zFileList.findallc C s ddl m} |rt| d S )Nr )DEBUG)Zdistutils.debugr print)r msgr r r r
r ) s zFileList.debug_printc C s | j j| d S )N)r append)r itemr r r
r 3 s zFileList.appendc C s | j j| d S )N)r extend)r itemsr r r
r 6 s zFileList.extendc C s@ t ttjj| j}g | _x |D ]}| jjtjj| q W d S )N)sortedmapospathsplitr r join)r Zsortable_filesZ
sort_tupler r r
sort9 s
z
FileList.sortc C sD x>t t| jd ddD ]$}| j| | j|d kr| j|= qW d S )N r )rangelenr )r ir r r
remove_duplicatesC s zFileList.remove_duplicatesc C s |j }|d }d } }}|dkrTt|dk r ...c S s g | ] }t |qS r )r ).0wr r r
W s z1FileList._parse_template_line..r recursive-includerecursive-exclude z,'%s' expects ...c S s g | ] }t |qS r )r )r+ r, r r r
r- ] s graftprunez#'%s' expects a single zunknown action '%s')r& r' r( r) )r. r/ )r1 r2 )r r# r r )r lineZwordsactionpatternsr dir_patternr r r
_parse_template_lineL s,
z FileList._parse_template_linec C sX | j |\}}}}|dkrZ| jddj| x&|D ] }| j|dds4tjd| q4W n|dkr| jddj| x&|D ] }| j|dds|tjd | q|W n|d
kr| jd dj| x&|D ] }| j|d dstjd
| qW nj|dkr8| jddj| x*|D ]"}| j|d dstjd| qW n |dkr| jd|dj|f x,|D ]$}| j||ds`tjd|| q`W n|dkr| jd|dj|f x|D ]$}| j||dstjd|| qW nx|dkr| jd| | jd |dsTtjd| nB|dkrH| jd | | jd |dsTtjd | n td | d S ) Nr& zinclude r )anchorz%warning: no files found matching '%s'r' zexclude z9warning: no previously-included files found matching '%s'zglobal-includezglobal-include r z>warning: no files found matching '%s' anywhere in distributionzglobal-excludezglobal-exclude zRwarning: no previously-included files matching '%s' found anywhere in distributionzrecursive-includezrecursive-include %s %s)prefixz:warning: no files found matching '%s' under directory '%s'zrecursive-excludezrecursive-exclude %s %szNwarning: no previously-included files matching '%s' found under directory '%s'r1 zgraft z+warning: no directories found matching '%s'r2 zprune z6no previously-included directories found matching '%s'z'this cannot happen: invalid action '%s')r7 r r include_patternr r
exclude_patternr )r r3 r4 r5 r r6 patternr r r
process_template_lineh sf
z FileList.process_template_liner r c C sp d}t ||||}| jd|j | jd kr4| j x6| jD ],}|j|r<| jd| | jj| d}q r; r< r r r r
r s
L
,r c C s& dd t j| ddD }tt jj|S )Nc s s, | ]$\}}}|D ]}t jj||V qqd S )N)r r r )r+ basedirsr filer r r
s z#_find_all_simple..T) followlinks)r walkfilterr isfile)r Zresultsr r r
_find_all_simple s rQ c C s6 t | }| tjkr.tjtjj| d}t||}t|S )N)start) rQ r rH functoolspartialr relpathr list)r r Zmake_relr r r
r s
r c C s8 t j| }tj}tjdkr d}d| }tjd||}|S )N\z\\\\z\1[^%s]z((?t| }nd}|d k rt|}|t|t|t| }tj} tjdkrd} |t|t|t| }d||| ||f }n |rd||t|d f }tj|S )N_ rW z\\z%s\A%s%s.*%s%sz%s\A%s)
isinstancestrr[ compiler] partitionr# r rZ )
r= r9 r: rA rR r^ endrC Z prefix_rerZ r r r
r? % s(
r? )r Nr )r r[ rX rS Zdistutils.utilr Zdistutils.errorsr r Z distutilsr r rQ rH r r] r? r r r r
s i PK ! 5L
!
! * __pycache__/text_file.cpython-36.opt-1.pycnu [ 3
\0 @ s& d Z ddlZddlZG dd dZdS )ztext_file
provides the TextFile class, which gives an interface to text files
that (optionally) takes care of stripping comments, ignoring blank
lines, and joining lines with backslashes. Nc @ st e Zd ZdZddddddddZdddZd d
Zd d Zdd
dZdddZ d ddZ
dd Z dd Z dd Z
dS ) TextFilea Provides a file-like object that takes care of all the things you
commonly want to do when processing a text file that has some
line-by-line syntax: strip comments (as long as "#" is your
comment character), skip blank lines, join adjacent lines by
escaping the newline (ie. backslash at end of line), strip
leading and/or trailing whitespace. All of these are optional
and independently controllable.
Provides a 'warn()' method so you can generate warning messages that
report physical line number, even if the logical line in question
spans multiple physical lines. Also provides 'unreadline()' for
implementing line-at-a-time lookahead.
Constructor is called as:
TextFile (filename=None, file=None, **options)
It bombs (RuntimeError) if both 'filename' and 'file' are None;
'filename' should be a string, and 'file' a file object (or
something that provides 'readline()' and 'close()' methods). It is
recommended that you supply at least 'filename', so that TextFile
can include it in warning messages. If 'file' is not supplied,
TextFile creates its own using 'io.open()'.
The options are all boolean, and affect the value returned by
'readline()':
strip_comments [default: true]
strip from "#" to end-of-line, as well as any whitespace
leading up to the "#" -- unless it is escaped by a backslash
lstrip_ws [default: false]
strip leading whitespace from each line before returning it
rstrip_ws [default: true]
strip trailing whitespace (including line terminator!) from
each line before returning it
skip_blanks [default: true}
skip lines that are empty *after* stripping comments and
whitespace. (If both lstrip_ws and rstrip_ws are false,
then some lines may consist of solely whitespace: these will
*not* be skipped, even if 'skip_blanks' is true.)
join_lines [default: false]
if a backslash is the last non-newline character on a line
after stripping comments and whitespace, join the following line
to it to form one "logical line"; if N consecutive lines end
with a backslash, then N+1 physical lines will be joined to
form one logical line.
collapse_join [default: false]
strip leading whitespace from lines that are joined to their
predecessor; only matters if (join_lines and not lstrip_ws)
errors [default: 'strict']
error handler used to decode the file content
Note that since 'rstrip_ws' can strip the trailing newline, the
semantics of 'readline()' must differ from those of the builtin file
object's 'readline()' method! In particular, 'readline()' returns
None for end-of-file: an empty string might just be a blank line (or
an all-whitespace line), if 'rstrip_ws' is true but 'skip_blanks' is
not. r strict)strip_comments skip_blanks lstrip_ws rstrip_ws
join_lines
collapse_joinerrorsNc K s |dkr|dkrt dx>| jj D ]0}||krBt| ||| q$t| || j| q$W x&|j D ]}|| jkrbtd| qbW |dkr| j| n|| _|| _d| _g | _ dS )zConstruct a new TextFile object. At least one of 'filename'
(a string) and 'file' (a file-like object) must be supplied.
They keyword argument options are described above and affect
the values returned by 'readline()'.Nz7you must supply either or both of 'filename' and 'file'z invalid TextFile option '%s'r )
RuntimeErrordefault_optionskeyssetattrKeyErroropenfilenamefile current_linelinebuf)selfr r Zoptionsopt r +/usr/lib64/python3.6/distutils/text_file.py__init__N s
zTextFile.__init__c C s& || _ tj| j d| jd| _d| _dS )zyOpen a new file named 'filename'. This overrides both the
'filename' and 'file' arguments to the constructor.r)r r N)r ior r r r )r r r r r r o s z
TextFile.openc C s$ | j }d| _ d| _d| _|j dS )ziClose the current file and forget everything we know about it
(filename, current line number).N)r r r close)r r r r r r v s
zTextFile.closec C sj g }|d kr| j }|j| jd t|ttfrD|jdt| n|jd| |jt| dj|S )Nz, z
lines %d-%d: z line %d: )r appendr
isinstancelisttuplestrjoin)r msglineZoutmsgr r r gen_error s zTextFile.gen_errorc C s t d| j|| d S )Nzerror: )
ValueErrorr' )r r% r& r r r error s zTextFile.errorc C s t jjd| j|| d dS )a Print (to stderr) a warning message tied to the current logical
line in the current file. If the current logical line in the
file spans multiple physical lines, the warning refers to the
whole range, eg. "lines 3-5". If 'line' supplied, it overrides
the current line number; it may be a list or tuple to indicate a
range of physical lines, or an integer for a single physical
line.z warning:
N)sysstderrwriter' )r r% r& r r r warn s z
TextFile.warnc C s | j r | j d }| j d
= |S d}x| jj }|dkr:d}| jr|r|jd}|dkrXnX|dksp||d dkr|d dkrdpd}|d| | }|j dkrq$n |jdd}| jo|r |dkr| jd |S | j r|j
}|| }t | j t
r | j d d | j d< n| j | j d g| _ n:|dkr.dS t | j t
rN| j d d | _ n | j d | _ | jrt| jrt|j }n"| jr|j
}n| jr|j }|dks|dkr| jrq$| jr|d dkr|dd }q$|dd d kr|dd d }q$|S dS )aU Read and return a single logical line from the current file (or
from an internal buffer if lines have previously been "unread"
with 'unreadline()'). If the 'join_lines' option is true, this
may involve reading multiple physical lines concatenated into a
single string. Updates the current line number, so calling
'warn()' after 'readline()' emits a warning about the physical
line(s) just read. Returns None on end-of-file, since the empty
string can occur if 'rstrip_ws' is true but 'strip_blanks' is
not.r r N#r \r* z\#z2continuation line immediately precedes end-of-file z\
r2 r2 r2 r2 r2 r3 )r r readliner findstripreplacer r. r
lstripr r r! r r rstripr )r r& Z buildup_lineposZeolr r r r4 sf
zTextFile.readlinec C s, g }x"| j }|dkr|S |j| qW dS )zWRead and return the list of all logical lines remaining in the
current file.N)r4 r )r linesr& r r r readlines s zTextFile.readlinesc C s | j j| dS )zPush 'line' (a string) onto an internal buffer that will be
checked by future 'readline()' calls. Handy for implementing
a parser with line-at-a-time lookahead.N)r r )r r& r r r
unreadline s zTextFile.unreadline)NN)N)N)N)__name__
__module__ __qualname____doc__r
r r r r' r) r. r4 r< r= r r r r r
s" 9
!
x
r )rA r+ r r r r r r s PK ! 5L
!
! $ __pycache__/text_file.cpython-36.pycnu [ 3
\0 @ s& d Z ddlZddlZG dd dZdS )ztext_file
provides the TextFile class, which gives an interface to text files
that (optionally) takes care of stripping comments, ignoring blank
lines, and joining lines with backslashes. Nc @ st e Zd ZdZddddddddZdddZd d
Zd d Zdd
dZdddZ d ddZ
dd Z dd Z dd Z
dS ) TextFilea Provides a file-like object that takes care of all the things you
commonly want to do when processing a text file that has some
line-by-line syntax: strip comments (as long as "#" is your
comment character), skip blank lines, join adjacent lines by
escaping the newline (ie. backslash at end of line), strip
leading and/or trailing whitespace. All of these are optional
and independently controllable.
Provides a 'warn()' method so you can generate warning messages that
report physical line number, even if the logical line in question
spans multiple physical lines. Also provides 'unreadline()' for
implementing line-at-a-time lookahead.
Constructor is called as:
TextFile (filename=None, file=None, **options)
It bombs (RuntimeError) if both 'filename' and 'file' are None;
'filename' should be a string, and 'file' a file object (or
something that provides 'readline()' and 'close()' methods). It is
recommended that you supply at least 'filename', so that TextFile
can include it in warning messages. If 'file' is not supplied,
TextFile creates its own using 'io.open()'.
The options are all boolean, and affect the value returned by
'readline()':
strip_comments [default: true]
strip from "#" to end-of-line, as well as any whitespace
leading up to the "#" -- unless it is escaped by a backslash
lstrip_ws [default: false]
strip leading whitespace from each line before returning it
rstrip_ws [default: true]
strip trailing whitespace (including line terminator!) from
each line before returning it
skip_blanks [default: true}
skip lines that are empty *after* stripping comments and
whitespace. (If both lstrip_ws and rstrip_ws are false,
then some lines may consist of solely whitespace: these will
*not* be skipped, even if 'skip_blanks' is true.)
join_lines [default: false]
if a backslash is the last non-newline character on a line
after stripping comments and whitespace, join the following line
to it to form one "logical line"; if N consecutive lines end
with a backslash, then N+1 physical lines will be joined to
form one logical line.
collapse_join [default: false]
strip leading whitespace from lines that are joined to their
predecessor; only matters if (join_lines and not lstrip_ws)
errors [default: 'strict']
error handler used to decode the file content
Note that since 'rstrip_ws' can strip the trailing newline, the
semantics of 'readline()' must differ from those of the builtin file
object's 'readline()' method! In particular, 'readline()' returns
None for end-of-file: an empty string might just be a blank line (or
an all-whitespace line), if 'rstrip_ws' is true but 'skip_blanks' is
not. r strict)strip_comments skip_blanks lstrip_ws rstrip_ws
join_lines
collapse_joinerrorsNc K s |dkr|dkrt dx>| jj D ]0}||krBt| ||| q$t| || j| q$W x&|j D ]}|| jkrbtd| qbW |dkr| j| n|| _|| _d| _g | _ dS )zConstruct a new TextFile object. At least one of 'filename'
(a string) and 'file' (a file-like object) must be supplied.
They keyword argument options are described above and affect
the values returned by 'readline()'.Nz7you must supply either or both of 'filename' and 'file'z invalid TextFile option '%s'r )
RuntimeErrordefault_optionskeyssetattrKeyErroropenfilenamefile current_linelinebuf)selfr r Zoptionsopt r +/usr/lib64/python3.6/distutils/text_file.py__init__N s
zTextFile.__init__c C s& || _ tj| j d| jd| _d| _dS )zyOpen a new file named 'filename'. This overrides both the
'filename' and 'file' arguments to the constructor.r)r r N)r ior r r r )r r r r r r o s z
TextFile.openc C s$ | j }d| _ d| _d| _|j dS )ziClose the current file and forget everything we know about it
(filename, current line number).N)r r r close)r r r r r r v s
zTextFile.closec C sj g }|d kr| j }|j| jd t|ttfrD|jdt| n|jd| |jt| dj|S )Nz, z
lines %d-%d: z line %d: )r appendr
isinstancelisttuplestrjoin)r msglineZoutmsgr r r gen_error s zTextFile.gen_errorc C s t d| j|| d S )Nzerror: )
ValueErrorr' )r r% r& r r r error s zTextFile.errorc C s t jjd| j|| d dS )a Print (to stderr) a warning message tied to the current logical
line in the current file. If the current logical line in the
file spans multiple physical lines, the warning refers to the
whole range, eg. "lines 3-5". If 'line' supplied, it overrides
the current line number; it may be a list or tuple to indicate a
range of physical lines, or an integer for a single physical
line.z warning:
N)sysstderrwriter' )r r% r& r r r warn s z
TextFile.warnc C s | j r | j d }| j d
= |S d}x| jj }|dkr:d}| jr|r|jd}|dkrXnX|dksp||d dkr|d dkrdpd}|d| | }|j dkrq$n |jdd}| jo|r |dkr| jd |S | j r|j
}|| }t | j t
r | j d d | j d< n| j | j d g| _ n:|dkr.dS t | j t
rN| j d d | _ n | j d | _ | jrt| jrt|j }n"| jr|j
}n| jr|j }|dks|dkr| jrq$| jr|d dkr|dd }q$|dd d kr|dd d }q$|S dS )aU Read and return a single logical line from the current file (or
from an internal buffer if lines have previously been "unread"
with 'unreadline()'). If the 'join_lines' option is true, this
may involve reading multiple physical lines concatenated into a
single string. Updates the current line number, so calling
'warn()' after 'readline()' emits a warning about the physical
line(s) just read. Returns None on end-of-file, since the empty
string can occur if 'rstrip_ws' is true but 'strip_blanks' is
not.r r N#r \r* z\#z2continuation line immediately precedes end-of-file z\
r2 r2 r2 r2 r2 r3 )r r readliner findstripreplacer r. r
lstripr r r! r r rstripr )r r& Z buildup_lineposZeolr r r r4 sf
zTextFile.readlinec C s, g }x"| j }|dkr|S |j| qW dS )zWRead and return the list of all logical lines remaining in the
current file.N)r4 r )r linesr& r r r readlines s zTextFile.readlinesc C s | j j| dS )zPush 'line' (a string) onto an internal buffer that will be
checked by future 'readline()' calls. Handy for implementing
a parser with line-at-a-time lookahead.N)r r )r r& r r r
unreadline s zTextFile.unreadline)NN)N)N)N)__name__
__module__ __qualname____doc__r
r r r r' r) r. r4 r< r= r r r r r
s" 9
!
x
r )rA r+ r r r r r r s PK ! =[Ä
* __pycache__/extension.cpython-36.opt-2.pycnu [ 3
\) @ s* d dl Z d dlZG dd dZdd ZdS ) Nc @ s e Zd ZdddZdd ZdS ) ExtensionNc K s t |tstdt |to,tdd |D s6td|| _|| _|pHg | _|pRg | _|p\g | _ |pfg | _
|ppg | _ |pzg | _ | pg | _
|
pg | _| pg | _| pg | _|
pg | _|pg | _|| _|| _t|dkrdd |D }djt|}d | }tj| d S )
Nz'name' must be a stringc s s | ]}t |tV qd S )N)
isinstancestr).0v r +/usr/lib64/python3.6/distutils/extension.py j s z%Extension.__init__..z#'sources' must be a list of stringsr c S s g | ] }t |qS r )repr)r Zoptionr r r
s z&Extension.__init__..z, z Unknown Extension options: %s)r r AssertionErrorlistallnamesources include_dirs
define_macros undef_macros library_dirs librariesruntime_library_dirs
extra_objectsextra_compile_argsextra_link_argsexport_symbols swig_optsdependslanguageoptionallenjoinsortedwarningswarn)selfr r r r r r r r r r r r r r r r kwZoptionsmsgr r r __init__V s4
zExtension.__init__c C s d| j j| j j| jt| f S )Nz<%s.%s(%r) at %#x>) __class__
__module__ __qualname__r id)r$ r r r __repr__ s
zExtension.__repr__)NNNNNNNNNNNNNN)__name__r) r* r' r, r r r r r s D
!r c C s ddl m}m}m} ddlm} ddlm} || }|| dddddd}zhg }x\|j } | d krfP |j | rrqT| d | d# kodkn r|j
d| qT|| |} || }
|
d } t | g } d }
x|
dd D ]}|
d k r|
j | d }
qt
jj|d }|dd }|d d }|d$kr8| jj | q|dkrP| jj | q|dkr|jd}|d%kr| jj |d f n$| jj |d| ||d d f q|dkr| jj | q|dkr| jj | q|dkr| jj | q|dkr| jj | q|dkr | jj | q|dkr0| j}
q|dkrB| j}
q|dkrT| j}
q|d krx| jj | |s| j}
q|d&kr| jj | q|j
d"| qW |j | qTW W d |j X |S )'Nr )parse_makefileexpand_makefile_vars _variable_rx)TextFile) split_quoted )Zstrip_commentsZ skip_blanksZ
join_linesZ lstrip_wsZ rstrip_ws*z'%s' lines not handled yet .c.cc.cpp.cxx.c++.m.mmz-Iz-D=z-Uz-Cz-lz-Lz-Rz-rpathz-Xlinkerz
-Xcompilerz-u.a.so.sl.o.dylibzunrecognized argument '%s')r6 r7 r8 r9 r: r; r< rC )r> r? r@ rA rB ) Zdistutils.sysconfigr. r/ r0 Zdistutils.text_filer1 Zdistutils.utilr2 readlinematchr# r appendospathsplitextr r findr r r r r r r r close)filenamer. r/ r0 r1 r2 varsfile
extensionslineZwordsmoduleZextZappend_next_wordZwordsuffixZswitchvalueZequalsr r r read_setup_file s
rT )rG r" r rT r r r r s zPK ! J ( __pycache__/unixccompiler.cpython-36.pycnu [ 3
Ii: @ s d Z ddlZddlZddlZddlmZ ddlmZ ddlm Z m
Z
m Z ddl m
Z
mZmZmZ ddlmZ ejdkr~ddlZG d d
d
e ZdS ) a9 distutils.unixccompiler
Contains the UnixCCompiler class, a subclass of CCompiler that handles
the "typical" Unix-style command-line C compiler:
* macros defined with -Dname[=value]
* macros undefined with -Uname
* include search directories specified with -Idir
* libraries specified with -lllib
* library search directories specified with -Ldir
* compile handled by 'cc' (or similar) executable with -c option:
compiles .c to .o
* link static library handled by 'ar' command (possibly with 'ranlib')
* link shared library handled by 'cc -shared'
N) sysconfig)newer) CCompilergen_preprocess_optionsgen_lib_options)DistutilsExecError CompileErrorLibError LinkError)logdarwinc
s e Zd ZdZddgdgdgddgdgddgddZejdd d krNd
ged
< d d d
dddgZdZdZ dZ
dZ dZ d Z
ZZeZejdkrdZ fddZd.dd Zd d Zd/d d!Zd0d"d#Zd$d% Zd&d' Zd(d) Zd*d+ Zd1d,d-Z Z S )2
UnixCCompilerZunixNZccz-sharedarz-cr) preprocessorcompiler compiler_so compiler_cxx linker_so
linker_exearchiverranlib r r z.cz.Cz.ccz.cxxz.cppz.mz.oz.az.soz.dylibz.tbdzlib%s%scygwinz.exec s@ t j|||\}}}tjd}|r6||kr6|j| |||fS )z'Remove standard library path from rpathLIBDIR)super
_fix_lib_argsr get_config_varremove)self libraries library_dirsruntime_library_dirsZlibdir) __class__ //usr/lib64/python3.6/distutils/unixccompiler.pyr U s
zUnixCCompiler._fix_lib_argsc C s | j d ||}|\}}}t||} | j| }
|r>|
jd|g |rN||
d d< |r\|
j| |
j| | js~|d ks~t||r|r| jtj j
| y| j |
W n* t k
r } zt
| W Y d d } ~ X nX d S )Nz-or )Z_fix_compile_argsr r extendappendZforcer mkpathospathdirnamespawnr r ) r sourceZ output_fileZmacrosZ include_dirs
extra_preargsextra_postargs
fixed_argsignorepp_optsZpp_argsmsgr# r# r$
preprocess^ s$
zUnixCCompiler.preprocessc C sp | j }tjdkr tj||| }y | j|| |d|g | W n* tk
rj } zt|W Y d d }~X nX d S )Nr z-o)r sysplatform _osx_supportcompiler_fixupr+ r r ) r objsrcZextZcc_argsr. r1 r r2 r# r# r$ _compilex s
zUnixCCompiler._compiler c C s | j ||\}}| j||d}| j||r| jtjj| | j| j|g | | j | j
ry| j| j
|g W q t k
r } zt |W Y d d }~X qX n t
jd| d S )N)
output_dirzskipping %s (up-to-date))_fix_object_argslibrary_filename
_need_linkr' r( r) r* r+ r objectsr r r r debug)r r? Zoutput_libnamer; r@ target_langoutput_filenamer2 r# r# r$ create_static_lib s z UnixCCompiler.create_static_libc C s | j ||\}}| j|||}|\}}}t| |||}t|ttd fsPtd|d k rftjj ||}| j
||r|| j | d|g }| rdg|d d< |
r|
|d d< | r|j | | j
tjj| y|tjkr| jd d }n| jd d }|
dkrR| jrRd}tjj|d dkrDd}x d|| krB|d7 }q(W | j| ||< tjd krjtj||}| j|| W n, tk
r } zt|W Y d d }~X nX n t j d
| d S ) Nz%'output_dir' must be a string or Nonez-oz-gr zc++env =r zskipping %s (up-to-date)) r< r r
isinstancestrtype TypeErrorr( r) joinr> r? r% r' r* r Z
EXECUTABLEr r r basenamer4 r5 r6 r7 r+ r r
r r@ )r Z target_descr? rB r; r r r! Zexport_symbolsr@ r- r. Z
build_temprA r/ Zlib_optsZld_argsZlinkerir2 r# r# r$ link sH
zUnixCCompiler.linkc C s d| S )Nz-Lr# )r dirr# r# r$ library_dir_option s z UnixCCompiler.library_dir_optionc C s d|kpd|kS )Ngcczg++r# )r Z
compiler_namer# r# r$ _is_gcc s zUnixCCompiler._is_gccc C s t jjtjd}tjd d dkr,d| S tjd d dkrFd| S tjd d d krz| j|rnd
d| gS d d| gS tjd d d kstjd d d
krd|gS | j|rtjddkrd| S d| S nd| S d S )NCCr r z-L Zfreebsdz -Wl,-rpath= zhp-uxz-Wl,+sz+sZirix646Zosf1V5z-rpathGNULDyesz-Wl,--enable-new-dtags,-Rz-Wl,-Rz-R)r( r) rL r r r4 r5 rR )r rO r r# r# r$ runtime_library_dir_option s
$
z(UnixCCompiler.runtime_library_dir_optionc C s d| S )Nz-lr# )r libr# r# r$ library_option s z UnixCCompiler.library_optionc C s | j |dd}| j |dd}| j |dd}| j |dd}tjdkrptjd}tjd|} | d krfd }
n
| jd
}
x|D ]} tj j
| |} tj j
| |}
tj j
| |}tj j
| |}tjdko| j d s| j d o| j d
rBtj j
|
| d
d |} tj j
|
| d
d |}
tj j
|
| d
d |}tj j
|
| d
d |}tj j |
rT|
S tj j |rf|S tj j | rx| S tj j |rx|S qxW d S )Nshared)Zlib_typedylib
xcode_stubstaticr CFLAGSz-isysroot\s+(\S+)/rE z/System/z/usr/z /usr/local/)
r= r4 r5 r r researchgroupr( r) rK
startswithexists)r dirsrY r@ Zshared_fZdylib_fZ xcode_stub_fZstatic_fZcflagsmZsysrootrO r[ r\ r^ r] r# r# r$ find_library_file s>
z UnixCCompiler.find_library_file)NNNNN)Nr N)
NNNNNr NNNN)r ) __name__
__module__ __qualname__Z
compiler_typeZ executablesr4 r5 Zsrc_extensionsZ
obj_extensionZstatic_lib_extensionZshared_lib_extensionZdylib_lib_extensionZxcode_stub_lib_extensionZstatic_lib_formatZshared_lib_formatZdylib_lib_formatZxcode_stub_lib_formatZ
exe_extensionr r3 r: rC rN rP rR rX rZ rh
__classcell__r# r# )r" r$ r
- sF
6,r
)__doc__r( r4 ra Z distutilsr Zdistutils.dep_utilr Zdistutils.ccompilerr r r Zdistutils.errorsr r r r
r r5 r6 r
r# r# r# r$ s
PK ! Fk & __pycache__/spawn.cpython-36.opt-1.pycnu [ 3
\ @ s d Z ddlZddlZddlmZmZ ddlmZ ddlm Z dddZ
d d
Z dd d Z ej
d
krvddlmZ dadadddZdddZdS )zdistutils.spawn
Provides the 'spawn()' function, a front-end to various platform-
specific functions for launching another program in a sub-process.
Also provides the 'find_executable()' to search the path for a given
executable name.
N)DistutilsPlatformErrorDistutilsExecError)DEBUG)log c C sN t | } tjdkr"t| ||d n(tjdkre s z _spawn_posix...c S s g | ] }t |qS r )r( )r) r* r r r r+ k s zF$MACOSX_DEPLOYMENT_TARGET mismatch: now "%s" but "%s" during configure)r& zunable to execute %r: %s
r z(unable to execute %r for unknown reasonszcommand %r failed: %sz"command %r terminated by signal %dz%command %r failed with exit status %dz1unknown error executing %r: termination status %dr )"r r r r execvpexecvsysplatform _cfg_targetr% get_config_varsplit_cfg_target_splitenvirongetr dictexecvpeexecveforkr! r stderrwritestrerror_exitwaitpidr r WIFSIGNALEDWTERMSIG WIFEXITED WEXITSTATUS
WIFSTOPPED)r r r r r" Zexec_fnenvZ
cur_targetZmy_msgpideZstatusr# Z exit_statusr r r r
X s
&
r
c C s |dkrt jjdt j}|jt j}t jj| \}}tj dkrN|dkrN| d } t jj
| sx*|D ]"}t jj || }t jj
|r`|S q`W dS | S dS )zTries to find 'executable' in the directories listed in 'path'.
A string listing directories separated by 'os.pathsep'; defaults to
os.environ['PATH']. Returns the complete filename or None if not found.
NPATHZwin32z.exe) r r5 r6 defpathr3 pathseppathsplitextr/ r0 isfiler )r" rK pathsbaseZextpfr r r r s
r )r r r )r r r )r r r )N)__doc__r/ r Zdistutils.errorsr r Zdistutils.debugr Z distutilsr r r r r0 r% r1 r4 r
r r r r r s
QPK ! xx2 2 - __pycache__/msvccompiler.cpython-36.opt-2.pycnu [ 3
\\ @ s d dl Z d dlZd dlmZmZmZmZmZ d dlm Z m
Z
m Z d dl m
Z
dZy,d dlZdZeZejZejZejZejZW nh ek
r y4d dlZd dlZdZeZejZejZejZejZW n ek
r e
j d Y nX Y nX erej ej ej ej fZ!dd Z"d
d Z#d d
Z$G dd dZ%dd Z&dd Z'dd Z(G dd de Z)e& dkr~e
j*d e)Z+d dl,m)Z) d dl,m%Z% dS ) N)DistutilsExecErrorDistutilsPlatformError CompileErrorLibError LinkError) CCompilergen_preprocess_optionsgen_lib_options)logFTzWarning: Can't read registry to find the necessary compiler setting
Make sure that Python modules winreg, win32api or win32con are installed.c C sn yt | |}W n tk
r" d S X g }d}x|| j
kr>|}d| }y"| j| jg| |g |g W qh tk
r8 } zt|W Y d d }~X qhX qhn|| jkr tj j|}tj j|}yl| j| jgd|d|g |g tj jtj j|\}}tj j||d }| j| jgd| g |g W qh tk
r } zt|W Y d d }~X qhX qhntd||f d | }y&| j| jg|
| ||g | W qh tk
rj } zt|W Y d d }~X qhX qhW |
S )
Nz/cz/Tcz/Tpz/foz-hz-rz.rcz"Don't know how to compile %s to %sz/Fo)rX rk Z_setup_compiler extendrh rg r/ rM r- abspath
_c_extensions_cpp_extensionsrr spawnrb r r rt dirnamerc rm rq rf r` )r) Zsourcesrv r' Z include_dirsdebug
extra_preargsextra_postargsZdependsZ compile_infoobjectsZpp_optsZbuildZ compile_optsobjsrcrw Z input_optZ
output_optmsgZh_dirZrc_dirr _Zrc_filer r r compileW sj
zMSVCCompiler.compilec C s | j s| j | j||\}}| j||d}| j||r|d| g }|rJy| j| jg| W q tk
r } zt|W Y d d }~X qX n t j
d| d S )N)rv z/OUT:zskipping %s (up-to-date)) rX rk _fix_object_argslibrary_filename
_need_linkr} rZ r r r
r ) r) r Zoutput_libnamerv r target_langoutput_filenameZlib_argsr r r r create_static_lib s z MSVCCompiler.create_static_libc C s | j s| j | j||\}}| j|||}|\}}}|rL| jdt| t| |||}|d k rptjj ||}| j
||r|t j kr| r| j
dd }q| jdd }n| r| j
}n| j}g }x |pg D ]}|jd| qW || | | d| g }|d k rLtjjtjj|\}}tjj tjj|d | j|}|jd| |
r^|
|d d< | rn|j| | jtjj| y| j| jg| W n, tk
r } zt|W Y d d }~X nX n tjd| d S )Nz5I don't know what to do with 'runtime_library_dirs': r z/EXPORT:z/OUT:r z/IMPLIB:zskipping %s (up-to-date)) rX rk r Z
_fix_lib_argswarnstrr rM r- rf r r Z
EXECUTABLErj ri r rm rq r~ r ry Zmkpathr} ra r r r
r )r) Z target_descr r rv Z librariesZ library_dirsZruntime_library_dirsZexport_symbolsr r r Z
build_tempr Z
fixed_argsZlib_optsZldflagsZ export_optsZsymZld_argsZdll_nameZdll_extZ implib_filer r r r link sV
zMSVCCompiler.linkc C s d| S )Nz /LIBPATH:r )r) dirr r r library_dir_option s z MSVCCompiler.library_dir_optionc C s t dd S )Nztjd jdD ]*}tjjtjj||}tjj|rH|S qHW |S )NZPathr\ )r] rM r- rf rz isfiler^ rD )r) Zexer1 fnr r r r_ 5 s zMSVCCompiler.find_exex86c C s t sg S |d }| jdkr,d| j| jf }nd| j|f }xHtD ]@}t||}|r@| jdkrr| jj|| jdS || jdS q@W | jdkrx,tD ]$}t|d| j d k r| jd P qW g S ) Nz dirsrR z6%s\%0.1f\VC\VC_OBJECTS_PLATFORM_INFO\Win32\Directoriesz?%s\6.0\Build System\Components\Platforms\Win32 (%s)\Directoriesr\ r: z%s\6.0zIt seems you have Visual Studio 6 installed, but the expected registry settings are not present.
You must at least run the Visual Studio GUI once so that these entries are created.)
_can_read_regrS rU r, r rV r6 rD r )r) r- platformr r r r r r rd K s(
zMSVCCompiler.get_msvc_pathsc C s6 |dkr| j d}n
| j |}|r2dj|tj|< d S )NrZ Zlibraryr\ )rd rf rM r^ )r) r r1 r r r re o s
z MSVCCompiler.set_path_env_var)r r r )r rl )NNNr NNN)Nr N)
NNNNNr NNNN)r )r ) r7 r8 r9 Z
compiler_typeZ executablesr{ r| rr rt rp rs ru Zstatic_lib_extensionZshared_lib_extensionZstatic_lib_formatZshared_lib_formatZ
exe_extensionr+ rk rx r r r r r r r r_ rd re r r r r rQ sN
B
V
F
$rQ g @z3Importing new compiler from distutils.msvc9compiler)rQ )r& )-rA rM Zdistutils.errorsr r r r r Zdistutils.ccompilerr r r Z distutilsr
r winregZhkey_modZ OpenKeyExr ZEnumKeyr Z EnumValuer errorr
ImportErrorZwin32apiZwin32coninfoZ
HKEY_USERSHKEY_CURRENT_USERHKEY_LOCAL_MACHINEZHKEY_CLASSES_ROOTr, r r r r& rH rL rP rQ r ZOldMSVCCompilerZdistutils.msvc9compilerr r r r s\
-
9
PK ! `E(1 1 - __pycache__/bcppcompiler.cpython-36.opt-2.pycnu [ 3
\W: @ st d dl Z d dlmZmZmZmZmZmZ d dlm Z m
Z
m Z d dl m
Z
d dlmZ d dlmZ G dd de ZdS ) N)DistutilsExecErrorDistutilsPlatformError CompileErrorLibError LinkErrorUnknownFileError) CCompilergen_preprocess_optionsgen_lib_options)
write_file)newer)logc
@ s e Zd ZdZi ZdgZdddgZee ZdZdZ dZ
d Z Z d
Z
d d d
Zd ddZd ddZd ddZd ddZd!ddZd"ddZdS )# BCPPCompilerZbcppz.cz.ccz.cppz.cxxz.objz.libz.dllz%s%sz.exer c C s t j| ||| d| _d| _d| _d | _ddddg| _ddddg| _d d
dd g| _d d
dd g| _ g | _
d
dd g| _ d
dd d g| _ d S )
Nz bcc32.exez ilink32.exeztlib.exez/tWMz/O2z/qz/g0z/Odz/Tpdz/Gnz/xz/r)
r __init__cclinkerlibZpreprocess_optionscompile_optionscompile_options_debugldflags_sharedldflags_shared_debugZldflags_static ldflags_exeldflags_exe_debug)selfverboseZdry_runforce r ./usr/lib64/python3.6/distutils/bcppcompiler.pyr 5 s zBCPPCompiler.__init__Nc C s | j ||||||\}} }}
} |p$g } | jd |rB| j| j n | j| j xD| D ]:}
y| |
\}}W n tk
r wVY nX tjj|}tjj|
}
| j tjj
|
|dkrqV|dkry| j dd|
|g W qV t k
r } zt
|W Y d d }~X qVX qV|| jkrd}n|| jkr,d}nd}d|
}y,| j | jg| |
||g | |g W qV t k
r } zt
|W Y d d }~X qVX qVW | S ) Nz-cz.resz.rcZbrcc32z-fo z-Pz-o)Z_setup_compileappendextendr r KeyErrorospathnormpathmkpathdirnamespawnr r
_c_extensions_cpp_extensionsr )r Zsources
output_dirmacros include_dirsdebug
extra_preargsextra_postargsZdependsobjectspp_optsZbuildZ compile_optsobjsrcextmsgZ input_optZ
output_optr r r compileQ sF
( zBCPPCompiler.compilec C s | j ||\}}| j||d}| j||r~|dg| }|r:y| j| jg| W q tk
rz } zt|W Y d d }~X qX n tjd| d S )N)r* z/uzskipping %s (up-to-date)) _fix_object_argslibrary_filename
_need_linkr' r r r r
r- ) r r0 Zoutput_libnamer* r- target_langoutput_filenameZlib_argsr5 r r r create_static_lib s z BCPPCompiler.create_static_libc C s | j ||\}}| j|||\}}}|r8tjdt| |d k rNtjj||}| j||r|t j
krd}| r~| j d d }q| j d d }n&d}| r| j
d d }n| jd d }|d krd}ntjj|\}}tjj|\}}tjj|d }tjj|d| }dg}x&|pg D ]}|jd||f qW | jt||fd | ttjj|}|g}g }xF|D ]>}tjjtjj|\}}|d
kr|j| n
|j| qfW x$|D ] } |jd tjj| qW |jd |j| |jd
|g |jd x<|D ]4} | j|| | } | d kr(|j| n
|j| q W |jd |jd |jd
|g |jd
|j| |
r|
|d d< | r|j| | jtjj| y| j| j g| W n, t k
r } zt | W Y d d } ~ X nX n tj d| d S )Nz7I don't know what to do with 'runtime_library_dirs': %sZc0w32Zc0d32r r z%s.defZEXPORTSz %s=_%sz
writing %sz.resz/L%sz/L.,z,,Zimport32Zcw32mtzskipping %s (up-to-date)) r7 Z
_fix_lib_argsr
warnstrr" r# joinr9 r Z
EXECUTABLEr r r r splitsplitextr& r Zexecuter mapr$ normcaser find_library_filer% r' r r r r- ) r Z target_descr0 r; r* Z librariesZ library_dirsZruntime_library_dirsZexport_symbolsr- r. r/ Z
build_tempr: Z startup_objZld_argsZdef_fileheadtailmodnamer4 Ztemp_dircontentsZsymZobjects2Z resourcesfilebaselr libfiler5 r r r link s|
zBCPPCompiler.linkc C sv |r"|d }|d |d ||f}n |d |f}xB|D ]6}x0|D ](}t jj|| j|}t jj|r>|S q>W q4W d S d S )NZ_dZ_bcpp)r" r# r@ r8 exists) r dirsr r- ZdlibZ try_namesdirnamerM r r r rE 4 s
z BCPPCompiler.find_library_filer c C s |d kr d}g }x|D ]}t jjt jj|\}}|| jddg krTtd||f |rdt jj|}|dkr|jt jj||| q|dkr|jt jj||d q|jt jj||| j qW |S )Nr z.rcz.resz"unknown file type '%s' (from '%s'))
r" r# rB rD src_extensionsr basenamer r@
obj_extension)r Zsource_filenamesZ strip_dirr* Z obj_namesZsrc_namerK r4 r r r object_filenamesN s"
z BCPPCompiler.object_filenamesc C s | j d ||\}}}t||}dg| } |d k r>| jd| |rN|| d d< |r\| j| | j| | js~|d ks~t||r|r| jtjj | y| j
| W n2 t k
r }
zt |
t
|
W Y d d }
~
X nX d S )Nz cpp32.exez-or )Z_fix_compile_argsr r r r r r% r" r# r& r' r printr ) r sourceZ output_filer+ r, r. r/ _r1 Zpp_argsr5 r r r
preprocessi s$
zBCPPCompiler.preprocess)r r r )NNNr NNN)Nr N)
NNNNNr NNNN)r )r r )NNNNN)__name__
__module__ __qualname__Z
compiler_typeZ executablesr( r) rS rU Zstatic_lib_extensionZshared_lib_extensionZstatic_lib_formatZshared_lib_formatZ
exe_extensionr r6 r< rN rE rV rZ r r r r r sH
B
|
r )r" Zdistutils.errorsr r r r r r Zdistutils.ccompilerr r r
Zdistutils.file_utilr Zdistutils.dep_utilr Z distutilsr
r r r r r s PK ! ͢ % __pycache__/dist.cpython-36.opt-1.pycnu [ 3
\ @ s d Z ddlZddlZddlZddlmZ y ddlZW n ek
rL dZY nX ddlT ddl m
Z
m Z ddl m
Z
mZmZ ddlmZ ddlmZ ejd ZG d
d d ZG d d
d
Zdd ZdS )z}distutils.dist
Provides the Distribution class, which represents the module distribution
being built/installed/distributed.
N)message_from_file)*) FancyGetopttranslate_longopt)
check_environ strtobool
rfc822_escape)log)DEBUGz^[a-zA-Z]([a-zA-Z0-9_]*)$c @ sp e Zd ZdZd~ddddgZdZdddddddddddddddddddddgZd>d? eD ZddiZdd@dAZ dBdC Z
ddEdFZ dGdH Z ddIdJZ
dKdL ZdMdN ZdOdP ZdQdR Zddg fdSdTZdUdV ZdWdX ZdYdZ Zd[d\ Zd]d^ Zd_d` ZddadbZddcddZddfdgZe j fdhdiZ djdk Z dldm Z dndo Z!dpdq Z"drds Z#dtdu Z$dvdw Z%dxdy Z&dzd{ Z'd|d} Z(dS ) Distributiona The core of the Distutils. Most of the work hiding behind 'setup'
is really done within a Distribution instance, which farms the work out
to the Distutils commands specified on the command line.
Setup scripts will almost never instantiate Distribution directly,
unless the 'setup()' function is totally inadequate to their needs.
However, it is conceivable that a setup script might wish to subclass
Distribution for some specialized purpose, and then pass the subclass
to 'setup()' as the 'distclass' keyword argument. If so, it is
necessary to respect the expectations that 'setup' has of Distribution.
See the code for 'setup()', in core.py, for details.
verbosevrun verbosely (default) quietq!run quietly (turns verbosity off)dry-runndon't actually do anythinghelphshow detailed help message no-user-cfgN-ignore pydistutils.cfg in your home directoryzCommon commands: (see '--help-commands' for more)
setup.py build will build the package underneath 'build/'
setup.py install will install the package
help-commandslist all available commandsnameprint package nameversionVprint package versionfullname print -authorprint the author's name author-email print the author's email address
maintainerprint the maintainer's namemaintainer-email$print the maintainer's email addresscontact7print the maintainer's name if known, else the author's
contact-email@print the maintainer's email address if known, else the author'surl print the URL for this packagelicense print the license of the packagelicencealias for --license description print the package descriptionlong-description"print the long package description platformsprint the list of platforms classifiers print the list of classifierskeywordsprint the list of keywordsprovides+print the list of packages/modules providedrequires+print the list of packages/modules required obsoletes0print the list of packages/modules made obsoletec C s g | ]}t |d qS )r )r ).0x rH &/usr/lib64/python3.6/distutils/dist.py
s s zDistribution.c C s d| _ d| _d| _x| jD ]}t| |d qW t | _x,| jjD ] }d| }t| |t| j| q@W i | _ d| _
d| _ d| _ i | _
g | _d| _i | _d| _d| _d| _d| _d| _d| _d| _d| _d| _d| _d| _i | _ i | _ |r8|j d}|dk rH|d= xD|j D ]8\}}| j |}x"|j D ]\} }
d|
f|| < q(W q W d|kr|d |d < |d= d
} t!dk r~t!j"| nt#j$j%| d x|j D ]\} }
t&| jd | rt| jd | |
njt&| j| rt| j| |
nLt&| | r t| | |
n2d
t'| } t!dk r"t!j"| nt#j$j%| d qW d| _(| j dk r|x0| j D ]&}
|
j)dsdP |
dkrRd| _(P qRW | j* dS )a0 Construct a new Distribution instance: initialize all the
attributes of a Distribution, and then use 'attrs' (a dictionary
mapping attribute names to values) to assign some of those
attributes their "real" values. (Any attributes not mentioned in
'attrs' will be assigned to some null value: 0, None, an empty list
or dictionary, etc.) Most importantly, initialize the
'command_obj' attribute to the empty dictionary; this will be
filled in with real command objects by 'parse_command_line()'.
r r get_N optionsz setup scriptr4 r2 z:'licence' distribution option is deprecated; use 'license'
Zset_z Unknown distribution option: %sT-z
--no-user-cfgF)+r dry_runr display_option_namessetattrDistributionMetadatametadata_METHOD_BASENAMESgetattrcmdclasscommand_packages script_name script_argscommand_optionsZ
dist_filespackagesZ package_dataZ package_dir
py_modules librariesheaders ext_modulesZ ext_packageZ include_dirsZ
extra_pathscripts
data_filesZpassword command_objhave_rungetitemsget_option_dictwarningswarnsysstderrwritehasattrrepr
want_user_cfg
startswithfinalize_options)selfZattrsattrbasenameZ method_namerM commandZ cmd_optionsopt_dictoptvalmsgkeyargrH rH rI __init__z s
zDistribution.__init__c C s& | j j|}|dkr"i }| j |< |S )zGet the option dictionary for a given command. If that
command's option dictionary hasn't been created yet, then create it
and return the new dictionary; otherwise, return the existing
option dictionary.
N)r[ re )rr ru dictrH rH rI rg s z Distribution.get_option_dictrL c C s ddl m} |d kr"t| jj }|d k r@| j|| |d }|sV| j|d d S xt|D ]l}| jj|}|d kr| j|d| q\| j|d| ||}x$|jdD ]}| j|d | qW q\W d S )Nr )pformatz zno commands known yetz no option dict for '%s' commandz option dict for '%s' command:rN )pprintr~ sortedr[ keysannouncere split) rr headercommandsindentr~ Zcmd_namerv outlinerH rH rI dump_option_dicts& s&
z Distribution.dump_option_dictsc C s g }t tjjtjd j}tjj|d}tjj|rB|j | tj
dkrRd}nd}| j rtjjtjj d|}tjj|r|j | d}tjj|r|j | t
r| jdd j| |S )
a Find as many configuration files as should be processed for this
platform, and return a list of filenames in the order in which they
should be parsed. The filenames returned are guaranteed to exist
(modulo nasty race conditions).
There are three possible config files: distutils.cfg in the
Distutils installation directory (ie. where the top-level
Distutils __inst__.py file lives), a file in the user's home
directory named .pydistutils.cfg on Unix and pydistutils.cfg
on Windows/Mac; and setup.cfg in the current directory.
The file in the user's home directory can be disabled with the
--no-user-cfg option.
distutilsz
distutils.cfgposixz.pydistutils.cfgzpydistutils.cfg~z setup.cfgzusing config files: %sz, )r ospathdirnamerj modules__file__joinisfileappendr ro
expanduserr
r )rr filesZsys_dirZsys_fileZ
user_filenameZ user_fileZ
local_filerH rH rI find_config_filesB s&
z Distribution.find_config_filesc C s ddl m} tjtjkr8ddddddd d
d d d
ddg
}ng }t|}|d krT| j }trb| jd | }x|D ]}tr| jd| |j | xf|j
D ]Z}|j |}| j |}x@|D ]8} | dkr| |kr|j
|| }
| jdd} ||
f|| < qW qW |j qnW d| jkrx| jd j D ]\} \} }
| jj
| } yF| rRt| | t|
n(| dkrnt| | t|
n t| | |
W n, tk
r }
zt|
W Y d d }
~
X nX q W d S )Nr ) ConfigParserz install-basezinstall-platbasez install-libzinstall-platlibzinstall-purelibzinstall-headerszinstall-scriptsz install-dataprefixz exec-prefixhomeuserrootz"Distribution.parse_config_files():z reading %s__name__rO _globalr rP )r rP )Z configparserr rj r base_prefix frozensetr r
r readZsectionsrM rg re replacer| r[ rf negative_optrR r
ValueErrorDistutilsOptionError)rr filenamesr Zignore_optionsparserfilenameZsectionrM rv rw rx srcaliasry rH rH rI parse_config_filesr sJ
z Distribution.parse_config_filesc C s | j }g | _t|| j }|j| j |jddi |j| j| d}|j }t
j | j | j
|rhdS x |r| j||}|dkrjdS qjW | jr| j|t| jdk| jd dS | jstddS ) a Parse the setup script's command line, taken from the
'script_args' instance attribute (which defaults to 'sys.argv[1:]'
-- see 'setup()' in core.py). This list is first processed for
"global options" -- options that set attributes of the Distribution
instance. Then, it is alternately scanned for Distutils commands
and options for that command. Each new command terminates the
options for the previous command. The allowed options for a
command are determined by the 'user_options' attribute of the
command class -- thus, we have to be able to load command classes
in order to parse the command line. Any error in that 'options'
attribute raises DistutilsGetoptError; any error on the
command-line raises DistutilsArgError. If no Distutils commands
were found on the command line, raises DistutilsArgError. Return
true if command-line was successfully parsed and we should carry
on with executing commands; false if no errors but we shouldn't
execute commands (currently, this only happens if user asks for
help).
r4 r2 )argsobjectNr )display_optionsr zno commands suppliedT)_get_toplevel_optionsr r r set_negative_aliasesr Z set_aliasesgetoptrZ Zget_option_orderr Z
set_verbosityr handle_display_options_parse_command_optsr
_show_helplenDistutilsArgError)rr Ztoplevel_optionsr r option_orderrH rH rI parse_command_line s,
z Distribution.parse_command_linec C s | j dg S )zReturn the non-display options recognized at the top level.
This includes options that are recognized *only* at the top
level as well as options recognized for commands.
command-packages=N0list of packages that provide distutils commands)r Nr )global_options)rr rH rH rI r s z"Distribution._get_toplevel_optionsc C s ddl m} |d }tj|s*td| | jj| y| j|}W n* tk
rn } zt |W Y dd}~X nX t
||st d| t |dot
|jtsd}t || | j}t |dr|j }|j|j t |d rt
|jtrt|j}ng }|j| j|j | |j| |j|d
d \}} t | d rV| jrV| j|d|gd dS t |d rt
|jtrd}
xP|jD ]F\} } }
}t | |j| r|d
}
t |r| nt d
|| f q|W |
rdS | j |}x&t | j D ]\}}d|f||< qW |S )a Parse the command-line options for a single command.
'parser' must be a FancyGetopt instance; 'args' must be the list
of arguments, starting with the current command (whose options
we are about to parse). Returns a new version of 'args' with
the next command at the front of the list; will be the empty
list if there are no more commands on the command line. Returns
None if the user asked for help on this command.
r )Commandzinvalid command name '%s'Nz&command class %s must subclass Command user_optionszIcommand class %s must provide 'user_options' attribute (a list of tuples)r help_optionsr r )r r zYinvalid help function %r for help option '%s': must be a callable object (function, etc.)z command line)
distutils.cmdr
command_rematch
SystemExitr r get_command_classDistutilsModuleErrorr
issubclassZDistutilsClassErrorrm
isinstancer listr copyupdater fix_help_optionsset_option_tabler r r r r Z
get_attr_namecallablerg varsrf )rr r r r ru Z cmd_classry r r ZoptsZhelp_option_foundZ help_optionZshortZdescfuncrv r valuerH rH rI r sb
z Distribution._parse_command_optsc C sT xNdD ]F}t | j|}|dkr qt|trdd |jdD }t| j|| qW dS )zSet final values for all the options on the Distribution
instance, analogous to the .finalize_options() method of Command
objects.
r> r: Nc S s g | ] }|j qS rH )strip)rF ZelmrH rH rI rJ _ s z1Distribution.finalize_options..,)r> r: )rV rT r strr rR )rr rs r rH rH rI rq U s
z Distribution.finalize_optionsc
C s ddl m} ddlm} |rR|r*| j }n| j}|j| |j| jd t d |rt|j| j
|jd t d x| j D ]z}t |t
rt||r|} n
| j|} t| drt | jtr|j| jt| j n |j| j |jd | j t d q|W t || j d
S ) ab Show help for the setup script command-line in the form of
several lists of command-line options. 'parser' should be a
FancyGetopt instance; do not expect it to be returned in the
same state, as its option table will be reset to make it
generate the correct help text.
If 'global_options' is true, lists the global options:
--verbose, --dry-run, etc. If 'display_options' is true, lists
the "display-only" options: --name, --version, etc. Finally,
lists per-command help for every command name or command class
in 'commands'.
r ) gen_usage)r z
Global options:rL z*Information display options (just display z!information, ignore any commands)r zOptions for '%s' command:NzKInformation display options (just display information, ignore any commands))distutils.corer r r r r r Z
print_help common_usageprintr r r typer r rm r r r r r rY )
rr r r r r r r rM ru klassrH rH rI r b s6
zDistribution._show_helpc C s ddl m} | jr4| j td t|| j dS d}i }x| jD ]}d||d < qDW xt|D ]l\}}|r^|j|r^t|}t | j
d| }|dkrtdj | n |dkrtd
j | nt| d}q^W |S )zIf there were any non-global "display-only" options
(--help-commands or the metadata display options) on the command
line, display the requested info and return true; else return
false.
r )r rL r rK r> r: r r< r@ rB rD rN )r> r: )r< r@ rB rD ) r r Z
help_commandsprint_commandsr rY r re r rV rT r ) rr r r Zany_display_optionsZis_display_optionoptionrw rx r rH rH rI r s, z#Distribution.handle_display_optionsc C sn t |d x\|D ]T}| jj|}|s0| j|}y
|j}W n tk
rR d}Y nX t d|||f qW dS )zZPrint a subset of the list of all commands -- used by
'print_commands()'.
:z(no description available)z
%-*s %sN)r rW re r r6 AttributeError)rr r r
max_lengthcmdr r6 rH rH rI print_command_list s
z Distribution.print_command_listc C s ddl }|jj}i }x|D ] }d||< qW g }x&| jj D ]}|j|s:|j| q:W d}x$|| D ]}t||krdt|}qdW | j|d| |rt | j|d| dS )an Print out a help message listing all available commands with a
description of each. The list is divided into "standard commands"
(listed in distutils.command.__all__) and "extra commands"
(mentioned in self.cmdclass, but not a standard command). The
descriptions come from the command class attribute
'description'.
r Nr zStandard commandszExtra commands)
distutils.commandru __all__rW r re r r r r )rr r std_commandsis_stdr extra_commandsr rH rH rI r s*
zDistribution.print_commandsc C s ddl }|jj}i }x|D ] }d||< qW g }x&| jj D ]}|j|s:|j| q:W g }x\|| D ]P}| jj|}|s| j|}y
|j}W n t k
r d}Y nX |j||f qdW |S )a> Get a list of (command, description) tuples.
The list is divided into "standard commands" (listed in
distutils.command.__all__) and "extra commands" (mentioned in
self.cmdclass, but not a standard command). The descriptions come
from the command class attribute 'description'.
r Nr z(no description available))
r ru r rW r re r r r6 r ) rr r r r r r rvr r6 rH rH rI get_command_list s(
z Distribution.get_command_listc C sN | j }t|tsJ|dkr d}dd |jdD }d|krD|jdd || _ |S )z9Return a list of packages from which commands are loaded.NrL c S s g | ]}|d kr|j qS )rL )r )rF ZpkgrH rH rI rJ s z5Distribution.get_command_packages..r zdistutils.commandr )rX r r r insert)rr ZpkgsrH rH rI get_command_packages s
z!Distribution.get_command_packagesc C s | j j|}|r|S x| j D ]}d||f }|}yt| tj| }W n tk
r^ w Y nX yt||}W n& tk
r t d|||f Y nX || j |< |S W t d| dS )ao Return the class that implements the Distutils command named by
'command'. First we check the 'cmdclass' dictionary; if the
command is mentioned there, we fetch the class object from the
dictionary and return it. Otherwise we load the command module
("distutils.command." + command) and fetch the command class from
the module. The loaded class is also stored in 'cmdclass'
to speed future calls to 'get_command_class()'.
Raises DistutilsModuleError if the expected module could not be
found, or if that module does not define the expected class.
z%s.%sz3invalid command '%s' (no class '%s' in module '%s')zinvalid command '%s'N)
rW re r
__import__rj r ImportErrorrV r r )rr ru r ZpkgnameZ module_nameZ
klass_namemodulerH rH rI r s(
z Distribution.get_command_classc C sn | j j|}| rj|rjtr(| jd| | j|}|| }| j |< d| j|< | jj|}|rj| j|| |S )a Return the command object for 'command'. Normally this object
is cached on a previous call to 'get_command_obj()'; if no command
object for 'command' is in the cache, then we either create and
return it (if 'create' is true) or return None.
z.z1error in %s: command '%s' has no such option '%s')get_command_namerg r
r rf Zboolean_optionsr r r r rR r rm r r ) rr rc Z option_dict command_namer sourcer Z bool_optsZneg_optZ is_stringry rH rH rI r ] s>
z!Distribution._set_command_optionsr c C s ddl m} t||s&|}| j|}n|j }|js8|S |j d|_d| j|< | j| |r|x |j D ]}| j
|| qhW |S )a Reinitializes a command to the state it was in when first
returned by 'get_command_obj()': ie., initialized but not yet
finalized. This provides the opportunity to sneak option
values in programmatically, overriding or supplementing
user-supplied values from the config files and command line.
You'll have to re-finalize the command object (by calling
'finalize_options()' or 'ensure_finalized()') before using it for
real.
'command' should be a command name (string) or command object. If
'reinit_subcommands' is true, also reinitializes the command's
sub-commands, as declared by the 'sub_commands' class attribute (if
it has one). See the "install" command for an example. Only
reinitializes the sub-commands that actually matter, ie. those
whose test predicates return true.
Returns the reinitialized command object.
r )r ) r r r r r Z finalizedZinitialize_optionsrd r Zget_sub_commandsreinitialize_command)rr ru Zreinit_subcommandsr r subrH rH rI r s
z!Distribution.reinitialize_commandc C s t j || d S )N)r )rr ry levelrH rH rI r s zDistribution.announcec C s x| j D ]}| j| qW dS )zRun each command that was seen on the setup script command line.
Uses the list of commands found and cache of command objects
created by 'get_command_obj()'.
N)r run_command)rr r rH rH rI run_commands s zDistribution.run_commandsc C sD | j j|rdS tjd| | j|}|j |j d| j |< dS )a Do whatever it takes to run a command (including nothing at all,
if the command has already been run). Specifically: if we have
already created and run the command named by 'command', return
silently without doing anything. If the command named by 'command'
doesn't even have a command object yet, create one. Then invoke
'run()' on that command object (or an existing one).
Nz
running %sr )rd re r infor Zensure_finalizedZrun)rr ru r rH rH rI r s
zDistribution.run_commandc C s t | jp| jpg dkS )Nr )r r\ r] )rr rH rH rI has_pure_modules s z Distribution.has_pure_modulesc C s | j ot| j dkS )Nr )r` r )rr rH rH rI has_ext_modules s z Distribution.has_ext_modulesc C s | j ot| j dkS )Nr )r^ r )rr rH rH rI has_c_libraries s z Distribution.has_c_librariesc C s | j p| j S )N)r r )rr rH rH rI has_modules s zDistribution.has_modulesc C s | j ot| j dkS )Nr )r_ r )rr rH rH rI has_headers s zDistribution.has_headersc C s | j ot| j dkS )Nr )ra r )rr rH rH rI has_scripts s zDistribution.has_scriptsc C s | j ot| j dkS )Nr )rb r )rr rH rH rI has_data_files s zDistribution.has_data_filesc C s | j o| j o| j S )N)r r r )rr rH rH rI is_pure s
zDistribution.is_pure)r r
r r )r r r )r r r )r r r )r Nr )r Nr )r Nr )r r r! )r" Nr# )r$ Nr% )r& Nr' )r( Nr) )r* Nr+ )r, Nr- )r. Nr/ )r0 Nr1 )r2 Nr3 )r4 Nr5 )r6 Nr7 )r8 Nr9 )r: Nr; )r< Nr= )r> Nr? )r@ NrA )rB NrC )rD NrE )N)NNrL )N)r )N)r ))r
__module__ __qualname____doc__r r r rQ r r| rg r r r r r r rq r r r r r r r r r r r INFOr r r r r r r r r r r rH rH rH rI r s
"
0
:C [
1(!" &
,
)
r c @ s e Zd ZdZdOZdPddZdd Zdd Zd d Zd d Z d!d" Z
d#d$ Z d%d& Z d'd( Z
d)d* Zd+d, Zd-d. Zd/d0 Zd1d2 Zd3d4 Zd5d6 ZeZd7d8 Zd9d: Zd;d< Zd=d> Zd?d@ ZdAdB ZdCdD Z dEdF Z dGdH Z dIdJ Z dKdL Z dMdN Z!dS )QrS z]Dummy class to hold the distribution meta-data: name, version,
author, and so forth.
r r r$ author_emailr( maintainer_emailr0 r2 r6 long_descriptionr> r: r" r,
contact_emailr< download_urlr@ rB rD Nc C s |d k r| j t| nfd | _d | _d | _d | _d | _d | _d | _d | _ d | _
d | _ d | _ d | _
d | _d | _d | _d | _d | _d S )N)
read_pkg_fileopenr r r$ r r( r r0 r2 r6 r r> r: r< r
r@ rB rD )rr r rH rH rI r| s& z DistributionMetadata.__init__c s t | fdd} fdd} d }|d| _|d| _|d| _|d | _d
| _|d | _d
| _|d | _|d
| _ d kr|d| _
nd
| _
|d| _ |d| _d kr|dj d| _
|d| _|d| _|dkr|d| _|d| _|d| _nd
| _d
| _d
| _d
S )z-Reads the metadata values from a file object.c s | }|dkrd S |S )NUNKNOWNrH )r r )ry rH rI _read_field s z7DistributionMetadata.read_pkg_file.._read_fieldc s j | d }|g krd S |S )N)Zget_all)r values)ry rH rI
_read_list# s z6DistributionMetadata.read_pkg_file.._read_listzmetadata-versionr r Zsummaryr$ Nz author-emailz home-pager2 z download-urlr6 r> r platformZ
classifierz1.1rB r@ rD )r r r r6 r$ r( r r r0 r2 r
r r r> r: r< rB r@ rD )rr filer r Zmetadata_versionrH )ry rI r s:
z"DistributionMetadata.read_pkg_filec C s2 t tjj|dddd}| j| W dQ R X dS )z7Write the PKG-INFO file into the release tree.
zPKG-INFOwzUTF-8)encodingN)r r r r write_pkg_file)rr Zbase_dirZpkg_inforH rH rI write_pkg_infoM s
z#DistributionMetadata.write_pkg_infoc C sb d}| j s"| js"| js"| js"| jr&d}|jd| |jd| j |jd| j |jd| j |jd| j |jd| j
|jd | j |jd
| j | jr|jd | j t
| j }|jd | d
j| j }|r|jd| | j|d| j | j|d| j | j|d| j | j|d| j | j|d| j dS )z9Write the PKG-INFO format data to a file object.
z1.0z1.1zMetadata-Version: %s
z Name: %s
z Version: %s
z Summary: %s
zHome-page: %s
z Author: %s
zAuthor-email: %s
z License: %s
zDownload-URL: %s
zDescription: %s
r z
Keywords: %s
ZPlatformZ
ClassifierZRequiresZProvidesZ ObsoletesN)r@ rB rD r< r
rl get_name get_versionget_descriptionget_url get_contactget_contact_email get_licenser get_long_descriptionr get_keywords _write_list
get_platformsget_classifiers get_requires get_provides
get_obsoletes)rr r r Z long_descr> rH rH rI r T s0 z#DistributionMetadata.write_pkg_filec C s$ x |D ]}|j d||f qW d S )Nz%s: %s
)rl )rr r r r r rH rH rI r v s
z DistributionMetadata._write_listc C s
| j pdS )Nr
)r )rr rH rH rI r | s z DistributionMetadata.get_namec C s
| j pdS )Nz0.0.0)r )rr rH rH rI r s z DistributionMetadata.get_versionc C s d| j | j f S )Nz%s-%s)r r )rr rH rH rI get_fullname s z!DistributionMetadata.get_fullnamec C s
| j pdS )Nr
)r$ )rr rH rH rI
get_author s z DistributionMetadata.get_authorc C s
| j pdS )Nr
)r )rr rH rH rI get_author_email s z%DistributionMetadata.get_author_emailc C s
| j pdS )Nr
)r( )rr rH rH rI get_maintainer s z#DistributionMetadata.get_maintainerc C s
| j pdS )Nr
)r )rr rH rH rI get_maintainer_email s z)DistributionMetadata.get_maintainer_emailc C s | j p| jpdS )Nr
)r( r$ )rr rH rH rI r s z DistributionMetadata.get_contactc C s | j p| jpdS )Nr
)r r )rr rH rH rI r s z&DistributionMetadata.get_contact_emailc C s
| j pdS )Nr
)r0 )rr rH rH rI r s z DistributionMetadata.get_urlc C s
| j pdS )Nr
)r2 )rr rH rH rI r s z DistributionMetadata.get_licensec C s
| j pdS )Nr
)r6 )rr rH rH rI r s z$DistributionMetadata.get_descriptionc C s
| j pdS )Nr
)r )rr rH rH rI r s z)DistributionMetadata.get_long_descriptionc C s
| j pg S )N)r> )rr rH rH rI r s z!DistributionMetadata.get_keywordsc C s | j p
dgS )Nr
)r: )rr rH rH rI r! s z"DistributionMetadata.get_platformsc C s
| j pg S )N)r< )rr rH rH rI r" s z$DistributionMetadata.get_classifiersc C s
| j pdS )Nr
)r
)rr rH rH rI get_download_url s z%DistributionMetadata.get_download_urlc C s
| j pg S )N)rB )rr rH rH rI r# s z!DistributionMetadata.get_requiresc C s, dd l }x|D ]}|jj| qW || _d S )Nr )distutils.versionpredicateversionpredicateVersionPredicaterB )rr r r r
rH rH rI set_requires s
z!DistributionMetadata.set_requiresc C s
| j pg S )N)r@ )rr rH rH rI r$ s z!DistributionMetadata.get_providesc C s: dd |D }x |D ]}dd l }|jj| qW || _d S )Nc S s g | ] }|j qS rH )r )rF r
rH rH rI rJ s z5DistributionMetadata.set_provides..r )r, r- Zsplit_provisionr@ )rr r r
r rH rH rI set_provides s
z!DistributionMetadata.set_providesc C s
| j pg S )N)rD )rr rH rH rI r% s z"DistributionMetadata.get_obsoletesc C s, dd l }x|D ]}|jj| qW || _d S )Nr )r, r- r. rD )rr r r r
rH rH rI
set_obsoletes s
z"DistributionMetadata.set_obsoletes)r r r$ r r( r r0 r2 r6 r r> r: r" r, r r< r
r@ rB rD )N)"r r r r rU r| r r r r r r r& r' r( r) r* r r r r Z get_licencer r r r! r" r+ r# r/ r$ r0 r% r1 rH rH rH rI rS sH
4"rS c C s( g }x | D ]}|j |dd q
W |S )zConvert a 4-tuple 'help_options' list as found in various command
classes to the 3-tuple form required by FancyGetopt.
r )r )rM Z new_optionsZ
help_tuplerH rH rI r s
r )r rj r reZemailr rh r Zdistutils.errorsZdistutils.fancy_getoptr r Zdistutils.utilr r r r r Zdistutils.debugr
compiler r rS r rH rH rH rI s2
] ZPK ! Vf __pycache__/core.cpython-36.pycnu [ 3
\" @ s d Z ddlZddlZddlmZ ddlT ddlmZ ddlm Z ddl
m Z ddl m
Z
d Zd
d Zdadad4Zd5Zd/d0 Zd6d2d3ZdS )7a# distutils.core
The only module that needs to be imported to use the Distutils; provides
the 'setup' function (which is to be called from the setup script). Also
indirectly provides the Distribution and Command classes, although they are
really defined in distutils.dist and distutils.cmd.
N)DEBUG)*) Distribution)Command)
PyPIRCCommand) Extensionzusage: %(script)s [global_opts] cmd1 [cmd1_opts] [cmd2 [cmd2_opts] ...]
or: %(script)s --help [cmd1 cmd2 ...]
or: %(script)s --help-commands
or: %(script)s cmd --help
c C s t jj| }tt S )N)ospathbasenameUSAGEvars) script_nameZscript r &/usr/lib64/python3.6/distutils/core.py gen_usage s r distclassr
script_argsoptionsnameversionauthor author_email
maintainermaintainer_emailurllicense descriptionlong_descriptionkeywords platforms classifiers download_urlrequiresprovides obsoletessources include_dirs
define_macros undef_macros library_dirs librariesruntime_library_dirs
extra_objectsextra_compile_argsextra_link_args swig_optsexport_symbolsdependslanguagec , K s | j d}|r| d= nt}d| kr8tjjtjd | d< d| krRtjdd | d< y|| a}W nL tk
r } z0d| krt d| nt d | d |f W Y dd}~X nX t
d
kr|S |j t rt
d |j t
d kr|S y |j }W n: tk
r* } z t t|jd
| W Y dd}~X nX t rBt
d |j t
dkrP|S |ry |j W n tk
r t dY n tk
r } z0t rtjjd|f nt d|f W Y dd}~X nB ttfk
r } z t r nt dt| W Y dd}~X nX |S )a The gateway to the Distutils: do everything your setup script needs
to do, in a highly flexible and user-driven way. Briefly: create a
Distribution instance; find and parse config files; parse the command
line; run each Distutils command found there, customized by the options
supplied to 'setup()' (as keyword arguments), in config files, and on
the command line.
The Distribution instance might be an instance of a class supplied via
the 'distclass' keyword argument to 'setup'; if no such class is
supplied, then the Distribution class (in dist.py) is instantiated.
All other arguments to 'setup' (except for 'cmdclass') are used to set
attributes of the Distribution instance.
The 'cmdclass' argument, if supplied, is a dictionary mapping command
names to command classes. Each command encountered on the command line
will be turned into a command class, which is in turn instantiated; any
class found in 'cmdclass' is used in place of the default, which is
(for command 'foo_bar') class 'foo_bar' in module
'distutils.command.foo_bar'. The command class must provide a
'user_options' attribute which is a list of option specifiers for
'distutils.fancy_getopt'. Any command-line options between the current
and the next command are used to set attributes of the current command
object.
When the entire command-line has been successfully parsed, calls the
'run()' method on each command object in turn. This method will be
driven entirely by the Distribution object (which each command object
has a reference to, thanks to its constructor), and the
command-specific options that became attributes of each command
object.
r r
r r Nr zerror in setup command: %sz error in %s setup command: %sinitz%options (after parsing config files):configz
error: %sz%options (after parsing command line): commandlineZ interruptedz
error: %s
z error: %szerror: )getr r r r
sysargv_setup_distributionZDistutilsSetupError
SystemExit_setup_stop_afterZparse_config_filesr printZdump_option_dictsZparse_command_lineZDistutilsArgErrorr r
Z run_commandsKeyboardInterruptOSErrorstderrwriteZDistutilsErrorZCCompilerErrorstr)ZattrsklassZdistmsgokexcr r r setup9 s` %
" (
"rG runc C s |d krt d|f |atjj }d| i}yZzH| tjd< |dk rP|tjd d< t| d
}t|j | W dQ R X W d|t_daX W n tk
r Y nX t dkrt
d | t S )
a. Run a setup script in a somewhat controlled environment, and
return the Distribution instance that drives things. This is useful
if you need to find out the distribution meta-data (passed as
keyword args from 'script' to 'setup()', or the contents of the
config files or command-line.
'script_name' is a file that will be read and run with 'exec()';
'sys.argv[0]' will be replaced with 'script' for the duration of the
call. 'script_args' is a list of strings; if supplied,
'sys.argv[1:]' will be replaced by 'script_args' for the duration of
the call.
'stop_after' tells 'setup()' when to stop processing; possible
values:
init
stop after the Distribution instance has been created and
populated with the keyword arguments to 'setup()'
config
stop after config files have been parsed (and their data
stored in the Distribution instance)
commandline
stop after the command-line ('sys.argv[1:]' or 'script_args')
have been parsed (and the data stored in the Distribution)
run [default]
stop after all commands have been run (the same as if 'setup()'
had been called in the usual way
Returns the Distribution instance, which provides all information
used to drive the Distutils.
r4 r5 r6 rH z"invalid value for 'stop_after': %r__file__r Nr3 rbzZ'distutils.core.setup()' was never called -- perhaps '%s' is not a Distutils setup script?)r4 r5 r6 rH )
ValueErrorr< r8 r9 copyopenexecreadr; r: RuntimeError)r
r Z
stop_afterZ save_argvgfr r r run_setup s(
rS )r r
r r r r r r r r r r r r r r r r! r" r# r$ )r r% r& r' r( r) r* r+ r, r- r. r/ r0 r1 r2 )NrH )__doc__r r8 Zdistutils.debugr Zdistutils.errorsZdistutils.distr Z
distutils.cmdr Zdistutils.configr Zdistutils.extensionr r r r< r: Zsetup_keywordsZextension_keywordsrG rS r r r r s2 qPK ! Cֺ " __pycache__/version.cpython-36.pycnu [ 3
\90 @ s> d Z ddlZG dd dZG dd deZG dd deZdS ) a Provides classes to represent module version numbers (one class for
each style of version numbering). There are currently two such classes
implemented: StrictVersion and LooseVersion.
Every version number class implements the following interface:
* the 'parse' method takes a string and parses it to some internal
representation; if the string is an invalid version number,
'parse' raises a ValueError exception
* the class constructor takes an optional string argument which,
if supplied, is passed to 'parse'
* __str__ reconstructs the string that was passed to 'parse' (or
an equivalent string -- ie. one that will generate an equivalent
version number instance)
* __repr__ generates Python code to recreate the version number instance
* _cmp compares the current instance with either another instance
of the same class or a string (which will be parsed to an instance
of the same class, thus must follow the same rules)
Nc @ sJ e Zd ZdZdddZdd Zdd Zd d
Zd d Zd
d Z dd Z
dS )VersionzAbstract base class for version numbering classes. Just provides
constructor (__init__) and reproducer (__repr__), because those
seem to be the same for all version numbering classes; and route
rich comparisons to _cmp.
Nc C s |r| j | d S )N)parse)selfvstring r )/usr/lib64/python3.6/distutils/version.py__init__& s zVersion.__init__c C s d| j jt| f S )Nz %s ('%s')) __class____name__str)r r r r __repr__* s zVersion.__repr__c C s | j |}|tkr|S |dkS )Nr )_cmpNotImplemented)r othercr r r __eq__- s
zVersion.__eq__c C s | j |}|tkr|S |dk S )Nr )r
r )r r r r r r __lt__3 s
zVersion.__lt__c C s | j |}|tkr|S |dkS )Nr )r
r )r r r r r r __le__9 s
zVersion.__le__c C s | j |}|tkr|S |dkS )Nr )r
r )r r r r r r __gt__? s
zVersion.__gt__c C s | j |}|tkr|S |dkS )Nr )r
r )r r r r r r __ge__E s
zVersion.__ge__)N) r
__module__ __qualname____doc__r r r r r r r r r r r r s
r c @ s< e Zd ZdZejdejejB Zdd Z dd Z
dd Z d S )
StrictVersiona? Version numbering for anal retentives and software idealists.
Implements the standard interface for version number classes as
described above. A version number consists of two or three
dot-separated numeric components, with an optional "pre-release" tag
on the end. The pre-release tag consists of the letter 'a' or 'b'
followed by a number. If the numeric components of two version
numbers are equal, then one with a pre-release tag will always
be deemed earlier (lesser) than one without.
The following are valid version numbers (shown in the order that
would be obtained by sorting according to the supplied cmp function):
0.4 0.4.0 (these two are equivalent)
0.4.1
0.5a1
0.5b3
0.5
0.9.6
1.0
1.0.4a3
1.0.4b1
1.0.4
The following are examples of invalid version numbers:
1
2.7.2.2
1.3.a4
1.3pl1
1.3c4
The rationale for this version numbering system will be explained
in the distutils documentation.
z)^(\d+) \. (\d+) (\. (\d+))? ([ab](\d+))?$c C s | j j|}|s td| |jddddd\}}}}}|rTttt|||g| _nttt||gd | _|r|d t|f| _nd | _d S ) Nzinvalid version number '%s' r )r )
version_rematch
ValueErrorgrouptuplemapintversion
prerelease)r r r majorminorZpatchr' Zprerelease_numr r r r s zStrictVersion.parsec C sb | j d dkr*djtt| j dd }ndjtt| j }| jr^|| jd t| jd }|S )Nr r .r )r& joinr$ r r' )r r r r r __str__ s zStrictVersion.__str__c C s t |trt|}| j|jkr2| j|jk r.dS dS | j rF|j rFdS | jrX|j rXdS | j rj|jrjdS | jr|jr| j|jkrdS | j|jk rdS dS n dstdd S )Nr r Fznever get herer- r- )
isinstancer r r& r' AssertionError)r r r r r r
s&
zStrictVersion._cmpN) r
r r r recompileVERBOSEASCIIr r r, r
r r r r r ] s #
r c @ sH e Zd ZdZejdejZdddZdd Z dd Z
d
d Z d d
Z dS ) LooseVersiona Version numbering for anarchists and software realists.
Implements the standard interface for version number classes as
described above. A version number consists of a series of numbers,
separated by either periods or strings of letters. When comparing
version numbers, the numeric components will be compared
numerically, and the alphabetic components lexically. The following
are all valid version numbers, in no particular order:
1.5.1
1.5.2b2
161
3.10a
8.02
3.4j
1996.07.12
3.2.pl0
3.1.1.6
2g6
11g
0.960923
2.2beta29
1.13++
5.5.kw
2.0b1pl0
In fact, there is no such thing as an invalid version number under
this scheme; the rules for comparison are simple and predictable,
but may not always give the results you want (for some definition
of "want").
z(\d+ | [a-z]+ | \.)Nc C s |r| j | d S )N)r )r r r r r r . s zLooseVersion.__init__c C sb || _ dd | jj|D }x:t|D ].\}}yt|||< W q& tk
rR Y q&X q&W || _d S )Nc S s g | ]}|r|d kr|qS )r* r ).0xr r r
8 s z&LooseVersion.parse..)r component_resplit enumerater% r! r& )r r Z
componentsiobjr r r r 3 s
zLooseVersion.parsec C s | j S )N)r )r r r r r, C s zLooseVersion.__str__c C s dt | S )NzLooseVersion ('%s'))r )r r r r r G s zLooseVersion.__repr__c C sF t |trt|}| j|jkr"dS | j|jk r2dS | j|jkrBdS d S )Nr r r- )r. r r4 r& )r r r r r r
K s
zLooseVersion._cmp)N)
r
r r r r0 r1 r2 r8 r r r, r r
r r r r r4 s
r4 )r r0 r r r4 r r r r s
> /PK ! ;T> $ __pycache__/log.cpython-36.opt-2.pycnu [ 3
\ @ sh d Z dZdZdZdZddlZG dd dZe ZejZej Z ej
Z
ej Z ej Z ej
Z
d d
Zd d ZdS )
Nc @ sP e Zd ZefddZdd Zdd Zdd Zd d
Zd d Z d
d Z
dd Z dS )Logc C s
|| _ d S )N) threshold)selfr r
%/usr/lib64/python3.6/distutils/log.py__init__ s z Log.__init__c C s |t ttttfkr"tdt| || jkr|r8|| }|tttfkrNtj }ntj
}y|j d| W n: t k
r |j
}|j|dj|}|j d| Y nX |j d S )Nz%s wrong log levelz%s
backslashreplace)DEBUGINFOWARNERRORFATAL
ValueErrorstrr sysstderrstdoutwriteUnicodeEncodeErrorencodingencodedecodeflush)r levelmsgargsstreamr r
r
r _log s
zLog._logc G s | j ||| d S )N)r" )r r r r r
r
r log' s zLog.logc G s | j t|| d S )N)r" r )r r r r
r
r debug* s z Log.debugc G s | j t|| d S )N)r" r )r r r r
r
r info- s zLog.infoc G s | j t|| d S )N)r" r )r r r r
r
r warn0 s zLog.warnc G s | j t|| d S )N)r" r )r r r r
r
r error3 s z Log.errorc G s | j t|| d S )N)r" r )r r r r
r
r fatal6 s z Log.fatalN) __name__
__module__ __qualname__r r r" r# r$ r% r& r' r( r
r
r
r r s r c C s t j}| t _|S )N) _global_logr )r oldr
r
r
set_thresholdA s r. c C s8 | dkrt t n"| dkr$t t n| dkr4t t d S )Nr r r )r. r r r )vr
r
r
set_verbosityG s
r0 )r r r r r r r r, r# r$ r% r& r' r( r. r0 r
r
r
r s +PK ! B: : __pycache__/cmd.cpython-36.pycnu [ 3
\J @ sr d Z ddlZddlZddlZddlmZ ddlmZmZm Z m
Z
m Z ddlm Z G dd dZ
G dd d e
ZdS )
ztdistutils.cmd
Provides the Command class, the base class for the command classes
in the distutils.command package.
N)DistutilsOptionError)utildir_util file_util archive_utildep_util)logc @ s" e Zd ZdZg Zdd Zdd Zdd Zdd Zd
d Z dCddZ
dd Z dDddZ dd Z
dEddZdFddZdd ZdGd d Zd d Zd!d" Zd#d$ Zd%d& ZdHd'd(ZdId*d+Zd,d- Zd.d/ Zd0d1 ZdJd2d3ZdKd5d6Z dLd7d8Z dMd9d:Z dNd;d<Z dOd=d>Z dPd?d@Z!dQdAdBZ"d S )RCommanda} Abstract base class for defining command classes, the "worker bees"
of the Distutils. A useful analogy for command classes is to think of
them as subroutines with local variables called "options". The options
are "declared" in 'initialize_options()' and "defined" (given their
final values, aka "finalized") in 'finalize_options()', both of which
must be defined by every command class. The distinction between the
two is necessary because option values might come from the outside
world (command line, config file, ...), and any options dependent on
other options must be computed *after* these outside influences have
been processed -- hence 'finalize_options()'. The "body" of the
subroutine, where it does all its work based on the values of its
options, is the 'run()' method, which must also be implemented by every
command class.
c C sb ddl m} t||s td| jtkr0td|| _| j d| _ |j
| _
d| _ d| _ d| _
dS )zCreate and initialize a new Command object. Most importantly,
invokes the 'initialize_options()' method, which is the real
initializer and depends on the actual command being
instantiated.
r ) Distributionz$dist must be a Distribution instancez Command is an abstract classN)Zdistutils.distr
isinstance TypeError __class__r RuntimeError distributioninitialize_optionsZ_dry_runverboseforcehelp finalized)selfZdistr
r %/usr/lib64/python3.6/distutils/cmd.py__init__/ s
zCommand.__init__c C s< |dkr0t | d| }|d kr*t | j|S |S nt|d S )Ndry_run_)getattrr AttributeError)r attrZmyvalr r r __getattr___ s zCommand.__getattr__c C s | j s| j d| _ d S )N )r finalize_options)r r r r ensure_finalizedi s zCommand.ensure_finalizedc C s t d| j dS )a Set default values for all the options that this command
supports. Note that these defaults may be overridden by other
commands, by the setup script, by config files, or by the
command-line. Thus, this is not the place to code dependencies
between options; generally, 'initialize_options()' implementations
are just a bunch of "self.foo = None" assignments.
This method must be implemented by all command classes.
z,abstract method -- subclass %s must overrideN)r r
)r r r r r { s
zCommand.initialize_optionsc C s t d| j dS )a Set final values for all the options that this command supports.
This is always called as late as possible, ie. after any option
assignments from the command-line or from other commands have been
done. Thus, this is the place to code option dependencies: if
'foo' depends on 'bar', then it is safe to set 'foo' from 'bar' as
long as 'foo' still has the same value it was assigned in
'initialize_options()'.
This method must be implemented by all command classes.
z,abstract method -- subclass %s must overrideN)r r
)r r r r r s zCommand.finalize_optionsN c C s ddl m} |d kr d| j }| j|| tjd |d }x\| jD ]R\}}}|j|}|d dkrp|d d
}t| |}| j|d||f tjd qDW d S ) Nr )
longopt_xlatezcommand options for '%s':)levelz r =z%s = %sr& ) Zdistutils.fancy_getoptr# get_command_nameannouncer INFO user_options translater )r headerindentr# optionr valuer r r dump_options s
zCommand.dump_optionsc C s t d| j dS )a A command's raison d'etre: carry out the action it exists to
perform, controlled by the options initialized in
'initialize_options()', customized by other commands, the setup
script, the command-line, and config files, and finalized in
'finalize_options()'. All terminal output and filesystem
interaction should be done by 'run()'.
This method must be implemented by all command classes.
z,abstract method -- subclass %s must overrideN)r r
)r r r r run s
z Command.runr c C s t j || dS )zmIf the current verbosity level is of greater than or equal to
'level' print 'msg' to stdout.
N)r )r msgr$ r r r r( s zCommand.announcec C s& ddl m} |r"t| tjj dS )z~Print 'msg' to stdout if the global DEBUG (taken from the
DISTUTILS_DEBUG environment variable) flag is true.
r )DEBUGN)Zdistutils.debugr3 printsysstdoutflush)r r2 r3 r r r debug_print s zCommand.debug_printc C sB t | |}|d kr"t| || |S t|ts>td|||f |S )Nz '%s' must be a %s (got `%s`))r setattrr strr )r r. whatdefaultvalr r r _ensure_stringlike s
zCommand._ensure_stringlikec C s | j |d| dS )zWEnsure that 'option' is a string; if not defined, set it to
'default'.
stringN)r> )r r. r< r r r
ensure_string s zCommand.ensure_stringc C sp t | |}|dkrdS t|tr6t| |tjd| n6t|trTtdd |D }nd}|sltd||f dS )zEnsure that 'option' is a list of strings. If 'option' is
currently a string, we split it either on /,\s*/ or /\s+/, so
"foo bar baz", "foo,bar,baz", and "foo, bar baz" all become
["foo", "bar", "baz"].
Nz,\s*|\s+c s s | ]}t |tV qd S )N)r r: ).0vr r r s z-Command.ensure_string_list..Fz''%s' must be a list of strings (got %r)) r r r: r9 resplitlistallr )r r. r= okr r r ensure_string_list s
zCommand.ensure_string_listc C s8 | j |||}|d k r4|| r4td| ||f d S )Nzerror in '%s' option: )r> r )r r. Ztesterr; Z error_fmtr< r= r r r _ensure_tested_string s z Command._ensure_tested_stringc C s | j |tjjdd dS )z5Ensure that 'option' is the name of an existing file.filenamez$'%s' does not exist or is not a fileN)rJ ospathisfile)r r. r r r ensure_filename s zCommand.ensure_filenamec C s | j |tjjdd d S )Nzdirectory namez)'%s' does not exist or is not a directory)rJ rL rM isdir)r r. r r r ensure_dirname s zCommand.ensure_dirnamec C s t | dr| jS | jjS d S )N command_name)hasattrrR r
__name__)r r r r r' s
zCommand.get_command_namec G sJ | j j|}|j x0|D ](\}}t| |dkrt| |t|| qW dS )a> Set the values of any "undefined" options from corresponding
option values in some other command object. "Undefined" here means
"is None", which is the convention used to indicate that an option
has not been changed between 'initialize_options()' and
'finalize_options()'. Usually called from 'finalize_options()' for
options that depend on some other command rather than another
option of the same command. 'src_cmd' is the other command from
which option values will be taken (a command object will be created
for it if necessary); the remaining arguments are
'(src_option,dst_option)' tuples which mean "take the value of
'src_option' in the 'src_cmd' command object, and copy it to
'dst_option' in the current command object".
N)r get_command_objr! r r9 )r Zsrc_cmdZ option_pairsZ src_cmd_objZ
src_optionZ
dst_optionr r r set_undefined_options s
z Command.set_undefined_optionsc C s | j j||}|j |S )zWrapper around Distribution's 'get_command_obj()' method: find
(create if necessary and 'create' is true) the command object for
'command', call its 'ensure_finalized()' method, and return the
finalized command object.
)r rU r! )r commandZcreateZcmd_objr r r get_finalized_command$ s z Command.get_finalized_commandr c C s | j j||S )N)r reinitialize_command)r rW Zreinit_subcommandsr r r rY 0 s z Command.reinitialize_commandc C s | j j| dS )zRun some other command: uses the 'run_command()' method of
Distribution, which creates and finalizes the command object if
necessary and then invokes its 'run()' method.
N)r run_command)r rW r r r rZ 4 s zCommand.run_commandc C s6 g }x,| j D ]"\}}|dks$|| r |j| q W |S )ak Determine the sub-commands that are relevant in the current
distribution (ie., that need to be run). This is based on the
'sub_commands' class attribute: each tuple in that list may include
a method that we call to determine if the subcommand needs to be
run for the current distribution. Return a list of command names.
N) sub_commandsappend)r ZcommandsZcmd_namemethodr r r get_sub_commands; s
zCommand.get_sub_commandsc C s t jd| j | d S )Nzwarning: %s: %s
)r warnr' )r r2 r r r r_ K s z Command.warnc C s t j|||| jd d S )N)r )r executer )r funcargsr2 r$ r r r r` N s zCommand.execute c C s t j||| jd d S )N)r )r mkpathr )r namemoder r r rd Q s zCommand.mkpathc C s t j||||| j || jdS )zCopy a file respecting verbose, dry-run and force flags. (The
former two default to whatever is in the Distribution object, and
the latter defaults to false for commands that don't define it.))r )r copy_filer r )r infileoutfile
preserve_modepreserve_timeslinkr$ r r r rg T s
zCommand.copy_filec C s t j|||||| j | jdS )z\Copy an entire directory tree respecting verbose, dry-run,
and force flags.
)r )r copy_treer r )r rh ri rj rk Zpreserve_symlinksr$ r r r rm ] s
zCommand.copy_treec C s t j||| jdS )z$Move a file respecting dry-run flag.)r )r move_filer )r srcdstr$ r r r rn f s zCommand.move_filec C s ddl m} |||| jd dS )z2Spawn an external command respecting dry-run flag.r )spawn)r N)Zdistutils.spawnrq r )r cmdZ search_pathr$ rq r r r rq j s z
Command.spawnc C s t j||||| j||dS )N)r ownergroup)r make_archiver )r Z base_nameformatZroot_dirZbase_dirrs rt r r r ru o s zCommand.make_archivec C s |dkrd| }t |tr"|f}nt |ttfs8td|dkrRd|dj|f }| jsdtj||rv| j |||| n
t
j | dS )a Special case of 'execute()' for operations that process one or
more input files and generate one output file. Works just like
'execute()', except the operation is skipped and a different
message printed if 'outfile' already exists and is newer than all
files listed in 'infiles'. If the command defined 'self.force',
and it is true, then the command is unconditionally run -- does no
timestamp checks.
Nz skipping %s (inputs unchanged)z9'infiles' must be a string, or a list or tuple of stringszgenerating %s from %sz, ) r r: rF tupler joinr r Z newer_groupr` r debug)r Zinfilesri ra rb Zexec_msgZskip_msgr$ r r r make_fileu s
zCommand.make_file)Nr" )r )N)N)N)r )r )Nr )rc )r r Nr )r r r r )r )r r )NNNN)NNr )#rT
__module__ __qualname____doc__r[ r r r! r r r0 r1 r( r8 r> r@ rI rJ rO rQ r' rV rX rY rZ r^ r_ r` rd rg rm rn rq ru rz r r r r r sF 0
r c @ s6 e Zd ZdZdgZdd Zdd Zd d
Zd d Zd
S ) install_miscz{Common base class for installing some files in a subdirectory.
Currently used by install_data and install_scripts.
install-dir=d!directory to install the files toc C s d | _ g | _d S )N) install_diroutfiles)r r r r r s z install_misc.initialize_optionsc C s | j d|df d S )NZinstallr )rV )r dirnamer r r _install_dir_from s z install_misc._install_dir_fromc C sR g | _ |sd S | j| j x2|D ]*}| j|| j | j jtjj| j| q W d S )N)r rd r rg r\ rL rM rx )r Zfilelistfr r r _copy_files s
zinstall_misc._copy_filesc C s | j S )N)r )r r r r get_outputs s zinstall_misc.get_outputsN)r r r ) rT r{ r| r} r* r r r r r r r r r~ s r~ )r} r5 rL rD Zdistutils.errorsr Z distutilsr r r r r r r r~ r r r r s PK ! ^9b
b
) __pycache__/dir_util.cpython-36.opt-2.pycnu [ 3
\b @ sl d dl Z d dlZd dlmZmZ d dlmZ i adddZddd Z dd
d Z
d d
Z dddZ dd Z
dS ) N)DistutilsFileErrorDistutilsInternalError)log c C sp t | tstd| f tjj| } g }tjj| s<| dkr@|S tjtjj | rV|S tjj
| \}}|g}x6|r|rtjj| rtjj
|\}}|j d| qnW x|D ]}tjj ||}tjj |} tj| rq|dkrt
jd| |s`ytj|| W nV tk
rT }
z8|
jtjko*tjj|sDtd||
jd f W Y d d }
~
X nX |j| dt| < qW |S )Nz(mkpath: 'name' must be a string (got %r) r r z creating %szcould not create '%s': %s)
isinstancestrr ospathnormpathisdir
_path_createdgetabspathsplitinsertjoinr infomkdirOSErrorerrnoZEEXISTr argsappend) namemodeverbosedry_runZ created_dirsheadtailZtailsdZabs_headexc r# */usr/lib64/python3.6/distutils/dir_util.pymkpath s>
&
r% c C sV t }x(|D ] }|jtjj| tjj| q W x t|D ]}t||||d q:W d S )N)r r )setaddr r r dirnamesortedr% )Zbase_dirfilesr r r Zneed_dirfiledirr# r# r$ create_treeP s
r- c C sf ddl m} | r,tjj| r,td| ytj| } W n> tk
rx }
z"|rVg } ntd| |
jf W Y d d }
~
X nX |st ||d g } x| D ]} tjj
| | }
tjj
|| }| j drq|otjj |
rtj
|
}|dkrtjd|| |stj|| | j| qtjj|
r>| jt|
|||||||d q||
||||||d | j| qW | S )
Nr ) copy_filez&cannot copy tree '%s': not a directoryz error listing files in '%s': %s)r z.nfsr zlinking %s -> %s)r r )Zdistutils.file_utilr. r r r r listdirr strerrorr% r
startswithislinkreadlinkr r symlinkr extend copy_tree)srcdstZ
preserve_modeZpreserve_timesZpreserve_symlinksupdater r r. nameseZoutputsnZsrc_nameZdst_nameZ link_destr# r# r$ r6 c sH
"
r6 c C sl xVt j| D ]H}t jj| |}t jj|rDt jj| rDt|| q |jt j|f q W |jt j | f d S )N)
r r/ r r r r2 _build_cmdtupler removermdir)r cmdtuplesfZreal_fr# r# r$ r= s r= c C s |dkrt jd| |r d S g }t| | xp|D ]h}y2|d |d tjj|d }|tkrdt|= W q0 tk
r } zt jd| | W Y d d }~X q0X q0W d S )Nr z'removing '%s' (and everything under it)r zerror removing %s: %s) r r r= r r r r r warn)Z directoryr r r@ cmdr r" r# r# r$ remove_tree s
rD c C s6 t jj| \}} | dd t jkr2|| dd } | S )Nr r )r r
splitdrivesep)r Zdriver# r# r$ ensure_relative s rG )r r r )r r r )r r r r r r )r r )r r Zdistutils.errorsr r Z distutilsr r r% r- r6 r= rD rG r# r# r# r$ s
?
D
PK ! nQ Q ' __pycache__/bcppcompiler.cpython-36.pycnu [ 3
\W: @ sx d Z ddlZddlmZmZmZmZmZmZ ddl m
Z
m Z m Z ddl
mZ ddlmZ ddlmZ G dd d e
ZdS )
zdistutils.bcppcompiler
Contains BorlandCCompiler, an implementation of the abstract CCompiler class
for the Borland C++ compiler.
N)DistutilsExecErrorDistutilsPlatformError CompileErrorLibError LinkErrorUnknownFileError) CCompilergen_preprocess_optionsgen_lib_options)
write_file)newer)logc
@ s e Zd ZdZdZi ZdgZdddgZee ZdZ dZ
d Z d
Z Z
d Zd d
dZd ddZd ddZd ddZd!ddZd"ddZd#dd ZdS )$ BCPPCompilerzConcrete class that implements an interface to the Borland C/C++
compiler, as defined by the CCompiler abstract class.
Zbcppz.cz.ccz.cppz.cxxz.objz.libz.dllz%s%sz.exer c C s t j| ||| d| _d| _d| _d | _ddddg| _ddddg| _d d
dd g| _d d
dd g| _ g | _
d
dd g| _ d
dd d g| _ d S )
Nz bcc32.exez ilink32.exeztlib.exez/tWMz/O2z/qz/g0z/Odz/Tpdz/Gnz/xz/r)
r __init__cclinkerlibZpreprocess_optionscompile_optionscompile_options_debugldflags_sharedldflags_shared_debugZldflags_static ldflags_exeldflags_exe_debug)selfverboseZdry_runforce r ./usr/lib64/python3.6/distutils/bcppcompiler.pyr 5 s zBCPPCompiler.__init__Nc C s | j ||||||\}} }}
} |p$g } | jd |rB| j| j n | j| j xD| D ]:}
y| |
\}}W n tk
r wVY nX tjj|}tjj|
}
| j tjj
|
|dkrqV|dkry| j dd|
|g W qV t k
r } zt
|W Y d d }~X qVX qV|| jkrd}n|| jkr,d}nd}d|
}y,| j | jg| |
||g | |g W qV t k
r } zt
|W Y d d }~X qVX qVW | S ) Nz-cz.resz.rcZbrcc32z-fo z-Pz-o)Z_setup_compileappendextendr r KeyErrorospathnormpathmkpathdirnamespawnr r
_c_extensions_cpp_extensionsr )r Zsources
output_dirmacros include_dirsdebug
extra_preargsextra_postargsZdependsobjectspp_optsZbuildZ compile_optsobjsrcextmsgZ input_optZ
output_optr r r compileQ sF
( zBCPPCompiler.compilec C s | j ||\}}| j||d}| j||r~|dg| }|r:y| j| jg| W q tk
rz } zt|W Y d d }~X qX n tjd| d S )N)r* z/uzskipping %s (up-to-date)) _fix_object_argslibrary_filename
_need_linkr' r r r r
r- ) r r0 Zoutput_libnamer* r- target_langoutput_filenameZlib_argsr5 r r r create_static_lib s z BCPPCompiler.create_static_libc C s | j ||\}}| j|||\}}}|r8tjdt| |d k rNtjj||}| j||r|t j
krd}| r~| j d d }q| j d d }n&d}| r| j
d d }n| jd d }|d krd}ntjj|\}}tjj|\}}tjj|d }tjj|d| }dg}x&|pg D ]}|jd||f qW | jt||fd | ttjj|}|g}g }xF|D ]>}tjjtjj|\}}|d
kr|j| n
|j| qfW x$|D ] } |jd tjj| qW |jd |j| |jd
|g |jd x<|D ]4} | j|| | } | d kr(|j| n
|j| q W |jd |jd |jd
|g |jd
|j| |
r|
|d d< | r|j| | jtjj| y| j| j g| W n, t k
r } zt | W Y d d } ~ X nX n tj d| d S )Nz7I don't know what to do with 'runtime_library_dirs': %sZc0w32Zc0d32r r z%s.defZEXPORTSz %s=_%sz
writing %sz.resz/L%sz/L.,z,,Zimport32Zcw32mtzskipping %s (up-to-date)) r7 Z
_fix_lib_argsr
warnstrr" r# joinr9 r Z
EXECUTABLEr r r r splitsplitextr& r Zexecuter mapr$ normcaser find_library_filer% r' r r r r- ) r Z target_descr0 r; r* Z librariesZ library_dirsZruntime_library_dirsZexport_symbolsr- r. r/ Z
build_tempr: Z startup_objZld_argsZdef_fileheadtailmodnamer4 Ztemp_dircontentsZsymZobjects2Z resourcesfilebaselr libfiler5 r r r link s|
zBCPPCompiler.linkc C sv |r"|d }|d |d ||f}n |d |f}xB|D ]6}x0|D ](}t jj|| j|}t jj|r>|S q>W q4W d S d S )NZ_dZ_bcpp)r" r# r@ r8 exists) r dirsr r- ZdlibZ try_namesdirnamerM r r r rE 4 s
z BCPPCompiler.find_library_filer c C s |d kr d}g }x|D ]}t jjt jj|\}}|| jddg krTtd||f |rdt jj|}|dkr|jt jj||| q|dkr|jt jj||d q|jt jj||| j qW |S )Nr z.rcz.resz"unknown file type '%s' (from '%s'))
r" r# rB rD src_extensionsr basenamer r@
obj_extension)r Zsource_filenamesZ strip_dirr* Z obj_namesZsrc_namerK r4 r r r object_filenamesN s"
z BCPPCompiler.object_filenamesc C s | j d ||\}}}t||}dg| } |d k r>| jd| |rN|| d d< |r\| j| | j| | js~|d ks~t||r|r| jtjj | y| j
| W n2 t k
r }
zt |
t
|
W Y d d }
~
X nX d S )Nz cpp32.exez-or )Z_fix_compile_argsr r r r r r% r" r# r& r' r printr ) r sourceZ output_filer+ r, r. r/ _r1 Zpp_argsr5 r r r
preprocessi s$
zBCPPCompiler.preprocess)r r r )NNNr NNN)Nr N)
NNNNNr NNNN)r )r r )NNNNN)__name__
__module__ __qualname____doc__Z
compiler_typeZ executablesr( r) rS rU Zstatic_lib_extensionZshared_lib_extensionZstatic_lib_formatZshared_lib_formatZ
exe_extensionr r6 r< rN rE rV rZ r r r r r sJ
B
|
r )r^ r" Zdistutils.errorsr r r r r r Zdistutils.ccompilerr r r
Zdistutils.file_utilr Zdistutils.dep_utilr Z distutilsr
r r r r r s
PK ! fY
& & $ __pycache__/extension.cpython-36.pycnu [ 3
\) @ s. d Z ddlZddlZG dd dZdd ZdS )zmdistutils.extension
Provides the Extension class, used to describe C/C++ extension
modules in setup scripts. Nc @ s" e Zd ZdZdddZdd ZdS ) Extensiona Just a collection of attributes that describes an extension
module and everything needed to build it (hopefully in a portable
way, but there are hooks that let you be as unportable as you need).
Instance attributes:
name : string
the full name of the extension, including any packages -- ie.
*not* a filename or pathname, but Python dotted name
sources : [string]
list of source filenames, relative to the distribution root
(where the setup script lives), in Unix form (slash-separated)
for portability. Source files may be C, C++, SWIG (.i),
platform-specific resource files, or whatever else is recognized
by the "build_ext" command as source for a Python extension.
include_dirs : [string]
list of directories to search for C/C++ header files (in Unix
form for portability)
define_macros : [(name : string, value : string|None)]
list of macros to define; each macro is defined using a 2-tuple,
where 'value' is either the string to define it to or None to
define it without a particular value (equivalent of "#define
FOO" in source or -DFOO on Unix C compiler command line)
undef_macros : [string]
list of macros to undefine explicitly
library_dirs : [string]
list of directories to search for C/C++ libraries at link time
libraries : [string]
list of library names (not filenames or paths) to link against
runtime_library_dirs : [string]
list of directories to search for C/C++ libraries at run time
(for shared extensions, this is when the extension is loaded)
extra_objects : [string]
list of extra files to link with (eg. object files not implied
by 'sources', static library that must be explicitly specified,
binary resource files, etc.)
extra_compile_args : [string]
any extra platform- and compiler-specific information to use
when compiling the source files in 'sources'. For platforms and
compilers where "command line" makes sense, this is typically a
list of command-line arguments, but for other platforms it could
be anything.
extra_link_args : [string]
any extra platform- and compiler-specific information to use
when linking object files together to create the extension (or
to create a new static Python interpreter). Similar
interpretation as for 'extra_compile_args'.
export_symbols : [string]
list of symbols to be exported from a shared extension. Not
used on all platforms, and not generally necessary for Python
extensions, which typically export exactly one symbol: "init" +
extension_name.
swig_opts : [string]
any extra options to pass to SWIG if a source file has the .i
extension.
depends : [string]
list of files that the extension depends on
language : string
extension language (i.e. "c", "c++", "objc"). Will be detected
from the source extensions if not provided.
optional : boolean
specifies that a build failure in the extension should not abort the
build process, but simply not install the failing extension.
Nc K s t |tstdt |to,tdd |D s6td|| _|| _|pHg | _|pRg | _|p\g | _ |pfg | _
|ppg | _ |pzg | _ | pg | _
|
pg | _| pg | _| pg | _|
pg | _|pg | _|| _|| _t|dkrdd |D }djt|}d | }tj| d S )
Nz'name' must be a stringc s s | ]}t |tV qd S )N)
isinstancestr).0v r +/usr/lib64/python3.6/distutils/extension.py j s z%Extension.__init__..z#'sources' must be a list of stringsr c S s g | ] }t |qS r )repr)r Zoptionr r r
s z&Extension.__init__..z, z Unknown Extension options: %s)r r AssertionErrorlistallnamesources include_dirs
define_macros undef_macros library_dirs librariesruntime_library_dirs
extra_objectsextra_compile_argsextra_link_argsexport_symbols swig_optsdependslanguageoptionallenjoinsortedwarningswarn)selfr r r r r r r r r r r r r r r r kwZoptionsmsgr r r __init__V s4
zExtension.__init__c C s d| j j| j j| jt| f S )Nz<%s.%s(%r) at %#x>) __class__
__module__ __qualname__r id)r$ r r r __repr__ s
zExtension.__repr__)NNNNNNNNNNNNNN)__name__r) r* __doc__r' r, r r r r r s ?
!r c C s ddl m}m}m} ddlm} ddlm} || }|| dddddd}zhg }x\|j } | dkrfP |j | rrqT| d | d$ kodkn r|j
d | qT|| |} || }
|
d } t | g } d}
x|
dd D ]}|
dk r|
j | d}
qt
jj|d }|dd
}|d
d }|d%kr8| jj | q|dkrP| jj | q|dkr|jd}|d&kr| jj |df n$| jj |d| ||d
d f q|dkr| jj | q|dkr| jj | q|dkr| jj | q|dkr| jj | q|dkr | jj | q|dkr0| j}
q|dkrB| j}
q|d krT| j}
q|d krx| jj | |s| j}
q|d'kr| jj | q|j
d#| qW |j | qTW W d|j X |S )(z3Reads a Setup file and returns Extension instances.r )parse_makefileexpand_makefile_vars _variable_rx)TextFile) split_quoted )Zstrip_commentsZ skip_blanksZ
join_linesZ lstrip_wsZ rstrip_wsN*z'%s' lines not handled yet .c.cc.cpp.cxx.c++.m.mmz-Iz-D=z-Uz-Cz-lz-Lz-Rz-rpathz-Xlinkerz
-Xcompilerz-u.a.so.sl.o.dylibzunrecognized argument '%s')r7 r8 r9 r: r; r< r= rD )r? r@ rA rB rC ) Zdistutils.sysconfigr/ r0 r1 Zdistutils.text_filer2 Zdistutils.utilr3 readlinematchr# r appendospathsplitextr r findr r r r r r r r close)filenamer/ r0 r1 r2 r3 varsfile
extensionslineZwordsmoduleZextZappend_next_wordZwordsuffixZswitchvalueZequalsr r r read_setup_file s
rU )r. rH r" r rU r r r r s zPK ! ͢ __pycache__/dist.cpython-36.pycnu [ 3
\ @ s d Z ddlZddlZddlZddlmZ y ddlZW n ek
rL dZY nX ddlT ddl m
Z
m Z ddl m
Z
mZmZ ddlmZ ddlmZ ejd ZG d
d d ZG d d
d
Zdd ZdS )z}distutils.dist
Provides the Distribution class, which represents the module distribution
being built/installed/distributed.
N)message_from_file)*) FancyGetopttranslate_longopt)
check_environ strtobool
rfc822_escape)log)DEBUGz^[a-zA-Z]([a-zA-Z0-9_]*)$c @ sp e Zd ZdZd~ddddgZdZdddddddddddddddddddddgZd>d? eD ZddiZdd@dAZ dBdC Z
ddEdFZ dGdH Z ddIdJZ
dKdL ZdMdN ZdOdP ZdQdR Zddg fdSdTZdUdV ZdWdX ZdYdZ Zd[d\ Zd]d^ Zd_d` ZddadbZddcddZddfdgZe j fdhdiZ djdk Z dldm Z dndo Z!dpdq Z"drds Z#dtdu Z$dvdw Z%dxdy Z&dzd{ Z'd|d} Z(dS ) Distributiona The core of the Distutils. Most of the work hiding behind 'setup'
is really done within a Distribution instance, which farms the work out
to the Distutils commands specified on the command line.
Setup scripts will almost never instantiate Distribution directly,
unless the 'setup()' function is totally inadequate to their needs.
However, it is conceivable that a setup script might wish to subclass
Distribution for some specialized purpose, and then pass the subclass
to 'setup()' as the 'distclass' keyword argument. If so, it is
necessary to respect the expectations that 'setup' has of Distribution.
See the code for 'setup()', in core.py, for details.
verbosevrun verbosely (default) quietq!run quietly (turns verbosity off)dry-runndon't actually do anythinghelphshow detailed help message no-user-cfgN-ignore pydistutils.cfg in your home directoryzCommon commands: (see '--help-commands' for more)
setup.py build will build the package underneath 'build/'
setup.py install will install the package
help-commandslist all available commandsnameprint package nameversionVprint package versionfullname print -authorprint the author's name author-email print the author's email address
maintainerprint the maintainer's namemaintainer-email$print the maintainer's email addresscontact7print the maintainer's name if known, else the author's
contact-email@print the maintainer's email address if known, else the author'surl print the URL for this packagelicense print the license of the packagelicencealias for --license description print the package descriptionlong-description"print the long package description platformsprint the list of platforms classifiers print the list of classifierskeywordsprint the list of keywordsprovides+print the list of packages/modules providedrequires+print the list of packages/modules required obsoletes0print the list of packages/modules made obsoletec C s g | ]}t |d qS )r )r ).0x rH &/usr/lib64/python3.6/distutils/dist.py
s s zDistribution.c C s d| _ d| _d| _x| jD ]}t| |d qW t | _x,| jjD ] }d| }t| |t| j| q@W i | _ d| _
d| _ d| _ i | _
g | _d| _i | _d| _d| _d| _d| _d| _d| _d| _d| _d| _d| _d| _i | _ i | _ |r8|j d}|dk rH|d= xD|j D ]8\}}| j |}x"|j D ]\} }
d|
f|| < q(W q W d|kr|d |d < |d= d
} t!dk r~t!j"| nt#j$j%| d x|j D ]\} }
t&| jd | rt| jd | |
njt&| j| rt| j| |
nLt&| | r t| | |
n2d
t'| } t!dk r"t!j"| nt#j$j%| d qW d| _(| j dk r|x0| j D ]&}
|
j)dsdP |
dkrRd| _(P qRW | j* dS )a0 Construct a new Distribution instance: initialize all the
attributes of a Distribution, and then use 'attrs' (a dictionary
mapping attribute names to values) to assign some of those
attributes their "real" values. (Any attributes not mentioned in
'attrs' will be assigned to some null value: 0, None, an empty list
or dictionary, etc.) Most importantly, initialize the
'command_obj' attribute to the empty dictionary; this will be
filled in with real command objects by 'parse_command_line()'.
r r get_N optionsz setup scriptr4 r2 z:'licence' distribution option is deprecated; use 'license'
Zset_z Unknown distribution option: %sT-z
--no-user-cfgF)+r dry_runr display_option_namessetattrDistributionMetadatametadata_METHOD_BASENAMESgetattrcmdclasscommand_packages script_name script_argscommand_optionsZ
dist_filespackagesZ package_dataZ package_dir
py_modules librariesheaders ext_modulesZ ext_packageZ include_dirsZ
extra_pathscripts
data_filesZpassword command_objhave_rungetitemsget_option_dictwarningswarnsysstderrwritehasattrrepr
want_user_cfg
startswithfinalize_options)selfZattrsattrbasenameZ method_namerM commandZ cmd_optionsopt_dictoptvalmsgkeyargrH rH rI __init__z s
zDistribution.__init__c C s& | j j|}|dkr"i }| j |< |S )zGet the option dictionary for a given command. If that
command's option dictionary hasn't been created yet, then create it
and return the new dictionary; otherwise, return the existing
option dictionary.
N)r[ re )rr ru dictrH rH rI rg s z Distribution.get_option_dictrL c C s ddl m} |d kr"t| jj }|d k r@| j|| |d }|sV| j|d d S xt|D ]l}| jj|}|d kr| j|d| q\| j|d| ||}x$|jdD ]}| j|d | qW q\W d S )Nr )pformatz zno commands known yetz no option dict for '%s' commandz option dict for '%s' command:rN )pprintr~ sortedr[ keysannouncere split) rr headercommandsindentr~ Zcmd_namerv outlinerH rH rI dump_option_dicts& s&
z Distribution.dump_option_dictsc C s g }t tjjtjd j}tjj|d}tjj|rB|j | tj
dkrRd}nd}| j rtjjtjj d|}tjj|r|j | d}tjj|r|j | t
r| jdd j| |S )
a Find as many configuration files as should be processed for this
platform, and return a list of filenames in the order in which they
should be parsed. The filenames returned are guaranteed to exist
(modulo nasty race conditions).
There are three possible config files: distutils.cfg in the
Distutils installation directory (ie. where the top-level
Distutils __inst__.py file lives), a file in the user's home
directory named .pydistutils.cfg on Unix and pydistutils.cfg
on Windows/Mac; and setup.cfg in the current directory.
The file in the user's home directory can be disabled with the
--no-user-cfg option.
distutilsz
distutils.cfgposixz.pydistutils.cfgzpydistutils.cfg~z setup.cfgzusing config files: %sz, )r ospathdirnamerj modules__file__joinisfileappendr ro
expanduserr
r )rr filesZsys_dirZsys_fileZ
user_filenameZ user_fileZ
local_filerH rH rI find_config_filesB s&
z Distribution.find_config_filesc C s ddl m} tjtjkr8ddddddd d
d d d
ddg
}ng }t|}|d krT| j }trb| jd | }x|D ]}tr| jd| |j | xf|j
D ]Z}|j |}| j |}x@|D ]8} | dkr| |kr|j
|| }
| jdd} ||
f|| < qW qW |j qnW d| jkrx| jd j D ]\} \} }
| jj
| } yF| rRt| | t|
n(| dkrnt| | t|
n t| | |
W n, tk
r }
zt|
W Y d d }
~
X nX q W d S )Nr ) ConfigParserz install-basezinstall-platbasez install-libzinstall-platlibzinstall-purelibzinstall-headerszinstall-scriptsz install-dataprefixz exec-prefixhomeuserrootz"Distribution.parse_config_files():z reading %s__name__rO _globalr rP )r rP )Z configparserr rj r base_prefix frozensetr r
r readZsectionsrM rg re replacer| r[ rf negative_optrR r
ValueErrorDistutilsOptionError)rr filenamesr Zignore_optionsparserfilenameZsectionrM rv rw rx srcaliasry rH rH rI parse_config_filesr sJ
z Distribution.parse_config_filesc C s | j }g | _t|| j }|j| j |jddi |j| j| d}|j }t
j | j | j
|rhdS x |r| j||}|dkrjdS qjW | jr| j|t| jdk| jd dS | jstddS ) a Parse the setup script's command line, taken from the
'script_args' instance attribute (which defaults to 'sys.argv[1:]'
-- see 'setup()' in core.py). This list is first processed for
"global options" -- options that set attributes of the Distribution
instance. Then, it is alternately scanned for Distutils commands
and options for that command. Each new command terminates the
options for the previous command. The allowed options for a
command are determined by the 'user_options' attribute of the
command class -- thus, we have to be able to load command classes
in order to parse the command line. Any error in that 'options'
attribute raises DistutilsGetoptError; any error on the
command-line raises DistutilsArgError. If no Distutils commands
were found on the command line, raises DistutilsArgError. Return
true if command-line was successfully parsed and we should carry
on with executing commands; false if no errors but we shouldn't
execute commands (currently, this only happens if user asks for
help).
r4 r2 )argsobjectNr )display_optionsr zno commands suppliedT)_get_toplevel_optionsr r r set_negative_aliasesr Z set_aliasesgetoptrZ Zget_option_orderr Z
set_verbosityr handle_display_options_parse_command_optsr
_show_helplenDistutilsArgError)rr Ztoplevel_optionsr r option_orderrH rH rI parse_command_line s,
z Distribution.parse_command_linec C s | j dg S )zReturn the non-display options recognized at the top level.
This includes options that are recognized *only* at the top
level as well as options recognized for commands.
command-packages=N0list of packages that provide distutils commands)r Nr )global_options)rr rH rH rI r s z"Distribution._get_toplevel_optionsc C s ddl m} |d }tj|s*td| | jj| y| j|}W n* tk
rn } zt |W Y dd}~X nX t
||st d| t |dot
|jtsd}t || | j}t |dr|j }|j|j t |d rt
|jtrt|j}ng }|j| j|j | |j| |j|d
d \}} t | d rV| jrV| j|d|gd dS t |d rt
|jtrd}
xP|jD ]F\} } }
}t | |j| r|d
}
t |r| nt d
|| f q|W |
rdS | j |}x&t | j D ]\}}d|f||< qW |S )a Parse the command-line options for a single command.
'parser' must be a FancyGetopt instance; 'args' must be the list
of arguments, starting with the current command (whose options
we are about to parse). Returns a new version of 'args' with
the next command at the front of the list; will be the empty
list if there are no more commands on the command line. Returns
None if the user asked for help on this command.
r )Commandzinvalid command name '%s'Nz&command class %s must subclass Command user_optionszIcommand class %s must provide 'user_options' attribute (a list of tuples)r help_optionsr r )r r zYinvalid help function %r for help option '%s': must be a callable object (function, etc.)z command line)
distutils.cmdr
command_rematch
SystemExitr r get_command_classDistutilsModuleErrorr
issubclassZDistutilsClassErrorrm
isinstancer listr copyupdater fix_help_optionsset_option_tabler r r r r Z
get_attr_namecallablerg varsrf )rr r r r ru Z cmd_classry r r ZoptsZhelp_option_foundZ help_optionZshortZdescfuncrv r valuerH rH rI r sb
z Distribution._parse_command_optsc C sT xNdD ]F}t | j|}|dkr qt|trdd |jdD }t| j|| qW dS )zSet final values for all the options on the Distribution
instance, analogous to the .finalize_options() method of Command
objects.
r> r: Nc S s g | ] }|j qS rH )strip)rF ZelmrH rH rI rJ _ s z1Distribution.finalize_options..,)r> r: )rV rT r strr rR )rr rs r rH rH rI rq U s
z Distribution.finalize_optionsc
C s ddl m} ddlm} |rR|r*| j }n| j}|j| |j| jd t d |rt|j| j
|jd t d x| j D ]z}t |t
rt||r|} n
| j|} t| drt | jtr|j| jt| j n |j| j |jd | j t d q|W t || j d
S ) ab Show help for the setup script command-line in the form of
several lists of command-line options. 'parser' should be a
FancyGetopt instance; do not expect it to be returned in the
same state, as its option table will be reset to make it
generate the correct help text.
If 'global_options' is true, lists the global options:
--verbose, --dry-run, etc. If 'display_options' is true, lists
the "display-only" options: --name, --version, etc. Finally,
lists per-command help for every command name or command class
in 'commands'.
r ) gen_usage)r z
Global options:rL z*Information display options (just display z!information, ignore any commands)r zOptions for '%s' command:NzKInformation display options (just display information, ignore any commands))distutils.corer r r r r r Z
print_help common_usageprintr r r typer r rm r r r r r rY )
rr r r r r r r rM ru klassrH rH rI r b s6
zDistribution._show_helpc C s ddl m} | jr4| j td t|| j dS d}i }x| jD ]}d||d < qDW xt|D ]l\}}|r^|j|r^t|}t | j
d| }|dkrtdj | n |dkrtd
j | nt| d}q^W |S )zIf there were any non-global "display-only" options
(--help-commands or the metadata display options) on the command
line, display the requested info and return true; else return
false.
r )r rL r rK r> r: r r< r@ rB rD rN )r> r: )r< r@ rB rD ) r r Z
help_commandsprint_commandsr rY r re r rV rT r ) rr r r Zany_display_optionsZis_display_optionoptionrw rx r rH rH rI r s, z#Distribution.handle_display_optionsc C sn t |d x\|D ]T}| jj|}|s0| j|}y
|j}W n tk
rR d}Y nX t d|||f qW dS )zZPrint a subset of the list of all commands -- used by
'print_commands()'.
:z(no description available)z
%-*s %sN)r rW re r r6 AttributeError)rr r r
max_lengthcmdr r6 rH rH rI print_command_list s
z Distribution.print_command_listc C s ddl }|jj}i }x|D ] }d||< qW g }x&| jj D ]}|j|s:|j| q:W d}x$|| D ]}t||krdt|}qdW | j|d| |rt | j|d| dS )an Print out a help message listing all available commands with a
description of each. The list is divided into "standard commands"
(listed in distutils.command.__all__) and "extra commands"
(mentioned in self.cmdclass, but not a standard command). The
descriptions come from the command class attribute
'description'.
r Nr zStandard commandszExtra commands)
distutils.commandru __all__rW r re r r r r )rr r std_commandsis_stdr extra_commandsr rH rH rI r s*
zDistribution.print_commandsc C s ddl }|jj}i }x|D ] }d||< qW g }x&| jj D ]}|j|s:|j| q:W g }x\|| D ]P}| jj|}|s| j|}y
|j}W n t k
r d}Y nX |j||f qdW |S )a> Get a list of (command, description) tuples.
The list is divided into "standard commands" (listed in
distutils.command.__all__) and "extra commands" (mentioned in
self.cmdclass, but not a standard command). The descriptions come
from the command class attribute 'description'.
r Nr z(no description available))
r ru r rW r re r r r6 r ) rr r r r r r rvr r6 rH rH rI get_command_list s(
z Distribution.get_command_listc C sN | j }t|tsJ|dkr d}dd |jdD }d|krD|jdd || _ |S )z9Return a list of packages from which commands are loaded.NrL c S s g | ]}|d kr|j qS )rL )r )rF ZpkgrH rH rI rJ s z5Distribution.get_command_packages..r zdistutils.commandr )rX r r r insert)rr ZpkgsrH rH rI get_command_packages s
z!Distribution.get_command_packagesc C s | j j|}|r|S x| j D ]}d||f }|}yt| tj| }W n tk
r^ w Y nX yt||}W n& tk
r t d|||f Y nX || j |< |S W t d| dS )ao Return the class that implements the Distutils command named by
'command'. First we check the 'cmdclass' dictionary; if the
command is mentioned there, we fetch the class object from the
dictionary and return it. Otherwise we load the command module
("distutils.command." + command) and fetch the command class from
the module. The loaded class is also stored in 'cmdclass'
to speed future calls to 'get_command_class()'.
Raises DistutilsModuleError if the expected module could not be
found, or if that module does not define the expected class.
z%s.%sz3invalid command '%s' (no class '%s' in module '%s')zinvalid command '%s'N)
rW re r
__import__rj r ImportErrorrV r r )rr ru r ZpkgnameZ module_nameZ
klass_namemodulerH rH rI r s(
z Distribution.get_command_classc C sn | j j|}| rj|rjtr(| jd| | j|}|| }| j |< d| j|< | jj|}|rj| j|| |S )a Return the command object for 'command'. Normally this object
is cached on a previous call to 'get_command_obj()'; if no command
object for 'command' is in the cache, then we either create and
return it (if 'create' is true) or return None.
z.z1error in %s: command '%s' has no such option '%s')get_command_namerg r
r rf Zboolean_optionsr r r r rR r rm r r ) rr rc Z option_dict command_namer sourcer Z bool_optsZneg_optZ is_stringry rH rH rI r ] s>
z!Distribution._set_command_optionsr c C s ddl m} t||s&|}| j|}n|j }|js8|S |j d|_d| j|< | j| |r|x |j D ]}| j
|| qhW |S )a Reinitializes a command to the state it was in when first
returned by 'get_command_obj()': ie., initialized but not yet
finalized. This provides the opportunity to sneak option
values in programmatically, overriding or supplementing
user-supplied values from the config files and command line.
You'll have to re-finalize the command object (by calling
'finalize_options()' or 'ensure_finalized()') before using it for
real.
'command' should be a command name (string) or command object. If
'reinit_subcommands' is true, also reinitializes the command's
sub-commands, as declared by the 'sub_commands' class attribute (if
it has one). See the "install" command for an example. Only
reinitializes the sub-commands that actually matter, ie. those
whose test predicates return true.
Returns the reinitialized command object.
r )r ) r r r r r Z finalizedZinitialize_optionsrd r Zget_sub_commandsreinitialize_command)rr ru Zreinit_subcommandsr r subrH rH rI r s
z!Distribution.reinitialize_commandc C s t j || d S )N)r )rr ry levelrH rH rI r s zDistribution.announcec C s x| j D ]}| j| qW dS )zRun each command that was seen on the setup script command line.
Uses the list of commands found and cache of command objects
created by 'get_command_obj()'.
N)r run_command)rr r rH rH rI run_commands s zDistribution.run_commandsc C sD | j j|rdS tjd| | j|}|j |j d| j |< dS )a Do whatever it takes to run a command (including nothing at all,
if the command has already been run). Specifically: if we have
already created and run the command named by 'command', return
silently without doing anything. If the command named by 'command'
doesn't even have a command object yet, create one. Then invoke
'run()' on that command object (or an existing one).
Nz
running %sr )rd re r infor Zensure_finalizedZrun)rr ru r rH rH rI r s
zDistribution.run_commandc C s t | jp| jpg dkS )Nr )r r\ r] )rr rH rH rI has_pure_modules s z Distribution.has_pure_modulesc C s | j ot| j dkS )Nr )r` r )rr rH rH rI has_ext_modules s z Distribution.has_ext_modulesc C s | j ot| j dkS )Nr )r^ r )rr rH rH rI has_c_libraries s z Distribution.has_c_librariesc C s | j p| j S )N)r r )rr rH rH rI has_modules s zDistribution.has_modulesc C s | j ot| j dkS )Nr )r_ r )rr rH rH rI has_headers s zDistribution.has_headersc C s | j ot| j dkS )Nr )ra r )rr rH rH rI has_scripts s zDistribution.has_scriptsc C s | j ot| j dkS )Nr )rb r )rr rH rH rI has_data_files s zDistribution.has_data_filesc C s | j o| j o| j S )N)r r r )rr rH rH rI is_pure s
zDistribution.is_pure)r r
r r )r r r )r r r )r r r )r Nr )r Nr )r Nr )r r r! )r" Nr# )r$ Nr% )r& Nr' )r( Nr) )r* Nr+ )r, Nr- )r. Nr/ )r0 Nr1 )r2 Nr3 )r4 Nr5 )r6 Nr7 )r8 Nr9 )r: Nr; )r< Nr= )r> Nr? )r@ NrA )rB NrC )rD NrE )N)NNrL )N)r )N)r ))r
__module__ __qualname____doc__r r r rQ r r| rg r r r r r r rq r r r r r r r r r r r INFOr r r r r r r r r r r rH rH rH rI r s
"
0
:C [
1(!" &
,
)
r c @ s e Zd ZdZdOZdPddZdd Zdd Zd d Zd d Z d!d" Z
d#d$ Z d%d& Z d'd( Z
d)d* Zd+d, Zd-d. Zd/d0 Zd1d2 Zd3d4 Zd5d6 ZeZd7d8 Zd9d: Zd;d< Zd=d> Zd?d@ ZdAdB ZdCdD Z dEdF Z dGdH Z dIdJ Z dKdL Z dMdN Z!dS )QrS z]Dummy class to hold the distribution meta-data: name, version,
author, and so forth.
r r r$ author_emailr( maintainer_emailr0 r2 r6 long_descriptionr> r: r" r,
contact_emailr< download_urlr@ rB rD Nc C s |d k r| j t| nfd | _d | _d | _d | _d | _d | _d | _d | _ d | _
d | _ d | _ d | _
d | _d | _d | _d | _d | _d S )N)
read_pkg_fileopenr r r$ r r( r r0 r2 r6 r r> r: r< r
r@ rB rD )rr r rH rH rI r| s& z DistributionMetadata.__init__c s t | fdd} fdd} d }|d| _|d| _|d| _|d | _d
| _|d | _d
| _|d | _|d
| _ d kr|d| _
nd
| _
|d| _ |d| _d kr|dj d| _
|d| _|d| _|dkr|d| _|d| _|d| _nd
| _d
| _d
| _d
S )z-Reads the metadata values from a file object.c s | }|dkrd S |S )NUNKNOWNrH )r r )ry rH rI _read_field s z7DistributionMetadata.read_pkg_file.._read_fieldc s j | d }|g krd S |S )N)Zget_all)r values)ry rH rI
_read_list# s z6DistributionMetadata.read_pkg_file.._read_listzmetadata-versionr r Zsummaryr$ Nz author-emailz home-pager2 z download-urlr6 r> r platformZ
classifierz1.1rB r@ rD )r r r r6 r$ r( r r r0 r2 r
r r r> r: r< rB r@ rD )rr filer r Zmetadata_versionrH )ry rI r s:
z"DistributionMetadata.read_pkg_filec C s2 t tjj|dddd}| j| W dQ R X dS )z7Write the PKG-INFO file into the release tree.
zPKG-INFOwzUTF-8)encodingN)r r r r write_pkg_file)rr Zbase_dirZpkg_inforH rH rI write_pkg_infoM s
z#DistributionMetadata.write_pkg_infoc C sb d}| j s"| js"| js"| js"| jr&d}|jd| |jd| j |jd| j |jd| j |jd| j |jd| j
|jd | j |jd
| j | jr|jd | j t
| j }|jd | d
j| j }|r|jd| | j|d| j | j|d| j | j|d| j | j|d| j | j|d| j dS )z9Write the PKG-INFO format data to a file object.
z1.0z1.1zMetadata-Version: %s
z Name: %s
z Version: %s
z Summary: %s
zHome-page: %s
z Author: %s
zAuthor-email: %s
z License: %s
zDownload-URL: %s
zDescription: %s
r z
Keywords: %s
ZPlatformZ
ClassifierZRequiresZProvidesZ ObsoletesN)r@ rB rD r< r
rl get_name get_versionget_descriptionget_url get_contactget_contact_email get_licenser get_long_descriptionr get_keywords _write_list
get_platformsget_classifiers get_requires get_provides
get_obsoletes)rr r r Z long_descr> rH rH rI r T s0 z#DistributionMetadata.write_pkg_filec C s$ x |D ]}|j d||f qW d S )Nz%s: %s
)rl )rr r r r r rH rH rI r v s
z DistributionMetadata._write_listc C s
| j pdS )Nr
)r )rr rH rH rI r | s z DistributionMetadata.get_namec C s
| j pdS )Nz0.0.0)r )rr rH rH rI r s z DistributionMetadata.get_versionc C s d| j | j f S )Nz%s-%s)r r )rr rH rH rI get_fullname s z!DistributionMetadata.get_fullnamec C s
| j pdS )Nr
)r$ )rr rH rH rI
get_author s z DistributionMetadata.get_authorc C s
| j pdS )Nr
)r )rr rH rH rI get_author_email s z%DistributionMetadata.get_author_emailc C s
| j pdS )Nr
)r( )rr rH rH rI get_maintainer s z#DistributionMetadata.get_maintainerc C s
| j pdS )Nr
)r )rr rH rH rI get_maintainer_email s z)DistributionMetadata.get_maintainer_emailc C s | j p| jpdS )Nr
)r( r$ )rr rH rH rI r s z DistributionMetadata.get_contactc C s | j p| jpdS )Nr
)r r )rr rH rH rI r s z&DistributionMetadata.get_contact_emailc C s
| j pdS )Nr
)r0 )rr rH rH rI r s z DistributionMetadata.get_urlc C s
| j pdS )Nr
)r2 )rr rH rH rI r s z DistributionMetadata.get_licensec C s
| j pdS )Nr
)r6 )rr rH rH rI r s z$DistributionMetadata.get_descriptionc C s
| j pdS )Nr
)r )rr rH rH rI r s z)DistributionMetadata.get_long_descriptionc C s
| j pg S )N)r> )rr rH rH rI r s z!DistributionMetadata.get_keywordsc C s | j p
dgS )Nr
)r: )rr rH rH rI r! s z"DistributionMetadata.get_platformsc C s
| j pg S )N)r< )rr rH rH rI r" s z$DistributionMetadata.get_classifiersc C s
| j pdS )Nr
)r
)rr rH rH rI get_download_url s z%DistributionMetadata.get_download_urlc C s
| j pg S )N)rB )rr rH rH rI r# s z!DistributionMetadata.get_requiresc C s, dd l }x|D ]}|jj| qW || _d S )Nr )distutils.versionpredicateversionpredicateVersionPredicaterB )rr r r r
rH rH rI set_requires s
z!DistributionMetadata.set_requiresc C s
| j pg S )N)r@ )rr rH rH rI r$ s z!DistributionMetadata.get_providesc C s: dd |D }x |D ]}dd l }|jj| qW || _d S )Nc S s g | ] }|j qS rH )r )rF r
rH rH rI rJ s z5DistributionMetadata.set_provides..r )r, r- Zsplit_provisionr@ )rr r r
r rH rH rI set_provides s
z!DistributionMetadata.set_providesc C s
| j pg S )N)rD )rr rH rH rI r% s z"DistributionMetadata.get_obsoletesc C s, dd l }x|D ]}|jj| qW || _d S )Nr )r, r- r. rD )rr r r r
rH rH rI
set_obsoletes s
z"DistributionMetadata.set_obsoletes)r r r$ r r( r r0 r2 r6 r r> r: r" r, r r< r
r@ rB rD )N)"r r r r rU r| r r r r r r r& r' r( r) r* r r r r Z get_licencer r r r! r" r+ r# r/ r$ r0 r% r1 rH rH rH rI rS sH
4"rS c C s( g }x | D ]}|j |dd q
W |S )zConvert a 4-tuple 'help_options' list as found in various command
classes to the 3-tuple form required by FancyGetopt.
r )r )rM Z new_optionsZ
help_tuplerH rH rI r s
r )r rj r reZemailr rh r Zdistutils.errorsZdistutils.fancy_getoptr r Zdistutils.utilr r r r r Zdistutils.debugr
compiler r rS r rH rH rH rI s2
] ZPK ! Y/& /& ) __pycache__/filelist.cpython-36.opt-1.pycnu [ 3
\ 2 @ s d Z ddlZddlZddlZddlZddlmZ ddlmZm Z ddl
m Z G dd dZ dd Z
ejfd
d Zd d
ZdddZdS )zsdistutils.filelist
Provides the FileList class, used for poking about the filesystem
and building lists of files.
N) convert_path)DistutilsTemplateErrorDistutilsInternalError)logc @ s| e Zd ZdZd ddZdd ZejfddZd d
Z d d Z
d
d Z dd Z dd Z
dd Zdd Zd ddZd dd ZdS ) FileLista A list of files built by on exploring the filesystem and filtered by
applying various patterns to what we find there.
Instance attributes:
dir
directory from which files will be taken -- only used if
'allfiles' not supplied to constructor
files
list of filenames currently being built/filtered/manipulated
allfiles
complete list of files under consideration (ie. without any
filtering applied)
Nc C s d | _ g | _d S )N)allfilesfiles)selfwarn debug_print r */usr/lib64/python3.6/distutils/filelist.py__init__ s zFileList.__init__c C s
|| _ d S )N)r )r r r r r
set_allfiles# s zFileList.set_allfilesc C s t || _d S )N)findallr )r dirr r r
r & s zFileList.findallc C s ddl m} |rt| dS )z~Print 'msg' to stdout if the global DEBUG (taken from the
DISTUTILS_DEBUG environment variable) flag is true.
r )DEBUGN)Zdistutils.debugr print)r msgr r r r
r ) s zFileList.debug_printc C s | j j| d S )N)r append)r itemr r r
r 3 s zFileList.appendc C s | j j| d S )N)r extend)r itemsr r r
r 6 s zFileList.extendc C s@ t ttjj| j}g | _x |D ]}| jjtjj| q W d S )N)sortedmapospathsplitr r join)r Zsortable_filesZ
sort_tupler r r
sort9 s
z
FileList.sortc C sD x>t t| jd ddD ]$}| j| | j|d kr| j|= qW d S )N r )rangelenr )r ir r r
remove_duplicatesC s zFileList.remove_duplicatesc C s |j }|d }d } }}|dkrTt|dk r ...c S s g | ] }t |qS r )r ).0wr r r
W s z1FileList._parse_template_line..r recursive-includerecursive-exclude z,'%s' expects ...c S s g | ] }t |qS r )r )r+ r, r r r
r- ] s graftprunez#'%s' expects a single zunknown action '%s')r& r' r( r) )r. r/ )r1 r2 )r r# r r )r lineZwordsactionpatternsr dir_patternr r r
_parse_template_lineL s,
z FileList._parse_template_linec C sX | j |\}}}}|dkrZ| jddj| x&|D ] }| j|dds4tjd| q4W n|dkr| jddj| x&|D ] }| j|dds|tjd | q|W n|d
kr| jd dj| x&|D ] }| j|d dstjd
| qW nj|dkr8| jddj| x*|D ]"}| j|d dstjd| qW n |dkr| jd|dj|f x,|D ]$}| j||ds`tjd|| q`W n|dkr| jd|dj|f x|D ]$}| j||dstjd|| qW nx|dkr| jd| | jd |dsTtjd| nB|dkrH| jd | | jd |dsTtjd | n td | d S ) Nr& zinclude r )anchorz%warning: no files found matching '%s'r' zexclude z9warning: no previously-included files found matching '%s'zglobal-includezglobal-include r z>warning: no files found matching '%s' anywhere in distributionzglobal-excludezglobal-exclude zRwarning: no previously-included files matching '%s' found anywhere in distributionzrecursive-includezrecursive-include %s %s)prefixz:warning: no files found matching '%s' under directory '%s'zrecursive-excludezrecursive-exclude %s %szNwarning: no previously-included files matching '%s' found under directory '%s'r1 zgraft z+warning: no directories found matching '%s'r2 zprune z6no previously-included directories found matching '%s'z'this cannot happen: invalid action '%s')r7 r r include_patternr r
exclude_patternr )r r3 r4 r5 r r6 patternr r r
process_template_lineh sf
z FileList.process_template_liner r c C sp d}t ||||}| jd|j | jdkr4| j x6| jD ],}|j|r<| jd| | jj| d}q r; r< r r r r
r s
L
,r c C s& dd t j| ddD }tt jj|S )z%
Find all files under 'path'
c s s, | ]$\}}}|D ]}t jj||V qqd S )N)r r r )r+ basedirsr filer r r
s z#_find_all_simple..T) followlinks)r walkfilterr isfile)r Zresultsr r r
_find_all_simple s rR c C s6 t | }| tjkr.tjtjj| d}t||}t|S )z
Find all files under 'dir' and return the list of full filenames.
Unless dir is '.', return full filenames with dir prepended.
)start) rR r rI functoolspartialr relpathr list)r r Zmake_relr r r
r s
r c C s8 t j| }tj}tjdkr d}d| }tjd||}|S )zTranslate a shell-like glob pattern to a regular expression; return
a string containing the regex. Differs from 'fnmatch.translate()' in
that '*' does not match "special characters" (which are
platform-specific).
\z\\\\z\1[^%s]z((?t| }nd}|dk rt|}|t|t|t| }tj} tjdkrd} |t|t|t| }d||| ||f }n |rd||t|d f }tj|S )a Translate a shell-like wildcard pattern to a compiled regular
expression. Return the compiled regex. If 'is_regex' true,
then 'pattern' is directly compiled to a regex (if it's a string)
or just returned as-is (assumes it's a regex object).
_ NrX z\\z%s\A%s%s.*%s%sz%s\A%s)
isinstancestrr\ compiler^ partitionr# r r[ )
r= r9 r: rA rS r_ endrC Z prefix_rer[ r r r
r? % s(
r? )r Nr )rH r r\ rY rT Zdistutils.utilr Zdistutils.errorsr r Z distutilsr r rR rI r r^ r? r r r r
s i PK ! wm ) __pycache__/dep_util.cpython-36.opt-2.pycnu [ 3
\
@ s2 d dl Z d dlmZ dd Zdd Zd
dd ZdS ) N)DistutilsFileErrorc C s` t jj| s tdt jj| t jj|s0dS ddlm} t j| | }t j|| }||kS )Nzfile '%s' does not exist r )ST_MTIME)ospathexistsr abspathstatr )sourcetargetr Zmtime1Zmtime2 r */usr/lib64/python3.6/distutils/dep_util.pynewer s r c C sl t | t |krtdg }g }xBtt | D ]2}t| | || r.|j| | |j|| q.W ||fS )Nz+'sources' and 'targets' must be same length)len
ValueErrorranger append)sourcesZtargetsZ n_sourcesZ n_targetsir r r
newer_pairwise s r errorc C s t jj|sdS ddlm} t j|| }xX| D ]L}t jj|sb|dkrJn|dkrVq0n |dkrbdS t j|| }||kr0dS q0W dS d S )Nr r )r r ignorer )r r r r r )r r Zmissingr Z target_mtimer
source_mtimer r r
newer_group6 s
r )r )r Zdistutils.errorsr r r r r r r r
s PK ! y + __pycache__/versionpredicate.cpython-36.pycnu [ 3
\
@ s d Z ddlZddlZddlZejdejZejdZejdZ dd Z
ej ej ej
ejejejdZG d d
d
Zdad d ZdS )
zBModule for parsing and testing package version predicate strings.
Nz'(?i)^\s*([a-z_]\w*(?:\.[a-z_]\w*)*)(.*)z^\s*\((.*)\)\s*$z%^\s*(<=|>=|<|>|!=|==)\s*([^\s,]+)\s*$c C s6 t j| }|std| |j \}}|tjj|fS )zVParse a single version comparison.
Return (comparison string, StrictVersion)
z"bad package restriction syntax: %r)re_splitComparisonmatch
ValueErrorgroups distutilsversion
StrictVersion)predrescompZverStr r 2/usr/lib64/python3.6/distutils/versionpredicate.pysplitUp s
r )z>=z!=c @ s( e Zd ZdZdd Zdd Zdd ZdS ) VersionPredicatea Parse and test package version predicates.
>>> v = VersionPredicate('pyepat.abc (>1.0, <3333.3a1, !=1555.1b3)')
The `name` attribute provides the full dotted name that is given::
>>> v.name
'pyepat.abc'
The str() of a `VersionPredicate` provides a normalized
human-readable version of the expression::
>>> print(v)
pyepat.abc (> 1.0, < 3333.3a1, != 1555.1b3)
The `satisfied_by()` method can be used to determine with a given
version number is included in the set described by the version
restrictions::
>>> v.satisfied_by('1.1')
True
>>> v.satisfied_by('1.4')
True
>>> v.satisfied_by('1.0')
False
>>> v.satisfied_by('4444.4')
False
>>> v.satisfied_by('1555.1b3')
False
`VersionPredicate` is flexible in accepting extra whitespace::
>>> v = VersionPredicate(' pat( == 0.1 ) ')
>>> v.name
'pat'
>>> v.satisfied_by('0.1')
True
>>> v.satisfied_by('0.2')
False
If any version numbers passed in do not conform to the
restrictions of `StrictVersion`, a `ValueError` is raised::
>>> v = VersionPredicate('p1.p2.p3.p4(>=1.0, <=1.3a1, !=1.2zb3)')
Traceback (most recent call last):
...
ValueError: invalid version number '1.2zb3'
It the module or package name given does not conform to what's
allowed as a legal module or package name, `ValueError` is
raised::
>>> v = VersionPredicate('foo-bar')
Traceback (most recent call last):
...
ValueError: expected parenthesized list: '-bar'
>>> v = VersionPredicate('foo bar (12.21)')
Traceback (most recent call last):
...
ValueError: expected parenthesized list: 'bar (12.21)'
c C s |j }|stdtj|}|s.td| |j \| _}|j }|rtj|}|sbtd| |j d }dd |jdD | _| jstd| ng | _d S )
z*Parse a version predicate string.
zempty package restrictionzbad package name in %rz expected parenthesized list: %rr c S s g | ] }t |qS r )r ).0ZaPredr r r
t s z-VersionPredicate.__init__..,z empty parenthesized list in %rN) stripr re_validPackager r namere_parensplitr )selfZversionPredicateStrr Zparenstrr r r
__init__` s$
zVersionPredicate.__init__c C s8 | j r.dd | j D }| jd dj| d S | jS d S )Nc S s g | ]\}}|d t | qS ) )r )r condverr r r
r } s z,VersionPredicate.__str__..z (z, ))r r join)r seqr r r
__str__{ s zVersionPredicate.__str__c C s* x$| j D ]\}}t| ||sdS qW dS )zTrue if version is compatible with all the predicates in self.
The parameter version must be acceptable to the StrictVersion
constructor. It may be either a string or StrictVersion.
FT)r compmap)r r r r r r r
satisfied_by s z VersionPredicate.satisfied_byN)__name__
__module__ __qualname____doc__r r# r% r r r r
r s ?r c C sd t dkrtjdtja | j } t j| }|s8td| |jdpDd}|rVtj j
|}|jd|fS )a9 Return the name and optional version number of a provision.
The version number, if given, will be returned as a `StrictVersion`
instance, otherwise it will be `None`.
>>> split_provision('mypkg')
('mypkg', None)
>>> split_provision(' mypkg( 1.2 ) ')
('mypkg', StrictVersion ('1.2'))
Nz=([a-zA-Z_]\w*(?:\.[a-zA-Z_]\w*)*)(?:\s*\(\s*([^)\s]+)\s*\))?$z"illegal provides specification: %r )
_provision_rxrecompileASCIIr r r groupr r r )valuemr r r r
split_provision s
r3 )r) r- Zdistutils.versionr operatorr. r/ r r r r ltleeqgtgener$ r r, r3 r r r r
s
nPK ! u>Ua Ua % __pycache__/dist.cpython-36.opt-2.pycnu [ 3
\ @ s d dl Z d dlZd dlZd dlmZ y d dlZW n ek
rH dZY nX d dlT d dlm Z m
Z
d dl m Z m
Z
mZ d dlmZ d dlmZ ejdZG d d
d
ZG d d d Zd
d ZdS ) N)message_from_file)*) FancyGetopttranslate_longopt)
check_environ strtobool
rfc822_escape)log)DEBUGz^[a-zA-Z]([a-zA-Z0-9_]*)$c @ sl e Zd Zd}d~dddgZdZdddddddddddddddddddddgZd=d> eD ZddiZdd?d@ZdAdB Z ddDdEZ
dFdG Z ddHdIZ dJdK Z
dLdM ZdNdO ZdPdQ Zddg fdRdSZdTdU ZdVdW ZdXdY ZdZd[ Zd\d] Zd^d_ Zdd`daZddbdcZddedfZej fdgdhZ didj Z dkdl Z dmdn Z dodp Z!dqdr Z"dsdt Z#dudv Z$dwdx Z%dydz Z&d{d| Z'dS ) Distributionverbosevrun verbosely (default) quietq!run quietly (turns verbosity off)dry-runndon't actually do anythinghelphshow detailed help message no-user-cfgN-ignore pydistutils.cfg in your home directoryzCommon commands: (see '--help-commands' for more)
setup.py build will build the package underneath 'build/'
setup.py install will install the package
help-commandslist all available commandsnameprint package nameversionVprint package versionfullname print -authorprint the author's name author-email print the author's email address
maintainerprint the maintainer's namemaintainer-email$print the maintainer's email addresscontact7print the maintainer's name if known, else the author's
contact-email@print the maintainer's email address if known, else the author'surl print the URL for this packagelicense print the license of the packagelicencealias for --license description print the package descriptionlong-description"print the long package description platformsprint the list of platforms classifiers print the list of classifierskeywordsprint the list of keywordsprovides+print the list of packages/modules providedrequires+print the list of packages/modules required obsoletes0print the list of packages/modules made obsoletec C s g | ]}t |d qS )r )r ).0x rH &/usr/lib64/python3.6/distutils/dist.py
s s zDistribution.c C s d| _ d| _d| _x| jD ]}t| |d qW t | _x,| jjD ] }d| }t| |t| j| q@W i | _ d | _
d | _ d | _ i | _
g | _d | _i | _d | _d | _d | _d | _d | _d | _d | _d | _d | _d | _d| _i | _ i | _ |r8|j d}|d k rH|d= xD|j D ]8\}}| j |}x"|j D ]\} }
d|
f|| < q(W q W d|kr|d |d< |d= d } t!d k r~t!j"| nt#j$j%| d
x|j D ]\} }
t&| jd | rt| jd | |
njt&| j| rt| j| |
nLt&| | r t| | |
n2d t'| } t!d k r"t!j"| nt#j$j%| d
qW d
| _(| j d k r|x0| j D ]&}
|
j)dsdP |
dkrRd| _(P qRW | j* d S )Nr r get_ optionsz setup scriptr4 r2 z:'licence' distribution option is deprecated; use 'license'
Zset_z Unknown distribution option: %sT-z
--no-user-cfgF)+r dry_runr display_option_namessetattrDistributionMetadatametadata_METHOD_BASENAMESgetattrcmdclasscommand_packages script_name script_argscommand_optionsZ
dist_filespackagesZ package_dataZ package_dir
py_modules librariesheaders ext_modulesZ ext_packageZ include_dirsZ
extra_pathscripts
data_filesZpassword command_objhave_rungetitemsget_option_dictwarningswarnsysstderrwritehasattrrepr
want_user_cfg
startswithfinalize_options)selfZattrsattrbasenameZ method_namerM commandZ cmd_optionsopt_dictoptvalmsgkeyargrH rH rI __init__z s
zDistribution.__init__c C s& | j j|}|d kr"i }| j |< |S )N)r[ re )rr ru dictrH rH rI rg s z Distribution.get_option_dictrL c C s ddl m} |d kr"t| jj }|d k r@| j|| |d }|sV| j|d d S xt|D ]l}| jj|}|d kr| j|d| q\| j|d| ||}x$|jdD ]}| j|d | qW q\W d S )Nr )pformatz zno commands known yetz no option dict for '%s' commandz option dict for '%s' command:rN )pprintr~ sortedr[ keysannouncere split) rr headercommandsindentr~ Zcmd_namerv outlinerH rH rI dump_option_dicts& s&
z Distribution.dump_option_dictsc C s g }t tjjtjd j}tjj|d}tjj|rB|j | tj
dkrRd}nd}| j rtjjtjj d|}tjj|r|j | d}tjj|r|j | t
r| jdd j| |S )
N distutilsz
distutils.cfgposixz.pydistutils.cfgzpydistutils.cfg~z setup.cfgzusing config files: %sz, )r ospathdirnamerj modules__file__joinisfileappendr ro
expanduserr
r )rr filesZsys_dirZsys_fileZ
user_filenameZ user_fileZ
local_filerH rH rI find_config_filesB s&
z Distribution.find_config_filesc C s ddl m} tjtjkr8ddddddd d
d d d
ddg
}ng }t|}|d krT| j }trb| jd | }x|D ]}tr| jd| |j | xf|j
D ]Z}|j |}| j |}x@|D ]8} | dkr| |kr|j
|| }
| jdd} ||
f|| < qW qW |j qnW d| jkrx| jd j D ]\} \} }
| jj
| } yF| rRt| | t|
n(| dkrnt| | t|
n t| | |
W n, tk
r }
zt|
W Y d d }
~
X nX q W d S )Nr ) ConfigParserz install-basezinstall-platbasez install-libzinstall-platlibzinstall-purelibzinstall-headerszinstall-scriptsz install-dataprefixz exec-prefixhomeuserrootz"Distribution.parse_config_files():z reading %s__name__rO _globalr rP )r rP )Z configparserr rj r base_prefix frozensetr r
r readZsectionsrM rg re replacer| r[ rf negative_optrR r
ValueErrorDistutilsOptionError)rr filenamesr Zignore_optionsparserfilenameZsectionrM rv rw rx srcaliasry rH rH rI parse_config_filesr sJ
z Distribution.parse_config_filesc C s | j }g | _t|| j }|j| j |jddi |j| j| d}|j }t
j | j | j
|rhd S x |r| j||}|d krjd S qjW | jr| j|t| jdk| jd d S | jstddS )Nr4 r2 )argsobjectr )display_optionsr zno commands suppliedT)_get_toplevel_optionsr r r set_negative_aliasesr Z set_aliasesgetoptrZ Zget_option_orderr Z
set_verbosityr handle_display_options_parse_command_optsr
_show_helplenDistutilsArgError)rr Ztoplevel_optionsr r option_orderrH rH rI parse_command_line s,
z Distribution.parse_command_linec C s | j dg S )Ncommand-packages=0list of packages that provide distutils commands)r Nr )global_options)rr rH rH rI r s z"Distribution._get_toplevel_optionsc C s ddl m} |d }tj|s*td| | jj| y| j|}W n* tk
rn } zt |W Y d d }~X nX t
||st d| t |dot
|jtsd}t || | j}t |dr|j }|j|j t |drt
|jtrt|j}ng }|j| j|j | |j| |j|d d \}} t | d
rV| jrV| j|d|gd d S t |drt
|jtrd}
xP|jD ]F\} } }
}t | |j| r|d }
t |r| nt d || f q|W |
rd S | j |}x&t | j D ]\}}d
|f||< qW |S )Nr )Commandzinvalid command name '%s'z&command class %s must subclass Command user_optionszIcommand class %s must provide 'user_options' attribute (a list of tuples)r help_optionsr r )r r zYinvalid help function %r for help option '%s': must be a callable object (function, etc.)z command line)
distutils.cmdr
command_rematch
SystemExitr r get_command_classDistutilsModuleErrorr
issubclassZDistutilsClassErrorrm
isinstancer listr copyupdater fix_help_optionsset_option_tabler r r r r Z
get_attr_namecallablerg varsrf )rr r r r ru Z cmd_classry r r ZoptsZhelp_option_foundZ help_optionZshortZdescfuncrv r valuerH rH rI r sb
z Distribution._parse_command_optsc C sT xNdD ]F}t | j|}|d kr qt|trdd |jdD }t| j|| qW d S )Nr> r: c S s g | ] }|j qS rH )strip)rF ZelmrH rH rI rJ _ s z1Distribution.finalize_options..,)r> r: )rV rT r strr rR )rr rs r rH rH rI rq U s
z Distribution.finalize_optionsc
C s ddl m} ddlm} |rR|r*| j }n| j}|j| |j| jd t d |rt|j| j
|jd
t d x| j D ]z}t |t
rt||r|} n
| j|} t| drt | jtr|j| jt| j n |j| j |jd | j t d q|W t || j d S ) Nr ) gen_usage)r z
Global options:rL z*Information display options (just display z!information, ignore any commands)r zOptions for '%s' command:zKInformation display options (just display information, ignore any commands))distutils.corer r r r r r Z
print_help common_usageprintr r r typer r rm r r r r r rY )
rr r r r r r r rM ru klassrH rH rI r b s6
zDistribution._show_helpc C s ddl m} | jr4| j td t|| j dS d}i }x| jD ]}d||d < qDW xt|D ]l\}}|r^|j|r^t|}t | j
d| }|dkrtdj | n |dkrtd
j | nt| d}q^W |S )Nr )r rL r rK r> r: r r< r@ rB rD rN )r> r: )r< r@ rB rD ) r r Z
help_commandsprint_commandsr rY r re r rV rT r ) rr r r Zany_display_optionsZis_display_optionoptionrw rx r rH rH rI r s, z#Distribution.handle_display_optionsc C sn t |d x\|D ]T}| jj|}|s0| j|}y
|j}W n tk
rR d}Y nX t d|||f qW d S )N:z(no description available)z
%-*s %s)r rW re r r6 AttributeError)rr r r
max_lengthcmdr r6 rH rH rI print_command_list s
z Distribution.print_command_listc C s dd l }|jj}i }x|D ] }d||< qW g }x&| jj D ]}|j|s:|j| q:W d}x$|| D ]}t||krdt|}qdW | j|d| |rt | j|d| d S )Nr r zStandard commandszExtra commands)
distutils.commandru __all__rW r re r r r r )rr r std_commandsis_stdr extra_commandsr rH rH rI r s*
zDistribution.print_commandsc C s dd l }|jj}i }x|D ] }d||< qW g }x&| jj D ]}|j|s:|j| q:W g }x\|| D ]P}| jj|}|s| j|}y
|j}W n t k
r d}Y nX |j||f qdW |S )Nr r z(no description available))
r ru r rW r re r r r6 r ) rr r r r r r rvr r6 rH rH rI get_command_list s(
z Distribution.get_command_listc C sN | j }t|tsJ|d kr d}dd |jdD }d|krD|jdd || _ |S )NrL c S s g | ]}|d kr|j qS )rL )r )rF ZpkgrH rH rI rJ s z5Distribution.get_command_packages..r zdistutils.commandr )rX r r r insert)rr ZpkgsrH rH rI get_command_packages s
z!Distribution.get_command_packagesc C s | j j|}|r|S x| j D ]}d||f }|}yt| tj| }W n tk
r^ w Y nX yt||}W n& tk
r t d|||f Y nX || j |< |S W t d| d S )Nz%s.%sz3invalid command '%s' (no class '%s' in module '%s')zinvalid command '%s')
rW re r
__import__rj r ImportErrorrV r r )rr ru r ZpkgnameZ module_nameZ
klass_namemodulerH rH rI r s(
z Distribution.get_command_classc C sn | j j|}| rj|rjtr(| jd| | j|}|| }| j |< d| j|< | jj|}|rj| j|| |S )Nz.z1error in %s: command '%s' has no such option '%s')get_command_namerg r
r rf Zboolean_optionsr r r r rR r rm r r ) rr rc Z option_dict command_namer sourcer Z bool_optsZneg_optZ is_stringry rH rH rI r ] s>
z!Distribution._set_command_optionsr c C s ddl m} t||s&|}| j|}n|j }|js8|S |j d|_d| j|< | j| |r|x |j D ]}| j
|| qhW |S )Nr )r ) r r r r r Z finalizedZinitialize_optionsrd r Zget_sub_commandsreinitialize_command)rr ru Zreinit_subcommandsr r subrH rH rI r s
z!Distribution.reinitialize_commandc C s t j || d S )N)r )rr ry levelrH rH rI r s zDistribution.announcec C s x| j D ]}| j| qW d S )N)r run_command)rr r rH rH rI run_commands s zDistribution.run_commandsc C sD | j j|rd S tjd| | j|}|j |j d| j |< d S )Nz
running %sr )rd re r infor Zensure_finalizedZrun)rr ru r rH rH rI r s
zDistribution.run_commandc C s t | jp| jpg dkS )Nr )r r\ r] )rr rH rH rI has_pure_modules s z Distribution.has_pure_modulesc C s | j ot| j dkS )Nr )r` r )rr rH rH rI has_ext_modules s z Distribution.has_ext_modulesc C s | j ot| j dkS )Nr )r^ r )rr rH rH rI has_c_libraries s z Distribution.has_c_librariesc C s | j p| j S )N)r r )rr rH rH rI has_modules s zDistribution.has_modulesc C s | j ot| j dkS )Nr )r_ r )rr rH rH rI has_headers s zDistribution.has_headersc C s | j ot| j dkS )Nr )ra r )rr rH rH rI has_scripts s zDistribution.has_scriptsc C s | j ot| j dkS )Nr )rb r )rr rH rH rI has_data_files s zDistribution.has_data_filesc C s | j o| j o| j S )N)r r r )rr rH rH rI is_pure s
zDistribution.is_pure)r r
r r )r r r )r r r )r r r )r Nr )r Nr )r Nr )r r r! )r" Nr# )r$ Nr% )r& Nr' )r( Nr) )r* Nr+ )r, Nr- )r. Nr/ )r0 Nr1 )r2 Nr3 )r4 Nr5 )r6 Nr7 )r8 Nr9 )r: Nr; )r< Nr= )r> Nr? )r@ NrA )rB NrC )rD NrE )N)NNrL )N)r )N)r )(r
__module__ __qualname__r r r rQ r r| rg r r r r r r rq r r r r r r r r r r r INFOr r r r r r r r r r r rH rH rH rI r s
"
0
:C [
1(!" &
,
)
r c @ s e Zd ZdNZdOddZdd Zdd Zd d Zd d Zd d! Z d"d# Z
d$d% Z d&d' Z d(d) Z
d*d+ Zd,d- Zd.d/ Zd0d1 Zd2d3 Zd4d5 ZeZd6d7 Zd8d9 Zd:d; Zdd? Zd@dA ZdBdC ZdDdE Z dFdG Z dHdI Z dJdK Z dLdM Z dS )PrS r r r$ author_emailr( maintainer_emailr0 r2 r6 long_descriptionr> r: r" r,
contact_emailr< download_urlr@ rB rD Nc C s |d k r| j t| nfd | _d | _d | _d | _d | _d | _d | _d | _ d | _
d | _ d | _ d | _
d | _d | _d | _d | _d | _d S )N)
read_pkg_fileopenr r r$ r r( r r0 r2 r6 r r> r: r< r r@ rB rD )rr r rH rH rI r| s& z DistributionMetadata.__init__c s t | fdd} fdd} d }|d| _|d| _|d| _|d | _d | _|d
| _d | _|d | _|d | _ d
kr|d
| _
nd | _
|d| _ |d| _d kr|dj d| _
|d| _|d| _|dkr|d| _|d| _|d| _nd | _d | _d | _d S )Nc s | }|dkrd S |S )NUNKNOWNrH )r r )ry rH rI _read_field s z7DistributionMetadata.read_pkg_file.._read_fieldc s j | d }|g krd S |S )N)Zget_all)r values)ry rH rI
_read_list# s z6DistributionMetadata.read_pkg_file.._read_listzmetadata-versionr r Zsummaryr$ z author-emailz home-pager2 z download-urlr6 r> r platformZ
classifierz1.1rB r@ rD )r r r r6 r$ r( r r r0 r2 r r r r> r: r< rB r@ rD )rr filer
r Zmetadata_versionrH )ry rI r
s:
z"DistributionMetadata.read_pkg_filec C s2 t tjj|dddd}| j| W d Q R X d S )NzPKG-INFOwzUTF-8)encoding)r r r r write_pkg_file)rr Zbase_dirZpkg_inforH rH rI write_pkg_infoM s
z#DistributionMetadata.write_pkg_infoc C sb d}| j s"| js"| js"| js"| jr&d}|jd| |jd| j |jd| j |jd| j |jd| j |jd| j
|jd | j |jd
| j | jr|jd | j t
| j }|jd | d
j| j }|r|jd| | j|d| j | j|d| j | j|d| j | j|d| j | j|d| j d S )Nz1.0z1.1zMetadata-Version: %s
z Name: %s
z Version: %s
z Summary: %s
zHome-page: %s
z Author: %s
zAuthor-email: %s
z License: %s
zDownload-URL: %s
zDescription: %s
r z
Keywords: %s
ZPlatformZ
ClassifierZRequiresZProvidesZ Obsoletes)r@ rB rD r< r rl get_name get_versionget_descriptionget_url get_contactget_contact_email get_licenser get_long_descriptionr get_keywords _write_list
get_platformsget_classifiers get_requires get_provides
get_obsoletes)rr r r Z long_descr> rH rH rI r T s0 z#DistributionMetadata.write_pkg_filec C s$ x |D ]}|j d||f qW d S )Nz%s: %s
)rl )rr r r r r rH rH rI r v s
z DistributionMetadata._write_listc C s
| j pdS )Nr )r )rr rH rH rI r | s z DistributionMetadata.get_namec C s
| j pdS )Nz0.0.0)r )rr rH rH rI r s z DistributionMetadata.get_versionc C s d| j | j f S )Nz%s-%s)r r )rr rH rH rI get_fullname s z!DistributionMetadata.get_fullnamec C s
| j pdS )Nr )r$ )rr rH rH rI
get_author s z DistributionMetadata.get_authorc C s
| j pdS )Nr )r )rr rH rH rI get_author_email s z%DistributionMetadata.get_author_emailc C s
| j pdS )Nr )r( )rr rH rH rI get_maintainer s z#DistributionMetadata.get_maintainerc C s
| j pdS )Nr )r )rr rH rH rI get_maintainer_email s z)DistributionMetadata.get_maintainer_emailc C s | j p| jpdS )Nr )r( r$ )rr rH rH rI r s z DistributionMetadata.get_contactc C s | j p| jpdS )Nr )r r )rr rH rH rI r s z&DistributionMetadata.get_contact_emailc C s
| j pdS )Nr )r0 )rr rH rH rI r s z DistributionMetadata.get_urlc C s
| j pdS )Nr )r2 )rr rH rH rI r s z DistributionMetadata.get_licensec C s
| j pdS )Nr )r6 )rr rH rH rI r s z$DistributionMetadata.get_descriptionc C s
| j pdS )Nr )r )rr rH rH rI r s z)DistributionMetadata.get_long_descriptionc C s
| j pg S )N)r> )rr rH rH rI r s z!DistributionMetadata.get_keywordsc C s | j p
dgS )Nr )r: )rr rH rH rI r s z"DistributionMetadata.get_platformsc C s
| j pg S )N)r< )rr rH rH rI r! s z$DistributionMetadata.get_classifiersc C s
| j pdS )Nr )r )rr rH rH rI get_download_url s z%DistributionMetadata.get_download_urlc C s
| j pg S )N)rB )rr rH rH rI r" s z!DistributionMetadata.get_requiresc C s, dd l }x|D ]}|jj| qW || _d S )Nr )distutils.versionpredicateversionpredicateVersionPredicaterB )rr r r r
rH rH rI set_requires s
z!DistributionMetadata.set_requiresc C s
| j pg S )N)r@ )rr rH rH rI r# s z!DistributionMetadata.get_providesc C s: dd |D }x |D ]}dd l }|jj| qW || _d S )Nc S s g | ] }|j qS rH )r )rF r
rH rH rI rJ s z5DistributionMetadata.set_provides..r )r+ r, Zsplit_provisionr@ )rr r r
r rH rH rI set_provides s
z!DistributionMetadata.set_providesc C s
| j pg S )N)rD )rr rH rH rI r$ s z"DistributionMetadata.get_obsoletesc C s, dd l }x|D ]}|jj| qW || _d S )Nr )r+ r, r- rD )rr r r r
rH rH rI
set_obsoletes s
z"DistributionMetadata.set_obsoletes)r r r$ r r( r r0 r2 r6 r r> r: r" r, r r< r r@ rB rD )N)!r r r rU r| r
r r r r r r% r& r' r( r) r r r r Z get_licencer r r r r! r* r" r. r# r/ r$ r0 rH rH rH rI rS sF
4"rS c C s( g }x | D ]}|j |dd q
W |S )Nr )r )rM Z new_optionsZ
help_tuplerH rH rI r s
r )rj r reZemailr rh r Zdistutils.errorsZdistutils.fancy_getoptr r Zdistutils.utilr r r r r Zdistutils.debugr
compiler r rS r rH rH rH rI s0
] ZPK ! < < % __pycache__/util.cpython-36.opt-1.pycnu [ 3
\5Q @ s d Z ddlZddlZddlZddlZddlZddlmZ ddl m
Z
ddl m Z ddl
mZ ddlmZ dd Zd
d Zd d
Zdadd Zdd Zd(ddZd a aadd Zdd Zd)ddZ dd 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 jdkrnd} tjj| }|d)kr(tjS tjjd|}tj|t| | j }|dkr\dS |dkrhdS tjS d t jkrt jd S t jd
kst t d rtjS t j
\}}}}}|j j d d
}|j dd}|j d d}|dd dkrd||f S |dd dkrV|d dkrd}dt |d d |dd f }d d d } |d | tj
7 }n|dd d!krtd||f S |dd d"krd#|||f S |dd$ d%krd%}tjd&tj}
|
j|} | r| j }n>|dd$ d'krddl} ddl}
| j|
jj |||\}}}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. for IRIX
the architecture isn't particularly important (IRIX only runs on SGI
hardware), but for Linux the kernel version isn't particularly
important.
Examples of returned values:
linux-i586
linux-alpha (?)
solaris-2.6-sun4u
irix-5.3
irix64-6.2
Windows will return one of:
win-amd64 (64bit Windows on AMD64 (aka x86_64, Intel64, EM64T, etc)
win-ia64 (64bit Windows on Itanium)
win32 (all others - specifically, sys.platform is returned)
For other non-POSIX platforms, currently just returns 'sys.platform'.
ntz bit ( )amd64z win-amd64itaniumzwin-ia64_PYTHON_HOST_PLATFORMposixuname/ _-N linuxz%s-%ssunosr 5solarisz%d.%s 32bit64bit)il z.%s irixaixz%s-%s.%s cygwinz[\d.]+darwinz%s-%s-%s)osnamesysversionfindplatformlenlowerenvironhasattrr replaceintmaxsizerecompileASCIImatchgroup _osx_supportZdistutils.sysconfigget_platform_osx sysconfigget_config_vars)prefixijlookosnamehostreleaser' machinebitnessrel_remr6 distutils rF &/usr/lib64/python3.6/distutils/util.py get_platform sX
rH c C s~ t jdkr| S | s| S | d dkr.td| | d dkrFtd| | jd}xd|krf|jd qRW |srt 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 absoluter z path '%s' cannot end with '/'.r# )r$ sep
ValueErrorsplitremovecurdirpathjoin)pathnamepathsrF rF rG convert_patho s
rS c C s t jdkr._substz\$([a-zA-Z_][a-zA-Z_0-9]*)zinvalid variable '$%s'N)r] r1 subKeyErrorrK )sr_ r` varrF rF rG
subst_vars s re error: c C s |t | S )N)r^ )excr: rF rF rG grok_environment_error s rh c C s( t jdtj at jdat jdad S )Nz
[^\\\'\"%s ]*z'(?:[^'\\]|\\.)*'z"(?:[^"\\]|\\.)*")r1 r2 string
whitespace
_wordchars_re
_squote_re
_dquote_rerF rF rF rG _init_regex s
rn c C s t dkrt | j } g }d}x`| rt j| |}|j }|t| kr\|j| d| P | | tjkr|j| d| | |d j } d}n| | dkr| d| | |d d } |d }n| | dkrt
j| |}n*| | dkrt j| |}nt d| | |dkr"t
d| | |j \}}| d| | |d |d | |d } |j d }|t| kr"|j| P q"W |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 rT r '"z!this can't happen (bad char '%c')z"bad string (mismatched %s quotes?)r )rk rn stripr4 endr* appendri rj lstriprl rm RuntimeErrorrK span)rc ZwordsposrD rr ZbegrF rF rG split_quoted s@
,
rx c C sP |dkr6d| j |f }|dd dkr6|dd d }tj| |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%rr z,)r r ry )__name__r info)funcargsmsgverbosedry_runrF rF rG execute s
r c C s2 | j } | dkrdS | dkr dS td| f dS )zConvert 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.
yyesttrueon1r nnoffalseoff0r zinvalid truth value %rN)r r r r r r )r r r r r r )r+ rK )valrF rF rG strtobool0 s r r c C sT ddl }tjrtd|dkr*do(|dk}|s8y ddlm} | d\}
} W n. tk
rz ddlm} d| d }
} Y nX tj d| |s|
dk rt
j |
d }
n
t | d }
|
j
d
|
j
d jtt| d |
j
d
|||||f |
j tjg}|j|j |j| t||d tt
j| fd| |d nddlm} x| D ]}|dd dkrhqL|dkr|dkrdn|}tj j ||d}n tj j |}|}|r|dt | |krt d||f |t |d }|rt
j j||}t
j j!|}|rL|st"||r.DistutilsRefactoringToolc _ s t j|f| d S )N)r error)selfr~ r} kwrF rF rG log_error s z4run_2to3..DistutilsRefactoringTool.log_errorc W s t j|f| d S )N)r r{ )r r~ r} rF rF rG log_message s z6run_2to3..DistutilsRefactoringTool.log_messagec W s t j|f| d S )N)r r )r r~ r} rF rF rG log_debug s z4run_2to3..DistutilsRefactoringTool.log_debugN)rz
__module__ __qualname__r r r rF rF rF rG DistutilsRefactoringTool s r z
lib2to3.fixes)optionsT)r )Zlib2to3.refactorr r Zrefactor)files fixer_namesr explicitr r r rrF rF rG run_2to3 s
r c C s ddl m} ddlm} ddlm} | } tj }
tj| z | j W dtj|
X | j
| j dd< |rx(|j D ] } | j
} | sqt| j| qtW g } xV| j D ]L}
tjj||
}|tjj| |tjj| |
|dd}|d r| j| qW tdd | D |||d
| S ) zRecursively 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)FileListNr )updatec S s g | ]}|j jd r|qS )z.py)r+ endswith).0fnrF rF rG
s z$copydir_run_2to3..)r r r )Zdistutils.dir_utilr Zdistutils.file_utilr Zdistutils.filelistr r$ getcwdchdirfindallZallfilesr
splitlinesrq Zprocess_template_linerO rP dirnamers r )srcdesttemplater r r r r r ZfilelistrN lineZcopiedfilenameZoutnameresrF rF rG copydir_run_2to3 s4
r c @ s$ e Zd ZdZdZdZdZdd ZdS ) Mixin2to3zMixin 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 )N)r r r r )r r rF rF rG r , s zMixin2to3.run_2to3)rz r r __doc__r r r r rF rF rF rG r s
r )rf )Nr r )r r NNr r N)NNN)NNNN)#r r$ r1 importlib.utilr ri r& Zdistutils.errorsr Zdistutils.dep_utilr Zdistutils.spawnr rE r r rH rS rW rY r] re rh rk rl rm rn rx r r r r r r r rF rF rF rG s@ ]
=
PK ! f * __pycache__/file_util.cpython-36.opt-1.pycnu [ 3
\ @ sZ d Z ddlZddlmZ ddlmZ ddddZdd d ZdddZdddZ dd Z
dS )zFdistutils.file_util
Utility functions for operating on single files.
N)DistutilsFileError)logZcopyingz hard linkingzsymbolically linking)Nhardsym i c N C s d}d}zvyt | d}W n4 tk
rN } ztd| |jf W Y dd}~X nX tjj|rytj| W n4 tk
r } ztd||jf W Y dd}~X nX yt |d}W n4 tk
r } ztd||jf W Y dd}~X nX xy|j|}W n6 tk
r* } ztd| |jf W Y dd}~X nX |s4P y|j | W q tk
rx } ztd||jf W Y dd}~X qX qW W d|r|j
|r|j
X dS ) a5 Copy the file 'src' to 'dst'; both must be filenames. Any error
opening either file, reading from 'src', or writing to 'dst', raises
DistutilsFileError. Data is read/written in chunks of 'buffer_size'
bytes (default 16k). No attempt is made to handle anything apart from
regular files.
Nrbzcould not open '%s': %szcould not delete '%s': %swbzcould not create '%s': %sz could not read from '%s': %szcould not write to '%s': %s) openOSErrorr strerrorospathexistsunlinkreadwriteclose)srcdst buffer_sizeZfsrcZfdsteZbuf r +/usr/lib64/python3.6/distutils/file_util.py_copy_file_contents sF $ """*r c C s ddl m} ddlm} m}
m} m} tjj | s %sr r ) Zdistutils.dep_utilr statr r r r r r
isfiler isdirjoinbasenamedirnamer debug _copy_actionKeyError
ValueErrorinfor samefilelinkr
symlinkr utimechmod)r r Z
preserve_modeZpreserve_timesupdater, verbosedry_runr r r r r diractionstr r r copy_fileC sT !
r6 c ( C s ddl m}m}m}m}m} ddl} |dkr:tjd| | |rB|S || sVt d| ||rrt
j j ||| }n||rt d| |f |||st d| |f d }
yt
j
| | W nP tk
r
} z2| j\} }
| | jkrd
}
nt d | ||
f W Y dd} ~ X nX |
rt| ||d yt
j| W nh tk
r } zJ| j\} }
yt
j| W n tk
rp Y nX t d
| || |
f W Y dd} ~ X nX |S )a% Move a file 'src' to 'dst'. If 'dst' is a directory, the file will
be moved into it with the same name; otherwise, 'src' is just renamed
to 'dst'. Return the new full name of the file.
Handles cross-device moves on Unix using 'copy_file()'. What about
other systems???
r )r r! r" r$ r% Nr zmoving %s -> %sz#can't move '%s': not a regular filez0can't move '%s': destination '%s' already existsz2can't move '%s': destination '%s' not a valid pathFTz couldn't move '%s' to '%s': %s)r1 zAcouldn't move '%s' to '%s' by copy/delete: delete '%s' failed: %s)Zos.pathr r! r" r$ r% errnor r* r r r
r# renamer
argsZEXDEVr6 r )r r r1 r2 r r! r" r$ r% r7 Zcopy_itr Znummsgr r r move_file sR
"
"r; c
C s: t | d}z x|D ]}|j|d qW W d|j X dS )z{Create a file with the specified name and write 'contents' (a
sequence of strings without line terminators) to it.
w
N)r r r )filenamecontentsfliner r r
write_file s
rB @ )rC )r r r Nr r )r r ) __doc__r Zdistutils.errorsr Z distutilsr r' r r6 r; rB r r r r s
3
c
=PK ! . . $ __pycache__/sysconfig.cpython-36.pycnu [ 3
KiN @ s d Z ddlZddlZddlZddlZddlmZ ejjej Z
ejjej Z ejjej
ZejjejZdejkrejjejd ZnejjejjejZejdkrej jd,rejjejjeZd d
Zeed dZeoejdkoej jd-rejjejjeZd d
Z e Z dZ ye s.ej Z W n e k
rF Y nX dd Z!d.ddZ"d/ddZ#dd Z$dd Z%dd Z&d0dd Z'ej(d Z)ej(d Z*ej(d Z+d1d d!Z,d"d# Z-da.d$d% Z/d&d' Z0d(d) Z1d*d+ Z2dS )2a Provide access to Python's configuration information. The specific
configuration variables available depend heavily on the platform and
configuration. The values may be retrieved using
get_config_var(name), and the list of variables is available via
get_config_vars().keys(). Additional convenience functions are also
available.
Written by: Fred L. Drake, Jr.
Email:
N )DistutilsPlatformErrorZ_PYTHON_PROJECT_BASEnt\pcbuild\win32\pcbuild\amd64c C s. x(dD ] }t jjt jj| d|rdS qW dS )N
Setup.dist Setup.localModulesTF)r r )ospathisfilejoin)dfn r +/usr/lib64/python3.6/distutils/sysconfig.py_is_python_source_dir) s
r _homec C s t r tt S ttS )N) _sys_homer project_baser r r r
_python_build2 s r c C s dt jdd S )zReturn a string containing the major and minor Python version,
leaving off the patchlevel. Sample return values could be '1.5'
or '2.2'.
z%d.%dN )sys version_infor r r r get_python_versionD s r c C s |dkr| rt pt}tjdkrjtrL| r.tp,tS tjjt dd}tjj
|S dt t }tjj|d|S tjdkrtjj|dS t
dtj dS ) a Return the directory containing installed Python header files.
If 'plat_specific' is false (the default), this is the path to the
non-platform-specific header files, i.e. Python.h and so on;
otherwise, this is the path to platform-specific header files
(namely pyconfig.h).
If 'prefix' is supplied, use it instead of sys.base_prefix or
sys.base_exec_prefix -- i.e., ignore 'plat_specific'.
NposixsrcdirZIncludepythonincluder zFI don't know where Python installs its C header files on platform '%s')BASE_EXEC_PREFIX BASE_PREFIXr
name python_buildr r r r
get_config_varnormpathr build_flagsr )
plat_specificprefixZincdirZ
python_dirr r r get_python_incL s
r) c C s |dkr&|r| rt pt}n | r"tp$t}tjdkrp| s8|r>d}nd}tjj||dt }|r`|S tjj|dS n rA ZccZcxxoptZcflagsZccsharedZldsharedZ shlib_suffixarZar_flagsZnewccZcppr? Zcc_cmdr r r rB s\
rB c C sD t r,tjdkr"tjjtptd} q6tp(t} n
tdd} tjj| dS )z2Return full pathname of installed pyconfig.h file.r PCr )r' z
pyconfig-64.h)r# r
r" r r
r r r) )inc_dirr r r get_config_h_filename s
rL c C s\ t rtjjtptdS tddd} djt t }t
t j drL|dt j j
7 }tjj| |dS )zAReturn full pathname of installed Makefile from the Python build.Makefiler r )r' r. z config-{}{}
_multiarchz-%s)r# r
r r
r r r/ formatr r& hasattrr implementationrN )Zlib_dirZ config_filer r r get_makefile_filename s rR c C s |dkr i }t jd}t jd}xx| j }|s0P |j|}|rz|jdd\}}y t|}W n tk
rn Y nX |||< q"|j|}|r"d||jd< q"W |S )zParse a config.h-style file.
A dictionary containing name/value pairs is returned. If an
optional dictionary is passed in as the second argument, it is
used instead of a new dictionary.
Nz"#define ([A-Z][A-Za-z0-9_]+) (.*)
z&/[*] #undef ([A-Z][A-Za-z0-9_]+) [*]/
r r r )recompilereadlinematchgroupint
ValueError)fpg define_rxundef_rxlinemnvr r r parse_config_h s(
rb z"([a-zA-Z][a-zA-Z0-9_]+)\s*=\s*(.*)z \$\(([A-Za-z][A-Za-z0-9_]*)\)z\${([A-Za-z][A-Za-z0-9_]*)}c C s ddl m} || ddddd}|dkr*i }i }i }x|j }|dkrFP tj|}|r4|jdd\}} | j } | jdd }
d
|
kr| ||< q4y t| } W n$ t k
r | jdd
||< Y q4X | ||< q4W d} x|rxt
|D ]} || }
t j |
pt
j |
}|rx|jd}d}||kr2t|| }n||krBd}nx|tjkrZtj| }n`|| kr| jdr| dd | krd }n$d| |krd}nt|d| }n d ||< }|r~|
|j d }|
d|j | | }
d
|kr|
|| < nzy t|
}
W n" t k
r* |
j || < Y n
X |
|| < || = | jdr~| dd | kr~| dd } | |kr~|
|| < q|| = qW qW |j x.|j D ]"\}} t| tr| j ||< qW |j| |S )zParse a Makefile-style file.
A dictionary containing name/value pairs is returned. If an
optional dictionary is passed in as the second argument, it is
used instead of a new dictionary.
r )TextFiler surrogateescape)Zstrip_commentsZ skip_blanksZ
join_lineserrorsNr z$$r $r5 r; r= TFPY_ )r5 r; r= )Zdistutils.text_filerc rU _variable_rxrV rW stripreplacerX rY list _findvar1_rxsearch _findvar2_rxstrr
rE rF endstartcloseitems
isinstanceupdate)r r[ rc rZ donenotdoner^ r_ r` ra tmpvrenamed_variablesr" valuefounditemafterkr r r parse_makefile s
r c C sZ xTt j| ptj| }|rP|j \}}| d| |j|jd | |d } qP qW | S )a Expand Makefile-style variables -- "${foo}" or "$(foo)" -- in
'string' according to 'vars' (a dictionary mapping variable names to
values). Variables not present in 'vars' are silently expanded to the
empty string. The variable values in 'vars' should not contain further
variable expansions; if 'vars' is the output of 'parse_makefile()',
you're fine. Returns a variable-expanded version of 's'.
r r N)rm rn ro spangetrW )svarsr_ Zbegrq r r r expand_makefile_vars s *r c C sV t jjddjtjtjttjddd} t | t
t dgd}|j }i a
t
j| dS ) z7Initialize the module as appropriate for POSIX systems._PYTHON_SYSCONFIGDATA_NAMEz+_sysconfigdata_{abi}_{platform}_{multiarch}rN r )abir@ multiarchbuild_time_varsr N)r
rE r rO r abiflagsr@ getattrrQ
__import__globalslocalsr rC rv )r" _tempr r r r _init_posix s r c C s~ i } t ddd| d< t ddd| d< tdd| d< tj d | d< d | d
< t jd d | d
< tjjtjj t
j | d< | a dS )z+Initialize the module as appropriate for NTr r )r' r. LIBDEST
BINLIBDEST)r' INCLUDEPY
EXT_SUFFIXz.exeEXE.r VERSIONBINDIRN)
r/ r) _impextension_suffixesr rk r
r dirnameabspathr
executablerC )r[ r r r _init_nt s r c G s^ t dkr(t jdtj }|r(| ni a tt d< tt d< t jd}|dk rV|t d< t jdt}tjdkrtrtj j
t }tj j ||}ntj j
t }tj j
tj j|t d< totjdkr
t}tj jt d o|tj kr
tj j |t d }tj j|t d< tjd kr(d
dl}|jt | rVg }x | D ]}|jt j| q8W |S t S dS ) a With no arguments, return a dictionary of all configuration
variables relevant for the current platform. Generally this includes
everything needed to build extensions and install both pure modules and
extensions. On Unix, this means every variable defined in Python's
installed Makefile; on Windows it's a much smaller set.
With arguments, return a list of values that result from looking up
each argument in the configuration variable dictionary.
NZ_init_r( exec_prefixr SOr r r0 r )rC r r r
r" r- r, r r# r r rR r
r r% isabsgetcwdr r@ rA customize_config_varsappend)argsfuncr r baserA valsr" r r r rD s@
rD c C s* | dkr ddl }|jdtd t j| S )zReturn the value of a single variable using the dictionary
returned by 'get_config_vars()'. Equivalent to
get_config_vars().get(name)
r r Nz SO is deprecated, use EXT_SUFFIXr )warningswarnDeprecationWarningrD r )r" r r r r r$ s r$ )r r )r r )r N)r r N)N)N)3__doc__r r
rS r re r r r% r( r- r r, base_prefixr! base_exec_prefixr rE r r r r r" lowerendswithr r r r r# r& r AttributeErrorr r) r/ rB rL rR rb rT ri rm ro r r rC r r rD r$ r r r r
sZ
#
+I
jJPK ! S۬ # __pycache__/dir_util.cpython-36.pycnu [ 3
\b @ sp d Z ddlZddlZddlmZmZ ddlmZ i adddZ dd d
Z
dd d Z d
d Z dddZ
dd ZdS )zWdistutils.dir_util
Utility functions for manipulating directories and directory trees. N)DistutilsFileErrorDistutilsInternalError)log c C sp t | tstd| f tjj| } g }tjj| s<| dkr@|S tjtjj | rV|S tjj
| \}}|g}x6|r|rtjj| rtjj
|\}}|j d| qnW x|D ]}tjj ||}tjj |} tj| rq|dkrt
jd| |s`ytj|| W nV tk
rT }
z8|
jtjko*tjj|sDtd||
jd f W Y dd}
~
X nX |j| dt| < qW |S ) a Create a directory and any missing ancestor directories.
If the directory already exists (or if 'name' is the empty string, which
means the current directory, which of course exists), then do nothing.
Raise DistutilsFileError if unable to create some directory along the way
(eg. some sub-path exists, but is a file rather than a directory).
If 'verbose' is true, print a one-line summary of each mkdir to stdout.
Return the list of directories actually created.
z(mkpath: 'name' must be a string (got %r) r r z creating %szcould not create '%s': %sN)
isinstancestrr ospathnormpathisdir
_path_createdgetabspathsplitinsertjoinr infomkdirOSErrorerrnoZEEXISTr argsappend) namemodeverbosedry_runZ created_dirsheadtailZtailsdZabs_headexc r# */usr/lib64/python3.6/distutils/dir_util.pymkpath s>
&
r% c C sV t }x(|D ] }|jtjj| tjj| q W x t|D ]}t||||d q:W dS )a Create all the empty directories under 'base_dir' needed to put 'files'
there.
'base_dir' is just the name of a directory which doesn't necessarily
exist yet; 'files' is a list of filenames to be interpreted relative to
'base_dir'. 'base_dir' + the directory portion of every file in 'files'
will be created if it doesn't already exist. 'mode', 'verbose' and
'dry_run' flags are as for 'mkpath()'.
)r r N)setaddr r r dirnamesortedr% )Zbase_dirfilesr r r Zneed_dirfiledirr# r# r$ create_treeP s
r- c C sf ddl m} | r,tjj| r,td| ytj| } W n> tk
rx }
z"|rVg } ntd| |
jf W Y dd}
~
X nX |st ||d g } x| D ]} tjj
| | }
tjj
|| }| j drq|otjj |
rtj
|
}|dkrtjd || |stj|| | j| qtjj|
r>| jt|
|||||||d
q||
||||||d
| j| qW | S ) a Copy an entire directory tree 'src' to a new location 'dst'.
Both 'src' and 'dst' must be directory names. If 'src' is not a
directory, raise DistutilsFileError. If 'dst' does not exist, it is
created with 'mkpath()'. The end result of the copy is that every
file in 'src' is copied to 'dst', and directories under 'src' are
recursively copied to 'dst'. Return the list of files that were
copied or might have been copied, using their output name. The
return value is unaffected by 'update' or 'dry_run': it is simply
the list of all files under 'src', with the names changed to be
under 'dst'.
'preserve_mode' and 'preserve_times' are the same as for
'copy_file'; note that they only apply to regular files, not to
directories. If 'preserve_symlinks' is true, symlinks will be
copied as symlinks (on platforms that support them!); otherwise
(the default), the destination of the symlink will be copied.
'update' and 'verbose' are the same as for 'copy_file'.
r ) copy_filez&cannot copy tree '%s': not a directoryz error listing files in '%s': %sN)r z.nfsr zlinking %s -> %s)r r )Zdistutils.file_utilr. r r r r listdirr strerrorr% r
startswithislinkreadlinkr r symlinkr extend copy_tree)srcdstZ
preserve_modeZpreserve_timesZpreserve_symlinksupdater r r. nameseZoutputsnZsrc_nameZdst_nameZ link_destr# r# r$ r6 c sH
"
r6 c C sl xVt j| D ]H}t jj| |}t jj|rDt jj| rDt|| q |jt j|f q W |jt j | f dS )zHelper for remove_tree().N)
r r/ r r r r2 _build_cmdtupler removermdir)r cmdtuplesfZreal_fr# r# r$ r= s r= c C s |dkrt jd| |r dS g }t| | xp|D ]h}y2|d |d tjj|d }|tkrdt|= W q0 tk
r } zt jd| | W Y dd}~X q0X q0W dS )zRecursively remove an entire directory tree.
Any errors are ignored (apart from being reported to stdout if 'verbose'
is true).
r z'removing '%s' (and everything under it)Nr zerror removing %s: %s) r r r= r r r r r warn)Z directoryr r r@ cmdr r" r# r# r$ remove_tree s
rD c C s6 t jj| \}} | dd t jkr2|| dd } | S )zTake the full path 'path', and make it a relative path.
This is useful to make 'path' the second argument to os.path.join().
r r N)r r
splitdrivesep)r Zdriver# r# r$ ensure_relative s rG )r r r )r r r )r r r r r r )r r )__doc__r r Zdistutils.errorsr r Z distutilsr r r% r- r6 r= rD rG r# r# r# r$ s
?
D
PK !
)
) __pycache__/dep_util.cpython-36.opt-1.pycnu [ 3
\
@ s6 d Z ddlZddlmZ dd Zdd Zd d d
ZdS ) zdistutils.dep_util
Utility functions for simple, timestamp-based dependency of files
and groups of files; also, function based entirely on such
timestamp dependency analysis. N)DistutilsFileErrorc C s` t jj| s tdt jj| t jj|s0dS ddlm} t j| | }t j|| }||kS )a Return true if 'source' exists and is more recently modified than
'target', or if 'source' exists and 'target' doesn't. Return false if
both exist and 'target' is the same age or younger than 'source'.
Raise DistutilsFileError if 'source' does not exist.
zfile '%s' does not exist r )ST_MTIME)ospathexistsr abspathstatr )sourcetargetr Zmtime1Zmtime2 r */usr/lib64/python3.6/distutils/dep_util.pynewer s r c C sl t | t |krtdg }g }xBtt | D ]2}t| | || r.|j| | |j|| q.W ||fS )zWalk two filename lists in parallel, testing if each source is newer
than its corresponding target. Return a pair of lists (sources,
targets) where source is newer than target, according to the semantics
of 'newer()'.
z+'sources' and 'targets' must be same length)len
ValueErrorranger append)sourcesZtargetsZ n_sourcesZ n_targetsir r r
newer_pairwise s r errorc C s t jj|sdS ddlm} t j|| }xX| D ]L}t jj|sb|dkrJn|dkrVq0n |dkrbdS t j|| }||kr0dS q0W dS dS )a Return true if 'target' is out-of-date with respect to any file
listed in 'sources'. In other words, if 'target' exists and is newer
than every file in 'sources', return false; otherwise return true.
'missing' controls what we do when a source file is missing; the
default ("error") is to blow up with an OSError from inside 'stat()';
if it is "ignore", we silently drop any missing source files; if it is
"newer", any missing source files make us assume that 'target' is
out-of-date (this is handy in "dry-run" mode: it'll make you pretend to
carry out commands that wouldn't work because inputs are missing, but
that doesn't matter because you're not actually going to run the
commands).
r r )r r ignorer N)r r r r r )r r Zmissingr Z target_mtimer
source_mtimer r r
newer_group6 s
r )r )__doc__r Zdistutils.errorsr r r r r r r r
s
PK ! 4Sc r@ normcaseZsrc_extensionsr rA rC rB
obj_extension)r/ Zsource_filenamesZ strip_dirrE Z obj_namesZsrc_namebaser6 r r r object_filenames s
z CygwinCCompiler.object_filenames)r r r )
NNNNNr NNNN)r rH )__name__
__module__ __qualname____doc__r+ rL Zstatic_lib_extensionZshared_lib_extensionZstatic_lib_formatZshared_lib_formatZ
exe_extensionr$ r9 rD rN r r r r r Y s
;
Kr c @ s e Zd ZdZdZdddZdS )Mingw32CCompilerz@ Handles the Mingw32 port of the GNU C compiler to Windows.
Zmingw32r c C sx t j| ||| | jdkr d}nd}| jdkr4d}nd}t rFtd| jdd d
d d | j||f d
g | _t | _d S )Nz2.13z-sharedz
-mdll -staticz2.91.57z--entry _DllMain@12rH z1Cygwin gcc cannot be used with --compiler=mingw32z gcc -O -Wallzgcc -mdll -O -Wallz g++ -O -Wallr z%s %s %s)r r r! r" r# )
r r$ r* r) is_cygwingccr
r- r, r. r )r/ r0 r1 r2 r3 Z entry_pointr r r r$ s&
zMingw32CCompiler.__init__N)r r r )rO rP rQ rR r+ r$ r r r r rS s rS okznot okZ uncertainc C s ddl m} dtjkr tdfS | j }y@t|}z(d|j krJtd| fS td| fS W d|j X W n. t
k
r } zt d ||j f fS d}~X nX dS )
aw Check if the current Python installation appears amenable to building
extensions with GCC.
Returns a tuple (status, details), where 'status' is one of the following
constants:
- CONFIG_H_OK: all is well, go ahead and compile
- CONFIG_H_NOTOK: doesn't look good
- CONFIG_H_UNCERTAIN: not sure -- unable to read pyconfig.h
'details' is a human-readable string explaining the situation.
Note there are two ways to conclude "OK": either 'sys.version' contains
the string "GCC" (implying that this Python was built with GCC), or the
installed "pyconfig.h" contains the string "__GNUC__".
r ) sysconfigZGCCzsys.version mentions 'GCC'Z__GNUC__z'%s' mentions '__GNUC__'z '%s' does not mention '__GNUC__'Nzcouldn't read '%s': %s)
distutilsrV r r r& get_config_h_filenameopenreadCONFIG_H_NOTOKcloseOSErrorCONFIG_H_UNCERTAINstrerror)rV fnconfig_hexcr r r r% H s
r% s (\d+\.\d+(\.\d+)*)c C sl | j d }t|dkr dS t| dtdj}z |j }W d|j X tj|}|dkrZdS t |j
dj S )zFind the version of an executable by running `cmd` in the shell.
If the command is not found, or the output does not match
`RE_VERSION`, returns None.
r NT)shellstdoutr ) splitr r r rd rZ r\
RE_VERSIONsearchr groupdecode)cmd
executableout
out_stringresultr r r _find_exe_versionu s
ro c C s dddg} t dd | D S )zg Try to find out the versions of gcc, ld and dllwrap.
If not possible it returns None for it.
zgcc -dumpversionzld -vzdllwrap --versionc S s g | ] }t |qS r )ro ).0rj r r r
s z get_versions..)tuple)Zcommandsr r r r( s
r( c C s t ddg} | j jdS )z>Try to determine if the gcc that would be used is from cygwin.r z -dumpmachines cygwin)r stripendswith)rm r r r rT s rT )'rR r= r r;
subprocessr r r reZdistutils.ccompilerr r Zdistutils.unixccompilerr Zdistutils.file_utilr Zdistutils.errorsr r
r r rW r
Zdistutils.versionr Zdistutils.spawnr r r rS r& r[ r^ r% compilerf ro r( rT r r r r s0 ) ;1+
PK ! Vf % __pycache__/core.cpython-36.opt-1.pycnu [ 3
\" @ s d Z ddlZddlZddlmZ ddlT ddlmZ ddlm Z ddl
m Z ddl m
Z
d Zd
d Zdadad4Zd5Zd/d0 Zd6d2d3ZdS )7a# distutils.core
The only module that needs to be imported to use the Distutils; provides
the 'setup' function (which is to be called from the setup script). Also
indirectly provides the Distribution and Command classes, although they are
really defined in distutils.dist and distutils.cmd.
N)DEBUG)*) Distribution)Command)
PyPIRCCommand) Extensionzusage: %(script)s [global_opts] cmd1 [cmd1_opts] [cmd2 [cmd2_opts] ...]
or: %(script)s --help [cmd1 cmd2 ...]
or: %(script)s --help-commands
or: %(script)s cmd --help
c C s t jj| }tt S )N)ospathbasenameUSAGEvars) script_nameZscript r &/usr/lib64/python3.6/distutils/core.py gen_usage s r distclassr
script_argsoptionsnameversionauthor author_email
maintainermaintainer_emailurllicense descriptionlong_descriptionkeywords platforms classifiers download_urlrequiresprovides obsoletessources include_dirs
define_macros undef_macros library_dirs librariesruntime_library_dirs
extra_objectsextra_compile_argsextra_link_args swig_optsexport_symbolsdependslanguagec , K s | j d}|r| d= nt}d| kr8tjjtjd | d< d| krRtjdd | d< y|| a}W nL tk
r } z0d| krt d| nt d | d |f W Y dd}~X nX t
d
kr|S |j t rt
d |j t
d kr|S y |j }W n: tk
r* } z t t|jd
| W Y dd}~X nX t rBt
d |j t
dkrP|S |ry |j W n tk
r t dY n tk
r } z0t rtjjd|f nt d|f W Y dd}~X nB ttfk
r } z t r nt dt| W Y dd}~X nX |S )a The gateway to the Distutils: do everything your setup script needs
to do, in a highly flexible and user-driven way. Briefly: create a
Distribution instance; find and parse config files; parse the command
line; run each Distutils command found there, customized by the options
supplied to 'setup()' (as keyword arguments), in config files, and on
the command line.
The Distribution instance might be an instance of a class supplied via
the 'distclass' keyword argument to 'setup'; if no such class is
supplied, then the Distribution class (in dist.py) is instantiated.
All other arguments to 'setup' (except for 'cmdclass') are used to set
attributes of the Distribution instance.
The 'cmdclass' argument, if supplied, is a dictionary mapping command
names to command classes. Each command encountered on the command line
will be turned into a command class, which is in turn instantiated; any
class found in 'cmdclass' is used in place of the default, which is
(for command 'foo_bar') class 'foo_bar' in module
'distutils.command.foo_bar'. The command class must provide a
'user_options' attribute which is a list of option specifiers for
'distutils.fancy_getopt'. Any command-line options between the current
and the next command are used to set attributes of the current command
object.
When the entire command-line has been successfully parsed, calls the
'run()' method on each command object in turn. This method will be
driven entirely by the Distribution object (which each command object
has a reference to, thanks to its constructor), and the
command-specific options that became attributes of each command
object.
r r
r r Nr zerror in setup command: %sz error in %s setup command: %sinitz%options (after parsing config files):configz
error: %sz%options (after parsing command line): commandlineZ interruptedz
error: %s
z error: %szerror: )getr r r r
sysargv_setup_distributionZDistutilsSetupError
SystemExit_setup_stop_afterZparse_config_filesr printZdump_option_dictsZparse_command_lineZDistutilsArgErrorr r
Z run_commandsKeyboardInterruptOSErrorstderrwriteZDistutilsErrorZCCompilerErrorstr)ZattrsklassZdistmsgokexcr r r setup9 s` %
" (
"rG runc C s |d krt d|f |atjj }d| i}yZzH| tjd< |dk rP|tjd d< t| d
}t|j | W dQ R X W d|t_daX W n tk
r Y nX t dkrt
d | t S )
a. Run a setup script in a somewhat controlled environment, and
return the Distribution instance that drives things. This is useful
if you need to find out the distribution meta-data (passed as
keyword args from 'script' to 'setup()', or the contents of the
config files or command-line.
'script_name' is a file that will be read and run with 'exec()';
'sys.argv[0]' will be replaced with 'script' for the duration of the
call. 'script_args' is a list of strings; if supplied,
'sys.argv[1:]' will be replaced by 'script_args' for the duration of
the call.
'stop_after' tells 'setup()' when to stop processing; possible
values:
init
stop after the Distribution instance has been created and
populated with the keyword arguments to 'setup()'
config
stop after config files have been parsed (and their data
stored in the Distribution instance)
commandline
stop after the command-line ('sys.argv[1:]' or 'script_args')
have been parsed (and the data stored in the Distribution)
run [default]
stop after all commands have been run (the same as if 'setup()'
had been called in the usual way
Returns the Distribution instance, which provides all information
used to drive the Distutils.
r4 r5 r6 rH z"invalid value for 'stop_after': %r__file__r Nr3 rbzZ'distutils.core.setup()' was never called -- perhaps '%s' is not a Distutils setup script?)r4 r5 r6 rH )
ValueErrorr< r8 r9 copyopenexecreadr; r: RuntimeError)r
r Z
stop_afterZ save_argvgfr r r run_setup s(
rS )r r
r r r r r r r r r r r r r r r r! r" r# r$ )r r% r& r' r( r) r* r+ r, r- r. r/ r0 r1 r2 )NrH )__doc__r r8 Zdistutils.debugr Zdistutils.errorsZdistutils.distr Z
distutils.cmdr Zdistutils.configr Zdistutils.extensionr r r r< r: Zsetup_keywordsZextension_keywordsrG rS r r r r s2 qPK ! B: : $ __pycache__/cmd.cpython-36.opt-1.pycnu [ 3
\J @ sr d Z ddlZddlZddlZddlmZ ddlmZmZm Z m
Z
m Z ddlm Z G dd dZ
G dd d e
ZdS )
ztdistutils.cmd
Provides the Command class, the base class for the command classes
in the distutils.command package.
N)DistutilsOptionError)utildir_util file_util archive_utildep_util)logc @ s" e Zd ZdZg Zdd Zdd Zdd Zdd Zd
d Z dCddZ
dd Z dDddZ dd Z
dEddZdFddZdd ZdGd d Zd d Zd!d" Zd#d$ Zd%d& ZdHd'd(ZdId*d+Zd,d- Zd.d/ Zd0d1 ZdJd2d3ZdKd5d6Z dLd7d8Z dMd9d:Z dNd;d<Z dOd=d>Z dPd?d@Z!dQdAdBZ"d S )RCommanda} Abstract base class for defining command classes, the "worker bees"
of the Distutils. A useful analogy for command classes is to think of
them as subroutines with local variables called "options". The options
are "declared" in 'initialize_options()' and "defined" (given their
final values, aka "finalized") in 'finalize_options()', both of which
must be defined by every command class. The distinction between the
two is necessary because option values might come from the outside
world (command line, config file, ...), and any options dependent on
other options must be computed *after* these outside influences have
been processed -- hence 'finalize_options()'. The "body" of the
subroutine, where it does all its work based on the values of its
options, is the 'run()' method, which must also be implemented by every
command class.
c C sb ddl m} t||s td| jtkr0td|| _| j d| _ |j
| _
d| _ d| _ d| _
dS )zCreate and initialize a new Command object. Most importantly,
invokes the 'initialize_options()' method, which is the real
initializer and depends on the actual command being
instantiated.
r ) Distributionz$dist must be a Distribution instancez Command is an abstract classN)Zdistutils.distr
isinstance TypeError __class__r RuntimeError distributioninitialize_optionsZ_dry_runverboseforcehelp finalized)selfZdistr
r %/usr/lib64/python3.6/distutils/cmd.py__init__/ s
zCommand.__init__c C s< |dkr0t | d| }|d kr*t | j|S |S nt|d S )Ndry_run_)getattrr AttributeError)r attrZmyvalr r r __getattr___ s zCommand.__getattr__c C s | j s| j d| _ d S )N )r finalize_options)r r r r ensure_finalizedi s zCommand.ensure_finalizedc C s t d| j dS )a Set default values for all the options that this command
supports. Note that these defaults may be overridden by other
commands, by the setup script, by config files, or by the
command-line. Thus, this is not the place to code dependencies
between options; generally, 'initialize_options()' implementations
are just a bunch of "self.foo = None" assignments.
This method must be implemented by all command classes.
z,abstract method -- subclass %s must overrideN)r r
)r r r r r { s
zCommand.initialize_optionsc C s t d| j dS )a Set final values for all the options that this command supports.
This is always called as late as possible, ie. after any option
assignments from the command-line or from other commands have been
done. Thus, this is the place to code option dependencies: if
'foo' depends on 'bar', then it is safe to set 'foo' from 'bar' as
long as 'foo' still has the same value it was assigned in
'initialize_options()'.
This method must be implemented by all command classes.
z,abstract method -- subclass %s must overrideN)r r
)r r r r r s zCommand.finalize_optionsN c C s ddl m} |d kr d| j }| j|| tjd |d }x\| jD ]R\}}}|j|}|d dkrp|d d
}t| |}| j|d||f tjd qDW d S ) Nr )
longopt_xlatezcommand options for '%s':)levelz r =z%s = %sr& ) Zdistutils.fancy_getoptr# get_command_nameannouncer INFO user_options translater )r headerindentr# optionr valuer r r dump_options s
zCommand.dump_optionsc C s t d| j dS )a A command's raison d'etre: carry out the action it exists to
perform, controlled by the options initialized in
'initialize_options()', customized by other commands, the setup
script, the command-line, and config files, and finalized in
'finalize_options()'. All terminal output and filesystem
interaction should be done by 'run()'.
This method must be implemented by all command classes.
z,abstract method -- subclass %s must overrideN)r r
)r r r r run s
z Command.runr c C s t j || dS )zmIf the current verbosity level is of greater than or equal to
'level' print 'msg' to stdout.
N)r )r msgr$ r r r r( s zCommand.announcec C s& ddl m} |r"t| tjj dS )z~Print 'msg' to stdout if the global DEBUG (taken from the
DISTUTILS_DEBUG environment variable) flag is true.
r )DEBUGN)Zdistutils.debugr3 printsysstdoutflush)r r2 r3 r r r debug_print s zCommand.debug_printc C sB t | |}|d kr"t| || |S t|ts>td|||f |S )Nz '%s' must be a %s (got `%s`))r setattrr strr )r r. whatdefaultvalr r r _ensure_stringlike s
zCommand._ensure_stringlikec C s | j |d| dS )zWEnsure that 'option' is a string; if not defined, set it to
'default'.
stringN)r> )r r. r< r r r
ensure_string s zCommand.ensure_stringc C sp t | |}|dkrdS t|tr6t| |tjd| n6t|trTtdd |D }nd}|sltd||f dS )zEnsure that 'option' is a list of strings. If 'option' is
currently a string, we split it either on /,\s*/ or /\s+/, so
"foo bar baz", "foo,bar,baz", and "foo, bar baz" all become
["foo", "bar", "baz"].
Nz,\s*|\s+c s s | ]}t |tV qd S )N)r r: ).0vr r r s z-Command.ensure_string_list..Fz''%s' must be a list of strings (got %r)) r r r: r9 resplitlistallr )r r. r= okr r r ensure_string_list s
zCommand.ensure_string_listc C s8 | j |||}|d k r4|| r4td| ||f d S )Nzerror in '%s' option: )r> r )r r. Ztesterr; Z error_fmtr< r= r r r _ensure_tested_string s z Command._ensure_tested_stringc C s | j |tjjdd dS )z5Ensure that 'option' is the name of an existing file.filenamez$'%s' does not exist or is not a fileN)rJ ospathisfile)r r. r r r ensure_filename s zCommand.ensure_filenamec C s | j |tjjdd d S )Nzdirectory namez)'%s' does not exist or is not a directory)rJ rL rM isdir)r r. r r r ensure_dirname s zCommand.ensure_dirnamec C s t | dr| jS | jjS d S )N command_name)hasattrrR r
__name__)r r r r r' s
zCommand.get_command_namec G sJ | j j|}|j x0|D ](\}}t| |dkrt| |t|| qW dS )a> Set the values of any "undefined" options from corresponding
option values in some other command object. "Undefined" here means
"is None", which is the convention used to indicate that an option
has not been changed between 'initialize_options()' and
'finalize_options()'. Usually called from 'finalize_options()' for
options that depend on some other command rather than another
option of the same command. 'src_cmd' is the other command from
which option values will be taken (a command object will be created
for it if necessary); the remaining arguments are
'(src_option,dst_option)' tuples which mean "take the value of
'src_option' in the 'src_cmd' command object, and copy it to
'dst_option' in the current command object".
N)r get_command_objr! r r9 )r Zsrc_cmdZ option_pairsZ src_cmd_objZ
src_optionZ
dst_optionr r r set_undefined_options s
z Command.set_undefined_optionsc C s | j j||}|j |S )zWrapper around Distribution's 'get_command_obj()' method: find
(create if necessary and 'create' is true) the command object for
'command', call its 'ensure_finalized()' method, and return the
finalized command object.
)r rU r! )r commandZcreateZcmd_objr r r get_finalized_command$ s z Command.get_finalized_commandr c C s | j j||S )N)r reinitialize_command)r rW Zreinit_subcommandsr r r rY 0 s z Command.reinitialize_commandc C s | j j| dS )zRun some other command: uses the 'run_command()' method of
Distribution, which creates and finalizes the command object if
necessary and then invokes its 'run()' method.
N)r run_command)r rW r r r rZ 4 s zCommand.run_commandc C s6 g }x,| j D ]"\}}|dks$|| r |j| q W |S )ak Determine the sub-commands that are relevant in the current
distribution (ie., that need to be run). This is based on the
'sub_commands' class attribute: each tuple in that list may include
a method that we call to determine if the subcommand needs to be
run for the current distribution. Return a list of command names.
N) sub_commandsappend)r ZcommandsZcmd_namemethodr r r get_sub_commands; s
zCommand.get_sub_commandsc C s t jd| j | d S )Nzwarning: %s: %s
)r warnr' )r r2 r r r r_ K s z Command.warnc C s t j|||| jd d S )N)r )r executer )r funcargsr2 r$ r r r r` N s zCommand.execute c C s t j||| jd d S )N)r )r mkpathr )r namemoder r r rd Q s zCommand.mkpathc C s t j||||| j || jdS )zCopy a file respecting verbose, dry-run and force flags. (The
former two default to whatever is in the Distribution object, and
the latter defaults to false for commands that don't define it.))r )r copy_filer r )r infileoutfile
preserve_modepreserve_timeslinkr$ r r r rg T s
zCommand.copy_filec C s t j|||||| j | jdS )z\Copy an entire directory tree respecting verbose, dry-run,
and force flags.
)r )r copy_treer r )r rh ri rj rk Zpreserve_symlinksr$ r r r rm ] s
zCommand.copy_treec C s t j||| jdS )z$Move a file respecting dry-run flag.)r )r move_filer )r srcdstr$ r r r rn f s zCommand.move_filec C s ddl m} |||| jd dS )z2Spawn an external command respecting dry-run flag.r )spawn)r N)Zdistutils.spawnrq r )r cmdZ search_pathr$ rq r r r rq j s z
Command.spawnc C s t j||||| j||dS )N)r ownergroup)r make_archiver )r Z base_nameformatZroot_dirZbase_dirrs rt r r r ru o s zCommand.make_archivec C s |dkrd| }t |tr"|f}nt |ttfs8td|dkrRd|dj|f }| jsdtj||rv| j |||| n
t
j | dS )a Special case of 'execute()' for operations that process one or
more input files and generate one output file. Works just like
'execute()', except the operation is skipped and a different
message printed if 'outfile' already exists and is newer than all
files listed in 'infiles'. If the command defined 'self.force',
and it is true, then the command is unconditionally run -- does no
timestamp checks.
Nz skipping %s (inputs unchanged)z9'infiles' must be a string, or a list or tuple of stringszgenerating %s from %sz, ) r r: rF tupler joinr r Z newer_groupr` r debug)r Zinfilesri ra rb Zexec_msgZskip_msgr$ r r r make_fileu s
zCommand.make_file)Nr" )r )N)N)N)r )r )Nr )rc )r r Nr )r r r r )r )r r )NNNN)NNr )#rT
__module__ __qualname____doc__r[ r r r! r r r0 r1 r( r8 r> r@ rI rJ rO rQ r' rV rX rY rZ r^ r_ r` rd rg rm rn rq ru rz r r r r r sF 0
r c @ s6 e Zd ZdZdgZdd Zdd Zd d
Zd d Zd
S ) install_miscz{Common base class for installing some files in a subdirectory.
Currently used by install_data and install_scripts.
install-dir=d!directory to install the files toc C s d | _ g | _d S )N) install_diroutfiles)r r r r r s z install_misc.initialize_optionsc C s | j d|df d S )NZinstallr )rV )r dirnamer r r _install_dir_from s z install_misc._install_dir_fromc C sR g | _ |sd S | j| j x2|D ]*}| j|| j | j jtjj| j| q W d S )N)r rd r rg r\ rL rM rx )r Zfilelistfr r r _copy_files s
zinstall_misc._copy_filesc C s | j S )N)r )r r r r get_outputs s zinstall_misc.get_outputsN)r r r ) rT r{ r| r} r* r r r r r r r r r~ s r~ )r} r5 rL rD Zdistutils.errorsr Z distutilsr r r r r r r r~ r r r r s PK ! Fk __pycache__/spawn.cpython-36.pycnu [ 3
\ @ s d Z ddlZddlZddlmZmZ ddlmZ ddlm Z dddZ
d d
Z dd d Z ej
d
krvddlmZ dadadddZdddZdS )zdistutils.spawn
Provides the 'spawn()' function, a front-end to various platform-
specific functions for launching another program in a sub-process.
Also provides the 'find_executable()' to search the path for a given
executable name.
N)DistutilsPlatformErrorDistutilsExecError)DEBUG)log c C sN t | } tjdkr"t| ||d n(tjdkre s z _spawn_posix...c S s g | ] }t |qS r )r( )r) r* r r r r+ k s zF$MACOSX_DEPLOYMENT_TARGET mismatch: now "%s" but "%s" during configure)r& zunable to execute %r: %s
r z(unable to execute %r for unknown reasonszcommand %r failed: %sz"command %r terminated by signal %dz%command %r failed with exit status %dz1unknown error executing %r: termination status %dr )"r r r r execvpexecvsysplatform _cfg_targetr% get_config_varsplit_cfg_target_splitenvirongetr dictexecvpeexecveforkr! r stderrwritestrerror_exitwaitpidr r WIFSIGNALEDWTERMSIG WIFEXITED WEXITSTATUS
WIFSTOPPED)r r r r r" Zexec_fnenvZ
cur_targetZmy_msgpideZstatusr# Z exit_statusr r r r
X s
&
r
c C s |dkrt jjdt j}|jt j}t jj| \}}tj dkrN|dkrN| d } t jj
| sx*|D ]"}t jj || }t jj
|r`|S q`W dS | S dS )zTries to find 'executable' in the directories listed in 'path'.
A string listing directories separated by 'os.pathsep'; defaults to
os.environ['PATH']. Returns the complete filename or None if not found.
NPATHZwin32z.exe) r r5 r6 defpathr3 pathseppathsplitextr/ r0 isfiler )r" rK pathsbaseZextpfr r r r s
r )r r r )r r r )r r r )N)__doc__r/ r Zdistutils.errorsr r Zdistutils.debugr Z distutilsr r r r r0 r% r1 r4 r
r r r r r s
QPK ! $D $D ( __pycache__/msvc9compiler.cpython-36.pycnu [ 3
\w @ sT d Z ddlZddlZddlZddlZddlmZmZmZm Z m
Z
ddl m Z m
Z
mZ ddlmZ ddlmZ ddlZejZejZejZejZej ej ej ej fZ ej!dkoej"d&kZ#e#rd
Z$d Z%d Z&n d
Z$dZ%dZ&ddddZ'G dd dZ(G dd dZ)dd Z*dd Z+d d Z,d d Z-d'd d!Z.e* Z/e/d"k r@ed#e/ G d$d% d%e Z0dS )(a distutils.msvc9compiler
Contains MSVCCompiler, an implementation of the abstract CCompiler class
for the Microsoft Visual Studio 2008.
The module is compatible with VS 2005 and VS 2008. You can find legacy support
for older versions of VS in distutils.msvccompiler.
N)DistutilsExecErrorDistutilsPlatformError CompileErrorLibError LinkError) CCompilergen_preprocess_optionsgen_lib_options)log) get_platformwin32 z1Software\Wow6432Node\Microsoft\VisualStudio\%0.1fz5Software\Wow6432Node\Microsoft\Microsoft SDKs\Windowsz,Software\Wow6432Node\Microsoft\.NETFrameworkz%Software\Microsoft\VisualStudio\%0.1fz)Software\Microsoft\Microsoft SDKs\Windowsz Software\Microsoft\.NETFrameworkx86amd64Zia64)r z win-amd64zwin-ia64c @ sP e Zd ZdZdd ZeeZdd ZeeZdd ZeeZdd Ze eZd
S ) Regz2Helper class to read values from the registry
c C s: x,t D ]$}| j||}|r||kr|| S qW t|d S )N)HKEYS read_valuesKeyError)clspathkeybased r //usr/lib64/python3.6/distutils/msvc9compiler.py get_valueA s
z
Reg.get_valuec C sn yt ||}W n tk
r" dS X g }d}x z$(FrameworkVersion))
r@ r; NET_BASEr r WINSDK_BASEr r r r r r r9 )r= r> pr hr r r r r r< s.
zMacroExpander.load_macrosc C s( x"| j j D ]\}}|j||}q W |S )N)r9 itemsreplace)r= r1 r% vr r r sub s zMacroExpander.subN)r2 r3 r4 r? r@ r< rI r r r r r8 { s r8 c C s d} t jj| }|d kr dS |t| }t j|d jdd\}}t|dd d }|dkrf|d7 }t|dd d }|dkrd
}|dkr|| S dS )
zReturn the version of MSVC that was used to build Python.
For Python 2.3 and up, the version number is included in
sys.version. For earlier versions, assume the compiler is MSVC 6.
zMSC v.r N r
g $@r )sysr> findlensplitint)prefixr$ r1 restZ majorVersionZ minorVersionr r r get_build_version s rW c C s4 g }x*| D ]"}t jj|}||kr
|j| q
W |S )znReturn a list of normalized paths with duplicates removed.
The current order of paths is maintained.
)osr normpathr! )pathsZ
reduced_pathsrD Znpr r r normalize_and_reduce_paths s
r[ c C s@ | j tj}g }x |D ]}||kr|j| qW tjj|}|S )z8Remove duplicate values of an environment variable.
)rS rX pathsepr! join)ZvariableZoldListZnewListr$ Z newVariabler r r removeDuplicates s
r^ c
C s t | }ytjd| d}W n" tk
r> tjd d}Y nX | sTtjj| rd| }tj j
|d}|rtjj|rtjj |tj tj d}tjj
|}tjj|stjd| dS ntjd| |stjd dS tjj |d
}tjj|r|S tjd dS ) zFind the vcvarsall.bat file
At first it tries to find the productdir of VS 2008 in the registry. If
that fails it falls back to the VS90COMNTOOLS env var.
z %s\Setup\VCrA z%Unable to find productdir in registryNzVS%0.f0COMNTOOLSZVCz%s is not a valid directoryz Env var %s is not set or invalidzNo productdir foundz
vcvarsall.batz Unable to find vcvarsall.bat)r: r r r r
debugrX r isdirenvirongetr] pardirabspathisfile)r> r; rA ZtoolskeyZtoolsdir vcvarsallr r r find_vcvarsall s2
rg c C s8 t | }td}i }|dkr$tdtjd|| tjd||f tjtjd }z|j \}}|j d
krvt|j
d |j
d }xr|j d D ]d}t j
|}d
|krq|j }|j d
d\} }
| j } | |kr|
jtjr|
dd }
t|
|| < qW W d|jj |jj X t|t|kr4ttt|j |S )zDLaunch vcvarsall.bat and read the settings from its environment
includeliblibpathr Nz Unable to find vcvarsall.batz'Calling 'vcvarsall.bat %s' (version=%s)z
"%s" %s & set)stdoutstderrr r.
=r )rh ri rj r rN ) rg setr r
r_
subprocessPopenPIPEZ communicatewaitr- rS r r) stripr( endswithrX r\ r^ rk closerl rR
ValueErrorstrlistkeys) r> Zarchrf Z interestingresultpopenrk rl liner r+ r r r query_vcvarsall s<
r~ g @z(VC %0.1f is not supported by this modulec
@ s e Zd ZdZdZi ZdgZdddgZdgZdgZ ee e e Z
d Z d
Z d Z
d Zd
ZZdZd.ddZd/ddZd0ddZd1ddZd2ddZd3d d Zd d Zd d! Zd"d# Zd$d% Zd&d' Z d(d) Z d4d*d+Z d,d- Z dS )5 MSVCCompilerzwConcrete class that implements an interface to Microsoft Visual C++,
as defined by the CCompiler abstract class.Zmsvcz.cz.ccz.cppz.cxxz.rcz.mcz.resz.objz.libz.dllz%s%sz.exer c C s8 t j| ||| t| _d| _g | _d | _d | _d| _d S )Nz Software\Microsoft\VisualStudioF) r r? VERSION_MSVCCompiler__versionZ_MSVCCompiler__root_MSVCCompiler__paths plat_name_MSVCCompiler__arch initialized)r= verboseZdry_runZforcer r r r? J s zMSVCCompiler.__init__Nc C s0 | j std|d kr t }d%}||kr8td|f dtjkrvdtjkrv| jdrvd| _d | _d
| _ d | _
d | _ n|t ks|dkrt | }nt t d
t | }t
t|}|d jtj| _|d tjd< |d tjd< t| jdk rtd| j | jd| _| jd | _| jd
| _ | jd | _
| jd | _ y,x&tjd jdD ]}| jj| qNW W n tk
r| Y nX t| j| _dj| jtjd< d | _| jdkrdddddg| _ddddd d g| _n&ddddd dg| _ddddd d d g| _d dd g| _ | j d!kr d dd"d#g| _ dg| _ d$| _ d S )&Nzdon't init multiple timesr win-amd64win-ia64z --plat-name must be one of %sZDISTUTILS_USE_SDKZMSSdkzcl.exezlink.exezlib.exezrc.exezmc.exe_r ri rh r zxPython was built with %s, and extensions need to be built with the same version of the compiler, but it isn't installed.;r z/nologoz/Oxz/MDz/W3z/DNDEBUGz/Odz/MDdz/Z7z/D_DEBUGz/GS-z/DLLz/INCREMENTAL:NO z/INCREMENTAL:noz/DEBUGT)r r r ) r AssertionErrorr r rX ra find_execclinkerri rcmcPLAT_TO_VCVARSr~ r rS r\ r rR Z_MSVCCompiler__productr! r r[ r] Zpreprocess_optionsr compile_optionscompile_options_debugldflags_sharedr ldflags_shared_debugZldflags_static)r= r Zok_platsZ plat_specZvc_envrD r r r
initializeU sf
zMSVCCompiler.initialize c C s |d kr d}g }x|D ]}t jj|\}}t jj|d }|t jj|d }|| jkrdtd| |rtt jj|}|| jkr|j t jj
||| j q|| j kr|j t jj
||| j q|j t jj
||| j
qW |S )Nr r z Don't know how to compile %s)rX r splitext
splitdriveisabssrc_extensionsr basename_rc_extensionsr! r]
res_extension_mc_extensions
obj_extension)r= Zsource_filenamesZ strip_dir
output_dirZ obj_namesZsrc_namer extr r r object_filenames s(
z MSVCCompiler.object_filenamesc C st | j s| j | j||||||} | \}}
}} } |p6g }
|
jd |rT|
j| j n |
j| j x |
D ]}y| | \}}W n tk
r whY nX |rtj j
|}|| j krd| }nT|| j krd| }n>|| j
kr>|}d| }y"| j| jg| |g |g W qh tk
r8 } zt|W Y d d }~X qhX qhn|| jkr tj j|}tj j|}yl| j| jgd|d|g |g tj jtj j|\}}tj j||d }| j| jgd| g |g W qh tk
r } zt|W Y d d }~X qhX qhntd||f d | }y&| j| jg|
| ||g | W qh tk
rj } zt|W Y d d }~X qhX qhW |
S )
Nz/cz/Tcz/Tpz/foz-hz-rz.rcz"Don't know how to compile %s to %sz/Fo)r r Z_setup_compiler! extendr r r rX r rd
_c_extensions_cpp_extensionsr spawnr r r r dirnamer r r r] r )r= Zsourcesr r9 Z include_dirsr_
extra_preargsextra_postargsZdependsZ compile_infoobjectsZpp_optsZbuildZ compile_optsobjsrcr Z input_optZ
output_optmsgZh_dirZrc_dirr r Zrc_filer r r compile sj
zMSVCCompiler.compilec C s | j s| j | j||\}}| j||d}| j||r|d| g }|rJy| j| jg| W q tk
r } zt|W Y d d }~X qX n t j
d| d S )N)r z/OUT:zskipping %s (up-to-date)) r r _fix_object_argslibrary_filename
_need_linkr ri r r r
r_ ) r= r Zoutput_libnamer r_ target_langoutput_filenameZlib_argsr r r r create_static_lib s z MSVCCompiler.create_static_libc C sX | j s| j | j||\}}| j|||}|\}}}|rL| jdt| t| |||}|d k rptjj ||}| j
||rH|t j kr| r| j
dd }q| jdd }n| r| j
}n| j}g }x |pg D ]}|jd| qW || | | d| g }tjj|d } |d k rPtjjtjj|\}}tjj | | j|}|jd| | j|| | |
rp|
|d d< | r|j| | jtjj| y| j| jg| W n, tk
r } zt|W Y d d }~X nX | j||}|d k rT|\}}d||f }y| jdd d
||g W n, tk
rD } zt|W Y d d }~X nX n t j d | d S ) Nz5I don't know what to do with 'runtime_library_dirs': r z/EXPORT:z/OUT:r z/IMPLIB:z-outputresource:%s;%szmt.exez-nologoz -manifestzskipping %s (up-to-date)) r r r Z
_fix_lib_argswarnrx r rX r r] r r
EXECUTABLEr r r! r r r r manifest_setup_ldargsr Zmkpathr r r r manifest_get_embed_infor
r_ ) r= target_descr r r Z librariesZ library_dirsZruntime_library_dirsZexport_symbolsr_ r r
build_tempr Z
fixed_argsZlib_optsZldflagsZ export_optsZsymld_argsZdll_nameZdll_extZ implib_filer ZmfinfoZ
mffilenamemfidZout_argr r r link8 sl
zMSVCCompiler.linkc C s, t jj|t jj|d }|jd| d S )Nz .manifestz/MANIFESTFILE:)rX r r] r r! )r= r r r
temp_manifestr r r r s z"MSVCCompiler.manifest_setup_ldargsc C s` x,|D ] }|j dr|jddd }P qW d S |tjkr>d}nd}| j|}|d krXd S ||fS )Nz/MANIFESTFILE::r r
)
startswithrS r r _remove_visual_c_ref)r= r r argr r r r r r s
z$MSVCCompiler.manifest_get_embed_infoc C s yt |}z |j }W d |j X tjdtj}tj|d|}d}tj|d|}tjdtj}tj||d krrd S t |d}z|j| |S |j X W n t k
r Y nX d S )NzU|)r z*\s*zI|)w)
openreadrv rer DOTALLrI searchwriteOSError)r= Z
manifest_fileZ
manifest_fZ manifest_bufpatternr r r r s.
z!MSVCCompiler._remove_visual_c_refc C s d| S )Nz /LIBPATH:r )r= dirr r r library_dir_option s z MSVCCompiler.library_dir_optionc C s t dd S )Nztjd jdD ]*}tjjtjj||}tjj|rH|S qHW |S )a Return path to an MSVC executable program.
Tries to find the program in several places: first, one of the
MSVC program search paths from the registry; next, the directories
in the PATH environment variable. If any of those work, return an
absolute path that is known to exist. If none of them work, just
return the original program name, 'exe'.
ZPathr )r rX r r] rd re ra rS )r= ZexerD fnr r r r s zMSVCCompiler.find_exe)r r r )N)r r )NNNr NNN)Nr N)
NNNNNr NNNN)r ) r2 r3 r4 r5 Z
compiler_typeZ executablesr r r r r r r Zstatic_lib_extensionZshared_lib_extensionZstatic_lib_formatZshared_lib_formatZ
exe_extensionr? r r r r r r r r r r r r r r r r r r , sR
X
V
R +
r l )r )1r5 rX rp rP r Zdistutils.errorsr r r r r Zdistutils.ccompilerr r r Z distutilsr
Zdistutils.utilr winregZ OpenKeyExr ZEnumKeyr Z EnumValuer' errorr Z
HKEY_USERSHKEY_CURRENT_USERHKEY_LOCAL_MACHINEZHKEY_CLASSES_ROOTr platformmaxsizeZ NATIVE_WIN64r: rC rB r r r8 rW r[ r^ rg r~ r r r r r r sN >. #
)
PK ! y 1 __pycache__/versionpredicate.cpython-36.opt-1.pycnu [ 3
\
@ s d Z ddlZddlZddlZejdejZejdZejdZ dd Z
ej ej ej
ejejejdZG d d
d
Zdad d ZdS )
zBModule for parsing and testing package version predicate strings.
Nz'(?i)^\s*([a-z_]\w*(?:\.[a-z_]\w*)*)(.*)z^\s*\((.*)\)\s*$z%^\s*(<=|>=|<|>|!=|==)\s*([^\s,]+)\s*$c C s6 t j| }|std| |j \}}|tjj|fS )zVParse a single version comparison.
Return (comparison string, StrictVersion)
z"bad package restriction syntax: %r)re_splitComparisonmatch
ValueErrorgroups distutilsversion
StrictVersion)predrescompZverStr r 2/usr/lib64/python3.6/distutils/versionpredicate.pysplitUp s
r )z>=z!=c @ s( e Zd ZdZdd Zdd Zdd ZdS ) VersionPredicatea Parse and test package version predicates.
>>> v = VersionPredicate('pyepat.abc (>1.0, <3333.3a1, !=1555.1b3)')
The `name` attribute provides the full dotted name that is given::
>>> v.name
'pyepat.abc'
The str() of a `VersionPredicate` provides a normalized
human-readable version of the expression::
>>> print(v)
pyepat.abc (> 1.0, < 3333.3a1, != 1555.1b3)
The `satisfied_by()` method can be used to determine with a given
version number is included in the set described by the version
restrictions::
>>> v.satisfied_by('1.1')
True
>>> v.satisfied_by('1.4')
True
>>> v.satisfied_by('1.0')
False
>>> v.satisfied_by('4444.4')
False
>>> v.satisfied_by('1555.1b3')
False
`VersionPredicate` is flexible in accepting extra whitespace::
>>> v = VersionPredicate(' pat( == 0.1 ) ')
>>> v.name
'pat'
>>> v.satisfied_by('0.1')
True
>>> v.satisfied_by('0.2')
False
If any version numbers passed in do not conform to the
restrictions of `StrictVersion`, a `ValueError` is raised::
>>> v = VersionPredicate('p1.p2.p3.p4(>=1.0, <=1.3a1, !=1.2zb3)')
Traceback (most recent call last):
...
ValueError: invalid version number '1.2zb3'
It the module or package name given does not conform to what's
allowed as a legal module or package name, `ValueError` is
raised::
>>> v = VersionPredicate('foo-bar')
Traceback (most recent call last):
...
ValueError: expected parenthesized list: '-bar'
>>> v = VersionPredicate('foo bar (12.21)')
Traceback (most recent call last):
...
ValueError: expected parenthesized list: 'bar (12.21)'
c C s |j }|stdtj|}|s.td| |j \| _}|j }|rtj|}|sbtd| |j d }dd |jdD | _| jstd| ng | _d S )
z*Parse a version predicate string.
zempty package restrictionzbad package name in %rz expected parenthesized list: %rr c S s g | ] }t |qS r )r ).0ZaPredr r r
t s z-VersionPredicate.__init__..,z empty parenthesized list in %rN) stripr re_validPackager r namere_parensplitr )selfZversionPredicateStrr Zparenstrr r r
__init__` s$
zVersionPredicate.__init__c C s8 | j r.dd | j D }| jd dj| d S | jS d S )Nc S s g | ]\}}|d t | qS ) )r )r condverr r r
r } s z,VersionPredicate.__str__..z (z, ))r r join)r seqr r r
__str__{ s zVersionPredicate.__str__c C s* x$| j D ]\}}t| ||sdS qW dS )zTrue if version is compatible with all the predicates in self.
The parameter version must be acceptable to the StrictVersion
constructor. It may be either a string or StrictVersion.
FT)r compmap)r r r r r r r
satisfied_by s z VersionPredicate.satisfied_byN)__name__
__module__ __qualname____doc__r r# r% r r r r
r s ?r c C sd t dkrtjdtja | j } t j| }|s8td| |jdpDd}|rVtj j
|}|jd|fS )a9 Return the name and optional version number of a provision.
The version number, if given, will be returned as a `StrictVersion`
instance, otherwise it will be `None`.
>>> split_provision('mypkg')
('mypkg', None)
>>> split_provision(' mypkg( 1.2 ) ')
('mypkg', StrictVersion ('1.2'))
Nz=([a-zA-Z_]\w*(?:\.[a-zA-Z_]\w*)*)(?:\s*\(\s*([^)\s]+)\s*\))?$z"illegal provides specification: %r )
_provision_rxrecompileASCIIr r r groupr r r )valuemr r r r
split_provision s
r3 )r) r- Zdistutils.versionr operatorr. r/ r r r r ltleeqgtgener$ r r, r3 r r r r
s
nPK ! fY
& & * __pycache__/extension.cpython-36.opt-1.pycnu [ 3
\) @ s. d Z ddlZddlZG dd dZdd ZdS )zmdistutils.extension
Provides the Extension class, used to describe C/C++ extension
modules in setup scripts. Nc @ s" e Zd ZdZdddZdd ZdS ) Extensiona Just a collection of attributes that describes an extension
module and everything needed to build it (hopefully in a portable
way, but there are hooks that let you be as unportable as you need).
Instance attributes:
name : string
the full name of the extension, including any packages -- ie.
*not* a filename or pathname, but Python dotted name
sources : [string]
list of source filenames, relative to the distribution root
(where the setup script lives), in Unix form (slash-separated)
for portability. Source files may be C, C++, SWIG (.i),
platform-specific resource files, or whatever else is recognized
by the "build_ext" command as source for a Python extension.
include_dirs : [string]
list of directories to search for C/C++ header files (in Unix
form for portability)
define_macros : [(name : string, value : string|None)]
list of macros to define; each macro is defined using a 2-tuple,
where 'value' is either the string to define it to or None to
define it without a particular value (equivalent of "#define
FOO" in source or -DFOO on Unix C compiler command line)
undef_macros : [string]
list of macros to undefine explicitly
library_dirs : [string]
list of directories to search for C/C++ libraries at link time
libraries : [string]
list of library names (not filenames or paths) to link against
runtime_library_dirs : [string]
list of directories to search for C/C++ libraries at run time
(for shared extensions, this is when the extension is loaded)
extra_objects : [string]
list of extra files to link with (eg. object files not implied
by 'sources', static library that must be explicitly specified,
binary resource files, etc.)
extra_compile_args : [string]
any extra platform- and compiler-specific information to use
when compiling the source files in 'sources'. For platforms and
compilers where "command line" makes sense, this is typically a
list of command-line arguments, but for other platforms it could
be anything.
extra_link_args : [string]
any extra platform- and compiler-specific information to use
when linking object files together to create the extension (or
to create a new static Python interpreter). Similar
interpretation as for 'extra_compile_args'.
export_symbols : [string]
list of symbols to be exported from a shared extension. Not
used on all platforms, and not generally necessary for Python
extensions, which typically export exactly one symbol: "init" +
extension_name.
swig_opts : [string]
any extra options to pass to SWIG if a source file has the .i
extension.
depends : [string]
list of files that the extension depends on
language : string
extension language (i.e. "c", "c++", "objc"). Will be detected
from the source extensions if not provided.
optional : boolean
specifies that a build failure in the extension should not abort the
build process, but simply not install the failing extension.
Nc K s t |tstdt |to,tdd |D s6td|| _|| _|pHg | _|pRg | _|p\g | _ |pfg | _
|ppg | _ |pzg | _ | pg | _
|
pg | _| pg | _| pg | _|
pg | _|pg | _|| _|| _t|dkrdd |D }djt|}d | }tj| d S )
Nz'name' must be a stringc s s | ]}t |tV qd S )N)
isinstancestr).0v r +/usr/lib64/python3.6/distutils/extension.py j s z%Extension.__init__..z#'sources' must be a list of stringsr c S s g | ] }t |qS r )repr)r Zoptionr r r
s z&Extension.__init__..z, z Unknown Extension options: %s)r r AssertionErrorlistallnamesources include_dirs
define_macros undef_macros library_dirs librariesruntime_library_dirs
extra_objectsextra_compile_argsextra_link_argsexport_symbols swig_optsdependslanguageoptionallenjoinsortedwarningswarn)selfr r r r r r r r r r r r r r r r kwZoptionsmsgr r r __init__V s4
zExtension.__init__c C s d| j j| j j| jt| f S )Nz<%s.%s(%r) at %#x>) __class__
__module__ __qualname__r id)r$ r r r __repr__ s
zExtension.__repr__)NNNNNNNNNNNNNN)__name__r) r* __doc__r' r, r r r r r s ?
!r c C s ddl m}m}m} ddlm} ddlm} || }|| dddddd}zhg }x\|j } | dkrfP |j | rrqT| d | d$ kodkn r|j
d | qT|| |} || }
|
d } t | g } d}
x|
dd D ]}|
dk r|
j | d}
qt
jj|d }|dd
}|d
d }|d%kr8| jj | q|dkrP| jj | q|dkr|jd}|d&kr| jj |df n$| jj |d| ||d
d f q|dkr| jj | q|dkr| jj | q|dkr| jj | q|dkr| jj | q|dkr | jj | q|dkr0| j}
q|dkrB| j}
q|d krT| j}
q|d krx| jj | |s| j}
q|d'kr| jj | q|j
d#| qW |j | qTW W d|j X |S )(z3Reads a Setup file and returns Extension instances.r )parse_makefileexpand_makefile_vars _variable_rx)TextFile) split_quoted )Zstrip_commentsZ skip_blanksZ
join_linesZ lstrip_wsZ rstrip_wsN*z'%s' lines not handled yet .c.cc.cpp.cxx.c++.m.mmz-Iz-D=z-Uz-Cz-lz-Lz-Rz-rpathz-Xlinkerz
-Xcompilerz-u.a.so.sl.o.dylibzunrecognized argument '%s')r7 r8 r9 r: r; r< r= rD )r? r@ rA rB rC ) Zdistutils.sysconfigr/ r0 r1 Zdistutils.text_filer2 Zdistutils.utilr3 readlinematchr# r appendospathsplitextr r findr r r r r r r r close)filenamer/ r0 r1 r2 r3 varsfile
extensionslineZwordsmoduleZextZappend_next_wordZwordsuffixZswitchvalueZequalsr r r read_setup_file s
rU )r. rH r" r rU r r r r s zPK ! uTW$ $ % __pycache__/util.cpython-36.opt-2.pycnu [ 3
\5Q @ s d dl Z d dlZd dlZd dlZd dlZd dlmZ d dlm Z d dl
m Z d dl m
Z
d dlmZ dd Zd d
Zd d Zd ad
d Zdd Zd'ddZd a aadd Zdd Zd(ddZdd Z d)d d Z d d Z d*d!d"Z d+d#d$Z G d%d& d&Z!dS ), N)DistutilsPlatformError)newer)spawn)log)DistutilsByteCompileErrorc C s t jdkrnd} tjj| }|d(kr(tjS tjjd|}tj|t| | j }|dkr\dS |dkrhdS tjS d t jkrt jd S t jd
kst t d rtjS t j
\}}}}}|j j d d
}|j dd}|j d d}|d d dkrd||f S |d d dkrV|d dkrd}dt |d d |dd f }dd d } |d | tj
7 }n|d d d krtd||f S |d d d!krd"|||f S |d d# d$krd$}tjd%tj}
|
j|} | r| j }n>|d d# d&krdd l} dd l}
| j|
jj |||\}}}d'|||f S ))Nntz bit ( )amd64z win-amd64itaniumzwin-ia64_PYTHON_HOST_PLATFORMposixuname/ _- linuxz%s-%ssunosr 5solarisz%d.%s 32bit64bit)il z.%s irixaixz%s-%s.%s cygwinz[\d.]+darwinz%s-%s-%s)osnamesysversionfindplatformlenlowerenvironhasattrr replaceintmaxsizerecompileASCIImatchgroup _osx_supportZdistutils.sysconfigget_platform_osx sysconfigget_config_vars)prefixijlookosnamehostreleaser' machinebitnessrel_remr6 distutils rF &/usr/lib64/python3.6/distutils/util.py get_platform sX
rH c C s~ t jdkr| S | s| S | d dkr.td| | d dkrFtd| | jd}xd|krf|jd qRW |srt jS t jj| S )Nr r z path '%s' cannot be absoluter z path '%s' cannot end with '/'.r# )r$ sep
ValueErrorsplitremovecurdirpathjoin)pathnamepathsrF rF rG convert_patho s
rS c C s t jdkr