Warning: file_get_contents(https://raw.githubusercontent.com/Den1xxx/Filemanager/master/languages/ru.json): failed to open stream: HTTP request failed! HTTP/1.1 404 Not Found
in /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php on line 88
Warning: Cannot modify header information - headers already sent by (output started at /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php:88) in /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php on line 215
Warning: Cannot modify header information - headers already sent by (output started at /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php:88) in /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php on line 216
Warning: Cannot modify header information - headers already sent by (output started at /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php:88) in /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php on line 217
Warning: Cannot modify header information - headers already sent by (output started at /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php:88) in /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php on line 218
Warning: Cannot modify header information - headers already sent by (output started at /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php:88) in /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php on line 219
Warning: Cannot modify header information - headers already sent by (output started at /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php:88) in /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php on line 220
PK ! 2\ msvc.pynu [ """
Improved support for Microsoft Visual C++ compilers.
Known supported compilers:
--------------------------
Microsoft Visual C++ 9.0:
Microsoft Visual C++ Compiler for Python 2.7 (x86, amd64)
Microsoft Windows SDK 6.1 (x86, x64, ia64)
Microsoft Windows SDK 7.0 (x86, x64, ia64)
Microsoft Visual C++ 10.0:
Microsoft Windows SDK 7.1 (x86, x64, ia64)
Microsoft Visual C++ 14.X:
Microsoft Visual C++ Build Tools 2015 (x86, x64, arm)
Microsoft Visual Studio Build Tools 2017 (x86, x64, arm, arm64)
Microsoft Visual Studio Build Tools 2019 (x86, x64, arm, arm64)
This may also support compilers shipped with compatible Visual Studio versions.
"""
import json
from io import open
from os import listdir, pathsep
from os.path import join, isfile, isdir, dirname
import sys
import platform
import itertools
import distutils.errors
from setuptools.extern.packaging.version import LegacyVersion
from setuptools.extern.six.moves import filterfalse
from .monkey import get_unpatched
if platform.system() == 'Windows':
from setuptools.extern.six.moves import winreg
from os import environ
else:
# Mock winreg and environ so the module can be imported on this platform.
class winreg:
HKEY_USERS = None
HKEY_CURRENT_USER = None
HKEY_LOCAL_MACHINE = None
HKEY_CLASSES_ROOT = None
environ = dict()
_msvc9_suppress_errors = (
# msvc9compiler isn't available on some platforms
ImportError,
# msvc9compiler raises DistutilsPlatformError in some
# environments. See #1118.
distutils.errors.DistutilsPlatformError,
)
try:
from distutils.msvc9compiler import Reg
except _msvc9_suppress_errors:
pass
def msvc9_find_vcvarsall(version):
"""
Patched "distutils.msvc9compiler.find_vcvarsall" to use the standalone
compiler build for Python
(VCForPython / Microsoft Visual C++ Compiler for Python 2.7).
Fall back to original behavior when the standalone compiler is not
available.
Redirect the path of "vcvarsall.bat".
Parameters
----------
version: float
Required Microsoft Visual C++ version.
Return
------
str
vcvarsall.bat path
"""
vc_base = r'Software\%sMicrosoft\DevDiv\VCForPython\%0.1f'
key = vc_base % ('', version)
try:
# Per-user installs register the compiler path here
productdir = Reg.get_value(key, "installdir")
except KeyError:
try:
# All-user installs on a 64-bit system register here
key = vc_base % ('Wow6432Node\\', version)
productdir = Reg.get_value(key, "installdir")
except KeyError:
productdir = None
if productdir:
vcvarsall = join(productdir, "vcvarsall.bat")
if isfile(vcvarsall):
return vcvarsall
return get_unpatched(msvc9_find_vcvarsall)(version)
def msvc9_query_vcvarsall(ver, arch='x86', *args, **kwargs):
"""
Patched "distutils.msvc9compiler.query_vcvarsall" for support extra
Microsoft Visual C++ 9.0 and 10.0 compilers.
Set environment without use of "vcvarsall.bat".
Parameters
----------
ver: float
Required Microsoft Visual C++ version.
arch: str
Target architecture.
Return
------
dict
environment
"""
# Try to get environment from vcvarsall.bat (Classical way)
try:
orig = get_unpatched(msvc9_query_vcvarsall)
return orig(ver, arch, *args, **kwargs)
except distutils.errors.DistutilsPlatformError:
# Pass error if Vcvarsall.bat is missing
pass
except ValueError:
# Pass error if environment not set after executing vcvarsall.bat
pass
# If error, try to set environment directly
try:
return EnvironmentInfo(arch, ver).return_env()
except distutils.errors.DistutilsPlatformError as exc:
_augment_exception(exc, ver, arch)
raise
def msvc14_get_vc_env(plat_spec):
"""
Patched "distutils._msvccompiler._get_vc_env" for support extra
Microsoft Visual C++ 14.X compilers.
Set environment without use of "vcvarsall.bat".
Parameters
----------
plat_spec: str
Target architecture.
Return
------
dict
environment
"""
# Try to get environment from vcvarsall.bat (Classical way)
try:
return get_unpatched(msvc14_get_vc_env)(plat_spec)
except distutils.errors.DistutilsPlatformError:
# Pass error Vcvarsall.bat is missing
pass
# If error, try to set environment directly
try:
return EnvironmentInfo(plat_spec, vc_min_ver=14.0).return_env()
except distutils.errors.DistutilsPlatformError as exc:
_augment_exception(exc, 14.0)
raise
def msvc14_gen_lib_options(*args, **kwargs):
"""
Patched "distutils._msvccompiler.gen_lib_options" for fix
compatibility between "numpy.distutils" and "distutils._msvccompiler"
(for Numpy < 1.11.2)
"""
if "numpy.distutils" in sys.modules:
import numpy as np
if LegacyVersion(np.__version__) < LegacyVersion('1.11.2'):
return np.distutils.ccompiler.gen_lib_options(*args, **kwargs)
return get_unpatched(msvc14_gen_lib_options)(*args, **kwargs)
def _augment_exception(exc, version, arch=''):
"""
Add details to the exception message to help guide the user
as to what action will resolve it.
"""
# Error if MSVC++ directory not found or environment not set
message = exc.args[0]
if "vcvarsall" in message.lower() or "visual c" in message.lower():
# Special error message if MSVC++ not installed
tmpl = 'Microsoft Visual C++ {version:0.1f} is required.'
message = tmpl.format(**locals())
msdownload = 'www.microsoft.com/download/details.aspx?id=%d'
if version == 9.0:
if arch.lower().find('ia64') > -1:
# For VC++ 9.0, if IA64 support is needed, redirect user
# to Windows SDK 7.0.
# Note: No download link available from Microsoft.
message += ' Get it with "Microsoft Windows SDK 7.0"'
else:
# For VC++ 9.0 redirect user to Vc++ for Python 2.7 :
# This redirection link is maintained by Microsoft.
# Contact vspython@microsoft.com if it needs updating.
message += ' Get it from http://aka.ms/vcpython27'
elif version == 10.0:
# For VC++ 10.0 Redirect user to Windows SDK 7.1
message += ' Get it with "Microsoft Windows SDK 7.1": '
message += msdownload % 8279
elif version >= 14.0:
# For VC++ 14.X Redirect user to latest Visual C++ Build Tools
message += (' Get it with "Build Tools for Visual Studio": '
r'https://visualstudio.microsoft.com/downloads/')
exc.args = (message, )
class PlatformInfo:
"""
Current and Target Architectures information.
Parameters
----------
arch: str
Target architecture.
"""
current_cpu = environ.get('processor_architecture', '').lower()
def __init__(self, arch):
self.arch = arch.lower().replace('x64', 'amd64')
@property
def target_cpu(self):
"""
Return Target CPU architecture.
Return
------
str
Target CPU
"""
return self.arch[self.arch.find('_') + 1:]
def target_is_x86(self):
"""
Return True if target CPU is x86 32 bits..
Return
------
bool
CPU is x86 32 bits
"""
return self.target_cpu == 'x86'
def current_is_x86(self):
"""
Return True if current CPU is x86 32 bits..
Return
------
bool
CPU is x86 32 bits
"""
return self.current_cpu == 'x86'
def current_dir(self, hidex86=False, x64=False):
"""
Current platform specific subfolder.
Parameters
----------
hidex86: bool
return '' and not '\x86' if architecture is x86.
x64: bool
return '\x64' and not '\amd64' if architecture is amd64.
Return
------
str
subfolder: '\target', or '' (see hidex86 parameter)
"""
return (
'' if (self.current_cpu == 'x86' and hidex86) else
r'\x64' if (self.current_cpu == 'amd64' and x64) else
r'\%s' % self.current_cpu
)
def target_dir(self, hidex86=False, x64=False):
r"""
Target platform specific subfolder.
Parameters
----------
hidex86: bool
return '' and not '\x86' if architecture is x86.
x64: bool
return '\x64' and not '\amd64' if architecture is amd64.
Return
------
str
subfolder: '\current', or '' (see hidex86 parameter)
"""
return (
'' if (self.target_cpu == 'x86' and hidex86) else
r'\x64' if (self.target_cpu == 'amd64' and x64) else
r'\%s' % self.target_cpu
)
def cross_dir(self, forcex86=False):
r"""
Cross platform specific subfolder.
Parameters
----------
forcex86: bool
Use 'x86' as current architecture even if current architecture is
not x86.
Return
------
str
subfolder: '' if target architecture is current architecture,
'\current_target' if not.
"""
current = 'x86' if forcex86 else self.current_cpu
return (
'' if self.target_cpu == current else
self.target_dir().replace('\\', '\\%s_' % current)
)
class RegistryInfo:
"""
Microsoft Visual Studio related registry information.
Parameters
----------
platform_info: PlatformInfo
"PlatformInfo" instance.
"""
HKEYS = (winreg.HKEY_USERS,
winreg.HKEY_CURRENT_USER,
winreg.HKEY_LOCAL_MACHINE,
winreg.HKEY_CLASSES_ROOT)
def __init__(self, platform_info):
self.pi = platform_info
@property
def visualstudio(self):
"""
Microsoft Visual Studio root registry key.
Return
------
str
Registry key
"""
return 'VisualStudio'
@property
def sxs(self):
"""
Microsoft Visual Studio SxS registry key.
Return
------
str
Registry key
"""
return join(self.visualstudio, 'SxS')
@property
def vc(self):
"""
Microsoft Visual C++ VC7 registry key.
Return
------
str
Registry key
"""
return join(self.sxs, 'VC7')
@property
def vs(self):
"""
Microsoft Visual Studio VS7 registry key.
Return
------
str
Registry key
"""
return join(self.sxs, 'VS7')
@property
def vc_for_python(self):
"""
Microsoft Visual C++ for Python registry key.
Return
------
str
Registry key
"""
return r'DevDiv\VCForPython'
@property
def microsoft_sdk(self):
"""
Microsoft SDK registry key.
Return
------
str
Registry key
"""
return 'Microsoft SDKs'
@property
def windows_sdk(self):
"""
Microsoft Windows/Platform SDK registry key.
Return
------
str
Registry key
"""
return join(self.microsoft_sdk, 'Windows')
@property
def netfx_sdk(self):
"""
Microsoft .NET Framework SDK registry key.
Return
------
str
Registry key
"""
return join(self.microsoft_sdk, 'NETFXSDK')
@property
def windows_kits_roots(self):
"""
Microsoft Windows Kits Roots registry key.
Return
------
str
Registry key
"""
return r'Windows Kits\Installed Roots'
def microsoft(self, key, x86=False):
"""
Return key in Microsoft software registry.
Parameters
----------
key: str
Registry key path where look.
x86: str
Force x86 software registry.
Return
------
str
Registry key
"""
node64 = '' if self.pi.current_is_x86() or x86 else 'Wow6432Node'
return join('Software', node64, 'Microsoft', key)
def lookup(self, key, name):
"""
Look for values in registry in Microsoft software registry.
Parameters
----------
key: str
Registry key path where look.
name: str
Value name to find.
Return
------
str
value
"""
key_read = winreg.KEY_READ
openkey = winreg.OpenKey
ms = self.microsoft
for hkey in self.HKEYS:
try:
bkey = openkey(hkey, ms(key), 0, key_read)
except (OSError, IOError):
if not self.pi.current_is_x86():
try:
bkey = openkey(hkey, ms(key, True), 0, key_read)
except (OSError, IOError):
continue
else:
continue
try:
return winreg.QueryValueEx(bkey, name)[0]
except (OSError, IOError):
pass
class SystemInfo:
"""
Microsoft Windows and Visual Studio related system information.
Parameters
----------
registry_info: RegistryInfo
"RegistryInfo" instance.
vc_ver: float
Required Microsoft Visual C++ version.
"""
# Variables and properties in this class use originals CamelCase variables
# names from Microsoft source files for more easy comparison.
WinDir = environ.get('WinDir', '')
ProgramFiles = environ.get('ProgramFiles', '')
ProgramFilesx86 = environ.get('ProgramFiles(x86)', ProgramFiles)
def __init__(self, registry_info, vc_ver=None):
self.ri = registry_info
self.pi = self.ri.pi
self.known_vs_paths = self.find_programdata_vs_vers()
# Except for VS15+, VC version is aligned with VS version
self.vs_ver = self.vc_ver = (
vc_ver or self._find_latest_available_vs_ver())
def _find_latest_available_vs_ver(self):
"""
Find the latest VC version
Return
------
float
version
"""
reg_vc_vers = self.find_reg_vs_vers()
if not (reg_vc_vers or self.known_vs_paths):
raise distutils.errors.DistutilsPlatformError(
'No Microsoft Visual C++ version found')
vc_vers = set(reg_vc_vers)
vc_vers.update(self.known_vs_paths)
return sorted(vc_vers)[-1]
def find_reg_vs_vers(self):
"""
Find Microsoft Visual Studio versions available in registry.
Return
------
list of float
Versions
"""
ms = self.ri.microsoft
vckeys = (self.ri.vc, self.ri.vc_for_python, self.ri.vs)
vs_vers = []
for hkey in self.ri.HKEYS:
for key in vckeys:
try:
bkey = winreg.OpenKey(hkey, ms(key), 0, winreg.KEY_READ)
except (OSError, IOError):
continue
subkeys, values, _ = winreg.QueryInfoKey(bkey)
for i in range(values):
try:
ver = float(winreg.EnumValue(bkey, i)[0])
if ver not in vs_vers:
vs_vers.append(ver)
except ValueError:
pass
for i in range(subkeys):
try:
ver = float(winreg.EnumKey(bkey, i))
if ver not in vs_vers:
vs_vers.append(ver)
except ValueError:
pass
return sorted(vs_vers)
def find_programdata_vs_vers(self):
r"""
Find Visual studio 2017+ versions from information in
"C:\ProgramData\Microsoft\VisualStudio\Packages\_Instances".
Return
------
dict
float version as key, path as value.
"""
vs_versions = {}
instances_dir = \
r'C:\ProgramData\Microsoft\VisualStudio\Packages\_Instances'
try:
hashed_names = listdir(instances_dir)
except (OSError, IOError):
# Directory not exists with all Visual Studio versions
return vs_versions
for name in hashed_names:
try:
# Get VS installation path from "state.json" file
state_path = join(instances_dir, name, 'state.json')
with open(state_path, 'rt', encoding='utf-8') as state_file:
state = json.load(state_file)
vs_path = state['installationPath']
# Raises OSError if this VS installation does not contain VC
listdir(join(vs_path, r'VC\Tools\MSVC'))
# Store version and path
vs_versions[self._as_float_version(
state['installationVersion'])] = vs_path
except (OSError, IOError, KeyError):
# Skip if "state.json" file is missing or bad format
continue
return vs_versions
@staticmethod
def _as_float_version(version):
"""
Return a string version as a simplified float version (major.minor)
Parameters
----------
version: str
Version.
Return
------
float
version
"""
return float('.'.join(version.split('.')[:2]))
@property
def VSInstallDir(self):
"""
Microsoft Visual Studio directory.
Return
------
str
path
"""
# Default path
default = join(self.ProgramFilesx86,
'Microsoft Visual Studio %0.1f' % self.vs_ver)
# Try to get path from registry, if fail use default path
return self.ri.lookup(self.ri.vs, '%0.1f' % self.vs_ver) or default
@property
def VCInstallDir(self):
"""
Microsoft Visual C++ directory.
Return
------
str
path
"""
path = self._guess_vc() or self._guess_vc_legacy()
if not isdir(path):
msg = 'Microsoft Visual C++ directory not found'
raise distutils.errors.DistutilsPlatformError(msg)
return path
def _guess_vc(self):
"""
Locate Visual C++ for VS2017+.
Return
------
str
path
"""
if self.vs_ver <= 14.0:
return ''
try:
# First search in known VS paths
vs_dir = self.known_vs_paths[self.vs_ver]
except KeyError:
# Else, search with path from registry
vs_dir = self.VSInstallDir
guess_vc = join(vs_dir, r'VC\Tools\MSVC')
# Subdir with VC exact version as name
try:
# Update the VC version with real one instead of VS version
vc_ver = listdir(guess_vc)[-1]
self.vc_ver = self._as_float_version(vc_ver)
return join(guess_vc, vc_ver)
except (OSError, IOError, IndexError):
return ''
def _guess_vc_legacy(self):
"""
Locate Visual C++ for versions prior to 2017.
Return
------
str
path
"""
default = join(self.ProgramFilesx86,
r'Microsoft Visual Studio %0.1f\VC' % self.vs_ver)
# Try to get "VC++ for Python" path from registry as default path
reg_path = join(self.ri.vc_for_python, '%0.1f' % self.vs_ver)
python_vc = self.ri.lookup(reg_path, 'installdir')
default_vc = join(python_vc, 'VC') if python_vc else default
# Try to get path from registry, if fail use default path
return self.ri.lookup(self.ri.vc, '%0.1f' % self.vs_ver) or default_vc
@property
def WindowsSdkVersion(self):
"""
Microsoft Windows SDK versions for specified MSVC++ version.
Return
------
tuple of str
versions
"""
if self.vs_ver <= 9.0:
return '7.0', '6.1', '6.0a'
elif self.vs_ver == 10.0:
return '7.1', '7.0a'
elif self.vs_ver == 11.0:
return '8.0', '8.0a'
elif self.vs_ver == 12.0:
return '8.1', '8.1a'
elif self.vs_ver >= 14.0:
return '10.0', '8.1'
@property
def WindowsSdkLastVersion(self):
"""
Microsoft Windows SDK last version.
Return
------
str
version
"""
return self._use_last_dir_name(join(self.WindowsSdkDir, 'lib'))
@property
def WindowsSdkDir(self):
"""
Microsoft Windows SDK directory.
Return
------
str
path
"""
sdkdir = ''
for ver in self.WindowsSdkVersion:
# Try to get it from registry
loc = join(self.ri.windows_sdk, 'v%s' % ver)
sdkdir = self.ri.lookup(loc, 'installationfolder')
if sdkdir:
break
if not sdkdir or not isdir(sdkdir):
# Try to get "VC++ for Python" version from registry
path = join(self.ri.vc_for_python, '%0.1f' % self.vc_ver)
install_base = self.ri.lookup(path, 'installdir')
if install_base:
sdkdir = join(install_base, 'WinSDK')
if not sdkdir or not isdir(sdkdir):
# If fail, use default new path
for ver in self.WindowsSdkVersion:
intver = ver[:ver.rfind('.')]
path = r'Microsoft SDKs\Windows Kits\%s' % intver
d = join(self.ProgramFiles, path)
if isdir(d):
sdkdir = d
if not sdkdir or not isdir(sdkdir):
# If fail, use default old path
for ver in self.WindowsSdkVersion:
path = r'Microsoft SDKs\Windows\v%s' % ver
d = join(self.ProgramFiles, path)
if isdir(d):
sdkdir = d
if not sdkdir:
# If fail, use Platform SDK
sdkdir = join(self.VCInstallDir, 'PlatformSDK')
return sdkdir
@property
def WindowsSDKExecutablePath(self):
"""
Microsoft Windows SDK executable directory.
Return
------
str
path
"""
# Find WinSDK NetFx Tools registry dir name
if self.vs_ver <= 11.0:
netfxver = 35
arch = ''
else:
netfxver = 40
hidex86 = True if self.vs_ver <= 12.0 else False
arch = self.pi.current_dir(x64=True, hidex86=hidex86)
fx = 'WinSDK-NetFx%dTools%s' % (netfxver, arch.replace('\\', '-'))
# list all possibles registry paths
regpaths = []
if self.vs_ver >= 14.0:
for ver in self.NetFxSdkVersion:
regpaths += [join(self.ri.netfx_sdk, ver, fx)]
for ver in self.WindowsSdkVersion:
regpaths += [join(self.ri.windows_sdk, 'v%sA' % ver, fx)]
# Return installation folder from the more recent path
for path in regpaths:
execpath = self.ri.lookup(path, 'installationfolder')
if execpath:
return execpath
@property
def FSharpInstallDir(self):
"""
Microsoft Visual F# directory.
Return
------
str
path
"""
path = join(self.ri.visualstudio, r'%0.1f\Setup\F#' % self.vs_ver)
return self.ri.lookup(path, 'productdir') or ''
@property
def UniversalCRTSdkDir(self):
"""
Microsoft Universal CRT SDK directory.
Return
------
str
path
"""
# Set Kit Roots versions for specified MSVC++ version
vers = ('10', '81') if self.vs_ver >= 14.0 else ()
# Find path of the more recent Kit
for ver in vers:
sdkdir = self.ri.lookup(self.ri.windows_kits_roots,
'kitsroot%s' % ver)
if sdkdir:
return sdkdir or ''
@property
def UniversalCRTSdkLastVersion(self):
"""
Microsoft Universal C Runtime SDK last version.
Return
------
str
version
"""
return self._use_last_dir_name(join(self.UniversalCRTSdkDir, 'lib'))
@property
def NetFxSdkVersion(self):
"""
Microsoft .NET Framework SDK versions.
Return
------
tuple of str
versions
"""
# Set FxSdk versions for specified VS version
return (('4.7.2', '4.7.1', '4.7',
'4.6.2', '4.6.1', '4.6',
'4.5.2', '4.5.1', '4.5')
if self.vs_ver >= 14.0 else ())
@property
def NetFxSdkDir(self):
"""
Microsoft .NET Framework SDK directory.
Return
------
str
path
"""
sdkdir = ''
for ver in self.NetFxSdkVersion:
loc = join(self.ri.netfx_sdk, ver)
sdkdir = self.ri.lookup(loc, 'kitsinstallationfolder')
if sdkdir:
break
return sdkdir
@property
def FrameworkDir32(self):
"""
Microsoft .NET Framework 32bit directory.
Return
------
str
path
"""
# Default path
guess_fw = join(self.WinDir, r'Microsoft.NET\Framework')
# Try to get path from registry, if fail use default path
return self.ri.lookup(self.ri.vc, 'frameworkdir32') or guess_fw
@property
def FrameworkDir64(self):
"""
Microsoft .NET Framework 64bit directory.
Return
------
str
path
"""
# Default path
guess_fw = join(self.WinDir, r'Microsoft.NET\Framework64')
# Try to get path from registry, if fail use default path
return self.ri.lookup(self.ri.vc, 'frameworkdir64') or guess_fw
@property
def FrameworkVersion32(self):
"""
Microsoft .NET Framework 32bit versions.
Return
------
tuple of str
versions
"""
return self._find_dot_net_versions(32)
@property
def FrameworkVersion64(self):
"""
Microsoft .NET Framework 64bit versions.
Return
------
tuple of str
versions
"""
return self._find_dot_net_versions(64)
def _find_dot_net_versions(self, bits):
"""
Find Microsoft .NET Framework versions.
Parameters
----------
bits: int
Platform number of bits: 32 or 64.
Return
------
tuple of str
versions
"""
# Find actual .NET version in registry
reg_ver = self.ri.lookup(self.ri.vc, 'frameworkver%d' % bits)
dot_net_dir = getattr(self, 'FrameworkDir%d' % bits)
ver = reg_ver or self._use_last_dir_name(dot_net_dir, 'v') or ''
# Set .NET versions for specified MSVC++ version
if self.vs_ver >= 12.0:
return ver, 'v4.0'
elif self.vs_ver >= 10.0:
return 'v4.0.30319' if ver.lower()[:2] != 'v4' else ver, 'v3.5'
elif self.vs_ver == 9.0:
return 'v3.5', 'v2.0.50727'
elif self.vs_ver == 8.0:
return 'v3.0', 'v2.0.50727'
@staticmethod
def _use_last_dir_name(path, prefix=''):
"""
Return name of the last dir in path or '' if no dir found.
Parameters
----------
path: str
Use dirs in this path
prefix: str
Use only dirs starting by this prefix
Return
------
str
name
"""
matching_dirs = (
dir_name
for dir_name in reversed(listdir(path))
if isdir(join(path, dir_name)) and
dir_name.startswith(prefix)
)
return next(matching_dirs, None) or ''
class EnvironmentInfo:
"""
Return environment variables for specified Microsoft Visual C++ version
and platform : Lib, Include, Path and libpath.
This function is compatible with Microsoft Visual C++ 9.0 to 14.X.
Script created by analysing Microsoft environment configuration files like
"vcvars[...].bat", "SetEnv.Cmd", "vcbuildtools.bat", ...
Parameters
----------
arch: str
Target architecture.
vc_ver: float
Required Microsoft Visual C++ version. If not set, autodetect the last
version.
vc_min_ver: float
Minimum Microsoft Visual C++ version.
"""
# Variables and properties in this class use originals CamelCase variables
# names from Microsoft source files for more easy comparison.
def __init__(self, arch, vc_ver=None, vc_min_ver=0):
self.pi = PlatformInfo(arch)
self.ri = RegistryInfo(self.pi)
self.si = SystemInfo(self.ri, vc_ver)
if self.vc_ver < vc_min_ver:
err = 'No suitable Microsoft Visual C++ version found'
raise distutils.errors.DistutilsPlatformError(err)
@property
def vs_ver(self):
"""
Microsoft Visual Studio.
Return
------
float
version
"""
return self.si.vs_ver
@property
def vc_ver(self):
"""
Microsoft Visual C++ version.
Return
------
float
version
"""
return self.si.vc_ver
@property
def VSTools(self):
"""
Microsoft Visual Studio Tools.
Return
------
list of str
paths
"""
paths = [r'Common7\IDE', r'Common7\Tools']
if self.vs_ver >= 14.0:
arch_subdir = self.pi.current_dir(hidex86=True, x64=True)
paths += [r'Common7\IDE\CommonExtensions\Microsoft\TestWindow']
paths += [r'Team Tools\Performance Tools']
paths += [r'Team Tools\Performance Tools%s' % arch_subdir]
return [join(self.si.VSInstallDir, path) for path in paths]
@property
def VCIncludes(self):
"""
Microsoft Visual C++ & Microsoft Foundation Class Includes.
Return
------
list of str
paths
"""
return [join(self.si.VCInstallDir, 'Include'),
join(self.si.VCInstallDir, r'ATLMFC\Include')]
@property
def VCLibraries(self):
"""
Microsoft Visual C++ & Microsoft Foundation Class Libraries.
Return
------
list of str
paths
"""
if self.vs_ver >= 15.0:
arch_subdir = self.pi.target_dir(x64=True)
else:
arch_subdir = self.pi.target_dir(hidex86=True)
paths = ['Lib%s' % arch_subdir, r'ATLMFC\Lib%s' % arch_subdir]
if self.vs_ver >= 14.0:
paths += [r'Lib\store%s' % arch_subdir]
return [join(self.si.VCInstallDir, path) for path in paths]
@property
def VCStoreRefs(self):
"""
Microsoft Visual C++ store references Libraries.
Return
------
list of str
paths
"""
if self.vs_ver < 14.0:
return []
return [join(self.si.VCInstallDir, r'Lib\store\references')]
@property
def VCTools(self):
"""
Microsoft Visual C++ Tools.
Return
------
list of str
paths
"""
si = self.si
tools = [join(si.VCInstallDir, 'VCPackages')]
forcex86 = True if self.vs_ver <= 10.0 else False
arch_subdir = self.pi.cross_dir(forcex86)
if arch_subdir:
tools += [join(si.VCInstallDir, 'Bin%s' % arch_subdir)]
if self.vs_ver == 14.0:
path = 'Bin%s' % self.pi.current_dir(hidex86=True)
tools += [join(si.VCInstallDir, path)]
elif self.vs_ver >= 15.0:
host_dir = (r'bin\HostX86%s' if self.pi.current_is_x86() else
r'bin\HostX64%s')
tools += [join(
si.VCInstallDir, host_dir % self.pi.target_dir(x64=True))]
if self.pi.current_cpu != self.pi.target_cpu:
tools += [join(
si.VCInstallDir, host_dir % self.pi.current_dir(x64=True))]
else:
tools += [join(si.VCInstallDir, 'Bin')]
return tools
@property
def OSLibraries(self):
"""
Microsoft Windows SDK Libraries.
Return
------
list of str
paths
"""
if self.vs_ver <= 10.0:
arch_subdir = self.pi.target_dir(hidex86=True, x64=True)
return [join(self.si.WindowsSdkDir, 'Lib%s' % arch_subdir)]
else:
arch_subdir = self.pi.target_dir(x64=True)
lib = join(self.si.WindowsSdkDir, 'lib')
libver = self._sdk_subdir
return [join(lib, '%sum%s' % (libver , arch_subdir))]
@property
def OSIncludes(self):
"""
Microsoft Windows SDK Include.
Return
------
list of str
paths
"""
include = join(self.si.WindowsSdkDir, 'include')
if self.vs_ver <= 10.0:
return [include, join(include, 'gl')]
else:
if self.vs_ver >= 14.0:
sdkver = self._sdk_subdir
else:
sdkver = ''
return [join(include, '%sshared' % sdkver),
join(include, '%sum' % sdkver),
join(include, '%swinrt' % sdkver)]
@property
def OSLibpath(self):
"""
Microsoft Windows SDK Libraries Paths.
Return
------
list of str
paths
"""
ref = join(self.si.WindowsSdkDir, 'References')
libpath = []
if self.vs_ver <= 9.0:
libpath += self.OSLibraries
if self.vs_ver >= 11.0:
libpath += [join(ref, r'CommonConfiguration\Neutral')]
if self.vs_ver >= 14.0:
libpath += [
ref,
join(self.si.WindowsSdkDir, 'UnionMetadata'),
join(ref, 'Windows.Foundation.UniversalApiContract', '1.0.0.0'),
join(ref, 'Windows.Foundation.FoundationContract', '1.0.0.0'),
join(ref,'Windows.Networking.Connectivity.WwanContract',
'1.0.0.0'),
join(self.si.WindowsSdkDir, 'ExtensionSDKs', 'Microsoft.VCLibs',
'%0.1f' % self.vs_ver, 'References', 'CommonConfiguration',
'neutral'),
]
return libpath
@property
def SdkTools(self):
"""
Microsoft Windows SDK Tools.
Return
------
list of str
paths
"""
return list(self._sdk_tools())
def _sdk_tools(self):
"""
Microsoft Windows SDK Tools paths generator.
Return
------
generator of str
paths
"""
if self.vs_ver < 15.0:
bin_dir = 'Bin' if self.vs_ver <= 11.0 else r'Bin\x86'
yield join(self.si.WindowsSdkDir, bin_dir)
if not self.pi.current_is_x86():
arch_subdir = self.pi.current_dir(x64=True)
path = 'Bin%s' % arch_subdir
yield join(self.si.WindowsSdkDir, path)
if self.vs_ver in (10.0, 11.0):
if self.pi.target_is_x86():
arch_subdir = ''
else:
arch_subdir = self.pi.current_dir(hidex86=True, x64=True)
path = r'Bin\NETFX 4.0 Tools%s' % arch_subdir
yield join(self.si.WindowsSdkDir, path)
elif self.vs_ver >= 15.0:
path = join(self.si.WindowsSdkDir, 'Bin')
arch_subdir = self.pi.current_dir(x64=True)
sdkver = self.si.WindowsSdkLastVersion
yield join(path, '%s%s' % (sdkver, arch_subdir))
if self.si.WindowsSDKExecutablePath:
yield self.si.WindowsSDKExecutablePath
@property
def _sdk_subdir(self):
"""
Microsoft Windows SDK version subdir.
Return
------
str
subdir
"""
ucrtver = self.si.WindowsSdkLastVersion
return ('%s\\' % ucrtver) if ucrtver else ''
@property
def SdkSetup(self):
"""
Microsoft Windows SDK Setup.
Return
------
list of str
paths
"""
if self.vs_ver > 9.0:
return []
return [join(self.si.WindowsSdkDir, 'Setup')]
@property
def FxTools(self):
"""
Microsoft .NET Framework Tools.
Return
------
list of str
paths
"""
pi = self.pi
si = self.si
if self.vs_ver <= 10.0:
include32 = True
include64 = not pi.target_is_x86() and not pi.current_is_x86()
else:
include32 = pi.target_is_x86() or pi.current_is_x86()
include64 = pi.current_cpu == 'amd64' or pi.target_cpu == 'amd64'
tools = []
if include32:
tools += [join(si.FrameworkDir32, ver)
for ver in si.FrameworkVersion32]
if include64:
tools += [join(si.FrameworkDir64, ver)
for ver in si.FrameworkVersion64]
return tools
@property
def NetFxSDKLibraries(self):
"""
Microsoft .Net Framework SDK Libraries.
Return
------
list of str
paths
"""
if self.vs_ver < 14.0 or not self.si.NetFxSdkDir:
return []
arch_subdir = self.pi.target_dir(x64=True)
return [join(self.si.NetFxSdkDir, r'lib\um%s' % arch_subdir)]
@property
def NetFxSDKIncludes(self):
"""
Microsoft .Net Framework SDK Includes.
Return
------
list of str
paths
"""
if self.vs_ver < 14.0 or not self.si.NetFxSdkDir:
return []
return [join(self.si.NetFxSdkDir, r'include\um')]
@property
def VsTDb(self):
"""
Microsoft Visual Studio Team System Database.
Return
------
list of str
paths
"""
return [join(self.si.VSInstallDir, r'VSTSDB\Deploy')]
@property
def MSBuild(self):
"""
Microsoft Build Engine.
Return
------
list of str
paths
"""
if self.vs_ver < 12.0:
return []
elif self.vs_ver < 15.0:
base_path = self.si.ProgramFilesx86
arch_subdir = self.pi.current_dir(hidex86=True)
else:
base_path = self.si.VSInstallDir
arch_subdir = ''
path = r'MSBuild\%0.1f\bin%s' % (self.vs_ver, arch_subdir)
build = [join(base_path, path)]
if self.vs_ver >= 15.0:
# Add Roslyn C# & Visual Basic Compiler
build += [join(base_path, path, 'Roslyn')]
return build
@property
def HTMLHelpWorkshop(self):
"""
Microsoft HTML Help Workshop.
Return
------
list of str
paths
"""
if self.vs_ver < 11.0:
return []
return [join(self.si.ProgramFilesx86, 'HTML Help Workshop')]
@property
def UCRTLibraries(self):
"""
Microsoft Universal C Runtime SDK Libraries.
Return
------
list of str
paths
"""
if self.vs_ver < 14.0:
return []
arch_subdir = self.pi.target_dir(x64=True)
lib = join(self.si.UniversalCRTSdkDir, 'lib')
ucrtver = self._ucrt_subdir
return [join(lib, '%sucrt%s' % (ucrtver, arch_subdir))]
@property
def UCRTIncludes(self):
"""
Microsoft Universal C Runtime SDK Include.
Return
------
list of str
paths
"""
if self.vs_ver < 14.0:
return []
include = join(self.si.UniversalCRTSdkDir, 'include')
return [join(include, '%sucrt' % self._ucrt_subdir)]
@property
def _ucrt_subdir(self):
"""
Microsoft Universal C Runtime SDK version subdir.
Return
------
str
subdir
"""
ucrtver = self.si.UniversalCRTSdkLastVersion
return ('%s\\' % ucrtver) if ucrtver else ''
@property
def FSharp(self):
"""
Microsoft Visual F#.
Return
------
list of str
paths
"""
if 11.0 > self.vs_ver > 12.0:
return []
return [self.si.FSharpInstallDir]
@property
def VCRuntimeRedist(self):
"""
Microsoft Visual C++ runtime redistributable dll.
Return
------
str
path
"""
vcruntime = 'vcruntime%d0.dll' % self.vc_ver
arch_subdir = self.pi.target_dir(x64=True).strip('\\')
# Installation prefixes candidates
prefixes = []
tools_path = self.si.VCInstallDir
redist_path = dirname(tools_path.replace(r'\Tools', r'\Redist'))
if isdir(redist_path):
# Redist version may not be exactly the same as tools
redist_path = join(redist_path, listdir(redist_path)[-1])
prefixes += [redist_path, join(redist_path, 'onecore')]
prefixes += [join(tools_path, 'redist')] # VS14 legacy path
# CRT directory
crt_dirs = ('Microsoft.VC%d.CRT' % (self.vc_ver * 10),
# Sometime store in directory with VS version instead of VC
'Microsoft.VC%d.CRT' % (int(self.vs_ver) * 10))
# vcruntime path
for prefix, crt_dir in itertools.product(prefixes, crt_dirs):
path = join(prefix, arch_subdir, crt_dir, vcruntime)
if isfile(path):
return path
def return_env(self, exists=True):
"""
Return environment dict.
Parameters
----------
exists: bool
It True, only return existing paths.
Return
------
dict
environment
"""
env = dict(
include=self._build_paths('include',
[self.VCIncludes,
self.OSIncludes,
self.UCRTIncludes,
self.NetFxSDKIncludes],
exists),
lib=self._build_paths('lib',
[self.VCLibraries,
self.OSLibraries,
self.FxTools,
self.UCRTLibraries,
self.NetFxSDKLibraries],
exists),
libpath=self._build_paths('libpath',
[self.VCLibraries,
self.FxTools,
self.VCStoreRefs,
self.OSLibpath],
exists),
path=self._build_paths('path',
[self.VCTools,
self.VSTools,
self.VsTDb,
self.SdkTools,
self.SdkSetup,
self.FxTools,
self.MSBuild,
self.HTMLHelpWorkshop,
self.FSharp],
exists),
)
if self.vs_ver >= 14 and isfile(self.VCRuntimeRedist):
env['py_vcruntime_redist'] = self.VCRuntimeRedist
return env
def _build_paths(self, name, spec_path_lists, exists):
"""
Given an environment variable name and specified paths,
return a pathsep-separated string of paths containing
unique, extant, directories from those paths and from
the environment variable. Raise an error if no paths
are resolved.
Parameters
----------
name: str
Environment variable name
spec_path_lists: list of str
Paths
exists: bool
It True, only return existing paths.
Return
------
str
Pathsep-separated paths
"""
# flatten spec_path_lists
spec_paths = itertools.chain.from_iterable(spec_path_lists)
env_paths = environ.get(name, '').split(pathsep)
paths = itertools.chain(spec_paths, env_paths)
extant_paths = list(filter(isdir, paths)) if exists else paths
if not extant_paths:
msg = "%s environment variable is empty" % name.upper()
raise distutils.errors.DistutilsPlatformError(msg)
unique_paths = self._unique_everseen(extant_paths)
return pathsep.join(unique_paths)
# from Python docs
@staticmethod
def _unique_everseen(iterable, key=None):
"""
List unique elements, preserving order.
Remember all elements ever seen.
_unique_everseen('AAAABBBCCDAABBB') --> A B C D
_unique_everseen('ABBCcAD', str.lower) --> A B C D
"""
seen = set()
seen_add = seen.add
if key is None:
for element in filterfalse(seen.__contains__, iterable):
seen_add(element)
yield element
else:
for element in iterable:
k = key(element)
if k not in seen:
seen_add(k)
yield element
PK ! s s __init__.pynu [ """Extensions to the 'distutils' for large or complex distributions"""
import os
import sys
import functools
import distutils.core
import distutils.filelist
import re
from distutils.errors import DistutilsOptionError
from distutils.util import convert_path
from fnmatch import fnmatchcase
from ._deprecation_warning import SetuptoolsDeprecationWarning
from setuptools.extern.six import PY3, string_types
from setuptools.extern.six.moves import filter, map
import setuptools.version
from setuptools.extension import Extension
from setuptools.dist import Distribution, Feature
from setuptools.depends import Require
from . import monkey
__metaclass__ = type
__all__ = [
'setup', 'Distribution', 'Feature', 'Command', 'Extension', 'Require',
'SetuptoolsDeprecationWarning',
'find_packages'
]
if PY3:
__all__.append('find_namespace_packages')
__version__ = setuptools.version.__version__
bootstrap_install_from = None
# If we run 2to3 on .py files, should we also convert docstrings?
# Default: yes; assume that we can detect doctests reliably
run_2to3_on_doctests = True
# Standard package names for fixer packages
lib2to3_fixer_packages = ['lib2to3.fixes']
class PackageFinder:
"""
Generate a list of all Python packages found within a directory
"""
@classmethod
def find(cls, where='.', exclude=(), include=('*',)):
"""Return a list all Python packages found within directory 'where'
'where' is the root directory which will be searched for packages. It
should be supplied as a "cross-platform" (i.e. URL-style) path; it will
be converted to the appropriate local path syntax.
'exclude' is a sequence of package names to exclude; '*' can be used
as a wildcard in the names, such that 'foo.*' will exclude all
subpackages of 'foo' (but not 'foo' itself).
'include' is a sequence of package names to include. If it's
specified, only the named packages will be included. If it's not
specified, all found packages will be included. 'include' can contain
shell style wildcard patterns just like 'exclude'.
"""
return list(cls._find_packages_iter(
convert_path(where),
cls._build_filter('ez_setup', '*__pycache__', *exclude),
cls._build_filter(*include)))
@classmethod
def _find_packages_iter(cls, where, exclude, include):
"""
All the packages found in 'where' that pass the 'include' filter, but
not the 'exclude' filter.
"""
for root, dirs, files in os.walk(where, followlinks=True):
# Copy dirs to iterate over it, then empty dirs.
all_dirs = dirs[:]
dirs[:] = []
for dir in all_dirs:
full_path = os.path.join(root, dir)
rel_path = os.path.relpath(full_path, where)
package = rel_path.replace(os.path.sep, '.')
# Skip directory trees that are not valid packages
if ('.' in dir or not cls._looks_like_package(full_path)):
continue
# Should this package be included?
if include(package) and not exclude(package):
yield package
# Keep searching subdirectories, as there may be more packages
# down there, even if the parent was excluded.
dirs.append(dir)
@staticmethod
def _looks_like_package(path):
"""Does a directory look like a package?"""
return os.path.isfile(os.path.join(path, '__init__.py'))
@staticmethod
def _build_filter(*patterns):
"""
Given a list of patterns, return a callable that will be true only if
the input matches at least one of the patterns.
"""
return lambda name: any(fnmatchcase(name, pat=pat) for pat in patterns)
class PEP420PackageFinder(PackageFinder):
@staticmethod
def _looks_like_package(path):
return True
find_packages = PackageFinder.find
if PY3:
find_namespace_packages = PEP420PackageFinder.find
def _install_setup_requires(attrs):
# Note: do not use `setuptools.Distribution` directly, as
# our PEP 517 backend patch `distutils.core.Distribution`.
dist = distutils.core.Distribution(dict(
(k, v) for k, v in attrs.items()
if k in ('dependency_links', 'setup_requires')
))
# Honor setup.cfg's options.
dist.parse_config_files(ignore_option_errors=True)
if dist.setup_requires:
dist.fetch_build_eggs(dist.setup_requires)
def setup(**attrs):
# Make sure we have any requirements needed to interpret 'attrs'.
_install_setup_requires(attrs)
return distutils.core.setup(**attrs)
setup.__doc__ = distutils.core.setup.__doc__
_Command = monkey.get_unpatched(distutils.core.Command)
class Command(_Command):
__doc__ = _Command.__doc__
command_consumes_arguments = False
def __init__(self, dist, **kw):
"""
Construct the command for dist, updating
vars(self) with any keyword parameters.
"""
_Command.__init__(self, dist)
vars(self).update(kw)
def _ensure_stringlike(self, option, what, default=None):
val = getattr(self, option)
if val is None:
setattr(self, option, default)
return default
elif not isinstance(val, string_types):
raise DistutilsOptionError("'%s' must be a %s (got `%s`)"
% (option, what, val))
return val
def ensure_string_list(self, option):
r"""Ensure that 'option' is a list of strings. If 'option' is
currently a string, we split it either on /,\s*/ or /\s+/, so
"foo bar baz", "foo,bar,baz", and "foo, bar baz" all become
["foo", "bar", "baz"].
"""
val = getattr(self, option)
if val is None:
return
elif isinstance(val, string_types):
setattr(self, option, re.split(r',\s*|\s+', val))
else:
if isinstance(val, list):
ok = all(isinstance(v, string_types) for v in val)
else:
ok = False
if not ok:
raise DistutilsOptionError(
"'%s' must be a list of strings (got %r)"
% (option, val))
def reinitialize_command(self, command, reinit_subcommands=0, **kw):
cmd = _Command.reinitialize_command(self, command, reinit_subcommands)
vars(cmd).update(kw)
return cmd
def _find_all_simple(path):
"""
Find all files under 'path'
"""
results = (
os.path.join(base, file)
for base, dirs, files in os.walk(path, followlinks=True)
for file in files
)
return filter(os.path.isfile, results)
def findall(dir=os.curdir):
"""
Find all files under 'dir' and return the list of full filenames.
Unless dir is '.', return full filenames with dir prepended.
"""
files = _find_all_simple(dir)
if dir == os.curdir:
make_rel = functools.partial(os.path.relpath, start=dir)
files = map(make_rel, files)
return list(files)
# Apply monkey patches
monkey.patch_all()
PK ! c
namespaces.pynu [ import os
from distutils import log
import itertools
from setuptools.extern.six.moves import map
flatten = itertools.chain.from_iterable
class Installer:
nspkg_ext = '-nspkg.pth'
def install_namespaces(self):
nsp = self._get_all_ns_packages()
if not nsp:
return
filename, ext = os.path.splitext(self._get_target())
filename += self.nspkg_ext
self.outputs.append(filename)
log.info("Installing %s", filename)
lines = map(self._gen_nspkg_line, nsp)
if self.dry_run:
# always generate the lines, even in dry run
list(lines)
return
with open(filename, 'wt') as f:
f.writelines(lines)
def uninstall_namespaces(self):
filename, ext = os.path.splitext(self._get_target())
filename += self.nspkg_ext
if not os.path.exists(filename):
return
log.info("Removing %s", filename)
os.remove(filename)
def _get_target(self):
return self.target
_nspkg_tmpl = (
"import sys, types, os",
"has_mfs = sys.version_info > (3, 5)",
"p = os.path.join(%(root)s, *%(pth)r)",
"importlib = has_mfs and __import__('importlib.util')",
"has_mfs and __import__('importlib.machinery')",
"m = has_mfs and "
"sys.modules.setdefault(%(pkg)r, "
"importlib.util.module_from_spec("
"importlib.machinery.PathFinder.find_spec(%(pkg)r, "
"[os.path.dirname(p)])))",
"m = m or "
"sys.modules.setdefault(%(pkg)r, types.ModuleType(%(pkg)r))",
"mp = (m or []) and m.__dict__.setdefault('__path__',[])",
"(p not in mp) and mp.append(p)",
)
"lines for the namespace installer"
_nspkg_tmpl_multi = (
'm and setattr(sys.modules[%(parent)r], %(child)r, m)',
)
"additional line(s) when a parent package is indicated"
def _get_root(self):
return "sys._getframe(1).f_locals['sitedir']"
def _gen_nspkg_line(self, pkg):
# ensure pkg is not a unicode string under Python 2.7
pkg = str(pkg)
pth = tuple(pkg.split('.'))
root = self._get_root()
tmpl_lines = self._nspkg_tmpl
parent, sep, child = pkg.rpartition('.')
if parent:
tmpl_lines += self._nspkg_tmpl_multi
return ';'.join(tmpl_lines) % locals() + '\n'
def _get_all_ns_packages(self):
"""Return sorted list of all package namespaces"""
pkgs = self.distribution.namespace_packages or []
return sorted(flatten(map(self._pkg_names, pkgs)))
@staticmethod
def _pkg_names(pkg):
"""
Given a namespace package, yield the components of that
package.
>>> names = Installer._pkg_names('a.b.c')
>>> set(names) == set(['a', 'a.b', 'a.b.c'])
True
"""
parts = pkg.split('.')
while parts:
yield '.'.join(parts)
parts.pop()
class DevelopInstaller(Installer):
def _get_root(self):
return repr(str(self.egg_path))
def _get_target(self):
return self.egg_link
PK ! 0F F
py31compat.pynu [ __all__ = []
__metaclass__ = type
try:
# Python >=3.2
from tempfile import TemporaryDirectory
except ImportError:
import shutil
import tempfile
class TemporaryDirectory:
"""
Very simple temporary directory context manager.
Will try to delete afterward, but will also ignore OS and similar
errors on deletion.
"""
def __init__(self, **kwargs):
self.name = None # Handle mkdtemp raising an exception
self.name = tempfile.mkdtemp(**kwargs)
def __enter__(self):
return self.name
def __exit__(self, exctype, excvalue, exctrace):
try:
shutil.rmtree(self.name, True)
except OSError: # removal errors are not the only possible
pass
self.name = None
PK ! $l extern/__init__.pynu [ import sys
class VendorImporter:
"""
A PEP 302 meta path importer for finding optionally-vendored
or otherwise naturally-installed packages from root_name.
"""
def __init__(self, root_name, vendored_names=(), vendor_pkg=None):
self.root_name = root_name
self.vendored_names = set(vendored_names)
self.vendor_pkg = vendor_pkg or root_name.replace('extern', '_vendor')
@property
def search_path(self):
"""
Search first the vendor package then as a natural package.
"""
yield self.vendor_pkg + '.'
yield ''
def find_module(self, fullname, path=None):
"""
Return self when fullname starts with root_name and the
target module is one vendored through this importer.
"""
root, base, target = fullname.partition(self.root_name + '.')
if root:
return
if not any(map(target.startswith, self.vendored_names)):
return
return self
def load_module(self, fullname):
"""
Iterate over the search path to locate and load fullname.
"""
root, base, target = fullname.partition(self.root_name + '.')
for prefix in self.search_path:
try:
extant = prefix + target
__import__(extant)
mod = sys.modules[extant]
sys.modules[fullname] = mod
# mysterious hack:
# Remove the reference to the extant package/module
# on later Python versions to cause relative imports
# in the vendor package to resolve the same modules
# as those going through this importer.
if sys.version_info >= (3, ):
del sys.modules[extant]
return mod
except ImportError:
pass
else:
raise ImportError(
"The '{target}' package is required; "
"normally this is bundled with this package so if you get "
"this warning, consult the packager of your "
"distribution.".format(**locals())
)
def install(self):
"""
Install this importer into sys.meta_path if not already present.
"""
if self not in sys.meta_path:
sys.meta_path.append(self)
names = 'six', 'packaging', 'pyparsing', 'ordered_set',
VendorImporter(__name__, names, 'setuptools._vendor').install()
PK ! t t 0 extern/__pycache__/__init__.cpython-38.opt-1.pycnu [ U
Qab @ s. d dl Z G dd dZdZeeed dS ) Nc @ s@ e Zd ZdZdddZedd Zddd Zd
d Zd d
Z dS )VendorImporterz
A PEP 302 meta path importer for finding optionally-vendored
or otherwise naturally-installed packages from root_name.
Nc C s& || _ t|| _|p |dd| _d S )NZexternZ_vendor) root_namesetvendored_namesreplace
vendor_pkg)selfr r r r r >/usr/lib/python3.8/site-packages/setuptools/extern/__init__.py__init__
s
zVendorImporter.__init__c c s | j d V dV dS )zL
Search first the vendor package then as a natural package.
. N)r r r r r
search_path s zVendorImporter.search_pathc C s8 | | jd \}}}|r dS tt|j| js4dS | S )z
Return self when fullname starts with root_name and the
target module is one vendored through this importer.
r N) partitionr anymap
startswithr )r fullnamepathrootbasetargetr r r
find_module s zVendorImporter.find_modulec C s | | jd \}}}| jD ]Z}z@|| }t| tj| }|tj|< tjdkrXtj|= |W S tk
rt Y q X q tdjf t dS )zK
Iterate over the search path to locate and load fullname.
r ) zThe '{target}' package is required; normally this is bundled with this package so if you get this warning, consult the packager of your distribution.N)
r r r
__import__sysmodules version_info ImportErrorformatlocals)r r r r r prefixZextantmodr r r
load_module# s"
zVendorImporter.load_modulec C s | t jkrt j| dS )zR
Install this importer into sys.meta_path if not already present.
N)r meta_pathappendr r r r
install@ s
zVendorImporter.install)r N)N)
__name__
__module__ __qualname____doc__r propertyr r r$ r' r r r r
r s
r )ZsixZ packagingZ pyparsingZ ordered_setzsetuptools._vendor)r r namesr( r' r r r r
s DPK ! t t * extern/__pycache__/__init__.cpython-38.pycnu [ U
Qab @ s. d dl Z G dd dZdZeeed dS ) Nc @ s@ e Zd ZdZdddZedd Zddd Zd
d Zd d
Z dS )VendorImporterz
A PEP 302 meta path importer for finding optionally-vendored
or otherwise naturally-installed packages from root_name.
Nc C s& || _ t|| _|p |dd| _d S )NZexternZ_vendor) root_namesetvendored_namesreplace
vendor_pkg)selfr r r r r >/usr/lib/python3.8/site-packages/setuptools/extern/__init__.py__init__
s
zVendorImporter.__init__c c s | j d V dV dS )zL
Search first the vendor package then as a natural package.
. N)r r r r r
search_path s zVendorImporter.search_pathc C s8 | | jd \}}}|r dS tt|j| js4dS | S )z
Return self when fullname starts with root_name and the
target module is one vendored through this importer.
r N) partitionr anymap
startswithr )r fullnamepathrootbasetargetr r r
find_module s zVendorImporter.find_modulec C s | | jd \}}}| jD ]Z}z@|| }t| tj| }|tj|< tjdkrXtj|= |W S tk
rt Y q X q tdjf t dS )zK
Iterate over the search path to locate and load fullname.
r ) zThe '{target}' package is required; normally this is bundled with this package so if you get this warning, consult the packager of your distribution.N)
r r r
__import__sysmodules version_info ImportErrorformatlocals)r r r r r prefixZextantmodr r r
load_module# s"
zVendorImporter.load_modulec C s | t jkrt j| dS )zR
Install this importer into sys.meta_path if not already present.
N)r meta_pathappendr r r r
install@ s
zVendorImporter.install)r N)N)
__name__
__module__ __qualname____doc__r propertyr r r$ r' r r r r
r s
r )ZsixZ packagingZ pyparsingZ ordered_setzsetuptools._vendor)r r namesr( r' r r r r
s DPK !
windows_support.pynu [ import platform
import ctypes
def windows_only(func):
if platform.system() != 'Windows':
return lambda *args, **kwargs: None
return func
@windows_only
def hide_file(path):
"""
Set the hidden attribute on a file or directory.
From http://stackoverflow.com/questions/19622133/
`path` must be text.
"""
__import__('ctypes.wintypes')
SetFileAttributes = ctypes.windll.kernel32.SetFileAttributesW
SetFileAttributes.argtypes = ctypes.wintypes.LPWSTR, ctypes.wintypes.DWORD
SetFileAttributes.restype = ctypes.wintypes.BOOL
FILE_ATTRIBUTE_HIDDEN = 0x02
ret = SetFileAttributes(path, FILE_ATTRIBUTE_HIDDEN)
if not ret:
raise ctypes.WinError()
PK ! eQ archive_util.pynu [ """Utilities for extracting common archive formats"""
import zipfile
import tarfile
import os
import shutil
import posixpath
import contextlib
from distutils.errors import DistutilsError
from pkg_resources import ensure_directory
__all__ = [
"unpack_archive", "unpack_zipfile", "unpack_tarfile", "default_filter",
"UnrecognizedFormat", "extraction_drivers", "unpack_directory",
]
class UnrecognizedFormat(DistutilsError):
"""Couldn't recognize the archive type"""
def default_filter(src, dst):
"""The default progress/filter callback; returns True for all files"""
return dst
def unpack_archive(filename, extract_dir, progress_filter=default_filter,
drivers=None):
"""Unpack `filename` to `extract_dir`, or raise ``UnrecognizedFormat``
`progress_filter` is a function taking two arguments: a source path
internal to the archive ('/'-separated), and a filesystem path where it
will be extracted. The callback must return the desired extract path
(which may be the same as the one passed in), or else ``None`` to skip
that file or directory. The callback can thus be used to report on the
progress of the extraction, as well as to filter the items extracted or
alter their extraction paths.
`drivers`, if supplied, must be a non-empty sequence of functions with the
same signature as this function (minus the `drivers` argument), that raise
``UnrecognizedFormat`` if they do not support extracting the designated
archive type. The `drivers` are tried in sequence until one is found that
does not raise an error, or until all are exhausted (in which case
``UnrecognizedFormat`` is raised). If you do not supply a sequence of
drivers, the module's ``extraction_drivers`` constant will be used, which
means that ``unpack_zipfile`` and ``unpack_tarfile`` will be tried, in that
order.
"""
for driver in drivers or extraction_drivers:
try:
driver(filename, extract_dir, progress_filter)
except UnrecognizedFormat:
continue
else:
return
else:
raise UnrecognizedFormat(
"Not a recognized archive type: %s" % filename
)
def unpack_directory(filename, extract_dir, progress_filter=default_filter):
""""Unpack" a directory, using the same interface as for archives
Raises ``UnrecognizedFormat`` if `filename` is not a directory
"""
if not os.path.isdir(filename):
raise UnrecognizedFormat("%s is not a directory" % filename)
paths = {
filename: ('', extract_dir),
}
for base, dirs, files in os.walk(filename):
src, dst = paths[base]
for d in dirs:
paths[os.path.join(base, d)] = src + d + '/', os.path.join(dst, d)
for f in files:
target = os.path.join(dst, f)
target = progress_filter(src + f, target)
if not target:
# skip non-files
continue
ensure_directory(target)
f = os.path.join(base, f)
shutil.copyfile(f, target)
shutil.copystat(f, target)
def unpack_zipfile(filename, extract_dir, progress_filter=default_filter):
"""Unpack zip `filename` to `extract_dir`
Raises ``UnrecognizedFormat`` if `filename` is not a zipfile (as determined
by ``zipfile.is_zipfile()``). See ``unpack_archive()`` for an explanation
of the `progress_filter` argument.
"""
if not zipfile.is_zipfile(filename):
raise UnrecognizedFormat("%s is not a zip file" % (filename,))
with zipfile.ZipFile(filename) as z:
for info in z.infolist():
name = info.filename
# don't extract absolute paths or ones with .. in them
if name.startswith('/') or '..' in name.split('/'):
continue
target = os.path.join(extract_dir, *name.split('/'))
target = progress_filter(name, target)
if not target:
continue
if name.endswith('/'):
# directory
ensure_directory(target)
else:
# file
ensure_directory(target)
data = z.read(info.filename)
with open(target, 'wb') as f:
f.write(data)
unix_attributes = info.external_attr >> 16
if unix_attributes:
os.chmod(target, unix_attributes)
def unpack_tarfile(filename, extract_dir, progress_filter=default_filter):
"""Unpack tar/tar.gz/tar.bz2 `filename` to `extract_dir`
Raises ``UnrecognizedFormat`` if `filename` is not a tarfile (as determined
by ``tarfile.open()``). See ``unpack_archive()`` for an explanation
of the `progress_filter` argument.
"""
try:
tarobj = tarfile.open(filename)
except tarfile.TarError:
raise UnrecognizedFormat(
"%s is not a compressed or uncompressed tar file" % (filename,)
)
with contextlib.closing(tarobj):
# don't do any chowning!
tarobj.chown = lambda *args: None
for member in tarobj:
name = member.name
# don't extract absolute paths or ones with .. in them
if not name.startswith('/') and '..' not in name.split('/'):
prelim_dst = os.path.join(extract_dir, *name.split('/'))
# resolve any links and to extract the link targets as normal
# files
while member is not None and (member.islnk() or member.issym()):
linkpath = member.linkname
if member.issym():
base = posixpath.dirname(member.name)
linkpath = posixpath.join(base, linkpath)
linkpath = posixpath.normpath(linkpath)
member = tarobj._getmember(linkpath)
if member is not None and (member.isfile() or member.isdir()):
final_dst = progress_filter(name, prelim_dst)
if final_dst:
if final_dst.endswith(os.sep):
final_dst = final_dst[:-1]
try:
# XXX Ugh
tarobj._extract_member(member, final_dst)
except tarfile.ExtractError:
# chown/chmod/mkfifo/mknode/makedev failed
pass
return True
extraction_drivers = unpack_directory, unpack_zipfile, unpack_tarfile
PK ! b dist.pynu [ # -*- coding: utf-8 -*-
__all__ = ['Distribution']
import io
import sys
import re
import os
import warnings
import numbers
import distutils.log
import distutils.core
import distutils.cmd
import distutils.dist
from distutils.util import strtobool
from distutils.debug import DEBUG
from distutils.fancy_getopt import translate_longopt
import itertools
from collections import defaultdict
from email import message_from_file
from distutils.errors import (
DistutilsOptionError, DistutilsPlatformError, DistutilsSetupError,
)
from distutils.util import rfc822_escape
from distutils.version import StrictVersion
from setuptools.extern import six
from setuptools.extern import packaging
from setuptools.extern import ordered_set
from setuptools.extern.six.moves import map, filter, filterfalse
from . import SetuptoolsDeprecationWarning
from setuptools.depends import Require
from setuptools import windows_support
from setuptools.monkey import get_unpatched
from setuptools.config import parse_configuration
import pkg_resources
__import__('setuptools.extern.packaging.specifiers')
__import__('setuptools.extern.packaging.version')
def _get_unpatched(cls):
warnings.warn("Do not call this function", DistDeprecationWarning)
return get_unpatched(cls)
def get_metadata_version(self):
mv = getattr(self, 'metadata_version', None)
if mv is None:
if self.long_description_content_type or self.provides_extras:
mv = StrictVersion('2.1')
elif (self.maintainer is not None or
self.maintainer_email is not None or
getattr(self, 'python_requires', None) is not None or
self.project_urls):
mv = StrictVersion('1.2')
elif (self.provides or self.requires or self.obsoletes or
self.classifiers or self.download_url):
mv = StrictVersion('1.1')
else:
mv = StrictVersion('1.0')
self.metadata_version = mv
return mv
def read_pkg_file(self, file):
"""Reads the metadata values from a file object."""
msg = message_from_file(file)
def _read_field(name):
value = msg[name]
if value == 'UNKNOWN':
return None
return value
def _read_list(name):
values = msg.get_all(name, None)
if values == []:
return None
return values
self.metadata_version = StrictVersion(msg['metadata-version'])
self.name = _read_field('name')
self.version = _read_field('version')
self.description = _read_field('summary')
# we are filling author only.
self.author = _read_field('author')
self.maintainer = None
self.author_email = _read_field('author-email')
self.maintainer_email = None
self.url = _read_field('home-page')
self.license = _read_field('license')
if 'download-url' in msg:
self.download_url = _read_field('download-url')
else:
self.download_url = None
self.long_description = _read_field('description')
self.description = _read_field('summary')
if 'keywords' in msg:
self.keywords = _read_field('keywords').split(',')
self.platforms = _read_list('platform')
self.classifiers = _read_list('classifier')
# PEP 314 - these fields only exist in 1.1
if self.metadata_version == StrictVersion('1.1'):
self.requires = _read_list('requires')
self.provides = _read_list('provides')
self.obsoletes = _read_list('obsoletes')
else:
self.requires = None
self.provides = None
self.obsoletes = None
# Based on Python 3.5 version
def write_pkg_file(self, file):
"""Write the PKG-INFO format data to a file object.
"""
version = self.get_metadata_version()
if six.PY2:
def write_field(key, value):
file.write("%s: %s\n" % (key, self._encode_field(value)))
else:
def write_field(key, value):
file.write("%s: %s\n" % (key, value))
write_field('Metadata-Version', str(version))
write_field('Name', self.get_name())
write_field('Version', self.get_version())
write_field('Summary', self.get_description())
write_field('Home-page', self.get_url())
if version < StrictVersion('1.2'):
write_field('Author', self.get_contact())
write_field('Author-email', self.get_contact_email())
else:
optional_fields = (
('Author', 'author'),
('Author-email', 'author_email'),
('Maintainer', 'maintainer'),
('Maintainer-email', 'maintainer_email'),
)
for field, attr in optional_fields:
attr_val = getattr(self, attr)
if attr_val is not None:
write_field(field, attr_val)
write_field('License', self.get_license())
if self.download_url:
write_field('Download-URL', self.download_url)
for project_url in self.project_urls.items():
write_field('Project-URL', '%s, %s' % project_url)
long_desc = rfc822_escape(self.get_long_description())
write_field('Description', long_desc)
keywords = ','.join(self.get_keywords())
if keywords:
write_field('Keywords', keywords)
if version >= StrictVersion('1.2'):
for platform in self.get_platforms():
write_field('Platform', platform)
else:
self._write_list(file, 'Platform', self.get_platforms())
self._write_list(file, 'Classifier', self.get_classifiers())
# PEP 314
self._write_list(file, 'Requires', self.get_requires())
self._write_list(file, 'Provides', self.get_provides())
self._write_list(file, 'Obsoletes', self.get_obsoletes())
# Setuptools specific for PEP 345
if hasattr(self, 'python_requires'):
write_field('Requires-Python', self.python_requires)
# PEP 566
if self.long_description_content_type:
write_field(
'Description-Content-Type',
self.long_description_content_type
)
if self.provides_extras:
for extra in self.provides_extras:
write_field('Provides-Extra', extra)
sequence = tuple, list
def check_importable(dist, attr, value):
try:
ep = pkg_resources.EntryPoint.parse('x=' + value)
assert not ep.extras
except (TypeError, ValueError, AttributeError, AssertionError):
raise DistutilsSetupError(
"%r must be importable 'module:attrs' string (got %r)"
% (attr, value)
)
def assert_string_list(dist, attr, value):
"""Verify that value is a string list"""
try:
# verify that value is a list or tuple to exclude unordered
# or single-use iterables
assert isinstance(value, (list, tuple))
# verify that elements of value are strings
assert ''.join(value) != value
except (TypeError, ValueError, AttributeError, AssertionError):
raise DistutilsSetupError(
"%r must be a list of strings (got %r)" % (attr, value)
)
def check_nsp(dist, attr, value):
"""Verify that namespace packages are valid"""
ns_packages = value
assert_string_list(dist, attr, ns_packages)
for nsp in ns_packages:
if not dist.has_contents_for(nsp):
raise DistutilsSetupError(
"Distribution contains no modules or packages for " +
"namespace package %r" % nsp
)
parent, sep, child = nsp.rpartition('.')
if parent and parent not in ns_packages:
distutils.log.warn(
"WARNING: %r is declared as a package namespace, but %r"
" is not: please correct this in setup.py", nsp, parent
)
def check_extras(dist, attr, value):
"""Verify that extras_require mapping is valid"""
try:
list(itertools.starmap(_check_extra, value.items()))
except (TypeError, ValueError, AttributeError):
raise DistutilsSetupError(
"'extras_require' must be a dictionary whose values are "
"strings or lists of strings containing valid project/version "
"requirement specifiers."
)
def _check_extra(extra, reqs):
name, sep, marker = extra.partition(':')
if marker and pkg_resources.invalid_marker(marker):
raise DistutilsSetupError("Invalid environment marker: " + marker)
list(pkg_resources.parse_requirements(reqs))
def assert_bool(dist, attr, value):
"""Verify that value is True, False, 0, or 1"""
if bool(value) != value:
tmpl = "{attr!r} must be a boolean value (got {value!r})"
raise DistutilsSetupError(tmpl.format(attr=attr, value=value))
def check_requirements(dist, attr, value):
"""Verify that install_requires is a valid requirements list"""
try:
list(pkg_resources.parse_requirements(value))
if isinstance(value, (dict, set)):
raise TypeError("Unordered types are not allowed")
except (TypeError, ValueError) as error:
tmpl = (
"{attr!r} must be a string or list of strings "
"containing valid project/version requirement specifiers; {error}"
)
raise DistutilsSetupError(tmpl.format(attr=attr, error=error))
def check_specifier(dist, attr, value):
"""Verify that value is a valid version specifier"""
try:
packaging.specifiers.SpecifierSet(value)
except packaging.specifiers.InvalidSpecifier as error:
tmpl = (
"{attr!r} must be a string "
"containing valid version specifiers; {error}"
)
raise DistutilsSetupError(tmpl.format(attr=attr, error=error))
def check_entry_points(dist, attr, value):
"""Verify that entry_points map is parseable"""
try:
pkg_resources.EntryPoint.parse_map(value)
except ValueError as e:
raise DistutilsSetupError(e)
def check_test_suite(dist, attr, value):
if not isinstance(value, six.string_types):
raise DistutilsSetupError("test_suite must be a string")
def check_package_data(dist, attr, value):
"""Verify that value is a dictionary of package names to glob lists"""
if not isinstance(value, dict):
raise DistutilsSetupError(
"{!r} must be a dictionary mapping package names to lists of "
"string wildcard patterns".format(attr))
for k, v in value.items():
if not isinstance(k, six.string_types):
raise DistutilsSetupError(
"keys of {!r} dict must be strings (got {!r})"
.format(attr, k)
)
assert_string_list(dist, 'values of {!r} dict'.format(attr), v)
def check_packages(dist, attr, value):
for pkgname in value:
if not re.match(r'\w+(\.\w+)*', pkgname):
distutils.log.warn(
"WARNING: %r not a valid package name; please use only "
".-separated package names in setup.py", pkgname
)
_Distribution = get_unpatched(distutils.core.Distribution)
class Distribution(_Distribution):
"""Distribution with support for features, tests, and package data
This is an enhanced version of 'distutils.dist.Distribution' that
effectively adds the following new optional keyword arguments to 'setup()':
'install_requires' -- a string or sequence of strings specifying project
versions that the distribution requires when installed, in the format
used by 'pkg_resources.require()'. They will be installed
automatically when the package is installed. If you wish to use
packages that are not available in PyPI, or want to give your users an
alternate download location, you can add a 'find_links' option to the
'[easy_install]' section of your project's 'setup.cfg' file, and then
setuptools will scan the listed web pages for links that satisfy the
requirements.
'extras_require' -- a dictionary mapping names of optional "extras" to the
additional requirement(s) that using those extras incurs. For example,
this::
extras_require = dict(reST = ["docutils>=0.3", "reSTedit"])
indicates that the distribution can optionally provide an extra
capability called "reST", but it can only be used if docutils and
reSTedit are installed. If the user installs your package using
EasyInstall and requests one of your extras, the corresponding
additional requirements will be installed if needed.
'features' **deprecated** -- a dictionary mapping option names to
'setuptools.Feature'
objects. Features are a portion of the distribution that can be
included or excluded based on user options, inter-feature dependencies,
and availability on the current system. Excluded features are omitted
from all setup commands, including source and binary distributions, so
you can create multiple distributions from the same source tree.
Feature names should be valid Python identifiers, except that they may
contain the '-' (minus) sign. Features can be included or excluded
via the command line options '--with-X' and '--without-X', where 'X' is
the name of the feature. Whether a feature is included by default, and
whether you are allowed to control this from the command line, is
determined by the Feature object. See the 'Feature' class for more
information.
'test_suite' -- the name of a test suite to run for the 'test' command.
If the user runs 'python setup.py test', the package will be installed,
and the named test suite will be run. The format is the same as
would be used on a 'unittest.py' command line. That is, it is the
dotted name of an object to import and call to generate a test suite.
'package_data' -- a dictionary mapping package names to lists of filenames
or globs to use to find data files contained in the named packages.
If the dictionary has filenames or globs listed under '""' (the empty
string), those names will be searched for in every package, in addition
to any names for the specific package. Data files found using these
names/globs will be installed along with the package, in the same
location as the package. Note that globs are allowed to reference
the contents of non-package subdirectories, as long as you use '/' as
a path separator. (Globs are automatically converted to
platform-specific paths at runtime.)
In addition to these new keywords, this class also has several new methods
for manipulating the distribution's contents. For example, the 'include()'
and 'exclude()' methods can be thought of as in-place add and subtract
commands that add or remove packages, modules, extensions, and so on from
the distribution. They are used by the feature subsystem to configure the
distribution for the included and excluded features.
"""
_DISTUTILS_UNSUPPORTED_METADATA = {
'long_description_content_type': None,
'project_urls': dict,
'provides_extras': ordered_set.OrderedSet,
}
_patched_dist = None
def patch_missing_pkg_info(self, attrs):
# Fake up a replacement for the data that would normally come from
# PKG-INFO, but which might not yet be built if this is a fresh
# checkout.
#
if not attrs or 'name' not in attrs or 'version' not in attrs:
return
key = pkg_resources.safe_name(str(attrs['name'])).lower()
dist = pkg_resources.working_set.by_key.get(key)
if dist is not None and not dist.has_metadata('PKG-INFO'):
dist._version = pkg_resources.safe_version(str(attrs['version']))
self._patched_dist = dist
def __init__(self, attrs=None):
have_package_data = hasattr(self, "package_data")
if not have_package_data:
self.package_data = {}
attrs = attrs or {}
if 'features' in attrs or 'require_features' in attrs:
Feature.warn_deprecated()
self.require_features = []
self.features = {}
self.dist_files = []
# Filter-out setuptools' specific options.
self.src_root = attrs.pop("src_root", None)
self.patch_missing_pkg_info(attrs)
self.dependency_links = attrs.pop('dependency_links', [])
self.setup_requires = attrs.pop('setup_requires', [])
for ep in pkg_resources.iter_entry_points('distutils.setup_keywords'):
vars(self).setdefault(ep.name, None)
_Distribution.__init__(self, {
k: v for k, v in attrs.items()
if k not in self._DISTUTILS_UNSUPPORTED_METADATA
})
# Fill-in missing metadata fields not supported by distutils.
# Note some fields may have been set by other tools (e.g. pbr)
# above; they are taken preferrentially to setup() arguments
for option, default in self._DISTUTILS_UNSUPPORTED_METADATA.items():
for source in self.metadata.__dict__, attrs:
if option in source:
value = source[option]
break
else:
value = default() if default else None
setattr(self.metadata, option, value)
if isinstance(self.metadata.version, numbers.Number):
# Some people apparently take "version number" too literally :)
self.metadata.version = str(self.metadata.version)
if self.metadata.version is not None:
try:
ver = packaging.version.Version(self.metadata.version)
normalized_version = str(ver)
if self.metadata.version != normalized_version:
warnings.warn(
"Normalizing '%s' to '%s'" % (
self.metadata.version,
normalized_version,
)
)
self.metadata.version = normalized_version
except (packaging.version.InvalidVersion, TypeError):
warnings.warn(
"The version specified (%r) is an invalid version, this "
"may not work as expected with newer versions of "
"setuptools, pip, and PyPI. Please see PEP 440 for more "
"details." % self.metadata.version
)
self._finalize_requires()
def _finalize_requires(self):
"""
Set `metadata.python_requires` and fix environment markers
in `install_requires` and `extras_require`.
"""
if getattr(self, 'python_requires', None):
self.metadata.python_requires = self.python_requires
if getattr(self, 'extras_require', None):
for extra in self.extras_require.keys():
# Since this gets called multiple times at points where the
# keys have become 'converted' extras, ensure that we are only
# truly adding extras we haven't seen before here.
extra = extra.split(':')[0]
if extra:
self.metadata.provides_extras.add(extra)
self._convert_extras_requirements()
self._move_install_requirements_markers()
def _convert_extras_requirements(self):
"""
Convert requirements in `extras_require` of the form
`"extra": ["barbazquux; {marker}"]` to
`"extra:{marker}": ["barbazquux"]`.
"""
spec_ext_reqs = getattr(self, 'extras_require', None) or {}
self._tmp_extras_require = defaultdict(list)
for section, v in spec_ext_reqs.items():
# Do not strip empty sections.
self._tmp_extras_require[section]
for r in pkg_resources.parse_requirements(v):
suffix = self._suffix_for(r)
self._tmp_extras_require[section + suffix].append(r)
@staticmethod
def _suffix_for(req):
"""
For a requirement, return the 'extras_require' suffix for
that requirement.
"""
return ':' + str(req.marker) if req.marker else ''
def _move_install_requirements_markers(self):
"""
Move requirements in `install_requires` that are using environment
markers `extras_require`.
"""
# divide the install_requires into two sets, simple ones still
# handled by install_requires and more complex ones handled
# by extras_require.
def is_simple_req(req):
return not req.marker
spec_inst_reqs = getattr(self, 'install_requires', None) or ()
inst_reqs = list(pkg_resources.parse_requirements(spec_inst_reqs))
simple_reqs = filter(is_simple_req, inst_reqs)
complex_reqs = filterfalse(is_simple_req, inst_reqs)
self.install_requires = list(map(str, simple_reqs))
for r in complex_reqs:
self._tmp_extras_require[':' + str(r.marker)].append(r)
self.extras_require = dict(
(k, [str(r) for r in map(self._clean_req, v)])
for k, v in self._tmp_extras_require.items()
)
def _clean_req(self, req):
"""
Given a Requirement, remove environment markers and return it.
"""
req.marker = None
return req
def _parse_config_files(self, filenames=None):
"""
Adapted from distutils.dist.Distribution.parse_config_files,
this method provides the same functionality in subtly-improved
ways.
"""
from setuptools.extern.six.moves.configparser import ConfigParser
# Ignore install directory options if we have a venv
if six.PY3 and sys.prefix != sys.base_prefix:
ignore_options = [
'install-base', 'install-platbase', 'install-lib',
'install-platlib', 'install-purelib', 'install-headers',
'install-scripts', 'install-data', 'prefix', 'exec-prefix',
'home', 'user', 'root']
else:
ignore_options = []
ignore_options = frozenset(ignore_options)
if filenames is None:
filenames = self.find_config_files()
if DEBUG:
self.announce("Distribution.parse_config_files():")
parser = ConfigParser()
for filename in filenames:
with io.open(filename, encoding='utf-8') as reader:
if DEBUG:
self.announce(" reading {filename}".format(**locals()))
(parser.read_file if six.PY3 else parser.readfp)(reader)
for section in parser.sections():
options = parser.options(section)
opt_dict = self.get_option_dict(section)
for opt in options:
if opt != '__name__' and opt not in ignore_options:
val = self._try_str(parser.get(section, opt))
opt = opt.replace('-', '_')
opt_dict[opt] = (filename, val)
# Make the ConfigParser forget everything (so we retain
# the original filenames that options come from)
parser.__init__()
# If there was a "global" section in the config file, use it
# to set Distribution options.
if 'global' in self.command_options:
for (opt, (src, val)) in self.command_options['global'].items():
alias = self.negative_opt.get(opt)
try:
if alias:
setattr(self, alias, not strtobool(val))
elif opt in ('verbose', 'dry_run'): # ugh!
setattr(self, opt, strtobool(val))
else:
setattr(self, opt, val)
except ValueError as msg:
raise DistutilsOptionError(msg)
@staticmethod
def _try_str(val):
"""
On Python 2, much of distutils relies on string values being of
type 'str' (bytes) and not unicode text. If the value can be safely
encoded to bytes using the default encoding, prefer that.
Why the default encoding? Because that value can be implicitly
decoded back to text if needed.
Ref #1653
"""
if six.PY3:
return val
try:
return val.encode()
except UnicodeEncodeError:
pass
return val
def _set_command_options(self, command_obj, option_dict=None):
"""
Set the options for 'command_obj' from 'option_dict'. Basically
this means copying elements of a dictionary ('option_dict') to
attributes of an instance ('command').
'command_obj' must be a Command instance. If 'option_dict' is not
supplied, uses the standard option dictionary for this command
(from 'self.command_options').
(Adopted from distutils.dist.Distribution._set_command_options)
"""
command_name = command_obj.get_command_name()
if option_dict is None:
option_dict = self.get_option_dict(command_name)
if DEBUG:
self.announce(" setting options for '%s' command:" % command_name)
for (option, (source, value)) in option_dict.items():
if DEBUG:
self.announce(" %s = %s (from %s)" % (option, value,
source))
try:
bool_opts = [translate_longopt(o)
for o in command_obj.boolean_options]
except AttributeError:
bool_opts = []
try:
neg_opt = command_obj.negative_opt
except AttributeError:
neg_opt = {}
try:
is_string = isinstance(value, six.string_types)
if option in neg_opt and is_string:
setattr(command_obj, neg_opt[option], not strtobool(value))
elif option in bool_opts and is_string:
setattr(command_obj, option, strtobool(value))
elif hasattr(command_obj, option):
setattr(command_obj, option, value)
else:
raise DistutilsOptionError(
"error in %s: command '%s' has no such option '%s'"
% (source, command_name, option))
except ValueError as msg:
raise DistutilsOptionError(msg)
def parse_config_files(self, filenames=None, ignore_option_errors=False):
"""Parses configuration files from various levels
and loads configuration.
"""
self._parse_config_files(filenames=filenames)
parse_configuration(self, self.command_options,
ignore_option_errors=ignore_option_errors)
self._finalize_requires()
def parse_command_line(self):
"""Process features after parsing command line options"""
result = _Distribution.parse_command_line(self)
if self.features:
self._finalize_features()
return result
def _feature_attrname(self, name):
"""Convert feature name to corresponding option attribute name"""
return 'with_' + name.replace('-', '_')
def fetch_build_eggs(self, requires):
"""Resolve pre-setup requirements"""
resolved_dists = pkg_resources.working_set.resolve(
pkg_resources.parse_requirements(requires),
installer=self.fetch_build_egg,
replace_conflicting=True,
)
for dist in resolved_dists:
pkg_resources.working_set.add(dist, replace=True)
return resolved_dists
def finalize_options(self):
_Distribution.finalize_options(self)
if self.features:
self._set_global_opts_from_features()
for ep in pkg_resources.iter_entry_points('distutils.setup_keywords'):
value = getattr(self, ep.name, None)
if value is not None:
ep.require(installer=self.fetch_build_egg)
ep.load()(self, ep.name, value)
if getattr(self, 'convert_2to3_doctests', None):
# XXX may convert to set here when we can rely on set being builtin
self.convert_2to3_doctests = [
os.path.abspath(p)
for p in self.convert_2to3_doctests
]
else:
self.convert_2to3_doctests = []
def get_egg_cache_dir(self):
egg_cache_dir = os.path.join(os.curdir, '.eggs')
if not os.path.exists(egg_cache_dir):
os.mkdir(egg_cache_dir)
windows_support.hide_file(egg_cache_dir)
readme_txt_filename = os.path.join(egg_cache_dir, 'README.txt')
with open(readme_txt_filename, 'w') as f:
f.write('This directory contains eggs that were downloaded '
'by setuptools to build, test, and run plug-ins.\n\n')
f.write('This directory caches those eggs to prevent '
'repeated downloads.\n\n')
f.write('However, it is safe to delete this directory.\n\n')
return egg_cache_dir
def fetch_build_egg(self, req):
"""Fetch an egg needed for building"""
from setuptools.command.easy_install import easy_install
dist = self.__class__({'script_args': ['easy_install']})
opts = dist.get_option_dict('easy_install')
opts.clear()
opts.update(
(k, v)
for k, v in self.get_option_dict('easy_install').items()
if k in (
# don't use any other settings
'find_links', 'site_dirs', 'index_url',
'optimize', 'site_dirs', 'allow_hosts',
))
if self.dependency_links:
links = self.dependency_links[:]
if 'find_links' in opts:
links = opts['find_links'][1] + links
opts['find_links'] = ('setup', links)
install_dir = self.get_egg_cache_dir()
cmd = easy_install(
dist, args=["x"], install_dir=install_dir,
exclude_scripts=True,
always_copy=False, build_directory=None, editable=False,
upgrade=False, multi_version=True, no_report=True, user=False
)
cmd.ensure_finalized()
return cmd.easy_install(req)
def _set_global_opts_from_features(self):
"""Add --with-X/--without-X options based on optional features"""
go = []
no = self.negative_opt.copy()
for name, feature in self.features.items():
self._set_feature(name, None)
feature.validate(self)
if feature.optional:
descr = feature.description
incdef = ' (default)'
excdef = ''
if not feature.include_by_default():
excdef, incdef = incdef, excdef
new = (
('with-' + name, None, 'include ' + descr + incdef),
('without-' + name, None, 'exclude ' + descr + excdef),
)
go.extend(new)
no['without-' + name] = 'with-' + name
self.global_options = self.feature_options = go + self.global_options
self.negative_opt = self.feature_negopt = no
def _finalize_features(self):
"""Add/remove features and resolve dependencies between them"""
# First, flag all the enabled items (and thus their dependencies)
for name, feature in self.features.items():
enabled = self.feature_is_included(name)
if enabled or (enabled is None and feature.include_by_default()):
feature.include_in(self)
self._set_feature(name, 1)
# Then disable the rest, so that off-by-default features don't
# get flagged as errors when they're required by an enabled feature
for name, feature in self.features.items():
if not self.feature_is_included(name):
feature.exclude_from(self)
self._set_feature(name, 0)
def get_command_class(self, command):
"""Pluggable version of get_command_class()"""
if command in self.cmdclass:
return self.cmdclass[command]
eps = pkg_resources.iter_entry_points('distutils.commands', command)
for ep in eps:
ep.require(installer=self.fetch_build_egg)
self.cmdclass[command] = cmdclass = ep.load()
return cmdclass
else:
return _Distribution.get_command_class(self, command)
def print_commands(self):
for ep in pkg_resources.iter_entry_points('distutils.commands'):
if ep.name not in self.cmdclass:
# don't require extras as the commands won't be invoked
cmdclass = ep.resolve()
self.cmdclass[ep.name] = cmdclass
return _Distribution.print_commands(self)
def get_command_list(self):
for ep in pkg_resources.iter_entry_points('distutils.commands'):
if ep.name not in self.cmdclass:
# don't require extras as the commands won't be invoked
cmdclass = ep.resolve()
self.cmdclass[ep.name] = cmdclass
return _Distribution.get_command_list(self)
def _set_feature(self, name, status):
"""Set feature's inclusion status"""
setattr(self, self._feature_attrname(name), status)
def feature_is_included(self, name):
"""Return 1 if feature is included, 0 if excluded, 'None' if unknown"""
return getattr(self, self._feature_attrname(name))
def include_feature(self, name):
"""Request inclusion of feature named 'name'"""
if self.feature_is_included(name) == 0:
descr = self.features[name].description
raise DistutilsOptionError(
descr + " is required, but was excluded or is not available"
)
self.features[name].include_in(self)
self._set_feature(name, 1)
def include(self, **attrs):
"""Add items to distribution that are named in keyword arguments
For example, 'dist.include(py_modules=["x"])' would add 'x' to
the distribution's 'py_modules' attribute, if it was not already
there.
Currently, this method only supports inclusion for attributes that are
lists or tuples. If you need to add support for adding to other
attributes in this or a subclass, you can add an '_include_X' method,
where 'X' is the name of the attribute. The method will be called with
the value passed to 'include()'. So, 'dist.include(foo={"bar":"baz"})'
will try to call 'dist._include_foo({"bar":"baz"})', which can then
handle whatever special inclusion logic is needed.
"""
for k, v in attrs.items():
include = getattr(self, '_include_' + k, None)
if include:
include(v)
else:
self._include_misc(k, v)
def exclude_package(self, package):
"""Remove packages, modules, and extensions in named package"""
pfx = package + '.'
if self.packages:
self.packages = [
p for p in self.packages
if p != package and not p.startswith(pfx)
]
if self.py_modules:
self.py_modules = [
p for p in self.py_modules
if p != package and not p.startswith(pfx)
]
if self.ext_modules:
self.ext_modules = [
p for p in self.ext_modules
if p.name != package and not p.name.startswith(pfx)
]
def has_contents_for(self, package):
"""Return true if 'exclude_package(package)' would do something"""
pfx = package + '.'
for p in self.iter_distribution_names():
if p == package or p.startswith(pfx):
return True
def _exclude_misc(self, name, value):
"""Handle 'exclude()' for list/tuple attrs without a special handler"""
if not isinstance(value, sequence):
raise DistutilsSetupError(
"%s: setting must be a list or tuple (%r)" % (name, value)
)
try:
old = getattr(self, name)
except AttributeError:
raise DistutilsSetupError(
"%s: No such distribution setting" % name
)
if old is not None and not isinstance(old, sequence):
raise DistutilsSetupError(
name + ": this setting cannot be changed via include/exclude"
)
elif old:
setattr(self, name, [item for item in old if item not in value])
def _include_misc(self, name, value):
"""Handle 'include()' for list/tuple attrs without a special handler"""
if not isinstance(value, sequence):
raise DistutilsSetupError(
"%s: setting must be a list (%r)" % (name, value)
)
try:
old = getattr(self, name)
except AttributeError:
raise DistutilsSetupError(
"%s: No such distribution setting" % name
)
if old is None:
setattr(self, name, value)
elif not isinstance(old, sequence):
raise DistutilsSetupError(
name + ": this setting cannot be changed via include/exclude"
)
else:
new = [item for item in value if item not in old]
setattr(self, name, old + new)
def exclude(self, **attrs):
"""Remove items from distribution that are named in keyword arguments
For example, 'dist.exclude(py_modules=["x"])' would remove 'x' from
the distribution's 'py_modules' attribute. Excluding packages uses
the 'exclude_package()' method, so all of the package's contained
packages, modules, and extensions are also excluded.
Currently, this method only supports exclusion from attributes that are
lists or tuples. If you need to add support for excluding from other
attributes in this or a subclass, you can add an '_exclude_X' method,
where 'X' is the name of the attribute. The method will be called with
the value passed to 'exclude()'. So, 'dist.exclude(foo={"bar":"baz"})'
will try to call 'dist._exclude_foo({"bar":"baz"})', which can then
handle whatever special exclusion logic is needed.
"""
for k, v in attrs.items():
exclude = getattr(self, '_exclude_' + k, None)
if exclude:
exclude(v)
else:
self._exclude_misc(k, v)
def _exclude_packages(self, packages):
if not isinstance(packages, sequence):
raise DistutilsSetupError(
"packages: setting must be a list or tuple (%r)" % (packages,)
)
list(map(self.exclude_package, packages))
def _parse_command_opts(self, parser, args):
# Remove --with-X/--without-X options when processing command args
self.global_options = self.__class__.global_options
self.negative_opt = self.__class__.negative_opt
# First, expand any aliases
command = args[0]
aliases = self.get_option_dict('aliases')
while command in aliases:
src, alias = aliases[command]
del aliases[command] # ensure each alias can expand only once!
import shlex
args[:1] = shlex.split(alias, True)
command = args[0]
nargs = _Distribution._parse_command_opts(self, parser, args)
# Handle commands that want to consume all remaining arguments
cmd_class = self.get_command_class(command)
if getattr(cmd_class, 'command_consumes_arguments', None):
self.get_option_dict(command)['args'] = ("command line", nargs)
if nargs is not None:
return []
return nargs
def get_cmdline_options(self):
"""Return a '{cmd: {opt:val}}' map of all command-line options
Option names are all long, but do not include the leading '--', and
contain dashes rather than underscores. If the option doesn't take
an argument (e.g. '--quiet'), the 'val' is 'None'.
Note that options provided by config files are intentionally excluded.
"""
d = {}
for cmd, opts in self.command_options.items():
for opt, (src, val) in opts.items():
if src != "command line":
continue
opt = opt.replace('_', '-')
if val == 0:
cmdobj = self.get_command_obj(cmd)
neg_opt = self.negative_opt.copy()
neg_opt.update(getattr(cmdobj, 'negative_opt', {}))
for neg, pos in neg_opt.items():
if pos == opt:
opt = neg
val = None
break
else:
raise AssertionError("Shouldn't be able to get here")
elif val == 1:
val = None
d.setdefault(cmd, {})[opt] = val
return d
def iter_distribution_names(self):
"""Yield all packages, modules, and extension names in distribution"""
for pkg in self.packages or ():
yield pkg
for module in self.py_modules or ():
yield module
for ext in self.ext_modules or ():
if isinstance(ext, tuple):
name, buildinfo = ext
else:
name = ext.name
if name.endswith('module'):
name = name[:-6]
yield name
def handle_display_options(self, option_order):
"""If there were any non-global "display-only" options
(--help-commands or the metadata display options) on the command
line, display the requested info and return true; else return
false.
"""
import sys
if six.PY2 or self.help_commands:
return _Distribution.handle_display_options(self, option_order)
# Stdout may be StringIO (e.g. in tests)
if not isinstance(sys.stdout, io.TextIOWrapper):
return _Distribution.handle_display_options(self, option_order)
# Don't wrap stdout if utf-8 is already the encoding. Provides
# workaround for #334.
if sys.stdout.encoding.lower() in ('utf-8', 'utf8'):
return _Distribution.handle_display_options(self, option_order)
# Print metadata in UTF-8 no matter the platform
encoding = sys.stdout.encoding
errors = sys.stdout.errors
newline = sys.platform != 'win32' and '\n' or None
line_buffering = sys.stdout.line_buffering
sys.stdout = io.TextIOWrapper(
sys.stdout.detach(), 'utf-8', errors, newline, line_buffering)
try:
return _Distribution.handle_display_options(self, option_order)
finally:
sys.stdout = io.TextIOWrapper(
sys.stdout.detach(), encoding, errors, newline, line_buffering)
class Feature:
"""
**deprecated** -- The `Feature` facility was never completely implemented
or supported, `has reported issues
`_ and will be removed in
a future version.
A subset of the distribution that can be excluded if unneeded/wanted
Features are created using these keyword arguments:
'description' -- a short, human readable description of the feature, to
be used in error messages, and option help messages.
'standard' -- if true, the feature is included by default if it is
available on the current system. Otherwise, the feature is only
included if requested via a command line '--with-X' option, or if
another included feature requires it. The default setting is 'False'.
'available' -- if true, the feature is available for installation on the
current system. The default setting is 'True'.
'optional' -- if true, the feature's inclusion can be controlled from the
command line, using the '--with-X' or '--without-X' options. If
false, the feature's inclusion status is determined automatically,
based on 'availabile', 'standard', and whether any other feature
requires it. The default setting is 'True'.
'require_features' -- a string or sequence of strings naming features
that should also be included if this feature is included. Defaults to
empty list. May also contain 'Require' objects that should be
added/removed from the distribution.
'remove' -- a string or list of strings naming packages to be removed
from the distribution if this feature is *not* included. If the
feature *is* included, this argument is ignored. This argument exists
to support removing features that "crosscut" a distribution, such as
defining a 'tests' feature that removes all the 'tests' subpackages
provided by other features. The default for this argument is an empty
list. (Note: the named package(s) or modules must exist in the base
distribution when the 'setup()' function is initially called.)
other keywords -- any other keyword arguments are saved, and passed to
the distribution's 'include()' and 'exclude()' methods when the
feature is included or excluded, respectively. So, for example, you
could pass 'packages=["a","b"]' to cause packages 'a' and 'b' to be
added or removed from the distribution as appropriate.
A feature must include at least one 'requires', 'remove', or other
keyword argument. Otherwise, it can't affect the distribution in any way.
Note also that you can subclass 'Feature' to create your own specialized
feature types that modify the distribution in other ways when included or
excluded. See the docstrings for the various methods here for more detail.
Aside from the methods, the only feature attributes that distributions look
at are 'description' and 'optional'.
"""
@staticmethod
def warn_deprecated():
msg = (
"Features are deprecated and will be removed in a future "
"version. See https://github.com/pypa/setuptools/issues/65."
)
warnings.warn(msg, DistDeprecationWarning, stacklevel=3)
def __init__(
self, description, standard=False, available=True,
optional=True, require_features=(), remove=(), **extras):
self.warn_deprecated()
self.description = description
self.standard = standard
self.available = available
self.optional = optional
if isinstance(require_features, (str, Require)):
require_features = require_features,
self.require_features = [
r for r in require_features if isinstance(r, str)
]
er = [r for r in require_features if not isinstance(r, str)]
if er:
extras['require_features'] = er
if isinstance(remove, str):
remove = remove,
self.remove = remove
self.extras = extras
if not remove and not require_features and not extras:
raise DistutilsSetupError(
"Feature %s: must define 'require_features', 'remove', or "
"at least one of 'packages', 'py_modules', etc."
)
def include_by_default(self):
"""Should this feature be included by default?"""
return self.available and self.standard
def include_in(self, dist):
"""Ensure feature and its requirements are included in distribution
You may override this in a subclass to perform additional operations on
the distribution. Note that this method may be called more than once
per feature, and so should be idempotent.
"""
if not self.available:
raise DistutilsPlatformError(
self.description + " is required, "
"but is not available on this platform"
)
dist.include(**self.extras)
for f in self.require_features:
dist.include_feature(f)
def exclude_from(self, dist):
"""Ensure feature is excluded from distribution
You may override this in a subclass to perform additional operations on
the distribution. This method will be called at most once per
feature, and only after all included features have been asked to
include themselves.
"""
dist.exclude(**self.extras)
if self.remove:
for item in self.remove:
dist.exclude_package(item)
def validate(self, dist):
"""Verify that feature makes sense in context of distribution
This method is called by the distribution just before it parses its
command line. It checks to ensure that the 'remove' attribute, if any,
contains only valid package/module names that are present in the base
distribution when 'setup()' is called. You may override it in a
subclass to perform any other required validation of the feature
against a target distribution.
"""
for item in self.remove:
if not dist.has_contents_for(item):
raise DistutilsSetupError(
"%s wants to be able to remove %s, but the distribution"
" doesn't contain any packages or modules under %s"
% (self.description, item, item)
)
class DistDeprecationWarning(SetuptoolsDeprecationWarning):
"""Class for warning about deprecations in dist in
setuptools. Not ignored by default, unlike DeprecationWarning."""
PK ! [
depends.pynu [ import sys
import marshal
import contextlib
from distutils.version import StrictVersion
from .py33compat import Bytecode
from .py27compat import find_module, PY_COMPILED, PY_FROZEN, PY_SOURCE
from . import py27compat
__all__ = [
'Require', 'find_module', 'get_module_constant', 'extract_constant'
]
class Require:
"""A prerequisite to building or installing a distribution"""
def __init__(
self, name, requested_version, module, homepage='',
attribute=None, format=None):
if format is None and requested_version is not None:
format = StrictVersion
if format is not None:
requested_version = format(requested_version)
if attribute is None:
attribute = '__version__'
self.__dict__.update(locals())
del self.self
def full_name(self):
"""Return full package/distribution name, w/version"""
if self.requested_version is not None:
return '%s-%s' % (self.name, self.requested_version)
return self.name
def version_ok(self, version):
"""Is 'version' sufficiently up-to-date?"""
return self.attribute is None or self.format is None or \
str(version) != "unknown" and version >= self.requested_version
def get_version(self, paths=None, default="unknown"):
"""Get version number of installed module, 'None', or 'default'
Search 'paths' for module. If not found, return 'None'. If found,
return the extracted version attribute, or 'default' if no version
attribute was specified, or the value cannot be determined without
importing the module. The version is formatted according to the
requirement's version format (if any), unless it is 'None' or the
supplied 'default'.
"""
if self.attribute is None:
try:
f, p, i = find_module(self.module, paths)
if f:
f.close()
return default
except ImportError:
return None
v = get_module_constant(self.module, self.attribute, default, paths)
if v is not None and v is not default and self.format is not None:
return self.format(v)
return v
def is_present(self, paths=None):
"""Return true if dependency is present on 'paths'"""
return self.get_version(paths) is not None
def is_current(self, paths=None):
"""Return true if dependency is present and up-to-date on 'paths'"""
version = self.get_version(paths)
if version is None:
return False
return self.version_ok(version)
def maybe_close(f):
@contextlib.contextmanager
def empty():
yield
return
if not f:
return empty()
return contextlib.closing(f)
def get_module_constant(module, symbol, default=-1, paths=None):
"""Find 'module' by searching 'paths', and extract 'symbol'
Return 'None' if 'module' does not exist on 'paths', or it does not define
'symbol'. If the module defines 'symbol' as a constant, return the
constant. Otherwise, return 'default'."""
try:
f, path, (suffix, mode, kind) = info = find_module(module, paths)
except ImportError:
# Module doesn't exist
return None
with maybe_close(f):
if kind == PY_COMPILED:
f.read(8) # skip magic & date
code = marshal.load(f)
elif kind == PY_FROZEN:
code = py27compat.get_frozen_object(module, paths)
elif kind == PY_SOURCE:
code = compile(f.read(), path, 'exec')
else:
# Not something we can parse; we'll have to import it. :(
imported = py27compat.get_module(module, paths, info)
return getattr(imported, symbol, None)
return extract_constant(code, symbol, default)
def extract_constant(code, symbol, default=-1):
"""Extract the constant value of 'symbol' from 'code'
If the name 'symbol' is bound to a constant value by the Python code
object 'code', return that value. If 'symbol' is bound to an expression,
return 'default'. Otherwise, return 'None'.
Return value is based on the first assignment to 'symbol'. 'symbol' must
be a global, or at least a non-"fast" local in the code block. That is,
only 'STORE_NAME' and 'STORE_GLOBAL' opcodes are checked, and 'symbol'
must be present in 'code.co_names'.
"""
if symbol not in code.co_names:
# name's not there, can't possibly be an assignment
return None
name_idx = list(code.co_names).index(symbol)
STORE_NAME = 90
STORE_GLOBAL = 97
LOAD_CONST = 100
const = default
for byte_code in Bytecode(code):
op = byte_code.opcode
arg = byte_code.arg
if op == LOAD_CONST:
const = code.co_consts[arg]
elif arg == name_idx and (op == STORE_NAME or op == STORE_GLOBAL):
return const
else:
const = default
def _update_globals():
"""
Patch the globals to remove the objects not available on some platforms.
XXX it'd be better to test assertions about bytecode instead.
"""
if not sys.platform.startswith('java') and sys.platform != 'cli':
return
incompatible = 'extract_constant', 'get_module_constant'
for name in incompatible:
del globals()[name]
__all__.remove(name)
_update_globals()
PK ! Ok glob.pynu [ """
Filename globbing utility. Mostly a copy of `glob` from Python 3.5.
Changes include:
* `yield from` and PEP3102 `*` removed.
* Hidden files are not ignored.
"""
import os
import re
import fnmatch
__all__ = ["glob", "iglob", "escape"]
def glob(pathname, recursive=False):
"""Return a list of paths matching a pathname pattern.
The pattern may contain simple shell-style wildcards a la
fnmatch. However, unlike fnmatch, filenames starting with a
dot are special cases that are not matched by '*' and '?'
patterns.
If recursive is true, the pattern '**' will match any files and
zero or more directories and subdirectories.
"""
return list(iglob(pathname, recursive=recursive))
def iglob(pathname, recursive=False):
"""Return an iterator which yields the paths matching a pathname pattern.
The pattern may contain simple shell-style wildcards a la
fnmatch. However, unlike fnmatch, filenames starting with a
dot are special cases that are not matched by '*' and '?'
patterns.
If recursive is true, the pattern '**' will match any files and
zero or more directories and subdirectories.
"""
it = _iglob(pathname, recursive)
if recursive and _isrecursive(pathname):
s = next(it) # skip empty string
assert not s
return it
def _iglob(pathname, recursive):
dirname, basename = os.path.split(pathname)
if not has_magic(pathname):
if basename:
if os.path.lexists(pathname):
yield pathname
else:
# Patterns ending with a slash should match only directories
if os.path.isdir(dirname):
yield pathname
return
if not dirname:
if recursive and _isrecursive(basename):
for x in glob2(dirname, basename):
yield x
else:
for x in glob1(dirname, basename):
yield x
return
# `os.path.split()` returns the argument itself as a dirname if it is a
# drive or UNC path. Prevent an infinite recursion if a drive or UNC path
# contains magic characters (i.e. r'\\?\C:').
if dirname != pathname and has_magic(dirname):
dirs = _iglob(dirname, recursive)
else:
dirs = [dirname]
if has_magic(basename):
if recursive and _isrecursive(basename):
glob_in_dir = glob2
else:
glob_in_dir = glob1
else:
glob_in_dir = glob0
for dirname in dirs:
for name in glob_in_dir(dirname, basename):
yield os.path.join(dirname, name)
# These 2 helper functions non-recursively glob inside a literal directory.
# They return a list of basenames. `glob1` accepts a pattern while `glob0`
# takes a literal basename (so it only has to check for its existence).
def glob1(dirname, pattern):
if not dirname:
if isinstance(pattern, bytes):
dirname = os.curdir.encode('ASCII')
else:
dirname = os.curdir
try:
names = os.listdir(dirname)
except OSError:
return []
return fnmatch.filter(names, pattern)
def glob0(dirname, basename):
if not basename:
# `os.path.split()` returns an empty basename for paths ending with a
# directory separator. 'q*x/' should match only directories.
if os.path.isdir(dirname):
return [basename]
else:
if os.path.lexists(os.path.join(dirname, basename)):
return [basename]
return []
# This helper function recursively yields relative pathnames inside a literal
# directory.
def glob2(dirname, pattern):
assert _isrecursive(pattern)
yield pattern[:0]
for x in _rlistdir(dirname):
yield x
# Recursively yields relative pathnames inside a literal directory.
def _rlistdir(dirname):
if not dirname:
if isinstance(dirname, bytes):
dirname = os.curdir.encode('ASCII')
else:
dirname = os.curdir
try:
names = os.listdir(dirname)
except os.error:
return
for x in names:
yield x
path = os.path.join(dirname, x) if dirname else x
for y in _rlistdir(path):
yield os.path.join(x, y)
magic_check = re.compile('([*?[])')
magic_check_bytes = re.compile(b'([*?[])')
def has_magic(s):
if isinstance(s, bytes):
match = magic_check_bytes.search(s)
else:
match = magic_check.search(s)
return match is not None
def _isrecursive(pattern):
if isinstance(pattern, bytes):
return pattern == b'**'
else:
return pattern == '**'
def escape(pathname):
"""Escape all special characters.
"""
# Escaping is done by wrapping any of "*?[" between square brackets.
# Metacharacters do not work in the drive part and shouldn't be escaped.
drive, pathname = os.path.splitdrive(pathname)
if isinstance(pathname, bytes):
pathname = magic_check_bytes.sub(br'[\1]', pathname)
else:
pathname = magic_check.sub(r'[\1]', pathname)
return drive + pathname
PK ! Bך unicode_utils.pynu [ import unicodedata
import sys
from setuptools.extern import six
# HFS Plus uses decomposed UTF-8
def decompose(path):
if isinstance(path, six.text_type):
return unicodedata.normalize('NFD', path)
try:
path = path.decode('utf-8')
path = unicodedata.normalize('NFD', path)
path = path.encode('utf-8')
except UnicodeError:
pass # Not UTF-8
return path
def filesys_decode(path):
"""
Ensure that the given path is decoded,
NONE when no expected encoding works
"""
if isinstance(path, six.text_type):
return path
fs_enc = sys.getfilesystemencoding() or 'utf-8'
candidates = fs_enc, 'utf-8'
for enc in candidates:
try:
return path.decode(enc)
except UnicodeDecodeError:
continue
def try_encode(string, enc):
"turn unicode encoding into a functional routine"
try:
return string.encode(enc)
except UnicodeEncodeError:
return None
PK ! extension.pynu [ import re
import functools
import distutils.core
import distutils.errors
import distutils.extension
from setuptools.extern.six.moves import map
from .monkey import get_unpatched
def _have_cython():
"""
Return True if Cython can be imported.
"""
cython_impl = 'Cython.Distutils.build_ext'
try:
# from (cython_impl) import build_ext
__import__(cython_impl, fromlist=['build_ext']).build_ext
return True
except Exception:
pass
return False
# for compatibility
have_pyrex = _have_cython
_Extension = get_unpatched(distutils.core.Extension)
class Extension(_Extension):
"""Extension that uses '.c' files in place of '.pyx' files"""
def __init__(self, name, sources, *args, **kw):
# The *args is needed for compatibility as calls may use positional
# arguments. py_limited_api may be set only via keyword.
self.py_limited_api = kw.pop("py_limited_api", False)
_Extension.__init__(self, name, sources, *args, **kw)
def _convert_pyx_sources_to_lang(self):
"""
Replace sources with .pyx extensions to sources with the target
language extension. This mechanism allows language authors to supply
pre-converted sources but to prefer the .pyx sources.
"""
if _have_cython():
# the build has Cython, so allow it to compile the .pyx files
return
lang = self.language or ''
target_ext = '.cpp' if lang.lower() == 'c++' else '.c'
sub = functools.partial(re.sub, '.pyx$', target_ext)
self.sources = list(map(sub, self.sources))
class Library(Extension):
"""Just like a regular Extension, but built as a library instead"""
PK ! script (dev).tmplnu [ # EASY-INSTALL-DEV-SCRIPT: %(spec)r,%(script_name)r
__requires__ = %(spec)r
__import__('pkg_resources').require(%(spec)r)
__file__ = %(dev_path)r
with open(__file__) as f:
exec(compile(f.read(), __file__, 'exec'))
PK ! 3 wheel.pynu [ """Wheels support."""
from distutils.util import get_platform
import email
import itertools
import os
import posixpath
import re
import zipfile
import pkg_resources
import setuptools
from pkg_resources import parse_version
from setuptools.extern.packaging.utils import canonicalize_name
from setuptools.extern.six import PY3
from setuptools import pep425tags
from setuptools.command.egg_info import write_requirements
__metaclass__ = type
WHEEL_NAME = re.compile(
r"""^(?P.+?)-(?P\d.*?)
((-(?P\d.*?))?-(?P.+?)-(?P.+?)-(?P.+?)
)\.whl$""",
re.VERBOSE).match
NAMESPACE_PACKAGE_INIT = '''\
try:
__import__('pkg_resources').declare_namespace(__name__)
except ImportError:
__path__ = __import__('pkgutil').extend_path(__path__, __name__)
'''
def unpack(src_dir, dst_dir):
'''Move everything under `src_dir` to `dst_dir`, and delete the former.'''
for dirpath, dirnames, filenames in os.walk(src_dir):
subdir = os.path.relpath(dirpath, src_dir)
for f in filenames:
src = os.path.join(dirpath, f)
dst = os.path.join(dst_dir, subdir, f)
os.renames(src, dst)
for n, d in reversed(list(enumerate(dirnames))):
src = os.path.join(dirpath, d)
dst = os.path.join(dst_dir, subdir, d)
if not os.path.exists(dst):
# Directory does not exist in destination,
# rename it and prune it from os.walk list.
os.renames(src, dst)
del dirnames[n]
# Cleanup.
for dirpath, dirnames, filenames in os.walk(src_dir, topdown=True):
assert not filenames
os.rmdir(dirpath)
class Wheel:
def __init__(self, filename):
match = WHEEL_NAME(os.path.basename(filename))
if match is None:
raise ValueError('invalid wheel name: %r' % filename)
self.filename = filename
for k, v in match.groupdict().items():
setattr(self, k, v)
def tags(self):
'''List tags (py_version, abi, platform) supported by this wheel.'''
return itertools.product(
self.py_version.split('.'),
self.abi.split('.'),
self.platform.split('.'),
)
def is_compatible(self):
'''Is the wheel is compatible with the current platform?'''
supported_tags = pep425tags.get_supported()
return next((True for t in self.tags() if t in supported_tags), False)
def egg_name(self):
return pkg_resources.Distribution(
project_name=self.project_name, version=self.version,
platform=(None if self.platform == 'any' else get_platform()),
).egg_name() + '.egg'
def get_dist_info(self, zf):
# find the correct name of the .dist-info dir in the wheel file
for member in zf.namelist():
dirname = posixpath.dirname(member)
if (dirname.endswith('.dist-info') and
canonicalize_name(dirname).startswith(
canonicalize_name(self.project_name))):
return dirname
raise ValueError("unsupported wheel format. .dist-info not found")
def install_as_egg(self, destination_eggdir):
'''Install wheel as an egg directory.'''
with zipfile.ZipFile(self.filename) as zf:
self._install_as_egg(destination_eggdir, zf)
def _install_as_egg(self, destination_eggdir, zf):
dist_basename = '%s-%s' % (self.project_name, self.version)
dist_info = self.get_dist_info(zf)
dist_data = '%s.data' % dist_basename
egg_info = os.path.join(destination_eggdir, 'EGG-INFO')
self._convert_metadata(zf, destination_eggdir, dist_info, egg_info)
self._move_data_entries(destination_eggdir, dist_data)
self._fix_namespace_packages(egg_info, destination_eggdir)
@staticmethod
def _convert_metadata(zf, destination_eggdir, dist_info, egg_info):
def get_metadata(name):
with zf.open(posixpath.join(dist_info, name)) as fp:
value = fp.read().decode('utf-8') if PY3 else fp.read()
return email.parser.Parser().parsestr(value)
wheel_metadata = get_metadata('WHEEL')
# Check wheel format version is supported.
wheel_version = parse_version(wheel_metadata.get('Wheel-Version'))
wheel_v1 = (
parse_version('1.0') <= wheel_version < parse_version('2.0dev0')
)
if not wheel_v1:
raise ValueError(
'unsupported wheel format version: %s' % wheel_version)
# Extract to target directory.
os.mkdir(destination_eggdir)
zf.extractall(destination_eggdir)
# Convert metadata.
dist_info = os.path.join(destination_eggdir, dist_info)
dist = pkg_resources.Distribution.from_location(
destination_eggdir, dist_info,
metadata=pkg_resources.PathMetadata(destination_eggdir, dist_info),
)
# Note: Evaluate and strip markers now,
# as it's difficult to convert back from the syntax:
# foobar; "linux" in sys_platform and extra == 'test'
def raw_req(req):
req.marker = None
return str(req)
install_requires = list(sorted(map(raw_req, dist.requires())))
extras_require = {
extra: sorted(
req
for req in map(raw_req, dist.requires((extra,)))
if req not in install_requires
)
for extra in dist.extras
}
os.rename(dist_info, egg_info)
os.rename(
os.path.join(egg_info, 'METADATA'),
os.path.join(egg_info, 'PKG-INFO'),
)
setup_dist = setuptools.Distribution(
attrs=dict(
install_requires=install_requires,
extras_require=extras_require,
),
)
write_requirements(
setup_dist.get_command_obj('egg_info'),
None,
os.path.join(egg_info, 'requires.txt'),
)
@staticmethod
def _move_data_entries(destination_eggdir, dist_data):
"""Move data entries to their correct location."""
dist_data = os.path.join(destination_eggdir, dist_data)
dist_data_scripts = os.path.join(dist_data, 'scripts')
if os.path.exists(dist_data_scripts):
egg_info_scripts = os.path.join(
destination_eggdir, 'EGG-INFO', 'scripts')
os.mkdir(egg_info_scripts)
for entry in os.listdir(dist_data_scripts):
# Remove bytecode, as it's not properly handled
# during easy_install scripts install phase.
if entry.endswith('.pyc'):
os.unlink(os.path.join(dist_data_scripts, entry))
else:
os.rename(
os.path.join(dist_data_scripts, entry),
os.path.join(egg_info_scripts, entry),
)
os.rmdir(dist_data_scripts)
for subdir in filter(os.path.exists, (
os.path.join(dist_data, d)
for d in ('data', 'headers', 'purelib', 'platlib')
)):
unpack(subdir, destination_eggdir)
if os.path.exists(dist_data):
os.rmdir(dist_data)
@staticmethod
def _fix_namespace_packages(egg_info, destination_eggdir):
namespace_packages = os.path.join(
egg_info, 'namespace_packages.txt')
if os.path.exists(namespace_packages):
with open(namespace_packages) as fp:
namespace_packages = fp.read().split()
for mod in namespace_packages:
mod_dir = os.path.join(destination_eggdir, *mod.split('.'))
mod_init = os.path.join(mod_dir, '__init__.py')
if os.path.exists(mod_dir) and not os.path.exists(mod_init):
with open(mod_init, 'w') as fp:
fp.write(NAMESPACE_PACKAGE_INIT)
PK ! VD
py34compat.pynu [ import importlib
try:
import importlib.util
except ImportError:
pass
try:
module_from_spec = importlib.util.module_from_spec
except AttributeError:
def module_from_spec(spec):
return spec.loader.load_module(spec.name)
PK ! s PK ! T-k k % __pycache__/lib2to3_ex.cpython-38.pycnu [ U
Qab @ sX d Z ddlmZ ddlmZ ddlmZmZ ddl Z G dd deZ
G dd d eZdS )
zy
Customized Mixin2to3 support:
- adds support for converting doctests
This module raises an ImportError on Python 2.
) Mixin2to3)log)RefactoringToolget_fixers_from_packageNc @ s$ e Zd Zdd Zdd Zdd ZdS )DistutilsRefactoringToolc O s t j|f| d S N)r error)selfmsgargskw r
9/usr/lib/python3.8/site-packages/setuptools/lib2to3_ex.py log_error s z"DistutilsRefactoringTool.log_errorc G s t j|f| d S r )r infor r
r r
r
r log_message s z$DistutilsRefactoringTool.log_messagec G s t j|f| d S r )r debugr r
r
r log_debug s z"DistutilsRefactoringTool.log_debugN)__name__
__module__ __qualname__r r r r
r
r
r r s r c @ s& e Zd Zd ddZdd Zdd ZdS )
r Fc C sr | j jdk rd S |sd S tdd| | | |rbtjrnt | j
}|j |ddd n t
| | d S )NTzFixing )writeZ
doctests_only) distributionZuse_2to3r r join _Mixin2to3__build_fixer_names_Mixin2to3__exclude_fixers
setuptoolsZrun_2to3_on_doctestsr fixer_namesZrefactor
_Mixin2to3run_2to3)r filesZdoctestsrr
r
r r! s
zMixin2to3.run_2to3c C sZ | j r
d S g | _ tjD ]}| j t| q| jjd k rV| jjD ]}| j t| q@d S r )r r Zlib2to3_fixer_packagesextendr r Zuse_2to3_fixers)r pr
r
r Z__build_fixer_names. s
z Mixin2to3.__build_fixer_namesc C sJ t | dg }| jjd k r&|| jj |D ]}|| jkr*| j| q*d S )NZexclude_fixers)getattrr Zuse_2to3_exclude_fixersr$ r remove)r Zexcluded_fixersZ
fixer_namer
r
r Z__exclude_fixers8 s
zMixin2to3.__exclude_fixersN)F)r r r r! r r r
r
r
r r s
r ) __doc__Zdistutils.utilr r Z distutilsr Zlib2to3.refactorr r r r r
r
r
r s PK ! ئ * __pycache__/windows_support.cpython-38.pycnu [ U
Qab @ s( d dl Z d dlZdd Zedd ZdS ) Nc C s t dkrdd S | S )NZWindowsc _ s d S )N )argskwargsr r >/usr/lib/python3.8/site-packages/setuptools/windows_support.py z windows_only..)platformsystem)funcr r r windows_only s r c C sL t d tjjj}tjjtjjf|_tjj |_
d}|| |}|sHt dS )z
Set the hidden attribute on a file or directory.
From http://stackoverflow.com/questions/19622133/
`path` must be text.
zctypes.wintypes N)
__import__ctypesZwindllZkernel32ZSetFileAttributesWZwintypesZLPWSTRZDWORDZargtypesZBOOLZrestypeZWinError)pathZSetFileAttributesFILE_ATTRIBUTE_HIDDENretr r r hide_file s
r )r r r r r r r r s PK ! ! % __pycache__/py31compat.cpython-38.pycnu [ U
QabF @ sP g Z eZzd dlmZ W n2 ek
rJ d dlZd dlZG dd dZY nX dS ) )TemporaryDirectoryNc @ s( e Zd ZdZdd Zdd Zdd ZdS ) r z
Very simple temporary directory context manager.
Will try to delete afterward, but will also ignore OS and similar
errors on deletion.
c K s d | _ tjf || _ d S N)nametempfileZmkdtemp)selfkwargs r 9/usr/lib/python3.8/site-packages/setuptools/py31compat.py__init__ s zTemporaryDirectory.__init__c C s | j S r )r )r r r r __enter__ s z TemporaryDirectory.__enter__c C s2 zt | jd W n tk
r& Y nX d | _d S )NT)shutilZrmtreer OSError)r exctypeZexcvalueZexctracer r r __exit__ s
zTemporaryDirectory.__exit__N)__name__
__module__ __qualname____doc__r
r r r r r r r
s r )__all__typeZ
__metaclass__r r ImportErrorr r r r r s PK ! C3 3 ) __pycache__/dep_util.cpython-38.opt-1.pycnu [ U
Qab @ s d dl mZ dd ZdS ) ) newer_groupc C sh t | t |krtdg }g }tt | D ]2}t| | || r,|| | ||| q,||fS )zWalk both arguments in parallel, testing if each source group is newer
than its corresponding target. Returns a pair of lists (sources_groups,
targets) where sources is newer than target, according to the semantics
of 'newer_group()'.
z5'sources_group' and 'targets' must be the same length)len
ValueErrorranger append)Zsources_groupsZtargetsZ n_sourcesZ n_targetsi r 7/usr/lib/python3.8/site-packages/setuptools/dep_util.pynewer_pairwise_group s r
N)Zdistutils.dep_utilr r
r r r r s PK ! \ + __pycache__/py34compat.cpython-38.opt-1.pycnu [ U
Qab @ sX d dl Z z d dlZ W n ek
r( Y nX z e jjZW n ek
rR dd ZY nX dS ) Nc C s | j | jS )N)loader load_modulename)spec r 9/usr/lib/python3.8/site-packages/setuptools/py34compat.pymodule_from_spec s r ) importlibimportlib.util ImportErrorutilr AttributeErrorr r r r s PK ! T-k k + __pycache__/lib2to3_ex.cpython-38.opt-1.pycnu [ U
Qab @ sX d Z ddlmZ ddlmZ ddlmZmZ ddl Z G dd deZ
G dd d eZdS )
zy
Customized Mixin2to3 support:
- adds support for converting doctests
This module raises an ImportError on Python 2.
) Mixin2to3)log)RefactoringToolget_fixers_from_packageNc @ s$ e Zd Zdd Zdd Zdd ZdS )DistutilsRefactoringToolc O s t j|f| d S N)r error)selfmsgargskw r
9/usr/lib/python3.8/site-packages/setuptools/lib2to3_ex.py log_error s z"DistutilsRefactoringTool.log_errorc G s t j|f| d S r )r infor r
r r
r
r log_message s z$DistutilsRefactoringTool.log_messagec G s t j|f| d S r )r debugr r
r
r log_debug s z"DistutilsRefactoringTool.log_debugN)__name__
__module__ __qualname__r r r r
r
r
r r s r c @ s& e Zd Zd ddZdd Zdd ZdS )
r Fc C sr | j jdk rd S |sd S tdd| | | |rbtjrnt | j
}|j |ddd n t
| | d S )NTzFixing )writeZ
doctests_only) distributionZuse_2to3r r join _Mixin2to3__build_fixer_names_Mixin2to3__exclude_fixers
setuptoolsZrun_2to3_on_doctestsr fixer_namesZrefactor
_Mixin2to3run_2to3)r filesZdoctestsrr
r
r r! s
zMixin2to3.run_2to3c C sZ | j r
d S g | _ tjD ]}| j t| q| jjd k rV| jjD ]}| j t| q@d S r )r r Zlib2to3_fixer_packagesextendr r Zuse_2to3_fixers)r pr
r
r Z__build_fixer_names. s
z Mixin2to3.__build_fixer_namesc C sJ t | dg }| jjd k r&|| jj |D ]}|| jkr*| j| q*d S )NZexclude_fixers)getattrr Zuse_2to3_exclude_fixersr$ r remove)r Zexcluded_fixersZ
fixer_namer
r
r Z__exclude_fixers8 s
zMixin2to3.__exclude_fixersN)F)r r r r! r r r
r
r
r r s
r ) __doc__Zdistutils.utilr r Z distutilsr Zlib2to3.refactorr r r r r
r
r
r s PK ! \ % __pycache__/py34compat.cpython-38.pycnu [ U
Qab @ sX d dl Z z d dlZ W n ek
r( Y nX z e jjZW n ek
rR dd ZY nX dS ) Nc C s | j | jS )N)loader load_modulename)spec r 9/usr/lib/python3.8/site-packages/setuptools/py34compat.pymodule_from_spec s r ) importlibimportlib.util ImportErrorutilr AttributeErrorr r r r s PK ! s PK ! M]/! /! % __pycache__/build_meta.cpython-38.pycnu [ U
Qab}% @ s d Z ddlZddlZddlZddlZddlZddlZddlZddlZddl m
Z
ddl m Z ddl
mZ dddd d
d d gZG d
d d eZG dd dejjZdd Zdd Zdd Zdd ZG dd deZG dd deZe Zej Z ej Z ej Z ej Z ej Z e Z!dS ) a- A PEP 517 interface to setuptools
Previously, when a user or a command line tool (let's call it a "frontend")
needed to make a request of setuptools to take a certain action, for
example, generating a list of installation requirements, the frontend would
would call "setup.py egg_info" or "setup.py bdist_wheel" on the command line.
PEP 517 defines a different method of interfacing with setuptools. Rather
than calling "setup.py" directly, the frontend should:
1. Set the current directory to the directory with a setup.py file
2. Import this module into a safe python interpreter (one in which
setuptools can potentially set global variables or crash hard).
3. Call one of the functions defined in PEP 517.
What each function does is defined in PEP 517. However, here is a "casual"
definition of the functions (this definition should not be relied on for
bug reports or API stability):
- `build_wheel`: build a wheel in the folder and return the basename
- `get_requires_for_build_wheel`: get the `setup_requires` to build
- `prepare_metadata_for_build_wheel`: get the `install_requires`
- `build_sdist`: build an sdist in the folder and return the basename
- `get_requires_for_build_sdist`: get the `setup_requires` to build
Again, this is not a formal definition! Just a "taste" of the module.
N)TemporaryDirectory)parse_requirements)makedirs get_requires_for_build_sdist get_requires_for_build_wheel prepare_metadata_for_build_wheel build_wheel build_sdist
__legacy__SetupRequirementsErrorc @ s e Zd Zdd ZdS )r c C s
|| _ d S N)
specifiers)selfr
r 9/usr/lib/python3.8/site-packages/setuptools/build_meta.py__init__4 s z SetupRequirementsError.__init__N)__name__
__module__ __qualname__r r r r r r 3 s c @ s& e Zd Zdd Zeejdd ZdS ) Distributionc C s t ttt|}t|d S r )listmapstrr r )r r
Zspecifier_listr r r fetch_build_eggs9 s z Distribution.fetch_build_eggsc c s* t jj}| t j_z
dV W 5 |t j_X dS )zw
Replace
distutils.dist.Distribution with this class
for the duration of this context.
N) distutilsZcorer )clsZorigr r r patch> s
zDistribution.patchN)r r r r classmethod
contextlibcontextmanagerr r r r r r 8 s r c C s* t jd dkr&t| ts&| t S | S )z
Convert a filename to a string (on Python 2, explicitly
a byte string, not Unicode) as distutils checks for the
exact type str.
r )sys version_info
isinstancer encodegetfilesystemencoding)sr r r _to_strN s r' c s fddt D S )Nc s& g | ] }t jt j |r|qS r )ospathisdirjoin).0nameZa_dirr r
\ s z1_get_immediate_subdirectories..r( listdirr. r r. r _get_immediate_subdirectories[ s r2 c s" fddt | D }|\}|S )Nc 3 s | ]}| r|V qd S r endswithr, f extensionr r a s
z'_file_with_extension..r0 )Z directoryr8 Zmatchingfiler r7 r _file_with_extension` s
r; c C s& t j| stdS ttdt| S )Nz%from setuptools import setup; setup()open)r( r) existsioStringIOgetattrtokenizer< setup_scriptr r r _open_setup_scripti s
rD c @ s` e Zd Zdd Zdd ZdddZdd d
Zdd d Zdd
dZdd Z dddZ
dddZ dS )_BuildMetaBackendc C s |pi }| dg |S )N--global-option)
setdefaultr config_settingsr r r _fix_configs s z _BuildMetaBackend._fix_configc
C sz | |}tjd d dg |d t_z t | W 5 Q R X W n, tk
rt } z||j7 }W 5 d }~X Y nX |S )N Zegg_inforF )rJ r! argvr r run_setupr r
)r rI requirementser r r _get_build_requiresx s
z%_BuildMetaBackend._get_build_requiressetup.pyc C sD |}d}t |}| dd}W 5 Q R X tt||dt d S )N__main__z\r\nz\nexec)rD readreplacerS compilelocals)r rC __file__r r6 coder r r rM s
z_BuildMetaBackend.run_setupNc C s | |}| j|dgdS )NZwheelrN rJ rP rH r r r r s
z._BuildMetaBackend.get_requires_for_build_wheelc C s | |}| j|g dS )NrZ r[ rH r r r r s
z._BuildMetaBackend.get_requires_for_build_sdistc C s t jd d ddt|g t _| |}dd t|D }t|dkrttt|dkrttj |t|d }q*t|dkst
qq*||krt tj ||d | t j
|dd |d S ) NrK Z dist_infoz
--egg-basec S s g | ]}| d r|qS )z
.dist-infor3 r5 r r r r/ s
zF_BuildMetaBackend.prepare_metadata_for_build_wheel..r T)
ignore_errors)r! rL r' rM r( r1 lenr2 r) r+ AssertionErrorshutilZmoveZrmtree)r metadata_directoryrI Zdist_info_directoryZ
dist_infosr r r r s. z2_BuildMetaBackend.prepare_metadata_for_build_wheelc C s | |}tj|}t|dd t|dv}tjd d | d|g |d t_| t ||}tj
||}tj |rt | t
tj
||| W 5 Q R X |S )NT)exist_ok)dirrK z
--dist-dirrF )rJ r( r) abspathr r r! rL rM r; r+ r= removerename)r Z
setup_commandZresult_extensionZresult_directoryrI Z tmp_dist_dirZresult_basenameZ result_pathr r r _build_with_temp_dir s
z&_BuildMetaBackend._build_with_temp_dirc C s | dgd||S )NZ bdist_wheelz.whlrf )r Zwheel_directoryrI r` r r r r s
z _BuildMetaBackend.build_wheelc C s | dddgd||S )NZsdistz --formatsZgztarz.tar.gzrg )r Zsdist_directoryrI r r r r s
z _BuildMetaBackend.build_sdist)rQ )N)N)N)NN)N) r r r rJ rP rM r r r rf r r r r r r rE q s
rE c s" e Zd ZdZd fdd Z ZS )_BuildMetaLegacyBackendaC Compatibility backend for setuptools
This is a version of setuptools.build_meta that endeavors to maintain backwards
compatibility with pre-PEP 517 modes of invocation. It exists as a temporary
bridge between the old packaging mechanism and the new packaging mechanism,
and will eventually be removed.
rQ c
sb t tj}tjtj|}|tjkr6tjd| ztt| j |d W 5 |tjd d < X d S )Nr rB )
r r! r) r( dirnamerc insertsuperrh rM )r rC Zsys_pathZ
script_dir __class__r r rM s
z!_BuildMetaLegacyBackend.run_setup)rQ )r r r __doc__rM
__classcell__r r rl r rh s rh )"rn r> r( r! rA r_ r Z
setuptoolsr Zsetuptools.py31compatr Z
pkg_resourcesr Zpkg_resources.py31compatr __all__
BaseExceptionr Zdistr r' r2 r; rD objectrE rh Z_BACKENDr r r r r r
r r r r sD
h PK ! tE E ' __pycache__/config.cpython-38.opt-1.pycnu [ U
Qab6P @ s d dl mZmZ d dlZd dlZd dlZd dlZd dlZd dlm Z d dlm
Z
d dlm Z d dl m
Z
d dlmZmZ d dlmZmZ d d lmZ d d
lmZmZ eZdd d
Zdd Z dd Z dddZ G dd dZ G dd de Z G dd de Z!dS ) )absolute_importunicode_literalsN) defaultdict)partialwraps)
import_module)DistutilsOptionErrorDistutilsFileError)
LegacyVersionparse) SpecifierSet) string_typesPY3Fc C s ddl m}m} tj| } tj| s4td| t }t tj
| zJ| }|rb| ng }| |krx| | |j
||d t||j|d}W 5 t | X t|S )a, Read given configuration file and returns options from it as a dict.
:param str|unicode filepath: Path to configuration file
to get options from.
:param bool find_others: Whether to search for other configuration files
which could be on in various places.
:param bool ignore_option_errors: Whether to silently ignore
options, values of which could not be resolved (e.g. due to exceptions
in directives such as file:, attr:, etc.).
If False exceptions are propagated as expected.
:rtype: dict
r ) Distribution
_Distributionz%Configuration file %s does not exist.) filenames)ignore_option_errors)Zsetuptools.distr r ospathabspathisfiler
getcwdchdirdirnameZfind_config_filesappendZparse_config_filesparse_configurationcommand_optionsconfiguration_to_dict) filepathZ find_othersr r r Zcurrent_directoryZdistr handlers r! 5/usr/lib/python3.8/site-packages/setuptools/config.pyread_configuration s*
r# c C s. dj f t }tt| |}t| ||}| S )z
Given a target object and option key, get that option from
the target object, either through a get_{key} method or
from an attribute directly.
z get_{key})formatlocals functoolsr getattr)
target_objkeyZ getter_nameZ by_attributegetterr! r! r" _get_optionE s r+ c C s< t t}| D ]*}|jD ] }t|j|}|||j |< qq |S )zReturns configuration data gathered by given handlers as a dict.
:param list[ConfigHandler] handlers: Handlers list,
usually from parse_configuration()
:rtype: dict
)r dict set_optionsr+ r( section_prefix)r Z config_dictZhandlerZoptionvaluer! r! r" r Q s
r c C s6 t | ||}| t| j||| j}| ||fS )a Performs additional parsing of configuration options
for a distribution.
Returns a list of used option handlers.
:param Distribution distribution:
:param dict command_options:
:param bool ignore_option_errors: Whether to silently ignore
options, values of which could not be resolved (e.g. due to exceptions
in directives such as file:, attr:, etc.).
If False exceptions are propagated as expected.
:rtype: list
)ConfigOptionsHandlerr ConfigMetadataHandlermetadata package_dir)Z distributionr r optionsmetar! r! r" r c s r c @ s e Zd ZdZdZi Zd%ddZedd Zdd Z e
d&d d Z e
d
d Z e
dd Z
e
dd Ze
dd Zedd Zedd Ze
d'ddZe
dd Ze
d(d d Zd d Zd!d" Zd#d$ ZdS ))
ConfigHandlerz1Handles metadata supplied in configuration files.NFc C s^ i }| j }| D ].\}}||s&q||dd}|||< q|| _|| _|| _g | _d S )N .) r. items
startswithreplacestripr r( sectionsr- )selfr( r4 r r= r. section_namesection_optionsr! r! r" __init__ s
zConfigHandler.__init__c C s t d| jj dS ).Metadata item name to parser function mapping.z!%s must provide .parsers propertyN)NotImplementedError __class____name__)r> r! r! r" parsers s
zConfigHandler.parsersc C s t }| j}| j||}t|||}||kr6t||r>d S d}| j|}|rz ||}W n tk
r~ d}| jsz Y nX |rd S t|d| d }|d krt ||| n|| | j
| d S )NFTzset_%s) tupler( aliasesgetr' KeyErrorrF Exceptionr setattrr- r ) r> Z option_namer/ unknownr( Z
current_valueZ skip_optionparsersetterr! r! r" __setitem__ s0 zConfigHandler.__setitem__,c C s8 t |tr|S d|kr | }n
||}dd |D S )zRepresents value as a list.
Value is split either by separator (defaults to comma) or by lines.
:param value:
:param separator: List items separator character.
:rtype: list
c S s g | ]}| r| qS r! )r< ).0chunkr! r! r"
s z-ConfigHandler._parse_list..)
isinstancelist
splitlinessplit)clsr/ separatorr! r! r" _parse_list s
zConfigHandler._parse_listc C sP d}i }| |D ]8}||\}}}||kr:td| | || < q|S )zPRepresents value as a dict.
:param value:
:rtype: dict
=z(Unable to parse option value to dict: %s)r\ partitionr r< )rZ r/ r[ resultliner) sepvalr! r! r" _parse_dict s zConfigHandler._parse_dictc C s | }|dkS )zQRepresents value as boolean.
:param value:
:rtype: bool
)1trueZyes)lower)rZ r/ r! r! r" _parse_bool s zConfigHandler._parse_boolc s fdd}|S )zReturns a parser function to make sure field inputs
are not files.
Parses a value after getting the key so error messages are
more informative.
:param key:
:rtype: callable
c s d}| |r td | S )Nfile:zCOnly strings are accepted for the {0} field, files are not accepted)r:
ValueErrorr$ )r/ Zexclude_directiver) r! r" rN s
z3ConfigHandler._exclude_files_parser..parserr! )rZ r) rN r! rj r" _exclude_files_parser s z#ConfigHandler._exclude_files_parserc s\ d}t |ts|S ||s |S |t|d }dd |dD }d fdd|D S )aO Represents value as a string, allowing including text
from nearest files using `file:` directive.
Directive is sandboxed and won't reach anything outside
directory with setup.py.
Examples:
file: README.rst, CHANGELOG.md, src/file.txt
:param str value:
:rtype: str
rh Nc s s | ]}t j| V qd S N)r r r r< rS r r! r! r" % s z,ConfigHandler._parse_file..rQ rR c 3 s. | ]&} |stj|r |V qdS )TN)
_assert_localr r r
_read_filerm rZ r! r" rn & s
)rV r r: lenrY join)rZ r/ Zinclude_directivespecZ filepathsr! rq r" _parse_file s
zConfigHandler._parse_filec C s | t std| d S )Nz#`file:` directive can not access %s)r: r r r )r r! r! r" ro - s zConfigHandler._assert_localc
C s. t j| dd}| W 5 Q R S Q R X d S )Nzutf-8)encoding)ioopenread)r fr! r! r" rp 3 s zConfigHandler._read_filec C s d}| |s|S ||d d}| }d|}|p@d}t }|r|d |kr||d }|dd} t | dkrtj
t | d }| d }q|}n d|krtj
t |d }t j
d| zt
|}
t|
|}W 5 t j
dd t _
X |S ) zRepresents value as a module attribute.
Examples:
attr: package.attr
attr: package.module.attr
:param str value:
:rtype: str
zattr:r7 r8 rA r / N)r: r; r< rY poprs r r rsplitrr r sysinsertr r' ) rZ r/ r3 Zattr_directiveZ
attrs_pathZ attr_nameZ module_name parent_pathZ custom_pathpartsmoduler! r! r" _parse_attr8 s0
zConfigHandler._parse_attrc s fdd}|S )zReturns parser function to represents value as a list.
Parses a value applying given methods one after another.
:param parse_methods:
:rtype: callable
c s | } D ] }||}q|S rl r! )r/ parsedmethod
parse_methodsr! r" r n s
z1ConfigHandler._get_parser_compound..parser! )rZ r r r! r r" _get_parser_compounde s z"ConfigHandler._get_parser_compoundc C s6 i }|pdd }| D ]\}\}}||||< q|S )zParses section options into a dictionary.
Optionally applies a given parser to values.
:param dict section_options:
:param callable values_parser:
:rtype: dict
c S s | S rl r! )rb r! r! r" z6ConfigHandler._parse_section_to_dict..)r9 )rZ r@ Z
values_parserr/ r) _rb r! r! r" _parse_section_to_dictx s
z$ConfigHandler._parse_section_to_dictc C s< | D ].\}\}}z || |< W q tk
r4 Y qX qdS )zQParses configuration file section.
:param dict section_options:
N)r9 rJ )r> r@ namer r/ r! r! r"
parse_section s
zConfigHandler.parse_sectionc C sb | j D ]R\}}d}|r"d| }t| d| ddd}|dkrTtd| j|f || q
dS )zTParses configuration file items from one
or more related sections.
r7 z_%szparse_section%sr8 __Nz0Unsupported distribution option section: [%s.%s])r= r9 r' r; r r. )r> r? r@ Zmethod_postfixZsection_parser_methodr! r! r" r s" zConfigHandler.parsec s t fdd}|S )z this function will wrap around parameters that are deprecated
:param msg: deprecation message
:param warning_class: class of warning exception to be raised
:param func: function to be wrapped around
c s t | |S rl )warningswarn)argskwargsfuncmsg
warning_classr! r" config_handler s z@ConfigHandler._deprecated_config_handler..config_handlerr )r> r r r r r! r r" _deprecated_config_handler s z(ConfigHandler._deprecated_config_handler)F)rQ )N)N)rE
__module__ __qualname____doc__r. rH rA propertyrF rP classmethodr\ rc rg rk ru staticmethodro rp r r r r r r r! r! r! r" r6 ~ s<
&
,
r6 c sH e Zd ZdZdddddZdZd fd d
Zed d Zd
d Z Z
S )r1 r2 Zurl description classifiers platforms)Z home_pageZsummaryZ
classifierplatformFNc s t t| ||| || _d S rl )superr1 rA r3 )r> r( r4 r r3 rD r! r" rA s z ConfigMetadataHandler.__init__c C sL | j }| j}| j}| j}|||| |dt|| |||d||| j|d S )rB z[The requires parameter is deprecated, please use install_requires for runtime dependencies.license) r keywordsZprovidesZrequiresZ obsoletesr r r Zlong_descriptionversionZ project_urls)r\ ru rc rk r DeprecationWarningr _parse_version)r>
parse_listZ
parse_file
parse_dictZexclude_files_parserr! r! r" rF s(
z ConfigMetadataHandler.parsersc C s | |}||krB| }tt|tr>d}t|jf t |S | || j }t
|r^| }t|t st |drd
tt|}nd| }|S )zSParses `version` option value.
:param value:
:rtype: str
zCVersion loaded from {value} does not comply with PEP 440: {version}__iter__r8 z%s)ru r< rV r r r r$ r% r r3 callabler hasattrrs mapstr)r> r/ r Ztmplr! r! r" r s
z$ConfigMetadataHandler._parse_version)FN) rE r r r. rH Z strict_moderA r rF r
__classcell__r! r! r r" r1 s
r1 c @ s\ e Zd ZdZedd Zdd Zdd Zdd Zd
d Z d d
Z
dd Z dd Z dd Z
dS )r0 r4 c C sN | j }t| j dd}| j}| j}||||||||||||||| j| j|tdS )rB ;r[ )Zzip_safeZuse_2to3Zinclude_package_datar3 Zuse_2to3_fixersZuse_2to3_exclude_fixersZconvert_2to3_doctestsZscriptsZeager_resourcesZdependency_linksZnamespace_packagesZinstall_requiresZsetup_requiresZ
tests_requireZpackages entry_pointsZ
py_modulesZpython_requires)r\ r rg rc _parse_packagesru r
)r> r Zparse_list_semicolonZ
parse_boolr r! r! r" rF s. z ConfigOptionsHandler.parsersc C sz ddg}| }||kr"| |S ||d k}|r>ts>td| | jdi }|rdddlm} n ddlm } |f |S ) zTParses `packages` option value.
:param value:
:rtype: list
zfind:zfind_namespace:r| z8find_namespace: directive is unsupported on Python < 3.3z
packages.findr )find_namespace_packages)
find_packages)
r< r\ r r parse_section_packages__findr= rI Z
setuptoolsr r )r> r/ Zfind_directivesZ
trimmed_valueZfindns find_kwargsr r! r! r" r 1 s
z$ConfigOptionsHandler._parse_packagesc sT | || j}dddg t fdd| D }|d}|dk rP|d |d< |S )zParses `packages.find` configuration file section.
To be used in conjunction with _parse_packages().
:param dict section_options:
whereZincludeexcludec s$ g | ] \}}| kr|r||fqS r! r! rS kvZ
valid_keysr! r" rU Z s zEConfigOptionsHandler.parse_section_packages__find..Nr )r r\ r, r9 rI )r> r@ Z section_datar r r! r r" r M s
z1ConfigOptionsHandler.parse_section_packages__findc C s | || j}|| d< dS )z`Parses `entry_points` configuration file section.
:param dict section_options:
r N)r r\ r> r@ r r! r! r" parse_section_entry_pointsb s z/ConfigOptionsHandler.parse_section_entry_pointsc C s. | || j}|d}|r*||d< |d= |S )N*r7 )r r\ rI )r> r@ r rootr! r! r" _parse_package_dataj s
z(ConfigOptionsHandler._parse_package_datac C s | || d< dS )z`Parses `package_data` configuration file section.
:param dict section_options:
Z package_dataNr r> r@ r! r! r" parse_section_package_datat s z/ConfigOptionsHandler.parse_section_package_datac C s | || d< dS )zhParses `exclude_package_data` configuration file section.
:param dict section_options:
Zexclude_package_dataNr r r! r! r" "parse_section_exclude_package_data{ s z7ConfigOptionsHandler.parse_section_exclude_package_datac C s" t | jdd}| ||| d< dS )zbParses `extras_require` configuration file section.
:param dict section_options:
r r Zextras_requireN)r r\ r )r> r@ r r! r! r" parse_section_extras_require s
z1ConfigOptionsHandler.parse_section_extras_requirec C s( | || j}dd | D | d< dS )z^Parses `data_files` configuration file section.
:param dict section_options:
c S s g | ]\}}||fqS r! r! r r! r! r" rU s zAConfigOptionsHandler.parse_section_data_files..Z
data_filesN)r r\ r9 r r! r! r" parse_section_data_files s z-ConfigOptionsHandler.parse_section_data_filesN)rE r r r. r rF r r r r r r r r r! r! r! r" r0 s
r0 )FF)F)"Z
__future__r r rw r r r r& collectionsr r r importlibr Zdistutils.errorsr r
Z#setuptools.extern.packaging.versionr r Z&setuptools.extern.packaging.specifiersr
Zsetuptools.extern.sixr r typeZ
__metaclass__r# r+ r r r6 r1 r0 r! r! r! r" s4
/
?UPK ! K&~ __pycache__/wheel.cpython-38.pycnu [ U
Qab @ s d Z ddlmZ ddlZddlZddlZddlZddlZddlZddl Z ddl
Z
ddl m Z ddl m
Z
ddlmZ ddl
mZ ddlmZ eZed ejjZd
Zd d ZG d
d dZdS )zWheels support. ) get_platformN)
parse_version)canonicalize_name)PY3)
pep425tags)write_requirementsz^(?P.+?)-(?P\d.*?)
((-(?P\d.*?))?-(?P.+?)-(?P.+?)-(?P.+?)
)\.whl$ztry:
__import__('pkg_resources').declare_namespace(__name__)
except ImportError:
__path__ = __import__('pkgutil').extend_path(__path__, __name__)
c C s t | D ]\}}}t j|| }|D ].}t j||}t j|||}t || q&ttt|D ]D\} }
t j||
}t j|||
}t j |sft || || = qfq
t j| ddD ] \}}}|rt
t | qdS )zDMove everything under `src_dir` to `dst_dir`, and delete the former.T)topdownN) oswalkpathrelpathjoinrenamesreversedlist enumerateexistsAssertionErrorrmdir) Zsrc_dirZdst_dirdirpathZdirnames filenamessubdirfsrcZdstnd r 4/usr/lib/python3.8/site-packages/setuptools/wheel.pyunpack% s
r c @ sh e Zd Zdd Zdd Zdd Zdd Zd d
Zd d Zd
d Z e
dd Z e
dd Z e
dd Z
dS )Wheelc C sP t tj|}|d kr$td| || _| D ]\}}t| || q6d S )Nzinvalid wheel name: %r)
WHEEL_NAMEr r basename
ValueErrorfilename groupdictitemssetattr)selfr# matchkvr r r __init__= s zWheel.__init__c C s& t | jd| jd| jdS )z>List tags (py_version, abi, platform) supported by this wheel..) itertoolsproductZ
py_versionsplitZabiplatformr' r r r tagsE s
z
Wheel.tagsc s$ t t fdd| D dS )z5Is the wheel is compatible with the current platform?c 3 s | ]}| krd V qdS )TNr ).0tZsupported_tagsr r P s z&Wheel.is_compatible..F)r Z
get_supportednextr2 r1 r r5 r
is_compatibleM s zWheel.is_compatiblec C s, t j| j| j| jdkrd nt d d S )Nany) project_nameversionr0 z.egg)
pkg_resources Distributionr: r; r0 r egg_namer1 r r r r> R s zWheel.egg_namec C sJ | D ]4}t|}|drt|t| jr| S qtdd S )Nz
.dist-infoz.unsupported wheel format. .dist-info not found)Znamelist posixpathdirnameendswithr
startswithr: r" )r' zfmemberr@ r r r
get_dist_infoX s
zWheel.get_dist_infoc C s( t | j}| || W 5 Q R X dS )z"Install wheel as an egg directory.N)zipfileZZipFiler# _install_as_egg)r' destination_eggdirrC r r r install_as_eggb s zWheel.install_as_eggc C s\ d| j | jf }| |}d| }tj|d}| |||| | || | || d S )Nz%s-%sz%s.dataEGG-INFO) r: r; rE r r r
_convert_metadata_move_data_entries_fix_namespace_packages)r' rH rC Z
dist_basename dist_info dist_dataegg_infor r r rG g s
zWheel._install_as_eggc
s& fdd}|d}t |d}t d| ko>t dk n }|sTtd| t| | tj|tj j
|t |d d d
t t
t fd d jD }t| ttj|d
tj|d tj t|dd} t| dd tj|d d S )Nc
sT t | 8}tr&| dn| }tj |W 5 Q R S Q R X d S )Nzutf-8)
openr? r
r readdecodeemailparserZParserZparsestr)namefpvalue)rN rC r r get_metadatas s z-Wheel._convert_metadata..get_metadataZWHEELz
Wheel-Versionz1.0z2.0dev0z$unsupported wheel format version: %s)Zmetadatac S s d | _ t| S N)Zmarkerstr)reqr r r raw_req s z(Wheel._convert_metadata..raw_reqc
s2 i | ]*}|t fd dt |fD qS )c 3 s | ]}| kr|V qd S rZ r )r3 r\ )install_requiresr r r6 s z5Wheel._convert_metadata...)sortedmaprequires)r3 Zextra)distr^ r] r r
s
z+Wheel._convert_metadata..ZMETADATAzPKG-INFO)r^ extras_require)ZattrsrP z requires.txt)r getr" r mkdirZ
extractallr r
r< r= Z
from_locationZ PathMetadatar r_ r` ra Zextrasrename
setuptoolsdictr Zget_command_obj)
rC rH rN rP rY Zwheel_metadataZ
wheel_versionZwheel_v1rd Z
setup_distr )rb rN r^ r] rC r rK q sL
zWheel._convert_metadatac s t j| t j d}t j|rt j| dd}t | t |D ]D}|drpt t j|| qLt t j||t j|| qLt | t
t jj fdddD D ]}t || qt j rt dS )z,Move data entries to their correct location.ZscriptsrJ z.pycc 3 s | ]}t j |V qd S rZ )r r r
)r3 r rO r r r6 s z+Wheel._move_data_entries..)dataZheadersZpurelibZplatlibN) r r r
r rf listdirrA unlinkrg r filterr )rH rO Zdist_data_scriptsZegg_info_scriptsentryr r rj r rL s.
zWheel._move_data_entriesc
C s t j| d}t j|rt|}| }W 5 Q R X |D ]b}t jj|f|d }t j|d}t j|r>t j|s>t|d}|t W 5 Q R X q>d S )Nznamespace_packages.txtr, z __init__.pyw) r r r
r rQ rR r/ writeNAMESPACE_PACKAGE_INIT)rP rH Znamespace_packagesrW modZmod_dirZmod_initr r r rM s
z Wheel._fix_namespace_packagesN)__name__
__module__ __qualname__r+ r2 r8 r> rE rI rG staticmethodrK rL rM r r r r r ; s
9
r ) __doc__Zdistutils.utilr rT r- r r? rerF r< rh r Z!setuptools.extern.packaging.utilsr Zsetuptools.extern.sixr r Zsetuptools.command.egg_infor typeZ
__metaclass__compileVERBOSEr( r rr r r r r r r s, PK ! [g` ` " __pycache__/depends.cpython-38.pycnu [ U
Qab @ s d dl Z d dlZd dlZd dlmZ ddlmZ ddlmZm Z m
Z
m Z ddl mZ ddd d
gZ
G d d dZd d
Zddd Zddd
Zdd Ze dS ) N)
StrictVersion )Bytecode) find_module PY_COMPILED PY_FROZEN PY_SOURCE)
py27compatRequirer get_module_constantextract_constantc @ sH e Zd ZdZdddZdd Zdd Zdd d Zdd
dZdddZ dS )r
z7A prerequisite to building or installing a distribution Nc C sF |d kr|d k rt }|d k r0||}|d kr0d}| jt | `d S )N __version__)r __dict__updatelocalsself)r namerequested_versionmoduleZhomepage attributeformat r 6/usr/lib/python3.8/site-packages/setuptools/depends.py__init__ s zRequire.__init__c C s | j dk rd| j| j f S | jS )z0Return full package/distribution name, w/versionNz%s-%s)r r )r r r r full_name# s
zRequire.full_namec C s* | j dkp(| jdkp(t|dko(|| jkS )z%Is 'version' sufficiently up-to-date?Nunknown)r r strr )r versionr r r
version_ok) s zRequire.version_okr c C s | j dkrFz$t| j|\}}}|r*| |W S tk
rD Y dS X t| j| j ||}|dk r|||k r|| jdk r|| |S |S )a Get version number of installed module, 'None', or 'default'
Search 'paths' for module. If not found, return 'None'. If found,
return the extracted version attribute, or 'default' if no version
attribute was specified, or the value cannot be determined without
importing the module. The version is formatted according to the
requirement's version format (if any), unless it is 'None' or the
supplied 'default'.
N)r r r close ImportErrorr r )r pathsdefaultfpivr r r get_version. s
zRequire.get_versionc C s | |dk S )z/Return true if dependency is present on 'paths'N)r( )r r" r r r
is_presentI s zRequire.is_presentc C s | |}|dkrdS | |S )z>Return true if dependency is present and up-to-date on 'paths'NF)r( r )r r" r r r r
is_currentM s
zRequire.is_current)r
NN)Nr )N)N)
__name__
__module__ __qualname____doc__r r r r( r) r* r r r r r
s
c C s" t jdd }| s| S t | S )Nc s s
d V d S )Nr r r r r emptyV s zmaybe_close..empty)
contextlibcontextmanagerclosing)r$ r/ r r r maybe_closeU s
r3 c
C s z t | | \}}\}}}} W n tk
r4 Y dS X t|z |tkr^|d t|}
nV|tkrtt | |}
n@|t
krt | |d}
n&t | || } t
| |dW 5 Q R S W 5 Q R X t|
||S )zFind 'module' by searching 'paths', and extract 'symbol'
Return 'None' if 'module' does not exist on 'paths', or it does not define
'symbol'. If the module defines 'symbol' as a constant, return the
constant. Otherwise, return 'default'.N exec)r r! r3 r readmarshalloadr r get_frozen_objectr compileZ
get_modulegetattrr ) r symbolr# r" r$ pathsuffixmodeZkindinfocodeZimportedr r r r ` s
"c C s || j krdS t| j |}d}d}d}|}t| D ]H}|j} |j}
| |krZ| j|
}q6|
|krz| |ksr| |krz| S |}q6dS )a Extract the constant value of 'symbol' from 'code'
If the name 'symbol' is bound to a constant value by the Python code
object 'code', return that value. If 'symbol' is bound to an expression,
return 'default'. Otherwise, return 'None'.
Return value is based on the first assignment to 'symbol'. 'symbol' must
be a global, or at least a non-"fast" local in the code block. That is,
only 'STORE_NAME' and 'STORE_GLOBAL' opcodes are checked, and 'symbol'
must be present in 'code.co_names'.
NZ a d )co_nameslistindexr Zopcodearg co_consts) rB r= r# Zname_idxZ
STORE_NAMEZ STORE_GLOBALZ
LOAD_CONSTconstZ byte_codeoprI r r r r } s
c C s> t jdst jdkrdS d} | D ]}t |= t| q"dS )z
Patch the globals to remove the objects not available on some platforms.
XXX it'd be better to test assertions about bytecode instead.
javaZcliN)r r )sysplatform
startswithglobals__all__remove)Z incompatibler r r r _update_globals s rT )r4 N)r4 )rN r8 r0 Zdistutils.versionr Z
py33compatr r r r r r r
rR r
r3 r r rT r r r r s" D
$PK ! $ $ ' __pycache__/monkey.cpython-38.opt-1.pycnu [ U
Qab @ s d Z ddlZddlZddlZddlZddlZddlmZ ddl Z ddl
m Z ddl Z g Z
dd Zdd Zd d
Zd d Zd
d Zdd Zdd Zdd ZdS )z
Monkey patching of distutils.
N)
import_module)sixc C s" t dkr| f| j S t| S )am
Returns the bases classes for cls sorted by the MRO.
Works around an issue on Jython where inspect.getmro will not return all
base classes if multiple classes share the same name. Instead, this
function will return a tuple containing the class itself, and the contents
of cls.__bases__. See https://github.com/pypa/setuptools/issues/1024.
ZJython)platformZpython_implementation __bases__inspectZgetmro)cls r 5/usr/lib/python3.8/site-packages/setuptools/monkey.py_get_mro s r
c C s0 t | tjrtnt | tjr tndd }|| S )Nc S s d S )Nr )itemr r r * z get_unpatched..)
isinstancer Z class_typesget_unpatched_classtypes FunctionTypeget_unpatched_function)r lookupr r r
get_unpatched& s
r c C s: dd t | D }t|}|jds6d| }t||S )zProtect against re-patching the distutils if reloaded
Also ensures that no other distutils extension monkeypatched the distutils
first.
c s s | ]}|j d s|V qdS )
setuptoolsN)
__module__
startswith).0r r r r 5 s z&get_unpatched_class.. distutilsz(distutils has already been patched by %r)r
nextr r AssertionError)r Zexternal_basesbasemsgr r r r / s r c C s t jtj_tjdk} | r"t jtj_tjdk p^dtj k o@dk n p^dtj k oZdkn }|rrd}|tjj _
t tj tjtj
fD ]}t j j|_qt jjtj_t jjtj_dtjkrt jjtjd _t d S )N) r )
)r )r r$ )r r z https://upload.pypi.org/legacy/zdistutils.command.build_ext)r ZCommandr Zcoresys version_infofindallZfilelistZconfigZ
PyPIRCCommandZDEFAULT_REPOSITORY _patch_distribution_metadatadistcmdZ Distribution extensionZ Extensionmodules#patch_for_msvc_specialized_compiler)Zhas_issue_12885Zneeds_warehouseZ warehousemoduler r r patch_allA s*
r0 c C s* dD ] } t tj| }ttjj| | qdS )zDPatch write_pkg_file and read_pkg_file for higher metadata standards)Zwrite_pkg_fileZ
read_pkg_fileZget_metadata_versionN)getattrr r* setattrr ZDistributionMetadata)attrZnew_valr r r r) h s r) c C s* t ||}t| d| t||| dS )z
Patch func_name in target_mod with replacement
Important - original must be resolved by name to avoid
patching an already patched function.
unpatchedN)r1 vars
setdefaultr2 )Z replacementZ
target_mod func_nameoriginalr r r
patch_funco s
r9 c C s
t | dS )Nr4 )r1 ) candidater r r r s r c s t d t dkrdS fdd} t| d}t| d}z t|d t|d W n tk
rl Y nX zt|d
W n tk
r Y nX zt|d W n tk
r Y nX dS ) z\
Patch functions in distutils to use standalone Microsoft Visual C++
compilers.
zsetuptools.msvcZWindowsNc sL d| kr dnd}|| d }t |}t| }t||sBt||||fS )zT
Prepare the parameters for patch_func to patch indicated function.
msvc9Zmsvc9_Zmsvc14__)lstripr1 r hasattr ImportError)Zmod_namer7 Z repl_prefixZ repl_namereplmodZmsvcr r patch_params s
z9patch_for_msvc_specialized_compiler..patch_paramszdistutils.msvc9compilerzdistutils._msvccompilerZfind_vcvarsallZquery_vcvarsallZ _get_vc_envZgen_lib_options)r r system functoolspartialr9 r? )rC r; Zmsvc14r rB r r. s&
r. )__doc__r& Zdistutils.filelistr r r rE importlibr r Zsetuptools.externr r __all__r
r r r0 r) r9 r r. r r r r s$ 'PK ! վ + __pycache__/site-patch.cpython-38.opt-1.pycnu [ U
Qab @ s d d Z edkre [ dS )c C s
dd l } dd l}|jd}|d ks2| jdkr8|s8g }n ||j}t| di }| jt |d }|j
t }|D ]}||ksr|sqr||}|d k r| d}|d k r|
d q.qrz dd l} | d|g\}
} } W n tk
r Y qrY nX |
d krqrz|
d|
| | W 5 |
X q.qrtdtdd | jD }
t| d d}d| _|D ]}t| qX| j|7 _t|d \}}d }g }| jD ]b}t|\}}||kr|d krt |}||
ks|d kr|| n||| |d
7 }q|| jd d < d S ) N
PYTHONPATHZwin32path_importer_cachesitez$Couldn't find the real 'site' modulec S s g | ]}t |d d fqS ) )makepath).0item r 9/usr/lib/python3.8/site-packages/setuptools/site-patch.py
) s z__boot.. __egginsertr )sysosenvirongetplatformsplitpathsepgetattrpathlendirname__file__ find_module load_moduleimp ImportErrorclosedictr
addsitedirr appendinsert)r
r r ZpicZstdpathZmydirr Zimporterloaderr streamr Zdescr known_pathsZoldposdZndZ insert_atnew_pathpZnpr r r
__boot s`
r( r N)r( __name__r r r r
s GPK ! A8 8 ' __pycache__/launch.cpython-38.opt-1.pycnu [ U
Qab @ s. d Z ddlZddlZdd Zedkr*e dS )z[
Launch the Python script on the command line after
setuptools is bootstrapped via import.
Nc C sr t tjd } t| ddd}tjdd tjdd< ttdt}|| }|dd}t || d}t
|| dS ) zP
Run the script in sys.argv[1] as if it had
been invoked naturally.
__main__N)__file____name____doc__openz\r\nz\nexec) __builtins__sysargvdictgetattrtokenizer readreplacecompiler )Z script_name namespaceZopen_ZscriptZ norm_scriptcode r 5/usr/lib/python3.8/site-packages/setuptools/launch.pyrun
s
r r )r r r
r r r r r r s
PK ! ئ 0 __pycache__/windows_support.cpython-38.opt-1.pycnu [ U
Qab @ s( d dl Z d dlZdd Zedd ZdS ) Nc C s t dkrdd S | S )NZWindowsc _ s d S )N )argskwargsr r >/usr/lib/python3.8/site-packages/setuptools/windows_support.py z windows_only..)platformsystem)funcr r r windows_only s r c C sL t d tjjj}tjjtjjf|_tjj |_
d}|| |}|sHt dS )z
Set the hidden attribute on a file or directory.
From http://stackoverflow.com/questions/19622133/
`path` must be text.
zctypes.wintypes N)
__import__ctypesZwindllZkernel32ZSetFileAttributesWZwintypesZLPWSTRZDWORDZargtypesZBOOLZrestypeZWinError)pathZSetFileAttributesFILE_ATTRIBUTE_HIDDENretr r r hide_file s
r )r r r r r r r r s PK ! Ϛ Ϛ __pycache__/msvc.cpython-38.pycnu [ U
Qab @ sX d Z ddlZddlmZ ddlmZmZ ddlmZm Z m
Z
m Z ddl Z ddl
Z
ddlZddlZddlmZ ddlmZ dd lmZ e
d
krdd lmZ dd lmZ nG d
d dZe Zeej j fZ zddl m Z W n e k
r Y nX dd Z!d$ddZ"dd Z#dd Z$d%ddZ%G d d d Z&G d d d Z'G d d! d!Z(G d"d# d#Z)dS )&a
Improved support for Microsoft Visual C++ compilers.
Known supported compilers:
--------------------------
Microsoft Visual C++ 9.0:
Microsoft Visual C++ Compiler for Python 2.7 (x86, amd64)
Microsoft Windows SDK 6.1 (x86, x64, ia64)
Microsoft Windows SDK 7.0 (x86, x64, ia64)
Microsoft Visual C++ 10.0:
Microsoft Windows SDK 7.1 (x86, x64, ia64)
Microsoft Visual C++ 14.X:
Microsoft Visual C++ Build Tools 2015 (x86, x64, arm)
Microsoft Visual Studio Build Tools 2017 (x86, x64, arm, arm64)
Microsoft Visual Studio Build Tools 2019 (x86, x64, arm, arm64)
This may also support compilers shipped with compatible Visual Studio versions.
N)open)listdirpathsep)joinisfileisdirdirname)
LegacyVersion) filterfalse )
get_unpatchedWindows)winreg)environc @ s e Zd ZdZdZdZdZdS )r N)__name__
__module__ __qualname__
HKEY_USERSHKEY_CURRENT_USERHKEY_LOCAL_MACHINEHKEY_CLASSES_ROOT r r 3/usr/lib/python3.8/site-packages/setuptools/msvc.pyr * s r )Regc C s d}|d| f }zt |d}W nJ tk
rj z |d| f }t |d}W n tk
rd d}Y nX Y nX |rt|d}t|r|S tt| S )a
Patched "distutils.msvc9compiler.find_vcvarsall" to use the standalone
compiler build for Python
(VCForPython / Microsoft Visual C++ Compiler for Python 2.7).
Fall back to original behavior when the standalone compiler is not
available.
Redirect the path of "vcvarsall.bat".
Parameters
----------
version: float
Required Microsoft Visual C++ version.
Return
------
str
vcvarsall.bat path
z-Software\%sMicrosoft\DevDiv\VCForPython\%0.1f
installdirz Wow6432Node\Nz
vcvarsall.bat)r Z get_valueKeyErrorr r r msvc9_find_vcvarsall)versionZvc_basekey
productdir vcvarsallr r r r A s
r x86c
O s z t t}|| |f||W S tjjk
r4 Y n tk
rF Y nX zt|| W S tjjk
r } zt|| | W 5 d}~X Y nX dS )ao
Patched "distutils.msvc9compiler.query_vcvarsall" for support extra
Microsoft Visual C++ 9.0 and 10.0 compilers.
Set environment without use of "vcvarsall.bat".
Parameters
----------
ver: float
Required Microsoft Visual C++ version.
arch: str
Target architecture.
Return
------
dict
environment
N) r msvc9_query_vcvarsall distutilserrorsDistutilsPlatformError
ValueErrorEnvironmentInfo
return_env_augment_exception)verarchargskwargsZorigexcr r r r# k s r# c
C sr zt t| W S tjjk
r& Y nX zt| dd W S tjjk
rl } zt|d W 5 d}~X Y nX dS )a*
Patched "distutils._msvccompiler._get_vc_env" for support extra
Microsoft Visual C++ 14.X compilers.
Set environment without use of "vcvarsall.bat".
Parameters
----------
plat_spec: str
Target architecture.
Return
------
dict
environment
,@)
vc_min_verN)r msvc14_get_vc_envr$ r% r& r( r) r* )Z plat_specr/ r r r r2 s
r2 c O sB dt jkr4ddl}t|jtdk r4|jjj| |S tt | |S )z
Patched "distutils._msvccompiler.gen_lib_options" for fix
compatibility between "numpy.distutils" and "distutils._msvccompiler"
(for Numpy < 1.11.2)
znumpy.distutilsr Nz1.11.2)
sysmodulesZnumpyr __version__r$ Z ccompilerZgen_lib_optionsr msvc14_gen_lib_options)r- r. Znpr r r r6 s
r6 r c C s | j d }d| ks"d| krd}|jf t }d}|dkrf| ddkr\|d 7 }q|d
7 }n.|d kr|d 7 }||d
7 }n|dkr|d7 }|f| _ dS )zl
Add details to the exception message to help guide the user
as to what action will resolve it.
r r! zvisual cz0Microsoft Visual C++ {version:0.1f} is required.z-www.microsoft.com/download/details.aspx?id=%d "@Zia64z( Get it with "Microsoft Windows SDK 7.0"z% Get it from http://aka.ms/vcpython27 $@z* Get it with "Microsoft Windows SDK 7.1": iW r0 z[ Get it with "Build Tools for Visual Studio": https://visualstudio.microsoft.com/downloads/N)r- lowerformatlocalsfind)r/ r r, messageZtmplZ
msdownloadr r r r* s
r* c @ sb e Zd ZdZedd Zdd Ze dd Z
dd Z d
d Z dd
dZ
dddZdddZdS ) PlatformInfoz
Current and Target Architectures information.
Parameters
----------
arch: str
Target architecture.
Zprocessor_architecturer c C s | dd| _d S )Nx64amd64)r: replacer, )selfr, r r r __init__ s zPlatformInfo.__init__c C s | j | j dd d S )zs
Return Target CPU architecture.
Return
------
str
Target CPU
_r N)r, r= rC r r r
target_cpu s
zPlatformInfo.target_cpuc C s
| j dkS )z
Return True if target CPU is x86 32 bits..
Return
------
bool
CPU is x86 32 bits
r" rG rF r r r
target_is_x86 s zPlatformInfo.target_is_x86c C s
| j dkS )z
Return True if current CPU is x86 32 bits..
Return
------
bool
CPU is x86 32 bits
r" current_cpurF r r r current_is_x86 s zPlatformInfo.current_is_x86Fc C s. | j dkr|rdS | j dkr$|r$dS d| j S )uk
Current platform specific subfolder.
Parameters
----------
hidex86: bool
return '' and not '' if architecture is x86.
x64: bool
return 'd' and not 'md64' if architecture is amd64.
Return
------
str
subfolder: ' arget', or '' (see hidex86 parameter)
r" r rA \x64\%srJ rC hidex86r@ r r r current_dir s zPlatformInfo.current_dirc C s. | j dkr|rdS | j dkr$|r$dS d| j S )ar
Target platform specific subfolder.
Parameters
----------
hidex86: bool
return '' and not '\x86' if architecture is x86.
x64: bool
return '\x64' and not '\amd64' if architecture is amd64.
Return
------
str
subfolder: '\current', or '' (see hidex86 parameter)
r" r rA rM rN rH rO r r r
target_dir( s zPlatformInfo.target_dirc C s0 |rdn| j }| j|kr dS | dd| S )ap
Cross platform specific subfolder.
Parameters
----------
forcex86: bool
Use 'x86' as current architecture even if current architecture is
not x86.
Return
------
str
subfolder: '' if target architecture is current architecture,
'\current_target' if not.
r" r \z\%s_)rK rG rR rB )rC forcex86Zcurrentr r r cross_dir> s zPlatformInfo.cross_dirN)FF)FF)F)r r r __doc__r getr: rK rD propertyrG rI rL rQ rR rU r r r r r? s
r? c @ s e Zd ZdZejejejejfZ dd Z
e dd Z e dd Z
e dd Ze d
d Ze d d
Ze dd Ze dd Ze dd Ze dd Zd ddZdd ZdS ) RegistryInfoz
Microsoft Visual Studio related registry information.
Parameters
----------
platform_info: PlatformInfo
"PlatformInfo" instance.
c C s
|| _ d S N)pi)rC Z
platform_infor r r rD c s zRegistryInfo.__init__c C s dS )z
Microsoft Visual Studio root registry key.
Return
------
str
Registry key
Z VisualStudior rF r r r visualstudiof s
zRegistryInfo.visualstudioc C s t | jdS )z
Microsoft Visual Studio SxS registry key.
Return
------
str
Registry key
ZSxS)r r\ rF r r r sxsr s
zRegistryInfo.sxsc C s t | jdS )z|
Microsoft Visual C++ VC7 registry key.
Return
------
str
Registry key
ZVC7r r] rF r r r vc~ s
zRegistryInfo.vcc C s t | jdS )z
Microsoft Visual Studio VS7 registry key.
Return
------
str
Registry key
ZVS7r^ rF r r r vs s
zRegistryInfo.vsc C s dS )z
Microsoft Visual C++ for Python registry key.
Return
------
str
Registry key
zDevDiv\VCForPythonr rF r r r
vc_for_python s
zRegistryInfo.vc_for_pythonc C s dS )zq
Microsoft SDK registry key.
Return
------
str
Registry key
zMicrosoft SDKsr rF r r r
microsoft_sdk s
zRegistryInfo.microsoft_sdkc C s t | jdS )z
Microsoft Windows/Platform SDK registry key.
Return
------
str
Registry key
r
r rb rF r r r windows_sdk s
zRegistryInfo.windows_sdkc C s t | jdS )z
Microsoft .NET Framework SDK registry key.
Return
------
str
Registry key
ZNETFXSDKrc rF r r r netfx_sdk s
zRegistryInfo.netfx_sdkc C s dS )z
Microsoft Windows Kits Roots registry key.
Return
------
str
Registry key
z Windows Kits\Installed Rootsr rF r r r windows_kits_roots s
z RegistryInfo.windows_kits_rootsFc C s$ | j s|rdnd}td|d|S )a
Return key in Microsoft software registry.
Parameters
----------
key: str
Registry key path where look.
x86: str
Force x86 software registry.
Return
------
str
Registry key
r Z Wow6432NodeZSoftwareZ Microsoft)r[ rL r )rC r r" Znode64r r r microsoft s zRegistryInfo.microsoftc
C s t j}t j}| j}| jD ]}z||||d|}W n` ttfk
r | j sz||||dd|}W q ttfk
r Y Y qY qX nY qY nX zt ||d W S ttfk
r Y qX qdS )a
Look for values in registry in Microsoft software registry.
Parameters
----------
key: str
Registry key path where look.
name: str
Value name to find.
Return
------
str
value
r TN)
r KEY_READOpenKeyrg HKEYSOSErrorIOErrorr[ rL Z QueryValueEx)rC r nameZkey_readZopenkeymshkeybkeyr r r lookup s"
zRegistryInfo.lookupN)F)r r r rV r r r r r rj rD rX r\ r] r_ r` ra rb rd re rf rg rq r r r r rY U s6
rY c @ s< e Zd ZdZeddZeddZedeZd7ddZ d d
Z
d d Z d
d Z e
dd Zedd Zedd Zdd Zdd Zedd Zedd Zed d Zed d Zed!d" Zed#d$ Zed%d& Zed'd( Zed)d* Z ed+d, Z ed-d. Z ed/d0 Z ed1d2 Z d3d4 Z!e
d8d5d6Z"dS )9
SystemInfoz
Microsoft Windows and Visual Studio related system information.
Parameters
----------
registry_info: RegistryInfo
"RegistryInfo" instance.
vc_ver: float
Required Microsoft Visual C++ version.
WinDirr ProgramFileszProgramFiles(x86)Nc C s2 || _ | j j| _| | _|p$| | _| _d S rZ )rir[ find_programdata_vs_versknown_vs_paths _find_latest_available_vs_vervs_vervc_ver)rC Z
registry_inforz r r r rD s
zSystemInfo.__init__c C s> | }|s | js tjdt|}|| j t|d S )zm
Find the latest VC version
Return
------
float
version
z%No Microsoft Visual C++ version foundr8 )find_reg_vs_versrw r$ r% r& setupdatesorted)rC Z reg_vc_versZvc_versr r r rx % s
z(SystemInfo._find_latest_available_vs_verc C s$ | j j}| j j| j j| j jf}g }| j jD ]}|D ]}zt|||dtj}W n t t
fk
rl Y q2Y nX t |\}}} t |D ]D}
z*t
t||
d } | |kr|| W q tk
r Y qX qt |D ]B}
z&t
t||
} | |kr|| W q tk
r Y qX qq2q*t|S )z
Find Microsoft Visual Studio versions available in registry.
Return
------
list of float
Versions
r )ru rg r_ ra r` rj r ri rh rk rl Z QueryInfoKeyrangefloatZ EnumValueappendr' ZEnumKeyr~ ) rC rn ZvckeysZvs_versro r rp ZsubkeysvaluesrE ir+ r r r r{ 8 s2
zSystemInfo.find_reg_vs_versc C s i }d}z t |}W n ttfk
r0 | Y S X |D ]}z\t||d}t|ddd}t|}W 5 Q R X |d }t t|d ||| |d < W q6 tttfk
r Y q6Y q6X q6|S ) z
Find Visual studio 2017+ versions from information in
"C:\ProgramData\Microsoft\VisualStudio\Packages\_Instances".
Return
------
dict
float version as key, path as value.
z9C:\ProgramData\Microsoft\VisualStudio\Packages\_Instancesz
state.jsonZrtzutf-8)encodingZinstallationPath
VC\Tools\MSVCZinstallationVersion) r rk rl r r jsonload_as_float_versionr ) rC Z vs_versionsZ
instances_dirZ hashed_namesrm Z
state_pathZ
state_filestateZvs_pathr r r rv [ s*
z#SystemInfo.find_programdata_vs_versc C s t d| ddd S )z
Return a string version as a simplified float version (major.minor)
Parameters
----------
version: str
Version.
Return
------
float
version
.N )r r split)r r r r r s z SystemInfo._as_float_versionc C s. t | jd| j }| j| jjd| j p,|S )zp
Microsoft Visual Studio directory.
Return
------
str
path
z Microsoft Visual Studio %0.1f%0.1f)r ProgramFilesx86ry ru rq r` )rC defaultr r r VSInstallDir s zSystemInfo.VSInstallDirc C s, | p| }t|s(d}tj||S )zm
Microsoft Visual C++ directory.
Return
------
str
path
z(Microsoft Visual C++ directory not found) _guess_vc_guess_vc_legacyr r$ r% r& )rC pathmsgr r r VCInstallDir s
zSystemInfo.VCInstallDirc
C s | j dkrdS z| j| j }W n tk
r8 | j}Y nX t|d}z$t|d }| || _t||W S tt t
fk
r Y dS X dS )zl
Locate Visual C++ for VS2017+.
Return
------
str
path
r0 r r r8 N) ry rw r r r r r rz rk rl
IndexError)rC Zvs_dirZguess_vcrz r r r r s
zSystemInfo._guess_vcc C sb t | jd| j }t | jjd| j }| j|d}|rBt |dn|}| j| jjd| j p`|S )z{
Locate Visual C++ for versions prior to 2017.
Return
------
str
path
z Microsoft Visual Studio %0.1f\VCr r ZVC)r r ry ru ra rq r_ )rC r Zreg_pathZ python_vcZ
default_vcr r r r s zSystemInfo._guess_vc_legacyc C sJ | j dkrdS | j dkr dS | j dkr*dS | j dkr8dS | j d krFd
S d S ) z
Microsoft Windows SDK versions for specified MSVC++ version.
Return
------
tuple of str
versions
r7 )z7.0z6.1z6.0ar9 )z7.1z7.0a &@)z8.0z8.0a (@)8.1z8.1ar0 )z10.0r Nry rF r r r WindowsSdkVersion s
z SystemInfo.WindowsSdkVersionc C s | t| jdS )zt
Microsoft Windows SDK last version.
Return
------
str
version
lib)_use_last_dir_namer
WindowsSdkDirrF r r r WindowsSdkLastVersion s
z SystemInfo.WindowsSdkLastVersionc C s d}| j D ],}t| jjd| }| j|d}|r
q8q
|rDt|stt| jjd| j }| j|d}|rtt|d}|rt|s| j D ]6}|d|d }d | }t| j |}t|r|}q|rt|s| j D ]$}d
| }t| j |}t|r|}q|st| j
d }|S ) zn
Microsoft Windows SDK directory.
Return
------
str
path
r zv%sinstallationfolderr r ZWinSDKNr z Microsoft SDKs\Windows Kits\%szMicrosoft SDKs\Windows\v%sZ PlatformSDK) r r ru rd rq r ra rz rfindrt r )rC sdkdirr+ locr Z install_baseZintverdr r r r s6
zSystemInfo.WindowsSdkDirc C s | j dkrd}d}n&d}| j dkr&dnd}| jjd|d}d ||d
d f }g }| j d kr~| jD ]}|t| jj||g7 }qb| jD ] }|t| jj d
| |g7 }q|D ] }| j
|d}|r| S qdS )zy
Microsoft Windows SDK executable directory.
Return
------
str
path
r # r ( r TF)r@ rP zWinSDK-NetFx%dTools%srS -r0 zv%sAr N) ry r[ rQ rB NetFxSdkVersionr ru re r rd rq ) rC Znetfxverr, rP ZfxZregpathsr+ r Zexecpathr r r WindowsSDKExecutablePath7 s"
z#SystemInfo.WindowsSDKExecutablePathc C s& t | jjd| j }| j|dp$dS )zl
Microsoft Visual F# directory.
Return
------
str
path
z%0.1f\Setup\F#r r )r ru r\ ry rq )rC r r r r FSharpInstallDirZ s
zSystemInfo.FSharpInstallDirc C sF | j dkrdnd}|D ]*}| j| jjd| }|r|p:d S qdS )zt
Microsoft Universal CRT SDK directory.
Return
------
str
path
r0 )Z10Z81r z
kitsroot%sr N)ry ru rq rf )rC Zversr+ r r r r UniversalCRTSdkDirg s z SystemInfo.UniversalCRTSdkDirc C s | t| jdS )z
Microsoft Universal C Runtime SDK last version.
Return
------
str
version
r )r r r rF r r r UniversalCRTSdkLastVersion{ s
z%SystemInfo.UniversalCRTSdkLastVersionc C s | j dkrdS dS )z
Microsoft .NET Framework SDK versions.
Return
------
tuple of str
versions
r0 ) z4.7.2z4.7.1z4.7z4.6.2z4.6.1z4.6z4.5.2z4.5.1z4.5r r rF r r r r s zSystemInfo.NetFxSdkVersionc C s8 d}| j D ](}t| jj|}| j|d}|r
q4q
|S )zu
Microsoft .NET Framework SDK directory.
Return
------
str
path
r Zkitsinstallationfolder)r r ru re rq )rC r r+ r r r r NetFxSdkDir s
zSystemInfo.NetFxSdkDirc C s" t | jd}| j| jjdp |S )zw
Microsoft .NET Framework 32bit directory.
Return
------
str
path
zMicrosoft.NET\FrameworkZframeworkdir32r rs ru rq r_ rC Zguess_fwr r r FrameworkDir32 s zSystemInfo.FrameworkDir32c C s" t | jd}| j| jjdp |S )zw
Microsoft .NET Framework 64bit directory.
Return
------
str
path
zMicrosoft.NET\Framework64Zframeworkdir64r r r r r FrameworkDir64 s zSystemInfo.FrameworkDir64c C s
| dS )z
Microsoft .NET Framework 32bit versions.
Return
------
tuple of str
versions
_find_dot_net_versionsrF r r r FrameworkVersion32 s
z SystemInfo.FrameworkVersion32c C s
| dS )z
Microsoft .NET Framework 64bit versions.
Return
------
tuple of str
versions
@ r rF r r r FrameworkVersion64 s
z SystemInfo.FrameworkVersion64c C s | j | j jd| }t| d| }|p6| |dp6d}| jdkrJ|dfS | jdkrt| dd d
krld n|d fS | jd
krdS | jdkrdS dS )z
Find Microsoft .NET Framework versions.
Parameters
----------
bits: int
Platform number of bits: 32 or 64.
Return
------
tuple of str
versions
zframeworkver%dzFrameworkDir%dvr r zv4.0r9 Nr Zv4z
v4.0.30319v3.5r7 )r
v2.0.50727g @)zv3.0r )ru rq r_ getattrr ry r: )rC bitsZreg_verZ dot_net_dirr+ r r r r s
z!SystemInfo._find_dot_net_versionsc s* fddt t D }t|dp(dS )a)
Return name of the last dir in path or '' if no dir found.
Parameters
----------
path: str
Use dirs in this path
prefix: str
Use only dirs starting by this prefix
Return
------
str
name
c 3 s* | ]"}t t |r|r|V qd S rZ )r r
startswith).0Zdir_namer prefixr r s
z0SystemInfo._use_last_dir_name..Nr )reversedr next)r r Z
matching_dirsr r r r s
z SystemInfo._use_last_dir_name)N)r )#r r r rV r rW rs rt r rD rx r{ rv staticmethodr rX r r r r r r r r r r r r r r r r r r r r r r r rr sZ
#*
*
"
rr c @ sb e Zd ZdZd?ddZedd Zedd Zed
d Zed d
Z edd Z
edd Z edd Z edd Z
edd Zedd Zedd Zd d Zed d Zed d! Zed"d# Zed$d% Zed&d' Zed(d) Zed*d+ Zed,d- Zed.d/ Zed0d1 Zed2d3 Z ed4d5 Z ed6d7 Z d@d9d:Z d;d< Z e!dAd=d>Z"dS )Br( aY
Return environment variables for specified Microsoft Visual C++ version
and platform : Lib, Include, Path and libpath.
This function is compatible with Microsoft Visual C++ 9.0 to 14.X.
Script created by analysing Microsoft environment configuration files like
"vcvars[...].bat", "SetEnv.Cmd", "vcbuildtools.bat", ...
Parameters
----------
arch: str
Target architecture.
vc_ver: float
Required Microsoft Visual C++ version. If not set, autodetect the last
version.
vc_min_ver: float
Minimum Microsoft Visual C++ version.
Nr c C sB t || _t| j| _t| j|| _| j|k r>d}tj |d S )Nz.No suitable Microsoft Visual C++ version found)
r? r[ rY ru rr sirz r$ r% r& )rC r, rz r1 errr r r rD 0 s
zEnvironmentInfo.__init__c C s | j jS )zk
Microsoft Visual Studio.
Return
------
float
version
)r ry rF r r r ry 9 s
zEnvironmentInfo.vs_verc C s | j jS )zp
Microsoft Visual C++ version.
Return
------
float
version
)r rz rF r r r rz E s
zEnvironmentInfo.vc_verc sV ddg} j dkrD jjddd}|dg7 }|dg7 }|d| g7 } fd d
|D S ) zu
Microsoft Visual Studio Tools.
Return
------
list of str
paths
z Common7\IDEz
Common7\Toolsr0 TrP r@ z1Common7\IDE\CommonExtensions\Microsoft\TestWindowz Team Tools\Performance Toolsz Team Tools\Performance Tools%sc s g | ]}t jj|qS r r r r r r rF r r
c s z+EnvironmentInfo.VSTools..)ry r[ rQ )rC paths arch_subdirr rF r VSToolsQ s
zEnvironmentInfo.VSToolsc C s t | jjdt | jjdgS )z
Microsoft Visual C++ & Microsoft Foundation Class Includes.
Return
------
list of str
paths
ZIncludezATLMFC\Includer r r rF r r r
VCIncludese s
zEnvironmentInfo.VCIncludesc sb j dkr jjdd}n jjdd}d| d| g} j dkrP|d| g7 } fd d
|D S ) z
Microsoft Visual C++ & Microsoft Foundation Class Libraries.
Return
------
list of str
paths
.@Tr@ rP Lib%sz ATLMFC\Lib%sr0 z Lib\store%sc s g | ]}t jj|qS r r r rF r r r s z/EnvironmentInfo.VCLibraries..)ry r[ rR )rC r r r rF r VCLibrariesr s
zEnvironmentInfo.VCLibrariesc C s | j dk rg S t| jjdgS )z
Microsoft Visual C++ store references Libraries.
Return
------
list of str
paths
r0 zLib\store\references)ry r r r rF r r r VCStoreRefs s
zEnvironmentInfo.VCStoreRefsc C s | j }t|jdg}| jdkr"dnd}| j|}|rL|t|jd| g7 }| jdkr|d| jjdd }|t|j|g7 }n| jdkr| j rd nd
}|t|j|| jjdd g7 }| jj | jj
kr|t|j|| jjdd g7 }n|t|jd g7 }|S )
zr
Microsoft Visual C++ Tools.
Return
------
list of str
paths
Z
VCPackagesr9 TFBin%sr0 r r z
bin\HostX86%sz
bin\HostX64%sr Bin) r r r ry r[ rU rQ rL rR rK rG )rC r toolsrT r r Zhost_dirr r r VCTools s0
zEnvironmentInfo.VCToolsc C sh | j dkr.| jjddd}t| jjd| gS | jjdd}t| jjd}| j}t|d||f gS dS ) zw
Microsoft Windows SDK Libraries.
Return
------
list of str
paths
r9 Tr r r r z%sum%sN)ry r[ rR r r r _sdk_subdir)rC r r Zlibverr r r OSLibraries s
zEnvironmentInfo.OSLibrariesc C sh t | jjd}| jdkr&|t |dgS | jdkr8| j}nd}t |d| t |d| t |d| gS d S )
zu
Microsoft Windows SDK Include.
Return
------
list of str
paths
includer9 Zglr0 r z%ssharedz%sumz%swinrtN)r r r ry r )rC r sdkverr r r
OSIncludes s
zEnvironmentInfo.OSIncludesc C s t | jjd}g }| jdkr&|| j7 }| jdkr@|t |dg7 }| jdkr||t | jjdt |ddt |d dt |d
dt | jjd d d
| j dddg7 }|S )z}
Microsoft Windows SDK Libraries Paths.
Return
------
list of str
paths
Z
Referencesr7 r zCommonConfiguration\Neutralr0 Z
UnionMetadataz'Windows.Foundation.UniversalApiContractz1.0.0.0z%Windows.Foundation.FoundationContractz,Windows.Networking.Connectivity.WwanContractZ
ExtensionSDKszMicrosoft.VCLibsr ZCommonConfigurationZneutral)r r r ry r )rC reflibpathr r r OSLibpath s.
zEnvironmentInfo.OSLibpathc C s t | S )zs
Microsoft Windows SDK Tools.
Return
------
list of str
paths
)list
_sdk_toolsrF r r r SdkTools s
zEnvironmentInfo.SdkToolsc c s | j dk r,| j dkrdnd}t| jj|V | j s\| jjdd}d| }t| jj|V | j dkr| j rvd }n| jjddd
}d | }t| jj|V nB| j dkrt| jjd}| jjdd}| jj}t|d ||f V | jj r| jj V d
S )z
Microsoft Windows SDK Tools paths generator.
Return
------
generator of str
paths
r r r zBin\x86Tr r )r9 r r r zBin\NETFX 4.0 Tools%sz%s%sN)
ry r r r r[ rL rQ rI r r )rC Zbin_dirr r r r r r r s(
zEnvironmentInfo._sdk_toolsc C s | j j}|rd| S dS )zu
Microsoft Windows SDK version subdir.
Return
------
str
subdir
%s\r )r r rC ucrtverr r r r 6 s
zEnvironmentInfo._sdk_subdirc C s | j dkrg S t| jjdgS )zs
Microsoft Windows SDK Setup.
Return
------
list of str
paths
r7 ZSetup)ry r r r rF r r r SdkSetupC s
zEnvironmentInfo.SdkSetupc s | j }| j | jdkr0d}| o,| }n$| p>| }|jdkpR|jdk}g }|rt| fdd jD 7 }|r| fdd jD 7 }|S )zv
Microsoft .NET Framework Tools.
Return
------
list of str
paths
r9 TrA c s g | ]}t j|qS r )r r r r+ r r r r h s z+EnvironmentInfo.FxTools..c s g | ]}t j|qS r )r r r r r r r k s ) r[ r ry rI rL rK rG r r )rC r[ Z include32Z include64r r r r FxToolsR s"
zEnvironmentInfo.FxToolsc C s8 | j dk s| jjsg S | jjdd}t| jjd| gS )z~
Microsoft .Net Framework SDK Libraries.
Return
------
list of str
paths
r0 Tr zlib\um%s)ry r r r[ rR r )rC r r r r NetFxSDKLibrarieso s
z!EnvironmentInfo.NetFxSDKLibrariesc C s& | j dk s| jjsg S t| jjdgS )z}
Microsoft .Net Framework SDK Includes.
Return
------
list of str
paths
r0 z
include\um)ry r r r rF r r r NetFxSDKIncludes s
z EnvironmentInfo.NetFxSDKIncludesc C s t | jjdgS )z
Microsoft Visual Studio Team System Database.
Return
------
list of str
paths
z
VSTSDB\Deployr rF r r r VsTDb s
zEnvironmentInfo.VsTDbc C sv | j dk rg S | j dk r0| jj}| jjdd}n | jj}d}d| j |f }t||g}| j dkrr|t||dg7 }|S )zn
Microsoft Build Engine.
Return
------
list of str
paths
r r Tr r zMSBuild\%0.1f\bin%sZRoslyn)ry r r r[ rQ r r )rC base_pathr r Zbuildr r r MSBuild s
zEnvironmentInfo.MSBuildc C s | j dk rg S t| jjdgS )zt
Microsoft HTML Help Workshop.
Return
------
list of str
paths
r zHTML Help Workshop)ry r r r rF r r r HTMLHelpWorkshop s
z EnvironmentInfo.HTMLHelpWorkshopc C sD | j dk rg S | jjdd}t| jjd}| j}t|d||f gS )z
Microsoft Universal C Runtime SDK Libraries.
Return
------
list of str
paths
r0 Tr r z%sucrt%s)ry r[ rR r r r _ucrt_subdir)rC r r r r r r
UCRTLibraries s
z EnvironmentInfo.UCRTLibrariesc C s. | j dk rg S t| jjd}t|d| j gS )z
Microsoft Universal C Runtime SDK Include.
Return
------
list of str
paths
r0 r z%sucrt)ry r r r r )rC r r r r UCRTIncludes s
z EnvironmentInfo.UCRTIncludesc C s | j j}|rd| S dS )z
Microsoft Universal C Runtime SDK version subdir.
Return
------
str
subdir
r r )r r r r r r r s
z EnvironmentInfo._ucrt_subdirc C s( d| j krdkr n ng S | jjgS )zk
Microsoft Visual F#.
Return
------
list of str
paths
r r )ry r r rF r r r FSharp s
zEnvironmentInfo.FSharpc
C s d| j }| jjddd}g }| jj}t|dd}t|rft |t
|d }||t |dg7 }|t |d g7 }d
| j d d
t | j d f}t
||D ]&\}}t ||||} t| r| S qd S )
z
Microsoft Visual C++ runtime redistributable dll.
Return
------
str
path
zvcruntime%d0.dllTr rS z\Toolsz\Redistr8 ZonecoreZredistzMicrosoft.VC%d.CRT
N)rz r[ rR stripr r r rB r r r intry itertoolsproductr )
rC Z vcruntimer prefixesZ
tools_pathZ redist_pathZcrt_dirsr Zcrt_dirr r r r VCRuntimeRedist s
z EnvironmentInfo.VCRuntimeRedistTc C s t | d| j| j| j| jg|| d| j| j| j| j | j
g|| d| j| j| j | j g|| d| j
| j| j| j| j| j| j| j| jg |d}| jdkrt| jr| j|d< |S )z
Return environment dict.
Parameters
----------
exists: bool
It True, only return existing paths.
Return
------
dict
environment
r r r r )r r r r Zpy_vcruntime_redist)dict _build_pathsr r r r r r r r r r r r r r r r r r r ry r r )rC existsenvr r r r) & sV
zEnvironmentInfo.return_envc
C sp t j|}t|dt}t ||}|r A B C D
_unique_everseen('ABBCcAD', str.lower) --> A B C D
N)r| addr
__contains__)iterabler seenZseen_addZelementkr r r r z s
z EnvironmentInfo._unique_everseen)Nr )T)N)#r r r rV rD rX ry rz r r r r r r r r r r r r r r r r r r r r r r r r) r r r r r r r r( sn
$
#
"
2"r( )r" )r )*rV r ior osr r Zos.pathr r r r r3 platformr Zdistutils.errorsr$ Z#setuptools.extern.packaging.versionr Zsetuptools.extern.six.movesr
Zmonkeyr systemr r r ImportErrorr% r& Z_msvc9_suppress_errorsZdistutils.msvc9compilerr r r# r2 r6 r* r? rY rr r( r r r r sJ *
&
$s 5 PK ! ! + __pycache__/py31compat.cpython-38.opt-1.pycnu [ U
QabF @ sP g Z eZzd dlmZ W n2 ek
rJ d dlZd dlZG dd dZY nX dS ) )TemporaryDirectoryNc @ s( e Zd ZdZdd Zdd Zdd ZdS ) r z
Very simple temporary directory context manager.
Will try to delete afterward, but will also ignore OS and similar
errors on deletion.
c K s d | _ tjf || _ d S N)nametempfileZmkdtemp)selfkwargs r 9/usr/lib/python3.8/site-packages/setuptools/py31compat.py__init__ s zTemporaryDirectory.__init__c C s | j S r )r )r r r r __enter__ s z TemporaryDirectory.__enter__c C s2 zt | jd W n tk
r& Y nX d | _d S )NT)shutilZrmtreer OSError)r exctypeZexcvalueZexctracer r r __exit__ s
zTemporaryDirectory.__exit__N)__name__
__module__ __qualname____doc__r
r r r r r r r
s r )__all__typeZ
__metaclass__r r ImportErrorr r r r r s PK ! A . __pycache__/unicode_utils.cpython-38.opt-1.pycnu [ U
Qab @ s8 d dl Z d dlZd dlmZ dd Zdd Zdd ZdS ) N)sixc C sV t | tjrtd| S z$| d} td| } | d} W n tk
rP Y nX | S )NZNFDutf-8)
isinstancer text_type unicodedataZ normalizedecodeencode UnicodeError)path r s
PK ! 5) X X ) __pycache__/__init__.cpython-38.opt-1.pycnu [ U
Qabs @ s d Z ddlZddlZddlZddlZddlZddlZddlm Z ddl
m Z ddl m
Z
ddlmZ ddlmZmZ dd lmZmZ ddlZdd
lmZ dd lmZm Z dd l m Z dd
l m Z e!Z"ddddddddgZ#ere#$d ej%j&Z&dZ'dZ(dgZ)G dd dZ*G dd d e*Z+e*j,Z-er,e+j,Z.d d Z/d d Z0ej1j0j e0_ e 2ej1j3Z4G d d de4Z3d!d" Z5ej6fd#d$Z7e 8 dS )%z@Extensions to the 'distutils' for large or complex distributions N)DistutilsOptionError) convert_path fnmatchcase ) SetuptoolsDeprecationWarning)PY3 string_types)filtermap) Extension) DistributionFeature)Require)monkeysetupr
r Commandr r r
find_packagesfind_namespace_packagesTz
lib2to3.fixesc @ sB e Zd ZdZedddZedd Zed d
Zed d Z d
S )
PackageFinderzI
Generate a list of all Python packages found within a directory
. *c C s& t | t|| jd| | j| S )a Return a list all Python packages found within directory 'where'
'where' is the root directory which will be searched for packages. It
should be supplied as a "cross-platform" (i.e. URL-style) path; it will
be converted to the appropriate local path syntax.
'exclude' is a sequence of package names to exclude; '*' can be used
as a wildcard in the names, such that 'foo.*' will exclude all
subpackages of 'foo' (but not 'foo' itself).
'include' is a sequence of package names to include. If it's
specified, only the named packages will be included. If it's not
specified, all found packages will be included. 'include' can contain
shell style wildcard patterns just like 'exclude'.
ez_setup *__pycache__)r r )list_find_packages_iterr
_build_filter)clswhereexcludeincluder r 7/usr/lib/python3.8/site-packages/setuptools/__init__.pyfind4 s
zPackageFinder.findc c s t j|ddD ]\}}}|dd }g |dd< |D ]d}t j||} t j| |}
|
t jjd} d|ks4| | sxq4|| r|| s| V || q4qdS )zy
All the packages found in 'where' that pass the 'include' filter, but
not the 'exclude' filter.
T followlinksNr ) oswalkpathjoinrelpathreplacesep_looks_like_packageappend) r r r! r" rootdirsfilesZall_dirsdir full_pathZrel_pathpackager r r# r K s z!PackageFinder._find_packages_iterc C s t jt j| dS )z%Does a directory look like a package?z __init__.py)r' r) isfiler* r) r r r# r. g s z!PackageFinder._looks_like_packagec s fddS )z
Given a list of patterns, return a callable that will be true only if
the input matches at least one of the patterns.
c s t fddD S )Nc 3 s | ]}t |d V qdS ))patNr ).0r8 namer r# r s z@PackageFinder._build_filter....)anyr: Zpatternsr: r# r z-PackageFinder._build_filter..r r> r r> r# r l s zPackageFinder._build_filterN)r r r )
__name__
__module__ __qualname____doc__ classmethodr$ r staticmethodr. r r r r r# r / s
r c @ s e Zd Zedd ZdS )PEP420PackageFinderc C s dS )NTr r7 r r r# r. v s z'PEP420PackageFinder._looks_like_packageN)rA rB rC rF r. r r r r# rG u s rG c C s@ t jtdd | D }|jdd |jr<||j d S )Nc s s" | ]\}}|d kr||fV qdS ))Zdependency_linkssetup_requiresNr )r9 kvr r r# r< s z*_install_setup_requires..T)Zignore_option_errors) distutilscorer
dictitemsZparse_config_filesrH Zfetch_build_eggs)attrsdistr r r# _install_setup_requires s
rQ c K s t | tjjf | S N)rQ rK rL r )rO r r r# r s c @ s: e Zd ZejZdZdd Zd ddZdd Zd
d
d Z dS )r Fc K s t | | t| | dS )zj
Construct the command for dist, updating
vars(self) with any keyword parameters.
N)_Command__init__varsupdate)selfrP kwr r r# rT s zCommand.__init__Nc C sB t | |}|d kr"t| || |S t|ts>td|||f |S )Nz '%s' must be a %s (got `%s`))getattrsetattr
isinstancer r )rW optionZwhatdefaultvalr r r# _ensure_stringlike s
zCommand._ensure_stringlikec C sp t | |}|dkrdS t|tr6t| |td| n6t|trTtdd |D }nd}|sltd||f dS )zEnsure that 'option' is a list of strings. If 'option' is
currently a string, we split it either on /,\s*/ or /\s+/, so
"foo bar baz", "foo,bar,baz", and "foo, bar baz" all become
["foo", "bar", "baz"].
Nz,\s*|\s+c s s | ]}t |tV qd S rR )r[ r )r9 rJ r r r# r< s z-Command.ensure_string_list..Fz''%s' must be a list of strings (got %r)) rY r[ r rZ resplitr allr )rW r\ r^ okr r r# ensure_string_list s
zCommand.ensure_string_listr c K s t | ||}t|| |S rR )rS reinitialize_commandrU rV )rW ZcommandZreinit_subcommandsrX cmdr r r# re s z Command.reinitialize_command)N)r )
rA rB rC rS rD Zcommand_consumes_argumentsrT r_ rd re r r r r# r s
c C s& dd t j| ddD }tt jj|S )z%
Find all files under 'path'
c s s, | ]$\}}}|D ]}t j||V qqd S rR )r' r) r* )r9 baser1 r2 filer r r# r< s z#_find_all_simple..Tr% )r' r( r
r) r6 )r) resultsr r r# _find_all_simple s rj c C s6 t | }| tjkr.tjtjj| d}t||}t|S )z
Find all files under 'dir' and return the list of full filenames.
Unless dir is '.', return full filenames with dir prepended.
)start) rj r' curdir functoolspartialr) r+ r r )r3 r2 Zmake_relr r r# findall s
ro )9rD r' sysrm Zdistutils.corerK Zdistutils.filelistr` Zdistutils.errorsr Zdistutils.utilr Zfnmatchr Z_deprecation_warningr Zsetuptools.extern.sixr r Zsetuptools.extern.six.movesr
r Zsetuptools.versionZ
setuptoolsZsetuptools.extensionr Zsetuptools.distr
r Zsetuptools.dependsr r typeZ
__metaclass____all__r/ version __version__Zbootstrap_install_fromZrun_2to3_on_doctestsZlib2to3_fixer_packagesr rG r$ r r rQ r rL Z
get_unpatchedr rS rj rl ro Z patch_allr r r r# s\
F
2
PK ! KӤ Ӥ __pycache__/dist.cpython-38.pycnu [ U
Qab @ s d gZ ddlZddlZddlZddlZddlZddlZddlZddl Zddl
Zddl Zddl m
Z
ddlmZ ddlmZ ddlZddlmZ ddlmZ ddlmZmZmZ dd l mZ dd
l m Z dd l m Z dd l m Z dd
l m!Z! ddl"m#Z#m$Z$m%Z% ddl&m'Z' ddl(m)Z) ddl*m+Z+ ddl,m-Z- ddl.m/Z/ ddl0Z0e1d e1d dd Z2dd Z3dd Z4d d Z5e6e7fZ8d d Z9d!d" Z:d#d$ Z;d%d& Zd+d, Z?d-d. Z@d/d0 ZAd1d2 ZBd3d4 ZCd5d6 ZDe-ejEjFZGG d7d d eGZFG d8d9 d9ZHG d:d; d;e'ZIdS )< Distribution N) strtobool)DEBUGtranslate_longopt) defaultdict)message_from_file)DistutilsOptionErrorDistutilsPlatformErrorDistutilsSetupError)
rfc822_escape)
StrictVersion)six) packaging) ordered_set)mapfilter filterfalse ) SetuptoolsDeprecationWarning)Require)windows_support)
get_unpatched)parse_configurationz&setuptools.extern.packaging.specifiersz#setuptools.extern.packaging.versionc C s t dt t| S )NzDo not call this function)warningswarnDistDeprecationWarningr )cls r 3/usr/lib/python3.8/site-packages/setuptools/dist.py_get_unpatched- s r c C s t | dd }|d kr| js | jr*td}nd| jd k sT| jd k sTt | dd d k sT| jr^td}n0| js|| js|| j s|| j
s|| j rtd}ntd}|| _ |S )Nmetadata_versionz2.1python_requires1.21.1z1.0)
getattr long_description_content_typeprovides_extrasr
maintainermaintainer_email project_urlsprovidesrequires obsoletes classifiers download_urlr! )selfZmvr r r get_metadata_version2 s*
r1 c s t | fdd} fdd}t d | _|d| _|d| _|d| _|d | _d
| _|d | _d
| _ |d | _
|d
| _ d kr|d| _ nd
| _ |d| _
|d| _d kr|dd| _|d| _|d| _| jtdkr
|d| _|d| _|d| _nd
| _d
| _d
| _d
S )z-Reads the metadata values from a file object.c s | }|dkrd S |S )NZUNKNOWNr )namevaluemsgr r _read_fieldL s z"read_pkg_file.._read_fieldc s | d }|g krd S |S N)Zget_all)r2 valuesr4 r r
_read_listR s z!read_pkg_file.._read_listzmetadata-versionr2 versionZsummaryauthorNz author-emailz home-pagelicensez download-url descriptionkeywords,platformZ
classifierr$ r, r+ r- )r r
r! r2 r: r= r; r( author_emailr) Zurlr< r/ Zlong_descriptionsplitr> Z platformsr. r, r+ r- )r0 filer6 r9 r r4 r
read_pkg_fileH s:
rD c
s }tjr fdd}n fdd}|dt| |d |d |d |d |td k r|d
|d
n.d }|D ]$\}}t |}|d
k r||| q|d j
r|dj
j D ]}|dd| qt } |d| d }
|
r:|d|
|td krd D ]} |d| qPn d d d d d tdr|dj j r|d j j r
j D ]} |d | qd
S ) z5Write the PKG-INFO format data to a file object.
c s d| |f d S Nz%s: %s
)writeZ
_encode_fieldkeyr3 rC r0 r r write_field s z#write_pkg_file..write_fieldc s d| |f d S rE )rF rG )rC r r rJ s zMetadata-VersionNameVersionZSummaryz Home-pager# Author Author-email))rM r; )rN rA )Z
Maintainerr( )zMaintainer-emailr) NZLicensez Download-URLz Project-URLz%s, %sZ Descriptionr? ZKeywordsZPlatformZ
ClassifierZRequiresZProvidesZ Obsoletesr" zRequires-PythonzDescription-Content-TypezProvides-Extra) r1 r PY2strZget_nameZ get_versionZget_descriptionZget_urlr
Z get_contactZget_contact_emailr% Z get_licenser/ r* itemsr Zget_long_descriptionjoinZ get_keywordsZ
get_platformsZ _write_listZget_classifiersZ get_requiresZ get_providesZ
get_obsoleteshasattrr" r& r' )
r0 rC r: rJ Zoptional_fieldsZfieldattrZattr_valZ project_urlZ long_descr> r@ extrar rI r write_pkg_file~ sZ
rV c C sP z t jd| }|jr tW n, ttttfk
rJ td||f Y nX d S )Nzx=z4%r must be importable 'module:attrs' string (got %r))
pkg_resources
EntryPointparseextrasAssertionError TypeError
ValueErrorAttributeErrorr )distrT r3 epr r r check_importable s ra c C sZ z(t |ttfstd||ks&tW n, ttttfk
rT td||f Y nX dS )z"Verify that value is a string list z%%r must be a list of strings (got %r)N)
isinstancelisttupler[ rR r\ r] r^ r r_ rT r3 r r r assert_string_list s
rg c C sd |}t | || |D ]J}| |s2tdd| |d\}}}|r||krtjd|| qdS )z(Verify that namespace packages are validz1Distribution contains no modules or packages for znamespace package %r.z^WARNING: %r is declared as a package namespace, but %r is not: please correct this in setup.pyN)rg has_contents_forr
rpartition distutilslogr )r_ rT r3 Z ns_packagesZnspparentsepZchildr r r check_nsp s
ro c
C s@ zt tt| W n" tttfk
r: tdY nX dS )z+Verify that extras_require mapping is validz'extras_require' must be a dictionary whose values are strings or lists of strings containing valid project/version requirement specifiers.N) rd itertoolsstarmap _check_extrarQ r\ r] r^ r rf r r r check_extras s rs c C s< | d\}}}|r*t|r*td| tt| d S )N:z Invalid environment marker: ) partitionrW Zinvalid_markerr rd parse_requirements)rU Zreqsr2 rn markerr r r rr s rr c C s& t ||kr"d}t|j||ddS )z)Verify that value is True, False, 0, or 1z0{attr!r} must be a boolean value (got {value!r}))rT r3 N)boolr format)r_ rT r3 tmplr r r assert_bool s r{ c
C sj z(t t| t|ttfr&tdW n< ttfk
rd } zd}t|j ||dW 5 d}~X Y nX dS )z9Verify that install_requires is a valid requirements listz Unordered types are not allowedzm{attr!r} must be a string or list of strings containing valid project/version requirement specifiers; {error}rT errorN)
rd rW rv rc dictsetr\ r] r ry r_ rT r3 r} rz r r r check_requirements s r c
C sR zt j| W n< t jjk
rL } zd}t|j||dW 5 d}~X Y nX dS )z.Verify that value is a valid version specifierzF{attr!r} must be a string containing valid version specifiers; {error}r| N)r Z
specifiersZ SpecifierSetZInvalidSpecifierr ry r r r r check_specifier s r c
C s@ zt j| W n* tk
r: } z t|W 5 d}~X Y nX dS )z)Verify that entry_points map is parseableN)rW rX Z parse_mapr] r )r_ rT r3 er r r check_entry_points, s r c C s t |tjstdd S )Nztest_suite must be a string)rc r string_typesr rf r r r check_test_suite4 s r c C s\ t |tstd|| D ]6\}}t |tjsDtd||t| d|| q dS )z@Verify that value is a dictionary of package names to glob listszT{!r} must be a dictionary mapping package names to lists of string wildcard patternsz,keys of {!r} dict must be strings (got {!r})zvalues of {!r} dictN)rc r~ r ry rQ r r rg )r_ rT r3 kvr r r check_package_data9 s
r c C s( |D ] }t d|stjd| qd S )Nz \w+(\.\w+)*z[WARNING: %r not a valid package name; please use only .-separated package names in setup.py)rematchrk rl r )r_ rT r3 Zpkgnamer r r check_packagesH s r c @ sR e Zd ZdZdeejdZdZdd Z dMddZ
dd Z d
d Z e
d d
Zdd Zdd ZdNddZe
dd ZdOddZdPddZdd Zd d Zd d Zd!d" Zd#d$ Zd%d& Zd'd( Zd)d* Z d+d, Z d-d. Z d/d0 Z d1d2 Z d3d4 Z!d5d6 Z"d7d8 Z#d9d: Z$d;d< Z%d=d> Z&d?d@ Z'dAdB Z(dCdD Z)dEdF Z*dGdH Z+dIdJ Z,dKdL Z-dS )Qr a Distribution with support for features, tests, and package data
This is an enhanced version of 'distutils.dist.Distribution' that
effectively adds the following new optional keyword arguments to 'setup()':
'install_requires' -- a string or sequence of strings specifying project
versions that the distribution requires when installed, in the format
used by 'pkg_resources.require()'. They will be installed
automatically when the package is installed. If you wish to use
packages that are not available in PyPI, or want to give your users an
alternate download location, you can add a 'find_links' option to the
'[easy_install]' section of your project's 'setup.cfg' file, and then
setuptools will scan the listed web pages for links that satisfy the
requirements.
'extras_require' -- a dictionary mapping names of optional "extras" to the
additional requirement(s) that using those extras incurs. For example,
this::
extras_require = dict(reST = ["docutils>=0.3", "reSTedit"])
indicates that the distribution can optionally provide an extra
capability called "reST", but it can only be used if docutils and
reSTedit are installed. If the user installs your package using
EasyInstall and requests one of your extras, the corresponding
additional requirements will be installed if needed.
'features' **deprecated** -- a dictionary mapping option names to
'setuptools.Feature'
objects. Features are a portion of the distribution that can be
included or excluded based on user options, inter-feature dependencies,
and availability on the current system. Excluded features are omitted
from all setup commands, including source and binary distributions, so
you can create multiple distributions from the same source tree.
Feature names should be valid Python identifiers, except that they may
contain the '-' (minus) sign. Features can be included or excluded
via the command line options '--with-X' and '--without-X', where 'X' is
the name of the feature. Whether a feature is included by default, and
whether you are allowed to control this from the command line, is
determined by the Feature object. See the 'Feature' class for more
information.
'test_suite' -- the name of a test suite to run for the 'test' command.
If the user runs 'python setup.py test', the package will be installed,
and the named test suite will be run. The format is the same as
would be used on a 'unittest.py' command line. That is, it is the
dotted name of an object to import and call to generate a test suite.
'package_data' -- a dictionary mapping package names to lists of filenames
or globs to use to find data files contained in the named packages.
If the dictionary has filenames or globs listed under '""' (the empty
string), those names will be searched for in every package, in addition
to any names for the specific package. Data files found using these
names/globs will be installed along with the package, in the same
location as the package. Note that globs are allowed to reference
the contents of non-package subdirectories, as long as you use '/' as
a path separator. (Globs are automatically converted to
platform-specific paths at runtime.)
In addition to these new keywords, this class also has several new methods
for manipulating the distribution's contents. For example, the 'include()'
and 'exclude()' methods can be thought of as in-place add and subtract
commands that add or remove packages, modules, extensions, and so on from
the distribution. They are used by the feature subsystem to configure the
distribution for the included and excluded features.
N)r& r* r' c C sl |rd|ksd|krd S t t|d }t jj|}|d k rh|dsht t|d |_ || _
d S )Nr2 r: zPKG-INFO) rW Z safe_namerP lower working_setZby_keygetZ has_metadataZ safe_versionZ_version
_patched_dist)r0 attrsrH r_ r r r patch_missing_pkg_info s z#Distribution.patch_missing_pkg_infoc
s t d}|si _|pi }d|ks,d|kr4t g _i _g _|dd _ | |dg _
|dg _ t
dD ]}t |jd qt fdd | D j D ]L\}} jj|fD ]}||kr|| } qq|r| nd }t j|| qt jjtjr4t jj j_ jjd k rzHt j jj}t |} jj| krt d
jj| f | j_W n0 t jj!t"fk
r t d jj Y nX # d S ) N package_datafeaturesrequire_featuressrc_rootdependency_linkssetup_requiresdistutils.setup_keywordsc s i | ]\}}| j kr||qS r ) _DISTUTILS_UNSUPPORTED_METADATA.0r r r0 r r
s
z)Distribution.__init__..zNormalizing '%s' to '%s'zThe version specified (%r) is an invalid version, this may not work as expected with newer versions of setuptools, pip, and PyPI. Please see PEP 440 for more details.)$rS r Featurewarn_deprecatedr r Z
dist_filespopr r r r rW iter_entry_pointsvars
setdefaultr2
_Distribution__init__rQ r metadata__dict__setattrrc r: numbersNumberrP r rL r r ZInvalidVersionr\ _finalize_requires)
r0 r Zhave_package_datar` optiondefaultsourcer3 ZverZnormalized_versionr r r r s\
zDistribution.__init__c C sf t | ddr| j| j_t | ddrR| j D ]$}|dd }|r,| jj| q,| | dS )z
Set `metadata.python_requires` and fix environment markers
in `install_requires` and `extras_require`.
r" Nextras_requirert r )
r% r" r r keysrB r' add _convert_extras_requirements"_move_install_requirements_markers)r0 rU r r r r s
z Distribution._finalize_requiresc C sh t | ddpi }tt| _| D ]@\}}| j| t|D ]"}| |}| j|| | q>q"dS )z
Convert requirements in `extras_require` of the form
`"extra": ["barbazquux; {marker}"]` to
`"extra:{marker}": ["barbazquux"]`.
r N) r% r rd _tmp_extras_requirerQ rW rv _suffix_forappend)r0 Z
spec_ext_reqssectionr rsuffixr r r r s
z)Distribution._convert_extras_requirementsc C s | j rdt| j S dS )ze
For a requirement, return the 'extras_require' suffix for
that requirement.
rt rb )rw rP reqr r r r s zDistribution._suffix_forc s dd }t ddpd}tt|}t||}t||}ttt| _|D ] } j dt|j
| qNt fdd j
D _dS ) zv
Move requirements in `install_requires` that are using environment
markers `extras_require`.
c S s | j S r7 rw r r r r
is_simple_req s zFDistribution._move_install_requirements_markers..is_simple_reqinstall_requiresNr rt c 3 s, | ]$\}}|d d t j|D fV qdS )c S s g | ] }t |qS r )rP r r r r r
) s zMDistribution._move_install_requirements_markers...N)r
_clean_reqr r r r ( s zBDistribution._move_install_requirements_markers..)r% rd rW rv r r r rP r r rw r r~ rQ r )r0 r Zspec_inst_reqsZ inst_reqsZ simple_reqsZ complex_reqsr r r r r s
z/Distribution._move_install_requirements_markersc C s
d|_ |S )zP
Given a Requirement, remove environment markers and return it.
Nr )r0 r r r r r - s zDistribution._clean_reqc
C s ddl m} tjr>tjtjkr>ddddddd d
d d d
ddg
}ng }t|}|dkrZ| }t rh|
d | }|D ]}t j |dd4}t r|
dj
f t tjr|jn|j| W 5 Q R X | D ]\}||}| |} |D ]>}
|
dkr|
|kr| |||
} |
dd}
|| f| |
< qq| qrd| jkr| jd D ]\}
\} } | j|
}
zF|
r|t| |
t | n(|
dkrt| |
t | n t| |
| W n, t k
r } z t |W 5 d}~X Y nX qHdS )z
Adapted from distutils.dist.Distribution.parse_config_files,
this method provides the same functionality in subtly-improved
ways.
r ) ConfigParserz install-basezinstall-platbasez install-libzinstall-platlibzinstall-purelibzinstall-headerszinstall-scriptsz install-dataprefixz exec-prefixhomeuserrootNz"Distribution.parse_config_files():utf-8)encodingz reading {filename}__name__-_global)verboseZdry_run) Z(setuptools.extern.six.moves.configparserr r PY3sysr base_prefix frozensetZfind_config_filesr announceioopenry localsZ read_fileZreadfpZsectionsoptionsget_option_dict_try_strr replacer command_optionsrQ negative_optr r r] r )r0 filenamesr Zignore_optionsparserfilenamereaderr r Zopt_dictoptvalsrcaliasr5 r r r _parse_config_files4 s`
z Distribution._parse_config_filesc C s. t jr
| S z
| W S tk
r( Y nX | S )ab
On Python 2, much of distutils relies on string values being of
type 'str' (bytes) and not unicode text. If the value can be safely
encoded to bytes using the default encoding, prefer that.
Why the default encoding? Because that value can be implicitly
decoded back to text if needed.
Ref #1653
)r r encodeUnicodeEncodeError)r r r r r r s
zDistribution._try_strc C s^ | }|dkr| |}tr,| d| | D ]"\}\}}trZ| d|||f zdd |jD }W n tk
r g }Y nX z
|j}W n tk
r i }Y nX z~t|t j
} ||kr| rt ||| t | nJ||kr| rt ||t | n,t
||rt ||| ntd|||f W q4 tk
rV }
z t|
W 5 d}
~
X Y q4X q4dS )a
Set the options for 'command_obj' from 'option_dict'. Basically
this means copying elements of a dictionary ('option_dict') to
attributes of an instance ('command').
'command_obj' must be a Command instance. If 'option_dict' is not
supplied, uses the standard option dictionary for this command
(from 'self.command_options').
(Adopted from distutils.dist.Distribution._set_command_options)
Nz# setting options for '%s' command:z %s = %s (from %s)c S s g | ] }t |qS r r )r or r r r s z5Distribution._set_command_options..z1error in %s: command '%s' has no such option '%s')Zget_command_namer r r rQ Zboolean_optionsr^ r rc r r r r rS r r] ) r0 Z command_objZ option_dictZ command_namer r r3 Z bool_optsneg_optZ is_stringr5 r r r _set_command_options sF
z!Distribution._set_command_optionsFc C s( | j |d t| | j|d | dS )zYParses configuration files from various levels
and loads configuration.
)r )ignore_option_errorsN)r r r r )r0 r r r r r parse_config_files s
z Distribution.parse_config_filesc C s t | }| jr| |S )z3Process features after parsing command line options)r parse_command_liner _finalize_features)r0 resultr r r r s
z Distribution.parse_command_linec C s d| dd S )z;Convert feature name to corresponding option attribute nameZwith_r r r r0 r2 r r r _feature_attrname s z Distribution._feature_attrnamec C s8 t jjt || jdd}|D ]}t jj|dd q |S )z Resolve pre-setup requirementsT) installerZreplace_conflictingr )rW r resolverv fetch_build_eggr )r0 r, Zresolved_distsr_ r r r fetch_build_eggs s z Distribution.fetch_build_eggsc C s t | | jr| tdD ]:}t| |jd }|d k r"|j| j d |
| |j| q"t| dd r~dd | j D | _ ng | _ d S )Nr r convert_2to3_doctestsc S s g | ]}t j|qS r )ospathabspathr pr r r r s z1Distribution.finalize_options..) r finalize_optionsr _set_global_opts_from_featuresrW r r% r2 requirer loadr )r0 r` r3 r r r r s
z Distribution.finalize_optionsc C sv t jt jd}t j|srt | t| t j|d}t|d$}| d | d | d W 5 Q R X |S )Nz.eggsz
README.txtwzcThis directory contains eggs that were downloaded by setuptools to build, test, and run plug-ins.
zAThis directory caches those eggs to prevent repeated downloads.
z/However, it is safe to delete this directory.
)
r r rR curdirexistsmkdirr Z hide_filer rF )r0 Z
egg_cache_dirZreadme_txt_filenamefr r r get_egg_cache_dir s
z Distribution.get_egg_cache_dirc
C s ddl m} | ddgi}|d}| |dd | d D | jr| jdd }d|krx|d d | }d
|f|d< | }||d g|d d
dd
d
d d d
d }| ||S )z Fetch an egg needed for buildingr ) easy_installZ script_argsr c s s" | ]\}}|d kr||fV qdS ))
find_links site_dirsZ index_urloptimizer Z allow_hostsNr r r r r r s z/Distribution.fetch_build_egg..Nr
r ZsetupxTF)
args install_dirZexclude_scriptsZ always_copyZbuild_directoryZeditableZupgradeZ
multi_versionZ no_reportr )
Z setuptools.command.easy_installr __class__r clearupdaterQ r r Zensure_finalized)r0 r r r_ optsZlinksr cmdr r r r s8
z Distribution.fetch_build_eggc C s g }| j }| j D ]\}}| |d || |jr|j}d}d}| s\|| }}d| dd| | fd| dd| | ff}| | d| |d| < q|| j
| _
| _ | | _ | _ dS )z;Add --with-X/--without-X options based on optional featuresNz
(default)rb zwith-zinclude zwithout-zexclude )
r copyr rQ _set_featurevalidateoptionalr= include_by_defaultextendglobal_optionsZfeature_optionsZfeature_negopt) r0 ZgoZnor2 featuredescrZincdefZexcdefnewr r r r s$
z+Distribution._set_global_opts_from_featuresc C s | j D ]<\}}| |}|s0|dkr
| r
|| | |d q
| j D ](\}}| |sR|| | |d qRdS )z9Add/remove features and resolve dependencies between themNr r )r rQ feature_is_includedr
include_inr exclude_from)r0 r2 r Zenabledr r r r 0 s
z Distribution._finalize_featuresc C s\ || j kr| j | S td|}|D ]*}|j| jd | | j |< }| S t| |S )z(Pluggable version of get_command_class()distutils.commandsr N)cmdclassrW r r r r r get_command_class)r0 commandZepsr` r# r r r r$ A s
z Distribution.get_command_classc C s: t dD ]$}|j| jkr
| }|| j|j< q
t| S Nr" )rW r r2 r# r r print_commandsr0 r` r# r r r r' N s
zDistribution.print_commandsc C s: t dD ]$}|j| jkr
| }|| j|j< q
t| S r& )rW r r2 r# r r get_command_listr( r r r r) V s
z Distribution.get_command_listc C s t | | || dS )z Set feature's inclusion statusN)r r )r0 r2 Zstatusr r r r ^ s zDistribution._set_featurec C s t | | |S )zAReturn 1 if feature is included, 0 if excluded, 'None' if unknown)r% r r r r r r b s z Distribution.feature_is_includedc C sF | |dkr&| j| j}t|d | j| | | |d dS )z)Request inclusion of feature named 'name'r z2 is required, but was excluded or is not availabler N)r r r= r r r )r0 r2 r r r r include_featuref s z Distribution.include_featurec K s@ | D ]2\}}t| d| d}|r.|| q| || qdS )a Add items to distribution that are named in keyword arguments
For example, 'dist.include(py_modules=["x"])' would add 'x' to
the distribution's 'py_modules' attribute, if it was not already
there.
Currently, this method only supports inclusion for attributes that are
lists or tuples. If you need to add support for adding to other
attributes in this or a subclass, you can add an '_include_X' method,
where 'X' is the name of the attribute. The method will be called with
the value passed to 'include()'. So, 'dist.include(foo={"bar":"baz"})'
will try to call 'dist._include_foo({"bar":"baz"})', which can then
handle whatever special inclusion logic is needed.
Z _include_N)rQ r%
_include_misc)r0 r r r includer r r r, q s
zDistribution.includec sf d | j r& fdd| j D | _ | jrD fdd| jD | _| jrb fdd| jD | _dS )z9Remove packages, modules, and extensions in named packagerh c s" g | ]}| kr| s|qS r
startswithr packagepfxr r r s
z0Distribution.exclude_package..c s" g | ]}| kr| s|qS r r- r r/ r r r s
c s& g | ] }|j kr|j s|qS r )r2 r. r r/ r r r s
N)packages
py_modules ext_modules)r0 r0 r r/ r exclude_package s z Distribution.exclude_packagec C s2 |d }| D ] }||ks&||r dS qdS )z.rc sequencer r% r^ r )r0 r2 r3 oldr r; r
_exclude_misc s
zDistribution._exclude_miscc s t |tstd||f zt| | W n tk
rH td| Y nX dkr`t| || n:t tsxt|d n" fdd|D }t| | | dS )zAHandle 'include()' for list/tuple attrs without a special handlerz %s: setting must be a list (%r)r7 Nr8 c s g | ]}| kr|qS r r r9 r> r r r s z.Distribution._include_misc..r< )r0 r2 r3 r r r@ r r+ s$
zDistribution._include_miscc K s@ | D ]2\}}t| d| d}|r.|| q| || qdS )a Remove items from distribution that are named in keyword arguments
For example, 'dist.exclude(py_modules=["x"])' would remove 'x' from
the distribution's 'py_modules' attribute. Excluding packages uses
the 'exclude_package()' method, so all of the package's contained
packages, modules, and extensions are also excluded.
Currently, this method only supports exclusion from attributes that are
lists or tuples. If you need to add support for excluding from other
attributes in this or a subclass, you can add an '_exclude_X' method,
where 'X' is the name of the attribute. The method will be called with
the value passed to 'exclude()'. So, 'dist.exclude(foo={"bar":"baz"})'
will try to call 'dist._exclude_foo({"bar":"baz"})', which can then
handle whatever special exclusion logic is needed.
Z _exclude_N)rQ r% r? )r0 r r r excluder r r rA s
zDistribution.excludec C s, t |tstd|f tt| j| d S )Nz.packages: setting must be a list or tuple (%r))rc r= r rd r r5 )r0 r2 r r r _exclude_packages s
z Distribution._exclude_packagesc
C s | j j| _| j j| _|d }| d}||krf|| \}}||= dd l}||d|d d< |d }q&t| ||}| |} t | dd rd|f| |d< |d k rg S |S )Nr aliasesTr Zcommand_consumes_arguments command liner )
r r r r shlexrB r _parse_command_optsr$ r% )
r0 r r r% rC r r rE nargsZ cmd_classr r r rF s"
z Distribution._parse_command_optsc C s i }| j D ]\}}| D ]\}\}}|dkr4q |dd}|dkr| |}| j }|t|di | D ] \} }
|
|krv| }d} qqvtdn |dkrd}|| |i |< q q|S ) ah Return a '{cmd: {opt:val}}' map of all command-line options
Option names are all long, but do not include the leading '--', and
contain dashes rather than underscores. If the option doesn't take
an argument (e.g. '--quiet'), the 'val' is 'None'.
Note that options provided by config files are intentionally excluded.
rD r r r r Nz Shouldn't be able to get herer )
r rQ r Zget_command_objr r r r% r[ r ) r0 dr r r r r Zcmdobjr negposr r r get_cmdline_options s(
z Distribution.get_cmdline_optionsc c sv | j pdD ]
}|V q
| jp dD ]
}|V q | jp4dD ]:}t|trN|\}}n|j}|drj|dd }|V q6dS )z@Yield all packages, modules, and extension names in distributionr moduleNi)r2 r3 r4 rc re r2 endswith)r0 ZpkgrL Zextr2 Z buildinfor r r r6 0 s
z$Distribution.iter_distribution_namesc
C s ddl }tjs| jr t| |S t|jtj s:t| |S |jj
dkrVt| |S |jj
}|jj }|j
dkrtdpvd}|jj}t |j d||||_zt| |W S t |j |||||_X dS )zIf there were any non-global "display-only" options
(--help-commands or the metadata display options) on the command
line, display the requested info and return true; else return
false.
r N)r utf8Zwin32
r )r r rO Z
help_commandsr handle_display_optionsrc stdoutr
TextIOWrapperr r errorsr@ line_bufferingdetach)r0 Z option_orderr r rS newlinerT r r r rP B s6 z#Distribution.handle_display_options)N)N)N)NF).r
__module__ __qualname____doc__r~ r Z
OrderedSetr r r r r r staticmethodr r r r r r r r r r r r r r r r$ r' r) r r r* r, r5 ri r? r+ rA rB rF rK r6 rP r r r r r T sX D
;
>
/
(c @ sF e Zd ZdZedd ZdddZd d
Zd d Zd
d Z dd Z
dS )r a
**deprecated** -- The `Feature` facility was never completely implemented
or supported, `has reported issues
`_ and will be removed in
a future version.
A subset of the distribution that can be excluded if unneeded/wanted
Features are created using these keyword arguments:
'description' -- a short, human readable description of the feature, to
be used in error messages, and option help messages.
'standard' -- if true, the feature is included by default if it is
available on the current system. Otherwise, the feature is only
included if requested via a command line '--with-X' option, or if
another included feature requires it. The default setting is 'False'.
'available' -- if true, the feature is available for installation on the
current system. The default setting is 'True'.
'optional' -- if true, the feature's inclusion can be controlled from the
command line, using the '--with-X' or '--without-X' options. If
false, the feature's inclusion status is determined automatically,
based on 'availabile', 'standard', and whether any other feature
requires it. The default setting is 'True'.
'require_features' -- a string or sequence of strings naming features
that should also be included if this feature is included. Defaults to
empty list. May also contain 'Require' objects that should be
added/removed from the distribution.
'remove' -- a string or list of strings naming packages to be removed
from the distribution if this feature is *not* included. If the
feature *is* included, this argument is ignored. This argument exists
to support removing features that "crosscut" a distribution, such as
defining a 'tests' feature that removes all the 'tests' subpackages
provided by other features. The default for this argument is an empty
list. (Note: the named package(s) or modules must exist in the base
distribution when the 'setup()' function is initially called.)
other keywords -- any other keyword arguments are saved, and passed to
the distribution's 'include()' and 'exclude()' methods when the
feature is included or excluded, respectively. So, for example, you
could pass 'packages=["a","b"]' to cause packages 'a' and 'b' to be
added or removed from the distribution as appropriate.
A feature must include at least one 'requires', 'remove', or other
keyword argument. Otherwise, it can't affect the distribution in any way.
Note also that you can subclass 'Feature' to create your own specialized
feature types that modify the distribution in other ways when included or
excluded. See the docstrings for the various methods here for more detail.
Aside from the methods, the only feature attributes that distributions look
at are 'description' and 'optional'.
c C s d} t j| tdd d S )NzrFeatures are deprecated and will be removed in a future version. See https://github.com/pypa/setuptools/issues/65. )
stacklevel)r r r r4 r r r r s zFeature.warn_deprecatedFTr c K s | || _|| _|| _|| _t|ttfr4|f}dd |D | _dd |D }|r^||d< t|trn|f}|| _ || _
|s|s|st dd S )Nc S s g | ]}t |tr|qS r rc rP r r r r r s
z$Feature.__init__..c S s g | ]}t |ts|qS r r] r r r r r s
r zgFeature %s: must define 'require_features', 'remove', or at least one of 'packages', 'py_modules', etc.) r r= standard availabler rc rP r r removerZ r ) r0 r= r^ r_ r r r` rZ Zerr r r r s*
zFeature.__init__c C s | j o
| jS )z+Should this feature be included by default?)r_ r^ r r r r r s zFeature.include_by_defaultc C s< | j st| jd |jf | j | jD ]}|| q(dS )a Ensure feature and its requirements are included in distribution
You may override this in a subclass to perform additional operations on
the distribution. Note that this method may be called more than once
per feature, and so should be idempotent.
z3 is required, but is not available on this platformN)r_ r
r= r, rZ r r* )r0 r_ r r r r r s
zFeature.include_inc C s. |j f | j | jr*| jD ]}|| qdS )a2 Ensure feature is excluded from distribution
You may override this in a subclass to perform additional operations on
the distribution. This method will be called at most once per
feature, and only after all included features have been asked to
include themselves.
N)rA rZ r` r5 r0 r_ r: r r r r! s
zFeature.exclude_fromc C s. | j D ]"}||std| j||f qdS )a Verify that feature makes sense in context of distribution
This method is called by the distribution just before it parses its
command line. It checks to ensure that the 'remove' attribute, if any,
contains only valid package/module names that are present in the base
distribution when 'setup()' is called. You may override it in a
subclass to perform any other required validation of the feature
against a target distribution.
zg%s wants to be able to remove %s, but the distribution doesn't contain any packages or modules under %sN)r` ri r r= ra r r r r s
zFeature.validateN)FTTr r ) r rW rX rY rZ r r r r r! r r r r r r e s 8
r c @ s e Zd ZdZdS )r zrClass for warning about deprecations in dist in
setuptools. Not ignored by default, unlike DeprecationWarning.N)r rW rX rY r r r r r s r )J__all__r r r r r r Z
distutils.logrk Zdistutils.coreZ
distutils.cmdZdistutils.distZdistutils.utilr Zdistutils.debugr Zdistutils.fancy_getoptr rp collectionsr Zemailr Zdistutils.errorsr r
r r Zdistutils.versionr
Zsetuptools.externr r r Zsetuptools.extern.six.movesr r r rb r Zsetuptools.dependsr Z
setuptoolsr Zsetuptools.monkeyr Zsetuptools.configr rW
__import__r r1 rD rV re rd r= ra rg ro rs rr r{ r r r r r r Zcorer r r r r r r r sv 6L PK ! C;b b % __pycache__/_imp.cpython-38.opt-1.pycnu [ U
Qab @ s\ d Z ddlZddlZddlZddlmZ dZdZdZ dZ
dZ dd d
Z dd d Z
d
d ZdS )zX
Re-implementation of find_module and get_frozen_object
from the deprecated imp module.
N )module_from_spec c C sV t j| |}|dkr"td| |jsBt|drBt jd|j}d}d}t|jt }|j
dkst|rt |jt j j
rt}d}d }}n|j
dks|rt |jt j jrt}d}d }}n|jr:|j
}tj|d }|t j jkrd
nd }|t j jkrt}n&|t j jkrt}n|t j jkr t}|tthkrFt||}n d}d }}|||||ffS ) z7Just like 'imp.find_module()', but with package supportN
Can't find %ssubmodule_search_locationsz __init__.pyfrozen zbuilt-inr rrb) importlibutil find_spec ImportError has_locationhasattrspec_from_loaderloader
isinstancetypeorigin
issubclass machineryFrozenImporter PY_FROZENBuiltinImporter C_BUILTINospathsplitextSOURCE_SUFFIXES PY_SOURCEBYTECODE_SUFFIXES PY_COMPILEDEXTENSION_SUFFIXES C_EXTENSIONopen) modulepathsspecZkindfileZstaticr! suffixmode r0 3/usr/lib/python3.8/site-packages/setuptools/_imp.py find_module sJ
r2 c C s* t j| |}|s td| |j| S Nr )r r r r r get_code)r* r+ r, r0 r0 r1 get_frozen_object> s r5 c C s& t j| |}|s td| t|S r3 )r r r r r )r* r+ infor, r0 r0 r1
get_moduleE s r7 )N)N)__doc__r importlib.utilr Zimportlib.machineryZ
py34compatr r$ r& r( r r r2 r5 r7 r0 r0 r0 r1 s
*
PK ! $ $ " __pycache__/version.cpython-38.pycnu [ U
Qab @ s6 d dl Z ze djZW n ek
r0 dZY nX dS ) NZ
setuptoolsunknown)Z
pkg_resourcesZget_distributionversion __version__ Exception r r 6/usr/lib/python3.8/site-packages/setuptools/version.py s PK ! {BB
!
! + __pycache__/build_meta.cpython-38.opt-1.pycnu [ U
Qab}% @ s d Z ddlZddlZddlZddlZddlZddlZddlZddlZddl m
Z
ddl m Z ddl
mZ dddd d
d d gZG d
d d eZG dd dejjZdd Zdd Zdd Zdd ZG dd deZG dd deZe Zej Z ej Z ej Z ej Z ej Z e Z!dS ) a- A PEP 517 interface to setuptools
Previously, when a user or a command line tool (let's call it a "frontend")
needed to make a request of setuptools to take a certain action, for
example, generating a list of installation requirements, the frontend would
would call "setup.py egg_info" or "setup.py bdist_wheel" on the command line.
PEP 517 defines a different method of interfacing with setuptools. Rather
than calling "setup.py" directly, the frontend should:
1. Set the current directory to the directory with a setup.py file
2. Import this module into a safe python interpreter (one in which
setuptools can potentially set global variables or crash hard).
3. Call one of the functions defined in PEP 517.
What each function does is defined in PEP 517. However, here is a "casual"
definition of the functions (this definition should not be relied on for
bug reports or API stability):
- `build_wheel`: build a wheel in the folder and return the basename
- `get_requires_for_build_wheel`: get the `setup_requires` to build
- `prepare_metadata_for_build_wheel`: get the `install_requires`
- `build_sdist`: build an sdist in the folder and return the basename
- `get_requires_for_build_sdist`: get the `setup_requires` to build
Again, this is not a formal definition! Just a "taste" of the module.
N)TemporaryDirectory)parse_requirements)makedirs get_requires_for_build_sdist get_requires_for_build_wheel prepare_metadata_for_build_wheel build_wheel build_sdist
__legacy__SetupRequirementsErrorc @ s e Zd Zdd ZdS )r c C s
|| _ d S N)
specifiers)selfr
r 9/usr/lib/python3.8/site-packages/setuptools/build_meta.py__init__4 s z SetupRequirementsError.__init__N)__name__
__module__ __qualname__r r r r r r 3 s c @ s& e Zd Zdd Zeejdd ZdS ) Distributionc C s t ttt|}t|d S r )listmapstrr r )r r
Zspecifier_listr r r fetch_build_eggs9 s z Distribution.fetch_build_eggsc c s* t jj}| t j_z
dV W 5 |t j_X dS )zw
Replace
distutils.dist.Distribution with this class
for the duration of this context.
N) distutilsZcorer )clsZorigr r r patch> s
zDistribution.patchN)r r r r classmethod
contextlibcontextmanagerr r r r r r 8 s r c C s* t jd dkr&t| ts&| t S | S )z
Convert a filename to a string (on Python 2, explicitly
a byte string, not Unicode) as distutils checks for the
exact type str.
r )sys version_info
isinstancer encodegetfilesystemencoding)sr r r _to_strN s r' c s fddt D S )Nc s& g | ] }t jt j |r|qS r )ospathisdirjoin).0nameZa_dirr r
\ s z1_get_immediate_subdirectories..r( listdirr. r r. r _get_immediate_subdirectories[ s r2 c s" fddt | D }|\}|S )Nc 3 s | ]}| r|V qd S r endswithr, f extensionr r a s
z'_file_with_extension..r0 )Z directoryr8 Zmatchingfiler r7 r _file_with_extension` s
r; c C s& t j| stdS ttdt| S )Nz%from setuptools import setup; setup()open)r( r) existsioStringIOgetattrtokenizer< setup_scriptr r r _open_setup_scripti s
rD c @ s` e Zd Zdd Zdd ZdddZdd d
Zdd d Zdd
dZdd Z dddZ
dddZ dS )_BuildMetaBackendc C s |pi }| dg |S )N--global-option)
setdefaultr config_settingsr r r _fix_configs s z _BuildMetaBackend._fix_configc
C sz | |}tjd d dg |d t_z t | W 5 Q R X W n, tk
rt } z||j7 }W 5 d }~X Y nX |S )N Zegg_inforF )rJ r! argvr r run_setupr r
)r rI requirementser r r _get_build_requiresx s
z%_BuildMetaBackend._get_build_requiressetup.pyc C sD |}d}t |}| dd}W 5 Q R X tt||dt d S )N__main__z\r\nz\nexec)rD readreplacerS compilelocals)r rC __file__r r6 coder r r rM s
z_BuildMetaBackend.run_setupNc C s | |}| j|dgdS )NZwheelrN rJ rP rH r r r r s
z._BuildMetaBackend.get_requires_for_build_wheelc C s | |}| j|g dS )NrZ r[ rH r r r r s
z._BuildMetaBackend.get_requires_for_build_sdistc C s t jd d ddt|g t _| |}dd t|D }t|dkrxtt|dkrxtj |t|d }q*qxq*||krt
tj ||d | t
j |dd |d S ) NrK Z dist_infoz
--egg-basec S s g | ]}| d r|qS )z
.dist-infor3 r5 r r r r/ s
zF_BuildMetaBackend.prepare_metadata_for_build_wheel..r T)
ignore_errors)
r! rL r' rM r( r1 lenr2 r) r+ shutilZmoveZrmtree)r metadata_directoryrI Zdist_info_directoryZ
dist_infosr r r r s, z2_BuildMetaBackend.prepare_metadata_for_build_wheelc C s | |}tj|}t|dd t|dv}tjd d | d|g |d t_| t ||}tj
||}tj |rt | t
tj
||| W 5 Q R X |S )NT)exist_ok)dirrK z
--dist-dirrF )rJ r( r) abspathr r r! rL rM r; r+ r= removerename)r Z
setup_commandZresult_extensionZresult_directoryrI Z tmp_dist_dirZresult_basenameZ result_pathr r r _build_with_temp_dir s
z&_BuildMetaBackend._build_with_temp_dirc C s | dgd||S )NZ bdist_wheelz.whlre )r Zwheel_directoryrI r_ r r r r s
z _BuildMetaBackend.build_wheelc C s | dddgd||S )NZsdistz --formatsZgztarz.tar.gzrf )r Zsdist_directoryrI r r r r s
z _BuildMetaBackend.build_sdist)rQ )N)N)N)NN)N) r r r rJ rP rM r r r re r r r r r r rE q s
rE c s" e Zd ZdZd fdd Z ZS )_BuildMetaLegacyBackendaC Compatibility backend for setuptools
This is a version of setuptools.build_meta that endeavors to maintain backwards
compatibility with pre-PEP 517 modes of invocation. It exists as a temporary
bridge between the old packaging mechanism and the new packaging mechanism,
and will eventually be removed.
rQ c
sb t tj}tjtj|}|tjkr6tjd| ztt| j |d W 5 |tjd d < X d S )Nr rB )
r r! r) r( dirnamerb insertsuperrg rM )r rC Zsys_pathZ
script_dir __class__r r rM s
z!_BuildMetaLegacyBackend.run_setup)rQ )r r r __doc__rM
__classcell__r r rk r rg s rg )"rm r> r( r! rA r^ r Z
setuptoolsr Zsetuptools.py31compatr Z
pkg_resourcesr Zpkg_resources.py31compatr __all__
BaseExceptionr Zdistr r' r2 r; rD objectrE rg Z_BACKENDr r r r r r
r r r r sD
h PK ! C;b b __pycache__/_imp.cpython-38.pycnu [ U
Qab @ s\ d Z ddlZddlZddlZddlmZ dZdZdZ dZ
dZ dd d
Z dd d Z
d
d ZdS )zX
Re-implementation of find_module and get_frozen_object
from the deprecated imp module.
N )module_from_spec c C sV t j| |}|dkr"td| |jsBt|drBt jd|j}d}d}t|jt }|j
dkst|rt |jt j j
rt}d}d }}n|j
dks|rt |jt j jrt}d}d }}n|jr:|j
}tj|d }|t j jkrd
nd }|t j jkrt}n&|t j jkrt}n|t j jkr t}|tthkrFt||}n d}d }}|||||ffS ) z7Just like 'imp.find_module()', but with package supportN
Can't find %ssubmodule_search_locationsz __init__.pyfrozen zbuilt-inr rrb) importlibutil find_spec ImportError has_locationhasattrspec_from_loaderloader
isinstancetypeorigin
issubclass machineryFrozenImporter PY_FROZENBuiltinImporter C_BUILTINospathsplitextSOURCE_SUFFIXES PY_SOURCEBYTECODE_SUFFIXES PY_COMPILEDEXTENSION_SUFFIXES C_EXTENSIONopen) modulepathsspecZkindfileZstaticr! suffixmode r0 3/usr/lib/python3.8/site-packages/setuptools/_imp.py find_module sJ
r2 c C s* t j| |}|s td| |j| S Nr )r r r r r get_code)r* r+ r, r0 r0 r1 get_frozen_object> s r5 c C s& t j| |}|s td| t|S r3 )r r r r r )r* r+ infor, r0 r0 r1
get_moduleE s r7 )N)N)__doc__r importlib.utilr Zimportlib.machineryZ
py34compatr r$ r& r( r r r2 r5 r7 r0 r0 r0 r1 s
*
PK ! M]] - __pycache__/archive_util.cpython-38.opt-1.pycnu [ U
Qab @ s d Z ddlZddlZddlZddlZddlZddlZddlmZ ddl m
Z
ddddd d
d gZ G d d d eZ d
d Z
e
dfddZe
fdd Ze
fddZe
fddZeeefZdS )z/Utilities for extracting common archive formats N)DistutilsError)ensure_directoryunpack_archiveunpack_zipfileunpack_tarfiledefault_filterUnrecognizedFormatextraction_driversunpack_directoryc @ s e Zd ZdZdS )r z#Couldn't recognize the archive typeN)__name__
__module__ __qualname____doc__ r r ;/usr/lib/python3.8/site-packages/setuptools/archive_util.pyr s c C s |S )z@The default progress/filter callback; returns True for all filesr )srcdstr r r r s c C sN |pt D ]4}z|| || W n tk
r4 Y qY qX dS qtd| dS )a Unpack `filename` to `extract_dir`, or raise ``UnrecognizedFormat``
`progress_filter` is a function taking two arguments: a source path
internal to the archive ('/'-separated), and a filesystem path where it
will be extracted. The callback must return the desired extract path
(which may be the same as the one passed in), or else ``None`` to skip
that file or directory. The callback can thus be used to report on the
progress of the extraction, as well as to filter the items extracted or
alter their extraction paths.
`drivers`, if supplied, must be a non-empty sequence of functions with the
same signature as this function (minus the `drivers` argument), that raise
``UnrecognizedFormat`` if they do not support extracting the designated
archive type. The `drivers` are tried in sequence until one is found that
does not raise an error, or until all are exhausted (in which case
``UnrecognizedFormat`` is raised). If you do not supply a sequence of
drivers, the module's ``extraction_drivers`` constant will be used, which
means that ``unpack_zipfile`` and ``unpack_tarfile`` will be tried, in that
order.
Nz!Not a recognized archive type: %s)r r )filename extract_dirprogress_filterZdriversZdriverr r r r s
c C s t j| std| | d|fi}t | D ]\}}}|| \}}|D ],} || d t j|| f|t j|| < qH|D ]T}
t j||
} |||
| } | sqzt| t j||
}
t|
| t |
| qzq.dS )z"Unpack" a directory, using the same interface as for archives
Raises ``UnrecognizedFormat`` if `filename` is not a directory
z%s is not a directory /N)
ospathisdirr walkjoinr shutilZcopyfileZcopystat) r r r pathsbasedirsfilesr r dftargetr r r r
? s$ * c
C s t | std| f t | }| D ]}|j}|ds,d|dkrPq,tj j
|f|d }|||}|sxq,| drt | n4t | |
|j}t|d}|| W 5 Q R X |jd? } | r,t|| q,W 5 Q R X dS )zUnpack zip `filename` to `extract_dir`
Raises ``UnrecognizedFormat`` if `filename` is not a zipfile (as determined
by ``zipfile.is_zipfile()``). See ``unpack_archive()`` for an explanation
of the `progress_filter` argument.
z%s is not a zip filer ..wb N)zipfileZ
is_zipfiler ZZipFileZinfolistr
startswithsplitr r r endswithr readopenwriteZ
external_attrchmod)
r r r zinfonamer$ datar# Zunix_attributesr r r r Z s(
c
C sf zt | }W n$ t jk
r2 td| f Y nX t| dd |_|D ]}|j}|dsPd| dkrPt
j j |f| d }|dk r|
s| r|j}| rt|j}t ||}t|}||}q|dk rP| s| rP|||} | rP| t
jr"| dd } z||| W qP t jk
rJ Y qPX qPW 5 Q R dS Q R X dS ) zUnpack tar/tar.gz/tar.bz2 `filename` to `extract_dir`
Raises ``UnrecognizedFormat`` if `filename` is not a tarfile (as determined
by ``tarfile.open()``). See ``unpack_archive()`` for an explanation
of the `progress_filter` argument.
z/%s is not a compressed or uncompressed tar filec W s d S )Nr )argsr r r z unpack_tarfile..r r% NT)tarfiler- ZTarErrorr
contextlibclosingchownr2 r) r* r r r ZislnkZissymZlinkname posixpathdirnamenormpathZ
_getmemberisfiler r+ sepZ_extract_memberZ ExtractError)
r r r Ztarobjmemberr2 Z
prelim_dstZlinkpathr Z final_dstr r r r s:
)r r( r8 r r r< r9 Zdistutils.errorsr Z
pkg_resourcesr __all__r r r r
r r r r r r r s2
# % .PK ! 9@# # % __pycache__/pep425tags.cpython-38.pycnu [ U
Qabm* @ s d Z ddlmZ ddlZddlmZ ddlZddlZddlZddl Z ddl
Z
ddl m Z ddl
mZ ddlmZ ed Zd
d Zd d
Zdd Zdd Zdd Zd$ddZdd Zdd Zdd Zd d Z d d Z d%d"d#Z e Z dS )&z2Generate and work with PEP 425 Compatibility Tags. )absolute_importN)log) OrderedDict )six)glibcz(.+)_(\d+)_(\d+)_(.+)c
C sL z t | W S tk
rF } z td|t W Y d S d }~X Y nX d S )Nz{}) sysconfigget_config_varIOErrorwarningswarnformatRuntimeWarning)vare r 9/usr/lib/python3.8/site-packages/setuptools/pep425tags.pyr s
r c C s: t tdrd} n&tjdr"d} ntjdkr2d} nd} | S )z'Return abbreviated implementation name.pypy_version_infoppjavaZjyZcliZipcp)hasattrsysplatform
startswith)Zpyimplr r r
get_abbr_impl s
r c C s, t d} | rt dkr(dttt } | S )z Return implementation version.Zpy_version_nodotr )r r joinmapstrget_impl_version_info)Zimpl_verr r r get_impl_ver+ s r! c C s: t dkr"tjd tjjtjjfS tjd tjd fS dS )zQReturn sys.version_info-like tuple for use in decrementing the minor
version.r r r N)r r version_infor majorminorr r r r r 3 s
r c C s d t t S )z;
Returns the Tag for this specific implementation.
z{}{})r
r r! r r r r get_impl_tag> s r% Tc C s. t | }|dkr&|r td| | S ||kS )zgUse a fallback method for determining SOABI flags if the needed config
var is unset or unavailable.Nz>Config variable '%s' is unset, Python ABI tag may be incorrect)r r debug)r Zfallbackexpectedr valr r r get_flagE s r) c s t d} t | s dkrttdrd}d}d}tddd dkd rJd
}td fd d dkd rhd
}tddd d dkotjdrtjrd}d t |||f }n@| r| drd| dd }n | r|
dd
dd}nd}|S )zXReturn the ABI tag based on SOABI (if available) or emulate SOABI
(CPython 2, PyPy).ZSOABI> r r
maxunicoder ZPy_DEBUGc S s
t tdS )NZgettotalrefcount)r r r r r r [ z get_abi_tag..r )r dZ
WITH_PYMALLOCc s dkS )Nr r r implr r r+ _ r, mZPy_UNICODE_SIZEc S s
t jdkS )Ni )r r* r r r r r+ c r, )r' r uz
%s%s%s%s%szcpython--r ._N) r r r r r) r ZPY2r! r splitreplace)Zsoabir- r0 r2 abir r. r get_abi_tagQ s@
r9 c C s
t jdkS )Ni)r maxsizer r r r _is_running_32bits s r; c C s t jdkr^t \} }}| d}|dkr6t r6d}n|dkrHt rHd}d|d |d |S tj dd
d d
}|d krt rd
}|S )z0Return our platform name 'win32', 'linux_x86_64'darwinr4 x86_64i386ppc64ppczmacosx_{}_{}_{}r r r5 r3 linux_x86_64
linux_i686)
r r Zmac_verr6 r; r
distutilsutil get_platformr7 )releaser5 machineZ split_verresultr r r rE w s
rE c C sH t dkrdS zdd l} t| jW S ttfk
r: Y nX tddS )N> rA rB Fr )rE
_manylinuxboolZmanylinux1_compatible ImportErrorAttributeErrorr Zhave_compatible_glibc)rK r r r is_manylinux1_compatible s
rO c sr g } fdd t ddddg | ||r8|| D ]&}|| kr< | ||r<|| q<|d |S )zReturn a list of supported arches (including group arches) for
the given major, minor and machine architecture of a macOS machine.
c s| |dkr| |fdkS |dkr(| |fdkS |dkr<| |fdkS |dkrP| |fdkS |krx| D ]} | ||r` dS q`dS ) Nr@ )
rJ r? r> )rP r1 r= TFr )r# r$ archgarch_supports_archgroupsr r rT s z)get_darwin_arches.._supports_arch)Zfat)r> r@ )Zintel)r= r> )Zfat64)r= r? )Zfat32)r= r> r@ Z universal)r append)r# r$ rG archesrR r rS r get_darwin_arches s $
rX Fc C s g }| dkrTg } t }|dd }t|d ddD ] }| dtt||f q2|p\t }g } |pjt }|r~|g| dd< t }
ddl } |
D ],} | d dr|
| d
ddd q| tt|
| d |sT|pt }
|
d
rzt|
}|rr| \}}}}d ||}g }ttt|d D ]0}tt|||D ]}||||f qRq>n|
g}n*|dkrt r|
d d
|
g}n|
g}| D ].}|D ]"}
|d|| d f ||
f qq| dd D ]F}|dkr q,|
D ]*}|D ] }
|d||f ||
f qqq|D ]"}
|d| d d d |
f q0|d|| d f d df |d|| d d f d df t| D ]B\}}|d|f d df |dkr|d|d d df q|S )ac Return a list of supported tags for each version specified in
`versions`.
:param versions: a list of string versions, of the form ["33", "32"],
or None. The first version will be assumed to support our ABI.
:param platform: specify the exact platform you want valid
tags for, or None. If None, use the local system platform.
:param impl: specify the exact implementation you want valid
tags for, or None. If None, use the local interpreter impl.
:param abi: specify the exact abi you want valid
tags for, or None. If None, use the local interpreter abi.
Nr r z.abir4 rI r ZnoneZmacosxz {}_{}_%i_%sZlinuxZ
manylinux1z%s%s> 3031zpy%sany) r rangerV r r r r r9 setimpZ get_suffixesr addr6 extendsortedlistrE
_osx_arch_patmatchrU r
reversedintrX rO r7 enumerate)ZversionsZnoarchr r/ r8 Z supportedr" r# r$ ZabisZabi3sr_ suffixrQ re nameZ actual_archZtplrW r0 aversionir r r
get_supported sh
$
$
rn )TT)NFNNN) __doc__Z
__future__r Zdistutils.utilrC r r rer r r collectionsr Zexternr r r compilerd r r r! r r% r) r9 r; rE rO rX rn Zimplementation_tagr r r r s8
"=
`PK ! 8H , __pycache__/ssl_support.cpython-38.opt-1.pycnu [ U
Qab-! @ s d dl Z d dlZd dlZd dlZd dlZd dlmZmZmZm Z d dl
m Z m Z z d dl
Z
W n ek
rt dZ
Y nX dddddgZd ZzejjZejZW n ek
r e ZZY nX e
dk oeeefkZzd d
l
mZmZ W nR ek
r: z d d lmZ d d lmZ W n ek
r4 dZdZY nX Y nX esRG d
d de Zesjd ddZ dd ZG dd deZ G dd deZ d ddZ dd Z!e!dd Z"d d Z#d d Z$dS )! N)urllib http_clientmapfilter)ResolutionErrorExtractionErrorVerifyingHTTPSHandlerfind_ca_bundle is_available
cert_paths
opener_fora
/etc/pki/tls/certs/ca-bundle.crt
/etc/ssl/certs/ca-certificates.crt
/usr/share/ssl/certs/ca-bundle.crt
/usr/local/share/certs/ca-root.crt
/etc/ssl/cert.pem
/System/Library/OpenSSL/certs/cert.pem
/usr/local/share/certs/ca-root-nss.crt
/etc/ssl/ca-bundle.pem
)CertificateErrormatch_hostname)r
)r c @ s e Zd ZdS )r
N)__name__
__module__ __qualname__ r r :/usr/lib/python3.8/site-packages/setuptools/ssl_support.pyr
5 s r
c
C s g }| s dS | d}|d }|dd }|d}||krLtdt| |s`| | kS |dkrt|d n>|d s|d r|t| n|t| d
d |D ]}|t| qt
d d
| d tj } |
|S )zqMatching according to RFC 6125, section 6.4.3
https://tools.ietf.org/html/rfc6125#section-6.4.3
F.r r N*z,too many wildcards in certificate DNS name: z[^.]+zxn--z\*z[^.]*z\Az\.z\Z)splitcountr
reprlowerappend
startswithreescapereplacecompilejoin
IGNORECASEmatch)
ZdnhostnameZ
max_wildcardsZpatspartsZleftmostZ remainderZ wildcardsZfragZpatr r r _dnsname_match; s,
r& c C s | s t dg }| dd}|D ]*\}}|dkr t||r@ dS || q |s| ddD ]6}|D ],\}}|dkrdt||r dS || qdq\t|dkrtd |d
tt|f n*t|dkrtd ||d f ntd
dS )a= Verify that *cert* (in decoded format as returned by
SSLSocket.getpeercert()) matches the *hostname*. RFC 2818 and RFC 6125
rules are followed, but IP addresses are not accepted for *hostname*.
CertificateError is raised on failure. On success, the function
returns nothing.
zempty or no certificateZsubjectAltNamer ZDNSNZsubjectZ
commonNamer z&hostname %r doesn't match either of %sz, z hostname %r doesn't match %rr z=no appropriate commonName or subjectAltName fields were found)
ValueErrorgetr& r lenr
r! r r )Zcertr$ ZdnsnamesZsankeyvaluesubr r r r o s2
r c @ s e Zd ZdZdd Zdd ZdS )r z=Simple verifying handler: no auth, subclasses, timeouts, etc.c C s || _ t| d S N) ca_bundle HTTPSHandler__init__)selfr. r r r r0 s z VerifyingHTTPSHandler.__init__c s fdd|S )Nc s t | jf|S r- )VerifyingHTTPSConnr. )hostkwr1 r r z2VerifyingHTTPSHandler.https_open..)Zdo_open)r1 Zreqr r5 r
https_open s
z VerifyingHTTPSHandler.https_openN)r r r __doc__r0 r8 r r r r r s c @ s e Zd ZdZdd Zdd ZdS )r2 z@Simple verifying connection: no auth, subclasses, timeouts, etc.c K s t j| |f| || _d S r- )HTTPSConnectionr0 r. )r1 r3 r. r4 r r r r0 s zVerifyingHTTPSConn.__init__c C s t | j| jft| dd }t| drHt| dd rH|| _| | j}n| j}tt drxt j
| j d}|j ||d| _nt j |t j
| j d| _zt| j | W n. tk
r | jt j | j Y nX d S )NZsource_address_tunnel _tunnel_hostcreate_default_context)Zcafile)Zserver_hostname)Z cert_reqsZca_certs)socketZcreate_connectionr3 Zportgetattrhasattrsockr; r< sslr= r. Z wrap_socketZ
CERT_REQUIREDr Z getpeercertr
ZshutdownZ SHUT_RDWRclose)r1 rA Z actual_hostZctxr r r connect s.
zVerifyingHTTPSConn.connectN)r r r r9 r0 rD r r r r r2 s r2 c C s t jt| pt jS )z@Get a urlopen() replacement that uses ca_bundle for verification)r requestZ build_openerr r open)r. r r r r s c s t fdd}|S )Nc s t ds | | _ jS )Nalways_returns)r@ rG )argskwargsfuncr r wrapper s
zonce..wrapper) functoolswraps)rK rL r rJ r once s rO c sZ z dd l } W n tk
r" Y d S X G fddd| j }|d |d |jS )Nr c s, e Zd Z fddZ fddZ ZS )z"get_win_certfile..CertFilec s t | t| j d S r- )superr0 atexitregisterrC r5 CertFile __class__r r r0 s z+get_win_certfile..CertFile.__init__c s, zt | W n tk
r& Y nX d S r- )rP rC OSErrorr5 rS r r rC s z(get_win_certfile..CertFile.close)r r r r0 rC
__classcell__r rT )rU r rT s rT ZCAZROOT) wincertstore ImportErrorrT Zaddstorename)rY Z _wincertsr rX r get_win_certfile s
r\ c C s$ t tjjt} t p"t| dp"t S )z*Return an existing CA bundle path, or NoneN)r ospathisfiler r\ next_certifi_where)Zextant_cert_pathsr r r r s c
C s. zt d W S tttfk
r( Y nX d S )NZcertifi)
__import__whererZ r r r r r r ra s ra )r )N)%r] r> rQ r rM Zsetuptools.extern.six.movesr r r r Z
pkg_resourcesr r rB rZ __all__stripr r rE r/ r: AttributeErrorobjectr
r
r Z backports.ssl_match_hostnamer' r& r r2 r rO r\ r ra r r r r sZ
4)
(
PK ! yʀ ʀ ( __pycache__/package_index.cpython-38.pycnu [ U
Qab @ s d Z ddlZddlZddlZddlZddlZddlZddlZddlZddl Z ddl
m Z ddl m
Z
ddlmZmZmZmZ ddlZddlmZmZmZmZmZmZmZm Z m Z m Z m Z m Z m!Z! ddlm"Z" ddl#m$Z$ dd l%m&Z& dd
l'm(Z( dd l)m*Z* dd l+m,Z, dd
l-m.Z. e/Z0e1dZ2e1dej3Z4e1dZ5e1dej3j6Z7d8 Z9ddddgZ:dZ;dZ edZ?dd Z@d d ZAd d ZBdGd dZCdHd!d"ZDdId#d$ZEdedfd%dZFdJd&d'ZGd(d) ZHe1d*ej3ZIeHd+d, ZJG d-d. d.ZKG d/d0 d0eKZLG d1d deZMe1d2jNZOd3d4 ZPd5d6 ZQdKd7d8ZRd9d: ZSG d;d< d<ZTG d=d> d>ejUZVejWjXfd?d@ZYdAdB ZZeRe;eYZYdCdD Z[dEdF Z\dS )Lz#PyPI and direct package downloading Nwraps)six)urllib http_client configparsermap)
CHECKOUT_DIST Distribution BINARY_DISTnormalize_path SOURCE_DIST Environmentfind_distributions safe_name safe_version to_filename Requirement DEVELOP_DISTEGG_DIST) ssl_support)log)DistutilsError) translate)get_all_headers)unescape)Wheelz^egg=([-A-Za-z0-9_.+!]+)$zhref\s*=\s*['"]?([^'"> ]+)z([^<]+)\n\s+\(md5\)z([-+.a-z0-9]{2,}):z .tar.gz .tar.bz2 .tar .zip .tgz PackageIndexdistros_for_urlparse_bdist_wininstinterpret_distro_name z rP )filenamerG r& r& r' distros_for_filename s
rT c
c s| | d}|s,tdd |dd D r,dS tdt|d D ]8}t| |d|d| d||d |||dV q>dS )zGenerate alternative interpretations of a source distro name
Note: if `location` is a filesystem filename, you should call
``pkg_resources.normalize_path()`` on it before passing it to this
routine!
rJ c s s | ]}t d |V qdS )z py\d\.\d$N)rerE ).0pr& r& r' s z(interpret_distro_name.. Nr6 )
py_versionrB rQ )r9 anyrangerO r
join)rK rP rG rZ rB rQ r; rW r& r& r' r s
c c sf t }|j}|dkr:tj|j| D ]}|| |V q$n(| D ]"}||}||kr>|| |V q>dS )zHList unique elements, preserving order. Remember all elements ever seen.N)setaddr Zmoves filterfalse __contains__)iterablekeyseenZseen_addZelementkr& r& r' unique_everseen s
rf c s t fdd}|S )zs
Wrap a function returning an iterable such that the resulting iterable
only ever yields unique items.
c s t | |S N)rf )argskwargsfuncr& r' wrapper s z unique_values..wrapperr )rk rl r& rj r'
unique_values s rm z(<([^>]*\srel\s*=\s*['"]?([^'">]+)[^>]*)>c c s t |D ]d}| \}}tttj| d}d|ksDd|kr
t |D ] }t
j | t
|dV qNq
dD ]@}||}|dkrtt ||}|rtt
j | t
|dV qtdS )zEFind rel="homepage" and rel="download" links in `page`, yielding URLs,Zhomepager3 r6 )z
Home Pagez | Download URLr2 N)RELfinditergroupsr^ r strstripr+ r9 HREFr r# urljoin
htmldecoderF findsearch)r: pagerE tagZrelZrelsposr& r& r' find_external_links s
r| c @ s( e Zd ZdZdd Zdd Zdd ZdS ) ContentCheckerzP
A null content checker that defines the interface for checking content
c C s dS )z3
Feed a block of data to the hash.
Nr& selfblockr& r& r' feed s zContentChecker.feedc C s dS )zC
Check the hash. Return False if validation fails.
Tr& r r& r& r' is_valid s zContentChecker.is_validc C s dS )zu
Call reporter with information about the checker (hash name)
substituted into the template.
Nr& )r reportertemplater& r& r' report s zContentChecker.reportN)__name__
__module__ __qualname____doc__r r r r& r& r& r' r} s r} c @ sB e Zd ZedZdd Zedd Zdd Z dd Z
d
d Z d S )
HashCheckerzK(?Psha1|sha224|sha384|sha256|sha512|md5)=(?P[a-f0-9]+)c C s || _ t|| _|| _d S rg ) hash_namehashlibnewhashexpected)r r r r& r& r' __init__ s zHashChecker.__init__c C s> t j|d }|st S | j|}|s0t S | f | S )z5Construct a (possibly null) ContentChecker from a URLr2 )r r# r7 r} patternrx groupdict)clsr: r@ rE r& r& r' from_url s zHashChecker.from_urlc C s | j | d S rg )r updater~ r& r& r' r s zHashChecker.feedc C s | j | jkS rg )r Z hexdigestr r r& r& r' r " s zHashChecker.is_validc C s || j }||S rg )r )r r r msgr& r& r' r % s
zHashChecker.reportN) r r r rU compiler r classmethodr r r r r& r& r& r' r s
r c s< e Zd ZdZdJddZdKd d
ZdLd d ZdMd
dZdd Zdd Z dd Z
dd Z dNddZ dd Z
dO fdd Zd d Zd d Zd!d" Zd#d$ Zd%d& ZdPd'd(ZdQd)d*Zd+d, Zd-Zd.d/ Zd0d1 ZdRd2d3Zd4d5 Zd6d7 Z d8d9 Z d:d; Z dd?Z!d@dA Z"dBdC Z#dDdE Z$dFdG Z%dHdI Z& Z'S )Tr z;A distribution index that scans web pages for download URLshttps://pypi.org/simple/*NTc O s t j| f|| |dd |d | _i | _i | _i | _td t
t |j | _
g | _|ortjor|prt }|rt|| _n
tjj| _d S )Nr1 |)r r r, index_url scanned_urls fetched_urls
package_pagesrU r r] r r rE allowsto_scanr Z is_availableZfind_ca_bundleZ
opener_foropenerr requesturlopen)r r ZhostsZ ca_bundleZ
verify_sslrh kwZuse_sslr& r& r' r - s
zPackageIndex.__init__Fc C s || j kr|sdS d| j |< t|s2| | dS tt|}|r\| |sPdS | d| |sn|rn|| jkrtt| j | dS | |sd| j|< dS |
d| d| j|< d}| ||| }|dkrdS d| j|j < d|j
dd kr | dS |j }| }t|tsNt|tjjr0d }n|j
d
p@d }||d }| t|D ](} tj |t | d }
| |
q`| | j!rt"|d
ddkr| #||}dS )z existswarnisdirrealpathlistdirr r] rT r r r r_ )r fnnestedr> itemr r& r& r' r u s z PackageIndex.process_filenamec C sb t |}|o |d dk}|s8| tj|d r entryr& r& r' rX s
z.PackageIndex.scan_egg_links..)filterrR r> r r itertoolsstarmap
scan_egg_link)r Z search_pathdirsZ egg_linksr& r& r' scan_egg_links s
zPackageIndex.scan_egg_linksc C s t tj|| }ttd ttj|}W 5 Q R X t |dkrDd S |\}}t
tj||D ](}tjj|f| |_ t |_
| | q^d S )NrY )openrR r> r] r r r rr rs rO r rK r
rB r_ )r r> r Z raw_lineslinesZegg_pathZ
setup_pathrH r& r& r' r s zPackageIndex.scan_egg_linkc
s fdd}t |D ]:}z |tj|t|d W q tk
rN Y qX q||\}}|rt||D ]H}t |\}} |
dr| s|r|d||f 7 }n
| | qlt
dd |S dS d S )
z#Process the contents of a PyPI pagec s | jrtttjj| t jd d}t|dkrd|d krt |d }t
|d }d j |
i | < t|t|fS dS )Nr1 rY r5 r6 r T)NN)r- r r r r r# r8 rO r9 r r r
setdefaultr+ r )r r; pkgverr r& r' scan s z(PackageIndex.process_index..scanr6 .pyz
#egg=%s-%sc S s d| ddd S )Nz%sr6 rY )rF )mr& r& r' z,PackageIndex.process_index..r N)rt rp r r# ru rv rF r$ r| rA r, need_version_infoscan_urlPYPI_MD5sub)
r r: ry r rE r r new_urlr/ fragr& r r' r s(
zPackageIndex.process_indexc C s | d| d S )NzPPage at %s links to .py file(s) without version info; an index scan is required.)scan_allr r: r& r& r' r s z PackageIndex.need_version_infoc G s: | j | jkr*|r | j|f| | d | | j d S )Nz6Scanning index of all packages (this may take a while))r r r r r r r rh r& r& r' r s zPackageIndex.scan_allc C sz | | j|j d | j|js:| | j|j d | j|jsR| | t| j|jdD ]}| | qfd S )Nr1 r& ) r r unsafe_namer r rc rL not_found_in_indexr )r requirementr: r& r& r'
find_packages s
zPackageIndex.find_packagesc sR | | | | |j D ]"}||kr0| S | d|| q tt| ||S )Nz%s does not match %s)prescanr rc r superr obtain)r r Z installerrH __class__r& r' r s
zPackageIndex.obtainc C sL | | jd| | sH| t| td|jjtj
|f dS )z-
checker is a ContentChecker
z Validating %%s checksum for %sz7%s validation failed for %s; possible download problem?N) r r r r rR unlinkr r r. r> rP )r checkerrS tfpr& r& r'
check_hash s
zPackageIndex.check_hashc C sN |D ]D}| j dks0t|r0|ds0tt|r<| | q| j | qdS )z;Add `urls` to the list that will be prescanned for searchesNfile:)r r r- r r r append)r Zurlsr: r& r& r' add_find_links s
zPackageIndex.add_find_linksc C s" | j rtt| j| j d| _ dS )z7Scan urls scheduled for prescanning (e.g. --find-links)N)r r r r r r& r& r' r s zPackageIndex.prescanc C s< | |j r| jd }}n | jd }}|||j | d S )Nz#Couldn't retrieve index page for %rz3Couldn't find index page for %r (maybe misspelled?))rc r r r r )r r Zmethr r& r& r' r # s
z PackageIndex.not_found_in_indexc C s~ t |tsjt|}|rR| |d||}t|\}}|drN| |||}|S tj
|rb|S t |}t |
||ddS )a Locate and/or download `spec` to `tmpdir`, returning a local path
`spec` may be a ``Requirement`` object, or a string containing a URL,
an existing local filename, or a project/version requirement spec
(i.e. the string form of a ``Requirement`` object). If it is the URL
of a .py file with an unambiguous ``#egg=name-version`` tag (i.e., one
that escapes ``-`` as ``_`` throughout), a trivial ``setup.py`` is
automatically created alongside the downloaded file.
If `spec` is a ``Requirement`` object or a string containing a
project/version requirement spec, this method returns the location of
a matching distribution (possibly after downloading it to `tmpdir`).
If `spec` is a locally existing file or directory name, it is simply
returned unchanged. If `spec` is a URL, it is downloaded to a subpath
of `tmpdir`, and the local filename is returned. Various errors may be
raised if a problem occurs during downloading.
r6 r rK N)r r r
_download_urlrF rA r, gen_setuprR r> r r( r fetch_distribution)r r% tmpdirr< foundr/ r@ r& r& r' r3 - s
zPackageIndex.downloadc s d| i d}d
fdd }|rH | ||}|s^|dk r^|||}|dkrjdk rx ||}|dkr|s| ||}|dkrdrdpd| n d| |j|jd S dS ) a| Obtain a distribution suitable for fulfilling `requirement`
`requirement` must be a ``pkg_resources.Requirement`` instance.
If necessary, or if the `force_scan` flag is set, the requirement is
searched for in the (online) package index as well as the locally
installed packages. If a distribution matching `requirement` is found,
the returned distribution's ``location`` is the value you would have
gotten from calling the ``download()`` method with the matching
distribution's URL or filename. If no matching distribution is found,
``None`` is returned.
If the `source` flag is set, only source distributions and source
checkout links will be considered. Unless the `develop_ok` flag is
set, development and system eggs (i.e., those using the ``.egg-info``
format) will be ignored.
zSearching for %sNc s |d kr }|| j D ]v}|jtkrF sF|krd| d|< q|| ko\|jtkp\ }|r|j}||_tj
|jr| S qd S )Nz&Skipping development or system egg: %sr6 ) rc rB r r r
r3 rK download_locationrR r> r )ZreqenvrH ZtestZloc
develop_okr Zskippedsourcer r& r' rw g s& z-PackageIndex.fetch_distribution..findz:No local packages or working download links found for %s%sza source distribution of r zBest match: %s)rK )N)r r r r r Zcloner ) r r r
force_scanr r Z local_indexrH rw r& r r' r O s2
z PackageIndex.fetch_distributionc C s" | ||||}|dk r |jS dS )a3 Obtain a file suitable for fulfilling `requirement`
DEPRECATED; use the ``fetch_distribution()`` method now instead. For
backward compatibility, this routine is identical but returns the
``location`` of the downloaded distribution instead of a distribution
object.
N)r rK )r r r r r rH r& r& r' fetch s zPackageIndex.fetchc
C s t |}|r*dd t||dd D p,g }t|dkrtj|}tj||krtj ||}ddl
m } |||st
|| |}ttj |dd2} | d|d j|d jtj|d f W 5 Q R X |S |rtd ||f ntd
d S ) Nc S s g | ]}|j r|qS r& )rM )rV dr& r& r'
s z*PackageIndex.gen_setup..r6 r )samefilezsetup.pywzIfrom setuptools import setup
setup(name=%r, version=%r, py_modules=[%r])
zCan't unambiguously interpret project/version identifier %r; any dashes in the name or version should be escaped using underscores. %rzpCan't process plain .py files without an '#egg=name-version' suffix to enable automatic setup script generation.)rD rE r rF rO rR r> rP dirnamer] Z setuptools.command.easy_installr shutilZcopy2r writerL rM splitextr )
r rS r@ r rE r rP Zdstr r r& r& r' r sB
zPackageIndex.gen_setupi c C s | d| d }zt|}| |}t|tjjrJt d||j
|j f | }d}| j }d}d|krt
|d} ttt| }| ||||| t|dV}
||} | r|| |
| |d7 }| ||||| qqq| |||
W 5 Q R X |W S |r| X d S ) NzDownloading %szCan't download %s: %s %sr r2 zcontent-lengthzContent-Lengthwbr6 )r r r r r r r r r r r r dl_blocksizer maxr int
reporthookr r r r
r ) r r: rS fpr r blocknumZbssizeZsizesr r r& r& r' _download_to s:
zPackageIndex._download_toc C s d S rg r& )r r: rS r Zblksizer r& r& r' r s zPackageIndex.reporthookc
C s | drt|S zt|| jW S ttjfk
r } z.z%s %szDownload error for %s: %sz;%s returned a bad status line. The server might be down, %s)r-
local_openopen_with_authr r$ r
InvalidURLr] rh r r r r r ZURLErrorreasonZ
BadStatusLinelineZ
HTTPExceptionsocket)r r: Zwarningvr r& r& r' r s>
"zPackageIndex.open_urlc C s t |\}}|r0d|kr4|dddd}qnd}|drJ|d d }tj||}|dksj|d rv| ||S |d
ks|d r| ||S |d r| ||S |d
krt
j t
j
|d S | |d | ||S d S )Nz...\_Z__downloaded__rI r* Zsvnzsvn+Zgitzgit+zhg+r rY T)rA replacer, rR r> r] r-
_download_svn
_download_git _download_hgr r url2pathnamer# r7 r _attempt_download)r r< r: r r. r@ rS r& r& r' r s$
zPackageIndex._download_urlc C s | |d d S )NT)r r r& r& r' r : s zPackageIndex.scan_urlc C s6 | ||}d|dd kr.| |||S |S d S )Nr r r )r r r+ _download_html)r r: rS r r& r& r' r) = s z PackageIndex._attempt_downloadc C sn t |}|D ]>}| r td|rF| t| | || S qLq | t| td| d S )Nz ([^- ]+ - )?Revision \d+:z Unexpected HTML page found at ) r rs rU rx r rR r r% r )r r: r rS r r r& r& r' r* D s
zPackageIndex._download_htmlc C s t dt |ddd }d}| drd|krtj|\}}}}}} |s|drd |d
d kr|d
d d d\}}t |\}
} |
rd |
kr|
d d\} }
d | |
f }nd
|
}| }|||||| f}tj
|}| d|| t
d|||f |S )Nz"SVN download support is deprecatedr5 r6 r r zsvn:@z//r1 rY :z --username=%s --password=%sz --username=z'Doing subversion checkout from %s to %szsvn checkout%s -q %s %s)warningsr UserWarningr9 r+ r- r r# r7
_splituser
urlunparser rR system)r r: rS Zcredsr< netlocr> rW qr authhostuserZpwr; r& r& r' r% S s& zPackageIndex._download_svnc C sp t j| \}}}}}|ddd }|ddd }d }d|krR|dd\}}t j||||df} | |fS )N+r6 r2 r5 r r+ r )r r# Zurlsplitr9 rsplitZ
urlunsplit)r:
pop_prefixr< r2 r> r? r revr& r& r' _vcs_split_rev_from_urli s z$PackageIndex._vcs_split_rev_from_urlc C sl | ddd }| j|dd\}}| d|| td||f |d k rh| d| td ||f |S )
Nr5 r6 r Tr9 z Doing git clone from %s to %szgit clone --quiet %s %szChecking out %sz git -C %s checkout --quiet %sr9 r; r rR r1 r r: rS r: r& r& r' r& { s zPackageIndex._download_gitc C sl | ddd }| j|dd\}}| d|| td||f |d k rh| d| td ||f |S )
Nr5 r6 r Tr< z Doing hg clone from %s to %szhg clone --quiet %s %szUpdating to %szhg --cwd %s up -C -r %s -qr= r> r& r& r' r' s zPackageIndex._download_hgc G s t j|f| d S rg )r r r r& r& r' r s zPackageIndex.debugc G s t j|f| d S rg )r r r r& r& r' r s zPackageIndex.infoc G s t j|f| d S rg )r r r r& r& r' r s zPackageIndex.warn)r r NT)F)F)F)N)N)FFFN)FF)N)F)(r r r r r r r r r r r r r r r r r r r r3 r r r r r r r r r r) r* r% staticmethodr; r& r' r r r
__classcell__r& r& r r' r * sX
3
+
#
L
)$
# z!&(#(\d+|x[\da-fA-F]+)|[\w.:-]+);?c C s | d}t|S )Nr )rF r )rE Zwhatr& r& r'
decode_entity s
rA c C s
t t| S )a
Decode HTML entities in the given text.
>>> htmldecode(
... 'https://../package_name-0.1.2.tar.gz'
... '?tokena=A&tokenb=B">package_name-0.1.2.tar.gz')
'https://../package_name-0.1.2.tar.gz?tokena=A&tokenb=B">package_name-0.1.2.tar.gz'
)
entity_subrA )textr& r& r' rv s rv c s fdd}|S )Nc s fdd}|S )Nc s2 t }t z | |W S t | X d S rg )r ZgetdefaulttimeoutZsetdefaulttimeout)rh ri Z old_timeout)rk timeoutr& r' _socket_timeout s
z@socket_timeout.<locals>._socket_timeout.<locals>._socket_timeoutr& )rk rE rD rj r' rE s z'socket_timeout.<locals>._socket_timeoutr& )rD rE r& rF r' socket_timeout s rG c C s2 t j| }| }t|}| }|ddS )aq
A function compatible with Python 2.3-3.3 that will encode
auth from a URL suitable for an HTTP header.
>>> str(_encode_auth('username%3Apassword'))
'dXNlcm5hbWU6cGFzc3dvcmQ='
Long auth strings should not cause a newline to be inserted.
>>> long_auth = 'username:' + 'password'*10
>>> chr(10) in str(_encode_auth(long_auth))
False
r )r r# r8 encodebase64Z b64encoder r$ )r4 Zauth_sZ
auth_bytesZ
encoded_bytesZencodedr& r& r' _encode_auth s
rK c @ s( e Zd ZdZdd Zdd Zdd ZdS )
Credentialz:
A username/password pair. Use like a namedtuple.
c C s || _ || _d S rg usernamepassword)r rN rO r& r& r' r s zCredential.__init__c c s | j V | jV d S rg rM r r& r& r' __iter__ s zCredential.__iter__c C s dt | S )Nz%(username)s:%(password)s)varsr r& r& r' __str__ s zCredential.__str__N)r r r r r rP rR r& r& r& r' rL s rL c @ s0 e Zd Zdd Zedd Zdd Zdd Zd S )
PyPIConfigc C sP t dddgd}tj| | tjtjdd}tj |rL|
| dS )z%
Load from ~/.pypirc
rN rO
repositoryr ~z.pypircN) dictfromkeysr RawConfigParserr rR r> r]
expanduserr r )r defaultsZrcr& r& r' r s
zPyPIConfig.__init__c s& fdd D }tt j|S )Nc s g | ]} |d r|qS )rT )r rs )rV sectionr r& r' r s z2PyPIConfig.creds_by_repository.<locals>.<listcomp>)ZsectionsrV r _get_repo_cred)r Zsections_with_repositoriesr& r r' creds_by_repository s
z PyPIConfig.creds_by_repositoryc C s6 | |d }|t| |d | |d fS )NrT rN rO )r rs rL )r r[ Zrepor& r& r' r\ s
zPyPIConfig._get_repo_credc C s* | j D ]\}}||r
| S q
dS )z
If the URL indicated appears to be a repository defined in this
config, return the credential for that repository.
N)r] itemsr- )r r: rT credr& r& r' find_credential
s
zPyPIConfig.find_credentialN)r r r r propertyr] r\ r` r& r& r& r' rS s
rS c C s: t j| }|\}}}}}}|dr0td|dkrFt|\} }
nd} | s~t | } | r~t | } | j
| f} t j d | | rdt
| } ||
||||f}
t j|
}t j|}|d| n t j| }|dt ||}| r6t j|j\}}}}}}||kr6||
kr6||||||f}
t j|
|_|S )
z4Open a urllib2 request, handling HTTP authenticationr, znonnumeric port: '')ZhttpZhttpsN*Authenticating as %s for %s (from .pypirc)zBasic Z
Authorizationz
User-Agent)rb )r r# r7 r, r r r/ rS r` rr rN r r rK r0 r ZRequestZ
add_header
user_agentr: )r: r Zparsedr< r2 r> Zparamsr? r r4 Zaddressr_ r r; r r r s2Zh2Zpath2Zparam2Zquery2Zfrag2r& r& r' r s8
r c C s | d\}}} |r|nd| fS )zJsplituser('user[:passwd]@host[:port]') --> 'user[:passwd]', 'host[:port]'.r+ N)
rpartition)r5 r6 Zdelimr& r& r' r/ F s r/ c C s | S rg r& )r: r& r& r'
fix_sf_urlP s rf c
C s t j| \}}}}}}t j|}tj|r<t j| S | drtj
|rg }t |D ]d} tj || }
| dkrt
|
d} | } W 5 Q R X qntj
|
r| d7 } |dj| d q`d}
|
j| d |d} d \}}n
d
\}}} d d i}t| }t j| ||||S )
z7Read a local path, with special support for directoriesr1 z
index.htmlrz<a href="{name}">{name}</a>)r. zB<html><head><title>{url}{files} |