| Current File : /home/mmdealscpanel/yummmdeals.com/command.tar |
__init__.py 0000644 00000001437 15051366002 0006660 0 ustar 00 """distutils.command
Package containing implementation of all the standard Distutils
commands."""
__all__ = ['build',
'build_py',
'build_ext',
'build_clib',
'build_scripts',
'clean',
'install',
'install_lib',
'install_headers',
'install_scripts',
'install_data',
'sdist',
'register',
'bdist',
'bdist_dumb',
'bdist_rpm',
'bdist_wininst',
'check',
'upload',
# These two are reserved for future use:
#'bdist_sdux',
#'bdist_pkgtool',
# Note:
# bdist_packager is not included because it only provides
# an abstract base class
]
clean.py 0000644 00000005330 15051366002 0006177 0 ustar 00 """distutils.command.clean
Implements the Distutils 'clean' command."""
# contributed by Bastian Kleineidam <calvin@cs.uni-sb.de>, added 2000-03-18
import os
from distutils.core import Command
from distutils.dir_util import remove_tree
from distutils import log
class clean(Command):
description = "clean up temporary files from 'build' command"
user_options = [
('build-base=', 'b',
"base build directory (default: 'build.build-base')"),
('build-lib=', None,
"build directory for all modules (default: 'build.build-lib')"),
('build-temp=', 't',
"temporary build directory (default: 'build.build-temp')"),
('build-scripts=', None,
"build directory for scripts (default: 'build.build-scripts')"),
('bdist-base=', None,
"temporary directory for built distributions"),
('all', 'a',
"remove all build output, not just temporary by-products")
]
boolean_options = ['all']
def initialize_options(self):
self.build_base = None
self.build_lib = None
self.build_temp = None
self.build_scripts = None
self.bdist_base = None
self.all = None
def finalize_options(self):
self.set_undefined_options('build',
('build_base', 'build_base'),
('build_lib', 'build_lib'),
('build_scripts', 'build_scripts'),
('build_temp', 'build_temp'))
self.set_undefined_options('bdist',
('bdist_base', 'bdist_base'))
def run(self):
# remove the build/temp.<plat> directory (unless it's already
# gone)
if os.path.exists(self.build_temp):
remove_tree(self.build_temp, dry_run=self.dry_run)
else:
log.debug("'%s' does not exist -- can't clean it",
self.build_temp)
if self.all:
# remove build directories
for directory in (self.build_lib,
self.bdist_base,
self.build_scripts):
if os.path.exists(directory):
remove_tree(directory, dry_run=self.dry_run)
else:
log.warn("'%s' does not exist -- can't clean it",
directory)
# just for the heck of it, try to remove the base build directory:
# we might have emptied it right now, but if not we don't care
if not self.dry_run:
try:
os.rmdir(self.build_base)
log.info("removing '%s'", self.build_base)
except OSError:
pass
bdist.py 0000644 00000012672 15051366002 0006231 0 ustar 00 """distutils.command.bdist
Implements the Distutils 'bdist' command (create a built [binary]
distribution)."""
import os
from distutils.core import Command
from distutils.errors import *
from distutils.util import get_platform
def show_formats():
"""Print list of available formats (arguments to "--format" option).
"""
from distutils.fancy_getopt import FancyGetopt
formats = []
for format in bdist.format_commands:
formats.append(("formats=" + format, None,
bdist.format_command[format][1]))
pretty_printer = FancyGetopt(formats)
pretty_printer.print_help("List of available distribution formats:")
class bdist(Command):
description = "create a built (binary) distribution"
user_options = [('bdist-base=', 'b',
"temporary directory for creating built distributions"),
('plat-name=', 'p',
"platform name to embed in generated filenames "
"(default: %s)" % get_platform()),
('formats=', None,
"formats for distribution (comma-separated list)"),
('dist-dir=', 'd',
"directory to put final built distributions in "
"[default: dist]"),
('skip-build', None,
"skip rebuilding everything (for testing/debugging)"),
('owner=', 'u',
"Owner name used when creating a tar file"
" [default: current user]"),
('group=', 'g',
"Group name used when creating a tar file"
" [default: current group]"),
]
boolean_options = ['skip-build']
help_options = [
('help-formats', None,
"lists available distribution formats", show_formats),
]
# The following commands do not take a format option from bdist
no_format_option = ('bdist_rpm',)
# This won't do in reality: will need to distinguish RPM-ish Linux,
# Debian-ish Linux, Solaris, FreeBSD, ..., Windows, Mac OS.
default_format = {'posix': 'gztar',
'nt': 'zip'}
# Establish the preferred order (for the --help-formats option).
format_commands = ['rpm', 'gztar', 'bztar', 'xztar', 'ztar', 'tar',
'wininst', 'zip', 'msi']
# And the real information.
format_command = {'rpm': ('bdist_rpm', "RPM distribution"),
'gztar': ('bdist_dumb', "gzip'ed tar file"),
'bztar': ('bdist_dumb', "bzip2'ed tar file"),
'xztar': ('bdist_dumb', "xz'ed tar file"),
'ztar': ('bdist_dumb', "compressed tar file"),
'tar': ('bdist_dumb', "tar file"),
'wininst': ('bdist_wininst',
"Windows executable installer"),
'zip': ('bdist_dumb', "ZIP file"),
'msi': ('bdist_msi', "Microsoft Installer")
}
def initialize_options(self):
self.bdist_base = None
self.plat_name = None
self.formats = None
self.dist_dir = None
self.skip_build = 0
self.group = None
self.owner = None
def finalize_options(self):
# have to finalize 'plat_name' before 'bdist_base'
if self.plat_name is None:
if self.skip_build:
self.plat_name = get_platform()
else:
self.plat_name = self.get_finalized_command('build').plat_name
# 'bdist_base' -- parent of per-built-distribution-format
# temporary directories (eg. we'll probably have
# "build/bdist.<plat>/dumb", "build/bdist.<plat>/rpm", etc.)
if self.bdist_base is None:
build_base = self.get_finalized_command('build').build_base
self.bdist_base = os.path.join(build_base,
'bdist.' + self.plat_name)
self.ensure_string_list('formats')
if self.formats is None:
try:
self.formats = [self.default_format[os.name]]
except KeyError:
raise DistutilsPlatformError(
"don't know how to create built distributions "
"on platform %s" % os.name)
if self.dist_dir is None:
self.dist_dir = "dist"
def run(self):
# Figure out which sub-commands we need to run.
commands = []
for format in self.formats:
try:
commands.append(self.format_command[format][0])
except KeyError:
raise DistutilsOptionError("invalid format '%s'" % format)
# Reinitialize and run each command.
for i in range(len(self.formats)):
cmd_name = commands[i]
sub_cmd = self.reinitialize_command(cmd_name)
if cmd_name not in self.no_format_option:
sub_cmd.format = self.formats[i]
# passing the owner and group names for tar archiving
if cmd_name == 'bdist_dumb':
sub_cmd.owner = self.owner
sub_cmd.group = self.group
# If we're going to need to run this command again, tell it to
# keep its temporary files around so subsequent runs go faster.
if cmd_name in commands[i+1:]:
sub_cmd.keep_temp = 1
self.run_command(cmd_name)
install.py 0000644 00000065201 15051366002 0006566 0 ustar 00 """distutils.command.install
Implements the Distutils 'install' command."""
import sys
import os
from distutils import log
from distutils.core import Command
from distutils.debug import DEBUG
from distutils.sysconfig import get_config_vars
from distutils.errors import DistutilsPlatformError
from distutils.file_util import write_file
from distutils.util import convert_path, subst_vars, change_root
from distutils.util import get_platform
from distutils.errors import DistutilsOptionError
from site import USER_BASE
from site import USER_SITE
HAS_USER_SITE = True
WINDOWS_SCHEME = {
'purelib': '$base/Lib/site-packages',
'platlib': '$base/Lib/site-packages',
'headers': '$base/Include/$dist_name',
'scripts': '$base/Scripts',
'data' : '$base',
}
INSTALL_SCHEMES = {
'unix_prefix': {
'purelib': '$base/lib/python$py_version_short/site-packages',
'platlib': '$platbase/lib64/python$py_version_short/site-packages',
'headers': '$base/include/python$py_version_short$abiflags/$dist_name',
'scripts': '$base/bin',
'data' : '$base',
},
'unix_home': {
'purelib': '$base/lib/python',
'platlib': '$base/lib64/python',
'headers': '$base/include/python/$dist_name',
'scripts': '$base/bin',
'data' : '$base',
},
'nt': WINDOWS_SCHEME,
}
# user site schemes
if HAS_USER_SITE:
INSTALL_SCHEMES['nt_user'] = {
'purelib': '$usersite',
'platlib': '$usersite',
'headers': '$userbase/Python$py_version_nodot/Include/$dist_name',
'scripts': '$userbase/Python$py_version_nodot/Scripts',
'data' : '$userbase',
}
INSTALL_SCHEMES['unix_user'] = {
'purelib': '$usersite',
'platlib': '$usersite',
'headers':
'$userbase/include/python$py_version_short$abiflags/$dist_name',
'scripts': '$userbase/bin',
'data' : '$userbase',
}
# The keys to an installation scheme; if any new types of files are to be
# installed, be sure to add an entry to every installation scheme above,
# and to SCHEME_KEYS here.
SCHEME_KEYS = ('purelib', 'platlib', 'headers', 'scripts', 'data')
class install(Command):
description = "install everything from build directory"
user_options = [
# Select installation scheme and set base director(y|ies)
('prefix=', None,
"installation prefix"),
('exec-prefix=', None,
"(Unix only) prefix for platform-specific files"),
('home=', None,
"(Unix only) home directory to install under"),
# Or, just set the base director(y|ies)
('install-base=', None,
"base installation directory (instead of --prefix or --home)"),
('install-platbase=', None,
"base installation directory for platform-specific files " +
"(instead of --exec-prefix or --home)"),
('root=', None,
"install everything relative to this alternate root directory"),
# Or, explicitly set the installation scheme
('install-purelib=', None,
"installation directory for pure Python module distributions"),
('install-platlib=', None,
"installation directory for non-pure module distributions"),
('install-lib=', None,
"installation directory for all module distributions " +
"(overrides --install-purelib and --install-platlib)"),
('install-headers=', None,
"installation directory for C/C++ headers"),
('install-scripts=', None,
"installation directory for Python scripts"),
('install-data=', None,
"installation directory for data files"),
# Byte-compilation options -- see install_lib.py for details, as
# these are duplicated from there (but only install_lib does
# anything with them).
('compile', 'c', "compile .py to .pyc [default]"),
('no-compile', None, "don't compile .py files"),
('optimize=', 'O',
"also compile with optimization: -O1 for \"python -O\", "
"-O2 for \"python -OO\", and -O0 to disable [default: -O0]"),
# Miscellaneous control options
('force', 'f',
"force installation (overwrite any existing files)"),
('skip-build', None,
"skip rebuilding everything (for testing/debugging)"),
# Where to install documentation (eventually!)
#('doc-format=', None, "format of documentation to generate"),
#('install-man=', None, "directory for Unix man pages"),
#('install-html=', None, "directory for HTML documentation"),
#('install-info=', None, "directory for GNU info files"),
('record=', None,
"filename in which to record list of installed files"),
]
boolean_options = ['compile', 'force', 'skip-build']
if HAS_USER_SITE:
user_options.append(('user', None,
"install in user site-package '%s'" % USER_SITE))
boolean_options.append('user')
negative_opt = {'no-compile' : 'compile'}
def initialize_options(self):
"""Initializes options."""
# High-level options: these select both an installation base
# and scheme.
self.prefix = None
self.exec_prefix = None
self.home = None
self.user = 0
# These select only the installation base; it's up to the user to
# specify the installation scheme (currently, that means supplying
# the --install-{platlib,purelib,scripts,data} options).
self.install_base = None
self.install_platbase = None
self.root = None
# These options are the actual installation directories; if not
# supplied by the user, they are filled in using the installation
# scheme implied by prefix/exec-prefix/home and the contents of
# that installation scheme.
self.install_purelib = None # for pure module distributions
self.install_platlib = None # non-pure (dists w/ extensions)
self.install_headers = None # for C/C++ headers
self.install_lib = None # set to either purelib or platlib
self.install_scripts = None
self.install_data = None
self.install_userbase = USER_BASE
self.install_usersite = USER_SITE
self.compile = None
self.optimize = None
# Deprecated
# These two are for putting non-packagized distributions into their
# own directory and creating a .pth file if it makes sense.
# 'extra_path' comes from the setup file; 'install_path_file' can
# be turned off if it makes no sense to install a .pth file. (But
# better to install it uselessly than to guess wrong and not
# install it when it's necessary and would be used!) Currently,
# 'install_path_file' is always true unless some outsider meddles
# with it.
self.extra_path = None
self.install_path_file = 1
# 'force' forces installation, even if target files are not
# out-of-date. 'skip_build' skips running the "build" command,
# handy if you know it's not necessary. 'warn_dir' (which is *not*
# a user option, it's just there so the bdist_* commands can turn
# it off) determines whether we warn about installing to a
# directory not in sys.path.
self.force = 0
self.skip_build = 0
self.warn_dir = 1
# These are only here as a conduit from the 'build' command to the
# 'install_*' commands that do the real work. ('build_base' isn't
# actually used anywhere, but it might be useful in future.) They
# are not user options, because if the user told the install
# command where the build directory is, that wouldn't affect the
# build command.
self.build_base = None
self.build_lib = None
# Not defined yet because we don't know anything about
# documentation yet.
#self.install_man = None
#self.install_html = None
#self.install_info = None
self.record = None
# -- Option finalizing methods -------------------------------------
# (This is rather more involved than for most commands,
# because this is where the policy for installing third-
# party Python modules on various platforms given a wide
# array of user input is decided. Yes, it's quite complex!)
def finalize_options(self):
"""Finalizes options."""
# This method (and its helpers, like 'finalize_unix()',
# 'finalize_other()', and 'select_scheme()') is where the default
# installation directories for modules, extension modules, and
# anything else we care to install from a Python module
# distribution. Thus, this code makes a pretty important policy
# statement about how third-party stuff is added to a Python
# installation! Note that the actual work of installation is done
# by the relatively simple 'install_*' commands; they just take
# their orders from the installation directory options determined
# here.
# Check for errors/inconsistencies in the options; first, stuff
# that's wrong on any platform.
if ((self.prefix or self.exec_prefix or self.home) and
(self.install_base or self.install_platbase)):
raise DistutilsOptionError(
"must supply either prefix/exec-prefix/home or " +
"install-base/install-platbase -- not both")
if self.home and (self.prefix or self.exec_prefix):
raise DistutilsOptionError(
"must supply either home or prefix/exec-prefix -- not both")
if self.user and (self.prefix or self.exec_prefix or self.home or
self.install_base or self.install_platbase):
raise DistutilsOptionError("can't combine user with prefix, "
"exec_prefix/home, or install_(plat)base")
# Next, stuff that's wrong (or dubious) only on certain platforms.
if os.name != "posix":
if self.exec_prefix:
self.warn("exec-prefix option ignored on this platform")
self.exec_prefix = None
# Now the interesting logic -- so interesting that we farm it out
# to other methods. The goal of these methods is to set the final
# values for the install_{lib,scripts,data,...} options, using as
# input a heady brew of prefix, exec_prefix, home, install_base,
# install_platbase, user-supplied versions of
# install_{purelib,platlib,lib,scripts,data,...}, and the
# INSTALL_SCHEME dictionary above. Phew!
self.dump_dirs("pre-finalize_{unix,other}")
if os.name == 'posix':
self.finalize_unix()
else:
self.finalize_other()
self.dump_dirs("post-finalize_{unix,other}()")
# Expand configuration variables, tilde, etc. in self.install_base
# and self.install_platbase -- that way, we can use $base or
# $platbase in the other installation directories and not worry
# about needing recursive variable expansion (shudder).
py_version = sys.version.split()[0]
(prefix, exec_prefix) = get_config_vars('prefix', 'exec_prefix')
try:
abiflags = sys.abiflags
except AttributeError:
# sys.abiflags may not be defined on all platforms.
abiflags = ''
self.config_vars = {'dist_name': self.distribution.get_name(),
'dist_version': self.distribution.get_version(),
'dist_fullname': self.distribution.get_fullname(),
'py_version': py_version,
'py_version_short': '%d.%d' % sys.version_info[:2],
'py_version_nodot': '%d%d' % sys.version_info[:2],
'sys_prefix': prefix,
'prefix': prefix,
'sys_exec_prefix': exec_prefix,
'exec_prefix': exec_prefix,
'abiflags': abiflags,
}
if HAS_USER_SITE:
self.config_vars['userbase'] = self.install_userbase
self.config_vars['usersite'] = self.install_usersite
self.expand_basedirs()
self.dump_dirs("post-expand_basedirs()")
# Now define config vars for the base directories so we can expand
# everything else.
self.config_vars['base'] = self.install_base
self.config_vars['platbase'] = self.install_platbase
if DEBUG:
from pprint import pprint
print("config vars:")
pprint(self.config_vars)
# Expand "~" and configuration variables in the installation
# directories.
self.expand_dirs()
self.dump_dirs("post-expand_dirs()")
# Create directories in the home dir:
if self.user:
self.create_home_path()
# Pick the actual directory to install all modules to: either
# install_purelib or install_platlib, depending on whether this
# module distribution is pure or not. Of course, if the user
# already specified install_lib, use their selection.
if self.install_lib is None:
if self.distribution.ext_modules: # has extensions: non-pure
self.install_lib = self.install_platlib
else:
self.install_lib = self.install_purelib
# Convert directories from Unix /-separated syntax to the local
# convention.
self.convert_paths('lib', 'purelib', 'platlib',
'scripts', 'data', 'headers',
'userbase', 'usersite')
# Deprecated
# Well, we're not actually fully completely finalized yet: we still
# have to deal with 'extra_path', which is the hack for allowing
# non-packagized module distributions (hello, Numerical Python!) to
# get their own directories.
self.handle_extra_path()
self.install_libbase = self.install_lib # needed for .pth file
self.install_lib = os.path.join(self.install_lib, self.extra_dirs)
# If a new root directory was supplied, make all the installation
# dirs relative to it.
if self.root is not None:
self.change_roots('libbase', 'lib', 'purelib', 'platlib',
'scripts', 'data', 'headers')
self.dump_dirs("after prepending root")
# Find out the build directories, ie. where to install from.
self.set_undefined_options('build',
('build_base', 'build_base'),
('build_lib', 'build_lib'))
# Punt on doc directories for now -- after all, we're punting on
# documentation completely!
def dump_dirs(self, msg):
"""Dumps the list of user options."""
if not DEBUG:
return
from distutils.fancy_getopt import longopt_xlate
log.debug(msg + ":")
for opt in self.user_options:
opt_name = opt[0]
if opt_name[-1] == "=":
opt_name = opt_name[0:-1]
if opt_name in self.negative_opt:
opt_name = self.negative_opt[opt_name]
opt_name = opt_name.translate(longopt_xlate)
val = not getattr(self, opt_name)
else:
opt_name = opt_name.translate(longopt_xlate)
val = getattr(self, opt_name)
log.debug(" %s: %s", opt_name, val)
def finalize_unix(self):
"""Finalizes options for posix platforms."""
if self.install_base is not None or self.install_platbase is not None:
if ((self.install_lib is None and
self.install_purelib is None and
self.install_platlib is None) or
self.install_headers is None or
self.install_scripts is None or
self.install_data is None):
raise DistutilsOptionError(
"install-base or install-platbase supplied, but "
"installation scheme is incomplete")
return
if self.user:
if self.install_userbase is None:
raise DistutilsPlatformError(
"User base directory is not specified")
self.install_base = self.install_platbase = self.install_userbase
self.select_scheme("unix_user")
elif self.home is not None:
self.install_base = self.install_platbase = self.home
self.select_scheme("unix_home")
else:
if self.prefix is None:
if self.exec_prefix is not None:
raise DistutilsOptionError(
"must not supply exec-prefix without prefix")
# self.prefix is set to sys.prefix + /local/
# if neither RPM build nor virtual environment is
# detected to make pip and distutils install packages
# into the separate location.
if (not (hasattr(sys, 'real_prefix') or
sys.prefix != sys.base_prefix) and
'RPM_BUILD_ROOT' not in os.environ):
addition = "/local"
else:
addition = ""
self.prefix = os.path.normpath(sys.prefix) + addition
self.exec_prefix = os.path.normpath(sys.exec_prefix) + addition
else:
if self.exec_prefix is None:
self.exec_prefix = self.prefix
self.install_base = self.prefix
self.install_platbase = self.exec_prefix
self.select_scheme("unix_prefix")
def finalize_other(self):
"""Finalizes options for non-posix platforms"""
if self.user:
if self.install_userbase is None:
raise DistutilsPlatformError(
"User base directory is not specified")
self.install_base = self.install_platbase = self.install_userbase
self.select_scheme(os.name + "_user")
elif self.home is not None:
self.install_base = self.install_platbase = self.home
self.select_scheme("unix_home")
else:
if self.prefix is None:
self.prefix = os.path.normpath(sys.prefix)
self.install_base = self.install_platbase = self.prefix
try:
self.select_scheme(os.name)
except KeyError:
raise DistutilsPlatformError(
"I don't know how to install stuff on '%s'" % os.name)
def select_scheme(self, name):
"""Sets the install directories by applying the install schemes."""
# it's the caller's problem if they supply a bad name!
scheme = INSTALL_SCHEMES[name]
for key in SCHEME_KEYS:
attrname = 'install_' + key
if getattr(self, attrname) is None:
setattr(self, attrname, scheme[key])
def _expand_attrs(self, attrs):
for attr in attrs:
val = getattr(self, attr)
if val is not None:
if os.name == 'posix' or os.name == 'nt':
val = os.path.expanduser(val)
val = subst_vars(val, self.config_vars)
setattr(self, attr, val)
def expand_basedirs(self):
"""Calls `os.path.expanduser` on install_base, install_platbase and
root."""
self._expand_attrs(['install_base', 'install_platbase', 'root'])
def expand_dirs(self):
"""Calls `os.path.expanduser` on install dirs."""
self._expand_attrs(['install_purelib', 'install_platlib',
'install_lib', 'install_headers',
'install_scripts', 'install_data',])
def convert_paths(self, *names):
"""Call `convert_path` over `names`."""
for name in names:
attr = "install_" + name
setattr(self, attr, convert_path(getattr(self, attr)))
def handle_extra_path(self):
"""Set `path_file` and `extra_dirs` using `extra_path`."""
if self.extra_path is None:
self.extra_path = self.distribution.extra_path
if self.extra_path is not None:
log.warn(
"Distribution option extra_path is deprecated. "
"See issue27919 for details."
)
if isinstance(self.extra_path, str):
self.extra_path = self.extra_path.split(',')
if len(self.extra_path) == 1:
path_file = extra_dirs = self.extra_path[0]
elif len(self.extra_path) == 2:
path_file, extra_dirs = self.extra_path
else:
raise DistutilsOptionError(
"'extra_path' option must be a list, tuple, or "
"comma-separated string with 1 or 2 elements")
# convert to local form in case Unix notation used (as it
# should be in setup scripts)
extra_dirs = convert_path(extra_dirs)
else:
path_file = None
extra_dirs = ''
# XXX should we warn if path_file and not extra_dirs? (in which
# case the path file would be harmless but pointless)
self.path_file = path_file
self.extra_dirs = extra_dirs
def change_roots(self, *names):
"""Change the install directories pointed by name using root."""
for name in names:
attr = "install_" + name
setattr(self, attr, change_root(self.root, getattr(self, attr)))
def create_home_path(self):
"""Create directories under ~."""
if not self.user:
return
home = convert_path(os.path.expanduser("~"))
for name, path in self.config_vars.items():
if path.startswith(home) and not os.path.isdir(path):
self.debug_print("os.makedirs('%s', 0o700)" % path)
os.makedirs(path, 0o700)
# -- Command execution methods -------------------------------------
def run(self):
"""Runs the command."""
# Obviously have to build before we can install
if not self.skip_build:
self.run_command('build')
# If we built for any other platform, we can't install.
build_plat = self.distribution.get_command_obj('build').plat_name
# check warn_dir - it is a clue that the 'install' is happening
# internally, and not to sys.path, so we don't check the platform
# matches what we are running.
if self.warn_dir and build_plat != get_platform():
raise DistutilsPlatformError("Can't install when "
"cross-compiling")
# Run all sub-commands (at least those that need to be run)
for cmd_name in self.get_sub_commands():
self.run_command(cmd_name)
if self.path_file:
self.create_path_file()
# write list of installed files, if requested.
if self.record:
outputs = self.get_outputs()
if self.root: # strip any package prefix
root_len = len(self.root)
for counter in range(len(outputs)):
outputs[counter] = outputs[counter][root_len:]
self.execute(write_file,
(self.record, outputs),
"writing list of installed files to '%s'" %
self.record)
sys_path = map(os.path.normpath, sys.path)
sys_path = map(os.path.normcase, sys_path)
install_lib = os.path.normcase(os.path.normpath(self.install_lib))
if (self.warn_dir and
not (self.path_file and self.install_path_file) and
install_lib not in sys_path):
log.debug(("modules installed to '%s', which is not in "
"Python's module search path (sys.path) -- "
"you'll have to change the search path yourself"),
self.install_lib)
def create_path_file(self):
"""Creates the .pth file"""
filename = os.path.join(self.install_libbase,
self.path_file + ".pth")
if self.install_path_file:
self.execute(write_file,
(filename, [self.extra_dirs]),
"creating %s" % filename)
else:
self.warn("path file '%s' not created" % filename)
# -- Reporting methods ---------------------------------------------
def get_outputs(self):
"""Assembles the outputs of all the sub-commands."""
outputs = []
for cmd_name in self.get_sub_commands():
cmd = self.get_finalized_command(cmd_name)
# Add the contents of cmd.get_outputs(), ensuring
# that outputs doesn't contain duplicate entries
for filename in cmd.get_outputs():
if filename not in outputs:
outputs.append(filename)
if self.path_file and self.install_path_file:
outputs.append(os.path.join(self.install_libbase,
self.path_file + ".pth"))
return outputs
def get_inputs(self):
"""Returns the inputs of all the sub-commands"""
# XXX gee, this looks familiar ;-(
inputs = []
for cmd_name in self.get_sub_commands():
cmd = self.get_finalized_command(cmd_name)
inputs.extend(cmd.get_inputs())
return inputs
# -- Predicates for sub-command list -------------------------------
def has_lib(self):
"""Returns true if the current distribution has any Python
modules to install."""
return (self.distribution.has_pure_modules() or
self.distribution.has_ext_modules())
def has_headers(self):
"""Returns true if the current distribution has any headers to
install."""
return self.distribution.has_headers()
def has_scripts(self):
"""Returns true if the current distribution has any scripts to.
install."""
return self.distribution.has_scripts()
def has_data(self):
"""Returns true if the current distribution has any data to.
install."""
return self.distribution.has_data_files()
# 'sub_commands': a list of commands this command might have to run to
# get its work done. See cmd.py for more info.
sub_commands = [('install_lib', has_lib),
('install_headers', has_headers),
('install_scripts', has_scripts),
('install_data', has_data),
('install_egg_info', lambda self:True),
]
install_egg_info.py 0000644 00000005053 15051366002 0010422 0 ustar 00 """distutils.command.install_egg_info
Implements the Distutils 'install_egg_info' command, for installing
a package's PKG-INFO metadata."""
from distutils.cmd import Command
from distutils import log, dir_util
import os, sys, re
class install_egg_info(Command):
"""Install an .egg-info file for the package"""
description = "Install package's PKG-INFO metadata as an .egg-info file"
user_options = [
('install-dir=', 'd', "directory to install to"),
]
def initialize_options(self):
self.install_dir = None
def finalize_options(self):
self.set_undefined_options('install_lib',('install_dir','install_dir'))
basename = "%s-%s-py%d.%d.egg-info" % (
to_filename(safe_name(self.distribution.get_name())),
to_filename(safe_version(self.distribution.get_version())),
*sys.version_info[:2]
)
self.target = os.path.join(self.install_dir, basename)
self.outputs = [self.target]
def run(self):
target = self.target
if os.path.isdir(target) and not os.path.islink(target):
dir_util.remove_tree(target, dry_run=self.dry_run)
elif os.path.exists(target):
self.execute(os.unlink,(self.target,),"Removing "+target)
elif not os.path.isdir(self.install_dir):
self.execute(os.makedirs, (self.install_dir,),
"Creating "+self.install_dir)
log.info("Writing %s", target)
if not self.dry_run:
with open(target, 'w', encoding='UTF-8') as f:
self.distribution.metadata.write_pkg_file(f)
def get_outputs(self):
return self.outputs
# The following routines are taken from setuptools' pkg_resources module and
# can be replaced by importing them from pkg_resources once it is included
# in the stdlib.
def safe_name(name):
"""Convert an arbitrary string to a standard distribution name
Any runs of non-alphanumeric/. characters are replaced with a single '-'.
"""
return re.sub('[^A-Za-z0-9.]+', '-', name)
def safe_version(version):
"""Convert an arbitrary string to a standard version string
Spaces become dots, and all other non-alphanumeric characters become
dashes, with runs of multiple dashes condensed to a single dash.
"""
version = version.replace(' ','.')
return re.sub('[^A-Za-z0-9.]+', '-', version)
def to_filename(name):
"""Convert a project or version name to its filename-escaped form
Any '-' characters are currently replaced with '_'.
"""
return name.replace('-','_')
command_template 0000644 00000001171 15051366002 0007776 0 ustar 00 """distutils.command.x
Implements the Distutils 'x' command.
"""
# created 2000/mm/dd, John Doe
__revision__ = "$Id$"
from distutils.core import Command
class x(Command):
# Brief (40-50 characters) description of the command
description = ""
# List of option tuples: long name, short name (None if no short
# name), and help string.
user_options = [('', '',
""),
]
def initialize_options(self):
self. = None
self. = None
self. = None
def finalize_options(self):
if self.x is None:
self.x =
def run(self):
build_scripts.py 0000644 00000014130 15051366002 0007761 0 ustar 00 """distutils.command.build_scripts
Implements the Distutils 'build_scripts' command."""
import os, re
from stat import ST_MODE
from distutils import sysconfig
from distutils.core import Command
from distutils.dep_util import newer
from distutils.util import convert_path, Mixin2to3
from distutils import log
import tokenize
# check if Python is called on the first line with this expression
first_line_re = re.compile(b'^#!.*python[0-9.]*([ \t].*)?$')
class build_scripts(Command):
description = "\"build\" scripts (copy and fixup #! line)"
user_options = [
('build-dir=', 'd', "directory to \"build\" (copy) to"),
('force', 'f', "forcibly build everything (ignore file timestamps"),
('executable=', 'e', "specify final destination interpreter path"),
]
boolean_options = ['force']
def initialize_options(self):
self.build_dir = None
self.scripts = None
self.force = None
self.executable = None
self.outfiles = None
def finalize_options(self):
self.set_undefined_options('build',
('build_scripts', 'build_dir'),
('force', 'force'),
('executable', 'executable'))
self.scripts = self.distribution.scripts
def get_source_files(self):
return self.scripts
def run(self):
if not self.scripts:
return
self.copy_scripts()
def copy_scripts(self):
r"""Copy each script listed in 'self.scripts'; if it's marked as a
Python script in the Unix way (first line matches 'first_line_re',
ie. starts with "\#!" and contains "python"), then adjust the first
line to refer to the current Python interpreter as we copy.
"""
self.mkpath(self.build_dir)
outfiles = []
updated_files = []
for script in self.scripts:
adjust = False
script = convert_path(script)
outfile = os.path.join(self.build_dir, os.path.basename(script))
outfiles.append(outfile)
if not self.force and not newer(script, outfile):
log.debug("not copying %s (up-to-date)", script)
continue
# Always open the file, but ignore failures in dry-run mode --
# that way, we'll get accurate feedback if we can read the
# script.
try:
f = open(script, "rb")
except OSError:
if not self.dry_run:
raise
f = None
else:
encoding, lines = tokenize.detect_encoding(f.readline)
f.seek(0)
first_line = f.readline()
if not first_line:
self.warn("%s is an empty file (skipping)" % script)
continue
match = first_line_re.match(first_line)
if match:
adjust = True
post_interp = match.group(1) or b''
if adjust:
log.info("copying and adjusting %s -> %s", script,
self.build_dir)
updated_files.append(outfile)
if not self.dry_run:
if not sysconfig.python_build:
executable = self.executable
else:
executable = os.path.join(
sysconfig.get_config_var("BINDIR"),
"python%s%s" % (sysconfig.get_config_var("VERSION"),
sysconfig.get_config_var("EXE")))
executable = os.fsencode(executable)
shebang = b"#!" + executable + post_interp + b"\n"
# Python parser starts to read a script using UTF-8 until
# it gets a #coding:xxx cookie. The shebang has to be the
# first line of a file, the #coding:xxx cookie cannot be
# written before. So the shebang has to be decodable from
# UTF-8.
try:
shebang.decode('utf-8')
except UnicodeDecodeError:
raise ValueError(
"The shebang ({!r}) is not decodable "
"from utf-8".format(shebang))
# If the script is encoded to a custom encoding (use a
# #coding:xxx cookie), the shebang has to be decodable from
# the script encoding too.
try:
shebang.decode(encoding)
except UnicodeDecodeError:
raise ValueError(
"The shebang ({!r}) is not decodable "
"from the script encoding ({})"
.format(shebang, encoding))
with open(outfile, "wb") as outf:
outf.write(shebang)
outf.writelines(f.readlines())
if f:
f.close()
else:
if f:
f.close()
updated_files.append(outfile)
self.copy_file(script, outfile)
if os.name == 'posix':
for file in outfiles:
if self.dry_run:
log.info("changing mode of %s", file)
else:
oldmode = os.stat(file)[ST_MODE] & 0o7777
newmode = (oldmode | 0o555) & 0o7777
if newmode != oldmode:
log.info("changing mode of %s from %o to %o",
file, oldmode, newmode)
os.chmod(file, newmode)
# XXX should we modify self.outfiles?
return outfiles, updated_files
class build_scripts_2to3(build_scripts, Mixin2to3):
def copy_scripts(self):
outfiles, updated_files = build_scripts.copy_scripts(self)
if not self.dry_run:
self.run_2to3(updated_files)
return outfiles, updated_files
bdist_dumb.py 0000644 00000011461 15051366002 0007233 0 ustar 00 """distutils.command.bdist_dumb
Implements the Distutils 'bdist_dumb' command (create a "dumb" built
distribution -- i.e., just an archive to be unpacked under $prefix or
$exec_prefix)."""
import os
from distutils.core import Command
from distutils.util import get_platform
from distutils.dir_util import remove_tree, ensure_relative
from distutils.errors import *
from distutils.sysconfig import get_python_version
from distutils import log
class bdist_dumb(Command):
description = "create a \"dumb\" built distribution"
user_options = [('bdist-dir=', 'd',
"temporary directory for creating the distribution"),
('plat-name=', 'p',
"platform name to embed in generated filenames "
"(default: %s)" % get_platform()),
('format=', 'f',
"archive format to create (tar, gztar, bztar, xztar, "
"ztar, zip)"),
('keep-temp', 'k',
"keep the pseudo-installation tree around after " +
"creating the distribution archive"),
('dist-dir=', 'd',
"directory to put final built distributions in"),
('skip-build', None,
"skip rebuilding everything (for testing/debugging)"),
('relative', None,
"build the archive using relative paths "
"(default: false)"),
('owner=', 'u',
"Owner name used when creating a tar file"
" [default: current user]"),
('group=', 'g',
"Group name used when creating a tar file"
" [default: current group]"),
]
boolean_options = ['keep-temp', 'skip-build', 'relative']
default_format = { 'posix': 'gztar',
'nt': 'zip' }
def initialize_options(self):
self.bdist_dir = None
self.plat_name = None
self.format = None
self.keep_temp = 0
self.dist_dir = None
self.skip_build = None
self.relative = 0
self.owner = None
self.group = None
def finalize_options(self):
if self.bdist_dir is None:
bdist_base = self.get_finalized_command('bdist').bdist_base
self.bdist_dir = os.path.join(bdist_base, 'dumb')
if self.format is None:
try:
self.format = self.default_format[os.name]
except KeyError:
raise DistutilsPlatformError(
"don't know how to create dumb built distributions "
"on platform %s" % os.name)
self.set_undefined_options('bdist',
('dist_dir', 'dist_dir'),
('plat_name', 'plat_name'),
('skip_build', 'skip_build'))
def run(self):
if not self.skip_build:
self.run_command('build')
install = self.reinitialize_command('install', reinit_subcommands=1)
install.root = self.bdist_dir
install.skip_build = self.skip_build
install.warn_dir = 0
log.info("installing to %s", self.bdist_dir)
self.run_command('install')
# And make an archive relative to the root of the
# pseudo-installation tree.
archive_basename = "%s.%s" % (self.distribution.get_fullname(),
self.plat_name)
pseudoinstall_root = os.path.join(self.dist_dir, archive_basename)
if not self.relative:
archive_root = self.bdist_dir
else:
if (self.distribution.has_ext_modules() and
(install.install_base != install.install_platbase)):
raise DistutilsPlatformError(
"can't make a dumb built distribution where "
"base and platbase are different (%s, %s)"
% (repr(install.install_base),
repr(install.install_platbase)))
else:
archive_root = os.path.join(self.bdist_dir,
ensure_relative(install.install_base))
# Make the archive
filename = self.make_archive(pseudoinstall_root,
self.format, root_dir=archive_root,
owner=self.owner, group=self.group)
if self.distribution.has_ext_modules():
pyversion = get_python_version()
else:
pyversion = 'any'
self.distribution.dist_files.append(('bdist_dumb', pyversion,
filename))
if not self.keep_temp:
remove_tree(self.bdist_dir, dry_run=self.dry_run)
bdist_msi.py 0000644 00000104737 15051366002 0007105 0 ustar 00 # Copyright (C) 2005, 2006 Martin von Löwis
# Licensed to PSF under a Contributor Agreement.
# The bdist_wininst command proper
# based on bdist_wininst
"""
Implements the bdist_msi command.
"""
import sys, os
from distutils.core import Command
from distutils.dir_util import remove_tree
from distutils.sysconfig import get_python_version
from distutils.version import StrictVersion
from distutils.errors import DistutilsOptionError
from distutils.util import get_platform
from distutils import log
import msilib
from msilib import schema, sequence, text
from msilib import Directory, Feature, Dialog, add_data
class PyDialog(Dialog):
"""Dialog class with a fixed layout: controls at the top, then a ruler,
then a list of buttons: back, next, cancel. Optionally a bitmap at the
left."""
def __init__(self, *args, **kw):
"""Dialog(database, name, x, y, w, h, attributes, title, first,
default, cancel, bitmap=true)"""
Dialog.__init__(self, *args)
ruler = self.h - 36
bmwidth = 152*ruler/328
#if kw.get("bitmap", True):
# self.bitmap("Bitmap", 0, 0, bmwidth, ruler, "PythonWin")
self.line("BottomLine", 0, ruler, self.w, 0)
def title(self, title):
"Set the title text of the dialog at the top."
# name, x, y, w, h, flags=Visible|Enabled|Transparent|NoPrefix,
# text, in VerdanaBold10
self.text("Title", 15, 10, 320, 60, 0x30003,
r"{\VerdanaBold10}%s" % title)
def back(self, title, next, name = "Back", active = 1):
"""Add a back button with a given title, the tab-next button,
its name in the Control table, possibly initially disabled.
Return the button, so that events can be associated"""
if active:
flags = 3 # Visible|Enabled
else:
flags = 1 # Visible
return self.pushbutton(name, 180, self.h-27 , 56, 17, flags, title, next)
def cancel(self, title, next, name = "Cancel", active = 1):
"""Add a cancel button with a given title, the tab-next button,
its name in the Control table, possibly initially disabled.
Return the button, so that events can be associated"""
if active:
flags = 3 # Visible|Enabled
else:
flags = 1 # Visible
return self.pushbutton(name, 304, self.h-27, 56, 17, flags, title, next)
def next(self, title, next, name = "Next", active = 1):
"""Add a Next button with a given title, the tab-next button,
its name in the Control table, possibly initially disabled.
Return the button, so that events can be associated"""
if active:
flags = 3 # Visible|Enabled
else:
flags = 1 # Visible
return self.pushbutton(name, 236, self.h-27, 56, 17, flags, title, next)
def xbutton(self, name, title, next, xpos):
"""Add a button with a given title, the tab-next button,
its name in the Control table, giving its x position; the
y-position is aligned with the other buttons.
Return the button, so that events can be associated"""
return self.pushbutton(name, int(self.w*xpos - 28), self.h-27, 56, 17, 3, title, next)
class bdist_msi(Command):
description = "create a Microsoft Installer (.msi) binary distribution"
user_options = [('bdist-dir=', None,
"temporary directory for creating the distribution"),
('plat-name=', 'p',
"platform name to embed in generated filenames "
"(default: %s)" % get_platform()),
('keep-temp', 'k',
"keep the pseudo-installation tree around after " +
"creating the distribution archive"),
('target-version=', None,
"require a specific python version" +
" on the target system"),
('no-target-compile', 'c',
"do not compile .py to .pyc on the target system"),
('no-target-optimize', 'o',
"do not compile .py to .pyo (optimized) "
"on the target system"),
('dist-dir=', 'd',
"directory to put final built distributions in"),
('skip-build', None,
"skip rebuilding everything (for testing/debugging)"),
('install-script=', None,
"basename of installation script to be run after "
"installation or before deinstallation"),
('pre-install-script=', None,
"Fully qualified filename of a script to be run before "
"any files are installed. This script need not be in the "
"distribution"),
]
boolean_options = ['keep-temp', 'no-target-compile', 'no-target-optimize',
'skip-build']
all_versions = ['2.0', '2.1', '2.2', '2.3', '2.4',
'2.5', '2.6', '2.7', '2.8', '2.9',
'3.0', '3.1', '3.2', '3.3', '3.4',
'3.5', '3.6', '3.7', '3.8', '3.9']
other_version = 'X'
def initialize_options(self):
self.bdist_dir = None
self.plat_name = None
self.keep_temp = 0
self.no_target_compile = 0
self.no_target_optimize = 0
self.target_version = None
self.dist_dir = None
self.skip_build = None
self.install_script = None
self.pre_install_script = None
self.versions = None
def finalize_options(self):
self.set_undefined_options('bdist', ('skip_build', 'skip_build'))
if self.bdist_dir is None:
bdist_base = self.get_finalized_command('bdist').bdist_base
self.bdist_dir = os.path.join(bdist_base, 'msi')
short_version = get_python_version()
if (not self.target_version) and self.distribution.has_ext_modules():
self.target_version = short_version
if self.target_version:
self.versions = [self.target_version]
if not self.skip_build and self.distribution.has_ext_modules()\
and self.target_version != short_version:
raise DistutilsOptionError(
"target version can only be %s, or the '--skip-build'"
" option must be specified" % (short_version,))
else:
self.versions = list(self.all_versions)
self.set_undefined_options('bdist',
('dist_dir', 'dist_dir'),
('plat_name', 'plat_name'),
)
if self.pre_install_script:
raise DistutilsOptionError(
"the pre-install-script feature is not yet implemented")
if self.install_script:
for script in self.distribution.scripts:
if self.install_script == os.path.basename(script):
break
else:
raise DistutilsOptionError(
"install_script '%s' not found in scripts"
% self.install_script)
self.install_script_key = None
def run(self):
if not self.skip_build:
self.run_command('build')
install = self.reinitialize_command('install', reinit_subcommands=1)
install.prefix = self.bdist_dir
install.skip_build = self.skip_build
install.warn_dir = 0
install_lib = self.reinitialize_command('install_lib')
# we do not want to include pyc or pyo files
install_lib.compile = 0
install_lib.optimize = 0
if self.distribution.has_ext_modules():
# If we are building an installer for a Python version other
# than the one we are currently running, then we need to ensure
# our build_lib reflects the other Python version rather than ours.
# Note that for target_version!=sys.version, we must have skipped the
# build step, so there is no issue with enforcing the build of this
# version.
target_version = self.target_version
if not target_version:
assert self.skip_build, "Should have already checked this"
target_version = '%d.%d' % sys.version_info[:2]
plat_specifier = ".%s-%s" % (self.plat_name, target_version)
build = self.get_finalized_command('build')
build.build_lib = os.path.join(build.build_base,
'lib' + plat_specifier)
log.info("installing to %s", self.bdist_dir)
install.ensure_finalized()
# avoid warning of 'install_lib' about installing
# into a directory not in sys.path
sys.path.insert(0, os.path.join(self.bdist_dir, 'PURELIB'))
install.run()
del sys.path[0]
self.mkpath(self.dist_dir)
fullname = self.distribution.get_fullname()
installer_name = self.get_installer_filename(fullname)
installer_name = os.path.abspath(installer_name)
if os.path.exists(installer_name): os.unlink(installer_name)
metadata = self.distribution.metadata
author = metadata.author
if not author:
author = metadata.maintainer
if not author:
author = "UNKNOWN"
version = metadata.get_version()
# ProductVersion must be strictly numeric
# XXX need to deal with prerelease versions
sversion = "%d.%d.%d" % StrictVersion(version).version
# Prefix ProductName with Python x.y, so that
# it sorts together with the other Python packages
# in Add-Remove-Programs (APR)
fullname = self.distribution.get_fullname()
if self.target_version:
product_name = "Python %s %s" % (self.target_version, fullname)
else:
product_name = "Python %s" % (fullname)
self.db = msilib.init_database(installer_name, schema,
product_name, msilib.gen_uuid(),
sversion, author)
msilib.add_tables(self.db, sequence)
props = [('DistVersion', version)]
email = metadata.author_email or metadata.maintainer_email
if email:
props.append(("ARPCONTACT", email))
if metadata.url:
props.append(("ARPURLINFOABOUT", metadata.url))
if props:
add_data(self.db, 'Property', props)
self.add_find_python()
self.add_files()
self.add_scripts()
self.add_ui()
self.db.Commit()
if hasattr(self.distribution, 'dist_files'):
tup = 'bdist_msi', self.target_version or 'any', fullname
self.distribution.dist_files.append(tup)
if not self.keep_temp:
remove_tree(self.bdist_dir, dry_run=self.dry_run)
def add_files(self):
db = self.db
cab = msilib.CAB("distfiles")
rootdir = os.path.abspath(self.bdist_dir)
root = Directory(db, cab, None, rootdir, "TARGETDIR", "SourceDir")
f = Feature(db, "Python", "Python", "Everything",
0, 1, directory="TARGETDIR")
items = [(f, root, '')]
for version in self.versions + [self.other_version]:
target = "TARGETDIR" + version
name = default = "Python" + version
desc = "Everything"
if version is self.other_version:
title = "Python from another location"
level = 2
else:
title = "Python %s from registry" % version
level = 1
f = Feature(db, name, title, desc, 1, level, directory=target)
dir = Directory(db, cab, root, rootdir, target, default)
items.append((f, dir, version))
db.Commit()
seen = {}
for feature, dir, version in items:
todo = [dir]
while todo:
dir = todo.pop()
for file in os.listdir(dir.absolute):
afile = os.path.join(dir.absolute, file)
if os.path.isdir(afile):
short = "%s|%s" % (dir.make_short(file), file)
default = file + version
newdir = Directory(db, cab, dir, file, default, short)
todo.append(newdir)
else:
if not dir.component:
dir.start_component(dir.logical, feature, 0)
if afile not in seen:
key = seen[afile] = dir.add_file(file)
if file==self.install_script:
if self.install_script_key:
raise DistutilsOptionError(
"Multiple files with name %s" % file)
self.install_script_key = '[#%s]' % key
else:
key = seen[afile]
add_data(self.db, "DuplicateFile",
[(key + version, dir.component, key, None, dir.logical)])
db.Commit()
cab.commit(db)
def add_find_python(self):
"""Adds code to the installer to compute the location of Python.
Properties PYTHON.MACHINE.X.Y and PYTHON.USER.X.Y will be set from the
registry for each version of Python.
Properties TARGETDIRX.Y will be set from PYTHON.USER.X.Y if defined,
else from PYTHON.MACHINE.X.Y.
Properties PYTHONX.Y will be set to TARGETDIRX.Y\\python.exe"""
start = 402
for ver in self.versions:
install_path = r"SOFTWARE\Python\PythonCore\%s\InstallPath" % ver
machine_reg = "python.machine." + ver
user_reg = "python.user." + ver
machine_prop = "PYTHON.MACHINE." + ver
user_prop = "PYTHON.USER." + ver
machine_action = "PythonFromMachine" + ver
user_action = "PythonFromUser" + ver
exe_action = "PythonExe" + ver
target_dir_prop = "TARGETDIR" + ver
exe_prop = "PYTHON" + ver
if msilib.Win64:
# type: msidbLocatorTypeRawValue + msidbLocatorType64bit
Type = 2+16
else:
Type = 2
add_data(self.db, "RegLocator",
[(machine_reg, 2, install_path, None, Type),
(user_reg, 1, install_path, None, Type)])
add_data(self.db, "AppSearch",
[(machine_prop, machine_reg),
(user_prop, user_reg)])
add_data(self.db, "CustomAction",
[(machine_action, 51+256, target_dir_prop, "[" + machine_prop + "]"),
(user_action, 51+256, target_dir_prop, "[" + user_prop + "]"),
(exe_action, 51+256, exe_prop, "[" + target_dir_prop + "]\\python.exe"),
])
add_data(self.db, "InstallExecuteSequence",
[(machine_action, machine_prop, start),
(user_action, user_prop, start + 1),
(exe_action, None, start + 2),
])
add_data(self.db, "InstallUISequence",
[(machine_action, machine_prop, start),
(user_action, user_prop, start + 1),
(exe_action, None, start + 2),
])
add_data(self.db, "Condition",
[("Python" + ver, 0, "NOT TARGETDIR" + ver)])
start += 4
assert start < 500
def add_scripts(self):
if self.install_script:
start = 6800
for ver in self.versions + [self.other_version]:
install_action = "install_script." + ver
exe_prop = "PYTHON" + ver
add_data(self.db, "CustomAction",
[(install_action, 50, exe_prop, self.install_script_key)])
add_data(self.db, "InstallExecuteSequence",
[(install_action, "&Python%s=3" % ver, start)])
start += 1
# XXX pre-install scripts are currently refused in finalize_options()
# but if this feature is completed, it will also need to add
# entries for each version as the above code does
if self.pre_install_script:
scriptfn = os.path.join(self.bdist_dir, "preinstall.bat")
with open(scriptfn, "w") as f:
# The batch file will be executed with [PYTHON], so that %1
# is the path to the Python interpreter; %0 will be the path
# of the batch file.
# rem ="""
# %1 %0
# exit
# """
# <actual script>
f.write('rem ="""\n%1 %0\nexit\n"""\n')
with open(self.pre_install_script) as fin:
f.write(fin.read())
add_data(self.db, "Binary",
[("PreInstall", msilib.Binary(scriptfn))
])
add_data(self.db, "CustomAction",
[("PreInstall", 2, "PreInstall", None)
])
add_data(self.db, "InstallExecuteSequence",
[("PreInstall", "NOT Installed", 450)])
def add_ui(self):
db = self.db
x = y = 50
w = 370
h = 300
title = "[ProductName] Setup"
# see "Dialog Style Bits"
modal = 3 # visible | modal
modeless = 1 # visible
track_disk_space = 32
# UI customization properties
add_data(db, "Property",
# See "DefaultUIFont Property"
[("DefaultUIFont", "DlgFont8"),
# See "ErrorDialog Style Bit"
("ErrorDialog", "ErrorDlg"),
("Progress1", "Install"), # modified in maintenance type dlg
("Progress2", "installs"),
("MaintenanceForm_Action", "Repair"),
# possible values: ALL, JUSTME
("WhichUsers", "ALL")
])
# Fonts, see "TextStyle Table"
add_data(db, "TextStyle",
[("DlgFont8", "Tahoma", 9, None, 0),
("DlgFontBold8", "Tahoma", 8, None, 1), #bold
("VerdanaBold10", "Verdana", 10, None, 1),
("VerdanaRed9", "Verdana", 9, 255, 0),
])
# UI Sequences, see "InstallUISequence Table", "Using a Sequence Table"
# Numbers indicate sequence; see sequence.py for how these action integrate
add_data(db, "InstallUISequence",
[("PrepareDlg", "Not Privileged or Windows9x or Installed", 140),
("WhichUsersDlg", "Privileged and not Windows9x and not Installed", 141),
# In the user interface, assume all-users installation if privileged.
("SelectFeaturesDlg", "Not Installed", 1230),
# XXX no support for resume installations yet
#("ResumeDlg", "Installed AND (RESUME OR Preselected)", 1240),
("MaintenanceTypeDlg", "Installed AND NOT RESUME AND NOT Preselected", 1250),
("ProgressDlg", None, 1280)])
add_data(db, 'ActionText', text.ActionText)
add_data(db, 'UIText', text.UIText)
#####################################################################
# Standard dialogs: FatalError, UserExit, ExitDialog
fatal=PyDialog(db, "FatalError", x, y, w, h, modal, title,
"Finish", "Finish", "Finish")
fatal.title("[ProductName] Installer ended prematurely")
fatal.back("< Back", "Finish", active = 0)
fatal.cancel("Cancel", "Back", active = 0)
fatal.text("Description1", 15, 70, 320, 80, 0x30003,
"[ProductName] setup ended prematurely because of an error. Your system has not been modified. To install this program at a later time, please run the installation again.")
fatal.text("Description2", 15, 155, 320, 20, 0x30003,
"Click the Finish button to exit the Installer.")
c=fatal.next("Finish", "Cancel", name="Finish")
c.event("EndDialog", "Exit")
user_exit=PyDialog(db, "UserExit", x, y, w, h, modal, title,
"Finish", "Finish", "Finish")
user_exit.title("[ProductName] Installer was interrupted")
user_exit.back("< Back", "Finish", active = 0)
user_exit.cancel("Cancel", "Back", active = 0)
user_exit.text("Description1", 15, 70, 320, 80, 0x30003,
"[ProductName] setup was interrupted. Your system has not been modified. "
"To install this program at a later time, please run the installation again.")
user_exit.text("Description2", 15, 155, 320, 20, 0x30003,
"Click the Finish button to exit the Installer.")
c = user_exit.next("Finish", "Cancel", name="Finish")
c.event("EndDialog", "Exit")
exit_dialog = PyDialog(db, "ExitDialog", x, y, w, h, modal, title,
"Finish", "Finish", "Finish")
exit_dialog.title("Completing the [ProductName] Installer")
exit_dialog.back("< Back", "Finish", active = 0)
exit_dialog.cancel("Cancel", "Back", active = 0)
exit_dialog.text("Description", 15, 235, 320, 20, 0x30003,
"Click the Finish button to exit the Installer.")
c = exit_dialog.next("Finish", "Cancel", name="Finish")
c.event("EndDialog", "Return")
#####################################################################
# Required dialog: FilesInUse, ErrorDlg
inuse = PyDialog(db, "FilesInUse",
x, y, w, h,
19, # KeepModeless|Modal|Visible
title,
"Retry", "Retry", "Retry", bitmap=False)
inuse.text("Title", 15, 6, 200, 15, 0x30003,
r"{\DlgFontBold8}Files in Use")
inuse.text("Description", 20, 23, 280, 20, 0x30003,
"Some files that need to be updated are currently in use.")
inuse.text("Text", 20, 55, 330, 50, 3,
"The following applications are using files that need to be updated by this setup. Close these applications and then click Retry to continue the installation or Cancel to exit it.")
inuse.control("List", "ListBox", 20, 107, 330, 130, 7, "FileInUseProcess",
None, None, None)
c=inuse.back("Exit", "Ignore", name="Exit")
c.event("EndDialog", "Exit")
c=inuse.next("Ignore", "Retry", name="Ignore")
c.event("EndDialog", "Ignore")
c=inuse.cancel("Retry", "Exit", name="Retry")
c.event("EndDialog","Retry")
# See "Error Dialog". See "ICE20" for the required names of the controls.
error = Dialog(db, "ErrorDlg",
50, 10, 330, 101,
65543, # Error|Minimize|Modal|Visible
title,
"ErrorText", None, None)
error.text("ErrorText", 50,9,280,48,3, "")
#error.control("ErrorIcon", "Icon", 15, 9, 24, 24, 5242881, None, "py.ico", None, None)
error.pushbutton("N",120,72,81,21,3,"No",None).event("EndDialog","ErrorNo")
error.pushbutton("Y",240,72,81,21,3,"Yes",None).event("EndDialog","ErrorYes")
error.pushbutton("A",0,72,81,21,3,"Abort",None).event("EndDialog","ErrorAbort")
error.pushbutton("C",42,72,81,21,3,"Cancel",None).event("EndDialog","ErrorCancel")
error.pushbutton("I",81,72,81,21,3,"Ignore",None).event("EndDialog","ErrorIgnore")
error.pushbutton("O",159,72,81,21,3,"Ok",None).event("EndDialog","ErrorOk")
error.pushbutton("R",198,72,81,21,3,"Retry",None).event("EndDialog","ErrorRetry")
#####################################################################
# Global "Query Cancel" dialog
cancel = Dialog(db, "CancelDlg", 50, 10, 260, 85, 3, title,
"No", "No", "No")
cancel.text("Text", 48, 15, 194, 30, 3,
"Are you sure you want to cancel [ProductName] installation?")
#cancel.control("Icon", "Icon", 15, 15, 24, 24, 5242881, None,
# "py.ico", None, None)
c=cancel.pushbutton("Yes", 72, 57, 56, 17, 3, "Yes", "No")
c.event("EndDialog", "Exit")
c=cancel.pushbutton("No", 132, 57, 56, 17, 3, "No", "Yes")
c.event("EndDialog", "Return")
#####################################################################
# Global "Wait for costing" dialog
costing = Dialog(db, "WaitForCostingDlg", 50, 10, 260, 85, modal, title,
"Return", "Return", "Return")
costing.text("Text", 48, 15, 194, 30, 3,
"Please wait while the installer finishes determining your disk space requirements.")
c = costing.pushbutton("Return", 102, 57, 56, 17, 3, "Return", None)
c.event("EndDialog", "Exit")
#####################################################################
# Preparation dialog: no user input except cancellation
prep = PyDialog(db, "PrepareDlg", x, y, w, h, modeless, title,
"Cancel", "Cancel", "Cancel")
prep.text("Description", 15, 70, 320, 40, 0x30003,
"Please wait while the Installer prepares to guide you through the installation.")
prep.title("Welcome to the [ProductName] Installer")
c=prep.text("ActionText", 15, 110, 320, 20, 0x30003, "Pondering...")
c.mapping("ActionText", "Text")
c=prep.text("ActionData", 15, 135, 320, 30, 0x30003, None)
c.mapping("ActionData", "Text")
prep.back("Back", None, active=0)
prep.next("Next", None, active=0)
c=prep.cancel("Cancel", None)
c.event("SpawnDialog", "CancelDlg")
#####################################################################
# Feature (Python directory) selection
seldlg = PyDialog(db, "SelectFeaturesDlg", x, y, w, h, modal, title,
"Next", "Next", "Cancel")
seldlg.title("Select Python Installations")
seldlg.text("Hint", 15, 30, 300, 20, 3,
"Select the Python locations where %s should be installed."
% self.distribution.get_fullname())
seldlg.back("< Back", None, active=0)
c = seldlg.next("Next >", "Cancel")
order = 1
c.event("[TARGETDIR]", "[SourceDir]", ordering=order)
for version in self.versions + [self.other_version]:
order += 1
c.event("[TARGETDIR]", "[TARGETDIR%s]" % version,
"FEATURE_SELECTED AND &Python%s=3" % version,
ordering=order)
c.event("SpawnWaitDialog", "WaitForCostingDlg", ordering=order + 1)
c.event("EndDialog", "Return", ordering=order + 2)
c = seldlg.cancel("Cancel", "Features")
c.event("SpawnDialog", "CancelDlg")
c = seldlg.control("Features", "SelectionTree", 15, 60, 300, 120, 3,
"FEATURE", None, "PathEdit", None)
c.event("[FEATURE_SELECTED]", "1")
ver = self.other_version
install_other_cond = "FEATURE_SELECTED AND &Python%s=3" % ver
dont_install_other_cond = "FEATURE_SELECTED AND &Python%s<>3" % ver
c = seldlg.text("Other", 15, 200, 300, 15, 3,
"Provide an alternate Python location")
c.condition("Enable", install_other_cond)
c.condition("Show", install_other_cond)
c.condition("Disable", dont_install_other_cond)
c.condition("Hide", dont_install_other_cond)
c = seldlg.control("PathEdit", "PathEdit", 15, 215, 300, 16, 1,
"TARGETDIR" + ver, None, "Next", None)
c.condition("Enable", install_other_cond)
c.condition("Show", install_other_cond)
c.condition("Disable", dont_install_other_cond)
c.condition("Hide", dont_install_other_cond)
#####################################################################
# Disk cost
cost = PyDialog(db, "DiskCostDlg", x, y, w, h, modal, title,
"OK", "OK", "OK", bitmap=False)
cost.text("Title", 15, 6, 200, 15, 0x30003,
r"{\DlgFontBold8}Disk Space Requirements")
cost.text("Description", 20, 20, 280, 20, 0x30003,
"The disk space required for the installation of the selected features.")
cost.text("Text", 20, 53, 330, 60, 3,
"The highlighted volumes (if any) do not have enough disk space "
"available for the currently selected features. You can either "
"remove some files from the highlighted volumes, or choose to "
"install less features onto local drive(s), or select different "
"destination drive(s).")
cost.control("VolumeList", "VolumeCostList", 20, 100, 330, 150, 393223,
None, "{120}{70}{70}{70}{70}", None, None)
cost.xbutton("OK", "Ok", None, 0.5).event("EndDialog", "Return")
#####################################################################
# WhichUsers Dialog. Only available on NT, and for privileged users.
# This must be run before FindRelatedProducts, because that will
# take into account whether the previous installation was per-user
# or per-machine. We currently don't support going back to this
# dialog after "Next" was selected; to support this, we would need to
# find how to reset the ALLUSERS property, and how to re-run
# FindRelatedProducts.
# On Windows9x, the ALLUSERS property is ignored on the command line
# and in the Property table, but installer fails according to the documentation
# if a dialog attempts to set ALLUSERS.
whichusers = PyDialog(db, "WhichUsersDlg", x, y, w, h, modal, title,
"AdminInstall", "Next", "Cancel")
whichusers.title("Select whether to install [ProductName] for all users of this computer.")
# A radio group with two options: allusers, justme
g = whichusers.radiogroup("AdminInstall", 15, 60, 260, 50, 3,
"WhichUsers", "", "Next")
g.add("ALL", 0, 5, 150, 20, "Install for all users")
g.add("JUSTME", 0, 25, 150, 20, "Install just for me")
whichusers.back("Back", None, active=0)
c = whichusers.next("Next >", "Cancel")
c.event("[ALLUSERS]", "1", 'WhichUsers="ALL"', 1)
c.event("EndDialog", "Return", ordering = 2)
c = whichusers.cancel("Cancel", "AdminInstall")
c.event("SpawnDialog", "CancelDlg")
#####################################################################
# Installation Progress dialog (modeless)
progress = PyDialog(db, "ProgressDlg", x, y, w, h, modeless, title,
"Cancel", "Cancel", "Cancel", bitmap=False)
progress.text("Title", 20, 15, 200, 15, 0x30003,
r"{\DlgFontBold8}[Progress1] [ProductName]")
progress.text("Text", 35, 65, 300, 30, 3,
"Please wait while the Installer [Progress2] [ProductName]. "
"This may take several minutes.")
progress.text("StatusLabel", 35, 100, 35, 20, 3, "Status:")
c=progress.text("ActionText", 70, 100, w-70, 20, 3, "Pondering...")
c.mapping("ActionText", "Text")
#c=progress.text("ActionData", 35, 140, 300, 20, 3, None)
#c.mapping("ActionData", "Text")
c=progress.control("ProgressBar", "ProgressBar", 35, 120, 300, 10, 65537,
None, "Progress done", None, None)
c.mapping("SetProgress", "Progress")
progress.back("< Back", "Next", active=False)
progress.next("Next >", "Cancel", active=False)
progress.cancel("Cancel", "Back").event("SpawnDialog", "CancelDlg")
###################################################################
# Maintenance type: repair/uninstall
maint = PyDialog(db, "MaintenanceTypeDlg", x, y, w, h, modal, title,
"Next", "Next", "Cancel")
maint.title("Welcome to the [ProductName] Setup Wizard")
maint.text("BodyText", 15, 63, 330, 42, 3,
"Select whether you want to repair or remove [ProductName].")
g=maint.radiogroup("RepairRadioGroup", 15, 108, 330, 60, 3,
"MaintenanceForm_Action", "", "Next")
#g.add("Change", 0, 0, 200, 17, "&Change [ProductName]")
g.add("Repair", 0, 18, 200, 17, "&Repair [ProductName]")
g.add("Remove", 0, 36, 200, 17, "Re&move [ProductName]")
maint.back("< Back", None, active=False)
c=maint.next("Finish", "Cancel")
# Change installation: Change progress dialog to "Change", then ask
# for feature selection
#c.event("[Progress1]", "Change", 'MaintenanceForm_Action="Change"', 1)
#c.event("[Progress2]", "changes", 'MaintenanceForm_Action="Change"', 2)
# Reinstall: Change progress dialog to "Repair", then invoke reinstall
# Also set list of reinstalled features to "ALL"
c.event("[REINSTALL]", "ALL", 'MaintenanceForm_Action="Repair"', 5)
c.event("[Progress1]", "Repairing", 'MaintenanceForm_Action="Repair"', 6)
c.event("[Progress2]", "repairs", 'MaintenanceForm_Action="Repair"', 7)
c.event("Reinstall", "ALL", 'MaintenanceForm_Action="Repair"', 8)
# Uninstall: Change progress to "Remove", then invoke uninstall
# Also set list of removed features to "ALL"
c.event("[REMOVE]", "ALL", 'MaintenanceForm_Action="Remove"', 11)
c.event("[Progress1]", "Removing", 'MaintenanceForm_Action="Remove"', 12)
c.event("[Progress2]", "removes", 'MaintenanceForm_Action="Remove"', 13)
c.event("Remove", "ALL", 'MaintenanceForm_Action="Remove"', 14)
# Close dialog when maintenance action scheduled
c.event("EndDialog", "Return", 'MaintenanceForm_Action<>"Change"', 20)
#c.event("NewDialog", "SelectFeaturesDlg", 'MaintenanceForm_Action="Change"', 21)
maint.cancel("Cancel", "RepairRadioGroup").event("SpawnDialog", "CancelDlg")
def get_installer_filename(self, fullname):
# Factored out to allow overriding in subclasses
if self.target_version:
base_name = "%s.%s-py%s.msi" % (fullname, self.plat_name,
self.target_version)
else:
base_name = "%s.%s.msi" % (fullname, self.plat_name)
installer_name = os.path.join(self.dist_dir, base_name)
return installer_name
install_scripts.py 0000644 00000003741 15051366002 0010336 0 ustar 00 """distutils.command.install_scripts
Implements the Distutils 'install_scripts' command, for installing
Python scripts."""
# contributed by Bastian Kleineidam
import os
from distutils.core import Command
from distutils import log
from stat import ST_MODE
class install_scripts(Command):
description = "install scripts (Python or otherwise)"
user_options = [
('install-dir=', 'd', "directory to install scripts to"),
('build-dir=','b', "build directory (where to install from)"),
('force', 'f', "force installation (overwrite existing files)"),
('skip-build', None, "skip the build steps"),
]
boolean_options = ['force', 'skip-build']
def initialize_options(self):
self.install_dir = None
self.force = 0
self.build_dir = None
self.skip_build = None
def finalize_options(self):
self.set_undefined_options('build', ('build_scripts', 'build_dir'))
self.set_undefined_options('install',
('install_scripts', 'install_dir'),
('force', 'force'),
('skip_build', 'skip_build'),
)
def run(self):
if not self.skip_build:
self.run_command('build_scripts')
self.outfiles = self.copy_tree(self.build_dir, self.install_dir)
if os.name == 'posix':
# Set the executable bits (owner, group, and world) on
# all the scripts we just installed.
for file in self.get_outputs():
if self.dry_run:
log.info("changing mode of %s", file)
else:
mode = ((os.stat(file)[ST_MODE]) | 0o555) & 0o7777
log.info("changing mode of %s to %o", file, mode)
os.chmod(file, mode)
def get_inputs(self):
return self.distribution.scripts or []
def get_outputs(self):
return self.outfiles or []
bdist_wininst.py 0000644 00000037253 15051366002 0010006 0 ustar 00 """distutils.command.bdist_wininst
Implements the Distutils 'bdist_wininst' command: create a windows installer
exe-program."""
import os
import sys
import warnings
from distutils.core import Command
from distutils.util import get_platform
from distutils.dir_util import create_tree, remove_tree
from distutils.errors import *
from distutils.sysconfig import get_python_version
from distutils import log
class bdist_wininst(Command):
description = "create an executable installer for MS Windows"
user_options = [('bdist-dir=', None,
"temporary directory for creating the distribution"),
('plat-name=', 'p',
"platform name to embed in generated filenames "
"(default: %s)" % get_platform()),
('keep-temp', 'k',
"keep the pseudo-installation tree around after " +
"creating the distribution archive"),
('target-version=', None,
"require a specific python version" +
" on the target system"),
('no-target-compile', 'c',
"do not compile .py to .pyc on the target system"),
('no-target-optimize', 'o',
"do not compile .py to .pyo (optimized) "
"on the target system"),
('dist-dir=', 'd',
"directory to put final built distributions in"),
('bitmap=', 'b',
"bitmap to use for the installer instead of python-powered logo"),
('title=', 't',
"title to display on the installer background instead of default"),
('skip-build', None,
"skip rebuilding everything (for testing/debugging)"),
('install-script=', None,
"basename of installation script to be run after "
"installation or before deinstallation"),
('pre-install-script=', None,
"Fully qualified filename of a script to be run before "
"any files are installed. This script need not be in the "
"distribution"),
('user-access-control=', None,
"specify Vista's UAC handling - 'none'/default=no "
"handling, 'auto'=use UAC if target Python installed for "
"all users, 'force'=always use UAC"),
]
boolean_options = ['keep-temp', 'no-target-compile', 'no-target-optimize',
'skip-build']
# bpo-10945: bdist_wininst requires mbcs encoding only available on Windows
_unsupported = (sys.platform != "win32")
def __init__(self, *args, **kw):
super().__init__(*args, **kw)
warnings.warn("bdist_wininst command is deprecated since Python 3.8, "
"use bdist_wheel (wheel packages) instead",
DeprecationWarning, 2)
def initialize_options(self):
self.bdist_dir = None
self.plat_name = None
self.keep_temp = 0
self.no_target_compile = 0
self.no_target_optimize = 0
self.target_version = None
self.dist_dir = None
self.bitmap = None
self.title = None
self.skip_build = None
self.install_script = None
self.pre_install_script = None
self.user_access_control = None
def finalize_options(self):
self.set_undefined_options('bdist', ('skip_build', 'skip_build'))
if self.bdist_dir is None:
if self.skip_build and self.plat_name:
# If build is skipped and plat_name is overridden, bdist will
# not see the correct 'plat_name' - so set that up manually.
bdist = self.distribution.get_command_obj('bdist')
bdist.plat_name = self.plat_name
# next the command will be initialized using that name
bdist_base = self.get_finalized_command('bdist').bdist_base
self.bdist_dir = os.path.join(bdist_base, 'wininst')
if not self.target_version:
self.target_version = ""
if not self.skip_build and self.distribution.has_ext_modules():
short_version = get_python_version()
if self.target_version and self.target_version != short_version:
raise DistutilsOptionError(
"target version can only be %s, or the '--skip-build'" \
" option must be specified" % (short_version,))
self.target_version = short_version
self.set_undefined_options('bdist',
('dist_dir', 'dist_dir'),
('plat_name', 'plat_name'),
)
if self.install_script:
for script in self.distribution.scripts:
if self.install_script == os.path.basename(script):
break
else:
raise DistutilsOptionError(
"install_script '%s' not found in scripts"
% self.install_script)
def run(self):
if (sys.platform != "win32" and
(self.distribution.has_ext_modules() or
self.distribution.has_c_libraries())):
raise DistutilsPlatformError \
("distribution contains extensions and/or C libraries; "
"must be compiled on a Windows 32 platform")
if not self.skip_build:
self.run_command('build')
install = self.reinitialize_command('install', reinit_subcommands=1)
install.root = self.bdist_dir
install.skip_build = self.skip_build
install.warn_dir = 0
install.plat_name = self.plat_name
install_lib = self.reinitialize_command('install_lib')
# we do not want to include pyc or pyo files
install_lib.compile = 0
install_lib.optimize = 0
if self.distribution.has_ext_modules():
# If we are building an installer for a Python version other
# than the one we are currently running, then we need to ensure
# our build_lib reflects the other Python version rather than ours.
# Note that for target_version!=sys.version, we must have skipped the
# build step, so there is no issue with enforcing the build of this
# version.
target_version = self.target_version
if not target_version:
assert self.skip_build, "Should have already checked this"
target_version = '%d.%d' % sys.version_info[:2]
plat_specifier = ".%s-%s" % (self.plat_name, target_version)
build = self.get_finalized_command('build')
build.build_lib = os.path.join(build.build_base,
'lib' + plat_specifier)
# Use a custom scheme for the zip-file, because we have to decide
# at installation time which scheme to use.
for key in ('purelib', 'platlib', 'headers', 'scripts', 'data'):
value = key.upper()
if key == 'headers':
value = value + '/Include/$dist_name'
setattr(install,
'install_' + key,
value)
log.info("installing to %s", self.bdist_dir)
install.ensure_finalized()
# avoid warning of 'install_lib' about installing
# into a directory not in sys.path
sys.path.insert(0, os.path.join(self.bdist_dir, 'PURELIB'))
install.run()
del sys.path[0]
# And make an archive relative to the root of the
# pseudo-installation tree.
from tempfile import mktemp
archive_basename = mktemp()
fullname = self.distribution.get_fullname()
arcname = self.make_archive(archive_basename, "zip",
root_dir=self.bdist_dir)
# create an exe containing the zip-file
self.create_exe(arcname, fullname, self.bitmap)
if self.distribution.has_ext_modules():
pyversion = get_python_version()
else:
pyversion = 'any'
self.distribution.dist_files.append(('bdist_wininst', pyversion,
self.get_installer_filename(fullname)))
# remove the zip-file again
log.debug("removing temporary file '%s'", arcname)
os.remove(arcname)
if not self.keep_temp:
remove_tree(self.bdist_dir, dry_run=self.dry_run)
def get_inidata(self):
# Return data describing the installation.
lines = []
metadata = self.distribution.metadata
# Write the [metadata] section.
lines.append("[metadata]")
# 'info' will be displayed in the installer's dialog box,
# describing the items to be installed.
info = (metadata.long_description or '') + '\n'
# Escape newline characters
def escape(s):
return s.replace("\n", "\\n")
for name in ["author", "author_email", "description", "maintainer",
"maintainer_email", "name", "url", "version"]:
data = getattr(metadata, name, "")
if data:
info = info + ("\n %s: %s" % \
(name.capitalize(), escape(data)))
lines.append("%s=%s" % (name, escape(data)))
# The [setup] section contains entries controlling
# the installer runtime.
lines.append("\n[Setup]")
if self.install_script:
lines.append("install_script=%s" % self.install_script)
lines.append("info=%s" % escape(info))
lines.append("target_compile=%d" % (not self.no_target_compile))
lines.append("target_optimize=%d" % (not self.no_target_optimize))
if self.target_version:
lines.append("target_version=%s" % self.target_version)
if self.user_access_control:
lines.append("user_access_control=%s" % self.user_access_control)
title = self.title or self.distribution.get_fullname()
lines.append("title=%s" % escape(title))
import time
import distutils
build_info = "Built %s with distutils-%s" % \
(time.ctime(time.time()), distutils.__version__)
lines.append("build_info=%s" % build_info)
return "\n".join(lines)
def create_exe(self, arcname, fullname, bitmap=None):
import struct
self.mkpath(self.dist_dir)
cfgdata = self.get_inidata()
installer_name = self.get_installer_filename(fullname)
self.announce("creating %s" % installer_name)
if bitmap:
with open(bitmap, "rb") as f:
bitmapdata = f.read()
bitmaplen = len(bitmapdata)
else:
bitmaplen = 0
with open(installer_name, "wb") as file:
file.write(self.get_exe_bytes())
if bitmap:
file.write(bitmapdata)
# Convert cfgdata from unicode to ascii, mbcs encoded
if isinstance(cfgdata, str):
cfgdata = cfgdata.encode("mbcs")
# Append the pre-install script
cfgdata = cfgdata + b"\0"
if self.pre_install_script:
# We need to normalize newlines, so we open in text mode and
# convert back to bytes. "latin-1" simply avoids any possible
# failures.
with open(self.pre_install_script, "r",
encoding="latin-1") as script:
script_data = script.read().encode("latin-1")
cfgdata = cfgdata + script_data + b"\n\0"
else:
# empty pre-install script
cfgdata = cfgdata + b"\0"
file.write(cfgdata)
# The 'magic number' 0x1234567B is used to make sure that the
# binary layout of 'cfgdata' is what the wininst.exe binary
# expects. If the layout changes, increment that number, make
# the corresponding changes to the wininst.exe sources, and
# recompile them.
header = struct.pack("<iii",
0x1234567B, # tag
len(cfgdata), # length
bitmaplen, # number of bytes in bitmap
)
file.write(header)
with open(arcname, "rb") as f:
file.write(f.read())
def get_installer_filename(self, fullname):
# Factored out to allow overriding in subclasses
if self.target_version:
# if we create an installer for a specific python version,
# it's better to include this in the name
installer_name = os.path.join(self.dist_dir,
"%s.%s-py%s.exe" %
(fullname, self.plat_name, self.target_version))
else:
installer_name = os.path.join(self.dist_dir,
"%s.%s.exe" % (fullname, self.plat_name))
return installer_name
def get_exe_bytes(self):
# If a target-version other than the current version has been
# specified, then using the MSVC version from *this* build is no good.
# Without actually finding and executing the target version and parsing
# its sys.version, we just hard-code our knowledge of old versions.
# NOTE: Possible alternative is to allow "--target-version" to
# specify a Python executable rather than a simple version string.
# We can then execute this program to obtain any info we need, such
# as the real sys.version string for the build.
cur_version = get_python_version()
# If the target version is *later* than us, then we assume they
# use what we use
# string compares seem wrong, but are what sysconfig.py itself uses
if self.target_version and self.target_version < cur_version:
if self.target_version < "2.4":
bv = '6.0'
elif self.target_version == "2.4":
bv = '7.1'
elif self.target_version == "2.5":
bv = '8.0'
elif self.target_version <= "3.2":
bv = '9.0'
elif self.target_version <= "3.4":
bv = '10.0'
else:
bv = '14.0'
else:
# for current version - use authoritative check.
try:
from msvcrt import CRT_ASSEMBLY_VERSION
except ImportError:
# cross-building, so assume the latest version
bv = '14.0'
else:
# as far as we know, CRT is binary compatible based on
# the first field, so assume 'x.0' until proven otherwise
major = CRT_ASSEMBLY_VERSION.partition('.')[0]
bv = major + '.0'
# wininst-x.y.exe is in the same directory as this file
directory = os.path.dirname(__file__)
# we must use a wininst-x.y.exe built with the same C compiler
# used for python. XXX What about mingw, borland, and so on?
# if plat_name starts with "win" but is not "win32"
# we want to strip "win" and leave the rest (e.g. -amd64)
# for all other cases, we don't want any suffix
if self.plat_name != 'win32' and self.plat_name[:3] == 'win':
sfix = self.plat_name[3:]
else:
sfix = ''
filename = os.path.join(directory, "wininst-%s%s.exe" % (bv, sfix))
f = open(filename, "rb")
try:
return f.read()
finally:
f.close()
upload.py 0000644 00000016364 15051366002 0006412 0 ustar 00 """
distutils.command.upload
Implements the Distutils 'upload' subcommand (upload package to a package
index).
"""
import os
import io
import platform
import hashlib
from base64 import standard_b64encode
from urllib.request import urlopen, Request, HTTPError
from urllib.parse import urlparse
from distutils.errors import DistutilsError, DistutilsOptionError
from distutils.core import PyPIRCCommand
from distutils.spawn import spawn
from distutils import log
class upload(PyPIRCCommand):
description = "upload binary package to PyPI"
user_options = PyPIRCCommand.user_options + [
('sign', 's',
'sign files to upload using gpg'),
('identity=', 'i', 'GPG identity used to sign files'),
]
boolean_options = PyPIRCCommand.boolean_options + ['sign']
def initialize_options(self):
PyPIRCCommand.initialize_options(self)
self.username = ''
self.password = ''
self.show_response = 0
self.sign = False
self.identity = None
def finalize_options(self):
PyPIRCCommand.finalize_options(self)
if self.identity and not self.sign:
raise DistutilsOptionError(
"Must use --sign for --identity to have meaning"
)
config = self._read_pypirc()
if config != {}:
self.username = config['username']
self.password = config['password']
self.repository = config['repository']
self.realm = config['realm']
# getting the password from the distribution
# if previously set by the register command
if not self.password and self.distribution.password:
self.password = self.distribution.password
def run(self):
if not self.distribution.dist_files:
msg = ("Must create and upload files in one command "
"(e.g. setup.py sdist upload)")
raise DistutilsOptionError(msg)
for command, pyversion, filename in self.distribution.dist_files:
self.upload_file(command, pyversion, filename)
def upload_file(self, command, pyversion, filename):
# Makes sure the repository URL is compliant
schema, netloc, url, params, query, fragments = \
urlparse(self.repository)
if params or query or fragments:
raise AssertionError("Incompatible url %s" % self.repository)
if schema not in ('http', 'https'):
raise AssertionError("unsupported schema " + schema)
# Sign if requested
if self.sign:
gpg_args = ["gpg", "--detach-sign", "-a", filename]
if self.identity:
gpg_args[2:2] = ["--local-user", self.identity]
spawn(gpg_args,
dry_run=self.dry_run)
# Fill in the data - send all the meta-data in case we need to
# register a new release
f = open(filename,'rb')
try:
content = f.read()
finally:
f.close()
meta = self.distribution.metadata
data = {
# action
':action': 'file_upload',
'protocol_version': '1',
# identify release
'name': meta.get_name(),
'version': meta.get_version(),
# file content
'content': (os.path.basename(filename),content),
'filetype': command,
'pyversion': pyversion,
'sha256_digest': hashlib.sha256(content).hexdigest(),
# additional meta-data
'metadata_version': '1.0',
'summary': meta.get_description(),
'home_page': meta.get_url(),
'author': meta.get_contact(),
'author_email': meta.get_contact_email(),
'license': meta.get_licence(),
'description': meta.get_long_description(),
'keywords': meta.get_keywords(),
'platform': meta.get_platforms(),
'classifiers': meta.get_classifiers(),
'download_url': meta.get_download_url(),
# PEP 314
'provides': meta.get_provides(),
'requires': meta.get_requires(),
'obsoletes': meta.get_obsoletes(),
}
try:
digest = hashlib.md5(content).hexdigest()
except ValueError as e:
msg = 'calculating md5 checksum failed: %s' % e
self.announce(msg, log.INFO)
from _hashlib import get_fips_mode
if not get_fips_mode():
# this really shouldn't fail
raise
else:
data['md5_digest'] = digest
data['comment'] = ''
if self.sign:
with open(filename + ".asc", "rb") as f:
data['gpg_signature'] = (os.path.basename(filename) + ".asc",
f.read())
# set up the authentication
user_pass = (self.username + ":" + self.password).encode('ascii')
# The exact encoding of the authentication string is debated.
# Anyway PyPI only accepts ascii for both username or password.
auth = "Basic " + standard_b64encode(user_pass).decode('ascii')
# Build up the MIME payload for the POST data
boundary = '--------------GHSKFJDLGDS7543FJKLFHRE75642756743254'
sep_boundary = b'\r\n--' + boundary.encode('ascii')
end_boundary = sep_boundary + b'--\r\n'
body = io.BytesIO()
for key, value in data.items():
title = '\r\nContent-Disposition: form-data; name="%s"' % key
# handle multiple entries for the same name
if not isinstance(value, list):
value = [value]
for value in value:
if type(value) is tuple:
title += '; filename="%s"' % value[0]
value = value[1]
else:
value = str(value).encode('utf-8')
body.write(sep_boundary)
body.write(title.encode('utf-8'))
body.write(b"\r\n\r\n")
body.write(value)
body.write(end_boundary)
body = body.getvalue()
msg = "Submitting %s to %s" % (filename, self.repository)
self.announce(msg, log.INFO)
# build the Request
headers = {
'Content-type': 'multipart/form-data; boundary=%s' % boundary,
'Content-length': str(len(body)),
'Authorization': auth,
}
request = Request(self.repository, data=body,
headers=headers)
# send the data
try:
result = urlopen(request)
status = result.getcode()
reason = result.msg
except HTTPError as e:
status = e.code
reason = e.msg
except OSError as e:
self.announce(str(e), log.ERROR)
raise
if status == 200:
self.announce('Server response (%s): %s' % (status, reason),
log.INFO)
if self.show_response:
text = self._read_pypi_response(result)
msg = '\n'.join(('-' * 75, text, '-' * 75))
self.announce(msg, log.INFO)
else:
msg = 'Upload failed (%s): %s' % (status, reason)
self.announce(msg, log.ERROR)
raise DistutilsError(msg)
bdist_rpm.py 0000644 00000052111 15051366002 0007077 0 ustar 00 """distutils.command.bdist_rpm
Implements the Distutils 'bdist_rpm' command (create RPM source and binary
distributions)."""
import subprocess, sys, os
from distutils.core import Command
from distutils.debug import DEBUG
from distutils.util import get_platform
from distutils.file_util import write_file
from distutils.errors import *
from distutils.sysconfig import get_python_version
from distutils import log
class bdist_rpm(Command):
description = "create an RPM distribution"
user_options = [
('bdist-base=', None,
"base directory for creating built distributions"),
('rpm-base=', None,
"base directory for creating RPMs (defaults to \"rpm\" under "
"--bdist-base; must be specified for RPM 2)"),
('dist-dir=', 'd',
"directory to put final RPM files in "
"(and .spec files if --spec-only)"),
('python=', None,
"path to Python interpreter to hard-code in the .spec file "
"(default: \"python\")"),
('fix-python', None,
"hard-code the exact path to the current Python interpreter in "
"the .spec file"),
('spec-only', None,
"only regenerate spec file"),
('source-only', None,
"only generate source RPM"),
('binary-only', None,
"only generate binary RPM"),
('use-bzip2', None,
"use bzip2 instead of gzip to create source distribution"),
# More meta-data: too RPM-specific to put in the setup script,
# but needs to go in the .spec file -- so we make these options
# to "bdist_rpm". The idea is that packagers would put this
# info in setup.cfg, although they are of course free to
# supply it on the command line.
('distribution-name=', None,
"name of the (Linux) distribution to which this "
"RPM applies (*not* the name of the module distribution!)"),
('group=', None,
"package classification [default: \"Development/Libraries\"]"),
('release=', None,
"RPM release number"),
('serial=', None,
"RPM serial number"),
('vendor=', None,
"RPM \"vendor\" (eg. \"Joe Blow <joe@example.com>\") "
"[default: maintainer or author from setup script]"),
('packager=', None,
"RPM packager (eg. \"Jane Doe <jane@example.net>\") "
"[default: vendor]"),
('doc-files=', None,
"list of documentation files (space or comma-separated)"),
('changelog=', None,
"RPM changelog"),
('icon=', None,
"name of icon file"),
('provides=', None,
"capabilities provided by this package"),
('requires=', None,
"capabilities required by this package"),
('conflicts=', None,
"capabilities which conflict with this package"),
('build-requires=', None,
"capabilities required to build this package"),
('obsoletes=', None,
"capabilities made obsolete by this package"),
('no-autoreq', None,
"do not automatically calculate dependencies"),
# Actions to take when building RPM
('keep-temp', 'k',
"don't clean up RPM build directory"),
('no-keep-temp', None,
"clean up RPM build directory [default]"),
('use-rpm-opt-flags', None,
"compile with RPM_OPT_FLAGS when building from source RPM"),
('no-rpm-opt-flags', None,
"do not pass any RPM CFLAGS to compiler"),
('rpm3-mode', None,
"RPM 3 compatibility mode (default)"),
('rpm2-mode', None,
"RPM 2 compatibility mode"),
# Add the hooks necessary for specifying custom scripts
('prep-script=', None,
"Specify a script for the PREP phase of RPM building"),
('build-script=', None,
"Specify a script for the BUILD phase of RPM building"),
('pre-install=', None,
"Specify a script for the pre-INSTALL phase of RPM building"),
('install-script=', None,
"Specify a script for the INSTALL phase of RPM building"),
('post-install=', None,
"Specify a script for the post-INSTALL phase of RPM building"),
('pre-uninstall=', None,
"Specify a script for the pre-UNINSTALL phase of RPM building"),
('post-uninstall=', None,
"Specify a script for the post-UNINSTALL phase of RPM building"),
('clean-script=', None,
"Specify a script for the CLEAN phase of RPM building"),
('verify-script=', None,
"Specify a script for the VERIFY phase of the RPM build"),
# Allow a packager to explicitly force an architecture
('force-arch=', None,
"Force an architecture onto the RPM build process"),
('quiet', 'q',
"Run the INSTALL phase of RPM building in quiet mode"),
]
boolean_options = ['keep-temp', 'use-rpm-opt-flags', 'rpm3-mode',
'no-autoreq', 'quiet']
negative_opt = {'no-keep-temp': 'keep-temp',
'no-rpm-opt-flags': 'use-rpm-opt-flags',
'rpm2-mode': 'rpm3-mode'}
def initialize_options(self):
self.bdist_base = None
self.rpm_base = None
self.dist_dir = None
self.python = None
self.fix_python = None
self.spec_only = None
self.binary_only = None
self.source_only = None
self.use_bzip2 = None
self.distribution_name = None
self.group = None
self.release = None
self.serial = None
self.vendor = None
self.packager = None
self.doc_files = None
self.changelog = None
self.icon = None
self.prep_script = None
self.build_script = None
self.install_script = None
self.clean_script = None
self.verify_script = None
self.pre_install = None
self.post_install = None
self.pre_uninstall = None
self.post_uninstall = None
self.prep = None
self.provides = None
self.requires = None
self.conflicts = None
self.build_requires = None
self.obsoletes = None
self.keep_temp = 0
self.use_rpm_opt_flags = 1
self.rpm3_mode = 1
self.no_autoreq = 0
self.force_arch = None
self.quiet = 0
def finalize_options(self):
self.set_undefined_options('bdist', ('bdist_base', 'bdist_base'))
if self.rpm_base is None:
if not self.rpm3_mode:
raise DistutilsOptionError(
"you must specify --rpm-base in RPM 2 mode")
self.rpm_base = os.path.join(self.bdist_base, "rpm")
if self.python is None:
if self.fix_python:
self.python = sys.executable
else:
self.python = "python3"
elif self.fix_python:
raise DistutilsOptionError(
"--python and --fix-python are mutually exclusive options")
if os.name != 'posix':
raise DistutilsPlatformError("don't know how to create RPM "
"distributions on platform %s" % os.name)
if self.binary_only and self.source_only:
raise DistutilsOptionError(
"cannot supply both '--source-only' and '--binary-only'")
# don't pass CFLAGS to pure python distributions
if not self.distribution.has_ext_modules():
self.use_rpm_opt_flags = 0
self.set_undefined_options('bdist', ('dist_dir', 'dist_dir'))
self.finalize_package_data()
def finalize_package_data(self):
self.ensure_string('group', "Development/Libraries")
self.ensure_string('vendor',
"%s <%s>" % (self.distribution.get_contact(),
self.distribution.get_contact_email()))
self.ensure_string('packager')
self.ensure_string_list('doc_files')
if isinstance(self.doc_files, list):
for readme in ('README', 'README.txt'):
if os.path.exists(readme) and readme not in self.doc_files:
self.doc_files.append(readme)
self.ensure_string('release', "1")
self.ensure_string('serial') # should it be an int?
self.ensure_string('distribution_name')
self.ensure_string('changelog')
# Format changelog correctly
self.changelog = self._format_changelog(self.changelog)
self.ensure_filename('icon')
self.ensure_filename('prep_script')
self.ensure_filename('build_script')
self.ensure_filename('install_script')
self.ensure_filename('clean_script')
self.ensure_filename('verify_script')
self.ensure_filename('pre_install')
self.ensure_filename('post_install')
self.ensure_filename('pre_uninstall')
self.ensure_filename('post_uninstall')
# XXX don't forget we punted on summaries and descriptions -- they
# should be handled here eventually!
# Now *this* is some meta-data that belongs in the setup script...
self.ensure_string_list('provides')
self.ensure_string_list('requires')
self.ensure_string_list('conflicts')
self.ensure_string_list('build_requires')
self.ensure_string_list('obsoletes')
self.ensure_string('force_arch')
def run(self):
if DEBUG:
print("before _get_package_data():")
print("vendor =", self.vendor)
print("packager =", self.packager)
print("doc_files =", self.doc_files)
print("changelog =", self.changelog)
# make directories
if self.spec_only:
spec_dir = self.dist_dir
self.mkpath(spec_dir)
else:
rpm_dir = {}
for d in ('SOURCES', 'SPECS', 'BUILD', 'RPMS', 'SRPMS'):
rpm_dir[d] = os.path.join(self.rpm_base, d)
self.mkpath(rpm_dir[d])
spec_dir = rpm_dir['SPECS']
# Spec file goes into 'dist_dir' if '--spec-only specified',
# build/rpm.<plat> otherwise.
spec_path = os.path.join(spec_dir,
"%s.spec" % self.distribution.get_name())
self.execute(write_file,
(spec_path,
self._make_spec_file()),
"writing '%s'" % spec_path)
if self.spec_only: # stop if requested
return
# Make a source distribution and copy to SOURCES directory with
# optional icon.
saved_dist_files = self.distribution.dist_files[:]
sdist = self.reinitialize_command('sdist')
if self.use_bzip2:
sdist.formats = ['bztar']
else:
sdist.formats = ['gztar']
self.run_command('sdist')
self.distribution.dist_files = saved_dist_files
source = sdist.get_archive_files()[0]
source_dir = rpm_dir['SOURCES']
self.copy_file(source, source_dir)
if self.icon:
if os.path.exists(self.icon):
self.copy_file(self.icon, source_dir)
else:
raise DistutilsFileError(
"icon file '%s' does not exist" % self.icon)
# build package
log.info("building RPMs")
rpm_cmd = ['rpmbuild']
if self.source_only: # what kind of RPMs?
rpm_cmd.append('-bs')
elif self.binary_only:
rpm_cmd.append('-bb')
else:
rpm_cmd.append('-ba')
rpm_cmd.extend(['--define', '__python %s' % self.python])
if self.rpm3_mode:
rpm_cmd.extend(['--define',
'_topdir %s' % os.path.abspath(self.rpm_base)])
if not self.keep_temp:
rpm_cmd.append('--clean')
if self.quiet:
rpm_cmd.append('--quiet')
rpm_cmd.append(spec_path)
# Determine the binary rpm names that should be built out of this spec
# file
# Note that some of these may not be really built (if the file
# list is empty)
nvr_string = "%{name}-%{version}-%{release}"
src_rpm = nvr_string + ".src.rpm"
non_src_rpm = "%{arch}/" + nvr_string + ".%{arch}.rpm"
q_cmd = r"rpm -q --qf '%s %s\n' --specfile '%s'" % (
src_rpm, non_src_rpm, spec_path)
out = os.popen(q_cmd)
try:
binary_rpms = []
source_rpm = None
while True:
line = out.readline()
if not line:
break
l = line.strip().split()
assert(len(l) == 2)
binary_rpms.append(l[1])
# The source rpm is named after the first entry in the spec file
if source_rpm is None:
source_rpm = l[0]
status = out.close()
if status:
raise DistutilsExecError("Failed to execute: %s" % repr(q_cmd))
finally:
out.close()
self.spawn(rpm_cmd)
if not self.dry_run:
if self.distribution.has_ext_modules():
pyversion = get_python_version()
else:
pyversion = 'any'
if not self.binary_only:
srpm = os.path.join(rpm_dir['SRPMS'], source_rpm)
assert(os.path.exists(srpm))
self.move_file(srpm, self.dist_dir)
filename = os.path.join(self.dist_dir, source_rpm)
self.distribution.dist_files.append(
('bdist_rpm', pyversion, filename))
if not self.source_only:
for rpm in binary_rpms:
rpm = os.path.join(rpm_dir['RPMS'], rpm)
if os.path.exists(rpm):
self.move_file(rpm, self.dist_dir)
filename = os.path.join(self.dist_dir,
os.path.basename(rpm))
self.distribution.dist_files.append(
('bdist_rpm', pyversion, filename))
def _dist_path(self, path):
return os.path.join(self.dist_dir, os.path.basename(path))
def _make_spec_file(self):
"""Generate the text of an RPM spec file and return it as a
list of strings (one per line).
"""
# definitions and headers
spec_file = [
'%define name ' + self.distribution.get_name(),
'%define version ' + self.distribution.get_version().replace('-','_'),
'%define unmangled_version ' + self.distribution.get_version(),
'%define release ' + self.release.replace('-','_'),
'',
'Summary: ' + self.distribution.get_description(),
]
# Workaround for #14443 which affects some RPM based systems such as
# RHEL6 (and probably derivatives)
vendor_hook = subprocess.getoutput('rpm --eval %{__os_install_post}')
# Generate a potential replacement value for __os_install_post (whilst
# normalizing the whitespace to simplify the test for whether the
# invocation of brp-python-bytecompile passes in __python):
vendor_hook = '\n'.join([' %s \\' % line.strip()
for line in vendor_hook.splitlines()])
problem = "brp-python-bytecompile \\\n"
fixed = "brp-python-bytecompile %{__python} \\\n"
fixed_hook = vendor_hook.replace(problem, fixed)
if fixed_hook != vendor_hook:
spec_file.append('# Workaround for http://bugs.python.org/issue14443')
spec_file.append('%define __os_install_post ' + fixed_hook + '\n')
# put locale summaries into spec file
# XXX not supported for now (hard to put a dictionary
# in a config file -- arg!)
#for locale in self.summaries.keys():
# spec_file.append('Summary(%s): %s' % (locale,
# self.summaries[locale]))
spec_file.extend([
'Name: %{name}',
'Version: %{version}',
'Release: %{release}',])
# XXX yuck! this filename is available from the "sdist" command,
# but only after it has run: and we create the spec file before
# running "sdist", in case of --spec-only.
if self.use_bzip2:
spec_file.append('Source0: %{name}-%{unmangled_version}.tar.bz2')
else:
spec_file.append('Source0: %{name}-%{unmangled_version}.tar.gz')
spec_file.extend([
'License: ' + self.distribution.get_license(),
'Group: ' + self.group,
'BuildRoot: %{_tmppath}/%{name}-%{version}-%{release}-buildroot',
'Prefix: %{_prefix}', ])
if not self.force_arch:
# noarch if no extension modules
if not self.distribution.has_ext_modules():
spec_file.append('BuildArch: noarch')
else:
spec_file.append( 'BuildArch: %s' % self.force_arch )
for field in ('Vendor',
'Packager',
'Provides',
'Requires',
'Conflicts',
'Obsoletes',
):
val = getattr(self, field.lower())
if isinstance(val, list):
spec_file.append('%s: %s' % (field, ' '.join(val)))
elif val is not None:
spec_file.append('%s: %s' % (field, val))
if self.distribution.get_url() != 'UNKNOWN':
spec_file.append('Url: ' + self.distribution.get_url())
if self.distribution_name:
spec_file.append('Distribution: ' + self.distribution_name)
if self.build_requires:
spec_file.append('BuildRequires: ' +
' '.join(self.build_requires))
if self.icon:
spec_file.append('Icon: ' + os.path.basename(self.icon))
if self.no_autoreq:
spec_file.append('AutoReq: 0')
spec_file.extend([
'',
'%description',
self.distribution.get_long_description()
])
# put locale descriptions into spec file
# XXX again, suppressed because config file syntax doesn't
# easily support this ;-(
#for locale in self.descriptions.keys():
# spec_file.extend([
# '',
# '%description -l ' + locale,
# self.descriptions[locale],
# ])
# rpm scripts
# figure out default build script
def_setup_call = "%s %s" % (self.python,os.path.basename(sys.argv[0]))
def_build = "%s build" % def_setup_call
if self.use_rpm_opt_flags:
def_build = 'env CFLAGS="$RPM_OPT_FLAGS" ' + def_build
# insert contents of files
# XXX this is kind of misleading: user-supplied options are files
# that we open and interpolate into the spec file, but the defaults
# are just text that we drop in as-is. Hmmm.
install_cmd = ('%s install -O1 --root=$RPM_BUILD_ROOT '
'--record=INSTALLED_FILES') % def_setup_call
script_options = [
('prep', 'prep_script', "%setup -n %{name}-%{unmangled_version}"),
('build', 'build_script', def_build),
('install', 'install_script', install_cmd),
('clean', 'clean_script', "rm -rf $RPM_BUILD_ROOT"),
('verifyscript', 'verify_script', None),
('pre', 'pre_install', None),
('post', 'post_install', None),
('preun', 'pre_uninstall', None),
('postun', 'post_uninstall', None),
]
for (rpm_opt, attr, default) in script_options:
# Insert contents of file referred to, if no file is referred to
# use 'default' as contents of script
val = getattr(self, attr)
if val or default:
spec_file.extend([
'',
'%' + rpm_opt,])
if val:
with open(val) as f:
spec_file.extend(f.read().split('\n'))
else:
spec_file.append(default)
# files section
spec_file.extend([
'',
'%files -f INSTALLED_FILES',
'%defattr(-,root,root)',
])
if self.doc_files:
spec_file.append('%doc ' + ' '.join(self.doc_files))
if self.changelog:
spec_file.extend([
'',
'%changelog',])
spec_file.extend(self.changelog)
return spec_file
def _format_changelog(self, changelog):
"""Format the changelog correctly and convert it to a list of strings
"""
if not changelog:
return changelog
new_changelog = []
for line in changelog.strip().split('\n'):
line = line.strip()
if line[0] == '*':
new_changelog.extend(['', line])
elif line[0] == '-':
new_changelog.append(line)
else:
new_changelog.append(' ' + line)
# strip trailing newline inserted by first changelog entry
if not new_changelog[0]:
del new_changelog[0]
return new_changelog
__pycache__/install_egg_info.cpython-38.opt-2.pyc 0000644 00000004417 15051366002 0015653 0 ustar 00 U
e5d+
� @ s` d dl mZ d dlmZmZ d dlZd dlZd dlZG dd� de�Zdd� Z dd � Z
d
d � Z dS ) � )�Command)�log�dir_utilNc @ s6 e Zd ZdZdgZdd� Zdd� Zdd� Zd d
� Zd S ) �install_egg_infoz8Install package's PKG-INFO metadata as an .egg-info file)z install-dir=�dzdirectory to install toc C s
d | _ d S �N)� install_dir��self� r �:/usr/lib64/python3.8/distutils/command/install_egg_info.py�initialize_options s z#install_egg_info.initialize_optionsc C sb | � dd� dtt| j�� ��tt| j�� ��ftjd d� � }t j
� | j |�| _
| j
g| _d S )NZ install_lib)r r z%s-%s-py%d.%d.egg-info� )Zset_undefined_options� to_filename� safe_name� distributionZget_name� safe_versionZ get_version�sys� version_info�os�path�joinr �target�outputs)r
�basenamer r r �finalize_options s � �z!install_egg_info.finalize_optionsc C s� | j }tj�|�r0tj�|�s0tj|| jd� nNtj�|�rV| � tj
| j fd| � n(tj�| j �s~| � tj | j fd| j � t
�d|� | js�t|ddd��}| jj�|� W 5 Q R X d S )N)�dry_runz Removing z Creating z
Writing %s�wzUTF-8)�encoding)r r r �isdir�islinkr Z remove_treer �existsZexecute�unlinkr �makedirsr �info�openr ZmetadataZwrite_pkg_file)r
r �fr r r �run s � zinstall_egg_info.runc C s | j S r )r r r r r � get_outputs. s z install_egg_info.get_outputsN) �__name__�
__module__� __qualname__Z descriptionZ user_optionsr
r r' r( r r r r r s �
r c C s t �dd| �S )N�[^A-Za-z0-9.]+�-)�re�sub��namer r r r 6 s r c C s | � dd�} t�dd| �S )N� �.r, r- )�replacer. r/ )�versionr r r r > s r c C s | � dd�S )Nr- �_)r4 r0 r r r r H s r ) Z
distutils.cmdr Z distutilsr r r r r. r r r r r r r r �<module> s +
__pycache__/register.cpython-38.opt-2.pyc 0000644 00000016030 15051366002 0014166 0 ustar 00 U
e5d�- � @ s` d dl Z d dlZd dlZd dlZd dlmZ d dlmZ d dl T d dl
m Z G dd� de�Z dS )� N)�warn)�
PyPIRCCommand)�*)�logc @ s� e Zd ZdZejddg Zejdddg Zddd � fgZd
d � Zd d
� Z dd� Z
dd� Z dd� Z dd� Z
dd� Zdd� Zdd� Zd d d �Zd S ) �registerz7register the distribution with the Python package index)�list-classifiersNz list the valid Trove classifiers)�strictNzBWill stop the registering if the meta-data are not fully compliant�verifyr r �checkc C s dS )NT� ��selfr r �2/usr/lib64/python3.8/distutils/command/register.py�<lambda> � zregister.<lambda>c C s t �| � d| _d| _d S )Nr )r �initialize_options�list_classifiersr r r r r r s
zregister.initialize_optionsc C s* t �| � d| jfdd�}|| jjd< d S )Nr )r � )r �restructuredtextr
)r �finalize_optionsr � distributionZcommand_options)r
Z
check_optionsr r r r $ s
�zregister.finalize_optionsc C sT | � � | �� | �� D ]}| �|� q| jr8| �� n| jrH| �� n| �� d S )N) r � _set_configZget_sub_commandsZ run_commandZdry_run�verify_metadatar � classifiers�
send_metadata)r
Zcmd_namer r r �run+ s
z register.runc C s8 t dt� | j�d�}|�� | j|_d|_|�� d S )Nzddistutils.command.register.check_metadata is deprecated, use the check command insteadr
r )r �PendingDeprecationWarningr Zget_command_objZensure_finalizedr r r )r
r
r r r �check_metadata: s � zregister.check_metadatac C sz | � � }|i kr@|d | _|d | _|d | _|d | _d| _n6| jd| jfkr^td| j ��| jdkrp| j| _d| _d S ) N�username�password�
repository�realmTZpypiz%s not found in .pypircF)Z _read_pypircr r r r! �
has_configZDEFAULT_REPOSITORY�
ValueError)r
Zconfigr r r r D s
zregister._set_configc C s* | j d }tj�|�}t�| �|�� d S )Nz?:action=list_classifiers)r �urllib�requestZurlopenr �info�_read_pypi_response)r
ZurlZresponser r r r U s
zregister.classifiersc C s& | � | �d��\}}t�d||� d S )Nr �Server response (%s): %s)�post_to_server�build_post_datar r& )r
�code�resultr r r r \ s zregister.verify_metadatac
C s� | j rd}| j}| j}n d}d }}d�� }||krd| �dtj� t� }|sRd}q,||kr,td� q,|dk�rl|s|td�}qn|s�t � d�}q|t
j � � }t
j
�| j�d }|�| j|||� | �| �d
�|�\}}| �d ||f tj� |d k�r�| j �r|| j_nf| �d
tj� | �d| �� tj� d}|�� dk�rNtd�}|�s*d}�q*|�� dk�r�| �||� �nl|dk�r�ddi} d | d< | d< | d< d | d< | d �s�td�| d< �q�| d | d k�r0| d �s�t � d�| d< �q�| d �st � d�| d< �q�| d | d k�r�d| d< d | d< td � �q�| d �sJtd �| d< �q0| �| �\}}|d k�rrt�d ||� nt�d � t�d � nP|d k�r�dd!i} d| d< | d �s�td"�| d< �q�| �| �\}}t�d ||� d S )#N�1�x� z1 2 3 4z�We need to know who you are, so please choose either:
1. use your existing login,
2. register as a new user,
3. have the server generate a new password for you (and email it to you), or
4. quit
Your selection [default 1]: z&Please choose one of the four options!z
Username: z
Password: r Zsubmitr( �� zAI can store your PyPI login so future submissions will be faster.z (the login will be stored in %s)�XZynzSave your login (y/N)?�n�y�2�:action�user�namer ZemailZconfirmz
Confirm: z!Password and confirm don't match!z
EMail: z"You will receive an email shortly.z7Follow the instructions in it to complete registration.�3Zpassword_resetzYour email address: )r" r r �split�announcer �INFO�input�print�getpassr$ r% ZHTTPPasswordMgr�parseZurlparser Z add_passwordr! r) r* r Z _get_rc_file�lowerZ
_store_pypircr& )
r
Zchoicer r �choices�authZhostr+ r, �datar r r r c s� �
��
���
zregister.send_metadatac C s� | j j}|d|�� |�� |�� |�� |�� |�� |�� |� � |�
� |� � |� � |�
� |�� |�� |�� d�}|d s�|d s�|d r�d|d< |S )Nz1.0)r5 �metadata_versionr7 �versionZsummaryZ home_pageZauthorZ author_email�license� description�keywords�platformr Z download_url�provides�requires� obsoletesrJ rK rL z1.1rD )r ZmetadataZget_nameZ get_versionZget_descriptionZget_urlZ get_contactZget_contact_emailZ get_licenceZget_long_descriptionZ get_keywordsZ
get_platformsZget_classifiersZget_download_urlZ get_providesZ get_requiresZ
get_obsoletes)r
�action�metarC r r r r* � s, �zregister.build_post_dataNc
C s� d|kr$| � d|d | jf tj� d}d| }|d }t�� }|�� D ]~\}}t|�tg �td�fkrn|g}|D ]R}t|�}|� |� |� d| � |� d� |� |� |rr|d d
krr|� d � qrqH|� |� |� d � |�
� � d �}d
| tt |��d�} t
j�| j|| �}
t
j�t
jj|d��} d}z| �|
�} W nx t
jjk
�r� }
z"| j�rd|
j�� }|
j|
jf} W 5 d }
~
X Y nJ t
jjk
�r� }
zdt|
�f} W 5 d }
~
X Y nX | j�r�| �| �}d} | j�r�d � d|df�}| � |tj� | S )Nr7 zRegistering %s to %sz3--------------GHSKFJDLGDS7543FJKLFHRE75642756743254z
--z--r z*
Content-Disposition: form-data; name="%s"z
����
�
zutf-8z/multipart/form-data; boundary=%s; charset=utf-8)z Content-typezContent-length)Z password_mgrr/ i� )r0 ZOKzK---------------------------------------------------------------------------) r: r r r; �io�StringIO�items�type�str�write�getvalue�encode�lenr$ r% ZRequestZ build_openerZHTTPBasicAuthHandler�open�errorZ HTTPErrorZ
show_response�fp�readr+ �msgZURLErrorr' �join)r
rC rB �boundaryZ sep_boundaryZ end_boundaryZbody�key�valueZheadersZreqZopenerr, �er_ r r r r) � s^ ��
� �
zregister.post_to_server)N)�__name__�
__module__� __qualname__rG r Z user_optionsZboolean_optionsZ sub_commandsr r r r r r r r r* r) r r r r r s* � �
z r )
r> rR Z urllib.parser$ Zurllib.request�warningsr Zdistutils.corer Zdistutils.errorsZ distutilsr r r r r r �<module> s __pycache__/install_headers.cpython-38.pyc 0000644 00000003256 15051366003 0014552 0 ustar 00 U
e5d � @ s$ d Z ddlmZ G dd� de�ZdS )z�distutils.command.install_headers
Implements the Distutils 'install_headers' command, to install C/C++ header
files to the Python include directory.� )�Commandc @ sF e Zd ZdZddgZdgZdd� Zdd� Zd d
� Zd d � Z d
d� Z
dS )�install_headerszinstall C/C++ header files)z install-dir=�dz$directory to install header files to)�force�fz-force installation (overwrite existing files)r c C s d | _ d| _g | _d S )Nr )� install_dirr �outfiles��self� r �9/usr/lib64/python3.8/distutils/command/install_headers.py�initialize_options s z"install_headers.initialize_optionsc C s | � ddd� d S )NZinstall)r r )r r )Zset_undefined_optionsr r r r �finalize_options s �z install_headers.finalize_optionsc C sH | j j}|sd S | �| j� |D ]"}| �|| j�\}}| j�|� q d S �N)� distribution�headersZmkpathr Z copy_filer �append)r
r �header�out�_r r r �run! s zinstall_headers.runc C s | j jp
g S r )r r r r r r �
get_inputs+ s zinstall_headers.get_inputsc C s | j S r )r r r r r � get_outputs. s zinstall_headers.get_outputsN) �__name__�
__module__� __qualname__Z descriptionZ user_optionsZboolean_optionsr
r r r r r r r r r
s �
r N)�__doc__Zdistutils.corer r r r r r �<module> s __pycache__/install_lib.cpython-38.opt-1.pyc 0000644 00000011773 15051366003 0014647 0 ustar 00 U
e5d� � @ sL d Z ddlZddlZddlZddlmZ ddlmZ dZ G dd� de�Z
dS )zkdistutils.command.install_lib
Implements the Distutils 'install_lib' command
(install all Python modules).� N)�Command)�DistutilsOptionErrorz.pyc @ s� e Zd ZdZdddddddgZd d
d gZd d
iZd
d� Zdd� Zdd� Z dd� Z
dd� Z dd� Z dd� Z
dd � Zd d � Zd d � Zd!S )"� install_libz7install all Python modules (extensions and pure Python))z install-dir=�dzdirectory to install to)z
build-dir=�bz'build directory (where to install from))�force�fz-force installation (overwrite existing files))�compile�cz compile .py to .pyc [default])�
no-compileNzdon't compile .py files)z optimize=�Ozlalso compile with optimization: -O1 for "python -O", -O2 for "python -OO", and -O0 to disable [default: -O0])�
skip-buildNzskip the build stepsr r r
r c C s( d | _ d | _d| _d | _d | _d | _d S )Nr )� install_dir� build_dirr r �optimize�
skip_build��self� r �5/usr/lib64/python3.8/distutils/command/install_lib.py�initialize_options3 s z install_lib.initialize_optionsc C s� | � ddddddd� | jd kr&d| _| jd kr6d | _t| jt�s�z t| j�| _| jd
kr^t�W n ttfk
r� td ��Y nX d S ) N�install)� build_libr )r r )r r )r r )r r )r r TF)r � � zoptimize must be 0, 1, or 2)Zset_undefined_optionsr r �
isinstance�int�AssertionError�
ValueErrorr r r r r �finalize_options< s& �
z install_lib.finalize_optionsc C s0 | � � | �� }|d k r,| j�� r,| �|� d S �N)�buildr � distribution�has_pure_modules� byte_compile�r Zoutfilesr r r �runV s zinstall_lib.runc C s2 | j s.| j�� r| �d� | j�� r.| �d� d S )N�build_py� build_ext)r r" r# Z run_command�has_ext_modulesr r r r r! f s
zinstall_lib.buildc C s8 t j�| j�r | �| j| j�}n| �d| j � d S |S )Nz3'%s' does not exist -- no Python modules to install)�os�path�isdirr Z copy_treer �warnr% r r r r m s �zinstall_lib.installc C sr t jr| �d� d S ddlm} | �d�j}| jrH||d| j|| j d� | j
dkrn||| j
| j|| j | j d� d S )Nz%byte-compiling is disabled, skipping.r )r$ r )r r �prefix�dry_run)r r r. �verboser/ ) �sys�dont_write_bytecoder- Zdistutils.utilr$ �get_finalized_command�rootr r r/ r r0 )r �filesr$ Z install_rootr r r r$ v s$
�
�zinstall_lib.byte_compilec
C sd |sg S | � |�}|�� }t||�}t|�ttj� }g }|D ] } |�tj�|| |d � �� q>|S r ) r3 � get_outputs�getattr�lenr* �sep�appendr+ �join)
r Zhas_anyZ build_cmdZ
cmd_optionZ
output_dirZ build_filesr �
prefix_lenZoutputs�filer r r �_mutate_outputs� s
zinstall_lib._mutate_outputsc C sr g }|D ]d}t j�t j�|��d }|tkr.q| jrJ|�tjj |dd�� | j
dkr|�tjj || j
d�� q|S )Nr � )� optimizationr ) r* r+ �splitext�normcase�PYTHON_SOURCE_EXTENSIONr r: � importlib�util�cache_from_sourcer )r Z py_filenamesZbytecode_filesZpy_fileZextr r r �_bytecode_filenames� s
�
�
z install_lib._bytecode_filenamesc C sR | � | j�� dd| j�}| jr*| �|�}ng }| � | j�� dd| j�}|| | S )z�Return the list of files that would be installed if this command
were actually run. Not affected by the "dry-run" flag or whether
modules have actually been built yet.
r' r r( )r> r" r# r r rG r) )r Z pure_outputsZbytecode_outputsZ ext_outputsr r r r6 � s �� ��zinstall_lib.get_outputsc C sL g }| j �� r&| �d�}|�|�� � | j �� rH| �d�}|�|�� � |S )z�Get the list of files that are input to this command, ie. the
files that get installed as they are named in the build tree.
The files in this list correspond one-to-one to the output
filenames returned by 'get_outputs()'.
r' r( )r" r# r3 �extendr6 r) )r Zinputsr' r( r r r �
get_inputs� s
zinstall_lib.get_inputsN)�__name__�
__module__� __qualname__Z descriptionZ user_optionsZboolean_optionsZ negative_optr r r& r! r r$ r> rG r6 rI r r r r r s* �
r ) �__doc__r* �importlib.utilrD r1 Zdistutils.corer Zdistutils.errorsr rC r r r r r �<module> s __pycache__/bdist_wininst.cpython-38.opt-1.pyc 0000644 00000020351 15051366003 0015223 0 ustar 00 U
e5d�> � @ sx d Z ddlZddlZddlZddlmZ ddlmZ ddlm Z m
Z
ddl T ddl m
Z
ddlmZ G d d
� d
e�ZdS ) zzdistutils.command.bdist_wininst
Implements the Distutils 'bdist_wininst' command: create a windows installer
exe-program.� N)�Command)� get_platform)� create_tree� remove_tree)�*)�get_python_version)�logc
s� e Zd ZdZdddde� fdddd d
d d d
dddg
ZddddgZejdkZ � fdd�Z
dd� Z dd� Z d d � Z
d d � Zd'd!d"�Zd#d$� Zd%d&� Z� ZS )(�
bdist_wininstz-create an executable installer for MS Windows)z
bdist-dir=Nz1temporary directory for creating the distributionz
plat-name=�pz;platform name to embed in generated filenames (default: %s))� keep-temp�kzPkeep the pseudo-installation tree around after creating the distribution archive)ztarget-version=Nz6require a specific python version on the target system)�no-target-compile�cz/do not compile .py to .pyc on the target system)�no-target-optimize�oz;do not compile .py to .pyo (optimized) on the target system)z dist-dir=�dz-directory to put final built distributions in)zbitmap=�bz>bitmap to use for the installer instead of python-powered logo)ztitle=�tz?title to display on the installer background instead of default)�
skip-buildNz2skip rebuilding everything (for testing/debugging))zinstall-script=NzUbasename of installation script to be run after installation or before deinstallation)zpre-install-script=Nz{Fully qualified filename of a script to be run before any files are installed. This script need not be in the distribution)zuser-access-control=Nz�specify Vista's UAC handling - 'none'/default=no handling, 'auto'=use UAC if target Python installed for all users, 'force'=always use UACr r
r r �win32c s t � j||� t�dtd� d S )Nz^bdist_wininst command is deprecated since Python 3.8, use bdist_wheel (wheel packages) instead� )�super�__init__�warnings�warn�DeprecationWarning)�self�args�kw�� __class__� �7/usr/lib64/python3.8/distutils/command/bdist_wininst.pyr ? s
�zbdist_wininst.__init__c C sR d | _ d | _d| _d| _d| _d | _d | _d | _d | _d | _ d | _
d | _ d | _ d S )Nr )
� bdist_dir� plat_name� keep_temp�no_target_compile�no_target_optimize�target_version�dist_dir�bitmap�title�
skip_build�install_script�pre_install_script�user_access_control)r r! r! r" �initialize_optionsE s z bdist_wininst.initialize_optionsc C s� | � dd� | jd krR| jr6| jr6| j�d�}| j|_| �d�j}tj �
|d�| _| j s^d| _ | js�| j� � r�t
� }| j r�| j |kr�td|f ��|| _ | � ddd� | jr�| jjD ]}| jtj �|�kr� q�q�td| j ��d S ) N�bdist)r, r, Zwininst� zMtarget version can only be %s, or the '--skip-build' option must be specified)r) r) )r$ r$ z(install_script '%s' not found in scripts)Zset_undefined_optionsr# r, r$ � distributionZget_command_obj�get_finalized_command�
bdist_base�os�path�joinr( �has_ext_modulesr ZDistutilsOptionErrorr- �scripts�basename)r r1 r5 Z
short_version�scriptr! r! r" �finalize_optionsU s>
��� ��z bdist_wininst.finalize_optionsc
C s� t jdkr&| j�� s | j�� r&td��| js6| �d� | jddd�}| j |_
| j|_d|_ | j |_ | �d�}d|_
d|_| j�� r�| j}|s�d t jd d
� }d | j |f }| �d�}tj�|jd | �|_d
D ],}|�� }|dkr�|d }t|d| |� q�t�d| j � |�� t j� dtj�| j d�� |� � t jd= ddl m } |� } | j� � }
| j!| d| j d�} | �"| |
| j#� | j�� �r�t$� } nd} | jj%�&d| | �'|
�f� t�(d| � t�)| � | j*�s�t+| j | j,d� d S )Nr z^distribution contains extensions and/or C libraries; must be compiled on a Windows 32 platform�build�install� )Zreinit_subcommandsr � install_libz%d.%dr z.%s-%s�lib)ZpurelibZplatlib�headersr: �datarC z/Include/$dist_nameZinstall_zinstalling to %sZPURELIB)�mktemp�zip)Zroot_dir�anyr z removing temporary file '%s')�dry_run)-�sys�platformr3 r9 Zhas_c_librariesZDistutilsPlatformErrorr, Z run_commandZreinitialize_commandr# �rootZwarn_dirr$ �compile�optimizer( � version_infor4 r6 r7 r8 Z
build_baseZ build_lib�upper�setattrr �infoZensure_finalized�insert�runZtempfilerE � get_fullnameZ make_archive�
create_exer* r Z
dist_files�append�get_installer_filename�debug�remover% r rH )
r r? rA r( Zplat_specifierr> �key�valuerE Zarchive_basename�fullname�arcnameZ pyversionr! r! r" rS { sr
���
��
� �
zbdist_wininst.runc C sZ g }| j j}|�d� |jp dd }dd� }dD ]B}t||d�}|r0|d|�� ||�f }|�d|||�f � q0|�d � | jr�|�d
| j � |�d ||� � |�d | j � |�d
| j � | j r�|�d| j � | j
r�|�d| j
� | j �p| j � � }|�d||� � dd l
}dd l} d|�|�
� �| jf }
|�d|
� d�|�S )Nz
[metadata]r2 �
c S s | � dd�S )Nr^ z\n)�replace)�sr! r! r" �escape� s z)bdist_wininst.get_inidata.<locals>.escape)ZauthorZ author_email� descriptionZ
maintainerZmaintainer_email�nameZurl�versionz
%s: %sz%s=%sz
[Setup]zinstall_script=%szinfo=%sztarget_compile=%dztarget_optimize=%dztarget_version=%szuser_access_control=%sztitle=%sr zBuilt %s with distutils-%sz
build_info=%s)r3 �metadatarV Zlong_description�getattr�
capitalizer- r& r' r( r/ r+ rT �time� distutils�ctime� __version__r8 ) r �linesre rQ ra rc rD r+ rh ri Z
build_infor! r! r" � get_inidata� s>
�
�zbdist_wininst.get_inidataNc
C sH dd l }| �| j� | �� }| �|�}| �d| � |r`t|d��}|�� }W 5 Q R X t|�} nd} t|d���}
|
� | �
� � |r�|
� |� t |t �r�|�
d�}|d }| jr�t| jddd ��} | �� �
d�} W 5 Q R X || d
}n|d }|
� |� |�d d t|�| �}
|
� |
� t|d��}|
� |�� � W 5 Q R X W 5 Q R X d S )
Nr z creating %s�rb�wb�mbcs� �rzlatin-1)�encodings
z<iiii{V4)�structZmkpathr) rm rW Zannounce�open�read�len�write�
get_exe_bytes�
isinstance�str�encoder. Zpack)r r] r\ r* rt Zcfgdata�installer_name�fZ
bitmapdataZ bitmaplen�filer< Z script_data�headerr! r! r" rU � sD
�
�
zbdist_wininst.create_exec C sD | j r&tj�| jd|| j| j f �}ntj�| jd|| jf �}|S )Nz%s.%s-py%s.exez %s.%s.exe)r( r6 r7 r8 r) r$ )r r\ r} r! r! r" rW 1 s
��
�z$bdist_wininst.get_installer_filenamec C s$ t � }| jrl| j|k rl| jdk r&d}q�| jdkr6d}q�| jdkrFd}q�| jdkrVd}q�| jdkrfd }q�d
}n@zd d lm} W n tk
r� d
}Y nX |�d
�d }|d }tj�t �}| j
dkr�| j
d d� dkr�| j
dd � }nd}tj� |d||f �}t |d�}z |�� W �S |�
� X d S )Nz2.4z6.0z7.1z2.5z8.0z3.2z9.0z3.4z10.0z14.0r )�CRT_ASSEMBLY_VERSION�.z.0r � �winr2 zwininst-%s%s.exern )r r( Zmsvcrtr� � ImportError� partitionr6 r7 �dirname�__file__r$ r8 ru �closerv ) r Z cur_versionZbvr� �majorZ directoryZsfix�filenamer~ r! r! r" ry > s8
zbdist_wininst.get_exe_bytes)N)�__name__�
__module__� __qualname__rb r Z user_optionsZboolean_optionsrI rJ Z _unsupportedr r0 r= rS rm rU rW ry �
__classcell__r! r! r r" r s> ���%�
&Q.
7
r )�__doc__r6 rI r Zdistutils.corer Zdistutils.utilr Zdistutils.dir_utilr r Zdistutils.errorsZdistutils.sysconfigr ri r r r! r! r! r" �<module> s __pycache__/bdist_dumb.cpython-38.opt-1.pyc 0000644 00000007012 15051366003 0014456 0 ustar 00 U
e5d1 � @ sh d Z ddlZddlmZ ddlmZ ddlmZmZ ddl T ddl
m Z ddl m
Z
G d d
� d
e�ZdS ) z�distutils.command.bdist_dumb
Implements the Distutils 'bdist_dumb' command (create a "dumb" built
distribution -- i.e., just an archive to be unpacked under $prefix or
$exec_prefix).� N)�Command)� get_platform)� remove_tree�ensure_relative)�*)�get_python_version)�logc @ s^ e Zd ZdZdddde� fdddd d
d d g Zd
ddgZddd�Zdd� Zdd� Z dd� Z
dS )�
bdist_dumbz"create a "dumb" built distribution)z
bdist-dir=�dz1temporary directory for creating the distributionz
plat-name=�pz;platform name to embed in generated filenames (default: %s))zformat=�fz>archive format to create (tar, gztar, bztar, xztar, ztar, zip))� keep-temp�kzPkeep the pseudo-installation tree around after creating the distribution archive)z dist-dir=r
z-directory to put final built distributions in)�
skip-buildNz2skip rebuilding everything (for testing/debugging))�relativeNz7build the archive using relative paths (default: false))zowner=�uz@Owner name used when creating a tar file [default: current user])zgroup=�gzAGroup name used when creating a tar file [default: current group]r
r r Zgztar�zip)�posix�ntc C s: d | _ d | _d | _d| _d | _d | _d| _d | _d | _d S )Nr ) � bdist_dir� plat_name�format� keep_temp�dist_dir�
skip_buildr �owner�group)�self� r �4/usr/lib64/python3.8/distutils/command/bdist_dumb.py�initialize_options2 s z bdist_dumb.initialize_optionsc C sz | j d kr&| �d�j}tj�|d�| _ | jd krfz| jtj | _W n" t k
rd t
dtj ��Y nX | � dddd� d S )NZbdistZdumbz@don't know how to create dumb built distributions on platform %s)r r )r r )r r ) r Zget_finalized_command�
bdist_base�os�path�joinr �default_format�name�KeyError�DistutilsPlatformErrorZset_undefined_options)r r" r r r �finalize_options= s"
��
�zbdist_dumb.finalize_optionsc C s( | j s| �d� | jddd�}| j|_| j |_ d|_t�d| j� | �d� d| j� � | j
f }t j �
| j|�}| js~| j}nJ| j�� r�|j|jkr�tdt|j�t|j�f ��nt j �
| jt|j��}| j|| j|| j| jd �}| j�� r�t� }nd
}| jj� d ||f� | j �s$t | j| j d � d S )
NZbuild�install� )Zreinit_subcommandsr zinstalling to %sz%s.%szScan't make a dumb built distribution where base and platbase are different (%s, %s))Zroot_dirr r �anyr )�dry_run) r Z run_commandZreinitialize_commandr �rootZwarn_dirr �infoZ distributionZ get_fullnamer r# r$ r% r r Zhas_ext_modulesZ install_baseZinstall_platbaser) �reprr Z make_archiver r r r Z
dist_files�appendr r r. )r r+ Zarchive_basenameZpseudoinstall_rootZ archive_root�filenameZ pyversionr r r �runO sR
�
����
� �
�zbdist_dumb.runN) �__name__�
__module__� __qualname__Z descriptionr Z user_optionsZboolean_optionsr& r! r* r4 r r r r r s, ���
� r )�__doc__r# Zdistutils.corer Zdistutils.utilr Zdistutils.dir_utilr r Zdistutils.errorsZdistutils.sysconfigr Z distutilsr r r r r r �<module> s __pycache__/install_lib.cpython-38.pyc 0000644 00000011773 15051366003 0013710 0 ustar 00 U
e5d� � @ sL d Z ddlZddlZddlZddlmZ ddlmZ dZ G dd� de�Z
dS )zkdistutils.command.install_lib
Implements the Distutils 'install_lib' command
(install all Python modules).� N)�Command)�DistutilsOptionErrorz.pyc @ s� e Zd ZdZdddddddgZd d
d gZd d
iZd
d� Zdd� Zdd� Z dd� Z
dd� Z dd� Z dd� Z
dd � Zd d � Zd d � Zd!S )"� install_libz7install all Python modules (extensions and pure Python))z install-dir=�dzdirectory to install to)z
build-dir=�bz'build directory (where to install from))�force�fz-force installation (overwrite existing files))�compile�cz compile .py to .pyc [default])�
no-compileNzdon't compile .py files)z optimize=�Ozlalso compile with optimization: -O1 for "python -O", -O2 for "python -OO", and -O0 to disable [default: -O0])�
skip-buildNzskip the build stepsr r r
r c C s( d | _ d | _d| _d | _d | _d | _d S )Nr )� install_dir� build_dirr r �optimize�
skip_build��self� r �5/usr/lib64/python3.8/distutils/command/install_lib.py�initialize_options3 s z install_lib.initialize_optionsc C s� | � ddddddd� | jd kr&d| _| jd kr6d | _t| jt�s�z t| j�| _| jd
kr^t�W n ttfk
r� td ��Y nX d S ) N�install)� build_libr )r r )r r )r r )r r )r r TF)r � � zoptimize must be 0, 1, or 2)Zset_undefined_optionsr r �
isinstance�int�AssertionError�
ValueErrorr r r r r �finalize_options< s& �
z install_lib.finalize_optionsc C s0 | � � | �� }|d k r,| j�� r,| �|� d S �N)�buildr � distribution�has_pure_modules� byte_compile�r Zoutfilesr r r �runV s zinstall_lib.runc C s2 | j s.| j�� r| �d� | j�� r.| �d� d S )N�build_py� build_ext)r r" r# Z run_command�has_ext_modulesr r r r r! f s
zinstall_lib.buildc C s8 t j�| j�r | �| j| j�}n| �d| j � d S |S )Nz3'%s' does not exist -- no Python modules to install)�os�path�isdirr Z copy_treer �warnr% r r r r m s �zinstall_lib.installc C sr t jr| �d� d S ddlm} | �d�j}| jrH||d| j|| j d� | j
dkrn||| j
| j|| j | j d� d S )Nz%byte-compiling is disabled, skipping.r )r$ r )r r �prefix�dry_run)r r r. �verboser/ ) �sys�dont_write_bytecoder- Zdistutils.utilr$ �get_finalized_command�rootr r r/ r r0 )r �filesr$ Z install_rootr r r r$ v s$
�
�zinstall_lib.byte_compilec
C sd |sg S | � |�}|�� }t||�}t|�ttj� }g }|D ] } |�tj�|| |d � �� q>|S r ) r3 � get_outputs�getattr�lenr* �sep�appendr+ �join)
r Zhas_anyZ build_cmdZ
cmd_optionZ
output_dirZ build_filesr �
prefix_lenZoutputs�filer r r �_mutate_outputs� s
zinstall_lib._mutate_outputsc C sr g }|D ]d}t j�t j�|��d }|tkr.q| jrJ|�tjj |dd�� | j
dkr|�tjj || j
d�� q|S )Nr � )� optimizationr ) r* r+ �splitext�normcase�PYTHON_SOURCE_EXTENSIONr r: � importlib�util�cache_from_sourcer )r Z py_filenamesZbytecode_filesZpy_fileZextr r r �_bytecode_filenames� s
�
�
z install_lib._bytecode_filenamesc C sR | � | j�� dd| j�}| jr*| �|�}ng }| � | j�� dd| j�}|| | S )z�Return the list of files that would be installed if this command
were actually run. Not affected by the "dry-run" flag or whether
modules have actually been built yet.
r' r r( )r> r" r# r r rG r) )r Z pure_outputsZbytecode_outputsZ ext_outputsr r r r6 � s �� ��zinstall_lib.get_outputsc C sL g }| j �� r&| �d�}|�|�� � | j �� rH| �d�}|�|�� � |S )z�Get the list of files that are input to this command, ie. the
files that get installed as they are named in the build tree.
The files in this list correspond one-to-one to the output
filenames returned by 'get_outputs()'.
r' r( )r" r# r3 �extendr6 r) )r Zinputsr' r( r r r �
get_inputs� s
zinstall_lib.get_inputsN)�__name__�
__module__� __qualname__Z descriptionZ user_optionsZboolean_optionsZ negative_optr r r& r! r r$ r> rG r6 rI r r r r r s* �
r ) �__doc__r* �importlib.utilrD r1 Zdistutils.corer Zdistutils.errorsr rC r r r r r �<module> s __pycache__/bdist_wininst.cpython-38.opt-2.pyc 0000644 00000020136 15051366003 0015225 0 ustar 00 U
e5d�> � @ st d dl Z d dlZd dlZd dlmZ d dlmZ d dlmZm Z d dl
T d dl m Z d dl
mZ G dd � d e�ZdS )
� N)�Command)� get_platform)� create_tree� remove_tree)�*)�get_python_version)�logc
s� e Zd ZdZdddde� fdddd d
d d d
dddg
ZddddgZejdkZ � fdd�Z
dd� Z dd� Z d d � Z
d d � Zd'd!d"�Zd#d$� Zd%d&� Z� ZS )(�
bdist_wininstz-create an executable installer for MS Windows)z
bdist-dir=Nz1temporary directory for creating the distributionz
plat-name=�pz;platform name to embed in generated filenames (default: %s))� keep-temp�kzPkeep the pseudo-installation tree around after creating the distribution archive)ztarget-version=Nz6require a specific python version on the target system)�no-target-compile�cz/do not compile .py to .pyc on the target system)�no-target-optimize�oz;do not compile .py to .pyo (optimized) on the target system)z dist-dir=�dz-directory to put final built distributions in)zbitmap=�bz>bitmap to use for the installer instead of python-powered logo)ztitle=�tz?title to display on the installer background instead of default)�
skip-buildNz2skip rebuilding everything (for testing/debugging))zinstall-script=NzUbasename of installation script to be run after installation or before deinstallation)zpre-install-script=Nz{Fully qualified filename of a script to be run before any files are installed. This script need not be in the distribution)zuser-access-control=Nz�specify Vista's UAC handling - 'none'/default=no handling, 'auto'=use UAC if target Python installed for all users, 'force'=always use UACr r
r r �win32c s t � j||� t�dtd� d S )Nz^bdist_wininst command is deprecated since Python 3.8, use bdist_wheel (wheel packages) instead� )�super�__init__�warnings�warn�DeprecationWarning)�self�args�kw�� __class__� �7/usr/lib64/python3.8/distutils/command/bdist_wininst.pyr ? s
�zbdist_wininst.__init__c C sR d | _ d | _d| _d| _d| _d | _d | _d | _d | _d | _ d | _
d | _ d | _ d S )Nr )
� bdist_dir� plat_name� keep_temp�no_target_compile�no_target_optimize�target_version�dist_dir�bitmap�title�
skip_build�install_script�pre_install_script�user_access_control)r r! r! r" �initialize_optionsE s z bdist_wininst.initialize_optionsc C s� | � dd� | jd krR| jr6| jr6| j�d�}| j|_| �d�j}tj �
|d�| _| j s^d| _ | js�| j� � r�t
� }| j r�| j |kr�td|f ��|| _ | � ddd� | jr�| jjD ]}| jtj �|�kr� q�q�td| j ��d S ) N�bdist)r, r, Zwininst� zMtarget version can only be %s, or the '--skip-build' option must be specified)r) r) )r$ r$ z(install_script '%s' not found in scripts)Zset_undefined_optionsr# r, r$ � distributionZget_command_obj�get_finalized_command�
bdist_base�os�path�joinr( �has_ext_modulesr ZDistutilsOptionErrorr- �scripts�basename)r r1 r5 Z
short_version�scriptr! r! r" �finalize_optionsU s>
��� ��z bdist_wininst.finalize_optionsc
C s� t jdkr&| j�� s | j�� r&td��| js6| �d� | jddd�}| j |_
| j|_d|_ | j |_ | �d�}d|_
d|_| j�� r�| j}|s�d t jd d
� }d | j |f }| �d�}tj�|jd | �|_d
D ],}|�� }|dkr�|d }t|d| |� q�t�d| j � |�� t j� dtj�| j d�� |� � t jd= ddl m } |� } | j� � }
| j!| d| j d�} | �"| |
| j#� | j�� �r�t$� } nd} | jj%�&d| | �'|
�f� t�(d| � t�)| � | j*�s�t+| j | j,d� d S )Nr z^distribution contains extensions and/or C libraries; must be compiled on a Windows 32 platform�build�install� )Zreinit_subcommandsr � install_libz%d.%dr z.%s-%s�lib)ZpurelibZplatlib�headersr: �datarC z/Include/$dist_nameZinstall_zinstalling to %sZPURELIB)�mktemp�zip)Zroot_dir�anyr z removing temporary file '%s')�dry_run)-�sys�platformr3 r9 Zhas_c_librariesZDistutilsPlatformErrorr, Z run_commandZreinitialize_commandr# �rootZwarn_dirr$ �compile�optimizer( � version_infor4 r6 r7 r8 Z
build_baseZ build_lib�upper�setattrr �infoZensure_finalized�insert�runZtempfilerE � get_fullnameZ make_archive�
create_exer* r Z
dist_files�append�get_installer_filename�debug�remover% r rH )
r r? rA r( Zplat_specifierr> �key�valuerE Zarchive_basename�fullname�arcnameZ pyversionr! r! r" rS { sr
���
��
� �
zbdist_wininst.runc C sZ g }| j j}|�d� |jp dd }dd� }dD ]B}t||d�}|r0|d|�� ||�f }|�d|||�f � q0|�d � | jr�|�d
| j � |�d ||� � |�d | j � |�d
| j � | j r�|�d| j � | j
r�|�d| j
� | j �p| j � � }|�d||� � dd l
}dd l} d|�|�
� �| jf }
|�d|
� d�|�S )Nz
[metadata]r2 �
c S s | � dd�S )Nr^ z\n)�replace)�sr! r! r" �escape� s z)bdist_wininst.get_inidata.<locals>.escape)ZauthorZ author_email� descriptionZ
maintainerZmaintainer_email�nameZurl�versionz
%s: %sz%s=%sz
[Setup]zinstall_script=%szinfo=%sztarget_compile=%dztarget_optimize=%dztarget_version=%szuser_access_control=%sztitle=%sr zBuilt %s with distutils-%sz
build_info=%s)r3 �metadatarV Zlong_description�getattr�
capitalizer- r& r' r( r/ r+ rT �time� distutils�ctime� __version__r8 ) r �linesre rQ ra rc rD r+ rh ri Z
build_infor! r! r" � get_inidata� s>
�
�zbdist_wininst.get_inidataNc
C sH dd l }| �| j� | �� }| �|�}| �d| � |r`t|d��}|�� }W 5 Q R X t|�} nd} t|d���}
|
� | �
� � |r�|
� |� t |t �r�|�
d�}|d }| jr�t| jddd ��} | �� �
d�} W 5 Q R X || d
}n|d }|
� |� |�d d t|�| �}
|
� |
� t|d��}|
� |�� � W 5 Q R X W 5 Q R X d S )
Nr z creating %s�rb�wb�mbcs� �rzlatin-1)�encodings
z<iiii{V4)�structZmkpathr) rm rW Zannounce�open�read�len�write�
get_exe_bytes�
isinstance�str�encoder. Zpack)r r] r\ r* rt Zcfgdata�installer_name�fZ
bitmapdataZ bitmaplen�filer< Z script_data�headerr! r! r" rU � sD
�
�
zbdist_wininst.create_exec C sD | j r&tj�| jd|| j| j f �}ntj�| jd|| jf �}|S )Nz%s.%s-py%s.exez %s.%s.exe)r( r6 r7 r8 r) r$ )r r\ r} r! r! r" rW 1 s
��
�z$bdist_wininst.get_installer_filenamec C s$ t � }| jrl| j|k rl| jdk r&d}q�| jdkr6d}q�| jdkrFd}q�| jdkrVd}q�| jdkrfd }q�d
}n@zd d lm} W n tk
r� d
}Y nX |�d
�d }|d }tj�t �}| j
dkr�| j
d d� dkr�| j
dd � }nd}tj� |d||f �}t |d�}z |�� W �S |�
� X d S )Nz2.4z6.0z7.1z2.5z8.0z3.2z9.0z3.4z10.0z14.0r )�CRT_ASSEMBLY_VERSION�.z.0r � �winr2 zwininst-%s%s.exern )r r( Zmsvcrtr� � ImportError� partitionr6 r7 �dirname�__file__r$ r8 ru �closerv ) r Z cur_versionZbvr� �majorZ directoryZsfix�filenamer~ r! r! r" ry > s8
zbdist_wininst.get_exe_bytes)N)�__name__�
__module__� __qualname__rb r Z user_optionsZboolean_optionsrI rJ Z _unsupportedr r0 r= rS rm rU rW ry �
__classcell__r! r! r r" r s> ���%�
&Q.
7
r )r6 rI r Zdistutils.corer Zdistutils.utilr Zdistutils.dir_utilr r Zdistutils.errorsZdistutils.sysconfigr ri r r r! r! r! r" �<module> s __pycache__/install_egg_info.cpython-38.opt-1.pyc 0000644 00000005666 15051366003 0015662 0 ustar 00 U
e5d+
� @ sd d Z ddlmZ ddlmZmZ ddlZddlZddlZG dd� de�Z dd� Z
d d
� Z d d � Z dS )
z�distutils.command.install_egg_info
Implements the Distutils 'install_egg_info' command, for installing
a package's PKG-INFO metadata.� )�Command)�log�dir_utilNc @ s: e Zd ZdZdZdgZdd� Zdd� Zdd � Zd
d � Z d S )
�install_egg_infoz)Install an .egg-info file for the packagez8Install package's PKG-INFO metadata as an .egg-info file)z install-dir=�dzdirectory to install toc C s
d | _ d S �N)� install_dir��self� r �:/usr/lib64/python3.8/distutils/command/install_egg_info.py�initialize_options s z#install_egg_info.initialize_optionsc C sb | � dd� dtt| j�� ��tt| j�� ��ftjd d� � }t j
� | j |�| _
| j
g| _d S )NZ install_lib)r r z%s-%s-py%d.%d.egg-info� )Zset_undefined_options� to_filename� safe_name� distributionZget_name� safe_versionZ get_version�sys� version_info�os�path�joinr �target�outputs)r
�basenamer r r �finalize_options s � �z!install_egg_info.finalize_optionsc C s� | j }tj�|�r0tj�|�s0tj|| jd� nNtj�|�rV| � tj
| j fd| � n(tj�| j �s~| � tj | j fd| j � t
�d|� | js�t|ddd��}| jj�|� W 5 Q R X d S )N)�dry_runz Removing z Creating z
Writing %s�wzUTF-8)�encoding)r r r �isdir�islinkr Z remove_treer �existsZexecute�unlinkr �makedirsr �info�openr ZmetadataZwrite_pkg_file)r
r �fr r r �run s � zinstall_egg_info.runc C s | j S r )r r r r r � get_outputs. s z install_egg_info.get_outputsN)
�__name__�
__module__� __qualname__�__doc__Z descriptionZ user_optionsr
r r' r( r r r r r s �
r c C s t �dd| �S )z�Convert an arbitrary string to a standard distribution name
Any runs of non-alphanumeric/. characters are replaced with a single '-'.
�[^A-Za-z0-9.]+�-)�re�sub��namer r r r 6 s r c C s | � dd�} t�dd| �S )z�Convert an arbitrary string to a standard version string
Spaces become dots, and all other non-alphanumeric characters become
dashes, with runs of multiple dashes condensed to a single dash.
� �.r- r. )�replacer/ r0 )�versionr r r r > s r c C s | � dd�S )z|Convert a project or version name to its filename-escaped form
Any '-' characters are currently replaced with '_'.
r. �_)r5 r1 r r r r H s r )
r, Z
distutils.cmdr Z distutilsr r r r r/ r r r r r r r r �<module> s +
__pycache__/sdist.cpython-38.opt-1.pyc 0000644 00000034266 15051366003 0013503 0 ustar 00 U
e5d=J � @ s� d Z ddlZddlZddlmZ ddlmZ ddlmZ ddlm Z ddlm
Z
ddlm Z dd l m
Z
dd
lmZ dd lmZ dd lmZ dd
lmZmZ dd� ZG dd� de�ZdS )zadistutils.command.sdist
Implements the Distutils 'sdist' command (create a source distribution).� N)�glob)�warn)�Command)�dir_util)� file_util)� archive_util)�TextFile)�FileList)�log)� convert_path)�DistutilsTemplateError�DistutilsOptionErrorc C s` ddl m} ddlm} g }|�� D ] }|�d| d|| d f� q$|�� | |��d� dS )zoPrint all possible values for the 'formats' option (used by
the "--help-formats" command-line option).
r )� FancyGetopt)�ARCHIVE_FORMATS�formats=N� z.List of available source distribution formats:)Zdistutils.fancy_getoptr Zdistutils.archive_utilr �keys�append�sortZ
print_help)r r �formats�format� r �//usr/lib64/python3.8/distutils/command/sdist.py� show_formats s
��r c @ s" e Zd ZdZdd� Zdddddd d
d d d
ddddgZddddddgZdddefgZddd�Z d efgZ
d Z d d � Z d d!� Z
d"d#� Zd$d%� Zd&d'� Zd(d)� Zed*d+� �Zd,d-� Zd.d/� Zd0d1� Zd2d3� Zd4d5� Zd6d7� Zd8d9� Zd:d;� Zd<d=� Z d>d?� Z d@dA� Z dBdC� Z dDdE� Z dFdG� Z!dHdI� Z"dS )J�sdistz6create a source distribution (tarball, zip file, etc.)c C s | j S )zYCallable used for the check sub-command.
Placed here so user_options can view it)�metadata_check��selfr r r �checking_metadata( s zsdist.checking_metadata)z template=�tz5name of manifest template file [default: MANIFEST.in])z manifest=�mz)name of manifest file [default: MANIFEST])� use-defaultsNzRinclude the default file set in the manifest [default; disable with --no-defaults])� no-defaultsNz"don't include the default file set)�pruneNz�specifically exclude files/directories that should not be distributed (build tree, RCS/CVS dirs, etc.) [default; disable with --no-prune])�no-pruneNz$don't automatically exclude anything)�
manifest-only�ozEjust regenerate the manifest and then stop (implies --force-manifest))�force-manifest�fzkforcibly regenerate the manifest and carry on as usual. Deprecated: now the manifest is always regenerated.)r Nz6formats for source distribution (comma-separated list))� keep-temp�kz@keep the distribution tree around after creating archive file(s))z dist-dir=�dzFdirectory to put the source distribution archive(s) in [default: dist])�metadata-checkNz[Ensure that all required elements of meta-data are supplied. Warn if any missing. [default])zowner=�uz@Owner name used when creating a tar file [default: current user])zgroup=�gzAGroup name used when creating a tar file [default: current group]r! r# r% r' r) r, z help-formatsNz#list available distribution formats)r" r$ �check)ZREADMEz
README.txtz
README.rstc C sT d | _ d | _d| _d| _d| _d| _dg| _d| _d | _d | _ d| _
d | _ d | _ d S )N� r Zgztar)
�template�manifest� use_defaultsr# �
manifest_onlyZforce_manifestr � keep_temp�dist_dir�
archive_filesr �owner�groupr r r r �initialize_optionse s zsdist.initialize_optionsc C sZ | j d krd| _ | jd kr d| _| �d� t�| j�}|rFtd| ��| jd krVd| _d S )NZMANIFESTz MANIFEST.inr zunknown archive format '%s'Zdist)r2 r1 Zensure_string_listr Zcheck_archive_formatsr r
r6 )r Z
bad_formatr r r �finalize_options| s
�
zsdist.finalize_optionsc C s> t � | _| �� D ]}| �|� q| �� | jr2d S | �� d S �N)r �filelistZget_sub_commandsZ run_command�
get_file_listr4 �make_distribution)r Zcmd_namer r r �run� s z sdist.runc C s* t dt� | j�d�}|�� |�� dS )zDeprecated API.zadistutils.command.sdist.check_metadata is deprecated, use the check command insteadr/ N)r �PendingDeprecationWarning� distributionZget_command_objZensure_finalizedr@ )r r/ r r r �check_metadata� s � zsdist.check_metadatac C s� t j�| j�}|s:| �� r:| �� | j�� | j�� dS |sN| � d| j � | j�
� | j rf| � � |rr| �
� | jr�| �� | j�� | j�� | �� dS )aC Figure out the list of files to include in the source
distribution, and put it in 'self.filelist'. This might involve
reading the manifest template (and writing the manifest), or just
reading the manifest, or just using the default file set -- it all
depends on the user's options.
Nz?manifest template '%s' does not exist (using default file list))�os�path�isfiler1 �_manifest_is_not_generated�
read_manifestr= r Zremove_duplicatesr �findallr3 � add_defaults�
read_templater# �prune_file_list�write_manifest)r Ztemplate_existsr r r r> � s(
�
zsdist.get_file_listc C s< | � � | �� | �� | �� | �� | �� | �� dS )a9 Add all the default files to self.filelist:
- README or README.txt
- setup.py
- test/test*.py
- all pure Python modules mentioned in setup script
- all files pointed by package_data (build_py)
- all files defined in data_files.
- all files defined as scripts.
- all C sources listed as part of extensions or C libraries
in the setup script (doesn't catch C headers!)
Warns if (README or README.txt) or setup.py are missing; everything
else is optional.
N)�_add_defaults_standards�_add_defaults_optional�_add_defaults_python�_add_defaults_data_files�_add_defaults_ext�_add_defaults_c_libs�_add_defaults_scriptsr r r r rJ � s zsdist.add_defaultsc C s: t j�| �sdS t j�| �}t j�|�\}}|t �|�kS )z�
Case-sensitive path existence check
>>> sdist._cs_path_exists(__file__)
True
>>> sdist._cs_path_exists(__file__.upper())
False
F)rD rE �exists�abspath�split�listdir)�fspathrV Z directory�filenamer r r �_cs_path_exists� s
zsdist._cs_path_existsc C s� | j | jjg}|D ]~}t|t�rj|}d}|D ]"}| �|�r,d}| j�|� qPq,|s�| �dd� |� � q| �|�r�| j�|� q| �d| � qd S )NFTz,standard file not found: should have one of z, z standard file '%s' not found)
�READMESrB Z script_name�
isinstance�tupler[ r= r r �join)r Z standards�fnZaltsZgot_itr r r rN � s"
�
z sdist._add_defaults_standardsc C s4 ddg}|D ]"}t tjjt|��}| j�|� q d S )Nz
test/test*.pyz setup.cfg)�filterrD rE rF r r= �extend)r Zoptional�pattern�filesr r r rO s z sdist._add_defaults_optionalc C s\ | � d�}| j�� r$| j�|�� � |jD ],\}}}}|D ]}| j�tj �
||�� q:q*d S )N�build_py) �get_finalized_commandrB Zhas_pure_modulesr= rb �get_source_files�
data_filesr rD rE r_ )r re ZpkgZsrc_dirZ build_dir� filenamesrZ r r r rP s
zsdist._add_defaults_pythonc C sz | j �� rv| j jD ]b}t|t�rBt|�}tj�|�rt| j �
|� q|\}}|D ]$}t|�}tj�|�rN| j �
|� qNqd S r< ) rB Zhas_data_filesrh r] �strr rD rE rF r= r )r �item�dirnameri r( r r r rQ $ s
z sdist._add_defaults_data_filesc C s( | j �� r$| �d�}| j�|�� � d S )N� build_ext)rB Zhas_ext_modulesrf r= rb rg )r rm r r r rR 5 s
zsdist._add_defaults_extc C s( | j �� r$| �d�}| j�|�� � d S )N�
build_clib)rB Zhas_c_librariesrf r= rb rg )r rn r r r rS : s
zsdist._add_defaults_c_libsc C s( | j �� r$| �d�}| j�|�� � d S )N�
build_scripts)rB Z has_scriptsrf r= rb rg )r ro r r r rT ? s
zsdist._add_defaults_scriptsc
C s� t �d| j� t| jddddddd�}zh|�� }|dkr:q�z| j�|� W q( tt fk
r� } z | �
d|j |j |f � W 5 d}~X Y q(X q(W 5 |�� X dS )z�Read and parse manifest template file named by self.template.
(usually "MANIFEST.in") The parsing and processing is done by
'self.filelist', which updates itself accordingly.
z reading manifest template '%s'r0 )Zstrip_commentsZ skip_blanksZ
join_linesZ lstrip_wsZ rstrip_wsZ
collapse_joinNz%s, line %d: %s)
r
�infor1 r �close�readliner= Zprocess_template_liner �
ValueErrorr rZ Z current_line)r r1 �line�msgr r r rK D s&
�
� zsdist.read_templatec C s� | � d�}| j�� }| jjd|jd� | jjd|d� tjdkrFd}nd}ddd d
d d d
g}d|d�|�|f }| jj|dd� dS )av Prune off branches that might slip into the file list as created
by 'read_template()', but really don't belong there:
* the build tree (typically "build")
* the release tree itself (only an issue if we ran "sdist"
previously with --keep-temp, or it aborted)
* any RCS, CVS, .svn, .hg, .git, .bzr, _darcs directories
�buildN)�prefixZwin32z/|\\�/ZRCSZCVSz\.svnz\.hgz\.gitz\.bzrZ_darcsz(^|%s)(%s)(%s).*�|r0 )Zis_regex) rf rB � get_fullnamer= Zexclude_patternZ
build_base�sys�platformr_ )r rv �base_dirZsepsZvcs_dirsZvcs_ptrnr r r rL a s
�zsdist.prune_file_listc C sX | � � r t�d| j � dS | jjdd� }|�dd� | �tj | j|fd| j � dS )z�Write the file list in 'self.filelist' (presumably as filled in
by 'add_defaults()' and 'read_template()') to the manifest file
named by 'self.manifest'.
z5not writing to manually maintained manifest file '%s'Nr z*# file GENERATED by distutils, do NOT editzwriting manifest file '%s')
rG r
rp r2 r= rd �insertZexecuter Z
write_file)r Zcontentr r r rM y s � �zsdist.write_manifestc C s< t j�| j�sdS t| j�}z |�� }W 5 |�� X |dkS )NFz+# file GENERATED by distutils, do NOT edit
)rD rE rF r2 �openrq rr )r �fpZ
first_liner r r rG � s
z sdist._manifest_is_not_generatedc C sV t �d| j� t| j��4}|D ](}|�� }|�d�s |s:q | j�|� q W 5 Q R X dS )z�Read the manifest file (named by 'self.manifest') and use it to
fill in 'self.filelist', the list of files to include in the source
distribution.
zreading manifest file '%s'�#N)r
rp r2 r �strip�
startswithr= r )r r2 rt r r r rH � s zsdist.read_manifestc C s� | � |� tj||| jd� ttd�r4d}d| }n d}d| }|sPt�d� n
t�|� |D ]<}tj �
|�s|t�d|� q^tj � ||�}| j |||d � q^| j
j�|� dS )
a� Create the directory tree that will become the source
distribution archive. All directories implied by the filenames in
'files' are created under 'base_dir', and then we hard link or copy
(if hard linking is unavailable) those files into place.
Essentially, this duplicates the developer's source tree, but in a
directory named after the distribution, containing only the files
to be distributed.
��dry_run�linkZhardzmaking hard links in %s...Nzcopying files to %s...z)no files to distribute -- empty manifest?z#'%s' not a regular file -- skipping)r� )Zmkpathr Z create_treer� �hasattrrD r
r rp rE rF r_ Z copy_filerB ZmetadataZwrite_pkg_info)r r} rd r� ru �file�destr r r �make_release_tree� s
zsdist.make_release_treec C s� | j �� }tj�| j|�}| �|| jj� g }d| j krT| j �
| j � | j � d��� | j D ]:}| j
|||| j| jd�}|�
|� | j j�
dd|f� qZ|| _| js�tj|| jd� dS )a� Create the source distribution(s). First, we create the release
tree with 'make_release_tree()'; then, we create all required
archive files (according to 'self.formats') from the release tree.
Finally, we clean up by blowing away the release tree (unless
'self.keep_temp' is true). The list of archive files created is
stored so it can be retrieved later by 'get_archive_files()'.
Ztar)r} r8 r9 r � r� N)rB rz rD rE r_ r6 r� r= rd r r �pop�indexZ make_archiver8 r9 Z
dist_filesr7 r5 r Z remove_treer� )r r} Z base_namer7 Zfmtr� r r r r? � s
�
zsdist.make_distributionc C s | j S )zzReturn the list of archive files created when the command
was run, or None if the command hasn't run yet.
)r7 r r r r �get_archive_files� s zsdist.get_archive_files)#�__name__�
__module__� __qualname__Z descriptionr Z user_optionsZboolean_optionsr Z help_optionsZ negative_optZ sub_commandsr\ r: r; r@ rC r> rJ � staticmethodr[ rN rO rP rQ rR rS rT rK rL rM rG rH r� r? r� r r r r r $ sp �' � ���
(
* r )�__doc__rD r{ r �warningsr Zdistutils.corer Z distutilsr r r Zdistutils.text_filer Zdistutils.filelistr r
Zdistutils.utilr Zdistutils.errorsr r
r r r r r r �<module> s __pycache__/build_py.cpython-38.opt-2.pyc 0000644 00000022002 15051366003 0014146 0 ustar 00 U
e5d&C � @ sv d dl Z d dlZd dlZd dlZd dlmZ d dlT d dlm Z m
Z
d dl m Z G dd� de�Z
G dd � d e
e
�ZdS )
� N)�Command)�*)� convert_path� Mixin2to3)�logc @ s� e Zd ZdZdddddgZddgZd diZd
d � Zd d
� Zdd� Z dd� Z
dd� Z dd� Z dd� Z
dd� Zdd� Zd d � Zd d � Zd d!� Zd"d#� Zd$d%� Zd2d'd(�Zd)d*� Zd+d,� Zd-d.� Zd/d0� Zd1S )3�build_pyz5"build" pure Python modules (copy to build directory))z
build-lib=�dz directory to "build" (copy) to)�compile�czcompile .py to .pyc)�
no-compileNz!don't compile .py files [default])z optimize=�Ozlalso compile with optimization: -O1 for "python -O", -O2 for "python -OO", and -O0 to disable [default: -O0])�force�fz2forcibly build everything (ignore file timestamps)r r
r c C s4 d | _ d | _d | _d | _d | _d| _d| _d | _d S )Nr )� build_lib�
py_modules�package� package_data� package_dirr �optimizer
��self� r �2/usr/lib64/python3.8/distutils/command/build_py.py�initialize_options s zbuild_py.initialize_optionsc C s� | � ddd� | jj| _| jj| _| jj| _i | _| jjr^| jj�� D ]\}}t|�| j|< qF| �� | _ t
| j t �s�zt | j �| _ W n t
tfk
r� td��Y nX d S )NZbuild)r r )r
r
zoptimize must be 0, 1, or 2)Zset_undefined_options� distribution�packagesr r r �itemsr �get_data_files�
data_files�
isinstancer �int�
ValueError�AssertionErrorZDistutilsOptionError)r �name�pathr r r �finalize_options* s$ �
zbuild_py.finalize_optionsc C s: | j r| �� | jr$| �� | �� | �| jdd�� d S �Nr )�include_bytecode)r �
build_modulesr �build_packages�build_package_data� byte_compile� get_outputsr r r r �runC s z build_py.runc s� g }| j s|S | j D ]h}| �|�}tjj| jg|�d� � }d� |rPt|�d � � fdd�| �||�D �}|� ||||f� q|S )N�.r � c s g | ]}|� d � �qS �Nr )�.0�file�Zplenr r �
<listcomp>s s z+build_py.get_data_files.<locals>.<listcomp>)
r �get_package_dir�osr$ �joinr �split�len�find_data_files�append)r �datar �src_dir� build_dir� filenamesr r3 r r a s
�zbuild_py.get_data_filesc sd | j �dg �| j �|g � }g � |D ]:}t�tj�t�|�t|���}� �� fdd�|D �� q$� S )N� c s$ g | ] }|� krt j�|�r|�qS r )r6 r$ �isfile)r1 �fn��filesr r r4 � s �z,build_py.find_data_files.<locals>.<listcomp>) r �get�globr6 r$ r7 �escaper �extend)r r r= Zglobs�patternZfilelistr rC r r: y s � zbuild_py.find_data_filesc C s` d }| j D ]P\}}}}|D ]>}tj�||�}| �tj�|�� | jtj�||�|dd� qq
d S )NF�Z
preserve_mode)r r6 r$ r7 �mkpath�dirname� copy_file)r Zlastdirr r= r> r? �filename�targetr r r r* � s �zbuild_py.build_package_datac C s� |� d�}| js&|r tjj|� S dS n�g }|r�z| jd�|� }W n* tk
rl |�d|d � |d= Y q*X |�d|� tjj|� S q*| j�d�}|d k r�|�d|� |r�tjj|� S dS d S )Nr. r@ r ���)r8 r r6 r$ r7 �KeyError�insertrE )r r r$ �tailZpdirr r r r5 � s(
zbuild_py.get_package_dirc C sj |dkr8t j�|�s td| ��t j�|�s8td| ��|rft j�|d�}t j�|�rZ|S t�d|� d S )Nr@ z%package directory '%s' does not existz>supposed package directory '%s' exists, but is not a directoryz __init__.pyz8package init file '%s' not found (or not a regular file)) r6 r$ �existsZDistutilsFileError�isdirr7 rA r �warn)r r r �init_pyr r r �
check_package� s& � �� �zbuild_py.check_packagec C s& t j�|�s t�d||� dS dS d S )Nz!file %s (for module %s) not foundFT)r6 r$ rA r rV )r �module� module_filer r r � check_module� s zbuild_py.check_modulec C s� | � ||� t�tj�t�|�d��}g }tj�| jj�}|D ]P}tj�|�}||kr�tj� tj�
|��d }|� |||f� q>| � d| � q>|S )Nz*.pyr z excluding %s)
rX rF r6 r$ r7 rG �abspathr Z script_name�splitext�basenamer; Z debug_print) r r r Z module_files�modulesZ setup_scriptr Zabs_frY r r r �find_package_modules� s z build_py.find_package_modulesc C s� i }g }| j D ]�}|�d�}d�|dd� �}|d }z|| \}}W n" tk
rh | �|�}d}Y nX |s�| �||�} |df||< | r�|�|d| f� tj�||d �}
| � ||
�s�q|�|||
f� q|S )Nr. r rP r/ �__init__�.py)
r r8 r7 rQ r5 rX r; r6 r$ r[ ) r r r_ rY r$ r Z module_baser �checkedrW rZ r r r � find_modules� s*
zbuild_py.find_modulesc C sN g }| j r|�| �� � | jrJ| jD ]$}| �|�}| �||�}|�|� q$|S r0 )r rH rd r r5 r` )r r_ r r �mr r r �find_all_modules s
zbuild_py.find_all_modulesc C s dd� | � � D �S )Nc S s g | ] }|d �qS )rP r )r1 rY r r r r4 - s z-build_py.get_source_files.<locals>.<listcomp>)rf r r r r �get_source_files, s zbuild_py.get_source_filesc C s$ |gt |� |d g }tjj|� S )Nrb )�listr6 r$ r7 )r r> r rY Z outfile_pathr r r �get_module_outfile/ s zbuild_py.get_module_outfiler/ c C s� | � � }g }|D ]p\}}}|�d�}| �| j||�}|�|� |r| jr^|�tjj|dd�� | j dkr|�tjj|| j d�� q|dd� | j
D �7 }|S )Nr. r@ )� optimizationr c S s, g | ]$\}}}}|D ]}t j�||��qqS r )r6 r$ r7 )r1 r r= r> r? rN r r r r4 B s
�z(build_py.get_outputs.<locals>.<listcomp>) rf r8 ri r r; r � importlib�util�cache_from_sourcer r )r r' r_ Zoutputsr rY rZ rN r r r r, 3 s*
�
�
�zbuild_py.get_outputsc C sb t |t�r|�d�}nt |ttf�s,td��| �| j||�}tj �
|�}| � |� | j ||dd�S )Nr. z:'package' must be a string (dot-separated), list, or tupler rJ )
r �strr8 rh �tuple� TypeErrorri r r6 r$ rL rK rM )r rY rZ r Zoutfile�dirr r r � build_moduleJ s
�
zbuild_py.build_modulec C s* | � � }|D ]\}}}| �|||� q d S r0 )rd rr )r r_ r rY rZ r r r r( Y s zbuild_py.build_modulesc C sD | j D ]8}| �|�}| �||�}|D ]\}}}| �|||� q$qd S r0 )r r5 r` rr )r r r r_ Zpackage_rY rZ r r r r) b s
zbuild_py.build_packagesc C s� t jr| �d� d S ddlm} | j}|d tjkr>|tj }| jrZ||d| j || j
d� | j dkr|||| j | j || j
d� d S )Nz%byte-compiling is disabled, skipping.r )r+ rP )r r
�prefix�dry_run) �sys�dont_write_bytecoderV �distutils.utilr+ r r6 �sepr r
rt r )r rD r+ rs r r r r+ v s&
�
�zbuild_py.byte_compileN)r/ )�__name__�
__module__� __qualname__Z descriptionZ user_optionsZboolean_optionsZ negative_optr r% r- r r: r* r5 rX r[ r` rd rf rg ri r, rr r( r) r+ r r r r r s8 �
'4
r c @ s e Zd Zdd� Zdd� ZdS )�
build_py_2to3c C sL g | _ | jr| �� | jr*| �� | �� | �| j � | �| jdd�� d S r& ) �
updated_filesr r( r r) r* Zrun_2to3r+ r, r r r r r- � s zbuild_py_2to3.runc C s, t �| |||�}|d r(| j�|d � |S )Nr/ r )r rr r} r; )r rY rZ r �resr r r rr � s zbuild_py_2to3.build_moduleN)ry rz r{ r- rr r r r r r| � s r| )r6 �importlib.utilrk ru rF Zdistutils.corer Zdistutils.errorsrw r r Z distutilsr r r| r r r r �<module> s } __pycache__/config.cpython-38.opt-2.pyc 0000644 00000015355 15051366004 0013622 0 ustar 00 U
e5d=3 � @ sh d dl Z d dlZd dlmZ d dlmZ d dlmZ d dlm Z ddd�Z
G d d
� d
e�Z d
d d �Z dS )� N)�Command)�DistutilsExecError)�customize_compiler)�logz.cz.cxx)�czc++c @ s� e Zd ZdZdddddddd d
g Zd d � Zd
d� Zdd� Zdd� Zdd� Z dd� Z
dd� Z dd� Z dd � Z
d0d d �Zd1d!d"�Zd2d#d$�Zd3d%d&�Zd4d'd(�Zd5d*d+�Zd d d g fd,d-�Zd6d.d/�Zd S )7�configzprepare to build)z compiler=Nzspecify the compiler type)zcc=Nz specify the compiler executable)z
include-dirs=�Iz.list of directories to search for header files)zdefine=�Dz C preprocessor macros to define)zundef=�Uz!C preprocessor macros to undefine)z
libraries=�lz!external C libraries to link with)z
library-dirs=�Lz.directories to search for external C libraries)�noisyNz1show every action (compile, link, run, ...) taken)z dump-sourceNz=dump generated source files before attempting to compile themc C s4 d | _ d | _d | _d | _d | _d| _d| _g | _d S )N� )�compilerZcc� include_dirs� libraries� library_dirsr
� dump_source�
temp_files��self� r �0/usr/lib64/python3.8/distutils/command/config.py�initialize_options3 s zconfig.initialize_optionsc C s� | j d kr| jj pg | _ n t| j t�r6| j �tj�| _ | jd krHg | _nt| jt�r^| jg| _| jd krpg | _n t| jt�r�| j�tj�| _d S �N) r Z distribution�
isinstance�str�split�os�pathsepr r r r r r �finalize_optionsB s
zconfig.finalize_optionsc C s d S r r r r r r �runR s z
config.runc C sz ddl m}m} t| j|�sv|| j| jdd�| _t| j� | jrN| j�| j� | j rb| j�
| j � | j rv| j� | j � d S )Nr )� CCompiler� new_compilerr )r �dry_runZforce)
�distutils.ccompilerr" r# r r r$ r r Zset_include_dirsr Z
set_librariesr Zset_library_dirs)r r" r# r r r �_check_compilerY s �
zconfig._check_compilerc C sl dt | }t|d��L}|r>|D ]}|�d| � q |�d� |�|� |d dkr^|�d� W 5 Q R X |S )NZ _configtest�wz#include <%s>
�
���)�LANG_EXT�open�write)r �body�headers�lang�filename�file�headerr r r �_gen_temp_sourcefilek s
zconfig._gen_temp_sourcefilec C s< | � |||�}d}| j�||g� | jj|||d� ||fS )Nz
_configtest.i�r )r3 r �extendr Z
preprocess)r r- r. r r/ �src�outr r r � _preprocessw s
zconfig._preprocessc C s\ | � |||�}| jr"t|d| � | j�|g�\}| j�||g� | jj|g|d� ||fS )Nzcompiling '%s':r4 )r3 r � dump_filer Zobject_filenamesr r5 �compile)r r- r. r r/ r6 �objr r r �_compile~ s zconfig._compilec
C sr | � ||||�\}}tj�tj�|��d } | jj|g| |||d� | jjd k r\| | jj } | j� | � ||| fS )Nr )r r Z target_lang)
r< r �path�splitext�basenamer Zlink_executableZ
exe_extensionr �append)
r r- r. r r r r/ r6 r; �progr r r �_link� s � z config._linkc G sT |s| j }g | _ t�dd�|�� |D ](}zt�|� W q& tk
rL Y q&X q&d S )Nz removing: %s� )r r �info�joinr �remove�OSError)r � filenamesr0 r r r �_clean� s z
config._cleanNr c C sR ddl m} | �� d}z| �||||� W n |k
rD d}Y nX | �� |S )Nr �� CompileErrorTF)r% rK r& r8 rI �r r- r. r r/ rK �okr r r �try_cpp� s
zconfig.try_cppc C sx | � � | �||||�\}}t|t�r0t�|�}t|��.}d} |�� }
|
dkrPqb|�|
�r>d} qbq>W 5 Q R X | � � | S )NF� T)
r& r8 r r �rer: r+ �readline�searchrI ) r �patternr- r. r r/ r6 r7 r1 �match�liner r r �
search_cpp� s
zconfig.search_cppc C sd ddl m} | �� z| �||||� d}W n |k
rD d}Y nX t�|rRdpTd� | �� |S )Nr rJ TF�success!�failure.)r% rK r& r< r rD rI rL r r r � try_compile� s
zconfig.try_compilec
C sp ddl m}m} | �� z | �||||||� d} W n ||fk
rP d} Y nX t�| r^dp`d� | �� | S �Nr )rK � LinkErrorTFrW rX )r% rK r[ r& rB r rD rI )
r r- r. r r r r/ rK r[ rM r r r �try_link� s
�
zconfig.try_linkc
C s� ddl m}m} | �� z.| �||||||�\} }
} | �| g� d} W n ||tfk
rd d} Y nX t�| rrdptd� | � � | S rZ )
r% rK r[ r& rB Zspawnr r rD rI )
r r- r. r r r r/ rK r[ r6 r; ZexerM r r r �try_run� s
�
zconfig.try_runr c C st | � � g }|r |�d| � |�d� |r<|�d| � n|�d| � |�d� d�|�d }| �|||||�S )Nz
int %s ();z
int main () {z %s();z %s;�}r( )r& r@ rE r\ ) r �funcr. r r r ZdeclZcallr- r r r �
check_func s
�zconfig.check_funcc C s | � � | �d|||g| |�S )Nzint main (void) { })r& r\ )r Zlibraryr r. r Zother_librariesr r r � check_lib4 s
�zconfig.check_libc C s | j d|g|d�S )Nz
/* No body */)r- r. r )rN )r r2 r r r/ r r r � check_headerB s
�zconfig.check_header)NNNr )NNNr )NNr )NNNNr )NNNNr )NNNNr r )NNr )�__name__�
__module__� __qualname__Z descriptionZ user_optionsr r r! r& r3 r8 r< rB rI rN rV rY r\ r] r` ra rb r r r r r s\ �
�
�
�
�
�
�r c C sJ |d krt �d| � n
t �|� t| �}zt �|�� � W 5 |�� X d S )Nz%s)r rD r+ �close�read)r0 �headr1 r r r r9 K s
r9 )N)
r rP Zdistutils.corer Zdistutils.errorsr Zdistutils.sysconfigr Z distutilsr r* r r9 r r r r �<module> s
8 __pycache__/bdist_wininst.cpython-38.pyc 0000644 00000020453 15051366004 0014270 0 ustar 00 U
e5d�> � @ sx d Z ddlZddlZddlZddlmZ ddlmZ ddlm Z m
Z
ddl T ddl m
Z
ddlmZ G d d
� d
e�ZdS ) zzdistutils.command.bdist_wininst
Implements the Distutils 'bdist_wininst' command: create a windows installer
exe-program.� N)�Command)� get_platform)� create_tree� remove_tree)�*)�get_python_version)�logc
s� e Zd ZdZdddde� fdddd d
d d d
dddg
ZddddgZejdkZ � fdd�Z
dd� Z dd� Z d d � Z
d d � Zd'd!d"�Zd#d$� Zd%d&� Z� ZS )(�
bdist_wininstz-create an executable installer for MS Windows)z
bdist-dir=Nz1temporary directory for creating the distributionz
plat-name=�pz;platform name to embed in generated filenames (default: %s))� keep-temp�kzPkeep the pseudo-installation tree around after creating the distribution archive)ztarget-version=Nz6require a specific python version on the target system)�no-target-compile�cz/do not compile .py to .pyc on the target system)�no-target-optimize�oz;do not compile .py to .pyo (optimized) on the target system)z dist-dir=�dz-directory to put final built distributions in)zbitmap=�bz>bitmap to use for the installer instead of python-powered logo)ztitle=�tz?title to display on the installer background instead of default)�
skip-buildNz2skip rebuilding everything (for testing/debugging))zinstall-script=NzUbasename of installation script to be run after installation or before deinstallation)zpre-install-script=Nz{Fully qualified filename of a script to be run before any files are installed. This script need not be in the distribution)zuser-access-control=Nz�specify Vista's UAC handling - 'none'/default=no handling, 'auto'=use UAC if target Python installed for all users, 'force'=always use UACr r
r r �win32c s t � j||� t�dtd� d S )Nz^bdist_wininst command is deprecated since Python 3.8, use bdist_wheel (wheel packages) instead� )�super�__init__�warnings�warn�DeprecationWarning)�self�args�kw�� __class__� �7/usr/lib64/python3.8/distutils/command/bdist_wininst.pyr ? s
�zbdist_wininst.__init__c C sR d | _ d | _d| _d| _d| _d | _d | _d | _d | _d | _ d | _
d | _ d | _ d S )Nr )
� bdist_dir� plat_name� keep_temp�no_target_compile�no_target_optimize�target_version�dist_dir�bitmap�title�
skip_build�install_script�pre_install_script�user_access_control)r r! r! r" �initialize_optionsE s z bdist_wininst.initialize_optionsc C s� | � dd� | jd krR| jr6| jr6| j�d�}| j|_| �d�j}tj �
|d�| _| j s^d| _ | js�| j� � r�t
� }| j r�| j |kr�td|f ��|| _ | � ddd� | jr�| jjD ]}| jtj �|�kr� q�q�td| j ��d S ) N�bdist)r, r, Zwininst� zMtarget version can only be %s, or the '--skip-build' option must be specified)r) r) )r$ r$ z(install_script '%s' not found in scripts)Zset_undefined_optionsr# r, r$ � distributionZget_command_obj�get_finalized_command�
bdist_base�os�path�joinr( �has_ext_modulesr ZDistutilsOptionErrorr- �scripts�basename)r r1 r5 Z
short_version�scriptr! r! r" �finalize_optionsU s>
��� ��z bdist_wininst.finalize_optionsc
C s� t jdkr&| j�� s | j�� r&td��| js6| �d� | jddd�}| j |_
| j|_d|_ | j |_ | �d�}d|_
d|_| j�� r�| j}|s�| js�td ��d
t jd d � }d | j |f }| �d�}tj�|jd
| �|_dD ],}|�� }|dkr�|d }t|d| |� q�t�d| j � |� � t j� dtj�| j d�� |� � t jd= ddl m } |� } | j�!� }
| j"| d| j d�} | �#| |
| j$� | j�� �r�t%� } nd} | jj&�'d| | �(|
�f� t�)d| � t�*| � | j+�s�t,| j | j-d� d S )Nr z^distribution contains extensions and/or C libraries; must be compiled on a Windows 32 platform�build�install� )Zreinit_subcommandsr � install_libz Should have already checked thisz%d.%dr z.%s-%s�lib)ZpurelibZplatlib�headersr: �datarC z/Include/$dist_nameZinstall_zinstalling to %sZPURELIB)�mktemp�zip)Zroot_dir�anyr z removing temporary file '%s')�dry_run).�sys�platformr3 r9 Zhas_c_librariesZDistutilsPlatformErrorr, Z run_commandZreinitialize_commandr# �rootZwarn_dirr$ �compile�optimizer( �AssertionError� version_infor4 r6 r7 r8 Z
build_baseZ build_lib�upper�setattrr �infoZensure_finalized�insert�runZtempfilerE � get_fullnameZ make_archive�
create_exer* r Z
dist_files�append�get_installer_filename�debug�remover% r rH )
r r? rA r( Zplat_specifierr> �key�valuerE Zarchive_basename�fullname�arcnameZ pyversionr! r! r" rT { st
���
��
� �
zbdist_wininst.runc C sZ g }| j j}|�d� |jp dd }dd� }dD ]B}t||d�}|r0|d|�� ||�f }|�d|||�f � q0|�d � | jr�|�d
| j � |�d ||� � |�d | j � |�d
| j � | j r�|�d| j � | j
r�|�d| j
� | j �p| j � � }|�d||� � dd l
}dd l} d|�|�
� �| jf }
|�d|
� d�|�S )Nz
[metadata]r2 �
c S s | � dd�S )Nr_ z\n)�replace)�sr! r! r" �escape� s z)bdist_wininst.get_inidata.<locals>.escape)ZauthorZ author_email� descriptionZ
maintainerZmaintainer_email�nameZurl�versionz
%s: %sz%s=%sz
[Setup]zinstall_script=%szinfo=%sztarget_compile=%dztarget_optimize=%dztarget_version=%szuser_access_control=%sztitle=%sr zBuilt %s with distutils-%sz
build_info=%s)r3 �metadatarW Zlong_description�getattr�
capitalizer- r& r' r( r/ r+ rU �time� distutils�ctime� __version__r8 ) r �linesrf rR rb rd rD r+ ri rj Z
build_infor! r! r" � get_inidata� s>
�
�zbdist_wininst.get_inidataNc
C sH dd l }| �| j� | �� }| �|�}| �d| � |r`t|d��}|�� }W 5 Q R X t|�} nd} t|d���}
|
� | �
� � |r�|
� |� t |t �r�|�
d�}|d }| jr�t| jddd ��} | �� �
d�} W 5 Q R X || d
}n|d }|
� |� |�d d t|�| �}
|
� |
� t|d��}|
� |�� � W 5 Q R X W 5 Q R X d S )
Nr z creating %s�rb�wb�mbcs� �rzlatin-1)�encodings
z<iiii{V4)�structZmkpathr) rn rX Zannounce�open�read�len�write�
get_exe_bytes�
isinstance�str�encoder. Zpack)r r^ r] r* ru Zcfgdata�installer_name�fZ
bitmapdataZ bitmaplen�filer< Z script_data�headerr! r! r" rV � sD
�
�
zbdist_wininst.create_exec C sD | j r&tj�| jd|| j| j f �}ntj�| jd|| jf �}|S )Nz%s.%s-py%s.exez %s.%s.exe)r( r6 r7 r8 r) r$ )r r] r~ r! r! r" rX 1 s
��
�z$bdist_wininst.get_installer_filenamec C s$ t � }| jrl| j|k rl| jdk r&d}q�| jdkr6d}q�| jdkrFd}q�| jdkrVd}q�| jdkrfd }q�d
}n@zd d lm} W n tk
r� d
}Y nX |�d
�d }|d }tj�t �}| j
dkr�| j
d d� dkr�| j
dd � }nd}tj� |d||f �}t |d�}z |�� W �S |�
� X d S )Nz2.4z6.0z7.1z2.5z8.0z3.2z9.0z3.4z10.0z14.0r )�CRT_ASSEMBLY_VERSION�.z.0r � �winr2 zwininst-%s%s.exero )r r( Zmsvcrtr� � ImportError� partitionr6 r7 �dirname�__file__r$ r8 rv �closerw ) r Z cur_versionZbvr� �majorZ directoryZsfix�filenamer r! r! r" rz > s8
zbdist_wininst.get_exe_bytes)N)�__name__�
__module__� __qualname__rc r Z user_optionsZboolean_optionsrI rJ Z _unsupportedr r0 r= rT rn rV rX rz �
__classcell__r! r! r r" r s> ���%�
&Q.
7
r )�__doc__r6 rI r Zdistutils.corer Zdistutils.utilr Zdistutils.dir_utilr r Zdistutils.errorsZdistutils.sysconfigr rj r r r! r! r! r" �<module> s __pycache__/bdist_msi.cpython-38.opt-2.pyc 0000644 00000043114 15051366004 0014324 0 ustar 00 U
e5d߉ � @ s� d dl Z d dlZd dlmZ d dlmZ d dlmZ d dlm Z d dl
m Z d dl m
Z
d dlmZ d dlZd d lmZmZmZ d d
lmZmZmZmZ G d d � d e�ZG d
d� de�ZdS )� N)�Command)� remove_tree)�get_python_version)�
StrictVersion)�DistutilsOptionError)� get_platform)�log)�schema�sequence�text)� Directory�Feature�Dialog�add_datac @ sB e Zd Zdd� Zdd� Zddd�Zdd
d �Zdd
d�Zdd� ZdS )�PyDialogc O s> t j| f|�� | jd }d| d }| �dd|| jd� d S )N�$ � iH Z
BottomLiner )r �__init__�h�line�w)�self�args�kwZrulerZbmwidth� r �3/usr/lib64/python3.8/distutils/command/bdist_msi.pyr s
zPyDialog.__init__c
C s | � ddddddd| � d S )N�Title� �
�@ �< � z{\VerdanaBold10}%s)r )r �titler r r r" # s �zPyDialog.title�Back� c
C s, |r
d}nd}| � |d| jd dd|||�S )N� r$ � � �8 � ��
pushbuttonr �r r" �next�name�active�flagsr r r �back* s z
PyDialog.back�Cancelc
C s, |r
d}nd}| � |d| jd dd|||�S )Nr% r$ i0 r' r( r) r* r, r r r �cancel5 s zPyDialog.cancel�Nextc
C s, |r
d}nd}| � |d| jd dd|||�S )Nr% r$ �� r' r( r) r* r, r r r r- @ s z
PyDialog.nextc
C s, | � |t| j| d �| jd ddd||�S )N� r' r( r) r% )r+ �intr r )r r. r" r- Zxposr r r �xbuttonK s zPyDialog.xbuttonN)r# r$ )r2 r$ )r4 r$ ) �__name__�
__module__� __qualname__r r" r1 r3 r- r8 r r r r r s
r c @ s� e Zd ZdZdddde� fdddd d
d d d
g
ZddddgZddddddddddd d d d d d!d"d#d$d%gZd&Zd'd(� Z d)d*� Z
d+d,� Z d-d.� Z d/d0� Z
d1d2� Zd3d4� Zd5d6� Zd7S )8� bdist_msiz7create a Microsoft Installer (.msi) binary distribution)z
bdist-dir=Nz1temporary directory for creating the distributionz
plat-name=�pz;platform name to embed in generated filenames (default: %s))� keep-temp�kzPkeep the pseudo-installation tree around after creating the distribution archive)ztarget-version=Nz6require a specific python version on the target system)�no-target-compile�cz/do not compile .py to .pyc on the target system)�no-target-optimize�oz;do not compile .py to .pyo (optimized) on the target system)z dist-dir=�dz-directory to put final built distributions in)�
skip-buildNz2skip rebuilding everything (for testing/debugging))zinstall-script=NzUbasename of installation script to be run after installation or before deinstallation)zpre-install-script=Nz{Fully qualified filename of a script to be run before any files are installed. This script need not be in the distributionr> r@ rB rE z2.0z2.1z2.2z2.3z2.4z2.5z2.6z2.7z2.8z2.9z3.0z3.1z3.2z3.3z3.4z3.5z3.6z3.7z3.8z3.9�Xc C sF d | _ d | _d| _d| _d| _d | _d | _d | _d | _d | _ d | _
d S )Nr ) � bdist_dir� plat_name� keep_tempZno_target_compileZno_target_optimize�target_version�dist_dir�
skip_build�install_script�pre_install_script�versions)r r r r �initialize_options} s z bdist_msi.initialize_optionsc C s� | � dd� | jd kr2| �d�j}tj�|d�| _t� }| jsN| j �
� rN|| _| jr�| jg| _ | j s�| j �
� r�| j|kr�t
d|f ��n t| j�| _ | � ddd� | jr�t
d��| jr�| j jD ]}| jtj�|�kr� q�q�t
d| j ��d | _d S ) NZbdist)rL rL ZmsizMtarget version can only be %s, or the '--skip-build' option must be specified)rK rK )rH rH z5the pre-install-script feature is not yet implementedz(install_script '%s' not found in scripts)Zset_undefined_optionsrG �get_finalized_command�
bdist_base�os�path�joinr rJ � distribution�has_ext_modulesrO rL r �list� all_versionsrN rM Zscripts�basename�install_script_key)r rR Z
short_versionZscriptr r r �finalize_options� sH
��� �� ��zbdist_msi.finalize_optionsc C sz | j s| �d� | jddd�}| j|_| j |_ d|_| �d�}d|_d|_| j� � r�| j
}|spdt j d d� }d | j
|f }| �d�}tj�|jd
| �|_t�d | j� |�� t j�dtj�| jd �� |�� t jd= | �| j� | j�� }| � |�}tj� |�}tj� |��r"t� |� | jj }|j!} | �s<|j"} | �sFd
} |�#� }
dt$|
�j% } | j�� }| j
�r~d| j
|f } nd| } t&�'|t(| t&�)� | | �| _*t&�+| j*t,� d|
fg}
|j-�p�|j.}|�r�|
�/d|f� |j0�r�|
�/d|j0f� |
�rt1| j*d|
� | �2� | �3� | �4� | �5� | j*�6� t7| jd��r^d| j
�pJd|f}| jj8�/|� | j9�svt:| j| j;d� d S )N�build�installr$ )Zreinit_subcommandsr � install_libz%d.%d� z.%s-%s�libzinstalling to %sZPURELIBZUNKNOWNz%d.%d.%dz Python %s %sz Python %sZ DistVersionZ
ARPCONTACTZARPURLINFOABOUT�Property�
dist_filesr< �any)�dry_run)<rL Z run_commandZreinitialize_commandrG �prefixZwarn_dir�compile�optimizerV rW rJ �sys� version_inforH rQ rS rT rU Z
build_baseZ build_libr �infoZensure_finalized�insert�runZmkpathrK � get_fullname�get_installer_filename�abspath�exists�unlink�metadata�authorZ
maintainerZ get_versionr �version�msilibZ
init_databaser Zgen_uuid�dbZ
add_tablesr
Z author_emailZmaintainer_email�appendZurlr �add_find_python� add_files� add_scripts�add_ui�Commit�hasattrrc rI r re )r r^ r_ rJ Zplat_specifierr] �fullname�installer_namers rt ru ZsversionZ product_nameZpropsZemail�tupr r r rm � s�
�
�
z
bdist_msi.runc
C s | j }t�d�}tj�| j�}t||d |dd�}t|ddddddd�}||d fg}| j | j
g D ]t}d| }d| } }
d} || j
kr�d
} d }
n d | } d}
t|| | | d|
|d�}t||||||
�}|� |||f� q`|� � i }|D �] \}}}|g}|�r�|�
� }t�|j�D ]�}tj�|j|�}tj�|��rld
|�|�|f }|| }
t|||||
|�}|� |� n�|j�s�|�|j|d� ||k�r�|�|� }||< || jk�r�| j�r�td| ��d| | _n*|| }t| j d|| |j|d |jfg� �qq�|� � q�|�|� d S )NZ distfiles� TARGETDIRZ SourceDir�PythonZ
Everythingr r$ )Z directory� z Python from another locationr` zPython %s from registryz%s|%szMultiple files with name %sz[#%s]Z
DuplicateFile) rw rv ZCABrS rT rp rG r r
rO �
other_versionrx r} �pop�listdirZabsoluterU �isdirZ
make_shortZ componentZstart_componentZlogicalZadd_filerM r[ r r Zcommit)r rw ZcabZrootdir�root�f�itemsru �targetr. �defaultZdescr" �level�dir�seenZfeatureZtodo�fileZafileZshortZnewdir�keyr r r rz
sf
�
� �
zbdist_msi.add_filesc C s| d}| j D �]j}d| }d| }d| }d| }d| }d| }d| } d | }
d
| } d | } tjrld }
nd
}
t| jd|d
|d |
f|d|d |
fg� t| jd||f||fg� t| jd|d| d| d f| d| d| d f|
d| d| d fg� t| jd|||f| ||d f|
d |d
fg� t| jd|||f| ||d f|
d |d
fg� t| jdd| dd| fg� |d 7 }q
d S ) Ni� z)SOFTWARE\Python\PythonCore\%s\InstallPathzpython.machine.z python.user.zPYTHON.MACHINE.z PYTHON.USER.ZPythonFromMachineZPythonFromUserZ PythonExer� �PYTHON� r` Z
RegLocatorr$ Z AppSearch� CustomActioni3 �[�]z ]\python.exe�InstallExecuteSequence�InstallUISequenceZ Conditionr� r z
NOT TARGETDIR� )rO rv ZWin64r rw )r �start�verZ install_pathZ machine_regZuser_regZ machine_propZ user_propZmachine_actionZ user_actionZ
exe_actionZtarget_dir_prop�exe_propZTyper r r ry C s` ������ �� ���zbdist_msi.add_find_pythonc
C s | j rjd}| j| jg D ]P}d| }d| }t| jd|d|| jfg� t| jd|d| |fg� |d7 }q| jr�tj� | j
d �}t |d
��4}|� d � t | j��}|� |�
� � W 5 Q R X W 5 Q R X t| jd d
t�|�fg� t| jddg� t| jddg� d S )Ni� zinstall_script.r� r� �2 r� z &Python%s=3r$ zpreinstall.batr zrem ="""
%1 %0
exit
"""
�Binary�
PreInstall)r� r` r� N)r� z
NOT Installedi� )rM rO r� r rw r[ rN rS rT rU rG �open�write�readrv r� )r r� r� Zinstall_actionr� Zscriptfnr� Zfinr r r r{ y s6 ��
"���zbdist_msi.add_scriptsc C s�
| j }d }}d}d}d}d}d}d} t|dd d
d d d
dg� t|dddddg� t|ddddddg� t|dtj� t|dtj� t|d ||||||d d d � }
|
�d � |
jd d d d!� |
jd"d#d d!� |
�d$d%d&d'd(d)d*� |
�d+d%d,d'd-d)d.� |
j d d"d d/�} | �
d0d1� t|d2||||||d d d � } | �d3� | jd d d d!� | jd"d#d d!� | �d$d%d&d'd(d)d4� | �d+d%d,d'd-d)d.� | j d d"d d/�} | �
d0d1� t|d5||||||d d d � }
|
�d6� |
jd d d d!� |
jd"d#d d!� |
�d7d%d8d'd-d)d.� |
j d d"d d/�} | �
d0d9� t|d:||||d;|d<d<d<d=d>� }|�d?d%d@dAd%d)dB� |�d7d-dCdDd-d)dE� |�dFd-dGdHdddI� |� dJdKd-dLdHdMdNdOd d d � |jd1dPd1d/�} | �
d0d1� |j dPd<dPd/�} | �
d0dP� |jd<d1d<d/�} | �
d0d<� t |dQddRdHdSdT|dUd d � }|�dUddVdDdWddX� |�
dYdZd[d\d]dd^d ��
d0d_� |�
d`dad[d\d]ddbd ��
d0dc� |�
ddd d[d\d]dded ��
d0df� |�
dgdhd[d\d]dd"d ��
d0di� |�
djd\d[d\d]ddPd ��
d0dk� |�
dldmd[d\d]ddnd ��
d0do� |�
dpdqd[d\d]dd<d ��
d0dr� t |dsddRdtdud|d^d^d^� }|�dFdWd%dvdwddx� |�
dbd[dydzd{ddbd^�} | �
d0d1� |�
d^d|dydzd{dd^db�} | �
d0d9� t |d}ddRdtdu||d9d9d9� }|�dFdWd%dvdwdd~� |�
d9ddydzd{dd9d �} | �
d0d1� t|d�||||||d"d"d"� }|�d7d%d&d'd�d)d�� |�d�� |�dd%d�d'd-d)d��} | �ddF� |�d�d%d�d'dwd)d �} | �d�dF� |jd#d d d!� |j d�d d d!� |�d"d �} | �
d�ds� t|d�||||||d�d�d"� }|�d�� |�d�d%dwdd-dd�| j�� � |jd d d d!� |� d�d"�} d}| j
d�d�|d�� | j| jg D ](}|d7 }| j
d�d�| d�| |d�� �q
| j
d�d}|d d�� | j
d0d9|d� d�� |�d"d��} | �
d�ds� |� d�d�d%d�ddZdd�d d�d � } | �
d�d�� | j}d�| }d�| }|�d�d%dAdd%dd��} | �d�|� | �d�|� | �d�|� | �d�|� |� d�d�d%d�dd�dd�| d d�d � } | �d�|� | �d�|� | �d�|� | �d�|� t|d�||||||d�d�d�d=d>� }|�d?d%d@dAd%d)d�� |�d7d-d-dDd-d)d�� |�dFd-d�dHd�dd�� |� d�d�d-d�dHd�d�d d�d d � |�d�dnd d���
d0d9� t|d�||||||d�d�d"� }|�d�� |�d�d%d�dtddd�dXd�� }|�d�d d�d�d-d�� |�d�d d�d�d-d�� |jd#d d d!� |� d�d"�} | �
d�d�d�d� | j
d0d9d�d�� |�d"d��} | �
d�ds� t|d�||||||d"d"d"d=d>� } | �d?d-d%dAd%d)d�� | �dFd�d�ddwddġ | �d�d�d�d�d-ddơ | �dd&d�|d& d-dd��} | �ddF� | � d�d�d�dZddRd�d d�d d � } | �d�dˡ | jd d�d=d!� | j d�d"d=d!� | �d"d#��
d�ds� t|d�||||||d�d�d"� } | �d͡ | �d�d%d�dHdhddС | �d�d%d�dHd�dd�dXd�� }|�d�d d�dAd{d֡ |�d�d d�dAd{d١ | jd d d=d!� | � d d"�} | �
d�d�d�d�� | �
d�d�d�d@� | �
d�d�d�dN� | �
d�d�d�d� | �
d�d�d�d� | �
d�d�d�d� | �
d�d�d�d� | �
d�d�d�d� | �
d0d9d�d-� | �d"dѡ�
d�ds� d S )�Nr� ir i, z[ProductName] Setupr% r$ � rb )Z
DefaultUIFont�DlgFont8)Z ErrorDialog�ErrorDlg)Z Progress1ZInstall)Z Progress2Zinstalls)�MaintenanceForm_Action�Repair)�
WhichUsers�ALLZ TextStyle)r� �Tahoma� Nr )Z DlgFontBold8r� � Nr$ )Z
VerdanaBold10�Verdanar Nr$ )Z VerdanaRed9r� r� � r r� )�
PrepareDlgz(Not Privileged or Windows9x or Installed� )�
WhichUsersDlgz.Privileged and not Windows9x and not Installed� )�SelectFeaturesDlgz
Not Installedi� )�MaintenanceTypeDlgz,Installed AND NOT RESUME AND NOT Preselectedi� )� ProgressDlgNi �
ActionText�UITextZ
FatalErrorZFinishz)[ProductName] Installer ended prematurelyz< Backr )r/ r2 r# Z Description1r �F r �P r! z�[ProductName] setup ended prematurely because of an error. Your system has not been modified. To install this program at a later time, please run the installation again.Z Description2� � z.Click the Finish button to exit the Installer.)r. Z EndDialogZExitZUserExitz'[ProductName] Installer was interruptedz�[ProductName] setup was interrupted. Your system has not been modified. To install this program at a later time, please run the installation again.Z
ExitDialogz&Completing the [ProductName] InstallerZ Description�� ZReturnZ
FilesInUse� ZRetryF)Zbitmapr � �� z{\DlgFontBold8}Files in Use� i z8Some files that need to be updated are currently in use.ZText�7 iJ z�The following applications are using files that need to be updated by this setup. Close these applications and then click Retry to continue the installation or Cancel to exit it.ZListZListBox�k � � ZFileInUseProcess�Ignorer� r �e i Z ErrorTextr� �0 r� �N�x �H �Q � ZNoZErrorNo�Y�� ZYesZErrorYes�AZAbortZ
ErrorAbort�C�* Z ErrorCancel�IZ ErrorIgnore�O� ZOkZErrorOk�R�� Z
ErrorRetryZ CancelDlgi �U �� � z;Are you sure you want to cancel [ProductName] installation?�9 r( r) � ZWaitForCostingDlgzRPlease wait while the installer finishes determining your disk space requirements.�f r� �( zOPlease wait while the Installer prepares to guide you through the installation.z&Welcome to the [ProductName] Installer�n z Pondering...Z
ActionData� r4 Z SpawnDialogr� zSelect Python InstallationsZHintz9Select the Python locations where %s should be installed.zNext >z [TARGETDIR]z [SourceDir])Zorderingz
[TARGETDIR%s]z FEATURE_SELECTED AND &Python%s=3ZSpawnWaitDialogr` ZFeaturesZ
SelectionTreer ZFEATUREZPathEditz[FEATURE_SELECTED]�1z!FEATURE_SELECTED AND &Python%s<>3ZOtherz$Provide an alternate Python locationZEnableZShowZDisableZHide�� � r� Z DiskCostDlgZOKz&{\DlgFontBold8}Disk Space RequirementszFThe disk space required for the installation of the selected features.�5 a The highlighted volumes (if any) do not have enough disk space available for the currently selected features. You can either remove some files from the highlighted volumes, or choose to install less features onto local drive(s), or select different destination drive(s).Z
VolumeListZVolumeCostList�d � i z{120}{70}{70}{70}{70}g �?r� Z AdminInstallzGSelect whether to install [ProductName] for all users of this computer.r� r� � zInstall for all usersZJUSTME� zInstall just for mez
[ALLUSERS]zWhichUsers="ALL"r� z({\DlgFontBold8}[Progress1] [ProductName]�# �A zYPlease wait while the Installer [Progress2] [ProductName]. This may take several minutes.Z StatusLabelzStatus:Z ProgressBari z
Progress doneZ SetProgressZProgressr� z)Welcome to the [ProductName] Setup WizardZBodyText�? z:Select whether you want to repair or remove [ProductName].ZRepairRadioGroup�l r� r� r� z&Repair [ProductName]ZRemover zRe&move [ProductName]z [REINSTALL]z MaintenanceForm_Action="Repair"z [Progress1]Z Repairingz [Progress2]ZrepairsZ Reinstallr� z[REMOVE]z MaintenanceForm_Action="Remove"� ZRemoving� Zremoves�
� z MaintenanceForm_Action<>"Change")rw r r r� r� r r" r1 r3 r- ZeventZcontrolr r+ �mappingrV rn rO r� Z conditionr8 Z
radiogroup�add) r rw �x�yr r r" ZmodalZmodelessZtrack_disk_spaceZfatalrA Z user_exitZ exit_dialogZinuse�errorr3 ZcostingZprepZseldlg�orderru r� Zinstall_other_condZdont_install_other_condZcostZ
whichusers�gZprogressZmaintr r r r| � sv ��
�� ��
�
�� �
�� �
� ���� � � �� �� ��
�
�� �
� � � ���� �
�
� ��� � �
� � zbdist_msi.add_uic C s< | j rd|| j| j f }nd|| jf }tj�| j|�}|S )Nz%s.%s-py%s.msiz %s.%s.msi)rJ rH rS rT rU rK )r r Z base_namer� r r r ro � s �z bdist_msi.get_installer_filenameN)r9 r: r; Z descriptionr Z user_optionsZboolean_optionsrY r� rP r\ rm rz ry r{ r| ro r r r r r< S s^ ��� �
�
([66& @r< )ri rS Zdistutils.corer Zdistutils.dir_utilr Zdistutils.sysconfigr Zdistutils.versionr Zdistutils.errorsr Zdistutils.utilr Z distutilsr rv r r
r r r
r r r r< r r r r �<module> s > __pycache__/install_egg_info.cpython-38.pyc 0000644 00000005666 15051366004 0014724 0 ustar 00 U
e5d+
� @ sd d Z ddlmZ ddlmZmZ ddlZddlZddlZG dd� de�Z dd� Z
d d
� Z d d � Z dS )
z�distutils.command.install_egg_info
Implements the Distutils 'install_egg_info' command, for installing
a package's PKG-INFO metadata.� )�Command)�log�dir_utilNc @ s: e Zd ZdZdZdgZdd� Zdd� Zdd � Zd
d � Z d S )
�install_egg_infoz)Install an .egg-info file for the packagez8Install package's PKG-INFO metadata as an .egg-info file)z install-dir=�dzdirectory to install toc C s
d | _ d S �N)� install_dir��self� r �:/usr/lib64/python3.8/distutils/command/install_egg_info.py�initialize_options s z#install_egg_info.initialize_optionsc C sb | � dd� dtt| j�� ��tt| j�� ��ftjd d� � }t j
� | j |�| _
| j
g| _d S )NZ install_lib)r r z%s-%s-py%d.%d.egg-info� )Zset_undefined_options� to_filename� safe_name� distributionZget_name� safe_versionZ get_version�sys� version_info�os�path�joinr �target�outputs)r
�basenamer r r �finalize_options s � �z!install_egg_info.finalize_optionsc C s� | j }tj�|�r0tj�|�s0tj|| jd� nNtj�|�rV| � tj
| j fd| � n(tj�| j �s~| � tj | j fd| j � t
�d|� | js�t|ddd��}| jj�|� W 5 Q R X d S )N)�dry_runz Removing z Creating z
Writing %s�wzUTF-8)�encoding)r r r �isdir�islinkr Z remove_treer �existsZexecute�unlinkr �makedirsr �info�openr ZmetadataZwrite_pkg_file)r
r �fr r r �run s � zinstall_egg_info.runc C s | j S r )r r r r r � get_outputs. s z install_egg_info.get_outputsN)
�__name__�
__module__� __qualname__�__doc__Z descriptionZ user_optionsr
r r' r( r r r r r s �
r c C s t �dd| �S )z�Convert an arbitrary string to a standard distribution name
Any runs of non-alphanumeric/. characters are replaced with a single '-'.
�[^A-Za-z0-9.]+�-)�re�sub��namer r r r 6 s r c C s | � dd�} t�dd| �S )z�Convert an arbitrary string to a standard version string
Spaces become dots, and all other non-alphanumeric characters become
dashes, with runs of multiple dashes condensed to a single dash.
� �.r- r. )�replacer/ r0 )�versionr r r r > s r c C s | � dd�S )z|Convert a project or version name to its filename-escaped form
Any '-' characters are currently replaced with '_'.
r. �_)r5 r1 r r r r H s r )
r, Z
distutils.cmdr Z distutilsr r r r r/ r r r r r r r r �<module> s +
__pycache__/bdist_dumb.cpython-38.pyc 0000644 00000007012 15051366004 0013520 0 ustar 00 U
e5d1 � @ sh d Z ddlZddlmZ ddlmZ ddlmZmZ ddl T ddl
m Z ddl m
Z
G d d
� d
e�ZdS ) z�distutils.command.bdist_dumb
Implements the Distutils 'bdist_dumb' command (create a "dumb" built
distribution -- i.e., just an archive to be unpacked under $prefix or
$exec_prefix).� N)�Command)� get_platform)� remove_tree�ensure_relative)�*)�get_python_version)�logc @ s^ e Zd ZdZdddde� fdddd d
d d g Zd
ddgZddd�Zdd� Zdd� Z dd� Z
dS )�
bdist_dumbz"create a "dumb" built distribution)z
bdist-dir=�dz1temporary directory for creating the distributionz
plat-name=�pz;platform name to embed in generated filenames (default: %s))zformat=�fz>archive format to create (tar, gztar, bztar, xztar, ztar, zip))� keep-temp�kzPkeep the pseudo-installation tree around after creating the distribution archive)z dist-dir=r
z-directory to put final built distributions in)�
skip-buildNz2skip rebuilding everything (for testing/debugging))�relativeNz7build the archive using relative paths (default: false))zowner=�uz@Owner name used when creating a tar file [default: current user])zgroup=�gzAGroup name used when creating a tar file [default: current group]r
r r Zgztar�zip)�posix�ntc C s: d | _ d | _d | _d| _d | _d | _d| _d | _d | _d S )Nr ) � bdist_dir� plat_name�format� keep_temp�dist_dir�
skip_buildr �owner�group)�self� r �4/usr/lib64/python3.8/distutils/command/bdist_dumb.py�initialize_options2 s z bdist_dumb.initialize_optionsc C sz | j d kr&| �d�j}tj�|d�| _ | jd krfz| jtj | _W n" t k
rd t
dtj ��Y nX | � dddd� d S )NZbdistZdumbz@don't know how to create dumb built distributions on platform %s)r r )r r )r r ) r Zget_finalized_command�
bdist_base�os�path�joinr �default_format�name�KeyError�DistutilsPlatformErrorZset_undefined_options)r r" r r r �finalize_options= s"
��
�zbdist_dumb.finalize_optionsc C s( | j s| �d� | jddd�}| j|_| j |_ d|_t�d| j� | �d� d| j� � | j
f }t j �
| j|�}| js~| j}nJ| j�� r�|j|jkr�tdt|j�t|j�f ��nt j �
| jt|j��}| j|| j|| j| jd �}| j�� r�t� }nd
}| jj� d ||f� | j �s$t | j| j d � d S )
NZbuild�install� )Zreinit_subcommandsr zinstalling to %sz%s.%szScan't make a dumb built distribution where base and platbase are different (%s, %s))Zroot_dirr r �anyr )�dry_run) r Z run_commandZreinitialize_commandr �rootZwarn_dirr �infoZ distributionZ get_fullnamer r# r$ r% r r Zhas_ext_modulesZ install_baseZinstall_platbaser) �reprr Z make_archiver r r r Z
dist_files�appendr r r. )r r+ Zarchive_basenameZpseudoinstall_rootZ archive_root�filenameZ pyversionr r r �runO sR
�
����
� �
�zbdist_dumb.runN) �__name__�
__module__� __qualname__Z descriptionr Z user_optionsZboolean_optionsr& r! r* r4 r r r r r s, ���
� r )�__doc__r# Zdistutils.corer Zdistutils.utilr Zdistutils.dir_utilr r Zdistutils.errorsZdistutils.sysconfigr Z distutilsr r r r r r �<module> s __pycache__/config.cpython-38.opt-1.pyc 0000644 00000023765 15051366004 0013625 0 ustar 00 U
e5d=3 � @ sl d Z ddlZddlZddlmZ ddlmZ ddlmZ ddl m
Z
ddd �Z G d
d � d e�Z dd d
�Z
dS )a� distutils.command.config
Implements the Distutils 'config' command, a (mostly) empty command class
that exists mainly to be sub-classed by specific module distributions and
applications. The idea is that while every "config" command is different,
at least they're all named the same, and users always see "config" in the
list of standard commands. Also, this is a good place to put common
configure-like tasks: "try to compile this C code", or "figure out where
this header file lives".
� N)�Command)�DistutilsExecError)�customize_compiler)�logz.cz.cxx)�czc++c @ s� e Zd ZdZdddddddd d
g Zd d � Zd
d� Zdd� Zdd� Zdd� Z dd� Z
dd� Z dd� Z dd � Z
d0d d �Zd1d!d"�Zd2d#d$�Zd3d%d&�Zd4d'd(�Zd5d*d+�Zd d d g fd,d-�Zd6d.d/�Zd S )7�configzprepare to build)z compiler=Nzspecify the compiler type)zcc=Nz specify the compiler executable)z
include-dirs=�Iz.list of directories to search for header files)zdefine=�Dz C preprocessor macros to define)zundef=�Uz!C preprocessor macros to undefine)z
libraries=�lz!external C libraries to link with)z
library-dirs=�Lz.directories to search for external C libraries)�noisyNz1show every action (compile, link, run, ...) taken)z dump-sourceNz=dump generated source files before attempting to compile themc C s4 d | _ d | _d | _d | _d | _d| _d| _g | _d S )N� )�compilerZcc� include_dirs� libraries� library_dirsr
� dump_source�
temp_files��self� r �0/usr/lib64/python3.8/distutils/command/config.py�initialize_options3 s zconfig.initialize_optionsc C s� | j d kr| jj pg | _ n t| j t�r6| j �tj�| _ | jd krHg | _nt| jt�r^| jg| _| jd krpg | _n t| jt�r�| j�tj�| _d S �N) r Z distribution�
isinstance�str�split�os�pathsepr r r r r r �finalize_optionsB s
zconfig.finalize_optionsc C s d S r r r r r r �runR s z
config.runc C sz ddl m}m} t| j|�sv|| j| jdd�| _t| j� | jrN| j�| j� | j rb| j�
| j � | j rv| j� | j � dS )z^Check that 'self.compiler' really is a CCompiler object;
if not, make it one.
r )� CCompiler� new_compilerr )r �dry_runZforceN)
�distutils.ccompilerr" r# r r r$ r r Zset_include_dirsr Z
set_librariesr Zset_library_dirs)r r" r# r r r �_check_compilerY s �
zconfig._check_compilerc C sl dt | }t|d��L}|r>|D ]}|�d| � q |�d� |�|� |d dkr^|�d� W 5 Q R X |S )NZ _configtest�wz#include <%s>
�
���)�LANG_EXT�open�write)r �body�headers�lang�filename�file�headerr r r �_gen_temp_sourcefilek s
zconfig._gen_temp_sourcefilec C s< | � |||�}d}| j�||g� | jj|||d� ||fS )Nz
_configtest.i�r )r3 r �extendr Z
preprocess)r r- r. r r/ �src�outr r r � _preprocessw s
zconfig._preprocessc C s\ | � |||�}| jr"t|d| � | j�|g�\}| j�||g� | jj|g|d� ||fS )Nzcompiling '%s':r4 )r3 r � dump_filer Zobject_filenamesr r5 �compile)r r- r. r r/ r6 �objr r r �_compile~ s zconfig._compilec
C sr | � ||||�\}}tj�tj�|��d } | jj|g| |||d� | jjd k r\| | jj } | j� | � ||| fS )Nr )r r Z target_lang)
r< r �path�splitext�basenamer Zlink_executableZ
exe_extensionr �append)
r r- r. r r r r/ r6 r; �progr r r �_link� s � z config._linkc G sT |s| j }g | _ t�dd�|�� |D ](}zt�|� W q& tk
rL Y q&X q&d S )Nz removing: %s� )r r �info�joinr �remove�OSError)r � filenamesr0 r r r �_clean� s z
config._cleanNr c C sR ddl m} | �� d}z| �||||� W n |k
rD d}Y nX | �� |S )aQ Construct a source file from 'body' (a string containing lines
of C/C++ code) and 'headers' (a list of header files to include)
and run it through the preprocessor. Return true if the
preprocessor succeeded, false if there were any errors.
('body' probably isn't of much use, but what the heck.)
r �� CompileErrorTF)r% rK r& r8 rI �r r- r. r r/ rK �okr r r �try_cpp� s
zconfig.try_cppc C sx | � � | �||||�\}}t|t�r0t�|�}t|��.}d} |�� }
|
dkrPqb|�|
�r>d} qbq>W 5 Q R X | � � | S )a� Construct a source file (just like 'try_cpp()'), run it through
the preprocessor, and return true if any line of the output matches
'pattern'. 'pattern' should either be a compiled regex object or a
string containing a regex. If both 'body' and 'headers' are None,
preprocesses an empty file -- which can be useful to determine the
symbols the preprocessor and compiler set by default.
F� T)
r& r8 r r �rer: r+ �readline�searchrI ) r �patternr- r. r r/ r6 r7 r1 �match�liner r r �
search_cpp� s
zconfig.search_cppc C sd ddl m} | �� z| �||||� d}W n |k
rD d}Y nX t�|rRdpTd� | �� |S )zwTry to compile a source file built from 'body' and 'headers'.
Return true on success, false otherwise.
r rJ TF�success!�failure.)r% rK r& r< r rD rI rL r r r � try_compile� s
zconfig.try_compilec
C sp ddl m}m} | �� z | �||||||� d} W n ||fk
rP d} Y nX t�| r^dp`d� | �� | S )z�Try to compile and link a source file, built from 'body' and
'headers', to executable form. Return true on success, false
otherwise.
r �rK � LinkErrorTFrW rX )r% rK r[ r& rB r rD rI )
r r- r. r r r r/ rK r[ rM r r r �try_link� s
�
zconfig.try_linkc
C s� ddl m}m} | �� z.| �||||||�\} }
} | �| g� d} W n ||tfk
rd d} Y nX t�| rrdptd� | � � | S )z�Try to compile, link to an executable, and run a program
built from 'body' and 'headers'. Return true on success, false
otherwise.
r rZ TFrW rX )
r% rK r[ r& rB Zspawnr r rD rI )
r r- r. r r r r/ rK r[ r6 r; ZexerM r r r �try_run� s
�
zconfig.try_runr c C st | � � g }|r |�d| � |�d� |r<|�d| � n|�d| � |�d� d�|�d }| �|||||�S )a� Determine if function 'func' is available by constructing a
source file that refers to 'func', and compiles and links it.
If everything succeeds, returns true; otherwise returns false.
The constructed source file starts out by including the header
files listed in 'headers'. If 'decl' is true, it then declares
'func' (as "int func()"); you probably shouldn't supply 'headers'
and set 'decl' true in the same call, or you might get errors about
a conflicting declarations for 'func'. Finally, the constructed
'main()' function either references 'func' or (if 'call' is true)
calls it. 'libraries' and 'library_dirs' are used when
linking.
z
int %s ();z
int main () {z %s();z %s;�}r( )r& r@ rE r\ ) r �funcr. r r r ZdeclZcallr- r r r �
check_func s
�zconfig.check_funcc C s | � � | �d|||g| |�S )a� Determine if 'library' is available to be linked against,
without actually checking that any particular symbols are provided
by it. 'headers' will be used in constructing the source file to
be compiled, but the only effect of this is to check if all the
header files listed are available. Any libraries listed in
'other_libraries' will be included in the link, in case 'library'
has symbols that depend on other libraries.
zint main (void) { })r& r\ )r Zlibraryr r. r Zother_librariesr r r � check_lib4 s
�zconfig.check_libc C s | j d|g|d�S )z�Determine if the system header file named by 'header_file'
exists and can be found by the preprocessor; return true if so,
false otherwise.
z
/* No body */)r- r. r )rN )r r2 r r r/ r r r � check_headerB s
�zconfig.check_header)NNNr )NNNr )NNr )NNNNr )NNNNr )NNNNr r )NNr )�__name__�
__module__� __qualname__Z descriptionZ user_optionsr r r! r& r3 r8 r< rB rI rN rV rY r\ r] r` ra rb r r r r r s\ �
�
�
�
�
�
�r c C sJ |dkrt �d| � n
t �|� t| �}zt �|�� � W 5 |�� X dS )zjDumps a file content into log.info.
If head is not None, will be dumped before the file content.
Nz%s)r rD r+ �close�read)r0 �headr1 r r r r9 K s
r9 )N)�__doc__r rP Zdistutils.corer Zdistutils.errorsr Zdistutils.sysconfigr Z distutilsr r* r r9 r r r r �<module> s
8 __pycache__/check.cpython-38.opt-2.pyc 0000644 00000010337 15051366004 0013425 0 ustar 00 U
e5d� � @ s� d dl mZ d dlmZ zTd dlmZ d dlmZ d dlm Z d dlm
Z
d dl m Z G dd � d e�Z
d
ZW n ek
r� d ZY nX G d d
� d
e�ZdS )� )�Command)�DistutilsSetupError)�Reporter)�Parser)�frontend)�nodes)�StringIOc @ s e Zd Zd dd�Zdd� ZdS )
�SilentReporterNr �ascii�replacec
C s" g | _ t�| |||||||� d S �N)�messagesr �__init__)�self�source� report_level�
halt_level�stream�debug�encoding�
error_handler� r �//usr/lib64/python3.8/distutils/command/check.pyr s �zSilentReporter.__init__c O s6 | j �||||f� tj|f|�|| j| d�|��S )N)�level�type)r
�appendr �system_messageZlevels)r r �messageZchildren�kwargsr r r r s ���z SilentReporter.system_message)Nr r
r )�__name__�
__module__� __qualname__r r r r r r r s �
r TFc @ s\ e Zd ZdZdddgZdddgZdd � Zd
d � Zd d
� Zdd� Z dd� Z
dd� Z dd� Z dS )�checkz"perform some checks on the package)�metadata�mzVerify meta-data)�restructuredtext�rzEChecks if long string meta-data syntax are reStructuredText-compliant)�strict�sz(Will exit with an error if a check failsr# r% r' c C s d| _ d| _d| _d| _d S )Nr � )r% r# r' � _warnings�r r r r �initialize_options1 s zcheck.initialize_optionsc C s d S r r r+ r r r �finalize_options8 s zcheck.finalize_optionsc C s | j d7 _ t�| |�S )Nr) )r* r �warn)r �msgr r r r. ; s z
check.warnc C sL | j r| �� | jr0tr"| �� n| jr0td��| jrH| jdkrHtd��d S )Nz The docutils package is needed.r z Please correct your package.)r# �check_metadatar% � HAS_DOCUTILS�check_restructuredtextr' r r* r+ r r r �run@ s
z check.runc C s� | j j}g }dD ]"}t||�r(t||�s|�|� q|rL| �dd�|� � |jrd|js�| �d� n"|j r||j
s�| �d� n
| �d� d S )N)�name�versionZurlz missing required meta-data: %sz, zLmissing meta-data: if 'author' supplied, 'author_email' must be supplied toozTmissing meta-data: if 'maintainer' supplied, 'maintainer_email' must be supplied toozimissing meta-data: either (author and author_email) or (maintainer and maintainer_email) must be supplied) � distributionr# �hasattr�getattrr r. �joinZauthorZ author_emailZ
maintainerZmaintainer_email)r r# Zmissing�attrr r r r0 P s zcheck.check_metadatac C sX | j �� }| �|�D ]>}|d �d�}|d kr8|d }nd|d |f }| �|� qd S )N����liner) z %s (line %s))r6 Zget_long_description�_check_rst_data�getr. )r �dataZwarningr< r r r r2 n s
z check.check_restructuredtextc
C s� | j jp
d}t� }tjtfd��� }d|_d |_d |_t ||j
|j |j |j
|j|jd�}tj|||d�}|�|d� z|�||� W n: tk
r� } z |j�dd| di f� W 5 d }~X Y nX |jS ) Nzsetup.py)Z
components� )r r r r )r r; z!Could not finish the parsing: %s.� )r6 Z script_namer r Z OptionParserZget_default_valuesZ tab_widthZpep_referencesZrfc_referencesr r r Zwarning_streamr Zerror_encodingZ error_encoding_error_handlerr �documentZ note_source�parse�AttributeErrorr
r )r r? � source_path�parserZsettingsZreporterrB �er r r r= y s. � �zcheck._check_rst_dataN)
r r r! Z descriptionZ user_optionsZboolean_optionsr, r- r. r3 r0 r2 r= r r r r r" $ s �
r" N)Zdistutils.corer Zdistutils.errorsr Zdocutils.utilsr Zdocutils.parsers.rstr Zdocutilsr r �ior r r1 � Exceptionr" r r r r �<module> s
__pycache__/clean.cpython-38.opt-1.pyc 0000644 00000004066 15051366004 0013433 0 ustar 00 U
e5d�
� @ sD d Z ddlZddlmZ ddlmZ ddlmZ G dd� de�ZdS )zBdistutils.command.clean
Implements the Distutils 'clean' command.� N)�Command)� remove_tree)�logc @ s> e Zd ZdZddddddgZdgZd d
� Zd d � Zd
d� ZdS )�cleanz-clean up temporary files from 'build' command)z build-base=�bz2base build directory (default: 'build.build-base'))z
build-lib=Nz<build directory for all modules (default: 'build.build-lib'))z build-temp=�tz7temporary build directory (default: 'build.build-temp'))zbuild-scripts=Nz<build directory for scripts (default: 'build.build-scripts'))z bdist-base=Nz+temporary directory for built distributions)�all�az7remove all build output, not just temporary by-productsr c C s( d | _ d | _d | _d | _d | _d | _d S )N)�
build_base� build_lib�
build_temp�
build_scripts�
bdist_baser ��self� r �//usr/lib64/python3.8/distutils/command/clean.py�initialize_options s zclean.initialize_optionsc C s" | � ddddd� | � dd� d S )NZbuild)r
r
)r r )r
r
)r r Zbdist)r r )Zset_undefined_optionsr r r r �finalize_options( s ��zclean.finalize_optionsc C s� t j�| j�r t| j| jd� nt�d| j� | jrr| j | j
| j fD ],}t j�|�rdt|| jd� qDt� d|� qD| js�z t �
| j� t�d| j� W n tk
r� Y nX d S )N)�dry_runz%'%s' does not exist -- can't clean itz
removing '%s')�os�path�existsr r r r �debugr r r r
�warn�rmdirr
�info�OSError)r Z directoryr r r �run1 s* �� � z clean.runN) �__name__�
__module__� __qualname__Z descriptionZ user_optionsZboolean_optionsr r r r r r r r s � r ) �__doc__r Zdistutils.corer Zdistutils.dir_utilr Z distutilsr r r r r r �<module> s
__pycache__/build.cpython-38.opt-2.pyc 0000644 00000007330 15051366004 0013446 0 ustar 00 U
e5d� � @ sP d dl Z d dlZd dlmZ d dlmZ d dlmZ dd� ZG dd� de�Z dS ) � N)�Command)�DistutilsOptionError)� get_platformc C s ddl m} | � d S )Nr ��show_compilers)Zdistutils.ccompilerr r � r �//usr/lib64/python3.8/distutils/command/build.pyr s r c @ s� e Zd ZdZdddddddd d
e� fd d d
ddg ZddgZdddefgZdd� Z dd� Z
dd� Z dd � Z d d � Z
d d � Zd!d"� Zd#e fd$e
fd%efd&efgZdS )'�buildz"build everything needed to install)z build-base=�bz base directory for build library)zbuild-purelib=Nz2build directory for platform-neutral distributions)zbuild-platlib=Nz3build directory for platform-specific distributions)z
build-lib=NzWbuild directory for all distribution (defaults to either build-purelib or build-platlib)zbuild-scripts=Nzbuild directory for scripts)z build-temp=�tztemporary build directoryz
plat-name=�pz6platform name to build for, if supported (default: %s))z compiler=�czspecify the compiler type)z parallel=�jz number of parallel build jobs)�debug�gz;compile extensions and libraries with debugging information)�force�fz2forcibly build everything (ignore file timestamps))z executable=�ez5specify final destination interpreter path (build.py)r r z
help-compilerNzlist available compilersc C sL d| _ d | _d | _d | _d | _d | _d | _d | _d | _d| _ d | _
d | _ d S )Nr r ) �
build_base�
build_purelib�
build_platlib� build_lib�
build_temp�
build_scriptsZcompiler� plat_namer r �
executable�parallel��selfr r r �initialize_options8 s zbuild.initialize_optionsc C sb | j d krt� | _ ntjdkr&td��d| j ftjd d� � }ttd�rR|d7 }| jd krntj �
| j d�| _| j d kr�tj �
| j d| �| _ | j
d kr�| jjr�| j | _
n| j| _
| jd kr�tj �
| j d| �| _| jd kr�tj �
| j d tjd d� �| _| jd k�r tj�r tj �tj�| _t| jt��r^zt| j�| _W n tk
�r\ td
��Y nX d S ) N�ntzW--plat-name only supported on Windows (try using './configure --help' on your platform)z .%s-%d.%d� Zgettotalrefcountz-pydebug�libZtempz
scripts-%d.%dz parallel should be an integer)r r �os�namer �sys� version_info�hasattrr �path�joinr r r � distributionZ ext_modulesr r r �normpath�
isinstancer �str�int�
ValueError)r Zplat_specifierr r r �finalize_optionsH sD
�
�
�
�zbuild.finalize_optionsc C s | � � D ]}| �|� qd S �N)Zget_sub_commandsZ run_command)r Zcmd_namer r r �run� s z build.runc C s
| j �� S r1 )r* �has_pure_modulesr r r r r3 � s zbuild.has_pure_modulesc C s
| j �� S r1 )r* �has_c_librariesr r r r r4 � s zbuild.has_c_librariesc C s
| j �� S r1 )r* �has_ext_modulesr r r r r5 � s zbuild.has_ext_modulesc C s
| j �� S r1 )r* � has_scriptsr r r r r6 � s zbuild.has_scriptsZbuild_pyZ
build_clibZ build_extr )�__name__�
__module__� __qualname__Z descriptionr Z user_optionsZboolean_optionsr Z help_optionsr r0 r2 r3 r4 r5 r6 Z sub_commandsr r r r r sH ��� ��8 �r )
r% r# Zdistutils.corer Zdistutils.errorsr Zdistutils.utilr r r r r r r �<module> s
__pycache__/install_scripts.cpython-38.opt-1.pyc 0000644 00000004137 15051366004 0015565 0 ustar 00 U
e5d� � @ sD d Z ddlZddlmZ ddlmZ ddlmZ G dd� de�ZdS )zudistutils.command.install_scripts
Implements the Distutils 'install_scripts' command, for installing
Python scripts.� N)�Command)�log)�ST_MODEc @ sL e Zd ZdZddddgZddgZdd � Zd
d � Zd d
� Zdd� Z dd� Z
dS )�install_scriptsz%install scripts (Python or otherwise))z install-dir=�dz directory to install scripts to)z
build-dir=�bz'build directory (where to install from))�force�fz-force installation (overwrite existing files))�
skip-buildNzskip the build stepsr r
c C s d | _ d| _d | _d | _d S )Nr )� install_dirr � build_dir�
skip_build��self� r �9/usr/lib64/python3.8/distutils/command/install_scripts.py�initialize_options s z"install_scripts.initialize_optionsc C s | � dd� | � dddd� d S )NZbuild)�
build_scriptsr Zinstall)r r )r r )r
r
)Zset_undefined_optionsr r r r �finalize_options! s �z install_scripts.finalize_optionsc C s� | j s| �d� | �| j| j�| _tjdkr~| �� D ]H}| j rLt
� d|� q4t� |�t
dB d@ }t
� d||� t�||� q4d S )Nr �posixzchanging mode of %sim i� zchanging mode of %s to %o)r
Z run_commandZ copy_treer r �outfiles�os�name� get_outputsZdry_runr �info�statr �chmod)r �file�moder r r �run) s
zinstall_scripts.runc C s | j jp
g S �N)Z distributionZscriptsr r r r �
get_inputs8 s zinstall_scripts.get_inputsc C s
| j pg S r )r r r r r r ; s zinstall_scripts.get_outputsN) �__name__�
__module__� __qualname__Z descriptionZ user_optionsZboolean_optionsr r r r! r r r r r r s �r ) �__doc__r Zdistutils.corer Z distutilsr r r r r r r r �<module> s
__pycache__/install.cpython-38.opt-1.pyc 0000644 00000032663 15051366004 0014023 0 ustar 00 U
&�.e�j � @ s d Z ddlZddlZddlmZ ddlmZ ddlmZ ddl m
Z
ddl m Z ddl
mZ dd lmZmZmZ dd
lmZ dd l mZ dd lmZ dd
lmZ dZdddddd�Zdddddd�dddddd�ed�Ze�rd d d d d d�ed < d d d!d"d d�ed#< dZG d$d%� d%e�Z dS )&zFdistutils.command.install
Implements the Distutils 'install' command.� N)�log)�Command)�DEBUG)�get_config_vars)�DistutilsPlatformError)�
write_file)� convert_path�
subst_vars� change_root)� get_platform)�DistutilsOptionError)� USER_BASE)� USER_SITETz$base/Lib/site-packagesz$base/Include/$dist_namez
$base/Scriptsz$base)�purelib�platlib�headers�scripts�dataz/$base/lib/python$py_version_short/site-packagesz5$platbase/lib64/python$py_version_short/site-packagesz9$base/include/python$py_version_short$abiflags/$dist_namez $base/binz$base/lib/pythonz$base/lib64/pythonz $base/include/python/$dist_name)� unix_prefix� unix_home�ntz $usersitez4$userbase/Python$py_version_nodot/Include/$dist_namez)$userbase/Python$py_version_nodot/Scriptsz $userbaseZnt_userz=$userbase/include/python$py_version_short$abiflags/$dist_namez
$userbase/bin� unix_userc @ s: e Zd ZdZdddddddd d
d d d
ddddddgZdddgZer`e�ddde f� e�d� ddiZ dd � Z
d d � Z d d � Z d!d"� Z
d#d$� Zd%d&� Zd'd(� Zd)d*� Zd+d,� Zd-d.� Zd/d0� Zd1d2� Zd3d4� Zd5d6� Zd7d8� Zd9d:� Zd;d<� Zd=d>� Zd?d@� Z dAdB� Z dCdD� Z dEefdFe fdGe fdHe fdIdJdK� fgZ dS )L�installz'install everything from build directory)zprefix=Nzinstallation prefix)z exec-prefix=Nz.(Unix only) prefix for platform-specific files)zhome=Nz+(Unix only) home directory to install under)z
install-base=Nz;base installation directory (instead of --prefix or --home))zinstall-platbase=Nz\base installation directory for platform-specific files (instead of --exec-prefix or --home))zroot=Nz<install everything relative to this alternate root directory)zinstall-purelib=Nz;installation directory for pure Python module distributions)zinstall-platlib=Nz8installation directory for non-pure module distributions)z install-lib=Nzginstallation directory for all module distributions (overrides --install-purelib and --install-platlib))zinstall-headers=Nz(installation directory for C/C++ headers)zinstall-scripts=Nz)installation directory for Python scripts)z
install-data=Nz%installation directory for data files)�compile�cz compile .py to .pyc [default])�
no-compileNzdon't compile .py files)z optimize=�Ozlalso compile with optimization: -O1 for "python -O", -O2 for "python -OO", and -O0 to disable [default: -O0])�force�fz1force installation (overwrite any existing files))�
skip-buildNz2skip rebuilding everything (for testing/debugging))zrecord=Nz3filename in which to record list of installed filesr r r �userNz!install in user site-package '%s'r c C s� d| _ d| _d| _d| _d| _d| _d| _d| _d| _d| _ d| _
d| _ d| _ t
| _t| _d| _d| _d| _d| _d| _d| _d| _d| _d| _d| _dS )zInitializes options.Nr � )�prefix� exec_prefix�homer � install_base�install_platbase�root�install_purelib�install_platlib�install_headers� install_lib�install_scripts� install_datar
�install_userbaser �install_usersiter �optimize�
extra_path�install_path_filer �
skip_build�warn_dir�
build_base� build_lib�record��self� r: �1/usr/lib64/python3.8/distutils/command/install.py�initialize_options� s2 zinstall.initialize_optionsc C sx | j s| js| jr&| js | jr&td��| jr@| j s8| jr@td��| jrl| j sd| jsd| jsd| jsd| jrltd��tjdkr�| jr�| � d� d| _| �
d� tjdkr�| � � n| � � | �
d� t
j�� d }td
d �\}}z
t
j}W n tk
r� d }Y nX | j�� | j�� | j�� |d
t
jdd� dt
jdd� |||||d� | _t�rf| j| jd< | j| jd< | � � | �
d� | j| jd< | j| jd< t �r�d dl m } t d� || j� | � � | �
d� | j�r�| �!� | j"dk�r�| jj#�r�| j$| _"n| j%| _"| �&dddd d d dd� | �'� | j"| _(tj)�*| j"| j+�| _"| j,dk �r\| �-d dddd d d � | �
d � | �.d!d"d#� dS )$zFinalizes options.zWmust supply either prefix/exec-prefix/home or install-base/install-platbase -- not bothz9must supply either home or prefix/exec-prefix -- not bothzGcan't combine user with prefix, exec_prefix/home, or install_(plat)base�posixz+exec-prefix option ignored on this platformNzpre-finalize_{unix,other}z post-finalize_{unix,other}()r r" r# � z%d.%d� z%d%d) Z dist_nameZ dist_versionZ
dist_fullname�
py_versionZpy_version_shortZpy_version_nodotZ
sys_prefixr" Zsys_exec_prefixr# �abiflags�userbaseZusersitezpost-expand_basedirs()�baseZplatbase)�pprintz config vars:zpost-expand_dirs()�libr r r r r Zlibbasezafter prepending root�build)r5 r5 )r6 r6 )/r" r# r$ r% r& r r �os�name�warn� dump_dirs�
finalize_unix�finalize_other�sys�version�splitr rA �AttributeError� distributionZget_nameZ get_versionZ get_fullname� version_info� config_vars�
HAS_USER_SITEr. r/ �expand_basedirsr rD �print� expand_dirs�create_home_pathr+ Z ext_modulesr) r( �
convert_paths�handle_extra_path�install_libbase�path�join�
extra_dirsr' � change_rootsZset_undefined_options)r9 r@ r" r# rA rD r: r: r; �finalize_options� s� ������
�
� �
�zinstall.finalize_optionsc C s� t sdS ddlm} t�|d � | jD ]r}|d }|d dkrL|dd� }|| jkrx| j| }|�|�}t| |� }n|�|�}t| |�}t�d||� q(dS )z Dumps the list of user options.Nr )�
longopt_xlate�:����=z %s: %s) r Zdistutils.fancy_getoptra r �debug� user_options� negative_opt� translate�getattr)r9 �msgra �optZopt_name�valr: r: r; rJ u s
zinstall.dump_dirsc C sV | j dk s| jdk r\| jdkr2| jdkr2| jdksP| jdksP| jdksP| jdkrXtd��dS | j r�| j
dkrtt d��| j
| _ | _| � d� n�| j
dk r�| j
| _ | _| � d� n�| jdk�r$| jdk r�td��ttd�s�tjtjks�dtjkr�d }nd
}tj�tj�| | _tj�tj�| | _n| jdk�r8| j| _| j| _ | j| _| � d � dS ) z&Finalizes options for posix platforms.NzPinstall-base or install-platbase supplied, but installation scheme is incomplete�$User base directory is not specifiedr r z*must not supply exec-prefix without prefixZ real_prefix�RPM_BUILD_ROOTz/localr> r )r% r& r+ r( r) r* r, r- r r r. r �
select_schemer$ r" r# �hasattrrM � base_prefixrG �environr\ �normpath)r9 Zadditionr: r: r; rK � sZ
������
�
�
�� zinstall.finalize_unixc C s� | j r8| jdkrtd��| j | _| _| �tjd � n�| jdk r\| j | _| _| �d� n\| j dkrvtj
� t j �| _ | j | _| _z| �tj� W n" t
k
r� tdtj ��Y nX dS )z)Finalizes options for non-posix platformsNrm Z_userr z)I don't know how to install stuff on '%s')r r. r r% r& ro rG rH r$ r" r\ rs rM �KeyErrorr8 r: r: r; rL � s&
�
�zinstall.finalize_otherc C s< t | }tD ]*}d| }t| |�dkr t| ||| � q dS )z=Sets the install directories by applying the install schemes.�install_N)�INSTALL_SCHEMES� SCHEME_KEYSri �setattr)r9 rH Zscheme�key�attrnamer: r: r; ro � s
zinstall.select_schemec C sX |D ]N}t | |�}|d k rtjdks.tjdkr:tj�|�}t|| j�}t| ||� qd S )Nr= r )ri rG rH r\ �
expanduserr rS rx )r9 �attrs�attrrl r: r: r; �
_expand_attrs� s
zinstall._expand_attrsc C s | � dddg� dS )zNCalls `os.path.expanduser` on install_base, install_platbase and
root.r% r& r' N�r~ r8 r: r: r; rU � s zinstall.expand_basedirsc C s | � ddddddg� dS )z+Calls `os.path.expanduser` on install dirs.r( r) r+ r* r, r- Nr r8 r: r: r; rW � s �zinstall.expand_dirsc G s, |D ]"}d| }t | |tt| |��� qdS )z!Call `convert_path` over `names`.ru N)rx r ri �r9 �namesrH r} r: r: r; rY � s zinstall.convert_pathsc C s� | j dkr| jj | _ | j dk r�t�d� t| j t�rB| j �d�| _ t| j �dkr`| j d }}n"t| j �dkrz| j \}}ntd��t |�}nd}d}|| _
|| _ dS ) z4Set `path_file` and `extra_dirs` using `extra_path`.NzIDistribution option extra_path is deprecated. See issue27919 for details.�,r! r r? zY'extra_path' option must be a list, tuple, or comma-separated string with 1 or 2 elementsr> ) r1 rQ r rI �
isinstance�strrO �lenr r � path_filer^ )r9 r� r^ r: r: r; rZ � s(
� �
zinstall.handle_extra_pathc G s0 |D ]&}d| }t | |t| jt| |��� qdS )z:Change the install directories pointed by name using root.ru N)rx r
r' ri r� r: r: r; r_ s zinstall.change_rootsc C sb | j s
dS ttj�d��}| j�� D ]8\}}|�|�r$tj�|�s$| � d| � t�
|d� q$dS )zCreate directories under ~.N�~zos.makedirs('%s', 0o700)i� ) r r rG r\ r{ rS �items�
startswith�isdirZ debug_print�makedirs)r9 r$ rH r\ r: r: r; rX s zinstall.create_home_pathc C s" | j s6| �d� | j�d�j}| jr6|t� kr6td��| �� D ]}| �|� q>| j r\| �
� | j r�| � � }| j
r�t| j
�}tt|��D ]}|| |d� ||< q�| �t| j |fd| j � ttjjtj�}ttjj|�}tj�tj�| j��}| j�r | j �r| j�s ||k�r t�d| j� dS )zRuns the command.rF z"Can't install when cross-compilingNz'writing list of installed files to '%s'z�modules installed to '%s', which is not in Python's module search path (sys.path) -- you'll have to change the search path yourself) r3 Z run_commandrQ Zget_command_objZ plat_namer4 r r �get_sub_commandsr� �create_path_filer7 � get_outputsr' r� �range�executer �maprG r\ rs rM �normcaser+ r2 r re )r9 Z
build_plat�cmd_name�outputsZroot_lenZcounterZsys_pathr+ r: r: r; �run( sD
������z install.runc C sJ t j�| j| jd �}| jr8| �t|| jgfd| � n| � d| � dS )zCreates the .pth file�.pthz creating %szpath file '%s' not createdN)
rG r\ r] r[ r� r2 r� r r^ rI )r9 �filenamer: r: r; r� T s
�
�zinstall.create_path_filec C sh g }| � � D ].}| �|�}|�� D ]}||kr"|�|� q"q | jrd| jrd|�tj�| j | jd �� |S )z.Assembles the outputs of all the sub-commands.r� )
r� �get_finalized_commandr� �appendr� r2 rG r\ r] r[ )r9 r� r� �cmdr� r: r: r; r� b s
�zinstall.get_outputsc C s. g }| � � D ] }| �|�}|�|�� � q |S )z*Returns the inputs of all the sub-commands)r� r� �extend�
get_inputs)r9 Zinputsr� r� r: r: r; r� s s
zinstall.get_inputsc C s | j �� p| j �� S )zSReturns true if the current distribution has any Python
modules to install.)rQ Zhas_pure_modulesZhas_ext_modulesr8 r: r: r; �has_lib s
�zinstall.has_libc C s
| j �� S )zLReturns true if the current distribution has any headers to
install.)rQ � has_headersr8 r: r: r; r� � s zinstall.has_headersc C s
| j �� S )zMReturns true if the current distribution has any scripts to.
install.)rQ � has_scriptsr8 r: r: r; r� � s zinstall.has_scriptsc C s
| j �� S )zJReturns true if the current distribution has any data to.
install.)rQ Zhas_data_filesr8 r: r: r; �has_data� s zinstall.has_datar+ r* r, r- Zinstall_egg_infoc C s dS )NTr: r8 r: r: r; �<lambda>� � zinstall.<lambda>) �__name__�
__module__� __qualname__Z descriptionrf Zboolean_optionsrT r� r rg r< r` rJ rK rL ro r~ rU rW rY rZ r_ rX r� r� r� r� r� r� r� r� Z sub_commandsr: r: r: r; r I sn �;
�
N 3 " ,
�r ) �__doc__rM rG Z distutilsr Zdistutils.corer Zdistutils.debugr Zdistutils.sysconfigr Zdistutils.errorsr Zdistutils.file_utilr Zdistutils.utilr r r
r r Zsiter
r rT ZWINDOWS_SCHEMErv rw r r: r: r: r; �<module> sb �
����
�
__pycache__/install_data.cpython-38.pyc 0000644 00000004363 15051366004 0014051 0 ustar 00 U
e5d � @ s< d Z ddlZddlmZ ddlmZmZ G dd� de�ZdS )z�distutils.command.install_data
Implements the Distutils 'install_data' command, for installing
platform-independent data files.� N)�Command)� change_root� convert_pathc @ sH e Zd ZdZdddgZdgZdd� Zdd � Zd
d � Zd d
� Z dd� Z
dS )� install_datazinstall data files)z install-dir=�dzIbase directory for installing data files (default: installation base dir))zroot=Nz<install everything relative to this alternate root directory)�force�fz-force installation (overwrite existing files)r c C s, d | _ g | _d | _d| _| jj| _d| _d S )Nr � )� install_dir�outfiles�rootr Z distribution�
data_files�warn_dir��self� r �6/usr/lib64/python3.8/distutils/command/install_data.py�initialize_options s
z install_data.initialize_optionsc C s | � dddd� d S )NZinstall)r r
)r r )r r )Zset_undefined_optionsr r r r �finalize_options# s
�z install_data.finalize_optionsc C s� | � | j� | jD ]�}t|t�rbt|�}| jrB| �d|| jf � | �|| j�\}}| j �
|� qt|d �}t j �
|�s�t j �| j|�}n| jr�t| j|�}| � |� |d g kr�| j �
|� q|d D ](}t|�}| �||�\}}| j �
|� q�qd S )NzMsetup script did not provide a directory for '%s' -- installing right in '%s'r r )Zmkpathr
r
�
isinstance�strr r �warnZ copy_filer �append�os�path�isabs�joinr r )r r �out�_�dir�datar r r �run* s,
�
zinstall_data.runc C s
| j pg S �N)r
r r r r �
get_inputsK s zinstall_data.get_inputsc C s | j S r" )r r r r r � get_outputsN s zinstall_data.get_outputsN) �__name__�
__module__� __qualname__Z descriptionZ user_optionsZboolean_optionsr r r! r# r$ r r r r r s � !r )�__doc__r Zdistutils.corer Zdistutils.utilr r r r r r r �<module> s __pycache__/install_scripts.cpython-38.opt-2.pyc 0000644 00000003731 15051366005 0015566 0 ustar 00 U
e5d� � @ s@ d dl Z d dlmZ d dlmZ d dlmZ G dd� de�ZdS )� N)�Command)�log)�ST_MODEc @ sL e Zd ZdZddddgZddgZdd � Zd
d � Zd d
� Zdd� Z dd� Z
dS )�install_scriptsz%install scripts (Python or otherwise))z install-dir=�dz directory to install scripts to)z
build-dir=�bz'build directory (where to install from))�force�fz-force installation (overwrite existing files))�
skip-buildNzskip the build stepsr r
c C s d | _ d| _d | _d | _d S )Nr )� install_dirr � build_dir�
skip_build��self� r �9/usr/lib64/python3.8/distutils/command/install_scripts.py�initialize_options s z"install_scripts.initialize_optionsc C s | � dd� | � dddd� d S )NZbuild)�
build_scriptsr Zinstall)r r )r r )r
r
)Zset_undefined_optionsr r r r �finalize_options! s �z install_scripts.finalize_optionsc C s� | j s| �d� | �| j| j�| _tjdkr~| �� D ]H}| j rLt
� d|� q4t� |�t
dB d@ }t
� d||� t�||� q4d S )Nr �posixzchanging mode of %sim i� zchanging mode of %s to %o)r
Z run_commandZ copy_treer r �outfiles�os�name� get_outputsZdry_runr �info�statr �chmod)r �file�moder r r �run) s
zinstall_scripts.runc C s | j jp
g S �N)Z distributionZscriptsr r r r �
get_inputs8 s zinstall_scripts.get_inputsc C s
| j pg S r )r r r r r r ; s zinstall_scripts.get_outputsN) �__name__�
__module__� __qualname__Z descriptionZ user_optionsZboolean_optionsr r r r! r r r r r r s �r )r Zdistutils.corer Z distutilsr r r r r r r r �<module> s __pycache__/install.cpython-38.opt-2.pyc 0000644 00000030624 15051366005 0014020 0 ustar 00 U
&�.e�j � @ s d dl Z d dlZd dlmZ d dlmZ d dlmZ d dlm Z d dl
m Z d dl m
Z
d dlmZmZmZ d d lmZ d d
l
mZ d d lmZ d d lmZ d
Zdddddd�Zdddddd�dddddd�ed�Ze�rddd d d d�ed < ddd d!d d�ed"< dZG d#d$� d$e�ZdS )%� N)�log)�Command)�DEBUG)�get_config_vars)�DistutilsPlatformError)�
write_file)� convert_path�
subst_vars� change_root)� get_platform)�DistutilsOptionError)� USER_BASE)� USER_SITETz$base/Lib/site-packagesz$base/Include/$dist_namez
$base/Scriptsz$base)�purelib�platlib�headers�scripts�dataz/$base/lib/python$py_version_short/site-packagesz5$platbase/lib64/python$py_version_short/site-packagesz9$base/include/python$py_version_short$abiflags/$dist_namez $base/binz$base/lib/pythonz$base/lib64/pythonz $base/include/python/$dist_name)� unix_prefix� unix_home�ntz $usersitez4$userbase/Python$py_version_nodot/Include/$dist_namez)$userbase/Python$py_version_nodot/Scriptsz $userbaseZnt_userz=$userbase/include/python$py_version_short$abiflags/$dist_namez
$userbase/bin� unix_userc @ s: e Zd ZdZdddddddd d
d d d
ddddddgZdddgZer`e�ddde f� e�d� ddiZ dd � Z
d d � Z d d � Z d!d"� Z
d#d$� Zd%d&� Zd'd(� Zd)d*� Zd+d,� Zd-d.� Zd/d0� Zd1d2� Zd3d4� Zd5d6� Zd7d8� Zd9d:� Zd;d<� Zd=d>� Zd?d@� Z dAdB� Z dCdD� Z dEefdFe fdGe fdHe fdIdJdK� fgZ dS )L�installz'install everything from build directory)zprefix=Nzinstallation prefix)z exec-prefix=Nz.(Unix only) prefix for platform-specific files)zhome=Nz+(Unix only) home directory to install under)z
install-base=Nz;base installation directory (instead of --prefix or --home))zinstall-platbase=Nz\base installation directory for platform-specific files (instead of --exec-prefix or --home))zroot=Nz<install everything relative to this alternate root directory)zinstall-purelib=Nz;installation directory for pure Python module distributions)zinstall-platlib=Nz8installation directory for non-pure module distributions)z install-lib=Nzginstallation directory for all module distributions (overrides --install-purelib and --install-platlib))zinstall-headers=Nz(installation directory for C/C++ headers)zinstall-scripts=Nz)installation directory for Python scripts)z
install-data=Nz%installation directory for data files)�compile�cz compile .py to .pyc [default])�
no-compileNzdon't compile .py files)z optimize=�Ozlalso compile with optimization: -O1 for "python -O", -O2 for "python -OO", and -O0 to disable [default: -O0])�force�fz1force installation (overwrite any existing files))�
skip-buildNz2skip rebuilding everything (for testing/debugging))zrecord=Nz3filename in which to record list of installed filesr r r �userNz!install in user site-package '%s'r c C s� d | _ d | _d | _d| _d | _d | _d | _d | _d | _d | _ d | _
d | _ d | _ t
| _t| _d | _d | _d | _d| _d| _d| _d| _d | _d | _d | _d S )Nr � )�prefix� exec_prefix�homer � install_base�install_platbase�root�install_purelib�install_platlib�install_headers� install_lib�install_scripts� install_datar
�install_userbaser �install_usersiter �optimize�
extra_path�install_path_filer �
skip_build�warn_dir�
build_base� build_lib�record��self� r: �1/usr/lib64/python3.8/distutils/command/install.py�initialize_options� s2 zinstall.initialize_optionsc C sx | j s| js| jr&| js | jr&td��| jr@| j s8| jr@td��| jrl| j sd| jsd| jsd| jsd| jrltd��tjdkr�| jr�| � d� d | _| �
d� tjdkr�| � � n| � � | �
d� t
j�� d }td d
�\}}z
t
j}W n tk
r� d }Y nX | j�� | j�� | j�� |d t
jd d
� dt
jd d
� |||||d� | _t�rf| j| jd< | j| jd< | � � | �
d� | j| jd< | j| jd< t �r�ddl m } t d� || j� | � � | �
d� | j�r�| �!� | j"d k�r�| jj#�r�| j$| _"n| j%| _"| �&ddddd d dd� | �'� | j"| _(tj)�*| j"| j+�| _"| j,d k �r\| �-d ddddd d � | �
d � | �.d d!d"� d S )#NzWmust supply either prefix/exec-prefix/home or install-base/install-platbase -- not bothz9must supply either home or prefix/exec-prefix -- not bothzGcan't combine user with prefix, exec_prefix/home, or install_(plat)base�posixz+exec-prefix option ignored on this platformzpre-finalize_{unix,other}z post-finalize_{unix,other}()r r" r# � z%d.%d� z%d%d) Z dist_nameZ dist_versionZ
dist_fullname�
py_versionZpy_version_shortZpy_version_nodotZ
sys_prefixr" Zsys_exec_prefixr# �abiflags�userbaseZusersitezpost-expand_basedirs()�baseZplatbase)�pprintz config vars:zpost-expand_dirs()�libr r r r r Zlibbasezafter prepending root�build)r5 r5 )r6 r6 )/r" r# r$ r% r& r r �os�name�warn� dump_dirs�
finalize_unix�finalize_other�sys�version�splitr rA �AttributeError� distributionZget_nameZ get_versionZ get_fullname� version_info� config_vars�
HAS_USER_SITEr. r/ �expand_basedirsr rD �print� expand_dirs�create_home_pathr+ Z ext_modulesr) r( �
convert_paths�handle_extra_path�install_libbase�path�join�
extra_dirsr' � change_rootsZset_undefined_options)r9 r@ r" r# rA rD r: r: r; �finalize_options� s� ������
�
� �
�zinstall.finalize_optionsc C s� t sd S ddlm} t�|d � | jD ]r}|d }|d dkrL|dd� }|| jkrx| j| }|�|�}t| |� }n|�|�}t| |�}t�d||� q(d S )Nr )�
longopt_xlate�:����=z %s: %s) r Zdistutils.fancy_getoptra r �debug� user_options� negative_opt� translate�getattr)r9 �msgra �optZopt_name�valr: r: r; rJ u s
zinstall.dump_dirsc C sV | j d k s| jd k r\| jd kr2| jd kr2| jd ksP| jd ksP| jd ksP| jd krXtd��d S | j r�| j
d krtt d��| j
| _ | _| � d� n�| j
d k r�| j
| _ | _| � d� n�| jd k�r$| jd k r�td��ttd�s�tjtjks�dtjkr�d}nd }tj�tj�| | _tj�tj�| | _n| jd k�r8| j| _| j| _ | j| _| � d
� d S ) NzPinstall-base or install-platbase supplied, but installation scheme is incomplete�$User base directory is not specifiedr r z*must not supply exec-prefix without prefixZ real_prefix�RPM_BUILD_ROOTz/localr> r )r% r& r+ r( r) r* r, r- r r r. r �
select_schemer$ r" r# �hasattrrM � base_prefixrG �environr\ �normpath)r9 Zadditionr: r: r; rK � sZ
������
�
�
�� zinstall.finalize_unixc C s� | j r8| jd krtd��| j | _| _| �tjd � n�| jd k r\| j | _| _| �d� n\| j d krvtj
� t j �| _ | j | _| _z| �tj� W n" t
k
r� tdtj ��Y nX d S )Nrm Z_userr z)I don't know how to install stuff on '%s')r r. r r% r& ro rG rH r$ r" r\ rs rM �KeyErrorr8 r: r: r; rL � s&
�
�zinstall.finalize_otherc C s< t | }tD ]*}d| }t| |�d kr t| ||| � q d S �NZinstall_)�INSTALL_SCHEMES� SCHEME_KEYSri �setattr)r9 rH Zscheme�key�attrnamer: r: r; ro � s
zinstall.select_schemec C sX |D ]N}t | |�}|d k rtjdks.tjdkr:tj�|�}t|| j�}t| ||� qd S )Nr= r )ri rG rH r\ �
expanduserr rS rx )r9 �attrs�attrrl r: r: r; �
_expand_attrs� s
zinstall._expand_attrsc C s | � dddg� d S )Nr% r& r' �r~ r8 r: r: r; rU � s zinstall.expand_basedirsc C s | � ddddddg� d S )Nr( r) r+ r* r, r- r r8 r: r: r; rW � s �zinstall.expand_dirsc G s, |D ]"}d| }t | |tt| |��� qd S ru )rx r ri �r9 �namesrH r} r: r: r; rY � s zinstall.convert_pathsc C s� | j d kr| jj | _ | j d k r�t�d� t| j t�rB| j �d�| _ t| j �dkr`| j d }}n"t| j �dkrz| j \}}ntd��t |�}nd }d}|| _
|| _ d S )NzIDistribution option extra_path is deprecated. See issue27919 for details.�,r! r r? zY'extra_path' option must be a list, tuple, or comma-separated string with 1 or 2 elementsr> ) r1 rQ r rI �
isinstance�strrO �lenr r � path_filer^ )r9 r� r^ r: r: r; rZ � s(
� �
zinstall.handle_extra_pathc G s0 |D ]&}d| }t | |t| jt| |��� qd S ru )rx r
r' ri r� r: r: r; r_ s zinstall.change_rootsc C sb | j s
d S ttj�d��}| j�� D ]8\}}|�|�r$tj�|�s$| � d| � t�
|d� q$d S )N�~zos.makedirs('%s', 0o700)i� ) r r rG r\ r{ rS �items�
startswith�isdirZ debug_print�makedirs)r9 r$ rH r\ r: r: r; rX s zinstall.create_home_pathc C s" | j s6| �d� | j�d�j}| jr6|t� kr6td��| �� D ]}| �|� q>| j r\| �
� | j r�| � � }| j
r�t| j
�}tt|��D ]}|| |d � ||< q�| �t| j |fd| j � ttjjtj�}ttjj|�}tj�tj�| j��}| j�r | j �r| j�s ||k�r t�d| j� d S )NrF z"Can't install when cross-compilingz'writing list of installed files to '%s'z�modules installed to '%s', which is not in Python's module search path (sys.path) -- you'll have to change the search path yourself) r3 Z run_commandrQ Zget_command_objZ plat_namer4 r r �get_sub_commandsr� �create_path_filer7 � get_outputsr' r� �range�executer �maprG r\ rs rM �normcaser+ r2 r re )r9 Z
build_plat�cmd_name�outputsZroot_lenZcounterZsys_pathr+ r: r: r; �run( sD
������z install.runc C sJ t j�| j| jd �}| jr8| �t|| jgfd| � n| � d| � d S )N�.pthz creating %szpath file '%s' not created)
rG r\ r] r[ r� r2 r� r r^ rI )r9 �filenamer: r: r; r� T s
�
�zinstall.create_path_filec C sh g }| � � D ].}| �|�}|�� D ]}||kr"|�|� q"q | jrd| jrd|�tj�| j | jd �� |S )Nr� )
r� �get_finalized_commandr� �appendr� r2 rG r\ r] r[ )r9 r� r� �cmdr� r: r: r; r� b s
�zinstall.get_outputsc C s. g }| � � D ] }| �|�}|�|�� � q |S �N)r� r� �extend�
get_inputs)r9 Zinputsr� r� r: r: r; r� s s
zinstall.get_inputsc C s | j �� p| j �� S r� )rQ Zhas_pure_modulesZhas_ext_modulesr8 r: r: r; �has_lib s
�zinstall.has_libc C s
| j �� S r� )rQ � has_headersr8 r: r: r; r� � s zinstall.has_headersc C s
| j �� S r� )rQ � has_scriptsr8 r: r: r; r� � s zinstall.has_scriptsc C s
| j �� S r� )rQ Zhas_data_filesr8 r: r: r; �has_data� s zinstall.has_datar+ r* r, r- Zinstall_egg_infoc C s dS )NTr: r8 r: r: r; �<lambda>� � zinstall.<lambda>) �__name__�
__module__� __qualname__Z descriptionrf Zboolean_optionsrT r� r rg r< r` rJ rK rL ro r~ rU rW rY rZ r_ rX r� r� r� r� r� r� r� r� Z sub_commandsr: r: r: r; r I sn �;
�
N 3 " ,
�r ) rM rG Z distutilsr Zdistutils.corer Zdistutils.debugr Zdistutils.sysconfigr Zdistutils.errorsr Zdistutils.file_utilr Zdistutils.utilr r r
r r Zsiter
r rT ZWINDOWS_SCHEMErv rw r r: r: r: r; �<module> s` �
����
�
__pycache__/__init__.cpython-38.opt-1.pyc 0000644 00000001041 15051366005 0014077 0 ustar 00 U
e5d � @ s2 d Z ddddddddd d
d d d
ddddddgZdS )z\distutils.command
Package containing implementation of all the standard Distutils
commands.ZbuildZbuild_pyZ build_extZ
build_clibZ
build_scriptsZcleanZinstallZ install_libZinstall_headersZinstall_scriptsZ install_dataZsdist�registerZbdistZ
bdist_dumbZ bdist_rpmZ
bdist_wininstZcheckZuploadN)�__doc__�__all__� r r �2/usr/lib64/python3.8/distutils/command/__init__.py�<module> s( � __pycache__/build_ext.cpython-38.pyc 0000644 00000037413 15051366005 0013374 0 ustar 00 U
e5dP{ � @ s� d Z ddlZddlZddlZddlZddlmZ ddlT ddlm Z m
Z
ddlm Z ddl m
Z
ddlmZ dd lmZ dd
lmZ dd lmZ e�d �Zd
d� ZG dd� de�ZdS )z�distutils.command.build_ext
Implements the Distutils 'build_ext' command, for building extension
modules (currently limited to C extensions, should accommodate C++
extensions ASAP).� N)�Command)�*)�customize_compiler�get_python_version)�get_config_h_filename)� newer_group)� Extension)� get_platform)�log)� USER_BASEz3^[a-zA-Z_][a-zA-Z_0-9]*(\.[a-zA-Z_][a-zA-Z_0-9]*)*$c C s ddl m} | � d S )Nr ��show_compilers)�distutils.ccompilerr
r � r �3/usr/lib64/python3.8/distutils/command/build_ext.pyr
s r
c @ s e Zd ZdZdej Zddddde� fdd d
d e fd d
dddde fddddddddddgZd d d d d gZ d!d"d#e
fgZ d$d%� Z d&d'� Z
d(d)� Zd*d+� Zd,d-� Zd.d/� Zd0d1� Zd2d3� Zd4d5� Zejd6d7� �Zd8d9� Zd:d;� Zd<d=� Zd>d?� Zd@dA� Z dBdC� Z dDdE� Z dFdG� Z d"S )H� build_extz8build C/C++ extensions (compile/link to build directory)z (separated by '%s'))z
build-lib=�bz(directory for compiled extension modules)z build-temp=�tz1directory for temporary files (build by-products)z
plat-name=�pz>platform name to cross-compile for, if supported (default: %s))�inplace�iziignore build-lib and put compiled extensions into the source directory alongside your pure Python modulesz
include-dirs=�Iz.list of directories to search for header files)zdefine=�Dz C preprocessor macros to define)zundef=�Uz!C preprocessor macros to undefine)z
libraries=�lz!external C libraries to link withz
library-dirs=�Lz.directories to search for external C libraries)zrpath=�Rz7directories to search for shared C libraries at runtime)z
link-objects=�Oz2extra explicit link objects to include in the link)�debug�gz'compile/link with debugging information)�force�fz2forcibly build everything (ignore file timestamps))z compiler=�czspecify the compiler type)z parallel=�jz number of parallel build jobs)�swig-cppNz)make SWIG create C++ files (default is C))z
swig-opts=Nz!list of SWIG command line options)zswig=Nzpath to the SWIG executable)�userNz#add user include, library and rpathr r r r$ r% z
help-compilerNzlist available compilersc C s� d | _ d | _d | _d | _d| _d | _d | _d | _d | _d | _ d | _
d | _ d | _ d | _
d | _d | _d | _d | _d | _d | _d | _d S )Nr )�
extensions� build_lib� plat_name�
build_tempr �package� include_dirs�define�undef� libraries� library_dirs�rpath� link_objectsr r �compiler�swig�swig_cpp� swig_optsr% �parallel��selfr r r �initialize_optionsj s* z build_ext.initialize_optionsc
C s� ddl m} | �ddddddd d
� | jd kr8| jj| _| jj| _|�� }|jd d �}| j d krn| jj pjg | _ t
| j t �r�| j � t
j�| _ tjtjkr�| j �t
j�tjd
�� | j �|� t
jj�� ||kr�| j �|� t
jj�� | �d� | �d� | jd k�rg | _| jd k�r g | _n t
| jt ��r:| j� t
j�| _| jd k�rNg | _n t
| jt ��rl| j� t
j�| _t
jdk�rh| j�t
j�tjd�� tjtjk�r�| j�t
j�tjd�� | j �r�t
j�| j d�| _ nt
j�| j d�| _ | j �t
j� t � �� t tdd �}|�r| j�|� | j!dk�r*d}n| j!dd � }t
j�tjd�}|�r\t
j�||�}| j�|� tj"d d� dk�r�tj#�$t
j�tjd���r�| j�t
j�tjdd t%� d �� n | j�d � |�&d ��r�|j'�s�| j�|�&d �� n | j�d � | j(�r | j(� d!�}d"d#� |D �| _(| j)�r4| j)� d!�| _)| j*d k�rHg | _*n| j*� d$�| _*| j+�r�t
j�t,d
�}t
j�t,d�} t
j�-|��r�| j �|� t
j�-| ��r�| j�| � | j�| � t
| j.t ��r�zt/| j.�| _.W n t0k
�r� t1d%��Y nX d S )&Nr )� sysconfigZbuild)r' r' )r) r) )r2 r2 )r r )r r )r6 r6 )r( r( � )Z
plat_specificZincluder. r1 �ntZlibsZDebugZRelease�_home�win32� ZPCbuild� �cygwin�bin�lib�pythonZconfig�.�Py_ENABLE_SHAREDZLIBDIR�,c S s g | ] }|d f�qS )�1r )�.0Zsymbolr r r �
<listcomp>� s z.build_ext.finalize_options.<locals>.<listcomp>� z parallel should be an integer)2� distutilsr: Zset_undefined_optionsr* � distributionZ ext_packageZ ext_modulesr& Zget_python_incr+ �
isinstance�str�split�os�pathsep�sys� exec_prefix�base_exec_prefix�append�path�join�extendZensure_string_listr. r/ r0 �name�prefixr r) �dirnamer �getattrr( �platform�
executable�
startswithr �get_config_varZ python_buildr, r- r5 r% r �isdirr6 �int�
ValueErrorZDistutilsOptionError)
r8 r: Z
py_includeZplat_py_includeZ _sys_home�suffixZnew_libZdefinesZ user_includeZuser_libr r r �finalize_options� s� �
�
� zbuild_ext.finalize_optionsc C sj ddl m} | jsd S | j�� rL| �d�}| j�|�� p:g � | j �
|j � || j | j
| j| jd�| _ t| j � tjdkr�| jt� kr�| j �| j� | jd k r�| j �| j� | jd k r�| jD ]\}}| j �||� q�| jd k r�| jD ]}| j �|� q�| jd k �r| j � | j� | j d k �r*| j � | j � | j d k �rD| j � | j � | j d k �r^| j �!| j � | �"� d S )Nr )� new_compiler�
build_clib)r2 �verbose�dry_runr r< )#r rg r& rM Zhas_c_libraries�get_finalized_commandr. rY Zget_library_namesr/ rV rh r2 ri rj r r rQ rZ r( r Z
initializer+ Zset_include_dirsr, Z define_macror- Zundefine_macroZ
set_librariesZset_library_dirsr0 Zset_runtime_library_dirsr1 Zset_link_objects�build_extensions)r8 rg rh rZ �value�macror r r �run s@
�
z
build_ext.runc
C sv t |t�std��t|�D �]T\}}t |t�r0qt |t�rFt|�dkrNtd��|\}}t�d|� t |t �rvt
� |�s~td��t |t �s�td��t||d �}dD ]"}|�
|�}|d k r�t|||� q�|�
d
�|_d |kr�t�d � |�
d
�}|�rhg |_g |_|D ]b} t | t��r"t| �dk�s*td��t| �dk�rJ|j�| d � nt| �dk�r|j�| � �q|||< qd S )a� Ensure that the list of extensions (presumably provided as a
command option 'extensions') is valid, i.e. it is a list of
Extension objects. We also support the old-style list of 2-tuples,
where the tuples are (ext_name, build_info), which are converted to
Extension instances here.
Raise DistutilsSetupError if the structure is invalid anywhere;
just returns otherwise.
z:'ext_modules' option must be a list of Extension instances� zMeach element of 'ext_modules' option must be an Extension instance or 2-tuplezvold-style (ext_name, build_info) tuple found in ext_modules for extension '%s' -- please convert to Extension instancezRfirst element of each tuple in 'ext_modules' must be the extension name (a string)zOsecond element of each tuple in 'ext_modules' must be a dictionary (build info)�sources)r+ r/ r. �
extra_objects�extra_compile_args�extra_link_argsNr0 Zdef_filez9'def_file' element of build info dict no longer supported�macros)r; rp z9'macros' element of build info dict must be 1- or 2-tupler; r )rN �list�DistutilsSetupError� enumerater �tuple�lenr
�warnrO �extension_name_re�match�dict�get�setattr�runtime_library_dirs�
define_macros� undef_macrosrV )
r8 r& r �ext�ext_nameZ
build_info�key�valru rn r r r �check_extensions_listV s^
�
��
��
�
�z build_ext.check_extensions_listc C s, | � | j� g }| jD ]}|�|j� q|S �N)r� r& rY rq )r8 � filenamesr� r r r �get_source_files� s
zbuild_ext.get_source_filesc C s2 | � | j� g }| jD ]}|�| �|j�� q|S r� )r� r& rV �get_ext_fullpathrZ )r8 Zoutputsr� r r r � get_outputs� s
zbuild_ext.get_outputsc C s( | � | j� | jr | �� n| �� d S r� )r� r& r6 �_build_extensions_parallel�_build_extensions_serialr7 r r r rl � s
zbuild_ext.build_extensionsc s� �j }�j dkrt�� }zddlm} W n tk
r@ d }Y nX |d krV��� d S ||d��P� � �fdd��jD �}t�j|�D ]&\}}�� |�� |�
� W 5 Q R X q�W 5 Q R X d S )NTr )�ThreadPoolExecutor)Z max_workersc s g | ]}� � �j|��qS r )Zsubmit�build_extension)rI r� �Zexecutorr8 r r rJ � s �z8build_ext._build_extensions_parallel.<locals>.<listcomp>) r6 rQ � cpu_countZconcurrent.futuresr� � ImportErrorr� r& �zip�_filter_build_errors�result)r8 Zworkersr� Zfuturesr� Zfutr r� r r� � s"
� z$build_ext._build_extensions_parallelc
C s0 | j D ]$}| �|�� | �|� W 5 Q R X qd S r� )r& r� r� )r8 r� r r r r� � s
z"build_ext._build_extensions_serialc
c sT z
d V W nD t ttfk
rN } z |js*� | �d|j|f � W 5 d }~X Y nX d S )Nz"building extension "%s" failed: %s)ZCCompilerErrorZDistutilsErrorZ CompileErrorZoptionalr{ rZ )r8 r� �er r r r� � s
�z build_ext._filter_build_errorsc
C sP |j }|d ks t|ttf�s*td|j ��t|�}| �|j�}||j }| jslt ||d�slt
� d|j� d S t
� d|j� | �
||�}|jp�g }|jd d � }|jD ]}|�|f� q�| jj|| j||j| j ||jd�}|d d � | _|jr�|�|j� |j�pg }|j�p| j�|�} | jj ||| � |�|j |j || � |�| j | j| d�
d S )Nzjin 'ext_modules' option (extension '%s'), 'sources' must be present and must be a list of source filenamesZnewerz$skipping '%s' extension (up-to-date)zbuilding '%s' extension)Z
output_dirru r+ r �extra_postargs�depends)r. r/ r� r� �export_symbolsr r) Z target_lang)!rq rN rv ry rw rZ r� r� r r r
r �info� swig_sourcesrs r� r� rV r2 �compiler) r+ Z_built_objectsrr rY rt �languageZdetect_languageZlink_shared_object�
get_librariesr/ r� �get_export_symbols)
r8 r� rq �ext_pathr� Z
extra_argsru r- Zobjectsr� r r r r� � sX ��
�
�zbuild_ext.build_extensionc C s$ g }g }i }| j r t�d� | j s6d| jks6d|jkr<d}nd}|D ]P}tj�|�\}} | dkr�|�|d | � |�|� |d ||< qD|�|� qD|s�|S | jp�| � � }
|
dg} | �
| j� | j r�| �d� | js�|jD ]} | �| � q�|D ].}|| }
t� d ||
� | � | d
|
|g � q�|S ) z�Walk the list of source files in 'sources', looking for SWIG
interface (.i) files. Run SWIG on all that are found, and
return a modified 'sources' list with SWIG source files replaced
by the generated C (or C++) files.
z/--swig-cpp is deprecated - use --swig-opts=-c++z-c++z.cppz.cz.i�_wrap���z-pythonzswigging %s to %sz-o)
r4 r
r{ r5 rQ rW �splitextrV r3 � find_swigrY r� Zspawn)r8 rq � extensionZ new_sourcesr� Z swig_targetsZ
target_ext�source�baser� r3 Zswig_cmd�o�targetr r r r� 1 s@
�
zbuild_ext.swig_sourcesc C s^ t jdkrdS t jdkrLdD ]*}t j�d| d�}t j�|�r | S q dS tdt j ��dS ) z�Return the name of the SWIG executable. On Unix, this is
just "swig" -- it should be in the PATH. Tries a bit harder on
Windows.
�posixr3 r< )z1.3z1.2z1.1z c:\swig%szswig.exez>I don't know how to find (much less run) SWIG on platform '%s'N)rQ rZ rW rX �isfileZDistutilsPlatformError)r8 Zvers�fnr r r r� g s
��zbuild_ext.find_swigc C s� | � |�}|�d�}| �|d �}| jsRtjj|dd� |g � }tj�| j|�S d�|dd� �}| �d�}tj� |�
|��}tj�||�S )z�Returns the path of the filename for a given extension.
The file is located in `build_lib` or directly in the package
(inplace option).
rE r� Nr �build_py) �get_ext_fullnamerP �get_ext_filenamer rQ rW rX r' rk �abspathZget_package_dir)r8 r� �fullname�modpath�filenamer* r� Z package_dirr r r r� s
zbuild_ext.get_ext_fullpathc C s | j dkr|S | j d | S dS )zSReturns the fullname of a given extension name.
Adds the `package.` prefixNrE )r* )r8 r� r r r r� � s
zbuild_ext.get_ext_fullnamec C s. ddl m} |�d�}|d�}tjj|� | S )z�Convert the name of an extension (eg. "foo.bar") into the name
of the file from which it will be loaded (eg. "foo/bar.so", or
"foo\bar.pyd").
r �ra rE Z
EXT_SUFFIX)�distutils.sysconfigra rP rQ rW rX )r8 r� ra r� Z
ext_suffixr r r r� � s
zbuild_ext.get_ext_filenamec C sx d|j �d�d }z|�d� W n0 tk
rR d|�d��dd��d� }Y nX d | }||jkrr|j�|� |jS )
a Return the list of symbols that a shared extension has to
export. This either uses 'ext.export_symbols' or, if it's not
provided, "PyInit_" + module_name. Only relevant on Windows, where
the .pyd file (DLL) must export the module "PyInit_" function.
�_rE r� �asciir Zpunycode� -� _ZPyInit)rZ rP �encode�UnicodeEncodeError�replace�decoder� rV )r8 r� re Z
initfunc_namer r r r� � s "
z build_ext.get_export_symbolsc C s� t jdkr^ddlm} t| j|�s�d}| jr4|d }|t jd? t jd? d@ f }|j|g S n�dd l m
} d
}|d �r�t t d �r�d
}n<t jdkr�d
}n,dt j
kr�|d�dkr�d
}n|d�dkr�d
}|r�|d�}|jd| g S |jS )z�Return the list of libraries to link against when building a
shared extension. On most platforms, this is just 'ext.libraries';
on Windows, we add the Python library (eg. python20.dll).
r> r )� MSVCCompilerz
python%d%dZ_d� � � r� FrF ZgetandroidapilevelTrA Z_PYTHON_HOST_PLATFORMZANDROID_API_LEVELZMACHDEPZ LDVERSIONrD )rS r^ Zdistutils._msvccompilerr� rN r2 r �
hexversionr. r� ra �hasattrrQ �environ)r8 r� r� �templateZ pythonlibra Zlink_libpythonZ ldversionr r r r� � s4
�
zbuild_ext.get_libraries) �__name__�
__module__� __qualname__Z descriptionrQ rR Zsep_byr Z user_optionsZboolean_optionsr
Z help_optionsr9 rf ro r� r� r� rl r� r� �
contextlib�contextmanagerr� r� r� r� r� r� r� r� r� r r r r r ! sp
�����+ �� @N
K6
r )�__doc__r� rQ �rerS Zdistutils.corer Zdistutils.errorsr� r r r Zdistutils.dep_utilr Zdistutils.extensionr Zdistutils.utilr rL r
Zsiter r� r| r
r r r r r �<module> s$ � __pycache__/build_ext.cpython-38.opt-1.pyc 0000644 00000037413 15051366005 0014333 0 ustar 00 U
e5dP{ � @ s� d Z ddlZddlZddlZddlZddlmZ ddlT ddlm Z m
Z
ddlm Z ddl m
Z
ddlmZ dd lmZ dd
lmZ dd lmZ e�d �Zd
d� ZG dd� de�ZdS )z�distutils.command.build_ext
Implements the Distutils 'build_ext' command, for building extension
modules (currently limited to C extensions, should accommodate C++
extensions ASAP).� N)�Command)�*)�customize_compiler�get_python_version)�get_config_h_filename)� newer_group)� Extension)� get_platform)�log)� USER_BASEz3^[a-zA-Z_][a-zA-Z_0-9]*(\.[a-zA-Z_][a-zA-Z_0-9]*)*$c C s ddl m} | � d S )Nr ��show_compilers)�distutils.ccompilerr
r � r �3/usr/lib64/python3.8/distutils/command/build_ext.pyr
s r
c @ s e Zd ZdZdej Zddddde� fdd d
d e fd d
dddde fddddddddddgZd d d d d gZ d!d"d#e
fgZ d$d%� Z d&d'� Z
d(d)� Zd*d+� Zd,d-� Zd.d/� Zd0d1� Zd2d3� Zd4d5� Zejd6d7� �Zd8d9� Zd:d;� Zd<d=� Zd>d?� Zd@dA� Z dBdC� Z dDdE� Z dFdG� Z d"S )H� build_extz8build C/C++ extensions (compile/link to build directory)z (separated by '%s'))z
build-lib=�bz(directory for compiled extension modules)z build-temp=�tz1directory for temporary files (build by-products)z
plat-name=�pz>platform name to cross-compile for, if supported (default: %s))�inplace�iziignore build-lib and put compiled extensions into the source directory alongside your pure Python modulesz
include-dirs=�Iz.list of directories to search for header files)zdefine=�Dz C preprocessor macros to define)zundef=�Uz!C preprocessor macros to undefine)z
libraries=�lz!external C libraries to link withz
library-dirs=�Lz.directories to search for external C libraries)zrpath=�Rz7directories to search for shared C libraries at runtime)z
link-objects=�Oz2extra explicit link objects to include in the link)�debug�gz'compile/link with debugging information)�force�fz2forcibly build everything (ignore file timestamps))z compiler=�czspecify the compiler type)z parallel=�jz number of parallel build jobs)�swig-cppNz)make SWIG create C++ files (default is C))z
swig-opts=Nz!list of SWIG command line options)zswig=Nzpath to the SWIG executable)�userNz#add user include, library and rpathr r r r$ r% z
help-compilerNzlist available compilersc C s� d | _ d | _d | _d | _d| _d | _d | _d | _d | _d | _ d | _
d | _ d | _ d | _
d | _d | _d | _d | _d | _d | _d | _d S )Nr )�
extensions� build_lib� plat_name�
build_tempr �package� include_dirs�define�undef� libraries� library_dirs�rpath� link_objectsr r �compiler�swig�swig_cpp� swig_optsr% �parallel��selfr r r �initialize_optionsj s* z build_ext.initialize_optionsc
C s� ddl m} | �ddddddd d
� | jd kr8| jj| _| jj| _|�� }|jd d �}| j d krn| jj pjg | _ t
| j t �r�| j � t
j�| _ tjtjkr�| j �t
j�tjd
�� | j �|� t
jj�� ||kr�| j �|� t
jj�� | �d� | �d� | jd k�rg | _| jd k�r g | _n t
| jt ��r:| j� t
j�| _| jd k�rNg | _n t
| jt ��rl| j� t
j�| _t
jdk�rh| j�t
j�tjd�� tjtjk�r�| j�t
j�tjd�� | j �r�t
j�| j d�| _ nt
j�| j d�| _ | j �t
j� t � �� t tdd �}|�r| j�|� | j!dk�r*d}n| j!dd � }t
j�tjd�}|�r\t
j�||�}| j�|� tj"d d� dk�r�tj#�$t
j�tjd���r�| j�t
j�tjdd t%� d �� n | j�d � |�&d ��r�|j'�s�| j�|�&d �� n | j�d � | j(�r | j(� d!�}d"d#� |D �| _(| j)�r4| j)� d!�| _)| j*d k�rHg | _*n| j*� d$�| _*| j+�r�t
j�t,d
�}t
j�t,d�} t
j�-|��r�| j �|� t
j�-| ��r�| j�| � | j�| � t
| j.t ��r�zt/| j.�| _.W n t0k
�r� t1d%��Y nX d S )&Nr )� sysconfigZbuild)r' r' )r) r) )r2 r2 )r r )r r )r6 r6 )r( r( � )Z
plat_specificZincluder. r1 �ntZlibsZDebugZRelease�_home�win32� ZPCbuild� �cygwin�bin�lib�pythonZconfig�.�Py_ENABLE_SHAREDZLIBDIR�,c S s g | ] }|d f�qS )�1r )�.0Zsymbolr r r �
<listcomp>� s z.build_ext.finalize_options.<locals>.<listcomp>� z parallel should be an integer)2� distutilsr: Zset_undefined_optionsr* � distributionZ ext_packageZ ext_modulesr& Zget_python_incr+ �
isinstance�str�split�os�pathsep�sys� exec_prefix�base_exec_prefix�append�path�join�extendZensure_string_listr. r/ r0 �name�prefixr r) �dirnamer �getattrr( �platform�
executable�
startswithr �get_config_varZ python_buildr, r- r5 r% r �isdirr6 �int�
ValueErrorZDistutilsOptionError)
r8 r: Z
py_includeZplat_py_includeZ _sys_home�suffixZnew_libZdefinesZ user_includeZuser_libr r r �finalize_options� s� �
�
� zbuild_ext.finalize_optionsc C sj ddl m} | jsd S | j�� rL| �d�}| j�|�� p:g � | j �
|j � || j | j
| j| jd�| _ t| j � tjdkr�| jt� kr�| j �| j� | jd k r�| j �| j� | jd k r�| jD ]\}}| j �||� q�| jd k r�| jD ]}| j �|� q�| jd k �r| j � | j� | j d k �r*| j � | j � | j d k �rD| j � | j � | j d k �r^| j �!| j � | �"� d S )Nr )� new_compiler�
build_clib)r2 �verbose�dry_runr r< )#r rg r& rM Zhas_c_libraries�get_finalized_commandr. rY Zget_library_namesr/ rV rh r2 ri rj r r rQ rZ r( r Z
initializer+ Zset_include_dirsr, Z define_macror- Zundefine_macroZ
set_librariesZset_library_dirsr0 Zset_runtime_library_dirsr1 Zset_link_objects�build_extensions)r8 rg rh rZ �value�macror r r �run s@
�
z
build_ext.runc
C sv t |t�std��t|�D �]T\}}t |t�r0qt |t�rFt|�dkrNtd��|\}}t�d|� t |t �rvt
� |�s~td��t |t �s�td��t||d �}dD ]"}|�
|�}|d k r�t|||� q�|�
d
�|_d |kr�t�d � |�
d
�}|�rhg |_g |_|D ]b} t | t��r"t| �dk�s*td��t| �dk�rJ|j�| d � nt| �dk�r|j�| � �q|||< qd S )a� Ensure that the list of extensions (presumably provided as a
command option 'extensions') is valid, i.e. it is a list of
Extension objects. We also support the old-style list of 2-tuples,
where the tuples are (ext_name, build_info), which are converted to
Extension instances here.
Raise DistutilsSetupError if the structure is invalid anywhere;
just returns otherwise.
z:'ext_modules' option must be a list of Extension instances� zMeach element of 'ext_modules' option must be an Extension instance or 2-tuplezvold-style (ext_name, build_info) tuple found in ext_modules for extension '%s' -- please convert to Extension instancezRfirst element of each tuple in 'ext_modules' must be the extension name (a string)zOsecond element of each tuple in 'ext_modules' must be a dictionary (build info)�sources)r+ r/ r. �
extra_objects�extra_compile_args�extra_link_argsNr0 Zdef_filez9'def_file' element of build info dict no longer supported�macros)r; rp z9'macros' element of build info dict must be 1- or 2-tupler; r )rN �list�DistutilsSetupError� enumerater �tuple�lenr
�warnrO �extension_name_re�match�dict�get�setattr�runtime_library_dirs�
define_macros� undef_macrosrV )
r8 r& r �ext�ext_nameZ
build_info�key�valru rn r r r �check_extensions_listV s^
�
��
��
�
�z build_ext.check_extensions_listc C s, | � | j� g }| jD ]}|�|j� q|S �N)r� r& rY rq )r8 � filenamesr� r r r �get_source_files� s
zbuild_ext.get_source_filesc C s2 | � | j� g }| jD ]}|�| �|j�� q|S r� )r� r& rV �get_ext_fullpathrZ )r8 Zoutputsr� r r r � get_outputs� s
zbuild_ext.get_outputsc C s( | � | j� | jr | �� n| �� d S r� )r� r& r6 �_build_extensions_parallel�_build_extensions_serialr7 r r r rl � s
zbuild_ext.build_extensionsc s� �j }�j dkrt�� }zddlm} W n tk
r@ d }Y nX |d krV��� d S ||d��P� � �fdd��jD �}t�j|�D ]&\}}�� |�� |�
� W 5 Q R X q�W 5 Q R X d S )NTr )�ThreadPoolExecutor)Z max_workersc s g | ]}� � �j|��qS r )Zsubmit�build_extension)rI r� �Zexecutorr8 r r rJ � s �z8build_ext._build_extensions_parallel.<locals>.<listcomp>) r6 rQ � cpu_countZconcurrent.futuresr� � ImportErrorr� r& �zip�_filter_build_errors�result)r8 Zworkersr� Zfuturesr� Zfutr r� r r� � s"
� z$build_ext._build_extensions_parallelc
C s0 | j D ]$}| �|�� | �|� W 5 Q R X qd S r� )r& r� r� )r8 r� r r r r� � s
z"build_ext._build_extensions_serialc
c sT z
d V W nD t ttfk
rN } z |js*� | �d|j|f � W 5 d }~X Y nX d S )Nz"building extension "%s" failed: %s)ZCCompilerErrorZDistutilsErrorZ CompileErrorZoptionalr{ rZ )r8 r� �er r r r� � s
�z build_ext._filter_build_errorsc
C sP |j }|d ks t|ttf�s*td|j ��t|�}| �|j�}||j }| jslt ||d�slt
� d|j� d S t
� d|j� | �
||�}|jp�g }|jd d � }|jD ]}|�|f� q�| jj|| j||j| j ||jd�}|d d � | _|jr�|�|j� |j�pg }|j�p| j�|�} | jj ||| � |�|j |j || � |�| j | j| d�
d S )Nzjin 'ext_modules' option (extension '%s'), 'sources' must be present and must be a list of source filenamesZnewerz$skipping '%s' extension (up-to-date)zbuilding '%s' extension)Z
output_dirru r+ r �extra_postargs�depends)r. r/ r� r� �export_symbolsr r) Z target_lang)!rq rN rv ry rw rZ r� r� r r r
r �info� swig_sourcesrs r� r� rV r2 �compiler) r+ Z_built_objectsrr rY rt �languageZdetect_languageZlink_shared_object�
get_librariesr/ r� �get_export_symbols)
r8 r� rq �ext_pathr� Z
extra_argsru r- Zobjectsr� r r r r� � sX ��
�
�zbuild_ext.build_extensionc C s$ g }g }i }| j r t�d� | j s6d| jks6d|jkr<d}nd}|D ]P}tj�|�\}} | dkr�|�|d | � |�|� |d ||< qD|�|� qD|s�|S | jp�| � � }
|
dg} | �
| j� | j r�| �d� | js�|jD ]} | �| � q�|D ].}|| }
t� d ||
� | � | d
|
|g � q�|S ) z�Walk the list of source files in 'sources', looking for SWIG
interface (.i) files. Run SWIG on all that are found, and
return a modified 'sources' list with SWIG source files replaced
by the generated C (or C++) files.
z/--swig-cpp is deprecated - use --swig-opts=-c++z-c++z.cppz.cz.i�_wrap���z-pythonzswigging %s to %sz-o)
r4 r
r{ r5 rQ rW �splitextrV r3 � find_swigrY r� Zspawn)r8 rq � extensionZ new_sourcesr� Z swig_targetsZ
target_ext�source�baser� r3 Zswig_cmd�o�targetr r r r� 1 s@
�
zbuild_ext.swig_sourcesc C s^ t jdkrdS t jdkrLdD ]*}t j�d| d�}t j�|�r | S q dS tdt j ��dS ) z�Return the name of the SWIG executable. On Unix, this is
just "swig" -- it should be in the PATH. Tries a bit harder on
Windows.
�posixr3 r< )z1.3z1.2z1.1z c:\swig%szswig.exez>I don't know how to find (much less run) SWIG on platform '%s'N)rQ rZ rW rX �isfileZDistutilsPlatformError)r8 Zvers�fnr r r r� g s
��zbuild_ext.find_swigc C s� | � |�}|�d�}| �|d �}| jsRtjj|dd� |g � }tj�| j|�S d�|dd� �}| �d�}tj� |�
|��}tj�||�S )z�Returns the path of the filename for a given extension.
The file is located in `build_lib` or directly in the package
(inplace option).
rE r� Nr �build_py) �get_ext_fullnamerP �get_ext_filenamer rQ rW rX r' rk �abspathZget_package_dir)r8 r� �fullname�modpath�filenamer* r� Z package_dirr r r r� s
zbuild_ext.get_ext_fullpathc C s | j dkr|S | j d | S dS )zSReturns the fullname of a given extension name.
Adds the `package.` prefixNrE )r* )r8 r� r r r r� � s
zbuild_ext.get_ext_fullnamec C s. ddl m} |�d�}|d�}tjj|� | S )z�Convert the name of an extension (eg. "foo.bar") into the name
of the file from which it will be loaded (eg. "foo/bar.so", or
"foo\bar.pyd").
r �ra rE Z
EXT_SUFFIX)�distutils.sysconfigra rP rQ rW rX )r8 r� ra r� Z
ext_suffixr r r r� � s
zbuild_ext.get_ext_filenamec C sx d|j �d�d }z|�d� W n0 tk
rR d|�d��dd��d� }Y nX d | }||jkrr|j�|� |jS )
a Return the list of symbols that a shared extension has to
export. This either uses 'ext.export_symbols' or, if it's not
provided, "PyInit_" + module_name. Only relevant on Windows, where
the .pyd file (DLL) must export the module "PyInit_" function.
�_rE r� �asciir Zpunycode� -� _ZPyInit)rZ rP �encode�UnicodeEncodeError�replace�decoder� rV )r8 r� re Z
initfunc_namer r r r� � s "
z build_ext.get_export_symbolsc C s� t jdkr^ddlm} t| j|�s�d}| jr4|d }|t jd? t jd? d@ f }|j|g S n�dd l m
} d
}|d �r�t t d �r�d
}n<t jdkr�d
}n,dt j
kr�|d�dkr�d
}n|d�dkr�d
}|r�|d�}|jd| g S |jS )z�Return the list of libraries to link against when building a
shared extension. On most platforms, this is just 'ext.libraries';
on Windows, we add the Python library (eg. python20.dll).
r> r )� MSVCCompilerz
python%d%dZ_d� � � r� FrF ZgetandroidapilevelTrA Z_PYTHON_HOST_PLATFORMZANDROID_API_LEVELZMACHDEPZ LDVERSIONrD )rS r^ Zdistutils._msvccompilerr� rN r2 r �
hexversionr. r� ra �hasattrrQ �environ)r8 r� r� �templateZ pythonlibra Zlink_libpythonZ ldversionr r r r� � s4
�
zbuild_ext.get_libraries) �__name__�
__module__� __qualname__Z descriptionrQ rR Zsep_byr Z user_optionsZboolean_optionsr
Z help_optionsr9 rf ro r� r� r� rl r� r� �
contextlib�contextmanagerr� r� r� r� r� r� r� r� r� r r r r r ! sp
�����+ �� @N
K6
r )�__doc__r� rQ �rerS Zdistutils.corer Zdistutils.errorsr� r r r Zdistutils.dep_utilr Zdistutils.extensionr Zdistutils.utilr rL r
Zsiter r� r| r
r r r r r �<module> s$ � __pycache__/bdist_msi.cpython-38.opt-1.pyc 0000644 00000046121 15051366005 0014325 0 ustar 00 U
e5d߉ � @ s� d Z ddlZddlZddlmZ ddlmZ ddlmZ ddl m
Z
ddl m Z ddl
mZ dd lmZ ddlZdd
lmZmZmZ dd lmZmZmZmZ G d d
� d
e�ZG dd� de�ZdS )z#
Implements the bdist_msi command.
� N)�Command)� remove_tree)�get_python_version)�
StrictVersion)�DistutilsOptionError)� get_platform)�log)�schema�sequence�text)� Directory�Feature�Dialog�add_datac @ sF e Zd ZdZdd� Zdd� Zddd �Zdd d �Zddd�Zdd� Z dS )�PyDialogz�Dialog class with a fixed layout: controls at the top, then a ruler,
then a list of buttons: back, next, cancel. Optionally a bitmap at the
left.c O s> t j| f|�� | jd }d| d }| �dd|| jd� dS )zbDialog(database, name, x, y, w, h, attributes, title, first,
default, cancel, bitmap=true)�$ � iH Z
BottomLiner N)r �__init__�h�line�w)�self�args�kwZrulerZbmwidth� r �3/usr/lib64/python3.8/distutils/command/bdist_msi.pyr s
zPyDialog.__init__c
C s | � ddddddd| � dS ) z,Set the title text of the dialog at the top.�Title� �
�@ �< � z{\VerdanaBold10}%sN)r )r �titler r r r" # s �zPyDialog.title�Back� c
C s, |r
d}nd}| � |d| jd dd|||�S )z�Add a back button with a given title, the tab-next button,
its name in the Control table, possibly initially disabled.
Return the button, so that events can be associated� r$ � � �8 � ��
pushbuttonr �r r" �next�name�active�flagsr r r �back* s z
PyDialog.back�Cancelc
C s, |r
d}nd}| � |d| jd dd|||�S )z�Add a cancel button with a given title, the tab-next button,
its name in the Control table, possibly initially disabled.
Return the button, so that events can be associatedr% r$ i0 r' r( r) r* r, r r r �cancel5 s zPyDialog.cancel�Nextc
C s, |r
d}nd}| � |d| jd dd|||�S )z�Add a Next button with a given title, the tab-next button,
its name in the Control table, possibly initially disabled.
Return the button, so that events can be associatedr% r$ �� r' r( r) r* r, r r r r- @ s z
PyDialog.nextc
C s, | � |t| j| d �| jd ddd||�S )z�Add a button with a given title, the tab-next button,
its name in the Control table, giving its x position; the
y-position is aligned with the other buttons.
Return the button, so that events can be associated� r' r( r) r% )r+ �intr r )r r. r" r- Zxposr r r �xbuttonK s zPyDialog.xbuttonN)r# r$ )r2 r$ )r4 r$ )
�__name__�
__module__� __qualname__�__doc__r r" r1 r3 r- r8 r r r r r s
r c @ s� e Zd ZdZdddde� fdddd d
d d d
g
ZddddgZddddddddddd d d d d d!d"d#d$d%gZd&Zd'd(� Z d)d*� Z
d+d,� Z d-d.� Z d/d0� Z
d1d2� Zd3d4� Zd5d6� Zd7S )8� bdist_msiz7create a Microsoft Installer (.msi) binary distribution)z
bdist-dir=Nz1temporary directory for creating the distributionz
plat-name=�pz;platform name to embed in generated filenames (default: %s))� keep-temp�kzPkeep the pseudo-installation tree around after creating the distribution archive)ztarget-version=Nz6require a specific python version on the target system)�no-target-compile�cz/do not compile .py to .pyc on the target system)�no-target-optimize�oz;do not compile .py to .pyo (optimized) on the target system)z dist-dir=�dz-directory to put final built distributions in)�
skip-buildNz2skip rebuilding everything (for testing/debugging))zinstall-script=NzUbasename of installation script to be run after installation or before deinstallation)zpre-install-script=Nz{Fully qualified filename of a script to be run before any files are installed. This script need not be in the distributionr? rA rC rF z2.0z2.1z2.2z2.3z2.4z2.5z2.6z2.7z2.8z2.9z3.0z3.1z3.2z3.3z3.4z3.5z3.6z3.7z3.8z3.9�Xc C sF d | _ d | _d| _d| _d| _d | _d | _d | _d | _d | _ d | _
d S )Nr ) � bdist_dir� plat_name� keep_tempZno_target_compileZno_target_optimize�target_version�dist_dir�
skip_build�install_script�pre_install_script�versions)r r r r �initialize_options} s z bdist_msi.initialize_optionsc C s� | � dd� | jd kr2| �d�j}tj�|d�| _t� }| jsN| j �
� rN|| _| jr�| jg| _ | j s�| j �
� r�| j|kr�t
d|f ��n t| j�| _ | � ddd� | jr�t
d��| jr�| j jD ]}| jtj�|�kr� q�q�t
d| j ��d | _d S ) NZbdist)rM rM ZmsizMtarget version can only be %s, or the '--skip-build' option must be specified)rL rL )rI rI z5the pre-install-script feature is not yet implementedz(install_script '%s' not found in scripts)Zset_undefined_optionsrH �get_finalized_command�
bdist_base�os�path�joinr rK � distribution�has_ext_modulesrP rM r �list� all_versionsrO rN Zscripts�basename�install_script_key)r rS Z
short_versionZscriptr r r �finalize_options� sH
��� �� ��zbdist_msi.finalize_optionsc C sz | j s| �d� | jddd�}| j|_| j |_ d|_| �d�}d|_d|_| j� � r�| j
}|spdt j d d� }d | j
|f }| �d�}tj�|jd
| �|_t�d | j� |�� t j�dtj�| jd �� |�� t jd= | �| j� | j�� }| � |�}tj� |�}tj� |��r"t� |� | jj }|j!} | �s<|j"} | �sFd
} |�#� }
dt$|
�j% } | j�� }| j
�r~d| j
|f } nd| } t&�'|t(| t&�)� | | �| _*t&�+| j*t,� d|
fg}
|j-�p�|j.}|�r�|
�/d|f� |j0�r�|
�/d|j0f� |
�rt1| j*d|
� | �2� | �3� | �4� | �5� | j*�6� t7| jd��r^d| j
�pJd|f}| jj8�/|� | j9�svt:| j| j;d� d S )N�build�installr$ )Zreinit_subcommandsr � install_libz%d.%d� z.%s-%s�libzinstalling to %sZPURELIBZUNKNOWNz%d.%d.%dz Python %s %sz Python %sZ DistVersionZ
ARPCONTACTZARPURLINFOABOUT�Property�
dist_filesr= �any)�dry_run)<rM Z run_commandZreinitialize_commandrH �prefixZwarn_dir�compile�optimizerW rX rK �sys� version_inforI rR rT rU rV Z
build_baseZ build_libr �infoZensure_finalized�insert�runZmkpathrL � get_fullname�get_installer_filename�abspath�exists�unlink�metadata�authorZ
maintainerZ get_versionr �version�msilibZ
init_databaser Zgen_uuid�dbZ
add_tablesr
Z author_emailZmaintainer_email�appendZurlr �add_find_python� add_files� add_scripts�add_ui�Commit�hasattrrd rJ r rf )r r_ r` rK Zplat_specifierr^ �fullname�installer_namert ru rv ZsversionZ product_nameZpropsZemail�tupr r r rn � s�
�
�
z
bdist_msi.runc
C s | j }t�d�}tj�| j�}t||d |dd�}t|ddddddd�}||d fg}| j | j
g D ]t}d| }d| } }
d} || j
kr�d
} d }
n d | } d}
t|| | | d|
|d�}t||||||
�}|� |||f� q`|� � i }|D �] \}}}|g}|�r�|�
� }t�|j�D ]�}tj�|j|�}tj�|��rld
|�|�|f }|| }
t|||||
|�}|� |� n�|j�s�|�|j|d� ||k�r�|�|� }||< || jk�r�| j�r�td| ��d| | _n*|| }t| j d|| |j|d |jfg� �qq�|� � q�|�|� d S )NZ distfiles� TARGETDIRZ SourceDir�PythonZ
Everythingr r$ )Z directory� z Python from another locationra zPython %s from registryz%s|%szMultiple files with name %sz[#%s]Z
DuplicateFile) rx rw ZCABrT rU rq rH r r
rP �
other_versionry r~ �pop�listdirZabsoluterV �isdirZ
make_shortZ componentZstart_componentZlogicalZadd_filerN r\ r r Zcommit)r rx ZcabZrootdir�root�f�itemsrv �targetr. �defaultZdescr" �level�dir�seenZfeatureZtodo�fileZafileZshortZnewdir�keyr r r r{
sf
�
� �
zbdist_msi.add_filesc C s| d}| j D �]j}d| }d| }d| }d| }d| }d| }d| } d | }
d
| } d | } tjrld }
nd
}
t| jd|d
|d|
f|d|d|
fg� t| jd||f||fg� t| jd|d| d| d f| d| d| d f|
d| d| d fg� t| jd|||f| ||d f|
d|d
fg� t| jd|||f| ||d f|
d|d
fg� t| jdd| dd | fg� |d 7 }q
dS ) as Adds code to the installer to compute the location of Python.
Properties PYTHON.MACHINE.X.Y and PYTHON.USER.X.Y will be set from the
registry for each version of Python.
Properties TARGETDIRX.Y will be set from PYTHON.USER.X.Y if defined,
else from PYTHON.MACHINE.X.Y.
Properties PYTHONX.Y will be set to TARGETDIRX.Y\python.exei� z)SOFTWARE\Python\PythonCore\%s\InstallPathzpython.machine.z python.user.zPYTHON.MACHINE.z PYTHON.USER.ZPythonFromMachineZPythonFromUserZ PythonExer� �PYTHON� ra Z
RegLocatorNr$ Z AppSearch� CustomActioni3 �[�]z ]\python.exe�InstallExecuteSequence�InstallUISequenceZ Conditionr� r z
NOT TARGETDIR� )rP rw ZWin64r rx )r �start�verZ install_pathZ machine_regZuser_regZ machine_propZ user_propZmachine_actionZ user_actionZ
exe_actionZtarget_dir_prop�exe_propZTyper r r rz C s` ������ �� ���zbdist_msi.add_find_pythonc
C s | j rjd}| j| jg D ]P}d| }d| }t| jd|d|| jfg� t| jd|d| |fg� |d7 }q| jr�tj� | j
d �}t |d
��4}|� d � t | j��}|� |�
� � W 5 Q R X W 5 Q R X t| jd d
t�|�fg� t| jddg� t| jddg� d S )Ni� zinstall_script.r� r� �2 r� z &Python%s=3r$ zpreinstall.batr zrem ="""
%1 %0
exit
"""
�Binary�
PreInstall)r� ra r� N)r� z
NOT Installedi� )rN rP r� r rx r\ rO rT rU rV rH �open�write�readrw r� )r r� r� Zinstall_actionr� Zscriptfnr� Zfinr r r r| y s6 ��
"���zbdist_msi.add_scriptsc C s�
| j }d }}d}d}d}d}d}d} t|dd d
d d d
dg� t|dddddg� t|ddddddg� t|dtj� t|dtj� t|d ||||||d d d � }
|
�d � |
jd d d d!� |
jd"d#d d!� |
�d$d%d&d'd(d)d*� |
�d+d%d,d'd-d)d.� |
j d d"d d/�} | �
d0d1� t|d2||||||d d d � } | �d3� | jd d d d!� | jd"d#d d!� | �d$d%d&d'd(d)d4� | �d+d%d,d'd-d)d.� | j d d"d d/�} | �
d0d1� t|d5||||||d d d � }
|
�d6� |
jd d d d!� |
jd"d#d d!� |
�d7d%d8d'd-d)d.� |
j d d"d d/�} | �
d0d9� t|d:||||d;|d<d<d<d=d>� }|�d?d%d@dAd%d)dB� |�d7d-dCdDd-d)dE� |�dFd-dGdHdddI� |� dJdKd-dLdHdMdNdOd d d � |jd1dPd1d/�} | �
d0d1� |j dPd<dPd/�} | �
d0dP� |jd<d1d<d/�} | �
d0d<� t |dQddRdHdSdT|dUd d � }|�dUddVdDdWddX� |�
dYdZd[d\d]dd^d ��
d0d_� |�
d`dad[d\d]ddbd ��
d0dc� |�
ddd d[d\d]dded ��
d0df� |�
dgdhd[d\d]dd"d ��
d0di� |�
djd\d[d\d]ddPd ��
d0dk� |�
dldmd[d\d]ddnd ��
d0do� |�
dpdqd[d\d]dd<d ��
d0dr� t |dsddRdtdud|d^d^d^� }|�dFdWd%dvdwddx� |�
dbd[dydzd{ddbd^�} | �
d0d1� |�
d^d|dydzd{dd^db�} | �
d0d9� t |d}ddRdtdu||d9d9d9� }|�dFdWd%dvdwdd~� |�
d9ddydzd{dd9d �} | �
d0d1� t|d�||||||d"d"d"� }|�d7d%d&d'd�d)d�� |�d�� |�dd%d�d'd-d)d��} | �ddF� |�d�d%d�d'dwd)d �} | �d�dF� |jd#d d d!� |j d�d d d!� |�d"d �} | �
d�ds� t|d�||||||d�d�d"� }|�d�� |�d�d%dwdd-dd�| j�� � |jd d d d!� |� d�d"�} d}| j
d�d�|d�� | j| jg D ](}|d7 }| j
d�d�| d�| |d�� �q
| j
d�d}|d d�� | j
d0d9|d� d�� |�d"d��} | �
d�ds� |� d�d�d%d�ddZdd�d d�d � } | �
d�d�� | j}d�| }d�| }|�d�d%dAdd%dd��} | �d�|� | �d�|� | �d�|� | �d�|� |� d�d�d%d�dd�dd�| d d�d � } | �d�|� | �d�|� | �d�|� | �d�|� t|d�||||||d�d�d�d=d>� }|�d?d%d@dAd%d)d�� |�d7d-d-dDd-d)d�� |�dFd-d�dHd�dd�� |� d�d�d-d�dHd�d�d d�d d � |�d�dnd d���
d0d9� t|d�||||||d�d�d"� }|�d�� |�d�d%d�dtddd�dXd�� }|�d�d d�d�d-d�� |�d�d d�d�d-d�� |jd#d d d!� |� d�d"�} | �
d�d�d�d� | j
d0d9d�d�� |�d"d��} | �
d�ds� t|d�||||||d"d"d"d=d>� } | �d?d-d%dAd%d)d�� | �dFd�d�ddwddġ | �d�d�d�d�d-ddơ | �dd&d�|d& d-dd��} | �ddF� | � d�d�d�dZddRd�d d�d d � } | �d�dˡ | jd d�d=d!� | j d�d"d=d!� | �d"d#��
d�ds� t|d�||||||d�d�d"� } | �d͡ | �d�d%d�dHdhddС | �d�d%d�dHd�dd�dXd�� }|�d�d d�dAd{d֡ |�d�d d�dAd{d١ | jd d d=d!� | � d d"�} | �
d�d�d�d�� | �
d�d�d�d@� | �
d�d�d�dN� | �
d�d�d�d� | �
d�d�d�d� | �
d�d�d�d� | �
d�d�d�d� | �
d�d�d�d� | �
d0d9d�d-� | �d"dѡ�
d�ds� d S )�Nr� ir i, z[ProductName] Setupr% r$ � rc )Z
DefaultUIFont�DlgFont8)Z ErrorDialog�ErrorDlg)Z Progress1ZInstall)Z Progress2Zinstalls)�MaintenanceForm_Action�Repair)�
WhichUsers�ALLZ TextStyle)r� �Tahoma� Nr )Z DlgFontBold8r� � Nr$ )Z
VerdanaBold10�Verdanar Nr$ )Z VerdanaRed9r� r� � r r� )�
PrepareDlgz(Not Privileged or Windows9x or Installed� )�
WhichUsersDlgz.Privileged and not Windows9x and not Installed� )�SelectFeaturesDlgz
Not Installedi� )�MaintenanceTypeDlgz,Installed AND NOT RESUME AND NOT Preselectedi� )� ProgressDlgNi �
ActionText�UITextZ
FatalErrorZFinishz)[ProductName] Installer ended prematurelyz< Backr )r/ r2 r# Z Description1r �F r �P r! z�[ProductName] setup ended prematurely because of an error. Your system has not been modified. To install this program at a later time, please run the installation again.Z Description2� � z.Click the Finish button to exit the Installer.)r. Z EndDialogZExitZUserExitz'[ProductName] Installer was interruptedz�[ProductName] setup was interrupted. Your system has not been modified. To install this program at a later time, please run the installation again.Z
ExitDialogz&Completing the [ProductName] InstallerZ Description�� ZReturnZ
FilesInUse� ZRetryF)Zbitmapr � �� z{\DlgFontBold8}Files in Use� i z8Some files that need to be updated are currently in use.ZText�7 iJ z�The following applications are using files that need to be updated by this setup. Close these applications and then click Retry to continue the installation or Cancel to exit it.ZListZListBox�k � � ZFileInUseProcess�Ignorer� r �e i Z ErrorTextr� �0 r� �N�x �H �Q � ZNoZErrorNo�Y�� ZYesZErrorYes�AZAbortZ
ErrorAbort�C�* Z ErrorCancel�IZ ErrorIgnore�O� ZOkZErrorOk�R�� Z
ErrorRetryZ CancelDlgi �U �� � z;Are you sure you want to cancel [ProductName] installation?�9 r( r) � ZWaitForCostingDlgzRPlease wait while the installer finishes determining your disk space requirements.�f r� �( zOPlease wait while the Installer prepares to guide you through the installation.z&Welcome to the [ProductName] Installer�n z Pondering...Z
ActionData� r4 Z SpawnDialogr� zSelect Python InstallationsZHintz9Select the Python locations where %s should be installed.zNext >z [TARGETDIR]z [SourceDir])Zorderingz
[TARGETDIR%s]z FEATURE_SELECTED AND &Python%s=3ZSpawnWaitDialogra ZFeaturesZ
SelectionTreer ZFEATUREZPathEditz[FEATURE_SELECTED]�1z!FEATURE_SELECTED AND &Python%s<>3ZOtherz$Provide an alternate Python locationZEnableZShowZDisableZHide�� � r� Z DiskCostDlgZOKz&{\DlgFontBold8}Disk Space RequirementszFThe disk space required for the installation of the selected features.�5 a The highlighted volumes (if any) do not have enough disk space available for the currently selected features. You can either remove some files from the highlighted volumes, or choose to install less features onto local drive(s), or select different destination drive(s).Z
VolumeListZVolumeCostList�d � i z{120}{70}{70}{70}{70}g �?r� Z AdminInstallzGSelect whether to install [ProductName] for all users of this computer.r� r� � zInstall for all usersZJUSTME� zInstall just for mez
[ALLUSERS]zWhichUsers="ALL"r� z({\DlgFontBold8}[Progress1] [ProductName]�# �A zYPlease wait while the Installer [Progress2] [ProductName]. This may take several minutes.Z StatusLabelzStatus:Z ProgressBari z
Progress doneZ SetProgressZProgressr� z)Welcome to the [ProductName] Setup WizardZBodyText�? z:Select whether you want to repair or remove [ProductName].ZRepairRadioGroup�l r� r� r� z&Repair [ProductName]ZRemover zRe&move [ProductName]z [REINSTALL]z MaintenanceForm_Action="Repair"z [Progress1]Z Repairingz [Progress2]ZrepairsZ Reinstallr� z[REMOVE]z MaintenanceForm_Action="Remove"� ZRemoving� Zremoves�
� z MaintenanceForm_Action<>"Change")rx r r r� r� r r" r1 r3 r- ZeventZcontrolr r+ �mappingrW ro rP r� Z conditionr8 Z
radiogroup�add) r rx �x�yr r r" ZmodalZmodelessZtrack_disk_spaceZfatalrB Z user_exitZ exit_dialogZinuse�errorr3 ZcostingZprepZseldlg�orderrv r� Zinstall_other_condZdont_install_other_condZcostZ
whichusers�gZprogressZmaintr r r r} � sv ��
�� ��
�
�� �
�� �
� ���� � � �� �� ��
�
�� �
� � � ���� �
�
� ��� � �
� � zbdist_msi.add_uic C s< | j rd|| j| j f }nd|| jf }tj�| j|�}|S )Nz%s.%s-py%s.msiz %s.%s.msi)rK rI rT rU rV rL )r r� Z base_namer� r r r rp � s �z bdist_msi.get_installer_filenameN)r9 r: r; Z descriptionr Z user_optionsZboolean_optionsrZ r� rQ r] rn r{ rz r| r} rp r r r r r= S s^ ��� �
�
([66& @r= )r< rj rT Zdistutils.corer Zdistutils.dir_utilr Zdistutils.sysconfigr Zdistutils.versionr Zdistutils.errorsr Zdistutils.utilr Z distutilsr rw r r
r r r
r r r r= r r r r �<module> s > __pycache__/sdist.cpython-38.pyc 0000644 00000034266 15051366005 0012546 0 ustar 00 U
e5d=J � @ s� d Z ddlZddlZddlmZ ddlmZ ddlmZ ddlm Z ddlm
Z
ddlm Z dd l m
Z
dd
lmZ dd lmZ dd lmZ dd
lmZmZ dd� ZG dd� de�ZdS )zadistutils.command.sdist
Implements the Distutils 'sdist' command (create a source distribution).� N)�glob)�warn)�Command)�dir_util)� file_util)� archive_util)�TextFile)�FileList)�log)� convert_path)�DistutilsTemplateError�DistutilsOptionErrorc C s` ddl m} ddlm} g }|�� D ] }|�d| d|| d f� q$|�� | |��d� dS )zoPrint all possible values for the 'formats' option (used by
the "--help-formats" command-line option).
r )� FancyGetopt)�ARCHIVE_FORMATS�formats=N� z.List of available source distribution formats:)Zdistutils.fancy_getoptr Zdistutils.archive_utilr �keys�append�sortZ
print_help)r r �formats�format� r �//usr/lib64/python3.8/distutils/command/sdist.py� show_formats s
��r c @ s" e Zd ZdZdd� Zdddddd d
d d d
ddddgZddddddgZdddefgZddd�Z d efgZ
d Z d d � Z d d!� Z
d"d#� Zd$d%� Zd&d'� Zd(d)� Zed*d+� �Zd,d-� Zd.d/� Zd0d1� Zd2d3� Zd4d5� Zd6d7� Zd8d9� Zd:d;� Zd<d=� Z d>d?� Z d@dA� Z dBdC� Z dDdE� Z dFdG� Z!dHdI� Z"dS )J�sdistz6create a source distribution (tarball, zip file, etc.)c C s | j S )zYCallable used for the check sub-command.
Placed here so user_options can view it)�metadata_check��selfr r r �checking_metadata( s zsdist.checking_metadata)z template=�tz5name of manifest template file [default: MANIFEST.in])z manifest=�mz)name of manifest file [default: MANIFEST])� use-defaultsNzRinclude the default file set in the manifest [default; disable with --no-defaults])� no-defaultsNz"don't include the default file set)�pruneNz�specifically exclude files/directories that should not be distributed (build tree, RCS/CVS dirs, etc.) [default; disable with --no-prune])�no-pruneNz$don't automatically exclude anything)�
manifest-only�ozEjust regenerate the manifest and then stop (implies --force-manifest))�force-manifest�fzkforcibly regenerate the manifest and carry on as usual. Deprecated: now the manifest is always regenerated.)r Nz6formats for source distribution (comma-separated list))� keep-temp�kz@keep the distribution tree around after creating archive file(s))z dist-dir=�dzFdirectory to put the source distribution archive(s) in [default: dist])�metadata-checkNz[Ensure that all required elements of meta-data are supplied. Warn if any missing. [default])zowner=�uz@Owner name used when creating a tar file [default: current user])zgroup=�gzAGroup name used when creating a tar file [default: current group]r! r# r% r' r) r, z help-formatsNz#list available distribution formats)r" r$ �check)ZREADMEz
README.txtz
README.rstc C sT d | _ d | _d| _d| _d| _d| _dg| _d| _d | _d | _ d| _
d | _ d | _ d S )N� r Zgztar)
�template�manifest� use_defaultsr# �
manifest_onlyZforce_manifestr � keep_temp�dist_dir�
archive_filesr �owner�groupr r r r �initialize_optionse s zsdist.initialize_optionsc C sZ | j d krd| _ | jd kr d| _| �d� t�| j�}|rFtd| ��| jd krVd| _d S )NZMANIFESTz MANIFEST.inr zunknown archive format '%s'Zdist)r2 r1 Zensure_string_listr Zcheck_archive_formatsr r
r6 )r Z
bad_formatr r r �finalize_options| s
�
zsdist.finalize_optionsc C s> t � | _| �� D ]}| �|� q| �� | jr2d S | �� d S �N)r �filelistZget_sub_commandsZ run_command�
get_file_listr4 �make_distribution)r Zcmd_namer r r �run� s z sdist.runc C s* t dt� | j�d�}|�� |�� dS )zDeprecated API.zadistutils.command.sdist.check_metadata is deprecated, use the check command insteadr/ N)r �PendingDeprecationWarning� distributionZget_command_objZensure_finalizedr@ )r r/ r r r �check_metadata� s � zsdist.check_metadatac C s� t j�| j�}|s:| �� r:| �� | j�� | j�� dS |sN| � d| j � | j�
� | j rf| � � |rr| �
� | jr�| �� | j�� | j�� | �� dS )aC Figure out the list of files to include in the source
distribution, and put it in 'self.filelist'. This might involve
reading the manifest template (and writing the manifest), or just
reading the manifest, or just using the default file set -- it all
depends on the user's options.
Nz?manifest template '%s' does not exist (using default file list))�os�path�isfiler1 �_manifest_is_not_generated�
read_manifestr= r Zremove_duplicatesr �findallr3 � add_defaults�
read_templater# �prune_file_list�write_manifest)r Ztemplate_existsr r r r> � s(
�
zsdist.get_file_listc C s< | � � | �� | �� | �� | �� | �� | �� dS )a9 Add all the default files to self.filelist:
- README or README.txt
- setup.py
- test/test*.py
- all pure Python modules mentioned in setup script
- all files pointed by package_data (build_py)
- all files defined in data_files.
- all files defined as scripts.
- all C sources listed as part of extensions or C libraries
in the setup script (doesn't catch C headers!)
Warns if (README or README.txt) or setup.py are missing; everything
else is optional.
N)�_add_defaults_standards�_add_defaults_optional�_add_defaults_python�_add_defaults_data_files�_add_defaults_ext�_add_defaults_c_libs�_add_defaults_scriptsr r r r rJ � s zsdist.add_defaultsc C s: t j�| �sdS t j�| �}t j�|�\}}|t �|�kS )z�
Case-sensitive path existence check
>>> sdist._cs_path_exists(__file__)
True
>>> sdist._cs_path_exists(__file__.upper())
False
F)rD rE �exists�abspath�split�listdir)�fspathrV Z directory�filenamer r r �_cs_path_exists� s
zsdist._cs_path_existsc C s� | j | jjg}|D ]~}t|t�rj|}d}|D ]"}| �|�r,d}| j�|� qPq,|s�| �dd� |� � q| �|�r�| j�|� q| �d| � qd S )NFTz,standard file not found: should have one of z, z standard file '%s' not found)
�READMESrB Z script_name�
isinstance�tupler[ r= r r �join)r Z standards�fnZaltsZgot_itr r r rN � s"
�
z sdist._add_defaults_standardsc C s4 ddg}|D ]"}t tjjt|��}| j�|� q d S )Nz
test/test*.pyz setup.cfg)�filterrD rE rF r r= �extend)r Zoptional�pattern�filesr r r rO s z sdist._add_defaults_optionalc C s\ | � d�}| j�� r$| j�|�� � |jD ],\}}}}|D ]}| j�tj �
||�� q:q*d S )N�build_py) �get_finalized_commandrB Zhas_pure_modulesr= rb �get_source_files�
data_filesr rD rE r_ )r re ZpkgZsrc_dirZ build_dir� filenamesrZ r r r rP s
zsdist._add_defaults_pythonc C sz | j �� rv| j jD ]b}t|t�rBt|�}tj�|�rt| j �
|� q|\}}|D ]$}t|�}tj�|�rN| j �
|� qNqd S r< ) rB Zhas_data_filesrh r] �strr rD rE rF r= r )r �item�dirnameri r( r r r rQ $ s
z sdist._add_defaults_data_filesc C s( | j �� r$| �d�}| j�|�� � d S )N� build_ext)rB Zhas_ext_modulesrf r= rb rg )r rm r r r rR 5 s
zsdist._add_defaults_extc C s( | j �� r$| �d�}| j�|�� � d S )N�
build_clib)rB Zhas_c_librariesrf r= rb rg )r rn r r r rS : s
zsdist._add_defaults_c_libsc C s( | j �� r$| �d�}| j�|�� � d S )N�
build_scripts)rB Z has_scriptsrf r= rb rg )r ro r r r rT ? s
zsdist._add_defaults_scriptsc
C s� t �d| j� t| jddddddd�}zh|�� }|dkr:q�z| j�|� W q( tt fk
r� } z | �
d|j |j |f � W 5 d}~X Y q(X q(W 5 |�� X dS )z�Read and parse manifest template file named by self.template.
(usually "MANIFEST.in") The parsing and processing is done by
'self.filelist', which updates itself accordingly.
z reading manifest template '%s'r0 )Zstrip_commentsZ skip_blanksZ
join_linesZ lstrip_wsZ rstrip_wsZ
collapse_joinNz%s, line %d: %s)
r
�infor1 r �close�readliner= Zprocess_template_liner �
ValueErrorr rZ Z current_line)r r1 �line�msgr r r rK D s&
�
� zsdist.read_templatec C s� | � d�}| j�� }| jjd|jd� | jjd|d� tjdkrFd}nd}ddd d
d d d
g}d|d�|�|f }| jj|dd� dS )av Prune off branches that might slip into the file list as created
by 'read_template()', but really don't belong there:
* the build tree (typically "build")
* the release tree itself (only an issue if we ran "sdist"
previously with --keep-temp, or it aborted)
* any RCS, CVS, .svn, .hg, .git, .bzr, _darcs directories
�buildN)�prefixZwin32z/|\\�/ZRCSZCVSz\.svnz\.hgz\.gitz\.bzrZ_darcsz(^|%s)(%s)(%s).*�|r0 )Zis_regex) rf rB � get_fullnamer= Zexclude_patternZ
build_base�sys�platformr_ )r rv �base_dirZsepsZvcs_dirsZvcs_ptrnr r r rL a s
�zsdist.prune_file_listc C sX | � � r t�d| j � dS | jjdd� }|�dd� | �tj | j|fd| j � dS )z�Write the file list in 'self.filelist' (presumably as filled in
by 'add_defaults()' and 'read_template()') to the manifest file
named by 'self.manifest'.
z5not writing to manually maintained manifest file '%s'Nr z*# file GENERATED by distutils, do NOT editzwriting manifest file '%s')
rG r
rp r2 r= rd �insertZexecuter Z
write_file)r Zcontentr r r rM y s � �zsdist.write_manifestc C s< t j�| j�sdS t| j�}z |�� }W 5 |�� X |dkS )NFz+# file GENERATED by distutils, do NOT edit
)rD rE rF r2 �openrq rr )r �fpZ
first_liner r r rG � s
z sdist._manifest_is_not_generatedc C sV t �d| j� t| j��4}|D ](}|�� }|�d�s |s:q | j�|� q W 5 Q R X dS )z�Read the manifest file (named by 'self.manifest') and use it to
fill in 'self.filelist', the list of files to include in the source
distribution.
zreading manifest file '%s'�#N)r
rp r2 r �strip�
startswithr= r )r r2 rt r r r rH � s zsdist.read_manifestc C s� | � |� tj||| jd� ttd�r4d}d| }n d}d| }|sPt�d� n
t�|� |D ]<}tj �
|�s|t�d|� q^tj � ||�}| j |||d � q^| j
j�|� dS )
a� Create the directory tree that will become the source
distribution archive. All directories implied by the filenames in
'files' are created under 'base_dir', and then we hard link or copy
(if hard linking is unavailable) those files into place.
Essentially, this duplicates the developer's source tree, but in a
directory named after the distribution, containing only the files
to be distributed.
��dry_run�linkZhardzmaking hard links in %s...Nzcopying files to %s...z)no files to distribute -- empty manifest?z#'%s' not a regular file -- skipping)r� )Zmkpathr Z create_treer� �hasattrrD r
r rp rE rF r_ Z copy_filerB ZmetadataZwrite_pkg_info)r r} rd r� ru �file�destr r r �make_release_tree� s
zsdist.make_release_treec C s� | j �� }tj�| j|�}| �|| jj� g }d| j krT| j �
| j � | j � d��� | j D ]:}| j
|||| j| jd�}|�
|� | j j�
dd|f� qZ|| _| js�tj|| jd� dS )a� Create the source distribution(s). First, we create the release
tree with 'make_release_tree()'; then, we create all required
archive files (according to 'self.formats') from the release tree.
Finally, we clean up by blowing away the release tree (unless
'self.keep_temp' is true). The list of archive files created is
stored so it can be retrieved later by 'get_archive_files()'.
Ztar)r} r8 r9 r � r� N)rB rz rD rE r_ r6 r� r= rd r r �pop�indexZ make_archiver8 r9 Z
dist_filesr7 r5 r Z remove_treer� )r r} Z base_namer7 Zfmtr� r r r r? � s
�
zsdist.make_distributionc C s | j S )zzReturn the list of archive files created when the command
was run, or None if the command hasn't run yet.
)r7 r r r r �get_archive_files� s zsdist.get_archive_files)#�__name__�
__module__� __qualname__Z descriptionr Z user_optionsZboolean_optionsr Z help_optionsZ negative_optZ sub_commandsr\ r: r; r@ rC r> rJ � staticmethodr[ rN rO rP rQ rR rS rT rK rL rM rG rH r� r? r� r r r r r $ sp �' � ���
(
* r )�__doc__rD r{ r �warningsr Zdistutils.corer Z distutilsr r r Zdistutils.text_filer Zdistutils.filelistr r
Zdistutils.utilr Zdistutils.errorsr r
r r r r r r �<module> s __pycache__/build_clib.cpython-38.opt-2.pyc 0000644 00000010246 15051366005 0014440 0 ustar 00 U
e5dV � @ sP d dl Z d dlmZ d dlT d dlmZ d dlmZ dd� ZG dd � d e�Z dS )
� N)�Command)�*)�customize_compiler)�logc C s ddl m} | � d S )Nr ��show_compilers)�distutils.ccompilerr r � r �4/usr/lib64/python3.8/distutils/command/build_clib.pyr s r c @ sl e Zd ZdZdddddgZddgZd d
d efgZd d
� Zdd� Z dd� Z
dd� Z dd� Z dd� Z
dd� Zd
S )�
build_clibz/build C/C++ libraries used by Python extensions)z build-clib=�bz%directory to build C/C++ libraries to)z build-temp=�tz,directory to put temporary build by-products)�debug�gz"compile with debugging information)�force�fz2forcibly build everything (ignore file timestamps))z compiler=�czspecify the compiler typer r z
help-compilerNzlist available compilersc C s: d | _ d | _d | _d | _d | _d | _d | _d| _d | _d S )Nr ) r �
build_temp� libraries� include_dirs�define�undefr r �compiler��selfr r r
�initialize_options4 s z build_clib.initialize_optionsc C sh | � dddddd� | jj| _| jr0| �| j� | jd krH| jjpDg | _t| jt�rd| j�tj �| _d S )NZbuild)r r )r r )r r )r r )r r )
Zset_undefined_optionsZ distributionr �check_library_listr �
isinstance�str�split�os�pathsepr r r r
�finalize_optionsD s �
zbuild_clib.finalize_optionsc C s� | j s
d S ddlm} || j| j| jd�| _t| j� | jd k rN| j�| j� | j d k rv| j D ]\}}| j�
||� q^| j d k r�| j D ]}| j� |� q�| �
| j � d S )Nr )� new_compiler)r �dry_runr )r r r# r r$ r r r Zset_include_dirsr Z define_macror Zundefine_macro�build_libraries)r r# �name�valueZmacror r r
�run^ s" �
zbuild_clib.runc C s� t |t�std��|D ]z}t |t�s8t|�dkr8td��|\}}t |t�sRtd��d|ksntjdkr~tj|kr~td|d ��t |t�std��qd S ) Nz+'libraries' option must be a list of tuples� z*each element of 'libraries' must a 2-tuplezNfirst element of each tuple in 'libraries' must be a string (the library name)�/z;bad library name '%s': may not contain directory separatorsr zMsecond element of each tuple in 'libraries' must be a dictionary (build info)) r �list�DistutilsSetupError�tuple�lenr r �sep�dict)r r �libr& �
build_infor r r
r v s,
��
� �
�z build_clib.check_library_listc C s, | j s
d S g }| j D ]\}}|�|� q|S )N)r �append)r Z lib_names�lib_namer2 r r r
�get_library_names� s z build_clib.get_library_namesc C sZ | � | j� g }| jD ]>\}}|�d�}|d ks>t|ttf�sJtd| ��|�|� q|S )N�sources�fin 'libraries' option (library '%s'), 'sources' must be present and must be a list of source filenames)r r �getr r+ r- r, �extend)r � filenamesr4 r2 r6 r r r
�get_source_files� s
�� zbuild_clib.get_source_filesc C s� |D ]�\}}|� d�}|d ks,t|ttf�s8td| ��t|�}t�d|� |� d�}|� d�}| jj|| j ||| j
d�}| jj ||| j | j
d� qd S )Nr6 r7 zbuilding '%s' library�macrosr )�
output_dirr< r r )r= r )
r8 r r+ r- r, r �infor �compiler r Zcreate_static_libr )r r r4 r2 r6 r< r Zobjectsr r r
r% � s,
��
�
�zbuild_clib.build_libraries)�__name__�
__module__� __qualname__Z descriptionZ user_optionsZboolean_optionsr Z help_optionsr r" r( r r5 r; r% r r r r
r s( �
��$ r )
r Zdistutils.corer Zdistutils.errorsZdistutils.sysconfigr Z distutilsr r r r r r r
�<module> s __pycache__/__init__.cpython-38.opt-2.pyc 0000644 00000000664 15051366005 0014112 0 ustar 00 U
e5d � @ s. d ddddddddd d
d d d
dddddgZ dS )ZbuildZbuild_pyZ build_extZ
build_clibZ
build_scriptsZcleanZinstallZ install_libZinstall_headersZinstall_scriptsZ install_dataZsdist�registerZbdistZ
bdist_dumbZ bdist_rpmZ
bdist_wininstZcheckZuploadN)�__all__� r r �2/usr/lib64/python3.8/distutils/command/__init__.py�<module> s& � __pycache__/sdist.cpython-38.opt-2.pyc 0000644 00000025627 15051366005 0013507 0 ustar 00 U
e5d=J � @ s� d dl Z d dlZd dlmZ d dlmZ d dlmZ d dlmZ d dlm Z d dlm
Z
d dl m Z d d l
mZ d d
lmZ d d lmZ d d lmZmZ d
d� ZG dd� de�ZdS )� N)�glob)�warn)�Command)�dir_util)� file_util)� archive_util)�TextFile)�FileList)�log)� convert_path)�DistutilsTemplateError�DistutilsOptionErrorc C s` ddl m} ddlm} g }|�� D ] }|�d| d || d f� q$|�� | |��d� d S )Nr )� FancyGetopt)�ARCHIVE_FORMATS�formats=� z.List of available source distribution formats:)Zdistutils.fancy_getoptr Zdistutils.archive_utilr �keys�append�sortZ
print_help)r r �formats�format� r �//usr/lib64/python3.8/distutils/command/sdist.py� show_formats s
��r c @ s" e Zd ZdZdd� Zdddddd d
d d d
ddddgZddddddgZdddefgZddd�Z d efgZ
d Z d d � Z d d!� Z
d"d#� Zd$d%� Zd&d'� Zd(d)� Zed*d+� �Zd,d-� Zd.d/� Zd0d1� Zd2d3� Zd4d5� Zd6d7� Zd8d9� Zd:d;� Zd<d=� Z d>d?� Z d@dA� Z dBdC� Z dDdE� Z dFdG� Z!dHdI� Z"dS )J�sdistz6create a source distribution (tarball, zip file, etc.)c C s | j S �N)�metadata_check��selfr r r �checking_metadata( s zsdist.checking_metadata)z template=�tz5name of manifest template file [default: MANIFEST.in])z manifest=�mz)name of manifest file [default: MANIFEST])� use-defaultsNzRinclude the default file set in the manifest [default; disable with --no-defaults])� no-defaultsNz"don't include the default file set)�pruneNz�specifically exclude files/directories that should not be distributed (build tree, RCS/CVS dirs, etc.) [default; disable with --no-prune])�no-pruneNz$don't automatically exclude anything)�
manifest-only�ozEjust regenerate the manifest and then stop (implies --force-manifest))�force-manifest�fzkforcibly regenerate the manifest and carry on as usual. Deprecated: now the manifest is always regenerated.)r Nz6formats for source distribution (comma-separated list))� keep-temp�kz@keep the distribution tree around after creating archive file(s))z dist-dir=�dzFdirectory to put the source distribution archive(s) in [default: dist])�metadata-checkNz[Ensure that all required elements of meta-data are supplied. Warn if any missing. [default])zowner=�uz@Owner name used when creating a tar file [default: current user])zgroup=�gzAGroup name used when creating a tar file [default: current group]r" r$ r& r( r* r- z help-formatsNz#list available distribution formats)r# r% �check)ZREADMEz
README.txtz
README.rstc C sT d | _ d | _d| _d| _d| _d| _dg| _d| _d | _d | _ d| _
d | _ d | _ d S )N� r Zgztar)
�template�manifest� use_defaultsr$ �
manifest_onlyZforce_manifestr � keep_temp�dist_dir�
archive_filesr �owner�groupr r r r �initialize_optionse s zsdist.initialize_optionsc C sZ | j d krd| _ | jd kr d| _| �d� t�| j�}|rFtd| ��| jd krVd| _d S )NZMANIFESTz MANIFEST.inr zunknown archive format '%s'Zdist)r3 r2 Zensure_string_listr Zcheck_archive_formatsr r
r7 )r Z
bad_formatr r r �finalize_options| s
�
zsdist.finalize_optionsc C s> t � | _| �� D ]}| �|� q| �� | jr2d S | �� d S r )r �filelistZget_sub_commandsZ run_command�
get_file_listr5 �make_distribution)r Zcmd_namer r r �run� s z sdist.runc C s* t dt� | j�d�}|�� |�� d S )Nzadistutils.command.sdist.check_metadata is deprecated, use the check command insteadr0 )r �PendingDeprecationWarning� distributionZget_command_objZensure_finalizedr@ )r r0 r r r �check_metadata� s � zsdist.check_metadatac C s� t j�| j�}|s:| �� r:| �� | j�� | j�� d S |sN| � d| j � | j�
� | j rf| � � |rr| �
� | jr�| �� | j�� | j�� | �� d S )Nz?manifest template '%s' does not exist (using default file list))�os�path�isfiler2 �_manifest_is_not_generated�
read_manifestr= r Zremove_duplicatesr �findallr4 � add_defaults�
read_templater$ �prune_file_list�write_manifest)r Ztemplate_existsr r r r> � s(
�
zsdist.get_file_listc C s< | � � | �� | �� | �� | �� | �� | �� d S r )�_add_defaults_standards�_add_defaults_optional�_add_defaults_python�_add_defaults_data_files�_add_defaults_ext�_add_defaults_c_libs�_add_defaults_scriptsr r r r rJ � s zsdist.add_defaultsc C s: t j�| �sdS t j�| �}t j�|�\}}|t �|�kS )NF)rD rE �exists�abspath�split�listdir)�fspathrV Z directory�filenamer r r �_cs_path_exists� s
zsdist._cs_path_existsc C s� | j | jjg}|D ]~}t|t�rj|}d}|D ]"}| �|�r,d}| j�|� qPq,|s�| �dd� |� � q| �|�r�| j�|� q| �d| � qd S )NFTz,standard file not found: should have one of z, z standard file '%s' not found)
�READMESrB Z script_name�
isinstance�tupler[ r= r r �join)r Z standards�fnZaltsZgot_itr r r rN � s"
�
z sdist._add_defaults_standardsc C s4 ddg}|D ]"}t tjjt|��}| j�|� q d S )Nz
test/test*.pyz setup.cfg)�filterrD rE rF r r= �extend)r Zoptional�pattern�filesr r r rO s z sdist._add_defaults_optionalc C s\ | � d�}| j�� r$| j�|�� � |jD ],\}}}}|D ]}| j�tj �
||�� q:q*d S )N�build_py) �get_finalized_commandrB Zhas_pure_modulesr= rb �get_source_files�
data_filesr rD rE r_ )r re ZpkgZsrc_dirZ build_dir� filenamesrZ r r r rP s
zsdist._add_defaults_pythonc C sz | j �� rv| j jD ]b}t|t�rBt|�}tj�|�rt| j �
|� q|\}}|D ]$}t|�}tj�|�rN| j �
|� qNqd S r ) rB Zhas_data_filesrh r] �strr rD rE rF r= r )r �item�dirnameri r) r r r rQ $ s
z sdist._add_defaults_data_filesc C s( | j �� r$| �d�}| j�|�� � d S )N� build_ext)rB Zhas_ext_modulesrf r= rb rg )r rm r r r rR 5 s
zsdist._add_defaults_extc C s( | j �� r$| �d�}| j�|�� � d S )N�
build_clib)rB Zhas_c_librariesrf r= rb rg )r rn r r r rS : s
zsdist._add_defaults_c_libsc C s( | j �� r$| �d�}| j�|�� � d S )N�
build_scripts)rB Z has_scriptsrf r= rb rg )r ro r r r rT ? s
zsdist._add_defaults_scriptsc
C s� t �d| j� t| jddddddd�}zh|�� }|d kr:q�z| j�|� W q( tt fk
r� } z | �
d|j |j |f � W 5 d }~X Y q(X q(W 5 |�� X d S )Nz reading manifest template '%s'r1 )Zstrip_commentsZ skip_blanksZ
join_linesZ lstrip_wsZ rstrip_wsZ
collapse_joinz%s, line %d: %s)
r
�infor2 r �close�readliner= Zprocess_template_liner �
ValueErrorr rZ Z current_line)r r2 �line�msgr r r rK D s&
�
� zsdist.read_templatec C s� | � d�}| j�� }| jjd |jd� | jjd |d� tjdkrFd}nd}dddd d
d d g}d
|d�|�|f }| jj|dd� d S )N�build)�prefixZwin32z/|\\�/ZRCSZCVSz\.svnz\.hgz\.gitz\.bzrZ_darcsz(^|%s)(%s)(%s).*�|r1 )Zis_regex) rf rB � get_fullnamer= Zexclude_patternZ
build_base�sys�platformr_ )r rv �base_dirZsepsZvcs_dirsZvcs_ptrnr r r rL a s
�zsdist.prune_file_listc C sX | � � r t�d| j � d S | jjd d � }|�dd� | �tj | j|fd| j � d S )Nz5not writing to manually maintained manifest file '%s'r z*# file GENERATED by distutils, do NOT editzwriting manifest file '%s')
rG r
rp r3 r= rd �insertZexecuter Z
write_file)r Zcontentr r r rM y s � �zsdist.write_manifestc C s< t j�| j�sdS t| j�}z |�� }W 5 |�� X |dkS )NFz+# file GENERATED by distutils, do NOT edit
)rD rE rF r3 �openrq rr )r �fpZ
first_liner r r rG � s
z sdist._manifest_is_not_generatedc C sV t �d| j� t| j��4}|D ](}|�� }|�d�s |s:q | j�|� q W 5 Q R X d S )Nzreading manifest file '%s'�#)r
rp r3 r �strip�
startswithr= r )r r3 rt r r r rH � s zsdist.read_manifestc C s� | � |� tj||| jd� ttd�r4d}d| }n d }d| }|sPt�d� n
t�|� |D ]<}tj �
|�s|t�d|� q^tj � ||�}| j |||d� q^| j
j�|� d S ) N��dry_run�linkZhardzmaking hard links in %s...zcopying files to %s...z)no files to distribute -- empty manifest?z#'%s' not a regular file -- skipping)r� )Zmkpathr Z create_treer� �hasattrrD r
r rp rE rF r_ Z copy_filerB ZmetadataZwrite_pkg_info)r r} rd r� ru �file�destr r r �make_release_tree� s
zsdist.make_release_treec C s� | j �� }tj�| j|�}| �|| jj� g }d| j krT| j �
| j � | j � d��� | j D ]:}| j
|||| j| jd�}|�
|� | j j�
dd|f� qZ|| _| js�tj|| jd� d S )NZtar)r} r9 r: r � r� )rB rz rD rE r_ r7 r� r= rd r r �pop�indexZ make_archiver9 r: Z
dist_filesr8 r6 r Z remove_treer� )r r} Z base_namer8 Zfmtr� r r r r? � s
�
zsdist.make_distributionc C s | j S r )r8 r r r r �get_archive_files� s zsdist.get_archive_files)#�__name__�
__module__� __qualname__Z descriptionr Z user_optionsZboolean_optionsr Z help_optionsZ negative_optZ sub_commandsr\ r; r< r@ rC r> rJ � staticmethodr[ rN rO rP rQ rR rS rT rK rL rM rG rH r� r? r� r r r r r $ sp �' � ���
(
* r )rD r{ r �warningsr Zdistutils.corer Z distutilsr r r Zdistutils.text_filer Zdistutils.filelistr r
Zdistutils.utilr Zdistutils.errorsr r
r r r r r r �<module> s __pycache__/register.cpython-38.opt-1.pyc 0000644 00000020411 15051366005 0014166 0 ustar 00 U
e5d�- � @ sd d Z ddlZddlZddlZddlZddlmZ ddlm Z ddl
T ddl m Z G dd� de �Z
dS ) zhdistutils.command.register
Implements the Distutils 'register' command (register with the repository).
� N)�warn)�
PyPIRCCommand)�*)�logc @ s� e Zd ZdZejddg Zejdddg Zddd � fgZd
d � Zd d
� Z dd� Z
dd� Z dd� Z dd� Z
dd� Zdd� Zdd� Zd d d �Zd S ) �registerz7register the distribution with the Python package index)�list-classifiersNz list the valid Trove classifiers)�strictNzBWill stop the registering if the meta-data are not fully compliant�verifyr r �checkc C s dS )NT� ��selfr r �2/usr/lib64/python3.8/distutils/command/register.py�<lambda> � zregister.<lambda>c C s t �| � d| _d| _d S )Nr )r �initialize_options�list_classifiersr r r r r r s
zregister.initialize_optionsc C s* t �| � d| jfdd�}|| jjd< d S )Nr )r � )r �restructuredtextr
)r �finalize_optionsr � distributionZcommand_options)r
Z
check_optionsr r r r $ s
�zregister.finalize_optionsc C sT | � � | �� | �� D ]}| �|� q| jr8| �� n| jrH| �� n| �� d S )N) r � _set_configZget_sub_commandsZ run_commandZdry_run�verify_metadatar � classifiers�
send_metadata)r
Zcmd_namer r r �run+ s
z register.runc C s8 t dt� | j�d�}|�� | j|_d|_|�� dS )zDeprecated API.zddistutils.command.register.check_metadata is deprecated, use the check command insteadr
r N)r �PendingDeprecationWarningr Zget_command_objZensure_finalizedr r r )r
r
r r r �check_metadata: s � zregister.check_metadatac C sz | � � }|i kr@|d | _|d | _|d | _|d | _d| _n6| jd| jfkr^td| j ��| jdkrp| j| _d| _d S )
z: Reads the configuration file and set attributes.
�username�password�
repository�realmTZpypiz%s not found in .pypircFN)Z _read_pypircr r r r! �
has_configZDEFAULT_REPOSITORY�
ValueError)r
Zconfigr r r r D s
zregister._set_configc C s* | j d }tj�|�}t�| �|�� dS )z8 Fetch the list of classifiers from the server.
z?:action=list_classifiersN)r �urllib�requestZurlopenr �info�_read_pypi_response)r
ZurlZresponser r r r U s
zregister.classifiersc C s& | � | �d��\}}t�d||� dS )zF Send the metadata to the package index server to be checked.
r �Server response (%s): %sN)�post_to_server�build_post_datar r& )r
�code�resultr r r r \ s zregister.verify_metadatac
C s� | j rd}| j}| j}n d}d }}d�� }||krd| �dtj� t� }|sRd}q,||kr,td� q,|dk�rl|s|td�}qn|s�t � d�}q|t
j � � }t
j
�| j�d }|�| j|||� | �| �d
�|�\}}| �d ||f tj� |d k�r�| j �r|| j_nf| �d
tj� | �d| �� tj� d}|�� dk�rNtd�}|�s*d}�q*|�� dk�r�| �||� �nl|dk�r�ddi} d | d< | d< | d< d| d< | d �s�td�| d< �q�| d | d k�r0| d �s�t � d�| d< �q�| d �st � d �| d< �q�| d | d k�r�d| d< d| d< td � �q�| d �sJtd �| d< �q0| �| �\}}|d k�rrt�d ||� nt�d � t�d � nP|d!k�r�dd"i} d| d< | d �s�td#�| d< �q�| �| �\}}t�d ||� dS )$a_ Send the metadata to the package index server.
Well, do the following:
1. figure who the user is, and then
2. send the data as a Basic auth'ed POST.
First we try to read the username/password from $HOME/.pypirc,
which is a ConfigParser-formatted file with a section
[distutils] containing username and password entries (both
in clear text). Eg:
[distutils]
index-servers =
pypi
[pypi]
username: fred
password: sekrit
Otherwise, to figure who the user is, we offer the user three
choices:
1. use existing login,
2. register as a new user, or
3. set the password to a random string and email the user.
�1�x� z1 2 3 4z�We need to know who you are, so please choose either:
1. use your existing login,
2. register as a new user,
3. have the server generate a new password for you (and email it to you), or
4. quit
Your selection [default 1]: z&Please choose one of the four options!z
Username: z
Password: r Zsubmitr( �� zAI can store your PyPI login so future submissions will be faster.z (the login will be stored in %s)�XZynzSave your login (y/N)?�n�y�2�:action�user�namer ZemailNZconfirmz
Confirm: z!Password and confirm don't match!z
EMail: z"You will receive an email shortly.z7Follow the instructions in it to complete registration.�3Zpassword_resetzYour email address: )r" r r �split�announcer �INFO�input�print�getpassr$ r% ZHTTPPasswordMgr�parseZurlparser Z add_passwordr! r) r* r Z _get_rc_file�lowerZ
_store_pypircr& )
r
Zchoicer r �choices�authZhostr+ r, �datar r r r c s� �
��
���
zregister.send_metadatac C s� | j j}|d|�� |�� |�� |�� |�� |�� |�� |� � |�
� |� � |� � |�
� |�� |�� |�� d�}|d s�|d s�|d r�d|d< |S )Nz1.0)r5 �metadata_versionr7 �versionZsummaryZ home_pageZauthorZ author_email�license� description�keywords�platformr Z download_url�provides�requires� obsoletesrJ rK rL z1.1rD )r ZmetadataZget_nameZ get_versionZget_descriptionZget_urlZ get_contactZget_contact_emailZ get_licenceZget_long_descriptionZ get_keywordsZ
get_platformsZget_classifiersZget_download_urlZ get_providesZ get_requiresZ
get_obsoletes)r
�action�metarC r r r r* � s, �zregister.build_post_dataNc
C s� d|kr$| � d|d | jf tj� d}d| }|d }t�� }|�� D ]~\}}t|�tg �td�fkrn|g}|D ]R}t|�}|� |� |� d| � |� d� |� |� |rr|d d
krr|� d � qrqH|� |� |� d � |�
� � d �}d
| tt |��d�} t
j�| j|| �}
t
j�t
jj|d��} d}z| �|
�} W nx t
jjk
�r� }
z"| j�rd|
j�� }|
j|
jf} W 5 d}
~
X Y nJ t
jjk
�r� }
zdt|
�f} W 5 d}
~
X Y nX | j�r�| �| �}d} | j�r�d � d|df�}| � |tj� | S )zC Post a query to the server, and return a string response.
r7 zRegistering %s to %sz3--------------GHSKFJDLGDS7543FJKLFHRE75642756743254z
--z--r z*
Content-Disposition: form-data; name="%s"z
����
�
zutf-8z/multipart/form-data; boundary=%s; charset=utf-8)z Content-typezContent-length)Z password_mgrr/ Ni� )r0 ZOKzK---------------------------------------------------------------------------) r: r r r; �io�StringIO�items�type�str�write�getvalue�encode�lenr$ r% ZRequestZ build_openerZHTTPBasicAuthHandler�open�errorZ HTTPErrorZ
show_response�fp�readr+ �msgZURLErrorr' �join)r
rC rB �boundaryZ sep_boundaryZ end_boundaryZbody�key�valueZheadersZreqZopenerr, �er_ r r r r) � s^ ��
� �
zregister.post_to_server)N)�__name__�
__module__� __qualname__rG r Z user_optionsZboolean_optionsZ sub_commandsr r r r r r r r r* r) r r r r r s* � �
z r )�__doc__r> rR Z urllib.parser$ Zurllib.request�warningsr Zdistutils.corer Zdistutils.errorsZ distutilsr r r r r r �<module> s __pycache__/register.cpython-38.pyc 0000644 00000020411 15051366005 0013227 0 ustar 00 U
e5d�- � @ sd d Z ddlZddlZddlZddlZddlmZ ddlm Z ddl
T ddl m Z G dd� de �Z
dS ) zhdistutils.command.register
Implements the Distutils 'register' command (register with the repository).
� N)�warn)�
PyPIRCCommand)�*)�logc @ s� e Zd ZdZejddg Zejdddg Zddd � fgZd
d � Zd d
� Z dd� Z
dd� Z dd� Z dd� Z
dd� Zdd� Zdd� Zd d d �Zd S ) �registerz7register the distribution with the Python package index)�list-classifiersNz list the valid Trove classifiers)�strictNzBWill stop the registering if the meta-data are not fully compliant�verifyr r �checkc C s dS )NT� ��selfr r �2/usr/lib64/python3.8/distutils/command/register.py�<lambda> � zregister.<lambda>c C s t �| � d| _d| _d S )Nr )r �initialize_options�list_classifiersr r r r r r s
zregister.initialize_optionsc C s* t �| � d| jfdd�}|| jjd< d S )Nr )r � )r �restructuredtextr
)r �finalize_optionsr � distributionZcommand_options)r
Z
check_optionsr r r r $ s
�zregister.finalize_optionsc C sT | � � | �� | �� D ]}| �|� q| jr8| �� n| jrH| �� n| �� d S )N) r � _set_configZget_sub_commandsZ run_commandZdry_run�verify_metadatar � classifiers�
send_metadata)r
Zcmd_namer r r �run+ s
z register.runc C s8 t dt� | j�d�}|�� | j|_d|_|�� dS )zDeprecated API.zddistutils.command.register.check_metadata is deprecated, use the check command insteadr
r N)r �PendingDeprecationWarningr Zget_command_objZensure_finalizedr r r )r
r
r r r �check_metadata: s � zregister.check_metadatac C sz | � � }|i kr@|d | _|d | _|d | _|d | _d| _n6| jd| jfkr^td| j ��| jdkrp| j| _d| _d S )
z: Reads the configuration file and set attributes.
�username�password�
repository�realmTZpypiz%s not found in .pypircFN)Z _read_pypircr r r r! �
has_configZDEFAULT_REPOSITORY�
ValueError)r
Zconfigr r r r D s
zregister._set_configc C s* | j d }tj�|�}t�| �|�� dS )z8 Fetch the list of classifiers from the server.
z?:action=list_classifiersN)r �urllib�requestZurlopenr �info�_read_pypi_response)r
ZurlZresponser r r r U s
zregister.classifiersc C s& | � | �d��\}}t�d||� dS )zF Send the metadata to the package index server to be checked.
r �Server response (%s): %sN)�post_to_server�build_post_datar r& )r
�code�resultr r r r \ s zregister.verify_metadatac
C s� | j rd}| j}| j}n d}d }}d�� }||krd| �dtj� t� }|sRd}q,||kr,td� q,|dk�rl|s|td�}qn|s�t � d�}q|t
j � � }t
j
�| j�d }|�| j|||� | �| �d
�|�\}}| �d ||f tj� |d k�r�| j �r|| j_nf| �d
tj� | �d| �� tj� d}|�� dk�rNtd�}|�s*d}�q*|�� dk�r�| �||� �nl|dk�r�ddi} d | d< | d< | d< d| d< | d �s�td�| d< �q�| d | d k�r0| d �s�t � d�| d< �q�| d �st � d �| d< �q�| d | d k�r�d| d< d| d< td � �q�| d �sJtd �| d< �q0| �| �\}}|d k�rrt�d ||� nt�d � t�d � nP|d!k�r�dd"i} d| d< | d �s�td#�| d< �q�| �| �\}}t�d ||� dS )$a_ Send the metadata to the package index server.
Well, do the following:
1. figure who the user is, and then
2. send the data as a Basic auth'ed POST.
First we try to read the username/password from $HOME/.pypirc,
which is a ConfigParser-formatted file with a section
[distutils] containing username and password entries (both
in clear text). Eg:
[distutils]
index-servers =
pypi
[pypi]
username: fred
password: sekrit
Otherwise, to figure who the user is, we offer the user three
choices:
1. use existing login,
2. register as a new user, or
3. set the password to a random string and email the user.
�1�x� z1 2 3 4z�We need to know who you are, so please choose either:
1. use your existing login,
2. register as a new user,
3. have the server generate a new password for you (and email it to you), or
4. quit
Your selection [default 1]: z&Please choose one of the four options!z
Username: z
Password: r Zsubmitr( �� zAI can store your PyPI login so future submissions will be faster.z (the login will be stored in %s)�XZynzSave your login (y/N)?�n�y�2�:action�user�namer ZemailNZconfirmz
Confirm: z!Password and confirm don't match!z
EMail: z"You will receive an email shortly.z7Follow the instructions in it to complete registration.�3Zpassword_resetzYour email address: )r" r r �split�announcer �INFO�input�print�getpassr$ r% ZHTTPPasswordMgr�parseZurlparser Z add_passwordr! r) r* r Z _get_rc_file�lowerZ
_store_pypircr& )
r
Zchoicer r �choices�authZhostr+ r, �datar r r r c s� �
��
���
zregister.send_metadatac C s� | j j}|d|�� |�� |�� |�� |�� |�� |�� |� � |�
� |� � |� � |�
� |�� |�� |�� d�}|d s�|d s�|d r�d|d< |S )Nz1.0)r5 �metadata_versionr7 �versionZsummaryZ home_pageZauthorZ author_email�license� description�keywords�platformr Z download_url�provides�requires� obsoletesrJ rK rL z1.1rD )r ZmetadataZget_nameZ get_versionZget_descriptionZget_urlZ get_contactZget_contact_emailZ get_licenceZget_long_descriptionZ get_keywordsZ
get_platformsZget_classifiersZget_download_urlZ get_providesZ get_requiresZ
get_obsoletes)r
�action�metarC r r r r* � s, �zregister.build_post_dataNc
C s� d|kr$| � d|d | jf tj� d}d| }|d }t�� }|�� D ]~\}}t|�tg �td�fkrn|g}|D ]R}t|�}|� |� |� d| � |� d� |� |� |rr|d d
krr|� d � qrqH|� |� |� d � |�
� � d �}d
| tt |��d�} t
j�| j|| �}
t
j�t
jj|d��} d}z| �|
�} W nx t
jjk
�r� }
z"| j�rd|
j�� }|
j|
jf} W 5 d}
~
X Y nJ t
jjk
�r� }
zdt|
�f} W 5 d}
~
X Y nX | j�r�| �| �}d} | j�r�d � d|df�}| � |tj� | S )zC Post a query to the server, and return a string response.
r7 zRegistering %s to %sz3--------------GHSKFJDLGDS7543FJKLFHRE75642756743254z
--z--r z*
Content-Disposition: form-data; name="%s"z
����
�
zutf-8z/multipart/form-data; boundary=%s; charset=utf-8)z Content-typezContent-length)Z password_mgrr/ Ni� )r0 ZOKzK---------------------------------------------------------------------------) r: r r r; �io�StringIO�items�type�str�write�getvalue�encode�lenr$ r% ZRequestZ build_openerZHTTPBasicAuthHandler�open�errorZ HTTPErrorZ
show_response�fp�readr+ �msgZURLErrorr' �join)r
rC rB �boundaryZ sep_boundaryZ end_boundaryZbody�key�valueZheadersZreqZopenerr, �er_ r r r r) � s^ ��
� �
zregister.post_to_server)N)�__name__�
__module__� __qualname__rG r Z user_optionsZboolean_optionsZ sub_commandsr r r r r r r r r* r) r r r r r s* � �
z r )�__doc__r> rR Z urllib.parser$ Zurllib.request�warningsr Zdistutils.corer Zdistutils.errorsZ distutilsr r r r r r �<module> s __pycache__/check.cpython-38.pyc 0000644 00000011427 15051366005 0012467 0 ustar 00 U
e5d� � @ s� d Z ddlmZ ddlmZ zTddlmZ ddlmZ ddl m
Z
ddl m Z ddl m
Z
G d d
� d
e�Zd ZW n ek
r� d ZY nX G d
d� de�ZdS )zCdistutils.command.check
Implements the Distutils 'check' command.
� )�Command)�DistutilsSetupError)�Reporter)�Parser)�frontend)�nodes)�StringIOc @ s e Zd Zd dd�Zdd� ZdS )
�SilentReporterNr �ascii�replacec
C s" g | _ t�| |||||||� d S �N)�messagesr �__init__)�self�source� report_level�
halt_level�stream�debug�encoding�
error_handler� r �//usr/lib64/python3.8/distutils/command/check.pyr s �zSilentReporter.__init__c O s6 | j �||||f� tj|f|�|| j| d�|��S )N)�level�type)r
�appendr �system_messageZlevels)r r �messageZchildren�kwargsr r r r s ���z SilentReporter.system_message)Nr r
r )�__name__�
__module__� __qualname__r r r r r r r s �
r TFc @ s` e Zd ZdZdZdddgZdddgZd d
� Zd d � Zd
d� Z dd� Z
dd� Z dd� Z dd� Z
dS )�checkz6This command checks the meta-data of the package.
z"perform some checks on the package)�metadata�mzVerify meta-data)�restructuredtext�rzEChecks if long string meta-data syntax are reStructuredText-compliant)�strict�sz(Will exit with an error if a check failsr# r% r' c C s d| _ d| _d| _d| _dS )z Sets default values for options.r � N)r% r# r' � _warnings�r r r r �initialize_options1 s zcheck.initialize_optionsc C s d S r r r+ r r r �finalize_options8 s zcheck.finalize_optionsc C s | j d7 _ t�| |�S )z*Counts the number of warnings that occurs.r) )r* r �warn)r �msgr r r r. ; s z
check.warnc C sL | j r| �� | jr0tr"| �� n| jr0td��| jrH| jdkrHtd��dS )zRuns the command.z The docutils package is needed.r z Please correct your package.N)r# �check_metadatar% � HAS_DOCUTILS�check_restructuredtextr' r r* r+ r r r �run@ s
z check.runc C s� | j j}g }dD ]"}t||�r(t||�s|�|� q|rL| �dd�|� � |jrd|js�| �d� n"|j r||j
s�| �d� n
| �d� dS )z�Ensures that all required elements of meta-data are supplied.
name, version, URL, (author and author_email) or
(maintainer and maintainer_email)).
Warns if any are missing.
)�name�versionZurlz missing required meta-data: %sz, zLmissing meta-data: if 'author' supplied, 'author_email' must be supplied toozTmissing meta-data: if 'maintainer' supplied, 'maintainer_email' must be supplied toozimissing meta-data: either (author and author_email) or (maintainer and maintainer_email) must be suppliedN) � distributionr# �hasattr�getattrr r. �joinZauthorZ author_emailZ
maintainerZmaintainer_email)r r# Zmissing�attrr r r r0 P s zcheck.check_metadatac C sX | j �� }| �|�D ]>}|d �d�}|dkr8|d }nd|d |f }| �|� qdS )z4Checks if the long string fields are reST-compliant.����lineNr) z %s (line %s))r6 Zget_long_description�_check_rst_data�getr. )r �dataZwarningr< r r r r2 n s
z check.check_restructuredtextc
C s� | j jp
d}t� }tjtfd��� }d|_d|_d|_t ||j
|j |j |j
|j|jd�}tj|||d�}|�|d� z|�||� W n: tk
r� } z |j�dd| d i f� W 5 d}~X Y nX |jS )
z8Returns warnings when the provided data doesn't compile.zsetup.py)Z
components� N)r r r r )r r; z!Could not finish the parsing: %s.� )r6 Z script_namer r Z OptionParserZget_default_valuesZ tab_widthZpep_referencesZrfc_referencesr r r Zwarning_streamr Zerror_encodingZ error_encoding_error_handlerr �documentZ note_source�parse�AttributeErrorr
r )r r? � source_path�parserZsettingsZreporterrB �er r r r= y s. � �zcheck._check_rst_dataN)r r r! �__doc__Z descriptionZ user_optionsZboolean_optionsr, r- r. r3 r0 r2 r= r r r r r" $ s �
r" N)rH Zdistutils.corer Zdistutils.errorsr Zdocutils.utilsr Zdocutils.parsers.rstr Zdocutilsr r �ior r r1 � Exceptionr" r r r r �<module> s
__pycache__/bdist_rpm.cpython-38.opt-2.pyc 0000644 00000027415 15051366005 0014341 0 ustar 00 U
e5dIT � @ s| d dl Z d dlZd dlZd dlmZ d dlmZ d dlmZ d dl m
Z
d dl T d dl m
Z
d dlmZ G d d
� d
e�ZdS ) � N)�Command)�DEBUG)� get_platform)�
write_file)�*)�get_python_version)�logc ) @ s� e Zd ZdZdddddddd d
d d d
ddddddddddddddd d d d d d!d"d#d$d%d&d'd(d)d*g)Zd+d,d-d.d/gZd+d,d-d0�Zd1d2� Zd3d4� Zd5d6� Z d7d8� Z
d9d:� Z d;d<� Z d=d>� Z
d?S )@� bdist_rpmzcreate an RPM distribution)z bdist-base=Nz/base directory for creating built distributions)z rpm-base=Nzdbase directory for creating RPMs (defaults to "rpm" under --bdist-base; must be specified for RPM 2))z dist-dir=�dzDdirectory to put final RPM files in (and .spec files if --spec-only))zpython=NzMpath to Python interpreter to hard-code in the .spec file (default: "python"))z
fix-pythonNzLhard-code the exact path to the current Python interpreter in the .spec file)z spec-onlyNzonly regenerate spec file)z source-onlyNzonly generate source RPM)z binary-onlyNzonly generate binary RPM)z use-bzip2Nz7use bzip2 instead of gzip to create source distribution)zdistribution-name=Nzgname of the (Linux) distribution to which this RPM applies (*not* the name of the module distribution!))zgroup=Nz9package classification [default: "Development/Libraries"])zrelease=NzRPM release number)zserial=NzRPM serial number)zvendor=NzaRPM "vendor" (eg. "Joe Blow <joe@example.com>") [default: maintainer or author from setup script])z packager=NzBRPM packager (eg. "Jane Doe <jane@example.net>") [default: vendor])z
doc-files=Nz6list of documentation files (space or comma-separated))z
changelog=Nz
RPM changelog)zicon=Nzname of icon file)z provides=Nz%capabilities provided by this package)z requires=Nz%capabilities required by this package)z
conflicts=Nz-capabilities which conflict with this package)zbuild-requires=Nz+capabilities required to build this package)z
obsoletes=Nz*capabilities made obsolete by this package)�
no-autoreqNz+do not automatically calculate dependencies)� keep-temp�kz"don't clean up RPM build directory)� no-keep-tempNz&clean up RPM build directory [default])�use-rpm-opt-flagsNz8compile with RPM_OPT_FLAGS when building from source RPM)�no-rpm-opt-flagsNz&do not pass any RPM CFLAGS to compiler)� rpm3-modeNz"RPM 3 compatibility mode (default))� rpm2-modeNzRPM 2 compatibility mode)z prep-script=Nz3Specify a script for the PREP phase of RPM building)z
build-script=Nz4Specify a script for the BUILD phase of RPM building)z pre-install=Nz:Specify a script for the pre-INSTALL phase of RPM building)zinstall-script=Nz6Specify a script for the INSTALL phase of RPM building)z
post-install=Nz;Specify a script for the post-INSTALL phase of RPM building)zpre-uninstall=Nz<Specify a script for the pre-UNINSTALL phase of RPM building)zpost-uninstall=Nz=Specify a script for the post-UNINSTALL phase of RPM building)z
clean-script=Nz4Specify a script for the CLEAN phase of RPM building)zverify-script=Nz6Specify a script for the VERIFY phase of the RPM build)z force-arch=Nz0Force an architecture onto the RPM build process)�quiet�qz3Run the INSTALL phase of RPM building in quiet moder r r r r )r r r c C s� d | _ d | _d | _d | _d | _d | _d | _d | _d | _d | _ d | _
d | _ d | _ d | _
d | _d | _d | _d | _d | _d | _d | _d | _d | _d | _d | _d | _d | _d | _d | _ d | _ d | _ d | _ d | _ d| _!d| _"d| _#d| _$d | _%d| _&d S )Nr � )'�
bdist_base�rpm_base�dist_dir�python�
fix_python� spec_only� binary_only� source_only� use_bzip2�distribution_name�group�release�serial�vendor�packager� doc_files� changelog�icon� prep_script� build_script�install_script� clean_script�
verify_script� pre_install� post_install�
pre_uninstall�post_uninstall�prep�provides�requires� conflicts�build_requires� obsoletes� keep_temp�use_rpm_opt_flags� rpm3_mode�
no_autoreq�
force_archr ��self� r> �3/usr/lib64/python3.8/distutils/command/bdist_rpm.py�initialize_options� sN z bdist_rpm.initialize_optionsc C s� | � dd� | jd kr6| js$td��tj�| jd�| _| jd krX| j rPt
j | _qfd| _n| j rftd��tj dkr~t
dtj ��| jr�| jr�td ��| j�� s�d
| _| � dd � | �� d S ) NZbdist)r r z)you must specify --rpm-base in RPM 2 mode�rpmZpython3z8--python and --fix-python are mutually exclusive options�posixz9don't know how to create RPM distributions on platform %sz6cannot supply both '--source-only' and '--binary-only'r )r r )Zset_undefined_optionsr r9 ZDistutilsOptionError�os�path�joinr r r �sys�
executable�nameZDistutilsPlatformErrorr r � distribution�has_ext_modulesr8 �finalize_package_datar< r> r> r? �finalize_options� s6
�
�
� �
zbdist_rpm.finalize_optionsc C sT | � dd� | � dd| j�� | j�� f � | � d� | �d� t| jt�rxdD ]&}tj �
|�rP|| jkrP| j� |� qP| � dd � | � d
� | � d � | � d � | � | j
�| _
| �d
� | �d� | �d� | �d� | �d� | �d� | �d� | �d� | �d� | �d� | �d� | �d� | �d� | �d� | �d� | � d � d S ) Nr zDevelopment/Librariesr# z%s <%s>r$ r% )ZREADMEz
README.txtr! �1r" r r& r' r( r) r* r+ r, r- r. r/ r0 r2 r3 r4 r5 r6 r; )Z
ensure_stringrI Z get_contactZget_contact_emailZensure_string_list�
isinstancer% �listrC rD �exists�append�_format_changelogr& Zensure_filename)r= Zreadmer> r> r? rK � sB
��
z bdist_rpm.finalize_package_datac C s� t r<td� td| j� td| j� td| j� td| j� | jrT| j}| �|� n8i }dD ]&}t j
� | j |�||< | �|| � q\|d }t j
� |d| j
�� �}| �t|| �� fd | � | jr�d S | j
jd d � }| �d
�}| jr�d g|_nd g|_| �d
� || j
_|�� d
}|d }| �||� | j�rbt j
�| j��rT| �| j|� ntd| j ��t � d� dg} | j �r�| � d� n | j �r�| � d� n
| � d� | �!dd| j" g� | j#�r�| �!ddt j
�$| j � g� | j%�s�| � d� | j&�r | � d� | � |� d}
|
d } d |
d } d | | |f }
t �'|
�}zlg }d }|�)� }|�sV�q�|�*� �+� }|� |d � |d k�rD|d
}�qD|�(� }|�r�t,d t-|
� ��W 5 |�(� X | �.| � | j/�s�| j
�0� �r�t1� }nd!}| j �s(t j
� |d" |�}| �2|| j� t j
� | j|�}| j
j� d#||f� | j �s�|D ]`}t j
� |d$ |�}t j
�|��r4| �2|| j� t j
� | jt j
�3|��}| j
j� d#||f� �q4d S )%Nzbefore _get_package_data():zvendor =z
packager =z doc_files =z changelog =)�SOURCES�SPECSZBUILD�RPMS�SRPMSrT z%s.specz writing '%s'�sdistZbztarZgztarr rS z icon file '%s' does not existz
building RPMsZrpmbuildz-bsz-bbz-baz--definez __python %sz
_topdir %sz--cleanz--quietz %{name}-%{version}-%{release}z.src.rpmz%{arch}/z .%{arch}.rpmz%rpm -q --qf '%s %s\n' --specfile '%s'r zFailed to execute: %s�anyrV r rU )4r �printr# r$ r% r& r r ZmkpathrC rD rE r rI �get_nameZexecuter �_make_spec_fileZ
dist_filesZreinitialize_commandr ZformatsZ run_commandZget_archive_filesZ copy_filer' rP ZDistutilsFileErrorr �infor rQ r �extendr r9 �abspathr7 r �popen�close�readline�strip�splitZDistutilsExecError�reprZspawnZdry_runrJ r Z move_file�basename)r= Zspec_dirZrpm_dirr
Z spec_pathZsaved_dist_filesrW �sourceZ
source_dirZrpm_cmdZ
nvr_stringZsrc_rpmZ non_src_rpmZq_cmd�outZ binary_rpmsZ
source_rpm�line�lZstatusZ pyversionZsrpm�filenamerA r> r> r? �run s� ���
�
�
�
�
��z
bdist_rpm.runc C s t j�| jt j�|��S )N)rC rD rE r re )r= rD r> r> r? �
_dist_path� s zbdist_rpm._dist_pathc
C sJ d| j �� d| j �� �dd� d| j �� d| j�dd� dd| j �� g}t�d �}d
�d d � |� � D ��}d
}d}|�||�}||kr�|�
d� |�
d| d
� |� dddg� | j r�|�
d� n
|�
d� |� d| j �
� d| j ddg� | j�s| j �� �s&|�
d� n|�
d| j � d D ]V}t| |�� �}t|t��rb|�
d |d �|�f � n |d k �r*|�
d ||f � �q*| j �� d k�r�|�
d | j �� � | j�r�|�
d!| j � | j�r�|�
d"d �| j� � | j�r�|�
d#tj�| j� � | j �r|�
d$� |� dd%| j � � g� d&| j tj�t j d' �f }d(| } | j!�rXd)| } d*| }
d+d,d-| fd.d/|
fd0d1d2d3d4d5g } | D ]n\} }
}t| |
�}|�s�|�r�|� dd6| g� |�r�t"|��}|� |�#� �$d
�� W 5 Q R X n
|�
|� �q�|� dd7d8g� | j%�r$|�
d9d �| j%� � | j&�rF|� dd:g� |� | j&� |S );Nz
%define name z%define version �-�_z%define unmangled_version z%define release � z Summary: z rpm --eval %{__os_install_post}�
c S s g | ]}d |� � �qS )z %s \)rb )�.0rh r> r> r? �
<listcomp>� s �z-bdist_rpm._make_spec_file.<locals>.<listcomp>zbrp-python-bytecompile \
z%brp-python-bytecompile %{__python} \
z2# Workaround for http://bugs.python.org/issue14443z%define __os_install_post z
Name: %{name}zVersion: %{version}zRelease: %{release}z-Source0: %{name}-%{unmangled_version}.tar.bz2z,Source0: %{name}-%{unmangled_version}.tar.gzz License: zGroup: z>BuildRoot: %{_tmppath}/%{name}-%{version}-%{release}-buildrootzPrefix: %{_prefix}zBuildArch: noarchz
BuildArch: %s)ZVendorZPackagerZProvidesZRequiresZ ConflictsZ Obsoletesz%s: %s� ZUNKNOWNzUrl: zDistribution: zBuildRequires: zIcon: z
AutoReq: 0z %descriptionz%s %sr z%s buildz env CFLAGS="$RPM_OPT_FLAGS" z>%s install -O1 --root=$RPM_BUILD_ROOT --record=INSTALLED_FILES)r1 r( z&%setup -n %{name}-%{unmangled_version}Zbuildr) Zinstallr* )Zcleanr+ zrm -rf $RPM_BUILD_ROOT)Z verifyscriptr, N)Zprer- N)Zpostr. N)Zpreunr/ N)Zpostunr0 N�%z%files -f INSTALLED_FILESz%defattr(-,root,root)z%doc z
%changelog)'rI rZ Z get_version�replacer! Zget_description�
subprocessZ getoutputrE �
splitlinesrQ r] r Z get_licenser r; rJ �getattr�lowerrN rO Zget_urlr r5 r' rC rD re r: Zget_long_descriptionr rF �argvr8 �open�readrc r% r& )r= Z spec_fileZ vendor_hookZproblemZfixedZ
fixed_hookZfield�valZdef_setup_callZ def_buildZ install_cmdZscript_optionsZrpm_opt�attr�default�fr> r> r? r[ � s� �
�
�
�
�
� ��
�
�� zbdist_rpm._make_spec_filec C s| |s|S g }|� � �d�D ]N}|� � }|d dkrB|�d|g� q|d dkrZ|�|� q|�d| � q|d sx|d= |S )Nrp r r ro rm z )rb rc r] rQ )r= r& Z
new_changelogrh r> r> r? rR 1 s zbdist_rpm._format_changelogN)�__name__�
__module__� __qualname__Z descriptionZ user_optionsZboolean_optionsZ negative_optr@ rL rK rk rl r[ rR r> r> r> r? r sx �m ��- - *r )rv rF rC Zdistutils.corer Zdistutils.debugr Zdistutils.utilr Zdistutils.file_utilr Zdistutils.errorsZdistutils.sysconfigr Z distutilsr r r> r> r> r? �<module> s __pycache__/install.cpython-38.pyc 0000644 00000032663 15051366005 0013065 0 ustar 00 U
&�.e�j � @ s d Z ddlZddlZddlmZ ddlmZ ddlmZ ddl m
Z
ddl m Z ddl
mZ dd lmZmZmZ dd
lmZ dd l mZ dd lmZ dd
lmZ dZdddddd�Zdddddd�dddddd�ed�Ze�rd d d d d d�ed < d d d!d"d d�ed#< dZG d$d%� d%e�Z dS )&zFdistutils.command.install
Implements the Distutils 'install' command.� N)�log)�Command)�DEBUG)�get_config_vars)�DistutilsPlatformError)�
write_file)� convert_path�
subst_vars� change_root)� get_platform)�DistutilsOptionError)� USER_BASE)� USER_SITETz$base/Lib/site-packagesz$base/Include/$dist_namez
$base/Scriptsz$base)�purelib�platlib�headers�scripts�dataz/$base/lib/python$py_version_short/site-packagesz5$platbase/lib64/python$py_version_short/site-packagesz9$base/include/python$py_version_short$abiflags/$dist_namez $base/binz$base/lib/pythonz$base/lib64/pythonz $base/include/python/$dist_name)� unix_prefix� unix_home�ntz $usersitez4$userbase/Python$py_version_nodot/Include/$dist_namez)$userbase/Python$py_version_nodot/Scriptsz $userbaseZnt_userz=$userbase/include/python$py_version_short$abiflags/$dist_namez
$userbase/bin� unix_userc @ s: e Zd ZdZdddddddd d
d d d
ddddddgZdddgZer`e�ddde f� e�d� ddiZ dd � Z
d d � Z d d � Z d!d"� Z
d#d$� Zd%d&� Zd'd(� Zd)d*� Zd+d,� Zd-d.� Zd/d0� Zd1d2� Zd3d4� Zd5d6� Zd7d8� Zd9d:� Zd;d<� Zd=d>� Zd?d@� Z dAdB� Z dCdD� Z dEefdFe fdGe fdHe fdIdJdK� fgZ dS )L�installz'install everything from build directory)zprefix=Nzinstallation prefix)z exec-prefix=Nz.(Unix only) prefix for platform-specific files)zhome=Nz+(Unix only) home directory to install under)z
install-base=Nz;base installation directory (instead of --prefix or --home))zinstall-platbase=Nz\base installation directory for platform-specific files (instead of --exec-prefix or --home))zroot=Nz<install everything relative to this alternate root directory)zinstall-purelib=Nz;installation directory for pure Python module distributions)zinstall-platlib=Nz8installation directory for non-pure module distributions)z install-lib=Nzginstallation directory for all module distributions (overrides --install-purelib and --install-platlib))zinstall-headers=Nz(installation directory for C/C++ headers)zinstall-scripts=Nz)installation directory for Python scripts)z
install-data=Nz%installation directory for data files)�compile�cz compile .py to .pyc [default])�
no-compileNzdon't compile .py files)z optimize=�Ozlalso compile with optimization: -O1 for "python -O", -O2 for "python -OO", and -O0 to disable [default: -O0])�force�fz1force installation (overwrite any existing files))�
skip-buildNz2skip rebuilding everything (for testing/debugging))zrecord=Nz3filename in which to record list of installed filesr r r �userNz!install in user site-package '%s'r c C s� d| _ d| _d| _d| _d| _d| _d| _d| _d| _d| _ d| _
d| _ d| _ t
| _t| _d| _d| _d| _d| _d| _d| _d| _d| _d| _d| _dS )zInitializes options.Nr � )�prefix� exec_prefix�homer � install_base�install_platbase�root�install_purelib�install_platlib�install_headers� install_lib�install_scripts� install_datar
�install_userbaser �install_usersiter �optimize�
extra_path�install_path_filer �
skip_build�warn_dir�
build_base� build_lib�record��self� r: �1/usr/lib64/python3.8/distutils/command/install.py�initialize_options� s2 zinstall.initialize_optionsc C sx | j s| js| jr&| js | jr&td��| jr@| j s8| jr@td��| jrl| j sd| jsd| jsd| jsd| jrltd��tjdkr�| jr�| � d� d| _| �
d� tjdkr�| � � n| � � | �
d� t
j�� d }td
d �\}}z
t
j}W n tk
r� d }Y nX | j�� | j�� | j�� |d
t
jdd� dt
jdd� |||||d� | _t�rf| j| jd< | j| jd< | � � | �
d� | j| jd< | j| jd< t �r�d dl m } t d� || j� | � � | �
d� | j�r�| �!� | j"dk�r�| jj#�r�| j$| _"n| j%| _"| �&dddd d d dd� | �'� | j"| _(tj)�*| j"| j+�| _"| j,dk �r\| �-d dddd d d � | �
d � | �.d!d"d#� dS )$zFinalizes options.zWmust supply either prefix/exec-prefix/home or install-base/install-platbase -- not bothz9must supply either home or prefix/exec-prefix -- not bothzGcan't combine user with prefix, exec_prefix/home, or install_(plat)base�posixz+exec-prefix option ignored on this platformNzpre-finalize_{unix,other}z post-finalize_{unix,other}()r r" r# � z%d.%d� z%d%d) Z dist_nameZ dist_versionZ
dist_fullname�
py_versionZpy_version_shortZpy_version_nodotZ
sys_prefixr" Zsys_exec_prefixr# �abiflags�userbaseZusersitezpost-expand_basedirs()�baseZplatbase)�pprintz config vars:zpost-expand_dirs()�libr r r r r Zlibbasezafter prepending root�build)r5 r5 )r6 r6 )/r" r# r$ r% r& r r �os�name�warn� dump_dirs�
finalize_unix�finalize_other�sys�version�splitr rA �AttributeError� distributionZget_nameZ get_versionZ get_fullname� version_info� config_vars�
HAS_USER_SITEr. r/ �expand_basedirsr rD �print� expand_dirs�create_home_pathr+ Z ext_modulesr) r( �
convert_paths�handle_extra_path�install_libbase�path�join�
extra_dirsr' � change_rootsZset_undefined_options)r9 r@ r" r# rA rD r: r: r; �finalize_options� s� ������
�
� �
�zinstall.finalize_optionsc C s� t sdS ddlm} t�|d � | jD ]r}|d }|d dkrL|dd� }|| jkrx| j| }|�|�}t| |� }n|�|�}t| |�}t�d||� q(dS )z Dumps the list of user options.Nr )�
longopt_xlate�:����=z %s: %s) r Zdistutils.fancy_getoptra r �debug� user_options� negative_opt� translate�getattr)r9 �msgra �optZopt_name�valr: r: r; rJ u s
zinstall.dump_dirsc C sV | j dk s| jdk r\| jdkr2| jdkr2| jdksP| jdksP| jdksP| jdkrXtd��dS | j r�| j
dkrtt d��| j
| _ | _| � d� n�| j
dk r�| j
| _ | _| � d� n�| jdk�r$| jdk r�td��ttd�s�tjtjks�dtjkr�d }nd
}tj�tj�| | _tj�tj�| | _n| jdk�r8| j| _| j| _ | j| _| � d � dS ) z&Finalizes options for posix platforms.NzPinstall-base or install-platbase supplied, but installation scheme is incomplete�$User base directory is not specifiedr r z*must not supply exec-prefix without prefixZ real_prefix�RPM_BUILD_ROOTz/localr> r )r% r& r+ r( r) r* r, r- r r r. r �
select_schemer$ r" r# �hasattrrM � base_prefixrG �environr\ �normpath)r9 Zadditionr: r: r; rK � sZ
������
�
�
�� zinstall.finalize_unixc C s� | j r8| jdkrtd��| j | _| _| �tjd � n�| jdk r\| j | _| _| �d� n\| j dkrvtj
� t j �| _ | j | _| _z| �tj� W n" t
k
r� tdtj ��Y nX dS )z)Finalizes options for non-posix platformsNrm Z_userr z)I don't know how to install stuff on '%s')r r. r r% r& ro rG rH r$ r" r\ rs rM �KeyErrorr8 r: r: r; rL � s&
�
�zinstall.finalize_otherc C s< t | }tD ]*}d| }t| |�dkr t| ||| � q dS )z=Sets the install directories by applying the install schemes.�install_N)�INSTALL_SCHEMES� SCHEME_KEYSri �setattr)r9 rH Zscheme�key�attrnamer: r: r; ro � s
zinstall.select_schemec C sX |D ]N}t | |�}|d k rtjdks.tjdkr:tj�|�}t|| j�}t| ||� qd S )Nr= r )ri rG rH r\ �
expanduserr rS rx )r9 �attrs�attrrl r: r: r; �
_expand_attrs� s
zinstall._expand_attrsc C s | � dddg� dS )zNCalls `os.path.expanduser` on install_base, install_platbase and
root.r% r& r' N�r~ r8 r: r: r; rU � s zinstall.expand_basedirsc C s | � ddddddg� dS )z+Calls `os.path.expanduser` on install dirs.r( r) r+ r* r, r- Nr r8 r: r: r; rW � s �zinstall.expand_dirsc G s, |D ]"}d| }t | |tt| |��� qdS )z!Call `convert_path` over `names`.ru N)rx r ri �r9 �namesrH r} r: r: r; rY � s zinstall.convert_pathsc C s� | j dkr| jj | _ | j dk r�t�d� t| j t�rB| j �d�| _ t| j �dkr`| j d }}n"t| j �dkrz| j \}}ntd��t |�}nd}d}|| _
|| _ dS ) z4Set `path_file` and `extra_dirs` using `extra_path`.NzIDistribution option extra_path is deprecated. See issue27919 for details.�,r! r r? zY'extra_path' option must be a list, tuple, or comma-separated string with 1 or 2 elementsr> ) r1 rQ r rI �
isinstance�strrO �lenr r � path_filer^ )r9 r� r^ r: r: r; rZ � s(
� �
zinstall.handle_extra_pathc G s0 |D ]&}d| }t | |t| jt| |��� qdS )z:Change the install directories pointed by name using root.ru N)rx r
r' ri r� r: r: r; r_ s zinstall.change_rootsc C sb | j s
dS ttj�d��}| j�� D ]8\}}|�|�r$tj�|�s$| � d| � t�
|d� q$dS )zCreate directories under ~.N�~zos.makedirs('%s', 0o700)i� ) r r rG r\ r{ rS �items�
startswith�isdirZ debug_print�makedirs)r9 r$ rH r\ r: r: r; rX s zinstall.create_home_pathc C s" | j s6| �d� | j�d�j}| jr6|t� kr6td��| �� D ]}| �|� q>| j r\| �
� | j r�| � � }| j
r�t| j
�}tt|��D ]}|| |d� ||< q�| �t| j |fd| j � ttjjtj�}ttjj|�}tj�tj�| j��}| j�r | j �r| j�s ||k�r t�d| j� dS )zRuns the command.rF z"Can't install when cross-compilingNz'writing list of installed files to '%s'z�modules installed to '%s', which is not in Python's module search path (sys.path) -- you'll have to change the search path yourself) r3 Z run_commandrQ Zget_command_objZ plat_namer4 r r �get_sub_commandsr� �create_path_filer7 � get_outputsr' r� �range�executer �maprG r\ rs rM �normcaser+ r2 r re )r9 Z
build_plat�cmd_name�outputsZroot_lenZcounterZsys_pathr+ r: r: r; �run( sD
������z install.runc C sJ t j�| j| jd �}| jr8| �t|| jgfd| � n| � d| � dS )zCreates the .pth file�.pthz creating %szpath file '%s' not createdN)
rG r\ r] r[ r� r2 r� r r^ rI )r9 �filenamer: r: r; r� T s
�
�zinstall.create_path_filec C sh g }| � � D ].}| �|�}|�� D ]}||kr"|�|� q"q | jrd| jrd|�tj�| j | jd �� |S )z.Assembles the outputs of all the sub-commands.r� )
r� �get_finalized_commandr� �appendr� r2 rG r\ r] r[ )r9 r� r� �cmdr� r: r: r; r� b s
�zinstall.get_outputsc C s. g }| � � D ] }| �|�}|�|�� � q |S )z*Returns the inputs of all the sub-commands)r� r� �extend�
get_inputs)r9 Zinputsr� r� r: r: r; r� s s
zinstall.get_inputsc C s | j �� p| j �� S )zSReturns true if the current distribution has any Python
modules to install.)rQ Zhas_pure_modulesZhas_ext_modulesr8 r: r: r; �has_lib s
�zinstall.has_libc C s
| j �� S )zLReturns true if the current distribution has any headers to
install.)rQ � has_headersr8 r: r: r; r� � s zinstall.has_headersc C s
| j �� S )zMReturns true if the current distribution has any scripts to.
install.)rQ � has_scriptsr8 r: r: r; r� � s zinstall.has_scriptsc C s
| j �� S )zJReturns true if the current distribution has any data to.
install.)rQ Zhas_data_filesr8 r: r: r; �has_data� s zinstall.has_datar+ r* r, r- Zinstall_egg_infoc C s dS )NTr: r8 r: r: r; �<lambda>� � zinstall.<lambda>) �__name__�
__module__� __qualname__Z descriptionrf Zboolean_optionsrT r� r rg r< r` rJ rK rL ro r~ rU rW rY rZ r_ rX r� r� r� r� r� r� r� r� Z sub_commandsr: r: r: r; r I sn �;
�
N 3 " ,
�r ) �__doc__rM rG Z distutilsr Zdistutils.corer Zdistutils.debugr Zdistutils.sysconfigr Zdistutils.errorsr Zdistutils.file_utilr Zdistutils.utilr r r
r r Zsiter
r rT ZWINDOWS_SCHEMErv rw r r: r: r: r; �<module> sb �
����
�
__pycache__/build.cpython-38.opt-1.pyc 0000644 00000007453 15051366005 0013454 0 ustar 00 U
e5d� � @ sT d Z ddlZddlZddlmZ ddlmZ ddlmZ dd� Z G dd � d e�Z
dS )
zBdistutils.command.build
Implements the Distutils 'build' command.� N)�Command)�DistutilsOptionError)� get_platformc C s ddl m} | � d S )Nr ��show_compilers)Zdistutils.ccompilerr r � r �//usr/lib64/python3.8/distutils/command/build.pyr s r c @ s� e Zd ZdZdddddddd d
e� fd d d
ddg ZddgZdddefgZdd� Z dd� Z
dd� Z dd � Z d d � Z
d d � Zd!d"� Zd#e fd$e
fd%efd&efgZdS )'�buildz"build everything needed to install)z build-base=�bz base directory for build library)zbuild-purelib=Nz2build directory for platform-neutral distributions)zbuild-platlib=Nz3build directory for platform-specific distributions)z
build-lib=NzWbuild directory for all distribution (defaults to either build-purelib or build-platlib)zbuild-scripts=Nzbuild directory for scripts)z build-temp=�tztemporary build directoryz
plat-name=�pz6platform name to build for, if supported (default: %s))z compiler=�czspecify the compiler type)z parallel=�jz number of parallel build jobs)�debug�gz;compile extensions and libraries with debugging information)�force�fz2forcibly build everything (ignore file timestamps))z executable=�ez5specify final destination interpreter path (build.py)r r z
help-compilerNzlist available compilersc C sL d| _ d | _d | _d | _d | _d | _d | _d | _d | _d| _ d | _
d | _ d S )Nr r ) �
build_base�
build_purelib�
build_platlib� build_lib�
build_temp�
build_scriptsZcompiler� plat_namer r �
executable�parallel��selfr r r �initialize_options8 s zbuild.initialize_optionsc C sb | j d krt� | _ ntjdkr&td��d| j ftjd d� � }ttd�rR|d7 }| jd krntj �
| j d�| _| j d kr�tj �
| j d| �| _ | j
d kr�| jjr�| j | _
n| j| _
| jd kr�tj �
| j d| �| _| jd kr�tj �
| j d tjd d� �| _| jd k�r tj�r tj �tj�| _t| jt��r^zt| j�| _W n tk
�r\ td
��Y nX d S ) N�ntzW--plat-name only supported on Windows (try using './configure --help' on your platform)z .%s-%d.%d� Zgettotalrefcountz-pydebug�libZtempz
scripts-%d.%dz parallel should be an integer)r r �os�namer �sys� version_info�hasattrr �path�joinr r r � distributionZ ext_modulesr r r �normpath�
isinstancer �str�int�
ValueError)r Zplat_specifierr r r �finalize_optionsH sD
�
�
�
�zbuild.finalize_optionsc C s | � � D ]}| �|� qd S �N)Zget_sub_commandsZ run_command)r Zcmd_namer r r �run� s z build.runc C s
| j �� S r1 )r* �has_pure_modulesr r r r r3 � s zbuild.has_pure_modulesc C s
| j �� S r1 )r* �has_c_librariesr r r r r4 � s zbuild.has_c_librariesc C s
| j �� S r1 )r* �has_ext_modulesr r r r r5 � s zbuild.has_ext_modulesc C s
| j �� S r1 )r* � has_scriptsr r r r r6 � s zbuild.has_scriptsZbuild_pyZ
build_clibZ build_extr )�__name__�
__module__� __qualname__Z descriptionr Z user_optionsZboolean_optionsr Z help_optionsr r0 r2 r3 r4 r5 r6 Z sub_commandsr r r r r sH ��� ��8 �r ) �__doc__r% r# Zdistutils.corer Zdistutils.errorsr Zdistutils.utilr r r r r r r �<module> s __pycache__/upload.cpython-38.pyc 0000644 00000012100 15051366005 0012663 0 ustar 00 U
&�.e� � @ s� d Z ddlZddlZddlZddlZddlmZ ddlmZm Z m
Z
ddl m Z ddl
mZmZ ddlmZ ddlmZ dd lmZ G d
d � d e�ZdS ) zm
distutils.command.upload
Implements the Distutils 'upload' subcommand (upload package to a package
index).
� N)�standard_b64encode)�urlopen�Request� HTTPError)�urlparse)�DistutilsError�DistutilsOptionError)�
PyPIRCCommand)�spawn)�logc @ sJ e Zd ZdZejddg Zejdg Zdd� Zdd� Zd d
� Z d d � Z
d
S )�uploadz upload binary package to PyPI)�sign�sz sign files to upload using gpg)z identity=�iz GPG identity used to sign filesr
c C s, t �| � d| _d| _d| _d| _d | _d S )N� r F)r �initialize_options�username�password�
show_responser
�identity)�self� r �0/usr/lib64/python3.8/distutils/command/upload.pyr s
zupload.initialize_optionsc C sr t �| � | jr | js td��| �� }|i krV|d | _|d | _|d | _|d | _ | jsn| j
jrn| j
j| _d S )Nz.Must use --sign for --identity to have meaningr r �
repository�realm) r �finalize_optionsr r
r Z _read_pypircr r r r � distribution)r Zconfigr r r r ( s
�
zupload.finalize_optionsc C s: | j jsd}t|��| j jD ]\}}}| �|||� q d S )NzHMust create and upload files in one command (e.g. setup.py sdist upload))r Z
dist_filesr � upload_file)r �msg�command� pyversion�filenamer r r �run: s
z
upload.runc " C s t | j�\}}}}}} |s"|s"| r0td| j ��|dkrDtd| ��| jr|ddd|g}
| jrnd| jg|
dd�< t|
| jd � t|d
�} z | � � } W 5 | �� X | j
j }
d d |
� � |
�
� tj�|�| f||t�| ��� d
|
�� |
�� |
�� |
�� |
�� |
�� |
�� |
�� |
� � |
� � |
� � |
� � |
� � d�}zt�!| ��� }W nP t"k
�r� } z0d| }| �#|t$j%� ddl&m'} |� �s|� W 5 d }~X Y n
X ||d< d|d< | j�r�t|d d
��"} tj�|�d | � � f|d< W 5 Q R X | j(d | j) �*d�}dt+|��,d� }d}d|�*d� }|d }t-�.� }|�/� D ]�\}}d | }t0|t1��sP|g}|D ]j}t2|�t3k�r�|d |d 7 }|d }nt4|��*d �}|�5|� |�5|�*d �� |�5d!� |�5|� �qT�q.|�5|� |�6� }d"|| jf }| �#|t$j%� d#| t4t7|��|d$�} t8| j|| d%�} zt9| �} | �:� } | j;} W nf t<k
�rd } z|j=} |j;} W 5 d }~X Y n8 t>k
�r� } z| �#t4|�t$j?� � W 5 d }~X Y nX | d&k�r�| �#d'| | f t$j%� | j@�r| �A| �}!d(�Bd)|!d)f�}| �#|t$j%� n"d*| | f }| �#|t$j?� tC|��d S )+NzIncompatible url %s)ZhttpZhttpszunsupported schema Zgpgz
--detach-signz-az --local-user� )�dry_run�rbZ file_upload�1z1.0)z:actionZprotocol_version�name�version�contentZfiletyper Z
sha256_digestZmetadata_versionZsummaryZ home_pageZauthorZ author_email�license� description�keywords�platformZ classifiersZ download_urlZprovidesZrequiresZ obsoletesz#calculating md5 checksum failed: %sr )�
get_fips_modeZ
md5_digestr Zcommentz.ascZ
gpg_signature�:�asciizBasic z3--------------GHSKFJDLGDS7543FJKLFHRE75642756743254s
--s --
z+
Content-Disposition: form-data; name="%s"z; filename="%s"� zutf-8s
zSubmitting %s to %sz multipart/form-data; boundary=%s)z Content-typezContent-lengthZ
Authorization)�data�headers�� zServer response (%s): %s�
zK---------------------------------------------------------------------------zUpload failed (%s): %s)Dr r �AssertionErrorr
r r
r$ �open�close�readr ZmetadataZget_nameZ get_version�os�path�basename�hashlibZsha256Z hexdigestZget_descriptionZget_urlZ get_contactZget_contact_emailZ get_licenceZget_long_descriptionZ get_keywordsZ
get_platformsZget_classifiersZget_download_urlZ get_providesZ get_requiresZ
get_obsoletesZmd5�
ValueErrorZannouncer �INFOZ_hashlibr. r r �encoder �decode�io�BytesIO�items�
isinstance�list�type�tuple�str�write�getvalue�lenr r Zgetcoder r �code�OSErrorZERRORr Z_read_pypi_response�joinr )"r r r r! ZschemaZnetlocZurlZparamsZqueryZ fragmentsZgpg_args�fr) �metar2 Zdigest�er r. Z user_passZauth�boundaryZ sep_boundaryZ end_boundaryZbody�key�value�titler3 Zrequest�resultZstatus�reason�textr r r r B s� � �
�! �
��
�
zupload.upload_fileN) �__name__�
__module__� __qualname__r+ r Z user_optionsZboolean_optionsr r r" r r r r r r s � r )�__doc__r: rB r- r= �base64r Zurllib.requestr r r Z urllib.parser Zdistutils.errorsr r Zdistutils.corer Zdistutils.spawnr
Z distutilsr r r r r r �<module> s __pycache__/build_scripts.cpython-38.pyc 0000644 00000010346 15051366006 0014260 0 ustar 00 U
e5dX � @ s� d Z ddlZddlZddlmZ ddlmZ ddlmZ ddl m
Z
ddl m Z m
Z
ddlmZ ddlZe�d �ZG d
d � d e�ZG d d
� d
ee
�ZdS )zRdistutils.command.build_scripts
Implements the Distutils 'build_scripts' command.� N)�ST_MODE)� sysconfig)�Command)�newer)� convert_path� Mixin2to3)�logs ^#!.*python[0-9.]*([ ].*)?$c @ sH e Zd ZdZdddgZdgZdd� Zdd � Zd
d � Zd d
� Z dd� Z
dS )�
build_scriptsz("build" scripts (copy and fixup #! line))z
build-dir=�dz directory to "build" (copy) to)�force�fz1forcibly build everything (ignore file timestamps)z executable=�ez*specify final destination interpreter pathr c C s" d | _ d | _d | _d | _d | _d S �N)� build_dir�scriptsr �
executable�outfiles��self� r �7/usr/lib64/python3.8/distutils/command/build_scripts.py�initialize_options s
z build_scripts.initialize_optionsc C s | � dddd� | jj| _d S )NZbuild)r r )r r )r r )Zset_undefined_optionsZ distributionr r r r r �finalize_options% s �z build_scripts.finalize_optionsc C s | j S r )r r r r r �get_source_files, s z build_scripts.get_source_filesc C s | j s
d S | �� d S r )r � copy_scriptsr r r r �run/ s zbuild_scripts.runc
C s� | � | j� g }g }| jD �] }d}t|�}tj�| jtj�|��}|�|� | j slt
||�slt � d|� qzt
|d�}W n tk
r� | js�� d}Y nXX t�|j�\}}|�d� |�� } | s�| �d| � qt�| �}
|
r�d}|
�d�p�d } |�rt �d
|| j� |�|� | j�stj�s*| j} n(tj�t� d �d t� d
�t� d�f �} t� | �} d| | d }
z|
� d� W n$ t k
�r� t d�!|
���Y nX z|
� |� W n& t k
�r� t d�!|
|���Y nX t
|d�� }|�"|
� |�#|�$� � W 5 Q R X |�r8|�%� q|�r"|�%� |�|� | �&||� qtj'dk�r�|D ]`}| j�rdt �d|� nDt�(|�t) d@ }|dB d@ }||k�rJt �d|||� t�*||� �qJ||fS )a" Copy each script listed in 'self.scripts'; if it's marked as a
Python script in the Unix way (first line matches 'first_line_re',
ie. starts with "\#!" and contains "python"), then adjust the first
line to refer to the current Python interpreter as we copy.
Fznot copying %s (up-to-date)�rbNr z %s is an empty file (skipping)T� � z copying and adjusting %s -> %sZBINDIRz
python%s%sZVERSIONZEXEs #!�
zutf-8z.The shebang ({!r}) is not decodable from utf-8zAThe shebang ({!r}) is not decodable from the script encoding ({})�wb�posixzchanging mode of %si� im z!changing mode of %s from %o to %o)+Zmkpathr r r �os�path�join�basename�appendr r r �debug�open�OSError�dry_run�tokenize�detect_encoding�readline�seek�warn�
first_line_re�match�group�infor Z python_buildr Zget_config_var�fsencode�decode�UnicodeDecodeError�
ValueError�format�write�
writelines� readlines�closeZ copy_file�name�statr �chmod)r r �
updated_filesZscriptZadjustZoutfiler �encoding�linesZ
first_liner1 Z post_interpr ZshebangZoutf�fileZoldmodeZnewmoder r r r 5 s�
�
��
��
��
�zbuild_scripts.copy_scriptsN) �__name__�
__module__� __qualname__Z descriptionZ user_optionsZboolean_optionsr r r r r r r r r r s �r c @ s e Zd Zdd� ZdS )�build_scripts_2to3c C s& t �| �\}}| js | �|� ||fS r )r r r* Zrun_2to3)r r r@ r r r r � s
z build_scripts_2to3.copy_scriptsN)rD rE rF r r r r r rG � s rG )�__doc__r" �rer> r Z distutilsr Zdistutils.corer Zdistutils.dep_utilr Zdistutils.utilr r r r+ �compiler0 r rG r r r r �<module> s
__pycache__/install_headers.cpython-38.opt-1.pyc 0000644 00000003256 15051366006 0015514 0 ustar 00 U
e5d � @ s$ d Z ddlmZ G dd� de�ZdS )z�distutils.command.install_headers
Implements the Distutils 'install_headers' command, to install C/C++ header
files to the Python include directory.� )�Commandc @ sF e Zd ZdZddgZdgZdd� Zdd� Zd d
� Zd d � Z d
d� Z
dS )�install_headerszinstall C/C++ header files)z install-dir=�dz$directory to install header files to)�force�fz-force installation (overwrite existing files)r c C s d | _ d| _g | _d S )Nr )� install_dirr �outfiles��self� r �9/usr/lib64/python3.8/distutils/command/install_headers.py�initialize_options s z"install_headers.initialize_optionsc C s | � ddd� d S )NZinstall)r r )r r )Zset_undefined_optionsr r r r �finalize_options s �z install_headers.finalize_optionsc C sH | j j}|sd S | �| j� |D ]"}| �|| j�\}}| j�|� q d S �N)� distribution�headersZmkpathr Z copy_filer �append)r
r �header�out�_r r r �run! s zinstall_headers.runc C s | j jp
g S r )r r r r r r �
get_inputs+ s zinstall_headers.get_inputsc C s | j S r )r r r r r � get_outputs. s zinstall_headers.get_outputsN) �__name__�
__module__� __qualname__Z descriptionZ user_optionsZboolean_optionsr
r r r r r r r r r
s �
r N)�__doc__Zdistutils.corer r r r r r �<module> s __pycache__/clean.cpython-38.pyc 0000644 00000004066 15051366006 0012476 0 ustar 00 U
e5d�
� @ sD d Z ddlZddlmZ ddlmZ ddlmZ G dd� de�ZdS )zBdistutils.command.clean
Implements the Distutils 'clean' command.� N)�Command)� remove_tree)�logc @ s> e Zd ZdZddddddgZdgZd d
� Zd d � Zd
d� ZdS )�cleanz-clean up temporary files from 'build' command)z build-base=�bz2base build directory (default: 'build.build-base'))z
build-lib=Nz<build directory for all modules (default: 'build.build-lib'))z build-temp=�tz7temporary build directory (default: 'build.build-temp'))zbuild-scripts=Nz<build directory for scripts (default: 'build.build-scripts'))z bdist-base=Nz+temporary directory for built distributions)�all�az7remove all build output, not just temporary by-productsr c C s( d | _ d | _d | _d | _d | _d | _d S )N)�
build_base� build_lib�
build_temp�
build_scripts�
bdist_baser ��self� r �//usr/lib64/python3.8/distutils/command/clean.py�initialize_options s zclean.initialize_optionsc C s" | � ddddd� | � dd� d S )NZbuild)r
r
)r r )r
r
)r r Zbdist)r r )Zset_undefined_optionsr r r r �finalize_options( s ��zclean.finalize_optionsc C s� t j�| j�r t| j| jd� nt�d| j� | jrr| j | j
| j fD ],}t j�|�rdt|| jd� qDt� d|� qD| js�z t �
| j� t�d| j� W n tk
r� Y nX d S )N)�dry_runz%'%s' does not exist -- can't clean itz
removing '%s')�os�path�existsr r r r �debugr r r r
�warn�rmdirr
�info�OSError)r Z directoryr r r �run1 s* �� � z clean.runN) �__name__�
__module__� __qualname__Z descriptionZ user_optionsZboolean_optionsr r r r r r r r s � r ) �__doc__r Zdistutils.corer Zdistutils.dir_utilr Z distutilsr r r r r r �<module> s
__pycache__/bdist_rpm.cpython-38.opt-1.pyc 0000644 00000030114 15051366006 0014327 0 ustar 00 U
e5dIT � @ s� d Z ddlZddlZddlZddlmZ ddlmZ ddlm Z ddl
m Z ddl T ddl
mZ dd lmZ G d
d � d e�ZdS ) zwdistutils.command.bdist_rpm
Implements the Distutils 'bdist_rpm' command (create RPM source and binary
distributions).� N)�Command)�DEBUG)� get_platform)�
write_file)�*)�get_python_version)�logc ) @ s� e Zd ZdZdddddddd d
d d d
ddddddddddddddd d d d d d!d"d#d$d%d&d'd(d)d*g)Zd+d,d-d.d/gZd+d,d-d0�Zd1d2� Zd3d4� Zd5d6� Z d7d8� Z
d9d:� Z d;d<� Z d=d>� Z
d?S )@� bdist_rpmzcreate an RPM distribution)z bdist-base=Nz/base directory for creating built distributions)z rpm-base=Nzdbase directory for creating RPMs (defaults to "rpm" under --bdist-base; must be specified for RPM 2))z dist-dir=�dzDdirectory to put final RPM files in (and .spec files if --spec-only))zpython=NzMpath to Python interpreter to hard-code in the .spec file (default: "python"))z
fix-pythonNzLhard-code the exact path to the current Python interpreter in the .spec file)z spec-onlyNzonly regenerate spec file)z source-onlyNzonly generate source RPM)z binary-onlyNzonly generate binary RPM)z use-bzip2Nz7use bzip2 instead of gzip to create source distribution)zdistribution-name=Nzgname of the (Linux) distribution to which this RPM applies (*not* the name of the module distribution!))zgroup=Nz9package classification [default: "Development/Libraries"])zrelease=NzRPM release number)zserial=NzRPM serial number)zvendor=NzaRPM "vendor" (eg. "Joe Blow <joe@example.com>") [default: maintainer or author from setup script])z packager=NzBRPM packager (eg. "Jane Doe <jane@example.net>") [default: vendor])z
doc-files=Nz6list of documentation files (space or comma-separated))z
changelog=Nz
RPM changelog)zicon=Nzname of icon file)z provides=Nz%capabilities provided by this package)z requires=Nz%capabilities required by this package)z
conflicts=Nz-capabilities which conflict with this package)zbuild-requires=Nz+capabilities required to build this package)z
obsoletes=Nz*capabilities made obsolete by this package)�
no-autoreqNz+do not automatically calculate dependencies)� keep-temp�kz"don't clean up RPM build directory)� no-keep-tempNz&clean up RPM build directory [default])�use-rpm-opt-flagsNz8compile with RPM_OPT_FLAGS when building from source RPM)�no-rpm-opt-flagsNz&do not pass any RPM CFLAGS to compiler)� rpm3-modeNz"RPM 3 compatibility mode (default))� rpm2-modeNzRPM 2 compatibility mode)z prep-script=Nz3Specify a script for the PREP phase of RPM building)z
build-script=Nz4Specify a script for the BUILD phase of RPM building)z pre-install=Nz:Specify a script for the pre-INSTALL phase of RPM building)zinstall-script=Nz6Specify a script for the INSTALL phase of RPM building)z
post-install=Nz;Specify a script for the post-INSTALL phase of RPM building)zpre-uninstall=Nz<Specify a script for the pre-UNINSTALL phase of RPM building)zpost-uninstall=Nz=Specify a script for the post-UNINSTALL phase of RPM building)z
clean-script=Nz4Specify a script for the CLEAN phase of RPM building)zverify-script=Nz6Specify a script for the VERIFY phase of the RPM build)z force-arch=Nz0Force an architecture onto the RPM build process)�quiet�qz3Run the INSTALL phase of RPM building in quiet moder r r r r )r r r c C s� d | _ d | _d | _d | _d | _d | _d | _d | _d | _d | _ d | _
d | _ d | _ d | _
d | _d | _d | _d | _d | _d | _d | _d | _d | _d | _d | _d | _d | _d | _d | _ d | _ d | _ d | _ d | _ d| _!d| _"d| _#d| _$d | _%d| _&d S )Nr � )'�
bdist_base�rpm_base�dist_dir�python�
fix_python� spec_only� binary_only� source_only� use_bzip2�distribution_name�group�release�serial�vendor�packager� doc_files� changelog�icon� prep_script� build_script�install_script� clean_script�
verify_script� pre_install� post_install�
pre_uninstall�post_uninstall�prep�provides�requires� conflicts�build_requires� obsoletes� keep_temp�use_rpm_opt_flags� rpm3_mode�
no_autoreq�
force_archr ��self� r> �3/usr/lib64/python3.8/distutils/command/bdist_rpm.py�initialize_options� sN z bdist_rpm.initialize_optionsc C s� | � dd� | jd kr6| js$td��tj�| jd�| _| jd krX| j rPt
j | _qfd| _n| j rftd��tj dkr~t
dtj ��| jr�| jr�td ��| j�� s�d
| _| � dd � | �� d S ) NZbdist)r r z)you must specify --rpm-base in RPM 2 mode�rpmZpython3z8--python and --fix-python are mutually exclusive options�posixz9don't know how to create RPM distributions on platform %sz6cannot supply both '--source-only' and '--binary-only'r )r r )Zset_undefined_optionsr r9 ZDistutilsOptionError�os�path�joinr r r �sys�
executable�nameZDistutilsPlatformErrorr r � distribution�has_ext_modulesr8 �finalize_package_datar< r> r> r? �finalize_options� s6
�
�
� �
zbdist_rpm.finalize_optionsc C sT | � dd� | � dd| j�� | j�� f � | � d� | �d� t| jt�rxdD ]&}tj �
|�rP|| jkrP| j� |� qP| � dd � | � d
� | � d � | � d � | � | j
�| _
| �d
� | �d� | �d� | �d� | �d� | �d� | �d� | �d� | �d� | �d� | �d� | �d� | �d� | �d� | �d� | � d � d S ) Nr zDevelopment/Librariesr# z%s <%s>r$ r% )ZREADMEz
README.txtr! �1r" r r& r' r( r) r* r+ r, r- r. r/ r0 r2 r3 r4 r5 r6 r; )Z
ensure_stringrI Z get_contactZget_contact_emailZensure_string_list�
isinstancer% �listrC rD �exists�append�_format_changelogr& Zensure_filename)r= Zreadmer> r> r? rK � sB
��
z bdist_rpm.finalize_package_datac C s� t r<td� td| j� td| j� td| j� td| j� | jrT| j}| �|� n8i }dD ]&}t j
� | j |�||< | �|| � q\|d }t j
� |d| j
�� �}| �t|| �� fd | � | jr�d S | j
jd d � }| �d
�}| jr�d g|_nd g|_| �d
� || j
_|�� d
}|d }| �||� | j�rbt j
�| j��rT| �| j|� ntd| j ��t � d� dg} | j �r�| � d� n | j �r�| � d� n
| � d� | �!dd| j" g� | j#�r�| �!ddt j
�$| j � g� | j%�s�| � d� | j&�r | � d� | � |� d}
|
d } d |
d } d | | |f }
t �'|
�}zlg }d }|�)� }|�sV�q�|�*� �+� }|� |d � |d k�rD|d
}�qD|�(� }|�r�t,d t-|
� ��W 5 |�(� X | �.| � | j/�s�| j
�0� �r�t1� }nd!}| j �s(t j
� |d" |�}| �2|| j� t j
� | j|�}| j
j� d#||f� | j �s�|D ]`}t j
� |d$ |�}t j
�|��r4| �2|| j� t j
� | jt j
�3|��}| j
j� d#||f� �q4d S )%Nzbefore _get_package_data():zvendor =z
packager =z doc_files =z changelog =)�SOURCES�SPECSZBUILD�RPMS�SRPMSrT z%s.specz writing '%s'�sdistZbztarZgztarr rS z icon file '%s' does not existz
building RPMsZrpmbuildz-bsz-bbz-baz--definez __python %sz
_topdir %sz--cleanz--quietz %{name}-%{version}-%{release}z.src.rpmz%{arch}/z .%{arch}.rpmz%rpm -q --qf '%s %s\n' --specfile '%s'r zFailed to execute: %s�anyrV r rU )4r �printr# r$ r% r& r r ZmkpathrC rD rE r rI �get_nameZexecuter �_make_spec_fileZ
dist_filesZreinitialize_commandr ZformatsZ run_commandZget_archive_filesZ copy_filer' rP ZDistutilsFileErrorr �infor rQ r �extendr r9 �abspathr7 r �popen�close�readline�strip�splitZDistutilsExecError�reprZspawnZdry_runrJ r Z move_file�basename)r= Zspec_dirZrpm_dirr
Z spec_pathZsaved_dist_filesrW �sourceZ
source_dirZrpm_cmdZ
nvr_stringZsrc_rpmZ non_src_rpmZq_cmd�outZ binary_rpmsZ
source_rpm�line�lZstatusZ pyversionZsrpm�filenamerA r> r> r? �run s� ���
�
�
�
�
��z
bdist_rpm.runc C s t j�| jt j�|��S )N)rC rD rE r re )r= rD r> r> r? �
_dist_path� s zbdist_rpm._dist_pathc
C sJ d| j �� d| j �� �dd� d| j �� d| j�dd� dd| j �� g}t�d �}d
�d d � |� � D ��}d
}d}|�||�}||kr�|�
d� |�
d| d
� |� dddg� | j r�|�
d� n
|�
d� |� d| j �
� d| j ddg� | j�s| j �� �s&|�
d� n|�
d| j � d D ]V}t| |�� �}t|t��rb|�
d |d �|�f � n |d k �r*|�
d ||f � �q*| j �� d k�r�|�
d!| j �� � | j�r�|�
d"| j � | j�r�|�
d#d �| j� � | j�r�|�
d$tj�| j� � | j �r|�
d%� |� dd&| j � � g� d'| j tj�t j d( �f }d)| } | j!�rXd*| } d+| }
d,d-d.| fd/d0|
fd1d2d3d4d5d6g } | D ]n\} }
}t| |
�}|�s�|�r�|� dd7| g� |�r�t"|��}|� |�#� �$d
�� W 5 Q R X n
|�
|� �q�|� dd8d9g� | j%�r$|�
d:d �| j%� � | j&�rF|� dd;g� |� | j&� |S )<ziGenerate the text of an RPM spec file and return it as a
list of strings (one per line).
z
%define name z%define version �-�_z%define unmangled_version z%define release � z Summary: z rpm --eval %{__os_install_post}�
c S s g | ]}d |� � �qS )z %s \)rb )�.0rh r> r> r? �
<listcomp>� s �z-bdist_rpm._make_spec_file.<locals>.<listcomp>zbrp-python-bytecompile \
z%brp-python-bytecompile %{__python} \
z2# Workaround for http://bugs.python.org/issue14443z%define __os_install_post z
Name: %{name}zVersion: %{version}zRelease: %{release}z-Source0: %{name}-%{unmangled_version}.tar.bz2z,Source0: %{name}-%{unmangled_version}.tar.gzz License: zGroup: z>BuildRoot: %{_tmppath}/%{name}-%{version}-%{release}-buildrootzPrefix: %{_prefix}zBuildArch: noarchz
BuildArch: %s)ZVendorZPackagerZProvidesZRequiresZ ConflictsZ Obsoletesz%s: %s� NZUNKNOWNzUrl: zDistribution: zBuildRequires: zIcon: z
AutoReq: 0z %descriptionz%s %sr z%s buildz env CFLAGS="$RPM_OPT_FLAGS" z>%s install -O1 --root=$RPM_BUILD_ROOT --record=INSTALLED_FILES)r1 r( z&%setup -n %{name}-%{unmangled_version}Zbuildr) Zinstallr* )Zcleanr+ zrm -rf $RPM_BUILD_ROOT)Z verifyscriptr, N)Zprer- N)Zpostr. N)Zpreunr/ N)Zpostunr0 N�%z%files -f INSTALLED_FILESz%defattr(-,root,root)z%doc z
%changelog)'rI rZ Z get_version�replacer! Zget_description�
subprocessZ getoutputrE �
splitlinesrQ r] r Z get_licenser r; rJ �getattr�lowerrN rO Zget_urlr r5 r' rC rD re r: Zget_long_descriptionr rF �argvr8 �open�readrc r% r& )r= Z spec_fileZ vendor_hookZproblemZfixedZ
fixed_hookZfield�valZdef_setup_callZ def_buildZ install_cmdZscript_optionsZrpm_opt�attr�default�fr> r> r? r[ � s� �
�
�
�
�
� ��
�
�� zbdist_rpm._make_spec_filec C s| |s|S g }|� � �d�D ]N}|� � }|d dkrB|�d|g� q|d dkrZ|�|� q|�d| � q|d sx|d= |S )zKFormat the changelog correctly and convert it to a list of strings
rp r r ro rm z )rb rc r] rQ )r= r& Z
new_changelogrh r> r> r? rR 1 s zbdist_rpm._format_changelogN)�__name__�
__module__� __qualname__Z descriptionZ user_optionsZboolean_optionsZ negative_optr@ rL rK rk rl r[ rR r> r> r> r? r sx �m ��- - *r )�__doc__rv rF rC Zdistutils.corer Zdistutils.debugr Zdistutils.utilr Zdistutils.file_utilr Zdistutils.errorsZdistutils.sysconfigr Z distutilsr r r> r> r> r? �<module> s __pycache__/build_ext.cpython-38.opt-2.pyc 0000644 00000033546 15051366006 0014340 0 ustar 00 U
e5dP{ � @ s� d dl Z d dlZd dlZd dlZd dlmZ d dlT d dlmZm Z d dlm
Z
d dl m Z d dl
mZ d dlmZ d d lmZ d d
lmZ e�d �Zd d
� ZG dd� de�ZdS )� N)�Command)�*)�customize_compiler�get_python_version)�get_config_h_filename)� newer_group)� Extension)� get_platform)�log)� USER_BASEz3^[a-zA-Z_][a-zA-Z_0-9]*(\.[a-zA-Z_][a-zA-Z_0-9]*)*$c C s ddl m} | � d S )Nr ��show_compilers)�distutils.ccompilerr
r � r �3/usr/lib64/python3.8/distutils/command/build_ext.pyr
s r
c @ s e Zd ZdZdej Zddddde� fdd d
d e fd d
dddde fddddddddddgZd d d d d gZ d!d"d#e
fgZ d$d%� Z d&d'� Z
d(d)� Zd*d+� Zd,d-� Zd.d/� Zd0d1� Zd2d3� Zd4d5� Zejd6d7� �Zd8d9� Zd:d;� Zd<d=� Zd>d?� Zd@dA� Z dBdC� Z dDdE� Z dFdG� Z d"S )H� build_extz8build C/C++ extensions (compile/link to build directory)z (separated by '%s'))z
build-lib=�bz(directory for compiled extension modules)z build-temp=�tz1directory for temporary files (build by-products)z
plat-name=�pz>platform name to cross-compile for, if supported (default: %s))�inplace�iziignore build-lib and put compiled extensions into the source directory alongside your pure Python modulesz
include-dirs=�Iz.list of directories to search for header files)zdefine=�Dz C preprocessor macros to define)zundef=�Uz!C preprocessor macros to undefine)z
libraries=�lz!external C libraries to link withz
library-dirs=�Lz.directories to search for external C libraries)zrpath=�Rz7directories to search for shared C libraries at runtime)z
link-objects=�Oz2extra explicit link objects to include in the link)�debug�gz'compile/link with debugging information)�force�fz2forcibly build everything (ignore file timestamps))z compiler=�czspecify the compiler type)z parallel=�jz number of parallel build jobs)�swig-cppNz)make SWIG create C++ files (default is C))z
swig-opts=Nz!list of SWIG command line options)zswig=Nzpath to the SWIG executable)�userNz#add user include, library and rpathr r r r$ r% z
help-compilerNzlist available compilersc C s� d | _ d | _d | _d | _d| _d | _d | _d | _d | _d | _ d | _
d | _ d | _ d | _
d | _d | _d | _d | _d | _d | _d | _d S )Nr )�
extensions� build_lib� plat_name�
build_tempr �package� include_dirs�define�undef� libraries� library_dirs�rpath� link_objectsr r �compiler�swig�swig_cpp� swig_optsr% �parallel��selfr r r �initialize_optionsj s* z build_ext.initialize_optionsc
C s� ddl m} | �ddddddd d
� | jd kr8| jj| _| jj| _|�� }|jd d �}| j d krn| jj pjg | _ t
| j t �r�| j � t
j�| _ tjtjkr�| j �t
j�tjd
�� | j �|� t
jj�� ||kr�| j �|� t
jj�� | �d� | �d� | jd k�rg | _| jd k�r g | _n t
| jt ��r:| j� t
j�| _| jd k�rNg | _n t
| jt ��rl| j� t
j�| _t
jdk�rh| j�t
j�tjd�� tjtjk�r�| j�t
j�tjd�� | j �r�t
j�| j d�| _ nt
j�| j d�| _ | j �t
j� t � �� t tdd �}|�r| j�|� | j!dk�r*d}n| j!dd � }t
j�tjd�}|�r\t
j�||�}| j�|� tj"d d� dk�r�tj#�$t
j�tjd���r�| j�t
j�tjdd t%� d �� n | j�d � |�&d ��r�|j'�s�| j�|�&d �� n | j�d � | j(�r | j(� d!�}d"d#� |D �| _(| j)�r4| j)� d!�| _)| j*d k�rHg | _*n| j*� d$�| _*| j+�r�t
j�t,d
�}t
j�t,d�} t
j�-|��r�| j �|� t
j�-| ��r�| j�| � | j�| � t
| j.t ��r�zt/| j.�| _.W n t0k
�r� t1d%��Y nX d S )&Nr )� sysconfigZbuild)r' r' )r) r) )r2 r2 )r r )r r )r6 r6 )r( r( � )Z
plat_specificZincluder. r1 �ntZlibsZDebugZRelease�_home�win32� ZPCbuild� �cygwin�bin�lib�pythonZconfig�.�Py_ENABLE_SHAREDZLIBDIR�,c S s g | ] }|d f�qS )�1r )�.0Zsymbolr r r �
<listcomp>� s z.build_ext.finalize_options.<locals>.<listcomp>� z parallel should be an integer)2� distutilsr: Zset_undefined_optionsr* � distributionZ ext_packageZ ext_modulesr& Zget_python_incr+ �
isinstance�str�split�os�pathsep�sys� exec_prefix�base_exec_prefix�append�path�join�extendZensure_string_listr. r/ r0 �name�prefixr r) �dirnamer �getattrr( �platform�
executable�
startswithr �get_config_varZ python_buildr, r- r5 r% r �isdirr6 �int�
ValueErrorZDistutilsOptionError)
r8 r: Z
py_includeZplat_py_includeZ _sys_home�suffixZnew_libZdefinesZ user_includeZuser_libr r r �finalize_options� s� �
�
� zbuild_ext.finalize_optionsc C sj ddl m} | jsd S | j�� rL| �d�}| j�|�� p:g � | j �
|j � || j | j
| j| jd�| _ t| j � tjdkr�| jt� kr�| j �| j� | jd k r�| j �| j� | jd k r�| jD ]\}}| j �||� q�| jd k r�| jD ]}| j �|� q�| jd k �r| j � | j� | j d k �r*| j � | j � | j d k �rD| j � | j � | j d k �r^| j �!| j � | �"� d S )Nr )� new_compiler�
build_clib)r2 �verbose�dry_runr r< )#r rg r& rM Zhas_c_libraries�get_finalized_commandr. rY Zget_library_namesr/ rV rh r2 ri rj r r rQ rZ r( r Z
initializer+ Zset_include_dirsr, Z define_macror- Zundefine_macroZ
set_librariesZset_library_dirsr0 Zset_runtime_library_dirsr1 Zset_link_objects�build_extensions)r8 rg rh rZ �value�macror r r �run s@
�
z
build_ext.runc
C sv t |t�std��t|�D �]T\}}t |t�r0qt |t�rFt|�dkrNtd��|\}}t�d|� t |t �rvt
� |�s~td��t |t �s�td��t||d �}dD ]"}|�
|�}|d k r�t|||� q�|�
d �|_d
|kr�t�d � |�
d �}|�rhg |_g |_|D ]b} t | t��r"t| �d
k�s*td��t| �dk�rJ|j�| d � nt| �dk�r|j�| � �q|||< qd S )Nz:'ext_modules' option must be a list of Extension instances� zMeach element of 'ext_modules' option must be an Extension instance or 2-tuplezvold-style (ext_name, build_info) tuple found in ext_modules for extension '%s' -- please convert to Extension instancezRfirst element of each tuple in 'ext_modules' must be the extension name (a string)zOsecond element of each tuple in 'ext_modules' must be a dictionary (build info)�sources)r+ r/ r. �
extra_objects�extra_compile_args�extra_link_argsr0 Zdef_filez9'def_file' element of build info dict no longer supported�macros)r; rp z9'macros' element of build info dict must be 1- or 2-tupler; r )rN �list�DistutilsSetupError� enumerater �tuple�lenr
�warnrO �extension_name_re�match�dict�get�setattr�runtime_library_dirs�
define_macros� undef_macrosrV )
r8 r& r �ext�ext_nameZ
build_info�key�valru rn r r r �check_extensions_listV s^
�
��
��
�
�z build_ext.check_extensions_listc C s, | � | j� g }| jD ]}|�|j� q|S �N)r� r& rY rq )r8 � filenamesr� r r r �get_source_files� s
zbuild_ext.get_source_filesc C s2 | � | j� g }| jD ]}|�| �|j�� q|S r� )r� r& rV �get_ext_fullpathrZ )r8 Zoutputsr� r r r � get_outputs� s
zbuild_ext.get_outputsc C s( | � | j� | jr | �� n| �� d S r� )r� r& r6 �_build_extensions_parallel�_build_extensions_serialr7 r r r rl � s
zbuild_ext.build_extensionsc s� �j }�j dkrt�� }zddlm} W n tk
r@ d }Y nX |d krV��� d S ||d��P� � �fdd��jD �}t�j|�D ]&\}}�� |�� |�
� W 5 Q R X q�W 5 Q R X d S )NTr )�ThreadPoolExecutor)Z max_workersc s g | ]}� � �j|��qS r )Zsubmit�build_extension)rI r� �Zexecutorr8 r r rJ � s �z8build_ext._build_extensions_parallel.<locals>.<listcomp>) r6 rQ � cpu_countZconcurrent.futuresr� � ImportErrorr� r& �zip�_filter_build_errors�result)r8 Zworkersr� Zfuturesr� Zfutr r� r r� � s"
� z$build_ext._build_extensions_parallelc
C s0 | j D ]$}| �|�� | �|� W 5 Q R X qd S r� )r& r� r� )r8 r� r r r r� � s
z"build_ext._build_extensions_serialc
c sT z
d V W nD t ttfk
rN } z |js*� | �d|j|f � W 5 d }~X Y nX d S )Nz"building extension "%s" failed: %s)ZCCompilerErrorZDistutilsErrorZ CompileErrorZoptionalr{ rZ )r8 r� �er r r r� � s
�z build_ext._filter_build_errorsc
C sP |j }|d ks t|ttf�s*td|j ��t|�}| �|j�}||j }| jslt ||d�slt
� d|j� d S t
� d|j� | �
||�}|jp�g }|jd d � }|jD ]}|�|f� q�| jj|| j||j| j ||jd�}|d d � | _|jr�|�|j� |j�pg }|j�p| j�|�} | jj ||| � |�|j |j || � |�| j | j| d�
d S )Nzjin 'ext_modules' option (extension '%s'), 'sources' must be present and must be a list of source filenamesZnewerz$skipping '%s' extension (up-to-date)zbuilding '%s' extension)Z
output_dirru r+ r �extra_postargs�depends)r. r/ r� r� �export_symbolsr r) Z target_lang)!rq rN rv ry rw rZ r� r� r r r
r �info� swig_sourcesrs r� r� rV r2 �compiler) r+ Z_built_objectsrr rY rt �languageZdetect_languageZlink_shared_object�
get_librariesr/ r� �get_export_symbols)
r8 r� rq �ext_pathr� Z
extra_argsru r- Zobjectsr� r r r r� � sX ��
�
�zbuild_ext.build_extensionc C s$ g }g }i }| j r t�d� | j s6d| jks6d|jkr<d}nd}|D ]P}tj�|�\}} | dkr�|�|d | � |�|� |d ||< qD|�|� qD|s�|S | jp�| � � }
|
dg} | �
| j� | j r�| �d� | js�|jD ]} | �| � q�|D ].}|| }
t� d ||
� | � | d
|
|g � q�|S ) Nz/--swig-cpp is deprecated - use --swig-opts=-c++z-c++z.cppz.cz.i�_wrap���z-pythonzswigging %s to %sz-o)
r4 r
r{ r5 rQ rW �splitextrV r3 � find_swigrY r� Zspawn)r8 rq � extensionZ new_sourcesr� Z swig_targetsZ
target_ext�source�baser� r3 Zswig_cmd�o�targetr r r r� 1 s@
�
zbuild_ext.swig_sourcesc C s^ t jdkrdS t jdkrLdD ]*}t j�d| d�}t j�|�r | S q dS tdt j ��d S )N�posixr3 r< )z1.3z1.2z1.1z c:\swig%szswig.exez>I don't know how to find (much less run) SWIG on platform '%s')rQ rZ rW rX �isfileZDistutilsPlatformError)r8 Zvers�fnr r r r� g s
��zbuild_ext.find_swigc C s� | � |�}|�d�}| �|d �}| jsRtjj|d d� |g � }tj�| j|�S d�|dd� �}| �d�}tj� |�
|��}tj�||�S )NrE r� r �build_py) �get_ext_fullnamerP �get_ext_filenamer rQ rW rX r' rk �abspathZget_package_dir)r8 r� �fullname�modpath�filenamer* r� Z package_dirr r r r� s
zbuild_ext.get_ext_fullpathc C s | j d kr|S | j d | S d S )NrE )r* )r8 r� r r r r� � s
zbuild_ext.get_ext_fullnamec C s. ddl m} |�d�}|d�}tjj|� | S )Nr �ra rE Z
EXT_SUFFIX)�distutils.sysconfigra rP rQ rW rX )r8 r� ra r� Z
ext_suffixr r r r� � s
zbuild_ext.get_ext_filenamec C sx d|j �d�d }z|�d� W n0 tk
rR d|�d��dd��d� }Y nX d | }||jkrr|j�|� |jS )
N�_rE r� �asciir Zpunycode� -� _ZPyInit)rZ rP �encode�UnicodeEncodeError�replace�decoder� rV )r8 r� re Z
initfunc_namer r r r� � s "
z build_ext.get_export_symbolsc C s� t jdkr^ddlm} t| j|�s�d}| jr4|d }|t jd? t jd? d@ f }|j|g S n�dd l m
} d
}|d �r�t t d �r�d
}n<t jdkr�d
}n,dt j
kr�|d�dkr�d
}n|d�dkr�d
}|r�|d�}|jd| g S |jS )Nr> r )� MSVCCompilerz
python%d%dZ_d� � � r� FrF ZgetandroidapilevelTrA Z_PYTHON_HOST_PLATFORMZANDROID_API_LEVELZMACHDEPZ LDVERSIONrD )rS r^ Zdistutils._msvccompilerr� rN r2 r �
hexversionr. r� ra �hasattrrQ �environ)r8 r� r� �templateZ pythonlibra Zlink_libpythonZ ldversionr r r r� � s4
�
zbuild_ext.get_libraries) �__name__�
__module__� __qualname__Z descriptionrQ rR Zsep_byr Z user_optionsZboolean_optionsr
Z help_optionsr9 rf ro r� r� r� rl r� r� �
contextlib�contextmanagerr� r� r� r� r� r� r� r� r� r r r r r ! sp
�����+ �� @N
K6
r )r� rQ �rerS Zdistutils.corer Zdistutils.errorsr� r r r Zdistutils.dep_utilr Zdistutils.extensionr Zdistutils.utilr rL r
Zsiter r� r| r
r r r r r �<module> s" � __pycache__/build_scripts.cpython-38.opt-1.pyc 0000644 00000010346 15051366006 0015217 0 ustar 00 U
e5dX � @ s� d Z ddlZddlZddlmZ ddlmZ ddlmZ ddl m
Z
ddl m Z m
Z
ddlmZ ddlZe�d �ZG d
d � d e�ZG d d
� d
ee
�ZdS )zRdistutils.command.build_scripts
Implements the Distutils 'build_scripts' command.� N)�ST_MODE)� sysconfig)�Command)�newer)� convert_path� Mixin2to3)�logs ^#!.*python[0-9.]*([ ].*)?$c @ sH e Zd ZdZdddgZdgZdd� Zdd � Zd
d � Zd d
� Z dd� Z
dS )�
build_scriptsz("build" scripts (copy and fixup #! line))z
build-dir=�dz directory to "build" (copy) to)�force�fz1forcibly build everything (ignore file timestamps)z executable=�ez*specify final destination interpreter pathr c C s" d | _ d | _d | _d | _d | _d S �N)� build_dir�scriptsr �
executable�outfiles��self� r �7/usr/lib64/python3.8/distutils/command/build_scripts.py�initialize_options s
z build_scripts.initialize_optionsc C s | � dddd� | jj| _d S )NZbuild)r r )r r )r r )Zset_undefined_optionsZ distributionr r r r r �finalize_options% s �z build_scripts.finalize_optionsc C s | j S r )r r r r r �get_source_files, s z build_scripts.get_source_filesc C s | j s
d S | �� d S r )r � copy_scriptsr r r r �run/ s zbuild_scripts.runc
C s� | � | j� g }g }| jD �] }d}t|�}tj�| jtj�|��}|�|� | j slt
||�slt � d|� qzt
|d�}W n tk
r� | js�� d}Y nXX t�|j�\}}|�d� |�� } | s�| �d| � qt�| �}
|
r�d}|
�d�p�d } |�rt �d
|| j� |�|� | j�stj�s*| j} n(tj�t� d �d t� d
�t� d�f �} t� | �} d| | d }
z|
� d� W n$ t k
�r� t d�!|
���Y nX z|
� |� W n& t k
�r� t d�!|
|���Y nX t
|d�� }|�"|
� |�#|�$� � W 5 Q R X |�r8|�%� q|�r"|�%� |�|� | �&||� qtj'dk�r�|D ]`}| j�rdt �d|� nDt�(|�t) d@ }|dB d@ }||k�rJt �d|||� t�*||� �qJ||fS )a" Copy each script listed in 'self.scripts'; if it's marked as a
Python script in the Unix way (first line matches 'first_line_re',
ie. starts with "\#!" and contains "python"), then adjust the first
line to refer to the current Python interpreter as we copy.
Fznot copying %s (up-to-date)�rbNr z %s is an empty file (skipping)T� � z copying and adjusting %s -> %sZBINDIRz
python%s%sZVERSIONZEXEs #!�
zutf-8z.The shebang ({!r}) is not decodable from utf-8zAThe shebang ({!r}) is not decodable from the script encoding ({})�wb�posixzchanging mode of %si� im z!changing mode of %s from %o to %o)+Zmkpathr r r �os�path�join�basename�appendr r r �debug�open�OSError�dry_run�tokenize�detect_encoding�readline�seek�warn�
first_line_re�match�group�infor Z python_buildr Zget_config_var�fsencode�decode�UnicodeDecodeError�
ValueError�format�write�
writelines� readlines�closeZ copy_file�name�statr �chmod)r r �
updated_filesZscriptZadjustZoutfiler �encoding�linesZ
first_liner1 Z post_interpr ZshebangZoutf�fileZoldmodeZnewmoder r r r 5 s�
�
��
��
��
�zbuild_scripts.copy_scriptsN) �__name__�
__module__� __qualname__Z descriptionZ user_optionsZboolean_optionsr r r r r r r r r r s �r c @ s e Zd Zdd� ZdS )�build_scripts_2to3c C s& t �| �\}}| js | �|� ||fS r )r r r* Zrun_2to3)r r r@ r r r r � s
z build_scripts_2to3.copy_scriptsN)rD rE rF r r r r r rG � s rG )�__doc__r" �rer> r Z distutilsr Zdistutils.corer Zdistutils.dep_utilr Zdistutils.utilr r r r+ �compiler0 r rG r r r r �<module> s
__pycache__/config.cpython-38.pyc 0000644 00000023765 15051366006 0012670 0 ustar 00 U
e5d=3 � @ sl d Z ddlZddlZddlmZ ddlmZ ddlmZ ddl m
Z
ddd �Z G d
d � d e�Z dd d
�Z
dS )a� distutils.command.config
Implements the Distutils 'config' command, a (mostly) empty command class
that exists mainly to be sub-classed by specific module distributions and
applications. The idea is that while every "config" command is different,
at least they're all named the same, and users always see "config" in the
list of standard commands. Also, this is a good place to put common
configure-like tasks: "try to compile this C code", or "figure out where
this header file lives".
� N)�Command)�DistutilsExecError)�customize_compiler)�logz.cz.cxx)�czc++c @ s� e Zd ZdZdddddddd d
g Zd d � Zd
d� Zdd� Zdd� Zdd� Z dd� Z
dd� Z dd� Z dd � Z
d0d d �Zd1d!d"�Zd2d#d$�Zd3d%d&�Zd4d'd(�Zd5d*d+�Zd d d g fd,d-�Zd6d.d/�Zd S )7�configzprepare to build)z compiler=Nzspecify the compiler type)zcc=Nz specify the compiler executable)z
include-dirs=�Iz.list of directories to search for header files)zdefine=�Dz C preprocessor macros to define)zundef=�Uz!C preprocessor macros to undefine)z
libraries=�lz!external C libraries to link with)z
library-dirs=�Lz.directories to search for external C libraries)�noisyNz1show every action (compile, link, run, ...) taken)z dump-sourceNz=dump generated source files before attempting to compile themc C s4 d | _ d | _d | _d | _d | _d| _d| _g | _d S )N� )�compilerZcc� include_dirs� libraries� library_dirsr
� dump_source�
temp_files��self� r �0/usr/lib64/python3.8/distutils/command/config.py�initialize_options3 s zconfig.initialize_optionsc C s� | j d kr| jj pg | _ n t| j t�r6| j �tj�| _ | jd krHg | _nt| jt�r^| jg| _| jd krpg | _n t| jt�r�| j�tj�| _d S �N) r Z distribution�
isinstance�str�split�os�pathsepr r r r r r �finalize_optionsB s
zconfig.finalize_optionsc C s d S r r r r r r �runR s z
config.runc C sz ddl m}m} t| j|�sv|| j| jdd�| _t| j� | jrN| j�| j� | j rb| j�
| j � | j rv| j� | j � dS )z^Check that 'self.compiler' really is a CCompiler object;
if not, make it one.
r )� CCompiler� new_compilerr )r �dry_runZforceN)
�distutils.ccompilerr" r# r r r$ r r Zset_include_dirsr Z
set_librariesr Zset_library_dirs)r r" r# r r r �_check_compilerY s �
zconfig._check_compilerc C sl dt | }t|d��L}|r>|D ]}|�d| � q |�d� |�|� |d dkr^|�d� W 5 Q R X |S )NZ _configtest�wz#include <%s>
�
���)�LANG_EXT�open�write)r �body�headers�lang�filename�file�headerr r r �_gen_temp_sourcefilek s
zconfig._gen_temp_sourcefilec C s< | � |||�}d}| j�||g� | jj|||d� ||fS )Nz
_configtest.i�r )r3 r �extendr Z
preprocess)r r- r. r r/ �src�outr r r � _preprocessw s
zconfig._preprocessc C s\ | � |||�}| jr"t|d| � | j�|g�\}| j�||g� | jj|g|d� ||fS )Nzcompiling '%s':r4 )r3 r � dump_filer Zobject_filenamesr r5 �compile)r r- r. r r/ r6 �objr r r �_compile~ s zconfig._compilec
C sr | � ||||�\}}tj�tj�|��d } | jj|g| |||d� | jjd k r\| | jj } | j� | � ||| fS )Nr )r r Z target_lang)
r< r �path�splitext�basenamer Zlink_executableZ
exe_extensionr �append)
r r- r. r r r r/ r6 r; �progr r r �_link� s � z config._linkc G sT |s| j }g | _ t�dd�|�� |D ](}zt�|� W q& tk
rL Y q&X q&d S )Nz removing: %s� )r r �info�joinr �remove�OSError)r � filenamesr0 r r r �_clean� s z
config._cleanNr c C sR ddl m} | �� d}z| �||||� W n |k
rD d}Y nX | �� |S )aQ Construct a source file from 'body' (a string containing lines
of C/C++ code) and 'headers' (a list of header files to include)
and run it through the preprocessor. Return true if the
preprocessor succeeded, false if there were any errors.
('body' probably isn't of much use, but what the heck.)
r �� CompileErrorTF)r% rK r& r8 rI �r r- r. r r/ rK �okr r r �try_cpp� s
zconfig.try_cppc C sx | � � | �||||�\}}t|t�r0t�|�}t|��.}d} |�� }
|
dkrPqb|�|
�r>d} qbq>W 5 Q R X | � � | S )a� Construct a source file (just like 'try_cpp()'), run it through
the preprocessor, and return true if any line of the output matches
'pattern'. 'pattern' should either be a compiled regex object or a
string containing a regex. If both 'body' and 'headers' are None,
preprocesses an empty file -- which can be useful to determine the
symbols the preprocessor and compiler set by default.
F� T)
r& r8 r r �rer: r+ �readline�searchrI ) r �patternr- r. r r/ r6 r7 r1 �match�liner r r �
search_cpp� s
zconfig.search_cppc C sd ddl m} | �� z| �||||� d}W n |k
rD d}Y nX t�|rRdpTd� | �� |S )zwTry to compile a source file built from 'body' and 'headers'.
Return true on success, false otherwise.
r rJ TF�success!�failure.)r% rK r& r< r rD rI rL r r r � try_compile� s
zconfig.try_compilec
C sp ddl m}m} | �� z | �||||||� d} W n ||fk
rP d} Y nX t�| r^dp`d� | �� | S )z�Try to compile and link a source file, built from 'body' and
'headers', to executable form. Return true on success, false
otherwise.
r �rK � LinkErrorTFrW rX )r% rK r[ r& rB r rD rI )
r r- r. r r r r/ rK r[ rM r r r �try_link� s
�
zconfig.try_linkc
C s� ddl m}m} | �� z.| �||||||�\} }
} | �| g� d} W n ||tfk
rd d} Y nX t�| rrdptd� | � � | S )z�Try to compile, link to an executable, and run a program
built from 'body' and 'headers'. Return true on success, false
otherwise.
r rZ TFrW rX )
r% rK r[ r& rB Zspawnr r rD rI )
r r- r. r r r r/ rK r[ r6 r; ZexerM r r r �try_run� s
�
zconfig.try_runr c C st | � � g }|r |�d| � |�d� |r<|�d| � n|�d| � |�d� d�|�d }| �|||||�S )a� Determine if function 'func' is available by constructing a
source file that refers to 'func', and compiles and links it.
If everything succeeds, returns true; otherwise returns false.
The constructed source file starts out by including the header
files listed in 'headers'. If 'decl' is true, it then declares
'func' (as "int func()"); you probably shouldn't supply 'headers'
and set 'decl' true in the same call, or you might get errors about
a conflicting declarations for 'func'. Finally, the constructed
'main()' function either references 'func' or (if 'call' is true)
calls it. 'libraries' and 'library_dirs' are used when
linking.
z
int %s ();z
int main () {z %s();z %s;�}r( )r& r@ rE r\ ) r �funcr. r r r ZdeclZcallr- r r r �
check_func s
�zconfig.check_funcc C s | � � | �d|||g| |�S )a� Determine if 'library' is available to be linked against,
without actually checking that any particular symbols are provided
by it. 'headers' will be used in constructing the source file to
be compiled, but the only effect of this is to check if all the
header files listed are available. Any libraries listed in
'other_libraries' will be included in the link, in case 'library'
has symbols that depend on other libraries.
zint main (void) { })r& r\ )r Zlibraryr r. r Zother_librariesr r r � check_lib4 s
�zconfig.check_libc C s | j d|g|d�S )z�Determine if the system header file named by 'header_file'
exists and can be found by the preprocessor; return true if so,
false otherwise.
z
/* No body */)r- r. r )rN )r r2 r r r/ r r r � check_headerB s
�zconfig.check_header)NNNr )NNNr )NNr )NNNNr )NNNNr )NNNNr r )NNr )�__name__�
__module__� __qualname__Z descriptionZ user_optionsr r r! r& r3 r8 r< rB rI rN rV rY r\ r] r` ra rb r r r r r s\ �
�
�
�
�
�
�r c C sJ |dkrt �d| � n
t �|� t| �}zt �|�� � W 5 |�� X dS )zjDumps a file content into log.info.
If head is not None, will be dumped before the file content.
Nz%s)r rD r+ �close�read)r0 �headr1 r r r r9 K s
r9 )N)�__doc__r rP Zdistutils.corer Zdistutils.errorsr Zdistutils.sysconfigr Z distutilsr r* r r9 r r r r �<module> s
8 __pycache__/install_data.cpython-38.opt-2.pyc 0000644 00000004142 15051366006 0015006 0 ustar 00 U
e5d � @ s8 d dl Z d dlmZ d dlmZmZ G dd� de�ZdS )� N)�Command)� change_root� convert_pathc @ sH e Zd ZdZdddgZdgZdd� Zdd � Zd
d � Zd d
� Z dd� Z
dS )� install_datazinstall data files)z install-dir=�dzIbase directory for installing data files (default: installation base dir))zroot=Nz<install everything relative to this alternate root directory)�force�fz-force installation (overwrite existing files)r c C s, d | _ g | _d | _d| _| jj| _d| _d S )Nr � )� install_dir�outfiles�rootr Z distribution�
data_files�warn_dir��self� r �6/usr/lib64/python3.8/distutils/command/install_data.py�initialize_options s
z install_data.initialize_optionsc C s | � dddd� d S )NZinstall)r r
)r r )r r )Zset_undefined_optionsr r r r �finalize_options# s
�z install_data.finalize_optionsc C s� | � | j� | jD ]�}t|t�rbt|�}| jrB| �d|| jf � | �|| j�\}}| j �
|� qt|d �}t j �
|�s�t j �| j|�}n| jr�t| j|�}| � |� |d g kr�| j �
|� q|d D ](}t|�}| �||�\}}| j �
|� q�qd S )NzMsetup script did not provide a directory for '%s' -- installing right in '%s'r r )Zmkpathr
r
�
isinstance�strr r �warnZ copy_filer �append�os�path�isabs�joinr r )r r �out�_�dir�datar r r �run* s,
�
zinstall_data.runc C s
| j pg S �N)r
r r r r �
get_inputsK s zinstall_data.get_inputsc C s | j S r" )r r r r r � get_outputsN s zinstall_data.get_outputsN) �__name__�
__module__� __qualname__Z descriptionZ user_optionsZboolean_optionsr r r! r# r$ r r r r r s � !r )r Zdistutils.corer Zdistutils.utilr r r r r r r �<module> s __pycache__/bdist.cpython-38.pyc 0000644 00000007124 15051366006 0012517 0 ustar 00 U
e5d� � @ sH d Z ddlZddlmZ ddlT ddlmZ dd� ZG dd � d e�ZdS )
zidistutils.command.bdist
Implements the Distutils 'bdist' command (create a built [binary]
distribution).� N)�Command)�*)� get_platformc C sP ddl m} g }tjD ]"}|�d| dtj| d f� q| |�}|�d� dS )zFPrint list of available formats (arguments to "--format" option).
r )� FancyGetopt�formats=N� z'List of available distribution formats:)Zdistutils.fancy_getoptr �bdist�format_commands�append�format_commandZ
print_help)r �formats�formatZpretty_printer� r �//usr/lib64/python3.8/distutils/command/bdist.py� show_formats s
�r c
@ s� e Zd ZdZdddde� fdddd d
gZd gZd d
defgZdZ ddd�Z
dddddddddg Z ddd d d d d d!d"d#� Z d$d%� Z
d&d'� Zd(d)� Zd
S )*r z$create a built (binary) distribution)z bdist-base=�bz4temporary directory for creating built distributionsz
plat-name=�pz;platform name to embed in generated filenames (default: %s))r Nz/formats for distribution (comma-separated list))z dist-dir=�dz=directory to put final built distributions in [default: dist])�
skip-buildNz2skip rebuilding everything (for testing/debugging))zowner=�uz@Owner name used when creating a tar file [default: current user])zgroup=�gzAGroup name used when creating a tar file [default: current group]r z help-formatsNz$lists available distribution formats)� bdist_rpm�gztar�zip)�posix�nt�rpm�bztar�xztar�ztar�tar�wininst�msi)r zRPM distribution)�
bdist_dumbzgzip'ed tar file)r# zbzip2'ed tar file)r# zxz'ed tar file)r# zcompressed tar file)r# ztar file)Z
bdist_wininstz Windows executable installer)r# zZIP file)Z bdist_msizMicrosoft Installer) r r r r r r r! r r" c C s. d | _ d | _d | _d | _d| _d | _d | _d S )Nr )�
bdist_base� plat_namer �dist_dir�
skip_build�group�owner)�selfr r r �initialize_optionsQ s zbdist.initialize_optionsc C s� | j d kr(| jrt� | _ n| �d�j | _ | jd krT| �d�j}tj�|d| j �| _| � d� | j
d kr�z| j tj g| _
W n" t
k
r� tdtj ��Y nX | jd kr�d| _d S )NZbuildzbdist.r z;don't know how to create built distributions on platform %sZdist)r% r' r Zget_finalized_commandr$ �
build_base�os�path�joinZensure_string_listr �default_format�name�KeyErrorZDistutilsPlatformErrorr& )r* r, r r r �finalize_optionsZ s*
�
��
zbdist.finalize_optionsc C s� g }| j D ]>}z|�| j| d � W q
tk
rF td| ��Y q
X q
tt| j ��D ]h}|| }| �|�}|| jkr�| j | |_ |dkr�| j
|_
| j |_ |||d d � kr�d|_ | �
|� qXd S )Nr zinvalid format '%s'r# r )r r
r r2 ZDistutilsOptionError�range�lenZreinitialize_command�no_format_optionr
r) r( Z keep_tempZ run_command)r* Zcommandsr
�iZcmd_nameZsub_cmdr r r �runv s"
z bdist.run)�__name__�
__module__� __qualname__Z descriptionr Z user_optionsZboolean_optionsr Z help_optionsr6 r0 r r r+ r3 r8 r r r r r sR ��� ��� ��
r ) �__doc__r- Zdistutils.corer Zdistutils.errorsZdistutils.utilr r r r r r r �<module> s __pycache__/build_clib.cpython-38.pyc 0000644 00000011320 15051366006 0013473 0 ustar 00 U
e5dV � @ sT d Z ddlZddlmZ ddlT ddlmZ ddlmZ dd� Z G d d
� d
e�Z
dS ) z�distutils.command.build_clib
Implements the Distutils 'build_clib' command, to build a C/C++ library
that is included in the module distribution and needed by an extension
module.� N)�Command)�*)�customize_compiler)�logc C s ddl m} | � d S )Nr ��show_compilers)�distutils.ccompilerr r � r �4/usr/lib64/python3.8/distutils/command/build_clib.pyr s r c @ sl e Zd ZdZdddddgZddgZd d
d efgZd d
� Zdd� Z dd� Z
dd� Z dd� Z dd� Z
dd� Zd
S )�
build_clibz/build C/C++ libraries used by Python extensions)z build-clib=�bz%directory to build C/C++ libraries to)z build-temp=�tz,directory to put temporary build by-products)�debug�gz"compile with debugging information)�force�fz2forcibly build everything (ignore file timestamps))z compiler=�czspecify the compiler typer r z
help-compilerNzlist available compilersc C s: d | _ d | _d | _d | _d | _d | _d | _d| _d | _d S )Nr ) r �
build_temp� libraries� include_dirs�define�undefr r �compiler��selfr r r
�initialize_options4 s z build_clib.initialize_optionsc C sh | � dddddd� | jj| _| jr0| �| j� | jd krH| jjpDg | _t| jt�rd| j�tj �| _d S )NZbuild)r r )r r )r r )r r )r r )
Zset_undefined_optionsZ distributionr �check_library_listr �
isinstance�str�split�os�pathsepr r r r
�finalize_optionsD s �
zbuild_clib.finalize_optionsc C s� | j s
d S ddlm} || j| j| jd�| _t| j� | jd k rN| j�| j� | j d k rv| j D ]\}}| j�
||� q^| j d k r�| j D ]}| j� |� q�| �
| j � d S )Nr )� new_compiler)r �dry_runr )r r r# r r$ r r r Zset_include_dirsr Z define_macror Zundefine_macro�build_libraries)r r# �name�valueZmacror r r
�run^ s" �
zbuild_clib.runc C s� t |t�std��|D ]z}t |t�s8t|�dkr8td��|\}}t |t�sRtd��d|ksntjdkr~tj|kr~td|d ��t |t�std��qd S )
a` Ensure that the list of libraries is valid.
`library` is presumably provided as a command option 'libraries'.
This method checks that it is a list of 2-tuples, where the tuples
are (library_name, build_info_dict).
Raise DistutilsSetupError if the structure is invalid anywhere;
just returns otherwise.
z+'libraries' option must be a list of tuples� z*each element of 'libraries' must a 2-tuplezNfirst element of each tuple in 'libraries' must be a string (the library name)�/z;bad library name '%s': may not contain directory separatorsr zMsecond element of each tuple in 'libraries' must be a dictionary (build info)N) r �list�DistutilsSetupError�tuple�lenr r �sep�dict)r r �libr& �
build_infor r r
r v s,
��
� �
�z build_clib.check_library_listc C s, | j s
d S g }| j D ]\}}|�|� q|S )N)r �append)r Z lib_names�lib_namer2 r r r
�get_library_names� s z build_clib.get_library_namesc C sZ | � | j� g }| jD ]>\}}|�d�}|d ks>t|ttf�sJtd| ��|�|� q|S )N�sources�fin 'libraries' option (library '%s'), 'sources' must be present and must be a list of source filenames)r r �getr r+ r- r, �extend)r � filenamesr4 r2 r6 r r r
�get_source_files� s
�� zbuild_clib.get_source_filesc C s� |D ]�\}}|� d�}|d ks,t|ttf�s8td| ��t|�}t�d|� |� d�}|� d�}| jj|| j ||| j
d�}| jj ||| j | j
d� qd S )Nr6 r7 zbuilding '%s' library�macrosr )�
output_dirr< r r )r= r )
r8 r r+ r- r, r �infor �compiler r Zcreate_static_libr )r r r4 r2 r6 r< r Zobjectsr r r
r% � s,
��
�
�zbuild_clib.build_libraries)�__name__�
__module__� __qualname__Z descriptionZ user_optionsZboolean_optionsr Z help_optionsr r" r( r r5 r; r% r r r r
r s( �
��$ r ) �__doc__r Zdistutils.corer Zdistutils.errorsZdistutils.sysconfigr Z distutilsr r r r r r r
�<module> s __pycache__/bdist.cpython-38.opt-2.pyc 0000644 00000006622 15051366006 0013461 0 ustar 00 U
e5d� � @ sD d dl Z d dlmZ d dlT d dlmZ dd� ZG dd� de�ZdS ) � N)�Command)�*)� get_platformc C sP ddl m} g }tjD ]"}|�d| d tj| d f� q| |�}|�d� d S )Nr )� FancyGetopt�formats=� z'List of available distribution formats:)Zdistutils.fancy_getoptr �bdist�format_commands�append�format_commandZ
print_help)r �formats�formatZpretty_printer� r �//usr/lib64/python3.8/distutils/command/bdist.py� show_formats s
�r c
@ s� e Zd ZdZdddde� fdddd d
gZd gZd d
defgZdZ ddd�Z
dddddddddg Z ddd d d d d d!d"d#� Z d$d%� Z
d&d'� Zd(d)� Zd
S )*r z$create a built (binary) distribution)z bdist-base=�bz4temporary directory for creating built distributionsz
plat-name=�pz;platform name to embed in generated filenames (default: %s))r Nz/formats for distribution (comma-separated list))z dist-dir=�dz=directory to put final built distributions in [default: dist])�
skip-buildNz2skip rebuilding everything (for testing/debugging))zowner=�uz@Owner name used when creating a tar file [default: current user])zgroup=�gzAGroup name used when creating a tar file [default: current group]r z help-formatsNz$lists available distribution formats)� bdist_rpm�gztar�zip)�posix�nt�rpm�bztar�xztar�ztar�tar�wininst�msi)r zRPM distribution)�
bdist_dumbzgzip'ed tar file)r# zbzip2'ed tar file)r# zxz'ed tar file)r# zcompressed tar file)r# ztar file)Z
bdist_wininstz Windows executable installer)r# zZIP file)Z bdist_msizMicrosoft Installer) r r r r r r r! r r" c C s. d | _ d | _d | _d | _d| _d | _d | _d S )Nr )�
bdist_base� plat_namer �dist_dir�
skip_build�group�owner)�selfr r r �initialize_optionsQ s zbdist.initialize_optionsc C s� | j d kr(| jrt� | _ n| �d�j | _ | jd krT| �d�j}tj�|d| j �| _| � d� | j
d kr�z| j tj g| _
W n" t
k
r� tdtj ��Y nX | jd kr�d| _d S )NZbuildzbdist.r z;don't know how to create built distributions on platform %sZdist)r% r' r Zget_finalized_commandr$ �
build_base�os�path�joinZensure_string_listr �default_format�name�KeyErrorZDistutilsPlatformErrorr& )r* r, r r r �finalize_optionsZ s*
�
��
zbdist.finalize_optionsc C s� g }| j D ]>}z|�| j| d � W q
tk
rF td| ��Y q
X q
tt| j ��D ]h}|| }| �|�}|| jkr�| j | |_ |dkr�| j
|_
| j |_ |||d d � kr�d|_ | �
|� qXd S )Nr zinvalid format '%s'r# r )r r
r r2 ZDistutilsOptionError�range�lenZreinitialize_command�no_format_optionr
r) r( Z keep_tempZ run_command)r* Zcommandsr
�iZcmd_nameZsub_cmdr r r �runv s"
z bdist.run)�__name__�
__module__� __qualname__Z descriptionr Z user_optionsZboolean_optionsr Z help_optionsr6 r0 r r r+ r3 r8 r r r r r sR ��� ��� ��
r )r- Zdistutils.corer Zdistutils.errorsZdistutils.utilr r r r r r r �<module> s
__pycache__/bdist_rpm.cpython-38.pyc 0000644 00000030216 15051366006 0013373 0 ustar 00 U
e5dIT � @ s� d Z ddlZddlZddlZddlmZ ddlmZ ddlm Z ddl
m Z ddl T ddl
mZ dd lmZ G d
d � d e�ZdS ) zwdistutils.command.bdist_rpm
Implements the Distutils 'bdist_rpm' command (create RPM source and binary
distributions).� N)�Command)�DEBUG)� get_platform)�
write_file)�*)�get_python_version)�logc ) @ s� e Zd ZdZdddddddd d
d d d
ddddddddddddddd d d d d d!d"d#d$d%d&d'd(d)d*g)Zd+d,d-d.d/gZd+d,d-d0�Zd1d2� Zd3d4� Zd5d6� Z d7d8� Z
d9d:� Z d;d<� Z d=d>� Z
d?S )@� bdist_rpmzcreate an RPM distribution)z bdist-base=Nz/base directory for creating built distributions)z rpm-base=Nzdbase directory for creating RPMs (defaults to "rpm" under --bdist-base; must be specified for RPM 2))z dist-dir=�dzDdirectory to put final RPM files in (and .spec files if --spec-only))zpython=NzMpath to Python interpreter to hard-code in the .spec file (default: "python"))z
fix-pythonNzLhard-code the exact path to the current Python interpreter in the .spec file)z spec-onlyNzonly regenerate spec file)z source-onlyNzonly generate source RPM)z binary-onlyNzonly generate binary RPM)z use-bzip2Nz7use bzip2 instead of gzip to create source distribution)zdistribution-name=Nzgname of the (Linux) distribution to which this RPM applies (*not* the name of the module distribution!))zgroup=Nz9package classification [default: "Development/Libraries"])zrelease=NzRPM release number)zserial=NzRPM serial number)zvendor=NzaRPM "vendor" (eg. "Joe Blow <joe@example.com>") [default: maintainer or author from setup script])z packager=NzBRPM packager (eg. "Jane Doe <jane@example.net>") [default: vendor])z
doc-files=Nz6list of documentation files (space or comma-separated))z
changelog=Nz
RPM changelog)zicon=Nzname of icon file)z provides=Nz%capabilities provided by this package)z requires=Nz%capabilities required by this package)z
conflicts=Nz-capabilities which conflict with this package)zbuild-requires=Nz+capabilities required to build this package)z
obsoletes=Nz*capabilities made obsolete by this package)�
no-autoreqNz+do not automatically calculate dependencies)� keep-temp�kz"don't clean up RPM build directory)� no-keep-tempNz&clean up RPM build directory [default])�use-rpm-opt-flagsNz8compile with RPM_OPT_FLAGS when building from source RPM)�no-rpm-opt-flagsNz&do not pass any RPM CFLAGS to compiler)� rpm3-modeNz"RPM 3 compatibility mode (default))� rpm2-modeNzRPM 2 compatibility mode)z prep-script=Nz3Specify a script for the PREP phase of RPM building)z
build-script=Nz4Specify a script for the BUILD phase of RPM building)z pre-install=Nz:Specify a script for the pre-INSTALL phase of RPM building)zinstall-script=Nz6Specify a script for the INSTALL phase of RPM building)z
post-install=Nz;Specify a script for the post-INSTALL phase of RPM building)zpre-uninstall=Nz<Specify a script for the pre-UNINSTALL phase of RPM building)zpost-uninstall=Nz=Specify a script for the post-UNINSTALL phase of RPM building)z
clean-script=Nz4Specify a script for the CLEAN phase of RPM building)zverify-script=Nz6Specify a script for the VERIFY phase of the RPM build)z force-arch=Nz0Force an architecture onto the RPM build process)�quiet�qz3Run the INSTALL phase of RPM building in quiet moder r r r r )r r r c C s� d | _ d | _d | _d | _d | _d | _d | _d | _d | _d | _ d | _
d | _ d | _ d | _
d | _d | _d | _d | _d | _d | _d | _d | _d | _d | _d | _d | _d | _d | _d | _ d | _ d | _ d | _ d | _ d| _!d| _"d| _#d| _$d | _%d| _&d S )Nr � )'�
bdist_base�rpm_base�dist_dir�python�
fix_python� spec_only� binary_only� source_only� use_bzip2�distribution_name�group�release�serial�vendor�packager� doc_files� changelog�icon� prep_script� build_script�install_script� clean_script�
verify_script� pre_install� post_install�
pre_uninstall�post_uninstall�prep�provides�requires� conflicts�build_requires� obsoletes� keep_temp�use_rpm_opt_flags� rpm3_mode�
no_autoreq�
force_archr ��self� r> �3/usr/lib64/python3.8/distutils/command/bdist_rpm.py�initialize_options� sN z bdist_rpm.initialize_optionsc C s� | � dd� | jd kr6| js$td��tj�| jd�| _| jd krX| j rPt
j | _qfd| _n| j rftd��tj dkr~t
dtj ��| jr�| jr�td ��| j�� s�d
| _| � dd � | �� d S ) NZbdist)r r z)you must specify --rpm-base in RPM 2 mode�rpmZpython3z8--python and --fix-python are mutually exclusive options�posixz9don't know how to create RPM distributions on platform %sz6cannot supply both '--source-only' and '--binary-only'r )r r )Zset_undefined_optionsr r9 ZDistutilsOptionError�os�path�joinr r r �sys�
executable�nameZDistutilsPlatformErrorr r � distribution�has_ext_modulesr8 �finalize_package_datar< r> r> r? �finalize_options� s6
�
�
� �
zbdist_rpm.finalize_optionsc C sT | � dd� | � dd| j�� | j�� f � | � d� | �d� t| jt�rxdD ]&}tj �
|�rP|| jkrP| j� |� qP| � dd � | � d
� | � d � | � d � | � | j
�| _
| �d
� | �d� | �d� | �d� | �d� | �d� | �d� | �d� | �d� | �d� | �d� | �d� | �d� | �d� | �d� | � d � d S ) Nr zDevelopment/Librariesr# z%s <%s>r$ r% )ZREADMEz
README.txtr! �1r" r r& r' r( r) r* r+ r, r- r. r/ r0 r2 r3 r4 r5 r6 r; )Z
ensure_stringrI Z get_contactZget_contact_emailZensure_string_list�
isinstancer% �listrC rD �exists�append�_format_changelogr& Zensure_filename)r= Zreadmer> r> r? rK � sB
��
z bdist_rpm.finalize_package_datac C s� t r<td� td| j� td| j� td| j� td| j� | jrT| j}| �|� n8i }dD ]&}t j
� | j |�||< | �|| � q\|d }t j
� |d| j
�� �}| �t|| �� fd | � | jr�d S | j
jd d � }| �d
�}| jr�d g|_nd g|_| �d
� || j
_|�� d
}|d }| �||� | j�rbt j
�| j��rT| �| j|� ntd| j ��t � d� dg} | j �r�| � d� n | j �r�| � d� n
| � d� | �!dd| j" g� | j#�r�| �!ddt j
�$| j � g� | j%�s�| � d� | j&�r | � d� | � |� d}
|
d } d |
d } d | | |f }
t �'|
�}z~g }d }|�)� }|�sV�q�|�*� �+� }t,|�d k�stt-�|� |d � |d k�rD|d
}�qD|�(� }|�r�t.d!t/|
� ��W 5 |�(� X | �0| � | j1�s�| j
�2� �r�t3� }nd"}| j �sLt j
� |d# |�}t j
�|��st-�| �4|| j� t j
� | j|�}| j
j� d$||f� | j �s�|D ]`}t j
� |d% |�}t j
�|��rX| �4|| j� t j
� | jt j
�5|��}| j
j� d$||f� �qXd S )&Nzbefore _get_package_data():zvendor =z
packager =z doc_files =z changelog =)�SOURCES�SPECSZBUILD�RPMS�SRPMSrT z%s.specz writing '%s'�sdistZbztarZgztarr rS z icon file '%s' does not existz
building RPMsZrpmbuildz-bsz-bbz-baz--definez __python %sz
_topdir %sz--cleanz--quietz %{name}-%{version}-%{release}z.src.rpmz%{arch}/z .%{arch}.rpmz%rpm -q --qf '%s %s\n' --specfile '%s'� r zFailed to execute: %s�anyrV r rU )6r �printr# r$ r% r& r r ZmkpathrC rD rE r rI �get_nameZexecuter �_make_spec_fileZ
dist_filesZreinitialize_commandr ZformatsZ run_commandZget_archive_filesZ copy_filer' rP ZDistutilsFileErrorr �infor rQ r �extendr r9 �abspathr7 r �popen�close�readline�strip�split�len�AssertionErrorZDistutilsExecError�reprZspawnZdry_runrJ r Z move_file�basename)r= Zspec_dirZrpm_dirr
Z spec_pathZsaved_dist_filesrW �sourceZ
source_dirZrpm_cmdZ
nvr_stringZsrc_rpmZ non_src_rpmZq_cmd�outZ binary_rpmsZ
source_rpm�line�lZstatusZ pyversionZsrpm�filenamerA r> r> r? �run s� ���
�
�
�
�
��z
bdist_rpm.runc C s t j�| jt j�|��S )N)rC rD rE r rh )r= rD r> r> r? �
_dist_path� s zbdist_rpm._dist_pathc
C sJ d| j �� d| j �� �dd� d| j �� d| j�dd� dd| j �� g}t�d �}d
�d d � |� � D ��}d
}d}|�||�}||kr�|�
d� |�
d| d
� |� dddg� | j r�|�
d� n
|�
d� |� d| j �
� d| j ddg� | j�s| j �� �s&|�
d� n|�
d| j � d D ]V}t| |�� �}t|t��rb|�
d |d �|�f � n |d k �r*|�
d ||f � �q*| j �� d k�r�|�
d!| j �� � | j�r�|�
d"| j � | j�r�|�
d#d �| j� � | j�r�|�
d$tj�| j� � | j �r|�
d%� |� dd&| j � � g� d'| j tj�t j d( �f }d)| } | j!�rXd*| } d+| }
d,d-d.| fd/d0|
fd1d2d3d4d5d6g } | D ]n\} }
}t| |
�}|�s�|�r�|� dd7| g� |�r�t"|��}|� |�#� �$d
�� W 5 Q R X n
|�
|� �q�|� dd8d9g� | j%�r$|�
d:d �| j%� � | j&�rF|� dd;g� |� | j&� |S )<ziGenerate the text of an RPM spec file and return it as a
list of strings (one per line).
z
%define name z%define version �-�_z%define unmangled_version z%define release � z Summary: z rpm --eval %{__os_install_post}�
c S s g | ]}d |� � �qS )z %s \)rc )�.0rk r> r> r? �
<listcomp>� s �z-bdist_rpm._make_spec_file.<locals>.<listcomp>zbrp-python-bytecompile \
z%brp-python-bytecompile %{__python} \
z2# Workaround for http://bugs.python.org/issue14443z%define __os_install_post z
Name: %{name}zVersion: %{version}zRelease: %{release}z-Source0: %{name}-%{unmangled_version}.tar.bz2z,Source0: %{name}-%{unmangled_version}.tar.gzz License: zGroup: z>BuildRoot: %{_tmppath}/%{name}-%{version}-%{release}-buildrootzPrefix: %{_prefix}zBuildArch: noarchz
BuildArch: %s)ZVendorZPackagerZProvidesZRequiresZ ConflictsZ Obsoletesz%s: %s� NZUNKNOWNzUrl: zDistribution: zBuildRequires: zIcon: z
AutoReq: 0z %descriptionz%s %sr z%s buildz env CFLAGS="$RPM_OPT_FLAGS" z>%s install -O1 --root=$RPM_BUILD_ROOT --record=INSTALLED_FILES)r1 r( z&%setup -n %{name}-%{unmangled_version}Zbuildr) Zinstallr* )Zcleanr+ zrm -rf $RPM_BUILD_ROOT)Z verifyscriptr, N)Zprer- N)Zpostr. N)Zpreunr/ N)Zpostunr0 N�%z%files -f INSTALLED_FILESz%defattr(-,root,root)z%doc z
%changelog)'rI r[ Z get_version�replacer! Zget_description�
subprocessZ getoutputrE �
splitlinesrQ r^ r Z get_licenser r; rJ �getattr�lowerrN rO Zget_urlr r5 r' rC rD rh r: Zget_long_descriptionr rF �argvr8 �open�readrd r% r& )r= Z spec_fileZ vendor_hookZproblemZfixedZ
fixed_hookZfield�valZdef_setup_callZ def_buildZ install_cmdZscript_optionsZrpm_opt�attr�default�fr> r> r? r\ � s� �
�
�
�
�
� ��
�
�� zbdist_rpm._make_spec_filec C s| |s|S g }|� � �d�D ]N}|� � }|d dkrB|�d|g� q|d dkrZ|�|� q|�d| � q|d sx|d= |S )zKFormat the changelog correctly and convert it to a list of strings
rs r r rr rp z )rc rd r^ rQ )r= r& Z
new_changelogrk r> r> r? rR 1 s zbdist_rpm._format_changelogN)�__name__�
__module__� __qualname__Z descriptionZ user_optionsZboolean_optionsZ negative_optr@ rL rK rn ro r\ rR r> r> r> r? r sx �m ��- - *r )�__doc__ry rF rC Zdistutils.corer Zdistutils.debugr Zdistutils.utilr Zdistutils.file_utilr Zdistutils.errorsZdistutils.sysconfigr Z distutilsr r r> r> r> r? �<module> s __pycache__/build.cpython-38.pyc 0000644 00000007453 15051366006 0012516 0 ustar 00 U
e5d� � @ sT d Z ddlZddlZddlmZ ddlmZ ddlmZ dd� Z G dd � d e�Z
dS )
zBdistutils.command.build
Implements the Distutils 'build' command.� N)�Command)�DistutilsOptionError)� get_platformc C s ddl m} | � d S )Nr ��show_compilers)Zdistutils.ccompilerr r � r �//usr/lib64/python3.8/distutils/command/build.pyr s r c @ s� e Zd ZdZdddddddd d
e� fd d d
ddg ZddgZdddefgZdd� Z dd� Z
dd� Z dd � Z d d � Z
d d � Zd!d"� Zd#e fd$e
fd%efd&efgZdS )'�buildz"build everything needed to install)z build-base=�bz base directory for build library)zbuild-purelib=Nz2build directory for platform-neutral distributions)zbuild-platlib=Nz3build directory for platform-specific distributions)z
build-lib=NzWbuild directory for all distribution (defaults to either build-purelib or build-platlib)zbuild-scripts=Nzbuild directory for scripts)z build-temp=�tztemporary build directoryz
plat-name=�pz6platform name to build for, if supported (default: %s))z compiler=�czspecify the compiler type)z parallel=�jz number of parallel build jobs)�debug�gz;compile extensions and libraries with debugging information)�force�fz2forcibly build everything (ignore file timestamps))z executable=�ez5specify final destination interpreter path (build.py)r r z
help-compilerNzlist available compilersc C sL d| _ d | _d | _d | _d | _d | _d | _d | _d | _d| _ d | _
d | _ d S )Nr r ) �
build_base�
build_purelib�
build_platlib� build_lib�
build_temp�
build_scriptsZcompiler� plat_namer r �
executable�parallel��selfr r r �initialize_options8 s zbuild.initialize_optionsc C sb | j d krt� | _ ntjdkr&td��d| j ftjd d� � }ttd�rR|d7 }| jd krntj �
| j d�| _| j d kr�tj �
| j d| �| _ | j
d kr�| jjr�| j | _
n| j| _
| jd kr�tj �
| j d| �| _| jd kr�tj �
| j d tjd d� �| _| jd k�r tj�r tj �tj�| _t| jt��r^zt| j�| _W n tk
�r\ td
��Y nX d S ) N�ntzW--plat-name only supported on Windows (try using './configure --help' on your platform)z .%s-%d.%d� Zgettotalrefcountz-pydebug�libZtempz
scripts-%d.%dz parallel should be an integer)r r �os�namer �sys� version_info�hasattrr �path�joinr r r � distributionZ ext_modulesr r r �normpath�
isinstancer �str�int�
ValueError)r Zplat_specifierr r r �finalize_optionsH sD
�
�
�
�zbuild.finalize_optionsc C s | � � D ]}| �|� qd S �N)Zget_sub_commandsZ run_command)r Zcmd_namer r r �run� s z build.runc C s
| j �� S r1 )r* �has_pure_modulesr r r r r3 � s zbuild.has_pure_modulesc C s
| j �� S r1 )r* �has_c_librariesr r r r r4 � s zbuild.has_c_librariesc C s
| j �� S r1 )r* �has_ext_modulesr r r r r5 � s zbuild.has_ext_modulesc C s
| j �� S r1 )r* � has_scriptsr r r r r6 � s zbuild.has_scriptsZbuild_pyZ
build_clibZ build_extr )�__name__�
__module__� __qualname__Z descriptionr Z user_optionsZboolean_optionsr Z help_optionsr r0 r2 r3 r4 r5 r6 Z sub_commandsr r r r r sH ��� ��8 �r ) �__doc__r% r# Zdistutils.corer Zdistutils.errorsr Zdistutils.utilr r r r r r r �<module> s __pycache__/build_scripts.cpython-38.opt-2.pyc 0000644 00000007534 15051366006 0015225 0 ustar 00 U
e5dX � @ s� d dl Z d dlZd dlmZ d dlmZ d dlmZ d dlm Z d dl
m Z m Z d dlm
Z
d dlZe�d�ZG d d
� d
e�ZG d d � d ee �ZdS )
� N)�ST_MODE)� sysconfig)�Command)�newer)� convert_path� Mixin2to3)�logs ^#!.*python[0-9.]*([ ].*)?$c @ sH e Zd ZdZdddgZdgZdd� Zdd � Zd
d � Zd d
� Z dd� Z
dS )�
build_scriptsz("build" scripts (copy and fixup #! line))z
build-dir=�dz directory to "build" (copy) to)�force�fz1forcibly build everything (ignore file timestamps)z executable=�ez*specify final destination interpreter pathr c C s" d | _ d | _d | _d | _d | _d S �N)� build_dir�scriptsr �
executable�outfiles��self� r �7/usr/lib64/python3.8/distutils/command/build_scripts.py�initialize_options s
z build_scripts.initialize_optionsc C s | � dddd� | jj| _d S )NZbuild)r r )r r )r r )Zset_undefined_optionsZ distributionr r r r r �finalize_options% s �z build_scripts.finalize_optionsc C s | j S r )r r r r r �get_source_files, s z build_scripts.get_source_filesc C s | j s
d S | �� d S r )r � copy_scriptsr r r r �run/ s zbuild_scripts.runc
C s� | � | j� g }g }| jD �] }d}t|�}tj�| jtj�|��}|�|� | j slt
||�slt � d|� qzt
|d�}W n tk
r� | js�� d }Y nXX t�|j�\}}|�d� |�� } | s�| �d| � qt�| �}
|
r�d}|
�d�p�d} |�rt �d || j� |�|� | j�stj�s*| j} n(tj�t� d
�d t� d �t� d
�f �} t� | �} d| | d }
z|
� d� W n$ t k
�r� t d�!|
���Y nX z|
� |� W n& t k
�r� t d�!|
|���Y nX t
|d�� }|�"|
� |�#|�$� � W 5 Q R X |�r8|�%� q|�r"|�%� |�|� | �&||� qtj'dk�r�|D ]`}| j�rdt �d|� nDt�(|�t) d@ }|dB d@ }||k�rJt �d|||� t�*||� �qJ||fS )NFznot copying %s (up-to-date)�rbr z %s is an empty file (skipping)T� � z copying and adjusting %s -> %sZBINDIRz
python%s%sZVERSIONZEXEs #!�
zutf-8z.The shebang ({!r}) is not decodable from utf-8zAThe shebang ({!r}) is not decodable from the script encoding ({})�wb�posixzchanging mode of %si� im z!changing mode of %s from %o to %o)+Zmkpathr r r �os�path�join�basename�appendr r r �debug�open�OSError�dry_run�tokenize�detect_encoding�readline�seek�warn�
first_line_re�match�group�infor Z python_buildr Zget_config_var�fsencode�decode�UnicodeDecodeError�
ValueError�format�write�
writelines� readlines�closeZ copy_file�name�statr �chmod)r r �
updated_filesZscriptZadjustZoutfiler �encoding�linesZ
first_liner1 Z post_interpr ZshebangZoutf�fileZoldmodeZnewmoder r r r 5 s�
�
��
��
��
�zbuild_scripts.copy_scriptsN) �__name__�
__module__� __qualname__Z descriptionZ user_optionsZboolean_optionsr r r r r r r r r r s �r c @ s e Zd Zdd� ZdS )�build_scripts_2to3c C s& t �| �\}}| js | �|� ||fS r )r r r* Zrun_2to3)r r r@ r r r r � s
z build_scripts_2to3.copy_scriptsN)rD rE rF r r r r r rG � s rG )r" �rer> r Z distutilsr Zdistutils.corer Zdistutils.dep_utilr Zdistutils.utilr r r r+ �compiler0 r rG r r r r �<module> s
__pycache__/build_clib.cpython-38.opt-1.pyc 0000644 00000011320 15051366006 0014432 0 ustar 00 U
e5dV � @ sT d Z ddlZddlmZ ddlT ddlmZ ddlmZ dd� Z G d d
� d
e�Z
dS ) z�distutils.command.build_clib
Implements the Distutils 'build_clib' command, to build a C/C++ library
that is included in the module distribution and needed by an extension
module.� N)�Command)�*)�customize_compiler)�logc C s ddl m} | � d S )Nr ��show_compilers)�distutils.ccompilerr r � r �4/usr/lib64/python3.8/distutils/command/build_clib.pyr s r c @ sl e Zd ZdZdddddgZddgZd d
d efgZd d
� Zdd� Z dd� Z
dd� Z dd� Z dd� Z
dd� Zd
S )�
build_clibz/build C/C++ libraries used by Python extensions)z build-clib=�bz%directory to build C/C++ libraries to)z build-temp=�tz,directory to put temporary build by-products)�debug�gz"compile with debugging information)�force�fz2forcibly build everything (ignore file timestamps))z compiler=�czspecify the compiler typer r z
help-compilerNzlist available compilersc C s: d | _ d | _d | _d | _d | _d | _d | _d| _d | _d S )Nr ) r �
build_temp� libraries� include_dirs�define�undefr r �compiler��selfr r r
�initialize_options4 s z build_clib.initialize_optionsc C sh | � dddddd� | jj| _| jr0| �| j� | jd krH| jjpDg | _t| jt�rd| j�tj �| _d S )NZbuild)r r )r r )r r )r r )r r )
Zset_undefined_optionsZ distributionr �check_library_listr �
isinstance�str�split�os�pathsepr r r r
�finalize_optionsD s �
zbuild_clib.finalize_optionsc C s� | j s
d S ddlm} || j| j| jd�| _t| j� | jd k rN| j�| j� | j d k rv| j D ]\}}| j�
||� q^| j d k r�| j D ]}| j� |� q�| �
| j � d S )Nr )� new_compiler)r �dry_runr )r r r# r r$ r r r Zset_include_dirsr Z define_macror Zundefine_macro�build_libraries)r r# �name�valueZmacror r r
�run^ s" �
zbuild_clib.runc C s� t |t�std��|D ]z}t |t�s8t|�dkr8td��|\}}t |t�sRtd��d|ksntjdkr~tj|kr~td|d ��t |t�std��qd S )
a` Ensure that the list of libraries is valid.
`library` is presumably provided as a command option 'libraries'.
This method checks that it is a list of 2-tuples, where the tuples
are (library_name, build_info_dict).
Raise DistutilsSetupError if the structure is invalid anywhere;
just returns otherwise.
z+'libraries' option must be a list of tuples� z*each element of 'libraries' must a 2-tuplezNfirst element of each tuple in 'libraries' must be a string (the library name)�/z;bad library name '%s': may not contain directory separatorsr zMsecond element of each tuple in 'libraries' must be a dictionary (build info)N) r �list�DistutilsSetupError�tuple�lenr r �sep�dict)r r �libr& �
build_infor r r
r v s,
��
� �
�z build_clib.check_library_listc C s, | j s
d S g }| j D ]\}}|�|� q|S )N)r �append)r Z lib_names�lib_namer2 r r r
�get_library_names� s z build_clib.get_library_namesc C sZ | � | j� g }| jD ]>\}}|�d�}|d ks>t|ttf�sJtd| ��|�|� q|S )N�sources�fin 'libraries' option (library '%s'), 'sources' must be present and must be a list of source filenames)r r �getr r+ r- r, �extend)r � filenamesr4 r2 r6 r r r
�get_source_files� s
�� zbuild_clib.get_source_filesc C s� |D ]�\}}|� d�}|d ks,t|ttf�s8td| ��t|�}t�d|� |� d�}|� d�}| jj|| j ||| j
d�}| jj ||| j | j
d� qd S )Nr6 r7 zbuilding '%s' library�macrosr )�
output_dirr< r r )r= r )
r8 r r+ r- r, r �infor �compiler r Zcreate_static_libr )r r r4 r2 r6 r< r Zobjectsr r r
r% � s,
��
�
�zbuild_clib.build_libraries)�__name__�
__module__� __qualname__Z descriptionZ user_optionsZboolean_optionsr Z help_optionsr r" r( r r5 r; r% r r r r
r s( �
��$ r ) �__doc__r Zdistutils.corer Zdistutils.errorsZdistutils.sysconfigr Z distutilsr r r r r r r
�<module> s __pycache__/upload.cpython-38.opt-1.pyc 0000644 00000012100 15051366006 0013623 0 ustar 00 U
&�.e� � @ s� d Z ddlZddlZddlZddlZddlmZ ddlmZm Z m
Z
ddl m Z ddl
mZmZ ddlmZ ddlmZ dd lmZ G d
d � d e�ZdS ) zm
distutils.command.upload
Implements the Distutils 'upload' subcommand (upload package to a package
index).
� N)�standard_b64encode)�urlopen�Request� HTTPError)�urlparse)�DistutilsError�DistutilsOptionError)�
PyPIRCCommand)�spawn)�logc @ sJ e Zd ZdZejddg Zejdg Zdd� Zdd� Zd d
� Z d d � Z
d
S )�uploadz upload binary package to PyPI)�sign�sz sign files to upload using gpg)z identity=�iz GPG identity used to sign filesr
c C s, t �| � d| _d| _d| _d| _d | _d S )N� r F)r �initialize_options�username�password�
show_responser
�identity)�self� r �0/usr/lib64/python3.8/distutils/command/upload.pyr s
zupload.initialize_optionsc C sr t �| � | jr | js td��| �� }|i krV|d | _|d | _|d | _|d | _ | jsn| j
jrn| j
j| _d S )Nz.Must use --sign for --identity to have meaningr r �
repository�realm) r �finalize_optionsr r
r Z _read_pypircr r r r � distribution)r Zconfigr r r r ( s
�
zupload.finalize_optionsc C s: | j jsd}t|��| j jD ]\}}}| �|||� q d S )NzHMust create and upload files in one command (e.g. setup.py sdist upload))r Z
dist_filesr � upload_file)r �msg�command� pyversion�filenamer r r �run: s
z
upload.runc " C s t | j�\}}}}}} |s"|s"| r0td| j ��|dkrDtd| ��| jr|ddd|g}
| jrnd| jg|
dd�< t|
| jd � t|d
�} z | � � } W 5 | �� X | j
j }
d d |
� � |
�
� tj�|�| f||t�| ��� d
|
�� |
�� |
�� |
�� |
�� |
�� |
�� |
�� |
� � |
� � |
� � |
� � |
� � d�}zt�!| ��� }W nP t"k
�r� } z0d| }| �#|t$j%� ddl&m'} |� �s|� W 5 d }~X Y n
X ||d< d|d< | j�r�t|d d
��"} tj�|�d | � � f|d< W 5 Q R X | j(d | j) �*d�}dt+|��,d� }d}d|�*d� }|d }t-�.� }|�/� D ]�\}}d | }t0|t1��sP|g}|D ]j}t2|�t3k�r�|d |d 7 }|d }nt4|��*d �}|�5|� |�5|�*d �� |�5d!� |�5|� �qT�q.|�5|� |�6� }d"|| jf }| �#|t$j%� d#| t4t7|��|d$�} t8| j|| d%�} zt9| �} | �:� } | j;} W nf t<k
�rd } z|j=} |j;} W 5 d }~X Y n8 t>k
�r� } z| �#t4|�t$j?� � W 5 d }~X Y nX | d&k�r�| �#d'| | f t$j%� | j@�r| �A| �}!d(�Bd)|!d)f�}| �#|t$j%� n"d*| | f }| �#|t$j?� tC|��d S )+NzIncompatible url %s)ZhttpZhttpszunsupported schema Zgpgz
--detach-signz-az --local-user� )�dry_run�rbZ file_upload�1z1.0)z:actionZprotocol_version�name�version�contentZfiletyper Z
sha256_digestZmetadata_versionZsummaryZ home_pageZauthorZ author_email�license� description�keywords�platformZ classifiersZ download_urlZprovidesZrequiresZ obsoletesz#calculating md5 checksum failed: %sr )�
get_fips_modeZ
md5_digestr Zcommentz.ascZ
gpg_signature�:�asciizBasic z3--------------GHSKFJDLGDS7543FJKLFHRE75642756743254s
--s --
z+
Content-Disposition: form-data; name="%s"z; filename="%s"� zutf-8s
zSubmitting %s to %sz multipart/form-data; boundary=%s)z Content-typezContent-lengthZ
Authorization)�data�headers�� zServer response (%s): %s�
zK---------------------------------------------------------------------------zUpload failed (%s): %s)Dr r �AssertionErrorr
r r
r$ �open�close�readr ZmetadataZget_nameZ get_version�os�path�basename�hashlibZsha256Z hexdigestZget_descriptionZget_urlZ get_contactZget_contact_emailZ get_licenceZget_long_descriptionZ get_keywordsZ
get_platformsZget_classifiersZget_download_urlZ get_providesZ get_requiresZ
get_obsoletesZmd5�
ValueErrorZannouncer �INFOZ_hashlibr. r r �encoder �decode�io�BytesIO�items�
isinstance�list�type�tuple�str�write�getvalue�lenr r Zgetcoder r �code�OSErrorZERRORr Z_read_pypi_response�joinr )"r r r r! ZschemaZnetlocZurlZparamsZqueryZ fragmentsZgpg_args�fr) �metar2 Zdigest�er r. Z user_passZauth�boundaryZ sep_boundaryZ end_boundaryZbody�key�value�titler3 Zrequest�resultZstatus�reason�textr r r r B s� � �
�! �
��
�
zupload.upload_fileN) �__name__�
__module__� __qualname__r+ r Z user_optionsZboolean_optionsr r r" r r r r r r s � r )�__doc__r: rB r- r= �base64r Zurllib.requestr r r Z urllib.parser Zdistutils.errorsr r Zdistutils.corer Zdistutils.spawnr
Z distutilsr r r r r r �<module> s __pycache__/clean.cpython-38.opt-2.pyc 0000644 00000003743 15051366006 0013437 0 ustar 00 U
e5d�
� @ s@ d dl Z d dlmZ d dlmZ d dlmZ G dd� de�ZdS )� N)�Command)� remove_tree)�logc @ s> e Zd ZdZddddddgZdgZd d
� Zd d � Zd
d� ZdS )�cleanz-clean up temporary files from 'build' command)z build-base=�bz2base build directory (default: 'build.build-base'))z
build-lib=Nz<build directory for all modules (default: 'build.build-lib'))z build-temp=�tz7temporary build directory (default: 'build.build-temp'))zbuild-scripts=Nz<build directory for scripts (default: 'build.build-scripts'))z bdist-base=Nz+temporary directory for built distributions)�all�az7remove all build output, not just temporary by-productsr c C s( d | _ d | _d | _d | _d | _d | _d S )N)�
build_base� build_lib�
build_temp�
build_scripts�
bdist_baser ��self� r �//usr/lib64/python3.8/distutils/command/clean.py�initialize_options s zclean.initialize_optionsc C s" | � ddddd� | � dd� d S )NZbuild)r
r
)r r )r
r
)r r Zbdist)r r )Zset_undefined_optionsr r r r �finalize_options( s ��zclean.finalize_optionsc C s� t j�| j�r t| j| jd� nt�d| j� | jrr| j | j
| j fD ],}t j�|�rdt|| jd� qDt� d|� qD| js�z t �
| j� t�d| j� W n tk
r� Y nX d S )N)�dry_runz%'%s' does not exist -- can't clean itz
removing '%s')�os�path�existsr r r r �debugr r r r
�warn�rmdirr
�info�OSError)r Z directoryr r r �run1 s* �� � z clean.runN) �__name__�
__module__� __qualname__Z descriptionZ user_optionsZboolean_optionsr r r r r r r r s � r )r Zdistutils.corer Zdistutils.dir_utilr Z distutilsr r r r r r �<module> s __pycache__/install_scripts.cpython-38.pyc 0000644 00000004137 15051366006 0014630 0 ustar 00 U
e5d� � @ sD d Z ddlZddlmZ ddlmZ ddlmZ G dd� de�ZdS )zudistutils.command.install_scripts
Implements the Distutils 'install_scripts' command, for installing
Python scripts.� N)�Command)�log)�ST_MODEc @ sL e Zd ZdZddddgZddgZdd � Zd
d � Zd d
� Zdd� Z dd� Z
dS )�install_scriptsz%install scripts (Python or otherwise))z install-dir=�dz directory to install scripts to)z
build-dir=�bz'build directory (where to install from))�force�fz-force installation (overwrite existing files))�
skip-buildNzskip the build stepsr r
c C s d | _ d| _d | _d | _d S )Nr )� install_dirr � build_dir�
skip_build��self� r �9/usr/lib64/python3.8/distutils/command/install_scripts.py�initialize_options s z"install_scripts.initialize_optionsc C s | � dd� | � dddd� d S )NZbuild)�
build_scriptsr Zinstall)r r )r r )r
r
)Zset_undefined_optionsr r r r �finalize_options! s �z install_scripts.finalize_optionsc C s� | j s| �d� | �| j| j�| _tjdkr~| �� D ]H}| j rLt
� d|� q4t� |�t
dB d@ }t
� d||� t�||� q4d S )Nr �posixzchanging mode of %sim i� zchanging mode of %s to %o)r
Z run_commandZ copy_treer r �outfiles�os�name� get_outputsZdry_runr �info�statr �chmod)r �file�moder r r �run) s
zinstall_scripts.runc C s | j jp
g S �N)Z distributionZscriptsr r r r �
get_inputs8 s zinstall_scripts.get_inputsc C s
| j pg S r )r r r r r r ; s zinstall_scripts.get_outputsN) �__name__�
__module__� __qualname__Z descriptionZ user_optionsZboolean_optionsr r r r! r r r r r r s �r ) �__doc__r Zdistutils.corer Z distutilsr r r r r r r r �<module> s
__pycache__/bdist.cpython-38.opt-1.pyc 0000644 00000007124 15051366006 0013456 0 ustar 00 U
e5d� � @ sH d Z ddlZddlmZ ddlT ddlmZ dd� ZG dd � d e�ZdS )
zidistutils.command.bdist
Implements the Distutils 'bdist' command (create a built [binary]
distribution).� N)�Command)�*)� get_platformc C sP ddl m} g }tjD ]"}|�d| dtj| d f� q| |�}|�d� dS )zFPrint list of available formats (arguments to "--format" option).
r )� FancyGetopt�formats=N� z'List of available distribution formats:)Zdistutils.fancy_getoptr �bdist�format_commands�append�format_commandZ
print_help)r �formats�formatZpretty_printer� r �//usr/lib64/python3.8/distutils/command/bdist.py� show_formats s
�r c
@ s� e Zd ZdZdddde� fdddd d
gZd gZd d
defgZdZ ddd�Z
dddddddddg Z ddd d d d d d!d"d#� Z d$d%� Z
d&d'� Zd(d)� Zd
S )*r z$create a built (binary) distribution)z bdist-base=�bz4temporary directory for creating built distributionsz
plat-name=�pz;platform name to embed in generated filenames (default: %s))r Nz/formats for distribution (comma-separated list))z dist-dir=�dz=directory to put final built distributions in [default: dist])�
skip-buildNz2skip rebuilding everything (for testing/debugging))zowner=�uz@Owner name used when creating a tar file [default: current user])zgroup=�gzAGroup name used when creating a tar file [default: current group]r z help-formatsNz$lists available distribution formats)� bdist_rpm�gztar�zip)�posix�nt�rpm�bztar�xztar�ztar�tar�wininst�msi)r zRPM distribution)�
bdist_dumbzgzip'ed tar file)r# zbzip2'ed tar file)r# zxz'ed tar file)r# zcompressed tar file)r# ztar file)Z
bdist_wininstz Windows executable installer)r# zZIP file)Z bdist_msizMicrosoft Installer) r r r r r r r! r r" c C s. d | _ d | _d | _d | _d| _d | _d | _d S )Nr )�
bdist_base� plat_namer �dist_dir�
skip_build�group�owner)�selfr r r �initialize_optionsQ s zbdist.initialize_optionsc C s� | j d kr(| jrt� | _ n| �d�j | _ | jd krT| �d�j}tj�|d| j �| _| � d� | j
d kr�z| j tj g| _
W n" t
k
r� tdtj ��Y nX | jd kr�d| _d S )NZbuildzbdist.r z;don't know how to create built distributions on platform %sZdist)r% r' r Zget_finalized_commandr$ �
build_base�os�path�joinZensure_string_listr �default_format�name�KeyErrorZDistutilsPlatformErrorr& )r* r, r r r �finalize_optionsZ s*
�
��
zbdist.finalize_optionsc C s� g }| j D ]>}z|�| j| d � W q
tk
rF td| ��Y q
X q
tt| j ��D ]h}|| }| �|�}|| jkr�| j | |_ |dkr�| j
|_
| j |_ |||d d � kr�d|_ | �
|� qXd S )Nr zinvalid format '%s'r# r )r r
r r2 ZDistutilsOptionError�range�lenZreinitialize_command�no_format_optionr
r) r( Z keep_tempZ run_command)r* Zcommandsr
�iZcmd_nameZsub_cmdr r r �runv s"
z bdist.run)�__name__�
__module__� __qualname__Z descriptionr Z user_optionsZboolean_optionsr Z help_optionsr6 r0 r r r+ r3 r8 r r r r r sR ��� ��� ��
r ) �__doc__r- Zdistutils.corer Zdistutils.errorsZdistutils.utilr r r r r r r �<module> s __pycache__/build_py.cpython-38.pyc 0000644 00000024362 15051366006 0013224 0 ustar 00 U
e5d&C � @ sz d Z ddlZddlZddlZddlZddlmZ ddlT ddl m
Z
m Z ddl m
Z
G dd� de�ZG d d
� d
ee �ZdS ) zHdistutils.command.build_py
Implements the Distutils 'build_py' command.� N)�Command)�*)� convert_path� Mixin2to3)�logc @ s� e Zd ZdZdddddgZddgZd diZd
d � Zd d
� Zdd� Z dd� Z
dd� Z dd� Z dd� Z
dd� Zdd� Zd d � Zd d � Zd d!� Zd"d#� Zd$d%� Zd2d'd(�Zd)d*� Zd+d,� Zd-d.� Zd/d0� Zd1S )3�build_pyz5"build" pure Python modules (copy to build directory))z
build-lib=�dz directory to "build" (copy) to)�compile�czcompile .py to .pyc)�
no-compileNz!don't compile .py files [default])z optimize=�Ozlalso compile with optimization: -O1 for "python -O", -O2 for "python -OO", and -O0 to disable [default: -O0])�force�fz2forcibly build everything (ignore file timestamps)r r
r c C s4 d | _ d | _d | _d | _d | _d| _d| _d | _d S )Nr )� build_lib�
py_modules�package� package_data� package_dirr �optimizer
��self� r �2/usr/lib64/python3.8/distutils/command/build_py.py�initialize_options s zbuild_py.initialize_optionsc C s� | � ddd� | jj| _| jj| _| jj| _i | _| jjr^| jj�� D ]\}}t|�| j|< qF| �� | _ t
| j t �s�z,t | j �| _ d| j kr�dks�n t
�W n tt
fk
r� td��Y nX d S )NZbuild)r r )r
r
r � zoptimize must be 0, 1, or 2)Zset_undefined_options� distribution�packagesr r r �itemsr �get_data_files�
data_files�
isinstancer �int�AssertionError�
ValueErrorZDistutilsOptionError)r �name�pathr r r �finalize_options* s$ �
zbuild_py.finalize_optionsc C s: | j r| �� | jr$| �� | �� | �| jdd�� d S �Nr )�include_bytecode)r �
build_modulesr �build_packages�build_package_data� byte_compile� get_outputsr r r r �runC s z build_py.runc s� g }| j s|S | j D ]h}| �|�}tjj| jg|�d� � }d� |rPt|�d � � fdd�| �||�D �}|� ||||f� q|S )z?Generate list of '(package,src_dir,build_dir,filenames)' tuples�.r � c s g | ]}|� d � �qS �Nr )�.0�file�Zplenr r �
<listcomp>s s z+build_py.get_data_files.<locals>.<listcomp>)
r �get_package_dir�osr% �joinr �split�len�find_data_files�append)r �datar �src_dir� build_dir� filenamesr r4 r r a s
�zbuild_py.get_data_filesc sd | j �dg �| j �|g � }g � |D ]:}t�tj�t�|�t|���}� �� fdd�|D �� q$� S )z6Return filenames for package's data files in 'src_dir'� c s$ g | ] }|� krt j�|�r|�qS r )r7 r% �isfile)r2 �fn��filesr r r5 � s �z,build_py.find_data_files.<locals>.<listcomp>) r �get�globr7 r% r8 �escaper �extend)r r r> Zglobs�patternZfilelistr rD r r; y s � zbuild_py.find_data_filesc C s` d}| j D ]P\}}}}|D ]>}tj�||�}| �tj�|�� | jtj�||�|dd� qq
dS )z$Copy data files into build directoryNF�Z
preserve_mode)r r7 r% r8 �mkpath�dirname� copy_file)r Zlastdirr r> r? r@ �filename�targetr r r r+ � s �zbuild_py.build_package_datac C s� |� d�}| js&|r tjj|� S dS n�g }|r�z| jd�|� }W n* tk
rl |�d|d � |d= Y q*X |�d|� tjj|� S q*| j�d�}|dk r�|�d|� |r�tjj|� S dS dS )z�Return the directory, relative to the top of the source
distribution, where package 'package' should be found
(at least according to the 'package_dir' option, if any).r/ rA r ���N)r9 r r7 r% r8 �KeyError�insertrF )r r r% �tailZpdirr r r r6 � s(
zbuild_py.get_package_dirc C sj |dkr8t j�|�s td| ��t j�|�s8td| ��|rft j�|d�}t j�|�rZ|S t�d|� d S )NrA z%package directory '%s' does not existz>supposed package directory '%s' exists, but is not a directoryz __init__.pyz8package init file '%s' not found (or not a regular file)) r7 r% �existsZDistutilsFileError�isdirr8 rB r �warn)r r r �init_pyr r r �
check_package� s& � �� �zbuild_py.check_packagec C s& t j�|�s t�d||� dS dS d S )Nz!file %s (for module %s) not foundFT)r7 r% rB r rW )r �module� module_filer r r � check_module� s zbuild_py.check_modulec C s� | � ||� t�tj�t�|�d��}g }tj�| jj�}|D ]P}tj�|�}||kr�tj� tj�
|��d }|� |||f� q>| � d| � q>|S )Nz*.pyr z excluding %s)
rY rG r7 r% r8 rH �abspathr Z script_name�splitext�basenamer< Z debug_print) r r r Z module_files�modulesZ setup_scriptr Zabs_frZ r r r �find_package_modules� s z build_py.find_package_modulesc C s� i }g }| j D ]�}|�d�}d�|dd� �}|d }z|| \}}W n" tk
rh | �|�}d}Y nX |s�| �||�} |df||< | r�|�|d| f� tj�||d �}
| � ||
�s�q|�|||
f� q|S )a� Finds individually-specified Python modules, ie. those listed by
module name in 'self.py_modules'. Returns a list of tuples (package,
module_base, filename): 'package' is a tuple of the path through
package-space to the module; 'module_base' is the bare (no
packages, no dots) module name, and 'filename' is the path to the
".py" file (relative to the distribution root) that implements the
module.
r/ r rQ r0 �__init__�.py)
r r9 r8 rR r6 rY r< r7 r% r\ ) r r r` rZ r% r Z module_baser �checkedrX r[ r r r � find_modules� s*
zbuild_py.find_modulesc C sN g }| j r|�| �� � | jrJ| jD ]$}| �|�}| �||�}|�|� q$|S )a4 Compute the list of all modules that will be built, whether
they are specified one-module-at-a-time ('self.py_modules') or
by whole packages ('self.packages'). Return a list of tuples
(package, module, module_file), just like 'find_modules()' and
'find_package_modules()' do.)r rI re r r6 ra )r r` r r �mr r r �find_all_modules s
zbuild_py.find_all_modulesc C s dd� | � � D �S )Nc S s g | ] }|d �qS )rQ r )r2 rZ r r r r5 - s z-build_py.get_source_files.<locals>.<listcomp>)rg r r r r �get_source_files, s zbuild_py.get_source_filesc C s$ |gt |� |d g }tjj|� S )Nrc )�listr7 r% r8 )r r? r rZ Z outfile_pathr r r �get_module_outfile/ s zbuild_py.get_module_outfiler0 c C s� | � � }g }|D ]p\}}}|�d�}| �| j||�}|�|� |r| jr^|�tjj|dd�� | j dkr|�tjj|| j d�� q|dd� | j
D �7 }|S )Nr/ rA )� optimizationr c S s, g | ]$\}}}}|D ]}t j�||��qqS r )r7 r% r8 )r2 r r> r? r@ rO r r r r5 B s
�z(build_py.get_outputs.<locals>.<listcomp>) rg r9 rj r r< r � importlib�util�cache_from_sourcer r )r r( r` Zoutputsr rZ r[ rO r r r r- 3 s*
�
�
�zbuild_py.get_outputsc C sb t |t�r|�d�}nt |ttf�s,td��| �| j||�}tj �
|�}| � |� | j ||dd�S )Nr/ z:'package' must be a string (dot-separated), list, or tupler rK )
r �strr9 ri �tuple� TypeErrorrj r r7 r% rM rL rN )r rZ r[ r Zoutfile�dirr r r � build_moduleJ s
�
zbuild_py.build_modulec C s* | � � }|D ]\}}}| �|||� q d S r1 )re rs )r r` r rZ r[ r r r r) Y s zbuild_py.build_modulesc C sP | j D ]D}| �|�}| �||�}|D ]$\}}}||ks:t�| �|||� q$qd S r1 )r r6 ra r" rs )r r r r` Zpackage_rZ r[ r r r r* b s
zbuild_py.build_packagesc C s� t jr| �d� d S ddlm} | j}|d tjkr>|tj }| jrZ||d| j || j
d� | j dkr|||| j | j || j
d� d S )Nz%byte-compiling is disabled, skipping.r )r, rQ )r r
�prefix�dry_run) �sys�dont_write_bytecoderW �distutils.utilr, r r7 �sepr r
ru r )r rE r, rt r r r r, v s&
�
�zbuild_py.byte_compileN)r0 )�__name__�
__module__� __qualname__Z descriptionZ user_optionsZboolean_optionsZ negative_optr r& r. r r; r+ r6 rY r\ ra re rg rh rj r- rs r) r* r, r r r r r s8 �
'4
r c @ s e Zd Zdd� Zdd� ZdS )�
build_py_2to3c C sL g | _ | jr| �� | jr*| �� | �� | �| j � | �| jdd�� d S r' ) �
updated_filesr r) r r* r+ Zrun_2to3r, r- r r r r r. � s zbuild_py_2to3.runc C s, t �| |||�}|d r(| j�|d � |S )Nr0 r )r rs r~ r< )r rZ r[ r �resr r r rs � s zbuild_py_2to3.build_moduleN)rz r{ r| r. rs r r r r r} � s r} )�__doc__r7 �importlib.utilrl rv rG Zdistutils.corer Zdistutils.errorsrx r r Z distutilsr r r} r r r r �<module> s } __pycache__/bdist_dumb.cpython-38.opt-2.pyc 0000644 00000006502 15051366006 0014465 0 ustar 00 U
e5d1 � @ sd d dl Z d dlmZ d dlmZ d dlmZmZ d dlT d dl m
Z
d dl m Z G dd � d e�Z
dS )
� N)�Command)� get_platform)� remove_tree�ensure_relative)�*)�get_python_version)�logc @ s^ e Zd ZdZdddde� fdddd d
d d g Zd
ddgZddd�Zdd� Zdd� Z dd� Z
dS )�
bdist_dumbz"create a "dumb" built distribution)z
bdist-dir=�dz1temporary directory for creating the distributionz
plat-name=�pz;platform name to embed in generated filenames (default: %s))zformat=�fz>archive format to create (tar, gztar, bztar, xztar, ztar, zip))� keep-temp�kzPkeep the pseudo-installation tree around after creating the distribution archive)z dist-dir=r
z-directory to put final built distributions in)�
skip-buildNz2skip rebuilding everything (for testing/debugging))�relativeNz7build the archive using relative paths (default: false))zowner=�uz@Owner name used when creating a tar file [default: current user])zgroup=�gzAGroup name used when creating a tar file [default: current group]r
r r Zgztar�zip)�posix�ntc C s: d | _ d | _d | _d| _d | _d | _d| _d | _d | _d S )Nr ) � bdist_dir� plat_name�format� keep_temp�dist_dir�
skip_buildr �owner�group)�self� r �4/usr/lib64/python3.8/distutils/command/bdist_dumb.py�initialize_options2 s z bdist_dumb.initialize_optionsc C sz | j d kr&| �d�j}tj�|d�| _ | jd krfz| jtj | _W n" t k
rd t
dtj ��Y nX | � dddd� d S )NZbdistZdumbz@don't know how to create dumb built distributions on platform %s)r r )r r )r r ) r Zget_finalized_command�
bdist_base�os�path�joinr �default_format�name�KeyError�DistutilsPlatformErrorZset_undefined_options)r r" r r r �finalize_options= s"
��
�zbdist_dumb.finalize_optionsc C s( | j s| �d� | jddd�}| j|_| j |_ d|_t�d| j� | �d� d| j� � | j
f }t j �
| j|�}| js~| j}nJ| j�� r�|j|jkr�tdt|j�t|j�f ��nt j �
| jt|j��}| j|| j|| j| jd �}| j�� r�t� }nd
}| jj� d ||f� | j �s$t | j| j d � d S )
NZbuild�install� )Zreinit_subcommandsr zinstalling to %sz%s.%szScan't make a dumb built distribution where base and platbase are different (%s, %s))Zroot_dirr r �anyr )�dry_run) r Z run_commandZreinitialize_commandr �rootZwarn_dirr �infoZ distributionZ get_fullnamer r# r$ r% r r Zhas_ext_modulesZ install_baseZinstall_platbaser) �reprr Z make_archiver r r r Z
dist_files�appendr r r. )r r+ Zarchive_basenameZpseudoinstall_rootZ archive_root�filenameZ pyversionr r r �runO sR
�
����
� �
�zbdist_dumb.runN) �__name__�
__module__� __qualname__Z descriptionr Z user_optionsZboolean_optionsr& r! r* r4 r r r r r s, ���
� r )r# Zdistutils.corer Zdistutils.utilr Zdistutils.dir_utilr r Zdistutils.errorsZdistutils.sysconfigr Z distutilsr r r r r r �<module> s __pycache__/check.cpython-38.opt-1.pyc 0000644 00000011427 15051366006 0013427 0 ustar 00 U
e5d� � @ s� d Z ddlmZ ddlmZ zTddlmZ ddlmZ ddl m
Z
ddl m Z ddl m
Z
G d d
� d
e�Zd ZW n ek
r� d ZY nX G d
d� de�ZdS )zCdistutils.command.check
Implements the Distutils 'check' command.
� )�Command)�DistutilsSetupError)�Reporter)�Parser)�frontend)�nodes)�StringIOc @ s e Zd Zd dd�Zdd� ZdS )
�SilentReporterNr �ascii�replacec
C s" g | _ t�| |||||||� d S �N)�messagesr �__init__)�self�source� report_level�
halt_level�stream�debug�encoding�
error_handler� r �//usr/lib64/python3.8/distutils/command/check.pyr s �zSilentReporter.__init__c O s6 | j �||||f� tj|f|�|| j| d�|��S )N)�level�type)r
�appendr �system_messageZlevels)r r �messageZchildren�kwargsr r r r s ���z SilentReporter.system_message)Nr r
r )�__name__�
__module__� __qualname__r r r r r r r s �
r TFc @ s` e Zd ZdZdZdddgZdddgZd d
� Zd d � Zd
d� Z dd� Z
dd� Z dd� Z dd� Z
dS )�checkz6This command checks the meta-data of the package.
z"perform some checks on the package)�metadata�mzVerify meta-data)�restructuredtext�rzEChecks if long string meta-data syntax are reStructuredText-compliant)�strict�sz(Will exit with an error if a check failsr# r% r' c C s d| _ d| _d| _d| _dS )z Sets default values for options.r � N)r% r# r' � _warnings�r r r r �initialize_options1 s zcheck.initialize_optionsc C s d S r r r+ r r r �finalize_options8 s zcheck.finalize_optionsc C s | j d7 _ t�| |�S )z*Counts the number of warnings that occurs.r) )r* r �warn)r �msgr r r r. ; s z
check.warnc C sL | j r| �� | jr0tr"| �� n| jr0td��| jrH| jdkrHtd��dS )zRuns the command.z The docutils package is needed.r z Please correct your package.N)r# �check_metadatar% � HAS_DOCUTILS�check_restructuredtextr' r r* r+ r r r �run@ s
z check.runc C s� | j j}g }dD ]"}t||�r(t||�s|�|� q|rL| �dd�|� � |jrd|js�| �d� n"|j r||j
s�| �d� n
| �d� dS )z�Ensures that all required elements of meta-data are supplied.
name, version, URL, (author and author_email) or
(maintainer and maintainer_email)).
Warns if any are missing.
)�name�versionZurlz missing required meta-data: %sz, zLmissing meta-data: if 'author' supplied, 'author_email' must be supplied toozTmissing meta-data: if 'maintainer' supplied, 'maintainer_email' must be supplied toozimissing meta-data: either (author and author_email) or (maintainer and maintainer_email) must be suppliedN) � distributionr# �hasattr�getattrr r. �joinZauthorZ author_emailZ
maintainerZmaintainer_email)r r# Zmissing�attrr r r r0 P s zcheck.check_metadatac C sX | j �� }| �|�D ]>}|d �d�}|dkr8|d }nd|d |f }| �|� qdS )z4Checks if the long string fields are reST-compliant.����lineNr) z %s (line %s))r6 Zget_long_description�_check_rst_data�getr. )r �dataZwarningr< r r r r2 n s
z check.check_restructuredtextc
C s� | j jp
d}t� }tjtfd��� }d|_d|_d|_t ||j
|j |j |j
|j|jd�}tj|||d�}|�|d� z|�||� W n: tk
r� } z |j�dd| d i f� W 5 d}~X Y nX |jS )
z8Returns warnings when the provided data doesn't compile.zsetup.py)Z
components� N)r r r r )r r; z!Could not finish the parsing: %s.� )r6 Z script_namer r Z OptionParserZget_default_valuesZ tab_widthZpep_referencesZrfc_referencesr r r Zwarning_streamr Zerror_encodingZ error_encoding_error_handlerr �documentZ note_source�parse�AttributeErrorr
r )r r? � source_path�parserZsettingsZreporterrB �er r r r= y s. � �zcheck._check_rst_dataN)r r r! �__doc__Z descriptionZ user_optionsZboolean_optionsr, r- r. r3 r0 r2 r= r r r r r" $ s �
r" N)rH Zdistutils.corer Zdistutils.errorsr Zdocutils.utilsr Zdocutils.parsers.rstr Zdocutilsr r �ior r r1 � Exceptionr" r r r r �<module> s
__pycache__/build_py.cpython-38.opt-1.pyc 0000644 00000024271 15051366006 0014162 0 ustar 00 U
e5d&C � @ sz d Z ddlZddlZddlZddlZddlmZ ddlT ddl m
Z
m Z ddl m
Z
G dd� de�ZG d d
� d
ee �ZdS ) zHdistutils.command.build_py
Implements the Distutils 'build_py' command.� N)�Command)�*)� convert_path� Mixin2to3)�logc @ s� e Zd ZdZdddddgZddgZd diZd
d � Zd d
� Zdd� Z dd� Z
dd� Z dd� Z dd� Z
dd� Zdd� Zd d � Zd d � Zd d!� Zd"d#� Zd$d%� Zd2d'd(�Zd)d*� Zd+d,� Zd-d.� Zd/d0� Zd1S )3�build_pyz5"build" pure Python modules (copy to build directory))z
build-lib=�dz directory to "build" (copy) to)�compile�czcompile .py to .pyc)�
no-compileNz!don't compile .py files [default])z optimize=�Ozlalso compile with optimization: -O1 for "python -O", -O2 for "python -OO", and -O0 to disable [default: -O0])�force�fz2forcibly build everything (ignore file timestamps)r r
r c C s4 d | _ d | _d | _d | _d | _d| _d| _d | _d S )Nr )� build_lib�
py_modules�package� package_data� package_dirr �optimizer
��self� r �2/usr/lib64/python3.8/distutils/command/build_py.py�initialize_options s zbuild_py.initialize_optionsc C s� | � ddd� | jj| _| jj| _| jj| _i | _| jjr^| jj�� D ]\}}t|�| j|< qF| �� | _ t
| j t �s�zt | j �| _ W n t
tfk
r� td��Y nX d S )NZbuild)r r )r
r
zoptimize must be 0, 1, or 2)Zset_undefined_options� distribution�packagesr r r �itemsr �get_data_files�
data_files�
isinstancer �int�
ValueError�AssertionErrorZDistutilsOptionError)r �name�pathr r r �finalize_options* s$ �
zbuild_py.finalize_optionsc C s: | j r| �� | jr$| �� | �� | �| jdd�� d S �Nr )�include_bytecode)r �
build_modulesr �build_packages�build_package_data� byte_compile� get_outputsr r r r �runC s z build_py.runc s� g }| j s|S | j D ]h}| �|�}tjj| jg|�d� � }d� |rPt|�d � � fdd�| �||�D �}|� ||||f� q|S )z?Generate list of '(package,src_dir,build_dir,filenames)' tuples�.r � c s g | ]}|� d � �qS �Nr )�.0�file�Zplenr r �
<listcomp>s s z+build_py.get_data_files.<locals>.<listcomp>)
r �get_package_dir�osr$ �joinr �split�len�find_data_files�append)r �datar �src_dir� build_dir� filenamesr r3 r r a s
�zbuild_py.get_data_filesc sd | j �dg �| j �|g � }g � |D ]:}t�tj�t�|�t|���}� �� fdd�|D �� q$� S )z6Return filenames for package's data files in 'src_dir'� c s$ g | ] }|� krt j�|�r|�qS r )r6 r$ �isfile)r1 �fn��filesr r r4 � s �z,build_py.find_data_files.<locals>.<listcomp>) r �get�globr6 r$ r7 �escaper �extend)r r r= Zglobs�patternZfilelistr rC r r: y s � zbuild_py.find_data_filesc C s` d}| j D ]P\}}}}|D ]>}tj�||�}| �tj�|�� | jtj�||�|dd� qq
dS )z$Copy data files into build directoryNF�Z
preserve_mode)r r6 r$ r7 �mkpath�dirname� copy_file)r Zlastdirr r= r> r? �filename�targetr r r r* � s �zbuild_py.build_package_datac C s� |� d�}| js&|r tjj|� S dS n�g }|r�z| jd�|� }W n* tk
rl |�d|d � |d= Y q*X |�d|� tjj|� S q*| j�d�}|dk r�|�d|� |r�tjj|� S dS dS )z�Return the directory, relative to the top of the source
distribution, where package 'package' should be found
(at least according to the 'package_dir' option, if any).r. r@ r ���N)r8 r r6 r$ r7 �KeyError�insertrE )r r r$ �tailZpdirr r r r5 � s(
zbuild_py.get_package_dirc C sj |dkr8t j�|�s td| ��t j�|�s8td| ��|rft j�|d�}t j�|�rZ|S t�d|� d S )Nr@ z%package directory '%s' does not existz>supposed package directory '%s' exists, but is not a directoryz __init__.pyz8package init file '%s' not found (or not a regular file)) r6 r$ �existsZDistutilsFileError�isdirr7 rA r �warn)r r r �init_pyr r r �
check_package� s& � �� �zbuild_py.check_packagec C s& t j�|�s t�d||� dS dS d S )Nz!file %s (for module %s) not foundFT)r6 r$ rA r rV )r �module� module_filer r r � check_module� s zbuild_py.check_modulec C s� | � ||� t�tj�t�|�d��}g }tj�| jj�}|D ]P}tj�|�}||kr�tj� tj�
|��d }|� |||f� q>| � d| � q>|S )Nz*.pyr z excluding %s)
rX rF r6 r$ r7 rG �abspathr Z script_name�splitext�basenamer; Z debug_print) r r r Z module_files�modulesZ setup_scriptr Zabs_frY r r r �find_package_modules� s z build_py.find_package_modulesc C s� i }g }| j D ]�}|�d�}d�|dd� �}|d }z|| \}}W n" tk
rh | �|�}d}Y nX |s�| �||�} |df||< | r�|�|d| f� tj�||d �}
| � ||
�s�q|�|||
f� q|S )a� Finds individually-specified Python modules, ie. those listed by
module name in 'self.py_modules'. Returns a list of tuples (package,
module_base, filename): 'package' is a tuple of the path through
package-space to the module; 'module_base' is the bare (no
packages, no dots) module name, and 'filename' is the path to the
".py" file (relative to the distribution root) that implements the
module.
r. r rP r/ �__init__�.py)
r r8 r7 rQ r5 rX r; r6 r$ r[ ) r r r_ rY r$ r Z module_baser �checkedrW rZ r r r � find_modules� s*
zbuild_py.find_modulesc C sN g }| j r|�| �� � | jrJ| jD ]$}| �|�}| �||�}|�|� q$|S )a4 Compute the list of all modules that will be built, whether
they are specified one-module-at-a-time ('self.py_modules') or
by whole packages ('self.packages'). Return a list of tuples
(package, module, module_file), just like 'find_modules()' and
'find_package_modules()' do.)r rH rd r r5 r` )r r_ r r �mr r r �find_all_modules s
zbuild_py.find_all_modulesc C s dd� | � � D �S )Nc S s g | ] }|d �qS )rP r )r1 rY r r r r4 - s z-build_py.get_source_files.<locals>.<listcomp>)rf r r r r �get_source_files, s zbuild_py.get_source_filesc C s$ |gt |� |d g }tjj|� S )Nrb )�listr6 r$ r7 )r r> r rY Z outfile_pathr r r �get_module_outfile/ s zbuild_py.get_module_outfiler/ c C s� | � � }g }|D ]p\}}}|�d�}| �| j||�}|�|� |r| jr^|�tjj|dd�� | j dkr|�tjj|| j d�� q|dd� | j
D �7 }|S )Nr. r@ )� optimizationr c S s, g | ]$\}}}}|D ]}t j�||��qqS r )r6 r$ r7 )r1 r r= r> r? rN r r r r4 B s
�z(build_py.get_outputs.<locals>.<listcomp>) rf r8 ri r r; r � importlib�util�cache_from_sourcer r )r r' r_ Zoutputsr rY rZ rN r r r r, 3 s*
�
�
�zbuild_py.get_outputsc C sb t |t�r|�d�}nt |ttf�s,td��| �| j||�}tj �
|�}| � |� | j ||dd�S )Nr. z:'package' must be a string (dot-separated), list, or tupler rJ )
r �strr8 rh �tuple� TypeErrorri r r6 r$ rL rK rM )r rY rZ r Zoutfile�dirr r r � build_moduleJ s
�
zbuild_py.build_modulec C s* | � � }|D ]\}}}| �|||� q d S r0 )rd rr )r r_ r rY rZ r r r r( Y s zbuild_py.build_modulesc C sD | j D ]8}| �|�}| �||�}|D ]\}}}| �|||� q$qd S r0 )r r5 r` rr )r r r r_ Zpackage_rY rZ r r r r) b s
zbuild_py.build_packagesc C s� t jr| �d� d S ddlm} | j}|d tjkr>|tj }| jrZ||d| j || j
d� | j dkr|||| j | j || j
d� d S )Nz%byte-compiling is disabled, skipping.r )r+ rP )r r
�prefix�dry_run) �sys�dont_write_bytecoderV �distutils.utilr+ r r6 �sepr r
rt r )r rD r+ rs r r r r+ v s&
�
�zbuild_py.byte_compileN)r/ )�__name__�
__module__� __qualname__Z descriptionZ user_optionsZboolean_optionsZ negative_optr r% r- r r: r* r5 rX r[ r` rd rf rg ri r, rr r( r) r+ r r r r r s8 �
'4
r c @ s e Zd Zdd� Zdd� ZdS )�
build_py_2to3c C sL g | _ | jr| �� | jr*| �� | �� | �| j � | �| jdd�� d S r& ) �
updated_filesr r( r r) r* Zrun_2to3r+ r, r r r r r- � s zbuild_py_2to3.runc C s, t �| |||�}|d r(| j�|d � |S )Nr/ r )r rr r} r; )r rY rZ r �resr r r rr � s zbuild_py_2to3.build_moduleN)ry rz r{ r- rr r r r r r| � s r| )�__doc__r6 �importlib.utilrk ru rF Zdistutils.corer Zdistutils.errorsrw r r Z distutilsr r r| r r r r �<module> s } __pycache__/install_headers.cpython-38.opt-2.pyc 0000644 00000003010 15051366006 0015501 0 ustar 00 U
e5d � @ s d dl mZ G dd� de�ZdS )� )�Commandc @ sF e Zd ZdZddgZdgZdd� Zdd� Zd d
� Zd d � Z d
d� Z
dS )�install_headerszinstall C/C++ header files)z install-dir=�dz$directory to install header files to)�force�fz-force installation (overwrite existing files)r c C s d | _ d| _g | _d S )Nr )� install_dirr �outfiles��self� r �9/usr/lib64/python3.8/distutils/command/install_headers.py�initialize_options s z"install_headers.initialize_optionsc C s | � ddd� d S )NZinstall)r r )r r )Zset_undefined_optionsr r r r �finalize_options s �z install_headers.finalize_optionsc C sH | j j}|sd S | �| j� |D ]"}| �|| j�\}}| j�|� q d S �N)� distribution�headersZmkpathr Z copy_filer �append)r
r �header�out�_r r r �run! s zinstall_headers.runc C s | j jp
g S r )r r r r r r �
get_inputs+ s zinstall_headers.get_inputsc C s | j S r )r r r r r � get_outputs. s zinstall_headers.get_outputsN) �__name__�
__module__� __qualname__Z descriptionZ user_optionsZboolean_optionsr
r r r r r r r r r
s �
r N)Zdistutils.corer r r r r r �<module> s __pycache__/install_data.cpython-38.opt-1.pyc 0000644 00000004363 15051366007 0015013 0 ustar 00 U
e5d � @ s< d Z ddlZddlmZ ddlmZmZ G dd� de�ZdS )z�distutils.command.install_data
Implements the Distutils 'install_data' command, for installing
platform-independent data files.� N)�Command)� change_root� convert_pathc @ sH e Zd ZdZdddgZdgZdd� Zdd � Zd
d � Zd d
� Z dd� Z
dS )� install_datazinstall data files)z install-dir=�dzIbase directory for installing data files (default: installation base dir))zroot=Nz<install everything relative to this alternate root directory)�force�fz-force installation (overwrite existing files)r c C s, d | _ g | _d | _d| _| jj| _d| _d S )Nr � )� install_dir�outfiles�rootr Z distribution�
data_files�warn_dir��self� r �6/usr/lib64/python3.8/distutils/command/install_data.py�initialize_options s
z install_data.initialize_optionsc C s | � dddd� d S )NZinstall)r r
)r r )r r )Zset_undefined_optionsr r r r �finalize_options# s
�z install_data.finalize_optionsc C s� | � | j� | jD ]�}t|t�rbt|�}| jrB| �d|| jf � | �|| j�\}}| j �
|� qt|d �}t j �
|�s�t j �| j|�}n| jr�t| j|�}| � |� |d g kr�| j �
|� q|d D ](}t|�}| �||�\}}| j �
|� q�qd S )NzMsetup script did not provide a directory for '%s' -- installing right in '%s'r r )Zmkpathr
r
�
isinstance�strr r �warnZ copy_filer �append�os�path�isabs�joinr r )r r �out�_�dir�datar r r �run* s,
�
zinstall_data.runc C s
| j pg S �N)r
r r r r �
get_inputsK s zinstall_data.get_inputsc C s | j S r" )r r r r r � get_outputsN s zinstall_data.get_outputsN) �__name__�
__module__� __qualname__Z descriptionZ user_optionsZboolean_optionsr r r! r# r$ r r r r r s � !r )�__doc__r Zdistutils.corer Zdistutils.utilr r r r r r r �<module> s __pycache__/upload.cpython-38.opt-2.pyc 0000644 00000011702 15051366007 0013634 0 ustar 00 U
&�.e� � @ s� d dl Z d dlZd dlZd dlZd dlmZ d dlmZmZm Z d dl
m Z d dl m
Z
mZ d dlmZ d dlmZ d dlmZ G d d
� d
e�ZdS ) � N)�standard_b64encode)�urlopen�Request� HTTPError)�urlparse)�DistutilsError�DistutilsOptionError)�
PyPIRCCommand)�spawn)�logc @ sJ e Zd ZdZejddg Zejdg Zdd� Zdd� Zd d
� Z d d � Z
d
S )�uploadz upload binary package to PyPI)�sign�sz sign files to upload using gpg)z identity=�iz GPG identity used to sign filesr
c C s, t �| � d| _d| _d| _d| _d | _d S )N� r F)r �initialize_options�username�password�
show_responser
�identity)�self� r �0/usr/lib64/python3.8/distutils/command/upload.pyr s
zupload.initialize_optionsc C sr t �| � | jr | js td��| �� }|i krV|d | _|d | _|d | _|d | _ | jsn| j
jrn| j
j| _d S )Nz.Must use --sign for --identity to have meaningr r �
repository�realm) r �finalize_optionsr r
r Z _read_pypircr r r r � distribution)r Zconfigr r r r ( s
�
zupload.finalize_optionsc C s: | j jsd}t|��| j jD ]\}}}| �|||� q d S )NzHMust create and upload files in one command (e.g. setup.py sdist upload))r Z
dist_filesr � upload_file)r �msg�command� pyversion�filenamer r r �run: s
z
upload.runc " C s t | j�\}}}}}} |s"|s"| r0td| j ��|dkrDtd| ��| jr|ddd|g}
| jrnd| jg|
dd�< t|
| jd � t|d
�} z | � � } W 5 | �� X | j
j }
d d |
� � |
�
� tj�|�| f||t�| ��� d
|
�� |
�� |
�� |
�� |
�� |
�� |
�� |
�� |
� � |
� � |
� � |
� � |
� � d�}zt�!| ��� }W nP t"k
�r� } z0d| }| �#|t$j%� ddl&m'} |� �s|� W 5 d }~X Y n
X ||d< d|d< | j�r�t|d d
��"} tj�|�d | � � f|d< W 5 Q R X | j(d | j) �*d�}dt+|��,d� }d}d|�*d� }|d }t-�.� }|�/� D ]�\}}d | }t0|t1��sP|g}|D ]j}t2|�t3k�r�|d |d 7 }|d }nt4|��*d �}|�5|� |�5|�*d �� |�5d!� |�5|� �qT�q.|�5|� |�6� }d"|| jf }| �#|t$j%� d#| t4t7|��|d$�} t8| j|| d%�} zt9| �} | �:� } | j;} W nf t<k
�rd } z|j=} |j;} W 5 d }~X Y n8 t>k
�r� } z| �#t4|�t$j?� � W 5 d }~X Y nX | d&k�r�| �#d'| | f t$j%� | j@�r| �A| �}!d(�Bd)|!d)f�}| �#|t$j%� n"d*| | f }| �#|t$j?� tC|��d S )+NzIncompatible url %s)ZhttpZhttpszunsupported schema Zgpgz
--detach-signz-az --local-user� )�dry_run�rbZ file_upload�1z1.0)z:actionZprotocol_version�name�version�contentZfiletyper Z
sha256_digestZmetadata_versionZsummaryZ home_pageZauthorZ author_email�license� description�keywords�platformZ classifiersZ download_urlZprovidesZrequiresZ obsoletesz#calculating md5 checksum failed: %sr )�
get_fips_modeZ
md5_digestr Zcommentz.ascZ
gpg_signature�:�asciizBasic z3--------------GHSKFJDLGDS7543FJKLFHRE75642756743254s
--s --
z+
Content-Disposition: form-data; name="%s"z; filename="%s"� zutf-8s
zSubmitting %s to %sz multipart/form-data; boundary=%s)z Content-typezContent-lengthZ
Authorization)�data�headers�� zServer response (%s): %s�
zK---------------------------------------------------------------------------zUpload failed (%s): %s)Dr r �AssertionErrorr
r r
r$ �open�close�readr ZmetadataZget_nameZ get_version�os�path�basename�hashlibZsha256Z hexdigestZget_descriptionZget_urlZ get_contactZget_contact_emailZ get_licenceZget_long_descriptionZ get_keywordsZ
get_platformsZget_classifiersZget_download_urlZ get_providesZ get_requiresZ
get_obsoletesZmd5�
ValueErrorZannouncer �INFOZ_hashlibr. r r �encoder �decode�io�BytesIO�items�
isinstance�list�type�tuple�str�write�getvalue�lenr r Zgetcoder r �code�OSErrorZERRORr Z_read_pypi_response�joinr )"r r r r! ZschemaZnetlocZurlZparamsZqueryZ fragmentsZgpg_args�fr) �metar2 Zdigest�er r. Z user_passZauth�boundaryZ sep_boundaryZ end_boundaryZbody�key�value�titler3 Zrequest�resultZstatus�reason�textr r r r B s� � �
�! �
��
�
zupload.upload_fileN) �__name__�
__module__� __qualname__r+ r Z user_optionsZboolean_optionsr r r" r r r r r r s � r )r: rB r- r= �base64r Zurllib.requestr r r Z urllib.parser Zdistutils.errorsr r Zdistutils.corer Zdistutils.spawnr
Z distutilsr r r r r r �<module> s __pycache__/bdist_msi.cpython-38.pyc 0000644 00000046251 15051366007 0013374 0 ustar 00 U
e5d߉ � @ s� d Z ddlZddlZddlmZ ddlmZ ddlmZ ddl m
Z
ddl m Z ddl
mZ dd lmZ ddlZdd
lmZmZmZ dd lmZmZmZmZ G d d
� d
e�ZG dd� de�ZdS )z#
Implements the bdist_msi command.
� N)�Command)� remove_tree)�get_python_version)�
StrictVersion)�DistutilsOptionError)� get_platform)�log)�schema�sequence�text)� Directory�Feature�Dialog�add_datac @ sF e Zd ZdZdd� Zdd� Zddd �Zdd d �Zddd�Zdd� Z dS )�PyDialogz�Dialog class with a fixed layout: controls at the top, then a ruler,
then a list of buttons: back, next, cancel. Optionally a bitmap at the
left.c O s> t j| f|�� | jd }d| d }| �dd|| jd� dS )zbDialog(database, name, x, y, w, h, attributes, title, first,
default, cancel, bitmap=true)�$ � iH Z
BottomLiner N)r �__init__�h�line�w)�self�args�kwZrulerZbmwidth� r �3/usr/lib64/python3.8/distutils/command/bdist_msi.pyr s
zPyDialog.__init__c
C s | � ddddddd| � dS ) z,Set the title text of the dialog at the top.�Title� �
�@ �< � z{\VerdanaBold10}%sN)r )r �titler r r r" # s �zPyDialog.title�Back� c
C s, |r
d}nd}| � |d| jd dd|||�S )z�Add a back button with a given title, the tab-next button,
its name in the Control table, possibly initially disabled.
Return the button, so that events can be associated� r$ � � �8 � ��
pushbuttonr �r r" �next�name�active�flagsr r r �back* s z
PyDialog.back�Cancelc
C s, |r
d}nd}| � |d| jd dd|||�S )z�Add a cancel button with a given title, the tab-next button,
its name in the Control table, possibly initially disabled.
Return the button, so that events can be associatedr% r$ i0 r' r( r) r* r, r r r �cancel5 s zPyDialog.cancel�Nextc
C s, |r
d}nd}| � |d| jd dd|||�S )z�Add a Next button with a given title, the tab-next button,
its name in the Control table, possibly initially disabled.
Return the button, so that events can be associatedr% r$ �� r' r( r) r* r, r r r r- @ s z
PyDialog.nextc
C s, | � |t| j| d �| jd ddd||�S )z�Add a button with a given title, the tab-next button,
its name in the Control table, giving its x position; the
y-position is aligned with the other buttons.
Return the button, so that events can be associated� r' r( r) r% )r+ �intr r )r r. r" r- Zxposr r r �xbuttonK s zPyDialog.xbuttonN)r# r$ )r2 r$ )r4 r$ )
�__name__�
__module__� __qualname__�__doc__r r" r1 r3 r- r8 r r r r r s
r c @ s� e Zd ZdZdddde� fdddd d
d d d
g
ZddddgZddddddddddd d d d d d!d"d#d$d%gZd&Zd'd(� Z d)d*� Z
d+d,� Z d-d.� Z d/d0� Z
d1d2� Zd3d4� Zd5d6� Zd7S )8� bdist_msiz7create a Microsoft Installer (.msi) binary distribution)z
bdist-dir=Nz1temporary directory for creating the distributionz
plat-name=�pz;platform name to embed in generated filenames (default: %s))� keep-temp�kzPkeep the pseudo-installation tree around after creating the distribution archive)ztarget-version=Nz6require a specific python version on the target system)�no-target-compile�cz/do not compile .py to .pyc on the target system)�no-target-optimize�oz;do not compile .py to .pyo (optimized) on the target system)z dist-dir=�dz-directory to put final built distributions in)�
skip-buildNz2skip rebuilding everything (for testing/debugging))zinstall-script=NzUbasename of installation script to be run after installation or before deinstallation)zpre-install-script=Nz{Fully qualified filename of a script to be run before any files are installed. This script need not be in the distributionr? rA rC rF z2.0z2.1z2.2z2.3z2.4z2.5z2.6z2.7z2.8z2.9z3.0z3.1z3.2z3.3z3.4z3.5z3.6z3.7z3.8z3.9�Xc C sF d | _ d | _d| _d| _d| _d | _d | _d | _d | _d | _ d | _
d S )Nr ) � bdist_dir� plat_name� keep_tempZno_target_compileZno_target_optimize�target_version�dist_dir�
skip_build�install_script�pre_install_script�versions)r r r r �initialize_options} s z bdist_msi.initialize_optionsc C s� | � dd� | jd kr2| �d�j}tj�|d�| _t� }| jsN| j �
� rN|| _| jr�| jg| _ | j s�| j �
� r�| j|kr�t
d|f ��n t| j�| _ | � ddd� | jr�t
d��| jr�| j jD ]}| jtj�|�kr� q�q�t
d| j ��d | _d S ) NZbdist)rM rM ZmsizMtarget version can only be %s, or the '--skip-build' option must be specified)rL rL )rI rI z5the pre-install-script feature is not yet implementedz(install_script '%s' not found in scripts)Zset_undefined_optionsrH �get_finalized_command�
bdist_base�os�path�joinr rK � distribution�has_ext_modulesrP rM r �list� all_versionsrO rN Zscripts�basename�install_script_key)r rS Z
short_versionZscriptr r r �finalize_options� sH
��� �� ��zbdist_msi.finalize_optionsc C s� | j s| �d� | jddd�}| j|_| j |_ d|_| �d�}d|_d|_| j� � r�| j
}|s~| j slt d��dt j
d d � }d
| j|f }| �d�}tj�|jd | �|_t�d | j� |�� t j�dtj�| jd
�� |�� t jd= | �| j� | j� � }| � |�}tj� |�}tj� |��r0t� |� | jj!}|j"} | �sJ|j#} | �sTd} |�$� }
dt%|
�j& } | j� � }| j
�r�d| j
|f } nd| } t'�(|t)| t'�*� | | �| _+t'�,| j+t-� d|
fg}
|j.�p�|j/}|�r�|
�0d|f� |j1�r |
�0d|j1f� |
�rt2| j+d|
� | �3� | �4� | �5� | �6� | j+�7� t8| jd��rld| j
�pXd|f}| jj9�0|� | j:�s�t;| j| j<d� d S )N�build�installr$ )Zreinit_subcommandsr � install_libz Should have already checked thisz%d.%d� z.%s-%s�libzinstalling to %sZPURELIBZUNKNOWNz%d.%d.%dz Python %s %sz Python %sZ DistVersionZ
ARPCONTACTZARPURLINFOABOUT�Property�
dist_filesr= �any)�dry_run)=rM Z run_commandZreinitialize_commandrH �prefixZwarn_dir�compile�optimizerW rX rK �AssertionError�sys� version_inforI rR rT rU rV Z
build_baseZ build_libr �infoZensure_finalized�insert�runZmkpathrL � get_fullname�get_installer_filename�abspath�exists�unlink�metadata�authorZ
maintainerZ get_versionr �version�msilibZ
init_databaser Zgen_uuid�dbZ
add_tablesr
Z author_emailZmaintainer_email�appendZurlr �add_find_python� add_files� add_scripts�add_ui�Commit�hasattrrd rJ r rf )r r_ r` rK Zplat_specifierr^ �fullname�installer_nameru rv rw ZsversionZ product_nameZpropsZemail�tupr r r ro � s�
�
�
z
bdist_msi.runc
C s | j }t�d�}tj�| j�}t||d |dd�}t|ddddddd�}||d fg}| j | j
g D ]t}d| }d| } }
d} || j
kr�d
} d }
n d | } d}
t|| | | d|
|d�}t||||||
�}|� |||f� q`|� � i }|D �] \}}}|g}|�r�|�
� }t�|j�D ]�}tj�|j|�}tj�|��rld
|�|�|f }|| }
t|||||
|�}|� |� n�|j�s�|�|j|d� ||k�r�|�|� }||< || jk�r�| j�r�td| ��d| | _n*|| }t| j d|| |j|d |jfg� �qq�|� � q�|�|� d S )NZ distfiles� TARGETDIRZ SourceDir�PythonZ
Everythingr r$ )Z directory� z Python from another locationra zPython %s from registryz%s|%szMultiple files with name %sz[#%s]Z
DuplicateFile) ry rx ZCABrT rU rr rH r r
rP �
other_versionrz r �pop�listdirZabsoluterV �isdirZ
make_shortZ componentZstart_componentZlogicalZadd_filerN r\ r r Zcommit)r ry ZcabZrootdir�root�f�itemsrw �targetr. �defaultZdescr" �level�dir�seenZfeatureZtodo�fileZafileZshortZnewdir�keyr r r r|
sf
�
� �
zbdist_msi.add_filesc C s� d}| j D �]v}d| }d| }d| }d| }d| }d| }d| } d | }
d
| } d | } tjrld }
nd
}
t| jd|d
|d|
f|d|d|
fg� t| jd||f||fg� t| jd|d| d| d f| d| d| d f|
d| d| d fg� t| jd|||f| ||d f|
d|d
fg� t| jd|||f| ||d f|
d|d
fg� t| jdd| dd | fg� |d 7 }|d k s
t�q
dS ) as Adds code to the installer to compute the location of Python.
Properties PYTHON.MACHINE.X.Y and PYTHON.USER.X.Y will be set from the
registry for each version of Python.
Properties TARGETDIRX.Y will be set from PYTHON.USER.X.Y if defined,
else from PYTHON.MACHINE.X.Y.
Properties PYTHONX.Y will be set to TARGETDIRX.Y\python.exei� z)SOFTWARE\Python\PythonCore\%s\InstallPathzpython.machine.z python.user.zPYTHON.MACHINE.z PYTHON.USER.ZPythonFromMachineZPythonFromUserZ PythonExer� �PYTHON� ra Z
RegLocatorNr$ Z AppSearch� CustomActioni3 �[�]z ]\python.exe�InstallExecuteSequence�InstallUISequenceZ Conditionr� r z
NOT TARGETDIR� i� )rP rx ZWin64r ry rj )r �start�verZ install_pathZ machine_regZuser_regZ machine_propZ user_propZmachine_actionZ user_actionZ
exe_actionZtarget_dir_prop�exe_propZTyper r r r{ C s` ������ �� ���zbdist_msi.add_find_pythonc
C s | j rjd}| j| jg D ]P}d| }d| }t| jd|d|| jfg� t| jd|d| |fg� |d7 }q| jr�tj� | j
d �}t |d
��4}|� d � t | j��}|� |�
� � W 5 Q R X W 5 Q R X t| jd d
t�|�fg� t| jddg� t| jddg� d S )Ni� zinstall_script.r� r� �2 r� z &Python%s=3r$ zpreinstall.batr zrem ="""
%1 %0
exit
"""
�Binary�
PreInstall)r� ra r� N)r� z
NOT Installedi� )rN rP r� r ry r\ rO rT rU rV rH �open�write�readrx r� )r r� r� Zinstall_actionr� Zscriptfnr� Zfinr r r r} y s6 ��
"���zbdist_msi.add_scriptsc C s�
| j }d }}d}d}d}d}d}d} t|dd d
d d d
dg� t|dddddg� t|ddddddg� t|dtj� t|dtj� t|d ||||||d d d � }
|
�d � |
jd d d d!� |
jd"d#d d!� |
�d$d%d&d'd(d)d*� |
�d+d%d,d'd-d)d.� |
j d d"d d/�} | �
d0d1� t|d2||||||d d d � } | �d3� | jd d d d!� | jd"d#d d!� | �d$d%d&d'd(d)d4� | �d+d%d,d'd-d)d.� | j d d"d d/�} | �
d0d1� t|d5||||||d d d � }
|
�d6� |
jd d d d!� |
jd"d#d d!� |
�d7d%d8d'd-d)d.� |
j d d"d d/�} | �
d0d9� t|d:||||d;|d<d<d<d=d>� }|�d?d%d@dAd%d)dB� |�d7d-dCdDd-d)dE� |�dFd-dGdHdddI� |� dJdKd-dLdHdMdNdOd d d � |jd1dPd1d/�} | �
d0d1� |j dPd<dPd/�} | �
d0dP� |jd<d1d<d/�} | �
d0d<� t |dQddRdHdSdT|dUd d � }|�dUddVdDdWddX� |�
dYdZd[d\d]dd^d ��
d0d_� |�
d`dad[d\d]ddbd ��
d0dc� |�
ddd d[d\d]dded ��
d0df� |�
dgdhd[d\d]dd"d ��
d0di� |�
djd\d[d\d]ddPd ��
d0dk� |�
dldmd[d\d]ddnd ��
d0do� |�
dpdqd[d\d]dd<d ��
d0dr� t |dsddRdtdud|d^d^d^� }|�dFdWd%dvdwddx� |�
dbd[dydzd{ddbd^�} | �
d0d1� |�
d^d|dydzd{dd^db�} | �
d0d9� t |d}ddRdtdu||d9d9d9� }|�dFdWd%dvdwdd~� |�
d9ddydzd{dd9d �} | �
d0d1� t|d�||||||d"d"d"� }|�d7d%d&d'd�d)d�� |�d�� |�dd%d�d'd-d)d��} | �ddF� |�d�d%d�d'dwd)d �} | �d�dF� |jd#d d d!� |j d�d d d!� |�d"d �} | �
d�ds� t|d�||||||d�d�d"� }|�d�� |�d�d%dwdd-dd�| j�� � |jd d d d!� |� d�d"�} d}| j
d�d�|d�� | j| jg D ](}|d7 }| j
d�d�| d�| |d�� �q
| j
d�d}|d d�� | j
d0d9|d� d�� |�d"d��} | �
d�ds� |� d�d�d%d�ddZdd�d d�d � } | �
d�d�� | j}d�| }d�| }|�d�d%dAdd%dd��} | �d�|� | �d�|� | �d�|� | �d�|� |� d�d�d%d�dd�dd�| d d�d � } | �d�|� | �d�|� | �d�|� | �d�|� t|d�||||||d�d�d�d=d>� }|�d?d%d@dAd%d)d�� |�d7d-d-dDd-d)d�� |�dFd-d�dHd�dd�� |� d�d�d-d�dHd�d�d d�d d � |�d�dnd d���
d0d9� t|d�||||||d�d�d"� }|�d�� |�d�d%d�dtddd�dXd�� }|�d�d d�d�d-d�� |�d�d d�d�d-d�� |jd#d d d!� |� d�d"�} | �
d�d�d�d� | j
d0d9d�d�� |�d"d��} | �
d�ds� t|d�||||||d"d"d"d=d>� } | �d?d-d%dAd%d)d�� | �dFd�d�ddwddġ | �d�d�d�d�d-ddơ | �dd&d�|d& d-dd��} | �ddF� | � d�d�d�dZddRd�d d�d d � } | �d�dˡ | jd d�d=d!� | j d�d"d=d!� | �d"d#��
d�ds� t|d�||||||d�d�d"� } | �d͡ | �d�d%d�dHdhddС | �d�d%d�dHd�dd�dXd�� }|�d�d d�dAd{d֡ |�d�d d�dAd{d١ | jd d d=d!� | � d d"�} | �
d�d�d�d�� | �
d�d�d�d@� | �
d�d�d�dN� | �
d�d�d�d� | �
d�d�d�d� | �
d�d�d�d� | �
d�d�d�d� | �
d�d�d�d� | �
d0d9d�d-� | �d"dѡ�
d�ds� d S )�Nr� ir i, z[ProductName] Setupr% r$ � rc )Z
DefaultUIFont�DlgFont8)Z ErrorDialog�ErrorDlg)Z Progress1ZInstall)Z Progress2Zinstalls)�MaintenanceForm_Action�Repair)�
WhichUsers�ALLZ TextStyle)r� �Tahoma� Nr )Z DlgFontBold8r� � Nr$ )Z
VerdanaBold10�Verdanar Nr$ )Z VerdanaRed9r� r� � r r� )�
PrepareDlgz(Not Privileged or Windows9x or Installed� )�
WhichUsersDlgz.Privileged and not Windows9x and not Installed� )�SelectFeaturesDlgz
Not Installedi� )�MaintenanceTypeDlgz,Installed AND NOT RESUME AND NOT Preselectedi� )� ProgressDlgNi �
ActionText�UITextZ
FatalErrorZFinishz)[ProductName] Installer ended prematurelyz< Backr )r/ r2 r# Z Description1r �F r �P r! z�[ProductName] setup ended prematurely because of an error. Your system has not been modified. To install this program at a later time, please run the installation again.Z Description2� � z.Click the Finish button to exit the Installer.)r. Z EndDialogZExitZUserExitz'[ProductName] Installer was interruptedz�[ProductName] setup was interrupted. Your system has not been modified. To install this program at a later time, please run the installation again.Z
ExitDialogz&Completing the [ProductName] InstallerZ Description�� ZReturnZ
FilesInUse� ZRetryF)Zbitmapr � �� z{\DlgFontBold8}Files in Use� i z8Some files that need to be updated are currently in use.ZText�7 iJ z�The following applications are using files that need to be updated by this setup. Close these applications and then click Retry to continue the installation or Cancel to exit it.ZListZListBox�k � � ZFileInUseProcess�Ignorer� r �e i Z ErrorTextr� �0 r� �N�x �H �Q � ZNoZErrorNo�Y�� ZYesZErrorYes�AZAbortZ
ErrorAbort�C�* Z ErrorCancel�IZ ErrorIgnore�O� ZOkZErrorOk�R�� Z
ErrorRetryZ CancelDlgi �U �� � z;Are you sure you want to cancel [ProductName] installation?�9 r( r) � ZWaitForCostingDlgzRPlease wait while the installer finishes determining your disk space requirements.�f r� �( zOPlease wait while the Installer prepares to guide you through the installation.z&Welcome to the [ProductName] Installer�n z Pondering...Z
ActionData� r4 Z SpawnDialogr� zSelect Python InstallationsZHintz9Select the Python locations where %s should be installed.zNext >z [TARGETDIR]z [SourceDir])Zorderingz
[TARGETDIR%s]z FEATURE_SELECTED AND &Python%s=3ZSpawnWaitDialogra ZFeaturesZ
SelectionTreer ZFEATUREZPathEditz[FEATURE_SELECTED]�1z!FEATURE_SELECTED AND &Python%s<>3ZOtherz$Provide an alternate Python locationZEnableZShowZDisableZHide�� � r� Z DiskCostDlgZOKz&{\DlgFontBold8}Disk Space RequirementszFThe disk space required for the installation of the selected features.�5 a The highlighted volumes (if any) do not have enough disk space available for the currently selected features. You can either remove some files from the highlighted volumes, or choose to install less features onto local drive(s), or select different destination drive(s).Z
VolumeListZVolumeCostList�d � i z{120}{70}{70}{70}{70}g �?r� Z AdminInstallzGSelect whether to install [ProductName] for all users of this computer.r� r� � zInstall for all usersZJUSTME� zInstall just for mez
[ALLUSERS]zWhichUsers="ALL"r� z({\DlgFontBold8}[Progress1] [ProductName]�# �A zYPlease wait while the Installer [Progress2] [ProductName]. This may take several minutes.Z StatusLabelzStatus:Z ProgressBari z
Progress doneZ SetProgressZProgressr� z)Welcome to the [ProductName] Setup WizardZBodyText�? z:Select whether you want to repair or remove [ProductName].ZRepairRadioGroup�l r� r� r� z&Repair [ProductName]ZRemover zRe&move [ProductName]z [REINSTALL]z MaintenanceForm_Action="Repair"z [Progress1]Z Repairingz [Progress2]ZrepairsZ Reinstallr� z[REMOVE]z MaintenanceForm_Action="Remove"� ZRemoving� Zremoves�
� z MaintenanceForm_Action<>"Change")ry r r r� r� r r" r1 r3 r- ZeventZcontrolr r+ �mappingrW rp rP r� Z conditionr8 Z
radiogroup�add) r ry �x�yr r r" ZmodalZmodelessZtrack_disk_spaceZfatalrB Z user_exitZ exit_dialogZinuse�errorr3 ZcostingZprepZseldlg�orderrw r� Zinstall_other_condZdont_install_other_condZcostZ
whichusers�gZprogressZmaintr r r r~ � sv ��
�� ��
�
�� �
�� �
� ���� � � �� �� ��
�
�� �
� � � ���� �
�
� ��� � �
� � zbdist_msi.add_uic C s< | j rd|| j| j f }nd|| jf }tj�| j|�}|S )Nz%s.%s-py%s.msiz %s.%s.msi)rK rI rT rU rV rL )r r� Z base_namer� r r r rq � s �z bdist_msi.get_installer_filenameN)r9 r: r; Z descriptionr Z user_optionsZboolean_optionsrZ r� rQ r] ro r| r{ r} r~ rq r r r r r= S s^ ��� �
�
([66& @r= )r< rk rT Zdistutils.corer Zdistutils.dir_utilr Zdistutils.sysconfigr Zdistutils.versionr Zdistutils.errorsr Zdistutils.utilr Z distutilsr rx r r
r r r
r r r r= r r r r �<module> s > __pycache__/install_lib.cpython-38.opt-2.pyc 0000644 00000010666 15051366007 0014654 0 ustar 00 U
e5d� � @ sH d dl Z d dlZd dlZd dlmZ d dlmZ dZG dd� de�Z dS )� N)�Command)�DistutilsOptionErrorz.pyc @ s� e Zd ZdZdddddddgZd d
d gZd d
iZd
d� Zdd� Zdd� Z dd� Z
dd� Z dd� Z dd� Z
dd � Zd d � Zd d � Zd!S )"� install_libz7install all Python modules (extensions and pure Python))z install-dir=�dzdirectory to install to)z
build-dir=�bz'build directory (where to install from))�force�fz-force installation (overwrite existing files))�compile�cz compile .py to .pyc [default])�
no-compileNzdon't compile .py files)z optimize=�Ozlalso compile with optimization: -O1 for "python -O", -O2 for "python -OO", and -O0 to disable [default: -O0])�
skip-buildNzskip the build stepsr r r
r c C s( d | _ d | _d| _d | _d | _d | _d S )Nr )� install_dir� build_dirr r �optimize�
skip_build��self� r �5/usr/lib64/python3.8/distutils/command/install_lib.py�initialize_options3 s z install_lib.initialize_optionsc C s� | � ddddddd� | jd kr&d| _| jd kr6d | _t| jt�s�z t| j�| _| jd
kr^t�W n ttfk
r� td ��Y nX d S ) N�install)� build_libr )r r )r r )r r )r r )r r TF)r � � zoptimize must be 0, 1, or 2)Zset_undefined_optionsr r �
isinstance�int�AssertionError�
ValueErrorr r r r r �finalize_options< s& �
z install_lib.finalize_optionsc C s0 | � � | �� }|d k r,| j�� r,| �|� d S �N)�buildr � distribution�has_pure_modules� byte_compile�r Zoutfilesr r r �runV s zinstall_lib.runc C s2 | j s.| j�� r| �d� | j�� r.| �d� d S �N�build_py� build_ext)r r" r# Z run_command�has_ext_modulesr r r r r! f s
zinstall_lib.buildc C s8 t j�| j�r | �| j| j�}n| �d| j � d S |S )Nz3'%s' does not exist -- no Python modules to install)�os�path�isdirr Z copy_treer �warnr% r r r r m s �zinstall_lib.installc C sr t jr| �d� d S ddlm} | �d�j}| jrH||d| j|| j d� | j
dkrn||| j
| j|| j | j d� d S )Nz%byte-compiling is disabled, skipping.r )r$ r )r r �prefix�dry_run)r r r/ �verboser0 ) �sys�dont_write_bytecoder. Zdistutils.utilr$ �get_finalized_command�rootr r r0 r r1 )r �filesr$ Z install_rootr r r r$ v s$
�
�zinstall_lib.byte_compilec
C sd |sg S | � |�}|�� }t||�}t|�ttj� }g }|D ] } |�tj�|| |d � �� q>|S r ) r4 � get_outputs�getattr�lenr+ �sep�appendr, �join)
r Zhas_anyZ build_cmdZ
cmd_optionZ
output_dirZ build_filesr �
prefix_lenZoutputs�filer r r �_mutate_outputs� s
zinstall_lib._mutate_outputsc C sr g }|D ]d}t j�t j�|��d }|tkr.q| jrJ|�tjj |dd�� | j
dkr|�tjj || j
d�� q|S )Nr � )� optimizationr ) r+ r, �splitext�normcase�PYTHON_SOURCE_EXTENSIONr r; � importlib�util�cache_from_sourcer )r Z py_filenamesZbytecode_filesZpy_fileZextr r r �_bytecode_filenames� s
�
�
z install_lib._bytecode_filenamesc C sR | � | j�� dd| j�}| jr*| �|�}ng }| � | j�� dd| j�}|| | S )Nr( r r) )r? r" r# r r rH r* )r Z pure_outputsZbytecode_outputsZ ext_outputsr r r r7 � s �� ��zinstall_lib.get_outputsc C sL g }| j �� r&| �d�}|�|�� � | j �� rH| �d�}|�|�� � |S r' )r" r# r4 �extendr7 r* )r Zinputsr( r) r r r �
get_inputs� s
zinstall_lib.get_inputsN)�__name__�
__module__� __qualname__Z descriptionZ user_optionsZboolean_optionsZ negative_optr r r& r! r r$ r? rH r7 rJ r r r r r s* �
r )
r+ �importlib.utilrE r2 Zdistutils.corer Zdistutils.errorsr rD r r r r r �<module> s __pycache__/__init__.cpython-38.pyc 0000644 00000001041 15051366007 0013142 0 ustar 00 U
e5d � @ s2 d Z ddddddddd d
d d d
ddddddgZdS )z\distutils.command
Package containing implementation of all the standard Distutils
commands.ZbuildZbuild_pyZ build_extZ
build_clibZ
build_scriptsZcleanZinstallZ install_libZinstall_headersZinstall_scriptsZ install_dataZsdist�registerZbdistZ
bdist_dumbZ bdist_rpmZ
bdist_wininstZcheckZuploadN)�__doc__�__all__� r r �2/usr/lib64/python3.8/distutils/command/__init__.py�<module> s( � install_headers.py 0000644 00000002422 15051366007 0010262 0 ustar 00 """distutils.command.install_headers
Implements the Distutils 'install_headers' command, to install C/C++ header
files to the Python include directory."""
from distutils.core import Command
# XXX force is never used
class install_headers(Command):
description = "install C/C++ header files"
user_options = [('install-dir=', 'd',
"directory to install header files to"),
('force', 'f',
"force installation (overwrite existing files)"),
]
boolean_options = ['force']
def initialize_options(self):
self.install_dir = None
self.force = 0
self.outfiles = []
def finalize_options(self):
self.set_undefined_options('install',
('install_headers', 'install_dir'),
('force', 'force'))
def run(self):
headers = self.distribution.headers
if not headers:
return
self.mkpath(self.install_dir)
for header in headers:
(out, _) = self.copy_file(header, self.install_dir)
self.outfiles.append(out)
def get_inputs(self):
return self.distribution.headers or []
def get_outputs(self):
return self.outfiles
config.py 0000644 00000031475 15051366007 0006400 0 ustar 00 """distutils.command.config
Implements the Distutils 'config' command, a (mostly) empty command class
that exists mainly to be sub-classed by specific module distributions and
applications. The idea is that while every "config" command is different,
at least they're all named the same, and users always see "config" in the
list of standard commands. Also, this is a good place to put common
configure-like tasks: "try to compile this C code", or "figure out where
this header file lives".
"""
import os, re
from distutils.core import Command
from distutils.errors import DistutilsExecError
from distutils.sysconfig import customize_compiler
from distutils import log
LANG_EXT = {"c": ".c", "c++": ".cxx"}
class config(Command):
description = "prepare to build"
user_options = [
('compiler=', None,
"specify the compiler type"),
('cc=', None,
"specify the compiler executable"),
('include-dirs=', 'I',
"list of directories to search for header files"),
('define=', 'D',
"C preprocessor macros to define"),
('undef=', 'U',
"C preprocessor macros to undefine"),
('libraries=', 'l',
"external C libraries to link with"),
('library-dirs=', 'L',
"directories to search for external C libraries"),
('noisy', None,
"show every action (compile, link, run, ...) taken"),
('dump-source', None,
"dump generated source files before attempting to compile them"),
]
# The three standard command methods: since the "config" command
# does nothing by default, these are empty.
def initialize_options(self):
self.compiler = None
self.cc = None
self.include_dirs = None
self.libraries = None
self.library_dirs = None
# maximal output for now
self.noisy = 1
self.dump_source = 1
# list of temporary files generated along-the-way that we have
# to clean at some point
self.temp_files = []
def finalize_options(self):
if self.include_dirs is None:
self.include_dirs = self.distribution.include_dirs or []
elif isinstance(self.include_dirs, str):
self.include_dirs = self.include_dirs.split(os.pathsep)
if self.libraries is None:
self.libraries = []
elif isinstance(self.libraries, str):
self.libraries = [self.libraries]
if self.library_dirs is None:
self.library_dirs = []
elif isinstance(self.library_dirs, str):
self.library_dirs = self.library_dirs.split(os.pathsep)
def run(self):
pass
# Utility methods for actual "config" commands. The interfaces are
# loosely based on Autoconf macros of similar names. Sub-classes
# may use these freely.
def _check_compiler(self):
"""Check that 'self.compiler' really is a CCompiler object;
if not, make it one.
"""
# We do this late, and only on-demand, because this is an expensive
# import.
from distutils.ccompiler import CCompiler, new_compiler
if not isinstance(self.compiler, CCompiler):
self.compiler = new_compiler(compiler=self.compiler,
dry_run=self.dry_run, force=1)
customize_compiler(self.compiler)
if self.include_dirs:
self.compiler.set_include_dirs(self.include_dirs)
if self.libraries:
self.compiler.set_libraries(self.libraries)
if self.library_dirs:
self.compiler.set_library_dirs(self.library_dirs)
def _gen_temp_sourcefile(self, body, headers, lang):
filename = "_configtest" + LANG_EXT[lang]
with open(filename, "w") as file:
if headers:
for header in headers:
file.write("#include <%s>\n" % header)
file.write("\n")
file.write(body)
if body[-1] != "\n":
file.write("\n")
return filename
def _preprocess(self, body, headers, include_dirs, lang):
src = self._gen_temp_sourcefile(body, headers, lang)
out = "_configtest.i"
self.temp_files.extend([src, out])
self.compiler.preprocess(src, out, include_dirs=include_dirs)
return (src, out)
def _compile(self, body, headers, include_dirs, lang):
src = self._gen_temp_sourcefile(body, headers, lang)
if self.dump_source:
dump_file(src, "compiling '%s':" % src)
(obj,) = self.compiler.object_filenames([src])
self.temp_files.extend([src, obj])
self.compiler.compile([src], include_dirs=include_dirs)
return (src, obj)
def _link(self, body, headers, include_dirs, libraries, library_dirs,
lang):
(src, obj) = self._compile(body, headers, include_dirs, lang)
prog = os.path.splitext(os.path.basename(src))[0]
self.compiler.link_executable([obj], prog,
libraries=libraries,
library_dirs=library_dirs,
target_lang=lang)
if self.compiler.exe_extension is not None:
prog = prog + self.compiler.exe_extension
self.temp_files.append(prog)
return (src, obj, prog)
def _clean(self, *filenames):
if not filenames:
filenames = self.temp_files
self.temp_files = []
log.info("removing: %s", ' '.join(filenames))
for filename in filenames:
try:
os.remove(filename)
except OSError:
pass
# XXX these ignore the dry-run flag: what to do, what to do? even if
# you want a dry-run build, you still need some sort of configuration
# info. My inclination is to make it up to the real config command to
# consult 'dry_run', and assume a default (minimal) configuration if
# true. The problem with trying to do it here is that you'd have to
# return either true or false from all the 'try' methods, neither of
# which is correct.
# XXX need access to the header search path and maybe default macros.
def try_cpp(self, body=None, headers=None, include_dirs=None, lang="c"):
"""Construct a source file from 'body' (a string containing lines
of C/C++ code) and 'headers' (a list of header files to include)
and run it through the preprocessor. Return true if the
preprocessor succeeded, false if there were any errors.
('body' probably isn't of much use, but what the heck.)
"""
from distutils.ccompiler import CompileError
self._check_compiler()
ok = True
try:
self._preprocess(body, headers, include_dirs, lang)
except CompileError:
ok = False
self._clean()
return ok
def search_cpp(self, pattern, body=None, headers=None, include_dirs=None,
lang="c"):
"""Construct a source file (just like 'try_cpp()'), run it through
the preprocessor, and return true if any line of the output matches
'pattern'. 'pattern' should either be a compiled regex object or a
string containing a regex. If both 'body' and 'headers' are None,
preprocesses an empty file -- which can be useful to determine the
symbols the preprocessor and compiler set by default.
"""
self._check_compiler()
src, out = self._preprocess(body, headers, include_dirs, lang)
if isinstance(pattern, str):
pattern = re.compile(pattern)
with open(out) as file:
match = False
while True:
line = file.readline()
if line == '':
break
if pattern.search(line):
match = True
break
self._clean()
return match
def try_compile(self, body, headers=None, include_dirs=None, lang="c"):
"""Try to compile a source file built from 'body' and 'headers'.
Return true on success, false otherwise.
"""
from distutils.ccompiler import CompileError
self._check_compiler()
try:
self._compile(body, headers, include_dirs, lang)
ok = True
except CompileError:
ok = False
log.info(ok and "success!" or "failure.")
self._clean()
return ok
def try_link(self, body, headers=None, include_dirs=None, libraries=None,
library_dirs=None, lang="c"):
"""Try to compile and link a source file, built from 'body' and
'headers', to executable form. Return true on success, false
otherwise.
"""
from distutils.ccompiler import CompileError, LinkError
self._check_compiler()
try:
self._link(body, headers, include_dirs,
libraries, library_dirs, lang)
ok = True
except (CompileError, LinkError):
ok = False
log.info(ok and "success!" or "failure.")
self._clean()
return ok
def try_run(self, body, headers=None, include_dirs=None, libraries=None,
library_dirs=None, lang="c"):
"""Try to compile, link to an executable, and run a program
built from 'body' and 'headers'. Return true on success, false
otherwise.
"""
from distutils.ccompiler import CompileError, LinkError
self._check_compiler()
try:
src, obj, exe = self._link(body, headers, include_dirs,
libraries, library_dirs, lang)
self.spawn([exe])
ok = True
except (CompileError, LinkError, DistutilsExecError):
ok = False
log.info(ok and "success!" or "failure.")
self._clean()
return ok
# -- High-level methods --------------------------------------------
# (these are the ones that are actually likely to be useful
# when implementing a real-world config command!)
def check_func(self, func, headers=None, include_dirs=None,
libraries=None, library_dirs=None, decl=0, call=0):
"""Determine if function 'func' is available by constructing a
source file that refers to 'func', and compiles and links it.
If everything succeeds, returns true; otherwise returns false.
The constructed source file starts out by including the header
files listed in 'headers'. If 'decl' is true, it then declares
'func' (as "int func()"); you probably shouldn't supply 'headers'
and set 'decl' true in the same call, or you might get errors about
a conflicting declarations for 'func'. Finally, the constructed
'main()' function either references 'func' or (if 'call' is true)
calls it. 'libraries' and 'library_dirs' are used when
linking.
"""
self._check_compiler()
body = []
if decl:
body.append("int %s ();" % func)
body.append("int main () {")
if call:
body.append(" %s();" % func)
else:
body.append(" %s;" % func)
body.append("}")
body = "\n".join(body) + "\n"
return self.try_link(body, headers, include_dirs,
libraries, library_dirs)
def check_lib(self, library, library_dirs=None, headers=None,
include_dirs=None, other_libraries=[]):
"""Determine if 'library' is available to be linked against,
without actually checking that any particular symbols are provided
by it. 'headers' will be used in constructing the source file to
be compiled, but the only effect of this is to check if all the
header files listed are available. Any libraries listed in
'other_libraries' will be included in the link, in case 'library'
has symbols that depend on other libraries.
"""
self._check_compiler()
return self.try_link("int main (void) { }", headers, include_dirs,
[library] + other_libraries, library_dirs)
def check_header(self, header, include_dirs=None, library_dirs=None,
lang="c"):
"""Determine if the system header file named by 'header_file'
exists and can be found by the preprocessor; return true if so,
false otherwise.
"""
return self.try_cpp(body="/* No body */", headers=[header],
include_dirs=include_dirs)
def dump_file(filename, head=None):
"""Dumps a file content into log.info.
If head is not None, will be dumped before the file content.
"""
if head is None:
log.info('%s', filename)
else:
log.info(head)
file = open(filename)
try:
log.info(file.read())
finally:
file.close()
sdist.py 0000644 00000045075 15051366007 0006262 0 ustar 00 """distutils.command.sdist
Implements the Distutils 'sdist' command (create a source distribution)."""
import os
import sys
from glob import glob
from warnings import warn
from distutils.core import Command
from distutils import dir_util
from distutils import file_util
from distutils import archive_util
from distutils.text_file import TextFile
from distutils.filelist import FileList
from distutils import log
from distutils.util import convert_path
from distutils.errors import DistutilsTemplateError, DistutilsOptionError
def show_formats():
"""Print all possible values for the 'formats' option (used by
the "--help-formats" command-line option).
"""
from distutils.fancy_getopt import FancyGetopt
from distutils.archive_util import ARCHIVE_FORMATS
formats = []
for format in ARCHIVE_FORMATS.keys():
formats.append(("formats=" + format, None,
ARCHIVE_FORMATS[format][2]))
formats.sort()
FancyGetopt(formats).print_help(
"List of available source distribution formats:")
class sdist(Command):
description = "create a source distribution (tarball, zip file, etc.)"
def checking_metadata(self):
"""Callable used for the check sub-command.
Placed here so user_options can view it"""
return self.metadata_check
user_options = [
('template=', 't',
"name of manifest template file [default: MANIFEST.in]"),
('manifest=', 'm',
"name of manifest file [default: MANIFEST]"),
('use-defaults', None,
"include the default file set in the manifest "
"[default; disable with --no-defaults]"),
('no-defaults', None,
"don't include the default file set"),
('prune', None,
"specifically exclude files/directories that should not be "
"distributed (build tree, RCS/CVS dirs, etc.) "
"[default; disable with --no-prune]"),
('no-prune', None,
"don't automatically exclude anything"),
('manifest-only', 'o',
"just regenerate the manifest and then stop "
"(implies --force-manifest)"),
('force-manifest', 'f',
"forcibly regenerate the manifest and carry on as usual. "
"Deprecated: now the manifest is always regenerated."),
('formats=', None,
"formats for source distribution (comma-separated list)"),
('keep-temp', 'k',
"keep the distribution tree around after creating " +
"archive file(s)"),
('dist-dir=', 'd',
"directory to put the source distribution archive(s) in "
"[default: dist]"),
('metadata-check', None,
"Ensure that all required elements of meta-data "
"are supplied. Warn if any missing. [default]"),
('owner=', 'u',
"Owner name used when creating a tar file [default: current user]"),
('group=', 'g',
"Group name used when creating a tar file [default: current group]"),
]
boolean_options = ['use-defaults', 'prune',
'manifest-only', 'force-manifest',
'keep-temp', 'metadata-check']
help_options = [
('help-formats', None,
"list available distribution formats", show_formats),
]
negative_opt = {'no-defaults': 'use-defaults',
'no-prune': 'prune' }
sub_commands = [('check', checking_metadata)]
READMES = ('README', 'README.txt', 'README.rst')
def initialize_options(self):
# 'template' and 'manifest' are, respectively, the names of
# the manifest template and manifest file.
self.template = None
self.manifest = None
# 'use_defaults': if true, we will include the default file set
# in the manifest
self.use_defaults = 1
self.prune = 1
self.manifest_only = 0
self.force_manifest = 0
self.formats = ['gztar']
self.keep_temp = 0
self.dist_dir = None
self.archive_files = None
self.metadata_check = 1
self.owner = None
self.group = None
def finalize_options(self):
if self.manifest is None:
self.manifest = "MANIFEST"
if self.template is None:
self.template = "MANIFEST.in"
self.ensure_string_list('formats')
bad_format = archive_util.check_archive_formats(self.formats)
if bad_format:
raise DistutilsOptionError(
"unknown archive format '%s'" % bad_format)
if self.dist_dir is None:
self.dist_dir = "dist"
def run(self):
# 'filelist' contains the list of files that will make up the
# manifest
self.filelist = FileList()
# Run sub commands
for cmd_name in self.get_sub_commands():
self.run_command(cmd_name)
# Do whatever it takes to get the list of files to process
# (process the manifest template, read an existing manifest,
# whatever). File list is accumulated in 'self.filelist'.
self.get_file_list()
# If user just wanted us to regenerate the manifest, stop now.
if self.manifest_only:
return
# Otherwise, go ahead and create the source distribution tarball,
# or zipfile, or whatever.
self.make_distribution()
def check_metadata(self):
"""Deprecated API."""
warn("distutils.command.sdist.check_metadata is deprecated, \
use the check command instead", PendingDeprecationWarning)
check = self.distribution.get_command_obj('check')
check.ensure_finalized()
check.run()
def get_file_list(self):
"""Figure out the list of files to include in the source
distribution, and put it in 'self.filelist'. This might involve
reading the manifest template (and writing the manifest), or just
reading the manifest, or just using the default file set -- it all
depends on the user's options.
"""
# new behavior when using a template:
# the file list is recalculated every time because
# even if MANIFEST.in or setup.py are not changed
# the user might have added some files in the tree that
# need to be included.
#
# This makes --force the default and only behavior with templates.
template_exists = os.path.isfile(self.template)
if not template_exists and self._manifest_is_not_generated():
self.read_manifest()
self.filelist.sort()
self.filelist.remove_duplicates()
return
if not template_exists:
self.warn(("manifest template '%s' does not exist " +
"(using default file list)") %
self.template)
self.filelist.findall()
if self.use_defaults:
self.add_defaults()
if template_exists:
self.read_template()
if self.prune:
self.prune_file_list()
self.filelist.sort()
self.filelist.remove_duplicates()
self.write_manifest()
def add_defaults(self):
"""Add all the default files to self.filelist:
- README or README.txt
- setup.py
- test/test*.py
- all pure Python modules mentioned in setup script
- all files pointed by package_data (build_py)
- all files defined in data_files.
- all files defined as scripts.
- all C sources listed as part of extensions or C libraries
in the setup script (doesn't catch C headers!)
Warns if (README or README.txt) or setup.py are missing; everything
else is optional.
"""
self._add_defaults_standards()
self._add_defaults_optional()
self._add_defaults_python()
self._add_defaults_data_files()
self._add_defaults_ext()
self._add_defaults_c_libs()
self._add_defaults_scripts()
@staticmethod
def _cs_path_exists(fspath):
"""
Case-sensitive path existence check
>>> sdist._cs_path_exists(__file__)
True
>>> sdist._cs_path_exists(__file__.upper())
False
"""
if not os.path.exists(fspath):
return False
# make absolute so we always have a directory
abspath = os.path.abspath(fspath)
directory, filename = os.path.split(abspath)
return filename in os.listdir(directory)
def _add_defaults_standards(self):
standards = [self.READMES, self.distribution.script_name]
for fn in standards:
if isinstance(fn, tuple):
alts = fn
got_it = False
for fn in alts:
if self._cs_path_exists(fn):
got_it = True
self.filelist.append(fn)
break
if not got_it:
self.warn("standard file not found: should have one of " +
', '.join(alts))
else:
if self._cs_path_exists(fn):
self.filelist.append(fn)
else:
self.warn("standard file '%s' not found" % fn)
def _add_defaults_optional(self):
optional = ['test/test*.py', 'setup.cfg']
for pattern in optional:
files = filter(os.path.isfile, glob(pattern))
self.filelist.extend(files)
def _add_defaults_python(self):
# build_py is used to get:
# - python modules
# - files defined in package_data
build_py = self.get_finalized_command('build_py')
# getting python files
if self.distribution.has_pure_modules():
self.filelist.extend(build_py.get_source_files())
# getting package_data files
# (computed in build_py.data_files by build_py.finalize_options)
for pkg, src_dir, build_dir, filenames in build_py.data_files:
for filename in filenames:
self.filelist.append(os.path.join(src_dir, filename))
def _add_defaults_data_files(self):
# getting distribution.data_files
if self.distribution.has_data_files():
for item in self.distribution.data_files:
if isinstance(item, str):
# plain file
item = convert_path(item)
if os.path.isfile(item):
self.filelist.append(item)
else:
# a (dirname, filenames) tuple
dirname, filenames = item
for f in filenames:
f = convert_path(f)
if os.path.isfile(f):
self.filelist.append(f)
def _add_defaults_ext(self):
if self.distribution.has_ext_modules():
build_ext = self.get_finalized_command('build_ext')
self.filelist.extend(build_ext.get_source_files())
def _add_defaults_c_libs(self):
if self.distribution.has_c_libraries():
build_clib = self.get_finalized_command('build_clib')
self.filelist.extend(build_clib.get_source_files())
def _add_defaults_scripts(self):
if self.distribution.has_scripts():
build_scripts = self.get_finalized_command('build_scripts')
self.filelist.extend(build_scripts.get_source_files())
def read_template(self):
"""Read and parse manifest template file named by self.template.
(usually "MANIFEST.in") The parsing and processing is done by
'self.filelist', which updates itself accordingly.
"""
log.info("reading manifest template '%s'", self.template)
template = TextFile(self.template, strip_comments=1, skip_blanks=1,
join_lines=1, lstrip_ws=1, rstrip_ws=1,
collapse_join=1)
try:
while True:
line = template.readline()
if line is None: # end of file
break
try:
self.filelist.process_template_line(line)
# the call above can raise a DistutilsTemplateError for
# malformed lines, or a ValueError from the lower-level
# convert_path function
except (DistutilsTemplateError, ValueError) as msg:
self.warn("%s, line %d: %s" % (template.filename,
template.current_line,
msg))
finally:
template.close()
def prune_file_list(self):
"""Prune off branches that might slip into the file list as created
by 'read_template()', but really don't belong there:
* the build tree (typically "build")
* the release tree itself (only an issue if we ran "sdist"
previously with --keep-temp, or it aborted)
* any RCS, CVS, .svn, .hg, .git, .bzr, _darcs directories
"""
build = self.get_finalized_command('build')
base_dir = self.distribution.get_fullname()
self.filelist.exclude_pattern(None, prefix=build.build_base)
self.filelist.exclude_pattern(None, prefix=base_dir)
if sys.platform == 'win32':
seps = r'/|\\'
else:
seps = '/'
vcs_dirs = ['RCS', 'CVS', r'\.svn', r'\.hg', r'\.git', r'\.bzr',
'_darcs']
vcs_ptrn = r'(^|%s)(%s)(%s).*' % (seps, '|'.join(vcs_dirs), seps)
self.filelist.exclude_pattern(vcs_ptrn, is_regex=1)
def write_manifest(self):
"""Write the file list in 'self.filelist' (presumably as filled in
by 'add_defaults()' and 'read_template()') to the manifest file
named by 'self.manifest'.
"""
if self._manifest_is_not_generated():
log.info("not writing to manually maintained "
"manifest file '%s'" % self.manifest)
return
content = self.filelist.files[:]
content.insert(0, '# file GENERATED by distutils, do NOT edit')
self.execute(file_util.write_file, (self.manifest, content),
"writing manifest file '%s'" % self.manifest)
def _manifest_is_not_generated(self):
# check for special comment used in 3.1.3 and higher
if not os.path.isfile(self.manifest):
return False
fp = open(self.manifest)
try:
first_line = fp.readline()
finally:
fp.close()
return first_line != '# file GENERATED by distutils, do NOT edit\n'
def read_manifest(self):
"""Read the manifest file (named by 'self.manifest') and use it to
fill in 'self.filelist', the list of files to include in the source
distribution.
"""
log.info("reading manifest file '%s'", self.manifest)
with open(self.manifest) as manifest:
for line in manifest:
# ignore comments and blank lines
line = line.strip()
if line.startswith('#') or not line:
continue
self.filelist.append(line)
def make_release_tree(self, base_dir, files):
"""Create the directory tree that will become the source
distribution archive. All directories implied by the filenames in
'files' are created under 'base_dir', and then we hard link or copy
(if hard linking is unavailable) those files into place.
Essentially, this duplicates the developer's source tree, but in a
directory named after the distribution, containing only the files
to be distributed.
"""
# Create all the directories under 'base_dir' necessary to
# put 'files' there; the 'mkpath()' is just so we don't die
# if the manifest happens to be empty.
self.mkpath(base_dir)
dir_util.create_tree(base_dir, files, dry_run=self.dry_run)
# And walk over the list of files, either making a hard link (if
# os.link exists) to each one that doesn't already exist in its
# corresponding location under 'base_dir', or copying each file
# that's out-of-date in 'base_dir'. (Usually, all files will be
# out-of-date, because by default we blow away 'base_dir' when
# we're done making the distribution archives.)
if hasattr(os, 'link'): # can make hard links on this system
link = 'hard'
msg = "making hard links in %s..." % base_dir
else: # nope, have to copy
link = None
msg = "copying files to %s..." % base_dir
if not files:
log.warn("no files to distribute -- empty manifest?")
else:
log.info(msg)
for file in files:
if not os.path.isfile(file):
log.warn("'%s' not a regular file -- skipping", file)
else:
dest = os.path.join(base_dir, file)
self.copy_file(file, dest, link=link)
self.distribution.metadata.write_pkg_info(base_dir)
def make_distribution(self):
"""Create the source distribution(s). First, we create the release
tree with 'make_release_tree()'; then, we create all required
archive files (according to 'self.formats') from the release tree.
Finally, we clean up by blowing away the release tree (unless
'self.keep_temp' is true). The list of archive files created is
stored so it can be retrieved later by 'get_archive_files()'.
"""
# Don't warn about missing meta-data here -- should be (and is!)
# done elsewhere.
base_dir = self.distribution.get_fullname()
base_name = os.path.join(self.dist_dir, base_dir)
self.make_release_tree(base_dir, self.filelist.files)
archive_files = [] # remember names of files we create
# tar archive must be created last to avoid overwrite and remove
if 'tar' in self.formats:
self.formats.append(self.formats.pop(self.formats.index('tar')))
for fmt in self.formats:
file = self.make_archive(base_name, fmt, base_dir=base_dir,
owner=self.owner, group=self.group)
archive_files.append(file)
self.distribution.dist_files.append(('sdist', '', file))
self.archive_files = archive_files
if not self.keep_temp:
dir_util.remove_tree(base_dir, dry_run=self.dry_run)
def get_archive_files(self):
"""Return the list of archive files created when the command
was run, or None if the command hasn't run yet.
"""
return self.archive_files
build_py.py 0000644 00000041446 15051366007 0006741 0 ustar 00 """distutils.command.build_py
Implements the Distutils 'build_py' command."""
import os
import importlib.util
import sys
import glob
from distutils.core import Command
from distutils.errors import *
from distutils.util import convert_path, Mixin2to3
from distutils import log
class build_py (Command):
description = "\"build\" pure Python modules (copy to build directory)"
user_options = [
('build-lib=', 'd', "directory to \"build\" (copy) to"),
('compile', 'c', "compile .py to .pyc"),
('no-compile', None, "don't compile .py files [default]"),
('optimize=', 'O',
"also compile with optimization: -O1 for \"python -O\", "
"-O2 for \"python -OO\", and -O0 to disable [default: -O0]"),
('force', 'f', "forcibly build everything (ignore file timestamps)"),
]
boolean_options = ['compile', 'force']
negative_opt = {'no-compile' : 'compile'}
def initialize_options(self):
self.build_lib = None
self.py_modules = None
self.package = None
self.package_data = None
self.package_dir = None
self.compile = 0
self.optimize = 0
self.force = None
def finalize_options(self):
self.set_undefined_options('build',
('build_lib', 'build_lib'),
('force', 'force'))
# Get the distribution options that are aliases for build_py
# options -- list of packages and list of modules.
self.packages = self.distribution.packages
self.py_modules = self.distribution.py_modules
self.package_data = self.distribution.package_data
self.package_dir = {}
if self.distribution.package_dir:
for name, path in self.distribution.package_dir.items():
self.package_dir[name] = convert_path(path)
self.data_files = self.get_data_files()
# Ick, copied straight from install_lib.py (fancy_getopt needs a
# type system! Hell, *everything* needs a type system!!!)
if not isinstance(self.optimize, int):
try:
self.optimize = int(self.optimize)
assert 0 <= self.optimize <= 2
except (ValueError, AssertionError):
raise DistutilsOptionError("optimize must be 0, 1, or 2")
def run(self):
# XXX copy_file by default preserves atime and mtime. IMHO this is
# the right thing to do, but perhaps it should be an option -- in
# particular, a site administrator might want installed files to
# reflect the time of installation rather than the last
# modification time before the installed release.
# XXX copy_file by default preserves mode, which appears to be the
# wrong thing to do: if a file is read-only in the working
# directory, we want it to be installed read/write so that the next
# installation of the same module distribution can overwrite it
# without problems. (This might be a Unix-specific issue.) Thus
# we turn off 'preserve_mode' when copying to the build directory,
# since the build directory is supposed to be exactly what the
# installation will look like (ie. we preserve mode when
# installing).
# Two options control which modules will be installed: 'packages'
# and 'py_modules'. The former lets us work with whole packages, not
# specifying individual modules at all; the latter is for
# specifying modules one-at-a-time.
if self.py_modules:
self.build_modules()
if self.packages:
self.build_packages()
self.build_package_data()
self.byte_compile(self.get_outputs(include_bytecode=0))
def get_data_files(self):
"""Generate list of '(package,src_dir,build_dir,filenames)' tuples"""
data = []
if not self.packages:
return data
for package in self.packages:
# Locate package source directory
src_dir = self.get_package_dir(package)
# Compute package build directory
build_dir = os.path.join(*([self.build_lib] + package.split('.')))
# Length of path to strip from found files
plen = 0
if src_dir:
plen = len(src_dir)+1
# Strip directory from globbed filenames
filenames = [
file[plen:] for file in self.find_data_files(package, src_dir)
]
data.append((package, src_dir, build_dir, filenames))
return data
def find_data_files(self, package, src_dir):
"""Return filenames for package's data files in 'src_dir'"""
globs = (self.package_data.get('', [])
+ self.package_data.get(package, []))
files = []
for pattern in globs:
# Each pattern has to be converted to a platform-specific path
filelist = glob.glob(os.path.join(glob.escape(src_dir), convert_path(pattern)))
# Files that match more than one pattern are only added once
files.extend([fn for fn in filelist if fn not in files
and os.path.isfile(fn)])
return files
def build_package_data(self):
"""Copy data files into build directory"""
lastdir = None
for package, src_dir, build_dir, filenames in self.data_files:
for filename in filenames:
target = os.path.join(build_dir, filename)
self.mkpath(os.path.dirname(target))
self.copy_file(os.path.join(src_dir, filename), target,
preserve_mode=False)
def get_package_dir(self, package):
"""Return the directory, relative to the top of the source
distribution, where package 'package' should be found
(at least according to the 'package_dir' option, if any)."""
path = package.split('.')
if not self.package_dir:
if path:
return os.path.join(*path)
else:
return ''
else:
tail = []
while path:
try:
pdir = self.package_dir['.'.join(path)]
except KeyError:
tail.insert(0, path[-1])
del path[-1]
else:
tail.insert(0, pdir)
return os.path.join(*tail)
else:
# Oops, got all the way through 'path' without finding a
# match in package_dir. If package_dir defines a directory
# for the root (nameless) package, then fallback on it;
# otherwise, we might as well have not consulted
# package_dir at all, as we just use the directory implied
# by 'tail' (which should be the same as the original value
# of 'path' at this point).
pdir = self.package_dir.get('')
if pdir is not None:
tail.insert(0, pdir)
if tail:
return os.path.join(*tail)
else:
return ''
def check_package(self, package, package_dir):
# Empty dir name means current directory, which we can probably
# assume exists. Also, os.path.exists and isdir don't know about
# my "empty string means current dir" convention, so we have to
# circumvent them.
if package_dir != "":
if not os.path.exists(package_dir):
raise DistutilsFileError(
"package directory '%s' does not exist" % package_dir)
if not os.path.isdir(package_dir):
raise DistutilsFileError(
"supposed package directory '%s' exists, "
"but is not a directory" % package_dir)
# Require __init__.py for all but the "root package"
if package:
init_py = os.path.join(package_dir, "__init__.py")
if os.path.isfile(init_py):
return init_py
else:
log.warn(("package init file '%s' not found " +
"(or not a regular file)"), init_py)
# Either not in a package at all (__init__.py not expected), or
# __init__.py doesn't exist -- so don't return the filename.
return None
def check_module(self, module, module_file):
if not os.path.isfile(module_file):
log.warn("file %s (for module %s) not found", module_file, module)
return False
else:
return True
def find_package_modules(self, package, package_dir):
self.check_package(package, package_dir)
module_files = glob.glob(os.path.join(glob.escape(package_dir), "*.py"))
modules = []
setup_script = os.path.abspath(self.distribution.script_name)
for f in module_files:
abs_f = os.path.abspath(f)
if abs_f != setup_script:
module = os.path.splitext(os.path.basename(f))[0]
modules.append((package, module, f))
else:
self.debug_print("excluding %s" % setup_script)
return modules
def find_modules(self):
"""Finds individually-specified Python modules, ie. those listed by
module name in 'self.py_modules'. Returns a list of tuples (package,
module_base, filename): 'package' is a tuple of the path through
package-space to the module; 'module_base' is the bare (no
packages, no dots) module name, and 'filename' is the path to the
".py" file (relative to the distribution root) that implements the
module.
"""
# Map package names to tuples of useful info about the package:
# (package_dir, checked)
# package_dir - the directory where we'll find source files for
# this package
# checked - true if we have checked that the package directory
# is valid (exists, contains __init__.py, ... ?)
packages = {}
# List of (package, module, filename) tuples to return
modules = []
# We treat modules-in-packages almost the same as toplevel modules,
# just the "package" for a toplevel is empty (either an empty
# string or empty list, depending on context). Differences:
# - don't check for __init__.py in directory for empty package
for module in self.py_modules:
path = module.split('.')
package = '.'.join(path[0:-1])
module_base = path[-1]
try:
(package_dir, checked) = packages[package]
except KeyError:
package_dir = self.get_package_dir(package)
checked = 0
if not checked:
init_py = self.check_package(package, package_dir)
packages[package] = (package_dir, 1)
if init_py:
modules.append((package, "__init__", init_py))
# XXX perhaps we should also check for just .pyc files
# (so greedy closed-source bastards can distribute Python
# modules too)
module_file = os.path.join(package_dir, module_base + ".py")
if not self.check_module(module, module_file):
continue
modules.append((package, module_base, module_file))
return modules
def find_all_modules(self):
"""Compute the list of all modules that will be built, whether
they are specified one-module-at-a-time ('self.py_modules') or
by whole packages ('self.packages'). Return a list of tuples
(package, module, module_file), just like 'find_modules()' and
'find_package_modules()' do."""
modules = []
if self.py_modules:
modules.extend(self.find_modules())
if self.packages:
for package in self.packages:
package_dir = self.get_package_dir(package)
m = self.find_package_modules(package, package_dir)
modules.extend(m)
return modules
def get_source_files(self):
return [module[-1] for module in self.find_all_modules()]
def get_module_outfile(self, build_dir, package, module):
outfile_path = [build_dir] + list(package) + [module + ".py"]
return os.path.join(*outfile_path)
def get_outputs(self, include_bytecode=1):
modules = self.find_all_modules()
outputs = []
for (package, module, module_file) in modules:
package = package.split('.')
filename = self.get_module_outfile(self.build_lib, package, module)
outputs.append(filename)
if include_bytecode:
if self.compile:
outputs.append(importlib.util.cache_from_source(
filename, optimization=''))
if self.optimize > 0:
outputs.append(importlib.util.cache_from_source(
filename, optimization=self.optimize))
outputs += [
os.path.join(build_dir, filename)
for package, src_dir, build_dir, filenames in self.data_files
for filename in filenames
]
return outputs
def build_module(self, module, module_file, package):
if isinstance(package, str):
package = package.split('.')
elif not isinstance(package, (list, tuple)):
raise TypeError(
"'package' must be a string (dot-separated), list, or tuple")
# Now put the module source file into the "build" area -- this is
# easy, we just copy it somewhere under self.build_lib (the build
# directory for Python source).
outfile = self.get_module_outfile(self.build_lib, package, module)
dir = os.path.dirname(outfile)
self.mkpath(dir)
return self.copy_file(module_file, outfile, preserve_mode=0)
def build_modules(self):
modules = self.find_modules()
for (package, module, module_file) in modules:
# Now "build" the module -- ie. copy the source file to
# self.build_lib (the build directory for Python source).
# (Actually, it gets copied to the directory for this package
# under self.build_lib.)
self.build_module(module, module_file, package)
def build_packages(self):
for package in self.packages:
# Get list of (package, module, module_file) tuples based on
# scanning the package directory. 'package' is only included
# in the tuple so that 'find_modules()' and
# 'find_package_tuples()' have a consistent interface; it's
# ignored here (apart from a sanity check). Also, 'module' is
# the *unqualified* module name (ie. no dots, no package -- we
# already know its package!), and 'module_file' is the path to
# the .py file, relative to the current directory
# (ie. including 'package_dir').
package_dir = self.get_package_dir(package)
modules = self.find_package_modules(package, package_dir)
# Now loop over the modules we found, "building" each one (just
# copy it to self.build_lib).
for (package_, module, module_file) in modules:
assert package == package_
self.build_module(module, module_file, package)
def byte_compile(self, files):
if sys.dont_write_bytecode:
self.warn('byte-compiling is disabled, skipping.')
return
from distutils.util import byte_compile
prefix = self.build_lib
if prefix[-1] != os.sep:
prefix = prefix + os.sep
# XXX this code is essentially the same as the 'byte_compile()
# method of the "install_lib" command, except for the determination
# of the 'prefix' string. Hmmm.
if self.compile:
byte_compile(files, optimize=0,
force=self.force, prefix=prefix, dry_run=self.dry_run)
if self.optimize > 0:
byte_compile(files, optimize=self.optimize,
force=self.force, prefix=prefix, dry_run=self.dry_run)
class build_py_2to3(build_py, Mixin2to3):
def run(self):
self.updated_files = []
# Base class code
if self.py_modules:
self.build_modules()
if self.packages:
self.build_packages()
self.build_package_data()
# 2to3
self.run_2to3(self.updated_files)
# Remaining base class code
self.byte_compile(self.get_outputs(include_bytecode=0))
def build_module(self, module, module_file, package):
res = build_py.build_module(self, module, module_file, package)
if res[1]:
# file was copied
self.updated_files.append(res[0])
return res
build_ext.py 0000644 00000075520 15051366010 0007103 0 ustar 00 """distutils.command.build_ext
Implements the Distutils 'build_ext' command, for building extension
modules (currently limited to C extensions, should accommodate C++
extensions ASAP)."""
import contextlib
import os
import re
import sys
from distutils.core import Command
from distutils.errors import *
from distutils.sysconfig import customize_compiler, get_python_version
from distutils.sysconfig import get_config_h_filename
from distutils.dep_util import newer_group
from distutils.extension import Extension
from distutils.util import get_platform
from distutils import log
from site import USER_BASE
# An extension name is just a dot-separated list of Python NAMEs (ie.
# the same as a fully-qualified module name).
extension_name_re = re.compile \
(r'^[a-zA-Z_][a-zA-Z_0-9]*(\.[a-zA-Z_][a-zA-Z_0-9]*)*$')
def show_compilers ():
from distutils.ccompiler import show_compilers
show_compilers()
class build_ext(Command):
description = "build C/C++ extensions (compile/link to build directory)"
# XXX thoughts on how to deal with complex command-line options like
# these, i.e. how to make it so fancy_getopt can suck them off the
# command line and make it look like setup.py defined the appropriate
# lists of tuples of what-have-you.
# - each command needs a callback to process its command-line options
# - Command.__init__() needs access to its share of the whole
# command line (must ultimately come from
# Distribution.parse_command_line())
# - it then calls the current command class' option-parsing
# callback to deal with weird options like -D, which have to
# parse the option text and churn out some custom data
# structure
# - that data structure (in this case, a list of 2-tuples)
# will then be present in the command object by the time
# we get to finalize_options() (i.e. the constructor
# takes care of both command-line and client options
# in between initialize_options() and finalize_options())
sep_by = " (separated by '%s')" % os.pathsep
user_options = [
('build-lib=', 'b',
"directory for compiled extension modules"),
('build-temp=', 't',
"directory for temporary files (build by-products)"),
('plat-name=', 'p',
"platform name to cross-compile for, if supported "
"(default: %s)" % get_platform()),
('inplace', 'i',
"ignore build-lib and put compiled extensions into the source " +
"directory alongside your pure Python modules"),
('include-dirs=', 'I',
"list of directories to search for header files" + sep_by),
('define=', 'D',
"C preprocessor macros to define"),
('undef=', 'U',
"C preprocessor macros to undefine"),
('libraries=', 'l',
"external C libraries to link with"),
('library-dirs=', 'L',
"directories to search for external C libraries" + sep_by),
('rpath=', 'R',
"directories to search for shared C libraries at runtime"),
('link-objects=', 'O',
"extra explicit link objects to include in the link"),
('debug', 'g',
"compile/link with debugging information"),
('force', 'f',
"forcibly build everything (ignore file timestamps)"),
('compiler=', 'c',
"specify the compiler type"),
('parallel=', 'j',
"number of parallel build jobs"),
('swig-cpp', None,
"make SWIG create C++ files (default is C)"),
('swig-opts=', None,
"list of SWIG command line options"),
('swig=', None,
"path to the SWIG executable"),
('user', None,
"add user include, library and rpath")
]
boolean_options = ['inplace', 'debug', 'force', 'swig-cpp', 'user']
help_options = [
('help-compiler', None,
"list available compilers", show_compilers),
]
def initialize_options(self):
self.extensions = None
self.build_lib = None
self.plat_name = None
self.build_temp = None
self.inplace = 0
self.package = None
self.include_dirs = None
self.define = None
self.undef = None
self.libraries = None
self.library_dirs = None
self.rpath = None
self.link_objects = None
self.debug = None
self.force = None
self.compiler = None
self.swig = None
self.swig_cpp = None
self.swig_opts = None
self.user = None
self.parallel = None
def finalize_options(self):
from distutils import sysconfig
self.set_undefined_options('build',
('build_lib', 'build_lib'),
('build_temp', 'build_temp'),
('compiler', 'compiler'),
('debug', 'debug'),
('force', 'force'),
('parallel', 'parallel'),
('plat_name', 'plat_name'),
)
if self.package is None:
self.package = self.distribution.ext_package
self.extensions = self.distribution.ext_modules
# Make sure Python's include directories (for Python.h, pyconfig.h,
# etc.) are in the include search path.
py_include = sysconfig.get_python_inc()
plat_py_include = sysconfig.get_python_inc(plat_specific=1)
if self.include_dirs is None:
self.include_dirs = self.distribution.include_dirs or []
if isinstance(self.include_dirs, str):
self.include_dirs = self.include_dirs.split(os.pathsep)
# If in a virtualenv, add its include directory
# Issue 16116
if sys.exec_prefix != sys.base_exec_prefix:
self.include_dirs.append(os.path.join(sys.exec_prefix, 'include'))
# Put the Python "system" include dir at the end, so that
# any local include dirs take precedence.
self.include_dirs.extend(py_include.split(os.path.pathsep))
if plat_py_include != py_include:
self.include_dirs.extend(
plat_py_include.split(os.path.pathsep))
self.ensure_string_list('libraries')
self.ensure_string_list('link_objects')
# Life is easier if we're not forever checking for None, so
# simplify these options to empty lists if unset
if self.libraries is None:
self.libraries = []
if self.library_dirs is None:
self.library_dirs = []
elif isinstance(self.library_dirs, str):
self.library_dirs = self.library_dirs.split(os.pathsep)
if self.rpath is None:
self.rpath = []
elif isinstance(self.rpath, str):
self.rpath = self.rpath.split(os.pathsep)
# for extensions under windows use different directories
# for Release and Debug builds.
# also Python's library directory must be appended to library_dirs
if os.name == 'nt':
# the 'libs' directory is for binary installs - we assume that
# must be the *native* platform. But we don't really support
# cross-compiling via a binary install anyway, so we let it go.
self.library_dirs.append(os.path.join(sys.exec_prefix, 'libs'))
if sys.base_exec_prefix != sys.prefix: # Issue 16116
self.library_dirs.append(os.path.join(sys.base_exec_prefix, 'libs'))
if self.debug:
self.build_temp = os.path.join(self.build_temp, "Debug")
else:
self.build_temp = os.path.join(self.build_temp, "Release")
# Append the source distribution include and library directories,
# this allows distutils on windows to work in the source tree
self.include_dirs.append(os.path.dirname(get_config_h_filename()))
_sys_home = getattr(sys, '_home', None)
if _sys_home:
self.library_dirs.append(_sys_home)
# Use the .lib files for the correct architecture
if self.plat_name == 'win32':
suffix = 'win32'
else:
# win-amd64
suffix = self.plat_name[4:]
new_lib = os.path.join(sys.exec_prefix, 'PCbuild')
if suffix:
new_lib = os.path.join(new_lib, suffix)
self.library_dirs.append(new_lib)
# For extensions under Cygwin, Python's library directory must be
# appended to library_dirs
if sys.platform[:6] == 'cygwin':
if sys.executable.startswith(os.path.join(sys.exec_prefix, "bin")):
# building third party extensions
self.library_dirs.append(os.path.join(sys.prefix, "lib",
"python" + get_python_version(),
"config"))
else:
# building python standard extensions
self.library_dirs.append('.')
# For building extensions with a shared Python library,
# Python's library directory must be appended to library_dirs
# See Issues: #1600860, #4366
if (sysconfig.get_config_var('Py_ENABLE_SHARED')):
if not sysconfig.python_build:
# building third party extensions
self.library_dirs.append(sysconfig.get_config_var('LIBDIR'))
else:
# building python standard extensions
self.library_dirs.append('.')
# The argument parsing will result in self.define being a string, but
# it has to be a list of 2-tuples. All the preprocessor symbols
# specified by the 'define' option will be set to '1'. Multiple
# symbols can be separated with commas.
if self.define:
defines = self.define.split(',')
self.define = [(symbol, '1') for symbol in defines]
# The option for macros to undefine is also a string from the
# option parsing, but has to be a list. Multiple symbols can also
# be separated with commas here.
if self.undef:
self.undef = self.undef.split(',')
if self.swig_opts is None:
self.swig_opts = []
else:
self.swig_opts = self.swig_opts.split(' ')
# Finally add the user include and library directories if requested
if self.user:
user_include = os.path.join(USER_BASE, "include")
user_lib = os.path.join(USER_BASE, "lib")
if os.path.isdir(user_include):
self.include_dirs.append(user_include)
if os.path.isdir(user_lib):
self.library_dirs.append(user_lib)
self.rpath.append(user_lib)
if isinstance(self.parallel, str):
try:
self.parallel = int(self.parallel)
except ValueError:
raise DistutilsOptionError("parallel should be an integer")
def run(self):
from distutils.ccompiler import new_compiler
# 'self.extensions', as supplied by setup.py, is a list of
# Extension instances. See the documentation for Extension (in
# distutils.extension) for details.
#
# For backwards compatibility with Distutils 0.8.2 and earlier, we
# also allow the 'extensions' list to be a list of tuples:
# (ext_name, build_info)
# where build_info is a dictionary containing everything that
# Extension instances do except the name, with a few things being
# differently named. We convert these 2-tuples to Extension
# instances as needed.
if not self.extensions:
return
# If we were asked to build any C/C++ libraries, make sure that the
# directory where we put them is in the library search path for
# linking extensions.
if self.distribution.has_c_libraries():
build_clib = self.get_finalized_command('build_clib')
self.libraries.extend(build_clib.get_library_names() or [])
self.library_dirs.append(build_clib.build_clib)
# Setup the CCompiler object that we'll use to do all the
# compiling and linking
self.compiler = new_compiler(compiler=self.compiler,
verbose=self.verbose,
dry_run=self.dry_run,
force=self.force)
customize_compiler(self.compiler)
# If we are cross-compiling, init the compiler now (if we are not
# cross-compiling, init would not hurt, but people may rely on
# late initialization of compiler even if they shouldn't...)
if os.name == 'nt' and self.plat_name != get_platform():
self.compiler.initialize(self.plat_name)
# And make sure that any compile/link-related options (which might
# come from the command-line or from the setup script) are set in
# that CCompiler object -- that way, they automatically apply to
# all compiling and linking done here.
if self.include_dirs is not None:
self.compiler.set_include_dirs(self.include_dirs)
if self.define is not None:
# 'define' option is a list of (name,value) tuples
for (name, value) in self.define:
self.compiler.define_macro(name, value)
if self.undef is not None:
for macro in self.undef:
self.compiler.undefine_macro(macro)
if self.libraries is not None:
self.compiler.set_libraries(self.libraries)
if self.library_dirs is not None:
self.compiler.set_library_dirs(self.library_dirs)
if self.rpath is not None:
self.compiler.set_runtime_library_dirs(self.rpath)
if self.link_objects is not None:
self.compiler.set_link_objects(self.link_objects)
# Now actually compile and link everything.
self.build_extensions()
def check_extensions_list(self, extensions):
"""Ensure that the list of extensions (presumably provided as a
command option 'extensions') is valid, i.e. it is a list of
Extension objects. We also support the old-style list of 2-tuples,
where the tuples are (ext_name, build_info), which are converted to
Extension instances here.
Raise DistutilsSetupError if the structure is invalid anywhere;
just returns otherwise.
"""
if not isinstance(extensions, list):
raise DistutilsSetupError(
"'ext_modules' option must be a list of Extension instances")
for i, ext in enumerate(extensions):
if isinstance(ext, Extension):
continue # OK! (assume type-checking done
# by Extension constructor)
if not isinstance(ext, tuple) or len(ext) != 2:
raise DistutilsSetupError(
"each element of 'ext_modules' option must be an "
"Extension instance or 2-tuple")
ext_name, build_info = ext
log.warn("old-style (ext_name, build_info) tuple found in "
"ext_modules for extension '%s' "
"-- please convert to Extension instance", ext_name)
if not (isinstance(ext_name, str) and
extension_name_re.match(ext_name)):
raise DistutilsSetupError(
"first element of each tuple in 'ext_modules' "
"must be the extension name (a string)")
if not isinstance(build_info, dict):
raise DistutilsSetupError(
"second element of each tuple in 'ext_modules' "
"must be a dictionary (build info)")
# OK, the (ext_name, build_info) dict is type-safe: convert it
# to an Extension instance.
ext = Extension(ext_name, build_info['sources'])
# Easy stuff: one-to-one mapping from dict elements to
# instance attributes.
for key in ('include_dirs', 'library_dirs', 'libraries',
'extra_objects', 'extra_compile_args',
'extra_link_args'):
val = build_info.get(key)
if val is not None:
setattr(ext, key, val)
# Medium-easy stuff: same syntax/semantics, different names.
ext.runtime_library_dirs = build_info.get('rpath')
if 'def_file' in build_info:
log.warn("'def_file' element of build info dict "
"no longer supported")
# Non-trivial stuff: 'macros' split into 'define_macros'
# and 'undef_macros'.
macros = build_info.get('macros')
if macros:
ext.define_macros = []
ext.undef_macros = []
for macro in macros:
if not (isinstance(macro, tuple) and len(macro) in (1, 2)):
raise DistutilsSetupError(
"'macros' element of build info dict "
"must be 1- or 2-tuple")
if len(macro) == 1:
ext.undef_macros.append(macro[0])
elif len(macro) == 2:
ext.define_macros.append(macro)
extensions[i] = ext
def get_source_files(self):
self.check_extensions_list(self.extensions)
filenames = []
# Wouldn't it be neat if we knew the names of header files too...
for ext in self.extensions:
filenames.extend(ext.sources)
return filenames
def get_outputs(self):
# Sanity check the 'extensions' list -- can't assume this is being
# done in the same run as a 'build_extensions()' call (in fact, we
# can probably assume that it *isn't*!).
self.check_extensions_list(self.extensions)
# And build the list of output (built) filenames. Note that this
# ignores the 'inplace' flag, and assumes everything goes in the
# "build" tree.
outputs = []
for ext in self.extensions:
outputs.append(self.get_ext_fullpath(ext.name))
return outputs
def build_extensions(self):
# First, sanity-check the 'extensions' list
self.check_extensions_list(self.extensions)
if self.parallel:
self._build_extensions_parallel()
else:
self._build_extensions_serial()
def _build_extensions_parallel(self):
workers = self.parallel
if self.parallel is True:
workers = os.cpu_count() # may return None
try:
from concurrent.futures import ThreadPoolExecutor
except ImportError:
workers = None
if workers is None:
self._build_extensions_serial()
return
with ThreadPoolExecutor(max_workers=workers) as executor:
futures = [executor.submit(self.build_extension, ext)
for ext in self.extensions]
for ext, fut in zip(self.extensions, futures):
with self._filter_build_errors(ext):
fut.result()
def _build_extensions_serial(self):
for ext in self.extensions:
with self._filter_build_errors(ext):
self.build_extension(ext)
@contextlib.contextmanager
def _filter_build_errors(self, ext):
try:
yield
except (CCompilerError, DistutilsError, CompileError) as e:
if not ext.optional:
raise
self.warn('building extension "%s" failed: %s' %
(ext.name, e))
def build_extension(self, ext):
sources = ext.sources
if sources is None or not isinstance(sources, (list, tuple)):
raise DistutilsSetupError(
"in 'ext_modules' option (extension '%s'), "
"'sources' must be present and must be "
"a list of source filenames" % ext.name)
sources = list(sources)
ext_path = self.get_ext_fullpath(ext.name)
depends = sources + ext.depends
if not (self.force or newer_group(depends, ext_path, 'newer')):
log.debug("skipping '%s' extension (up-to-date)", ext.name)
return
else:
log.info("building '%s' extension", ext.name)
# First, scan the sources for SWIG definition files (.i), run
# SWIG on 'em to create .c files, and modify the sources list
# accordingly.
sources = self.swig_sources(sources, ext)
# Next, compile the source code to object files.
# XXX not honouring 'define_macros' or 'undef_macros' -- the
# CCompiler API needs to change to accommodate this, and I
# want to do one thing at a time!
# Two possible sources for extra compiler arguments:
# - 'extra_compile_args' in Extension object
# - CFLAGS environment variable (not particularly
# elegant, but people seem to expect it and I
# guess it's useful)
# The environment variable should take precedence, and
# any sensible compiler will give precedence to later
# command line args. Hence we combine them in order:
extra_args = ext.extra_compile_args or []
macros = ext.define_macros[:]
for undef in ext.undef_macros:
macros.append((undef,))
objects = self.compiler.compile(sources,
output_dir=self.build_temp,
macros=macros,
include_dirs=ext.include_dirs,
debug=self.debug,
extra_postargs=extra_args,
depends=ext.depends)
# XXX outdated variable, kept here in case third-part code
# needs it.
self._built_objects = objects[:]
# Now link the object files together into a "shared object" --
# of course, first we have to figure out all the other things
# that go into the mix.
if ext.extra_objects:
objects.extend(ext.extra_objects)
extra_args = ext.extra_link_args or []
# Detect target language, if not provided
language = ext.language or self.compiler.detect_language(sources)
self.compiler.link_shared_object(
objects, ext_path,
libraries=self.get_libraries(ext),
library_dirs=ext.library_dirs,
runtime_library_dirs=ext.runtime_library_dirs,
extra_postargs=extra_args,
export_symbols=self.get_export_symbols(ext),
debug=self.debug,
build_temp=self.build_temp,
target_lang=language)
def swig_sources(self, sources, extension):
"""Walk the list of source files in 'sources', looking for SWIG
interface (.i) files. Run SWIG on all that are found, and
return a modified 'sources' list with SWIG source files replaced
by the generated C (or C++) files.
"""
new_sources = []
swig_sources = []
swig_targets = {}
# XXX this drops generated C/C++ files into the source tree, which
# is fine for developers who want to distribute the generated
# source -- but there should be an option to put SWIG output in
# the temp dir.
if self.swig_cpp:
log.warn("--swig-cpp is deprecated - use --swig-opts=-c++")
if self.swig_cpp or ('-c++' in self.swig_opts) or \
('-c++' in extension.swig_opts):
target_ext = '.cpp'
else:
target_ext = '.c'
for source in sources:
(base, ext) = os.path.splitext(source)
if ext == ".i": # SWIG interface file
new_sources.append(base + '_wrap' + target_ext)
swig_sources.append(source)
swig_targets[source] = new_sources[-1]
else:
new_sources.append(source)
if not swig_sources:
return new_sources
swig = self.swig or self.find_swig()
swig_cmd = [swig, "-python"]
swig_cmd.extend(self.swig_opts)
if self.swig_cpp:
swig_cmd.append("-c++")
# Do not override commandline arguments
if not self.swig_opts:
for o in extension.swig_opts:
swig_cmd.append(o)
for source in swig_sources:
target = swig_targets[source]
log.info("swigging %s to %s", source, target)
self.spawn(swig_cmd + ["-o", target, source])
return new_sources
def find_swig(self):
"""Return the name of the SWIG executable. On Unix, this is
just "swig" -- it should be in the PATH. Tries a bit harder on
Windows.
"""
if os.name == "posix":
return "swig"
elif os.name == "nt":
# Look for SWIG in its standard installation directory on
# Windows (or so I presume!). If we find it there, great;
# if not, act like Unix and assume it's in the PATH.
for vers in ("1.3", "1.2", "1.1"):
fn = os.path.join("c:\\swig%s" % vers, "swig.exe")
if os.path.isfile(fn):
return fn
else:
return "swig.exe"
else:
raise DistutilsPlatformError(
"I don't know how to find (much less run) SWIG "
"on platform '%s'" % os.name)
# -- Name generators -----------------------------------------------
# (extension names, filenames, whatever)
def get_ext_fullpath(self, ext_name):
"""Returns the path of the filename for a given extension.
The file is located in `build_lib` or directly in the package
(inplace option).
"""
fullname = self.get_ext_fullname(ext_name)
modpath = fullname.split('.')
filename = self.get_ext_filename(modpath[-1])
if not self.inplace:
# no further work needed
# returning :
# build_dir/package/path/filename
filename = os.path.join(*modpath[:-1]+[filename])
return os.path.join(self.build_lib, filename)
# the inplace option requires to find the package directory
# using the build_py command for that
package = '.'.join(modpath[0:-1])
build_py = self.get_finalized_command('build_py')
package_dir = os.path.abspath(build_py.get_package_dir(package))
# returning
# package_dir/filename
return os.path.join(package_dir, filename)
def get_ext_fullname(self, ext_name):
"""Returns the fullname of a given extension name.
Adds the `package.` prefix"""
if self.package is None:
return ext_name
else:
return self.package + '.' + ext_name
def get_ext_filename(self, ext_name):
r"""Convert the name of an extension (eg. "foo.bar") into the name
of the file from which it will be loaded (eg. "foo/bar.so", or
"foo\bar.pyd").
"""
from distutils.sysconfig import get_config_var
ext_path = ext_name.split('.')
ext_suffix = get_config_var('EXT_SUFFIX')
return os.path.join(*ext_path) + ext_suffix
def get_export_symbols(self, ext):
"""Return the list of symbols that a shared extension has to
export. This either uses 'ext.export_symbols' or, if it's not
provided, "PyInit_" + module_name. Only relevant on Windows, where
the .pyd file (DLL) must export the module "PyInit_" function.
"""
suffix = '_' + ext.name.split('.')[-1]
try:
# Unicode module name support as defined in PEP-489
# https://www.python.org/dev/peps/pep-0489/#export-hook-name
suffix.encode('ascii')
except UnicodeEncodeError:
suffix = 'U' + suffix.encode('punycode').replace(b'-', b'_').decode('ascii')
initfunc_name = "PyInit" + suffix
if initfunc_name not in ext.export_symbols:
ext.export_symbols.append(initfunc_name)
return ext.export_symbols
def get_libraries(self, ext):
"""Return the list of libraries to link against when building a
shared extension. On most platforms, this is just 'ext.libraries';
on Windows, we add the Python library (eg. python20.dll).
"""
# The python library is always needed on Windows. For MSVC, this
# is redundant, since the library is mentioned in a pragma in
# pyconfig.h that MSVC groks. The other Windows compilers all seem
# to need it mentioned explicitly, though, so that's what we do.
# Append '_d' to the python import library on debug builds.
if sys.platform == "win32":
from distutils._msvccompiler import MSVCCompiler
if not isinstance(self.compiler, MSVCCompiler):
template = "python%d%d"
if self.debug:
template = template + '_d'
pythonlib = (template %
(sys.hexversion >> 24, (sys.hexversion >> 16) & 0xff))
# don't extend ext.libraries, it may be shared with other
# extensions, it is a reference to the original list
return ext.libraries + [pythonlib]
else:
# On Android only the main executable and LD_PRELOADs are considered
# to be RTLD_GLOBAL, all the dependencies of the main executable
# remain RTLD_LOCAL and so the shared libraries must be linked with
# libpython when python is built with a shared python library (issue
# bpo-21536).
# On Cygwin (and if required, other POSIX-like platforms based on
# Windows like MinGW) it is simply necessary that all symbols in
# shared libraries are resolved at link time.
from distutils.sysconfig import get_config_var
link_libpython = False
if get_config_var('Py_ENABLE_SHARED'):
# A native build on an Android device or on Cygwin
if hasattr(sys, 'getandroidapilevel'):
link_libpython = True
elif sys.platform == 'cygwin':
link_libpython = True
elif '_PYTHON_HOST_PLATFORM' in os.environ:
# We are cross-compiling for one of the relevant platforms
if get_config_var('ANDROID_API_LEVEL') != 0:
link_libpython = True
elif get_config_var('MACHDEP') == 'cygwin':
link_libpython = True
if link_libpython:
ldversion = get_config_var('LDVERSION')
return ext.libraries + ['python' + ldversion]
return ext.libraries
install_lib.py 0000644 00000020315 15051366010 0007410 0 ustar 00 """distutils.command.install_lib
Implements the Distutils 'install_lib' command
(install all Python modules)."""
import os
import importlib.util
import sys
from distutils.core import Command
from distutils.errors import DistutilsOptionError
# Extension for Python source files.
PYTHON_SOURCE_EXTENSION = ".py"
class install_lib(Command):
description = "install all Python modules (extensions and pure Python)"
# The byte-compilation options are a tad confusing. Here are the
# possible scenarios:
# 1) no compilation at all (--no-compile --no-optimize)
# 2) compile .pyc only (--compile --no-optimize; default)
# 3) compile .pyc and "opt-1" .pyc (--compile --optimize)
# 4) compile "opt-1" .pyc only (--no-compile --optimize)
# 5) compile .pyc and "opt-2" .pyc (--compile --optimize-more)
# 6) compile "opt-2" .pyc only (--no-compile --optimize-more)
#
# The UI for this is two options, 'compile' and 'optimize'.
# 'compile' is strictly boolean, and only decides whether to
# generate .pyc files. 'optimize' is three-way (0, 1, or 2), and
# decides both whether to generate .pyc files and what level of
# optimization to use.
user_options = [
('install-dir=', 'd', "directory to install to"),
('build-dir=','b', "build directory (where to install from)"),
('force', 'f', "force installation (overwrite existing files)"),
('compile', 'c', "compile .py to .pyc [default]"),
('no-compile', None, "don't compile .py files"),
('optimize=', 'O',
"also compile with optimization: -O1 for \"python -O\", "
"-O2 for \"python -OO\", and -O0 to disable [default: -O0]"),
('skip-build', None, "skip the build steps"),
]
boolean_options = ['force', 'compile', 'skip-build']
negative_opt = {'no-compile' : 'compile'}
def initialize_options(self):
# let the 'install' command dictate our installation directory
self.install_dir = None
self.build_dir = None
self.force = 0
self.compile = None
self.optimize = None
self.skip_build = None
def finalize_options(self):
# Get all the information we need to install pure Python modules
# from the umbrella 'install' command -- build (source) directory,
# install (target) directory, and whether to compile .py files.
self.set_undefined_options('install',
('build_lib', 'build_dir'),
('install_lib', 'install_dir'),
('force', 'force'),
('compile', 'compile'),
('optimize', 'optimize'),
('skip_build', 'skip_build'),
)
if self.compile is None:
self.compile = True
if self.optimize is None:
self.optimize = False
if not isinstance(self.optimize, int):
try:
self.optimize = int(self.optimize)
if self.optimize not in (0, 1, 2):
raise AssertionError
except (ValueError, AssertionError):
raise DistutilsOptionError("optimize must be 0, 1, or 2")
def run(self):
# Make sure we have built everything we need first
self.build()
# Install everything: simply dump the entire contents of the build
# directory to the installation directory (that's the beauty of
# having a build directory!)
outfiles = self.install()
# (Optionally) compile .py to .pyc
if outfiles is not None and self.distribution.has_pure_modules():
self.byte_compile(outfiles)
# -- Top-level worker functions ------------------------------------
# (called from 'run()')
def build(self):
if not self.skip_build:
if self.distribution.has_pure_modules():
self.run_command('build_py')
if self.distribution.has_ext_modules():
self.run_command('build_ext')
def install(self):
if os.path.isdir(self.build_dir):
outfiles = self.copy_tree(self.build_dir, self.install_dir)
else:
self.warn("'%s' does not exist -- no Python modules to install" %
self.build_dir)
return
return outfiles
def byte_compile(self, files):
if sys.dont_write_bytecode:
self.warn('byte-compiling is disabled, skipping.')
return
from distutils.util import byte_compile
# Get the "--root" directory supplied to the "install" command,
# and use it as a prefix to strip off the purported filename
# encoded in bytecode files. This is far from complete, but it
# should at least generate usable bytecode in RPM distributions.
install_root = self.get_finalized_command('install').root
if self.compile:
byte_compile(files, optimize=0,
force=self.force, prefix=install_root,
dry_run=self.dry_run)
if self.optimize > 0:
byte_compile(files, optimize=self.optimize,
force=self.force, prefix=install_root,
verbose=self.verbose, dry_run=self.dry_run)
# -- Utility methods -----------------------------------------------
def _mutate_outputs(self, has_any, build_cmd, cmd_option, output_dir):
if not has_any:
return []
build_cmd = self.get_finalized_command(build_cmd)
build_files = build_cmd.get_outputs()
build_dir = getattr(build_cmd, cmd_option)
prefix_len = len(build_dir) + len(os.sep)
outputs = []
for file in build_files:
outputs.append(os.path.join(output_dir, file[prefix_len:]))
return outputs
def _bytecode_filenames(self, py_filenames):
bytecode_files = []
for py_file in py_filenames:
# Since build_py handles package data installation, the
# list of outputs can contain more than just .py files.
# Make sure we only report bytecode for the .py files.
ext = os.path.splitext(os.path.normcase(py_file))[1]
if ext != PYTHON_SOURCE_EXTENSION:
continue
if self.compile:
bytecode_files.append(importlib.util.cache_from_source(
py_file, optimization=''))
if self.optimize > 0:
bytecode_files.append(importlib.util.cache_from_source(
py_file, optimization=self.optimize))
return bytecode_files
# -- External interface --------------------------------------------
# (called by outsiders)
def get_outputs(self):
"""Return the list of files that would be installed if this command
were actually run. Not affected by the "dry-run" flag or whether
modules have actually been built yet.
"""
pure_outputs = \
self._mutate_outputs(self.distribution.has_pure_modules(),
'build_py', 'build_lib',
self.install_dir)
if self.compile:
bytecode_outputs = self._bytecode_filenames(pure_outputs)
else:
bytecode_outputs = []
ext_outputs = \
self._mutate_outputs(self.distribution.has_ext_modules(),
'build_ext', 'build_lib',
self.install_dir)
return pure_outputs + bytecode_outputs + ext_outputs
def get_inputs(self):
"""Get the list of files that are input to this command, ie. the
files that get installed as they are named in the build tree.
The files in this list correspond one-to-one to the output
filenames returned by 'get_outputs()'.
"""
inputs = []
if self.distribution.has_pure_modules():
build_py = self.get_finalized_command('build_py')
inputs.extend(build_py.get_outputs())
if self.distribution.has_ext_modules():
build_ext = self.get_finalized_command('build_ext')
inputs.extend(build_ext.get_outputs())
return inputs
register.py 0000644 00000026700 15051366010 0006744 0 ustar 00 """distutils.command.register
Implements the Distutils 'register' command (register with the repository).
"""
# created 2002/10/21, Richard Jones
import getpass
import io
import urllib.parse, urllib.request
from warnings import warn
from distutils.core import PyPIRCCommand
from distutils.errors import *
from distutils import log
class register(PyPIRCCommand):
description = ("register the distribution with the Python package index")
user_options = PyPIRCCommand.user_options + [
('list-classifiers', None,
'list the valid Trove classifiers'),
('strict', None ,
'Will stop the registering if the meta-data are not fully compliant')
]
boolean_options = PyPIRCCommand.boolean_options + [
'verify', 'list-classifiers', 'strict']
sub_commands = [('check', lambda self: True)]
def initialize_options(self):
PyPIRCCommand.initialize_options(self)
self.list_classifiers = 0
self.strict = 0
def finalize_options(self):
PyPIRCCommand.finalize_options(self)
# setting options for the `check` subcommand
check_options = {'strict': ('register', self.strict),
'restructuredtext': ('register', 1)}
self.distribution.command_options['check'] = check_options
def run(self):
self.finalize_options()
self._set_config()
# Run sub commands
for cmd_name in self.get_sub_commands():
self.run_command(cmd_name)
if self.dry_run:
self.verify_metadata()
elif self.list_classifiers:
self.classifiers()
else:
self.send_metadata()
def check_metadata(self):
"""Deprecated API."""
warn("distutils.command.register.check_metadata is deprecated, \
use the check command instead", PendingDeprecationWarning)
check = self.distribution.get_command_obj('check')
check.ensure_finalized()
check.strict = self.strict
check.restructuredtext = 1
check.run()
def _set_config(self):
''' Reads the configuration file and set attributes.
'''
config = self._read_pypirc()
if config != {}:
self.username = config['username']
self.password = config['password']
self.repository = config['repository']
self.realm = config['realm']
self.has_config = True
else:
if self.repository not in ('pypi', self.DEFAULT_REPOSITORY):
raise ValueError('%s not found in .pypirc' % self.repository)
if self.repository == 'pypi':
self.repository = self.DEFAULT_REPOSITORY
self.has_config = False
def classifiers(self):
''' Fetch the list of classifiers from the server.
'''
url = self.repository+'?:action=list_classifiers'
response = urllib.request.urlopen(url)
log.info(self._read_pypi_response(response))
def verify_metadata(self):
''' Send the metadata to the package index server to be checked.
'''
# send the info to the server and report the result
(code, result) = self.post_to_server(self.build_post_data('verify'))
log.info('Server response (%s): %s', code, result)
def send_metadata(self):
''' Send the metadata to the package index server.
Well, do the following:
1. figure who the user is, and then
2. send the data as a Basic auth'ed POST.
First we try to read the username/password from $HOME/.pypirc,
which is a ConfigParser-formatted file with a section
[distutils] containing username and password entries (both
in clear text). Eg:
[distutils]
index-servers =
pypi
[pypi]
username: fred
password: sekrit
Otherwise, to figure who the user is, we offer the user three
choices:
1. use existing login,
2. register as a new user, or
3. set the password to a random string and email the user.
'''
# see if we can short-cut and get the username/password from the
# config
if self.has_config:
choice = '1'
username = self.username
password = self.password
else:
choice = 'x'
username = password = ''
# get the user's login info
choices = '1 2 3 4'.split()
while choice not in choices:
self.announce('''\
We need to know who you are, so please choose either:
1. use your existing login,
2. register as a new user,
3. have the server generate a new password for you (and email it to you), or
4. quit
Your selection [default 1]: ''', log.INFO)
choice = input()
if not choice:
choice = '1'
elif choice not in choices:
print('Please choose one of the four options!')
if choice == '1':
# get the username and password
while not username:
username = input('Username: ')
while not password:
password = getpass.getpass('Password: ')
# set up the authentication
auth = urllib.request.HTTPPasswordMgr()
host = urllib.parse.urlparse(self.repository)[1]
auth.add_password(self.realm, host, username, password)
# send the info to the server and report the result
code, result = self.post_to_server(self.build_post_data('submit'),
auth)
self.announce('Server response (%s): %s' % (code, result),
log.INFO)
# possibly save the login
if code == 200:
if self.has_config:
# sharing the password in the distribution instance
# so the upload command can reuse it
self.distribution.password = password
else:
self.announce(('I can store your PyPI login so future '
'submissions will be faster.'), log.INFO)
self.announce('(the login will be stored in %s)' % \
self._get_rc_file(), log.INFO)
choice = 'X'
while choice.lower() not in 'yn':
choice = input('Save your login (y/N)?')
if not choice:
choice = 'n'
if choice.lower() == 'y':
self._store_pypirc(username, password)
elif choice == '2':
data = {':action': 'user'}
data['name'] = data['password'] = data['email'] = ''
data['confirm'] = None
while not data['name']:
data['name'] = input('Username: ')
while data['password'] != data['confirm']:
while not data['password']:
data['password'] = getpass.getpass('Password: ')
while not data['confirm']:
data['confirm'] = getpass.getpass(' Confirm: ')
if data['password'] != data['confirm']:
data['password'] = ''
data['confirm'] = None
print("Password and confirm don't match!")
while not data['email']:
data['email'] = input(' EMail: ')
code, result = self.post_to_server(data)
if code != 200:
log.info('Server response (%s): %s', code, result)
else:
log.info('You will receive an email shortly.')
log.info(('Follow the instructions in it to '
'complete registration.'))
elif choice == '3':
data = {':action': 'password_reset'}
data['email'] = ''
while not data['email']:
data['email'] = input('Your email address: ')
code, result = self.post_to_server(data)
log.info('Server response (%s): %s', code, result)
def build_post_data(self, action):
# figure the data to send - the metadata plus some additional
# information used by the package server
meta = self.distribution.metadata
data = {
':action': action,
'metadata_version' : '1.0',
'name': meta.get_name(),
'version': meta.get_version(),
'summary': meta.get_description(),
'home_page': meta.get_url(),
'author': meta.get_contact(),
'author_email': meta.get_contact_email(),
'license': meta.get_licence(),
'description': meta.get_long_description(),
'keywords': meta.get_keywords(),
'platform': meta.get_platforms(),
'classifiers': meta.get_classifiers(),
'download_url': meta.get_download_url(),
# PEP 314
'provides': meta.get_provides(),
'requires': meta.get_requires(),
'obsoletes': meta.get_obsoletes(),
}
if data['provides'] or data['requires'] or data['obsoletes']:
data['metadata_version'] = '1.1'
return data
def post_to_server(self, data, auth=None):
''' Post a query to the server, and return a string response.
'''
if 'name' in data:
self.announce('Registering %s to %s' % (data['name'],
self.repository),
log.INFO)
# Build up the MIME payload for the urllib2 POST data
boundary = '--------------GHSKFJDLGDS7543FJKLFHRE75642756743254'
sep_boundary = '\n--' + boundary
end_boundary = sep_boundary + '--'
body = io.StringIO()
for key, value in data.items():
# handle multiple entries for the same name
if type(value) not in (type([]), type( () )):
value = [value]
for value in value:
value = str(value)
body.write(sep_boundary)
body.write('\nContent-Disposition: form-data; name="%s"'%key)
body.write("\n\n")
body.write(value)
if value and value[-1] == '\r':
body.write('\n') # write an extra newline (lurve Macs)
body.write(end_boundary)
body.write("\n")
body = body.getvalue().encode("utf-8")
# build the Request
headers = {
'Content-type': 'multipart/form-data; boundary=%s; charset=utf-8'%boundary,
'Content-length': str(len(body))
}
req = urllib.request.Request(self.repository, body, headers)
# handle HTTP and include the Basic Auth handler
opener = urllib.request.build_opener(
urllib.request.HTTPBasicAuthHandler(password_mgr=auth)
)
data = ''
try:
result = opener.open(req)
except urllib.error.HTTPError as e:
if self.show_response:
data = e.fp.read()
result = e.code, e.msg
except urllib.error.URLError as e:
result = 500, str(e)
else:
if self.show_response:
data = self._read_pypi_response(result)
result = 200, 'OK'
if self.show_response:
msg = '\n'.join(('-' * 75, data, '-' * 75))
self.announce(msg, log.INFO)
return result
check.py 0000644 00000012737 15051366010 0006202 0 ustar 00 """distutils.command.check
Implements the Distutils 'check' command.
"""
from distutils.core import Command
from distutils.errors import DistutilsSetupError
try:
# docutils is installed
from docutils.utils import Reporter
from docutils.parsers.rst import Parser
from docutils import frontend
from docutils import nodes
from io import StringIO
class SilentReporter(Reporter):
def __init__(self, source, report_level, halt_level, stream=None,
debug=0, encoding='ascii', error_handler='replace'):
self.messages = []
Reporter.__init__(self, source, report_level, halt_level, stream,
debug, encoding, error_handler)
def system_message(self, level, message, *children, **kwargs):
self.messages.append((level, message, children, kwargs))
return nodes.system_message(message, level=level,
type=self.levels[level],
*children, **kwargs)
HAS_DOCUTILS = True
except Exception:
# Catch all exceptions because exceptions besides ImportError probably
# indicate that docutils is not ported to Py3k.
HAS_DOCUTILS = False
class check(Command):
"""This command checks the meta-data of the package.
"""
description = ("perform some checks on the package")
user_options = [('metadata', 'm', 'Verify meta-data'),
('restructuredtext', 'r',
('Checks if long string meta-data syntax '
'are reStructuredText-compliant')),
('strict', 's',
'Will exit with an error if a check fails')]
boolean_options = ['metadata', 'restructuredtext', 'strict']
def initialize_options(self):
"""Sets default values for options."""
self.restructuredtext = 0
self.metadata = 1
self.strict = 0
self._warnings = 0
def finalize_options(self):
pass
def warn(self, msg):
"""Counts the number of warnings that occurs."""
self._warnings += 1
return Command.warn(self, msg)
def run(self):
"""Runs the command."""
# perform the various tests
if self.metadata:
self.check_metadata()
if self.restructuredtext:
if HAS_DOCUTILS:
self.check_restructuredtext()
elif self.strict:
raise DistutilsSetupError('The docutils package is needed.')
# let's raise an error in strict mode, if we have at least
# one warning
if self.strict and self._warnings > 0:
raise DistutilsSetupError('Please correct your package.')
def check_metadata(self):
"""Ensures that all required elements of meta-data are supplied.
name, version, URL, (author and author_email) or
(maintainer and maintainer_email)).
Warns if any are missing.
"""
metadata = self.distribution.metadata
missing = []
for attr in ('name', 'version', 'url'):
if not (hasattr(metadata, attr) and getattr(metadata, attr)):
missing.append(attr)
if missing:
self.warn("missing required meta-data: %s" % ', '.join(missing))
if metadata.author:
if not metadata.author_email:
self.warn("missing meta-data: if 'author' supplied, " +
"'author_email' must be supplied too")
elif metadata.maintainer:
if not metadata.maintainer_email:
self.warn("missing meta-data: if 'maintainer' supplied, " +
"'maintainer_email' must be supplied too")
else:
self.warn("missing meta-data: either (author and author_email) " +
"or (maintainer and maintainer_email) " +
"must be supplied")
def check_restructuredtext(self):
"""Checks if the long string fields are reST-compliant."""
data = self.distribution.get_long_description()
for warning in self._check_rst_data(data):
line = warning[-1].get('line')
if line is None:
warning = warning[1]
else:
warning = '%s (line %s)' % (warning[1], line)
self.warn(warning)
def _check_rst_data(self, data):
"""Returns warnings when the provided data doesn't compile."""
# the include and csv_table directives need this to be a path
source_path = self.distribution.script_name or 'setup.py'
parser = Parser()
settings = frontend.OptionParser(components=(Parser,)).get_default_values()
settings.tab_width = 4
settings.pep_references = None
settings.rfc_references = None
reporter = SilentReporter(source_path,
settings.report_level,
settings.halt_level,
stream=settings.warning_stream,
debug=settings.debug,
encoding=settings.error_encoding,
error_handler=settings.error_encoding_error_handler)
document = nodes.document(settings, reporter, source=source_path)
document.note_source(source_path, -1)
try:
parser.parse(data, document)
except AttributeError as e:
reporter.messages.append(
(-1, 'Could not finish the parsing: %s.' % e, '', {}))
return reporter.messages
build.py 0000644 00000013207 15051366010 0006215 0 ustar 00 """distutils.command.build
Implements the Distutils 'build' command."""
import sys, os
from distutils.core import Command
from distutils.errors import DistutilsOptionError
from distutils.util import get_platform
def show_compilers():
from distutils.ccompiler import show_compilers
show_compilers()
class build(Command):
description = "build everything needed to install"
user_options = [
('build-base=', 'b',
"base directory for build library"),
('build-purelib=', None,
"build directory for platform-neutral distributions"),
('build-platlib=', None,
"build directory for platform-specific distributions"),
('build-lib=', None,
"build directory for all distribution (defaults to either " +
"build-purelib or build-platlib"),
('build-scripts=', None,
"build directory for scripts"),
('build-temp=', 't',
"temporary build directory"),
('plat-name=', 'p',
"platform name to build for, if supported "
"(default: %s)" % get_platform()),
('compiler=', 'c',
"specify the compiler type"),
('parallel=', 'j',
"number of parallel build jobs"),
('debug', 'g',
"compile extensions and libraries with debugging information"),
('force', 'f',
"forcibly build everything (ignore file timestamps)"),
('executable=', 'e',
"specify final destination interpreter path (build.py)"),
]
boolean_options = ['debug', 'force']
help_options = [
('help-compiler', None,
"list available compilers", show_compilers),
]
def initialize_options(self):
self.build_base = 'build'
# these are decided only after 'build_base' has its final value
# (unless overridden by the user or client)
self.build_purelib = None
self.build_platlib = None
self.build_lib = None
self.build_temp = None
self.build_scripts = None
self.compiler = None
self.plat_name = None
self.debug = None
self.force = 0
self.executable = None
self.parallel = None
def finalize_options(self):
if self.plat_name is None:
self.plat_name = get_platform()
else:
# plat-name only supported for windows (other platforms are
# supported via ./configure flags, if at all). Avoid misleading
# other platforms.
if os.name != 'nt':
raise DistutilsOptionError(
"--plat-name only supported on Windows (try "
"using './configure --help' on your platform)")
plat_specifier = ".%s-%d.%d" % (self.plat_name, *sys.version_info[:2])
# Make it so Python 2.x and Python 2.x with --with-pydebug don't
# share the same build directories. Doing so confuses the build
# process for C modules
if hasattr(sys, 'gettotalrefcount'):
plat_specifier += '-pydebug'
# 'build_purelib' and 'build_platlib' just default to 'lib' and
# 'lib.<plat>' under the base build directory. We only use one of
# them for a given distribution, though --
if self.build_purelib is None:
self.build_purelib = os.path.join(self.build_base, 'lib')
if self.build_platlib is None:
self.build_platlib = os.path.join(self.build_base,
'lib' + plat_specifier)
# 'build_lib' is the actual directory that we will use for this
# particular module distribution -- if user didn't supply it, pick
# one of 'build_purelib' or 'build_platlib'.
if self.build_lib is None:
if self.distribution.ext_modules:
self.build_lib = self.build_platlib
else:
self.build_lib = self.build_purelib
# 'build_temp' -- temporary directory for compiler turds,
# "build/temp.<plat>"
if self.build_temp is None:
self.build_temp = os.path.join(self.build_base,
'temp' + plat_specifier)
if self.build_scripts is None:
self.build_scripts = os.path.join(self.build_base,
'scripts-%d.%d' % sys.version_info[:2])
if self.executable is None and sys.executable:
self.executable = os.path.normpath(sys.executable)
if isinstance(self.parallel, str):
try:
self.parallel = int(self.parallel)
except ValueError:
raise DistutilsOptionError("parallel should be an integer")
def run(self):
# Run all relevant sub-commands. This will be some subset of:
# - build_py - pure Python modules
# - build_clib - standalone C libraries
# - build_ext - Python extensions
# - build_scripts - (Python) scripts
for cmd_name in self.get_sub_commands():
self.run_command(cmd_name)
# -- Predicates for the sub-command list ---------------------------
def has_pure_modules(self):
return self.distribution.has_pure_modules()
def has_c_libraries(self):
return self.distribution.has_c_libraries()
def has_ext_modules(self):
return self.distribution.has_ext_modules()
def has_scripts(self):
return self.distribution.has_scripts()
sub_commands = [('build_py', has_pure_modules),
('build_clib', has_c_libraries),
('build_ext', has_ext_modules),
('build_scripts', has_scripts),
]
build_clib.py 0000644 00000017526 15051366010 0007216 0 ustar 00 """distutils.command.build_clib
Implements the Distutils 'build_clib' command, to build a C/C++ library
that is included in the module distribution and needed by an extension
module."""
# XXX this module has *lots* of code ripped-off quite transparently from
# build_ext.py -- not surprisingly really, as the work required to build
# a static library from a collection of C source files is not really all
# that different from what's required to build a shared object file from
# a collection of C source files. Nevertheless, I haven't done the
# necessary refactoring to account for the overlap in code between the
# two modules, mainly because a number of subtle details changed in the
# cut 'n paste. Sigh.
import os
from distutils.core import Command
from distutils.errors import *
from distutils.sysconfig import customize_compiler
from distutils import log
def show_compilers():
from distutils.ccompiler import show_compilers
show_compilers()
class build_clib(Command):
description = "build C/C++ libraries used by Python extensions"
user_options = [
('build-clib=', 'b',
"directory to build C/C++ libraries to"),
('build-temp=', 't',
"directory to put temporary build by-products"),
('debug', 'g',
"compile with debugging information"),
('force', 'f',
"forcibly build everything (ignore file timestamps)"),
('compiler=', 'c',
"specify the compiler type"),
]
boolean_options = ['debug', 'force']
help_options = [
('help-compiler', None,
"list available compilers", show_compilers),
]
def initialize_options(self):
self.build_clib = None
self.build_temp = None
# List of libraries to build
self.libraries = None
# Compilation options for all libraries
self.include_dirs = None
self.define = None
self.undef = None
self.debug = None
self.force = 0
self.compiler = None
def finalize_options(self):
# This might be confusing: both build-clib and build-temp default
# to build-temp as defined by the "build" command. This is because
# I think that C libraries are really just temporary build
# by-products, at least from the point of view of building Python
# extensions -- but I want to keep my options open.
self.set_undefined_options('build',
('build_temp', 'build_clib'),
('build_temp', 'build_temp'),
('compiler', 'compiler'),
('debug', 'debug'),
('force', 'force'))
self.libraries = self.distribution.libraries
if self.libraries:
self.check_library_list(self.libraries)
if self.include_dirs is None:
self.include_dirs = self.distribution.include_dirs or []
if isinstance(self.include_dirs, str):
self.include_dirs = self.include_dirs.split(os.pathsep)
# XXX same as for build_ext -- what about 'self.define' and
# 'self.undef' ?
def run(self):
if not self.libraries:
return
# Yech -- this is cut 'n pasted from build_ext.py!
from distutils.ccompiler import new_compiler
self.compiler = new_compiler(compiler=self.compiler,
dry_run=self.dry_run,
force=self.force)
customize_compiler(self.compiler)
if self.include_dirs is not None:
self.compiler.set_include_dirs(self.include_dirs)
if self.define is not None:
# 'define' option is a list of (name,value) tuples
for (name,value) in self.define:
self.compiler.define_macro(name, value)
if self.undef is not None:
for macro in self.undef:
self.compiler.undefine_macro(macro)
self.build_libraries(self.libraries)
def check_library_list(self, libraries):
"""Ensure that the list of libraries is valid.
`library` is presumably provided as a command option 'libraries'.
This method checks that it is a list of 2-tuples, where the tuples
are (library_name, build_info_dict).
Raise DistutilsSetupError if the structure is invalid anywhere;
just returns otherwise.
"""
if not isinstance(libraries, list):
raise DistutilsSetupError(
"'libraries' option must be a list of tuples")
for lib in libraries:
if not isinstance(lib, tuple) and len(lib) != 2:
raise DistutilsSetupError(
"each element of 'libraries' must a 2-tuple")
name, build_info = lib
if not isinstance(name, str):
raise DistutilsSetupError(
"first element of each tuple in 'libraries' "
"must be a string (the library name)")
if '/' in name or (os.sep != '/' and os.sep in name):
raise DistutilsSetupError("bad library name '%s': "
"may not contain directory separators" % lib[0])
if not isinstance(build_info, dict):
raise DistutilsSetupError(
"second element of each tuple in 'libraries' "
"must be a dictionary (build info)")
def get_library_names(self):
# Assume the library list is valid -- 'check_library_list()' is
# called from 'finalize_options()', so it should be!
if not self.libraries:
return None
lib_names = []
for (lib_name, build_info) in self.libraries:
lib_names.append(lib_name)
return lib_names
def get_source_files(self):
self.check_library_list(self.libraries)
filenames = []
for (lib_name, build_info) in self.libraries:
sources = build_info.get('sources')
if sources is None or not isinstance(sources, (list, tuple)):
raise DistutilsSetupError(
"in 'libraries' option (library '%s'), "
"'sources' must be present and must be "
"a list of source filenames" % lib_name)
filenames.extend(sources)
return filenames
def build_libraries(self, libraries):
for (lib_name, build_info) in libraries:
sources = build_info.get('sources')
if sources is None or not isinstance(sources, (list, tuple)):
raise DistutilsSetupError(
"in 'libraries' option (library '%s'), "
"'sources' must be present and must be "
"a list of source filenames" % lib_name)
sources = list(sources)
log.info("building '%s' library", lib_name)
# First, compile the source code to object files in the library
# directory. (This should probably change to putting object
# files in a temporary build directory.)
macros = build_info.get('macros')
include_dirs = build_info.get('include_dirs')
objects = self.compiler.compile(sources,
output_dir=self.build_temp,
macros=macros,
include_dirs=include_dirs,
debug=self.debug)
# Now "link" the object files together into a static library.
# (On Unix at least, this isn't really linking -- it just
# builds an archive. Whatever.)
self.compiler.create_static_lib(objects, lib_name,
output_dir=self.build_clib,
debug=self.debug)
install_data.py 0000644 00000005406 15051366010 0007557 0 ustar 00 """distutils.command.install_data
Implements the Distutils 'install_data' command, for installing
platform-independent data files."""
# contributed by Bastian Kleineidam
import os
from distutils.core import Command
from distutils.util import change_root, convert_path
class install_data(Command):
description = "install data files"
user_options = [
('install-dir=', 'd',
"base directory for installing data files "
"(default: installation base dir)"),
('root=', None,
"install everything relative to this alternate root directory"),
('force', 'f', "force installation (overwrite existing files)"),
]
boolean_options = ['force']
def initialize_options(self):
self.install_dir = None
self.outfiles = []
self.root = None
self.force = 0
self.data_files = self.distribution.data_files
self.warn_dir = 1
def finalize_options(self):
self.set_undefined_options('install',
('install_data', 'install_dir'),
('root', 'root'),
('force', 'force'),
)
def run(self):
self.mkpath(self.install_dir)
for f in self.data_files:
if isinstance(f, str):
# it's a simple file, so copy it
f = convert_path(f)
if self.warn_dir:
self.warn("setup script did not provide a directory for "
"'%s' -- installing right in '%s'" %
(f, self.install_dir))
(out, _) = self.copy_file(f, self.install_dir)
self.outfiles.append(out)
else:
# it's a tuple with path to install to and a list of files
dir = convert_path(f[0])
if not os.path.isabs(dir):
dir = os.path.join(self.install_dir, dir)
elif self.root:
dir = change_root(self.root, dir)
self.mkpath(dir)
if f[1] == []:
# If there are no files listed, the user must be
# trying to create an empty directory, so add the
# directory to the list of output files.
self.outfiles.append(dir)
else:
# Copy files, adding them to the list of output files.
for data in f[1]:
data = convert_path(data)
(out, _) = self.copy_file(data, dir)
self.outfiles.append(out)
def get_inputs(self):
return self.data_files or []
def get_outputs(self):
return self.outfiles