def install_into(self, target):
"""
Installs a wheel as a self contained distribution into target
"""
basename = os.path.splitext(os.path.basename(self.wheel.filename))[0]
distname = basename + self._dist_extension
location = os.path.join(target, distname)
distinfo_location = os.path.join(location, self.wheel.distinfo_name)
# drop everything inside the .dist-info directory, keyed by section
# name, except the code itself:
overrides = {
key: (location if key in ('platlib', 'purelib')
else os.path.join(distinfo_location, key))
for key in distutils.command.install.SCHEME_KEYS
}
self.wheel.install(overrides=overrides)
# Fix namespaces missing __init__ for Python 2 since we're not feeding
# the wheel dirs to `site.addsitedir()` and so Python will ignore .pth
# files in the wheel dirs.
metadata = pkg_resources.PathMetadata(
location, os.path.join(location, self.wheel.distinfo_name)
)
dist = self.distribution(location, metadata=metadata)
if (sys.version_info < (3, 3) and
metadata.has_metadata('namespace_packages.txt')):
self._plant_namespace_declarations(dist)
return dist
def run(self):
if os.name != 'nt':
get_script_args = override_get_script_args
else:
get_script_args = easy_install.get_script_args
import distutils.command.install_scripts
self.run_command("egg_info")
if self.distribution.scripts:
# run first to set up self.outfiles
distutils.command.install_scripts.install_scripts.run(self)
else:
self.outfiles = []
if self.no_ep:
# don't install entry point scripts into .egg file!
return
ei_cmd = self.get_finalized_command("egg_info")
dist = pkg_resources.Distribution(
ei_cmd.egg_base,
pkg_resources.PathMetadata(ei_cmd.egg_base, ei_cmd.egg_info),
ei_cmd.egg_name,
ei_cmd.egg_version,
)
bs_cmd = self.get_finalized_command('build_scripts')
executable = getattr(bs_cmd, 'executable', easy_install.sys_executable)
is_wininst = getattr(self.get_finalized_command("bdist_wininst"),
'_is_running', False)
for args in get_script_args(dist, executable, is_wininst):
self.write_script(*args)
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')
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(map(raw_req, dist.requires()))
extras_require = {
extra: [
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,
), )
# Temporarily disable info traces.
log_threshold = log._global_log.threshold
log.set_threshold(log.WARN)
try:
write_requirements(
setup_dist.get_command_obj('egg_info'),
None,
os.path.join(egg_info, 'requires.txt'),
)
finally:
log.set_threshold(log_threshold)
def get_metadata(path, pkg_name=None):
if pkg_name:
pkg_name = packaging.utils.canonicalize_name(pkg_name)
egg_dir = next(iter(find_egginfo(path, pkg_name=pkg_name)), None)
if egg_dir is not None:
import pkg_resources
egg_dir = os.path.abspath(egg_dir.path)
base_dir = os.path.dirname(egg_dir)
path_metadata = pkg_resources.PathMetadata(base_dir, egg_dir)
dist = next(
iter(pkg_resources.distributions_from_metadata(path_metadata.egg_info)),
None,
)
if dist:
requires = dist.requires()
dep_map = dist._build_dep_map()
deps = []
for k in dep_map.keys():
if k is None:
deps.extend(dep_map.get(k))
continue
else:
_deps = dep_map.get(k)
k = k.replace(":", "; ")
_deps = [
pkg_resources.Requirement.parse("{0}{1}".format(str(req), k))
for req in _deps
]
deps.extend(_deps)
return {
"name": dist.project_name,
"version": dist.version,
"requires": requires,
}
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"),
)
def __init__(self, *args, **kwargs):
ext_dir = pkg_resources.normalize_path('build_ext')
dist = pkg_resources.Distribution(ext_dir,
project_name='build_ext',
metadata=pkg_resources.PathMetadata(
ext_dir, ext_dir))
pkg_resources.working_set.add(dist)
Flake8.__init__(self, *args, **kwargs)
def _build_egg_info(name, extractor, setup_file):
temp_tar = tempfile.mkdtemp()
extractor.extract(temp_tar)
extracted_setup_py = os.path.join(temp_tar, setup_file)
LOG.info("Building egg info for %s", extracted_setup_py)
try:
setup_dir = os.path.dirname(extracted_setup_py)
output = _run_with_output(
[
sys.executable,
"-c",
SETUPTOOLS_SHIM % extracted_setup_py,
"egg_info",
"--egg-base",
setup_dir,
],
cwd=setup_dir,
timeout=EGG_INFO_TIMEOUT,
)
try:
egg_info_dir = [
egg_info
for egg_info in os.listdir(setup_dir)
if egg_info.endswith(".egg-info")
][0]
metadata = pkg_resources.PathMetadata(
setup_dir, os.path.join(setup_dir, egg_info_dir)
)
pkg_dist = PkgResourcesDistInfo(
pkg_resources.Distribution(
setup_dir, project_name=name, metadata=metadata
)
)
return pkg_dist
except IndexError:
LOG.error(
"Failed to build .egg-info %s:\n%s", list(os.listdir(setup_dir)), output
)
except subprocess.CalledProcessError as ex:
LOG.warning(
'Failed to build egg-info for %s:\nThe command "%s" produced:\n%s',
name,
subprocess.list2cmdline(ex.cmd),
ex.output,
)
try:
return _build_wheel(name, os.path.dirname(extracted_setup_py))
finally:
shutil.rmtree(temp_tar)
def get_metadata(path, pkg_name=None):
if pkg_name:
pkg_name = packaging.utils.canonicalize_name(pkg_name)
egg_dir = next(iter(find_egginfo(path, pkg_name=pkg_name)), None)
if egg_dir is not None:
import pkg_resources
egg_dir = os.path.abspath(egg_dir.path)
base_dir = os.path.dirname(egg_dir)
path_metadata = pkg_resources.PathMetadata(base_dir, egg_dir)
dist = next(
iter(
pkg_resources.distributions_from_metadata(
path_metadata.egg_info)),
None,
)
if dist:
try:
requires = dist.requires()
except exception:
requires = []
try:
dep_map = dist._build_dep_map()
except Exception:
dep_map = {}
deps = []
extras = {}
for k in dep_map.keys():
if k is None:
deps.extend(dep_map.get(k))
continue
else:
extra = None
_deps = dep_map.get(k)
if k.startswith(":python_version"):
marker = k.replace(":", "; ")
else:
marker = ""
extra = "{0}".format(k)
_deps = [
pkg_resources.Requirement.parse("{0}{1}".format(
str(req), marker)) for req in _deps
]
if extra:
extras[extra] = _deps
else:
deps.extend(_deps)
return {
"name": dist.project_name,
"version": dist.version,
"requires": requires,
"extras": extras
}
def install_for_development(self):
if not six.PY2 and getattr(self.distribution, "use_2to3", False):
# If we run 2to3 we can not do this inplace:
# Ensure metadata is up-to-date
self.reinitialize_command("build_py", inplace=0)
self.run_command("build_py")
bpy_cmd = self.get_finalized_command("build_py")
build_path = pkg_resources.normalize_path(bpy_cmd.build_lib)
# Build extensions
self.reinitialize_command("egg_info", egg_base=build_path)
self.run_command("egg_info")
self.reinitialize_command("build_ext", inplace=0)
self.run_command("build_ext")
# Fixup egg-link and easy-install.pth
ei_cmd = self.get_finalized_command("egg_info")
self.egg_path = build_path
self.dist.location = build_path
# XXX
self.dist._provider = pkg_resources.PathMetadata(
build_path, ei_cmd.egg_info
)
else:
# Without 2to3 inplace works fine:
self.run_command("egg_info")
# Build extensions in-place
self.reinitialize_command("build_ext", inplace=1)
self.run_command("build_ext")
self.install_site_py() # ensure that target dir is site-safe
if setuptools.bootstrap_install_from:
self.easy_install(setuptools.bootstrap_install_from)
setuptools.bootstrap_install_from = None
self.install_namespaces()
# create an .egg-link in the installation dir, pointing to our egg
log.info("Creating %s (link to %s)", self.egg_link, self.egg_base)
if not self.dry_run:
with open(self.egg_link, "w") as f:
f.write(self.egg_path + "\n" + self.setup_path)
# postprocess the installed distro, fixing up .pth, installing scripts,
# and handling requirements
self.process_distribution(None, self.dist, not self.no_deps)
def preinitialize(self):
by_require = self.pdist_fname and os.path.exists(self.pdist_fname)
distributions = self.product_distributions()
working_set = pkg_resources.working_set
for distribution in distributions:
if is_zip_safe_distribution(distribution):
working_set.add(distribution)
else:
if os.path.isdir(distribution.location):
# already a directory
working_set.add(distribution)
continue
# if it's not zip-safe and not already a directory, blast
# it out to a dir and create new distro out of the
# file-based egg
if by_require: # these get added to the working set in req mode
remove_distribution_from_working_set(distribution)
explodedDir = self.ensureExplodedDir(distribution.project_name)
self.exploded_dirs.append(explodedDir)
eggname = os.path.basename(distribution.location)
eggdir = os.path.join(explodedDir, eggname)
if not os.path.isdir(eggdir):
os.makedirs(eggdir)
timestamp = os.path.join(explodedDir, 'timestamp-%s' % eggname)
if not os.path.isfile(timestamp) or \
os.path.getmtime(distribution.location) > os.path.getmtime(timestamp):
un = unzip.unzip()
un.extract(distribution.location, eggdir)
f = open(timestamp, 'w')
f.close()
atime = os.path.getatime(distribution.location)
mtime = os.path.getmtime(distribution.location)
os.utime(timestamp, (atime, mtime))
metadata = pkg_resources.PathMetadata(
eggdir, os.path.join(eggdir, 'EGG-INFO'))
new_distro = pkg_resources.Distribution.from_filename(
eggdir, metadata=metadata)
working_set.add(new_distro)
self.pre_initialized = True
def run(self):
import distutils.command.install_scripts
self.run_command("egg_info")
if self.distribution.scripts:
# run first to set up self.outfiles
distutils.command.install_scripts.install_scripts.run(self)
else:
self.outfiles = []
ei_cmd = self.get_finalized_command("egg_info")
dist = pkg_resources.Distribution(
ei_cmd.egg_base,
pkg_resources.PathMetadata(ei_cmd.egg_base, ei_cmd.egg_info),
ei_cmd.egg_name, ei_cmd.egg_version,
)
bs_cmd = self.get_finalized_command('build_scripts')
executable = getattr(
bs_cmd, 'executable', easy_install.sys_executable)
is_wininst = getattr(
self.get_finalized_command("bdist_wininst"), '_is_running', False
)
if 'bdist_wheel' in self.distribution.have_run:
# We're building a wheel which has no way of generating mod_wsgi
# scripts for us. Let's build them.
# NOTE(sigmavirus24): This needs to happen here because, as the
# comment below indicates, no_ep is True when building a wheel.
self._make_wsgi_scripts_only(dist, executable, is_wininst)
if self.no_ep:
# no_ep is True if we're installing into an .egg file or building
# a .whl file, in those cases, we do not want to build all of the
# entry-points listed for this package.
return
if os.name != 'nt':
get_script_args = override_get_script_args
else:
get_script_args = easy_install.get_script_args
executable = '"%s"' % executable
for args in get_script_args(dist, executable, is_wininst):
self.write_script(*args)
def __init__(self, distribution=None, location=None, importer=None):
"""
Constructs the WheelDistribution
"""
if distribution is not None and location is not None:
raise self.Error("location and distribution cannot both be set")
if distribution is not None:
self.distribution = distribution
else:
# Construct the metadata provider
if self.is_wheel_archive(location):
importer = importer or zipimport.zipimporter(location)
metadata = WheelMetadata(importer)
else:
root = os.path.dirname(location)
metadata = pkg_resources.PathMetadata(root, location)
project_name, version, py_version, platform = [None] * 4
match = self.WHEEL_INFO_RE(os.path.basename(metadata.egg_info))
if match:
project_name, version, py_version, platform = match.group(
"name", "ver", "pyver", "plat"
)
py_version = py_version or sys.version_info[0]
self.distribution = pkg_resources.DistInfoDistribution(
location,
metadata,
project_name=project_name,
version=version,
py_version=py_version,
platform=platform,
)
# self.distribution.egg_info is the only reliable way to get the name.
# I'm not sure if egg_info is a public interface, but we already rely
# on it for WheelMetadata.
wheel_info = os.path.basename(self.distribution.egg_info)
parsed_filename = self.WHEEL_INFO_RE(wheel_info)
if parsed_filename is None:
raise self.Error("Bad wheel '%s'" % wheel_info)
self.name, self.ver, self.namever = parsed_filename.group(
"name", "ver", "namever"
)
def finalize_options(self):
ei = self.get_finalized_command("egg_info")
if ei.broken_egg_info:
template = "Please rename %r to %r before using 'develop'"
args = ei.egg_info, ei.broken_egg_info
raise DistutilsError(template % args)
self.args = [ei.egg_name]
easy_install.finalize_options(self)
self.expand_basedirs()
self.expand_dirs()
# pick up setup-dir .egg files only: no .egg-info
self.package_index.scan(glob.glob("*.egg"))
egg_link_fn = ei.egg_name + ".egg-link"
self.egg_link = os.path.join(self.install_dir, egg_link_fn)
self.egg_base = ei.egg_base
if self.egg_path is None:
self.egg_path = os.path.abspath(ei.egg_base)
target = pkg_resources.normalize_path(self.egg_base)
egg_path = pkg_resources.normalize_path(
os.path.join(self.install_dir, self.egg_path)
)
if egg_path != target:
raise DistutilsOptionError(
"--egg-path must be a relative path from the install"
" directory to " + target
)
# Make a distribution for the package's source
self.dist = pkg_resources.Distribution(
target,
pkg_resources.PathMetadata(target, os.path.abspath(ei.egg_info)),
project_name=ei.egg_name,
)
self.setup_path = self._resolve_setup_path(
self.egg_base,
self.install_dir,
self.egg_path,
)
def get_metadata(path, pkg_name=None, metadata_type=None):
# type: (S, Optional[S], Optional[S]) -> Dict[S, Union[S, List[RequirementType], Dict[S, RequirementType]]]
metadata_dirs = []
wheel_allowed = metadata_type == "wheel" or metadata_type is None
egg_allowed = metadata_type == "egg" or metadata_type is None
egg_dir = next(iter(find_egginfo(path, pkg_name=pkg_name)), None)
dist_dir = next(iter(find_distinfo(path, pkg_name=pkg_name)), None)
if dist_dir and wheel_allowed:
metadata_dirs.append(dist_dir)
if egg_dir and egg_allowed:
metadata_dirs.append(egg_dir)
matched_dir = next(iter(d for d in metadata_dirs if d is not None), None)
metadata_dir = None
base_dir = None
if matched_dir is not None:
import pkg_resources
metadata_dir = os.path.abspath(matched_dir.path)
base_dir = os.path.dirname(metadata_dir)
dist = None
distinfo_dist = None
egg_dist = None
if wheel_allowed and dist_dir is not None:
distinfo_dist = next(
iter(pkg_resources.find_distributions(base_dir)), None)
if egg_allowed and egg_dir is not None:
path_metadata = pkg_resources.PathMetadata(base_dir, metadata_dir)
egg_dist = next(
iter(
pkg_resources.distributions_from_metadata(
path_metadata.egg_info)),
None,
)
dist = next(
iter(d for d in (distinfo_dist, egg_dist) if d is not None), None)
if dist is not None:
return get_metadata_from_dist(dist)
return {}
def preinitialize(self):
by_require = self.pdist_fname and os.path.exists(self.pdist_fname)
if by_require:
distributions = self.product_distributions_by_require()
else:
distributions = self.product_distributions_by_dwim()
working_set = pkg_resources.working_set
for distribution in distributions:
if is_zip_safe_distribution(distribution):
working_set.add(distribution)
else:
if os.path.isdir(distribution.location):
# already a directory
working_set.add(distribution)
continue
# if it's not zip-safe and not already a directory, blast
# it out to a tempdir and create new distro out of the
# file-based egg; we delete the tempdir at system exit
if by_require: # these get added to the working set in req mode
remove_distribution_from_working_set(distribution)
tempdir = tempfile.mkdtemp()
eggname = os.path.basename(distribution.location)
eggdir = os.path.join(tempdir, eggname)
os.makedirs(eggdir)
self.tempdirs.append(tempdir)
un = unzip.unzip()
un.extract(distribution.location, eggdir)
metadata = pkg_resources.PathMetadata(
eggdir, os.path.join(eggdir, 'EGG-INFO'))
new_distro = pkg_resources.Distribution.from_filename(
eggdir, metadata=metadata)
working_set.add(new_distro)
self.pre_initialized = True
def fetch_build_egg(dist, req):
"""Fetch an egg needed for building.
Use pip/wheel to fetch/build a wheel."""
# Check pip is available.
try:
pkg_resources.get_distribution('pip')
except pkg_resources.DistributionNotFound:
dist.announce(
'WARNING: The pip package is not available, falling back '
'to EasyInstall for handling setup_requires/test_requires; '
'this is deprecated and will be removed in a future version.',
log.WARN
)
return _legacy_fetch_build_egg(dist, req)
# Warn if wheel is not.
try:
pkg_resources.get_distribution('wheel')
except pkg_resources.DistributionNotFound:
dist.announce('WARNING: The wheel package is not available.', log.WARN)
# Ignore environment markers; if supplied, it is required.
req = strip_marker(req)
# Take easy_install options into account, but do not override relevant
# pip environment variables (like PIP_INDEX_URL or PIP_QUIET); they'll
# take precedence.
opts = dist.get_option_dict('easy_install')
if 'allow_hosts' in opts:
raise DistutilsError('the `allow-hosts` option is not supported '
'when using pip to install requirements.')
if 'PIP_QUIET' in os.environ or 'PIP_VERBOSE' in os.environ:
quiet = False
else:
quiet = True
if 'PIP_INDEX_URL' in os.environ:
index_url = None
elif 'index_url' in opts:
index_url = opts['index_url'][1]
else:
index_url = None
if 'find_links' in opts:
find_links = _fixup_find_links(opts['find_links'][1])[:]
else:
find_links = []
if dist.dependency_links:
find_links.extend(dist.dependency_links)
eggs_dir = os.path.realpath(dist.get_egg_cache_dir())
environment = pkg_resources.Environment()
for egg_dist in pkg_resources.find_distributions(eggs_dir):
if egg_dist in req and environment.can_add(egg_dist):
return egg_dist
with TemporaryDirectory() as tmpdir:
cmd = [
sys.executable, '-m', 'pip',
'--disable-pip-version-check',
'wheel', '--no-deps',
'-w', tmpdir,
]
if quiet:
cmd.append('--quiet')
if index_url is not None:
cmd.extend(('--index-url', index_url))
if find_links is not None:
for link in find_links:
cmd.extend(('--find-links', link))
# If requirement is a PEP 508 direct URL, directly pass
# the URL to pip, as `req @ url` does not work on the
# command line.
if req.url:
cmd.append(req.url)
else:
cmd.append(str(req))
try:
subprocess.check_call(cmd)
except subprocess.CalledProcessError as e:
raise DistutilsError(str(e))
wheel = Wheel(glob.glob(os.path.join(tmpdir, '*.whl'))[0])
dist_location = os.path.join(eggs_dir, wheel.egg_name())
wheel.install_as_egg(dist_location)
dist_metadata = pkg_resources.PathMetadata(
dist_location, os.path.join(dist_location, 'EGG-INFO'))
dist = pkg_resources.Distribution.from_filename(
dist_location, metadata=dist_metadata)
return dist
if req.url:
cmd.append(req.url)
else:
cmd.append(str(req))
try:
subprocess.check_call(cmd)
except subprocess.CalledProcessError as e:
<<<<<<< HEAD
raise DistutilsError(str(e)) from e
=======
raise DistutilsError(str(e))
>>>>>>> b66a76afa15ab74019740676a52a071b85ed8f71
wheel = Wheel(glob.glob(os.path.join(tmpdir, '*.whl'))[0])
dist_location = os.path.join(eggs_dir, wheel.egg_name())
wheel.install_as_egg(dist_location)
dist_metadata = pkg_resources.PathMetadata(
dist_location, os.path.join(dist_location, 'EGG-INFO'))
dist = pkg_resources.Distribution.from_filename(
dist_location, metadata=dist_metadata)
return dist
def strip_marker(req):
"""
Return a new requirement without the environment marker to avoid
calling pip with something like `babel; extra == "i18n"`, which
would always be ignored.
"""
# create a copy to avoid mutating the input
req = pkg_resources.Requirement.parse(str(req))
req.marker = None
return req
# 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
)
def _dist_from_eggfile(filename, logger, observer):
""" Create distribution by unpacking egg file. """
if not os.path.exists(filename):
msg = "'%s' not found." % filename
observer.exception(msg)
raise ValueError(msg)
if not zipfile.is_zipfile(filename):
msg = "'%s' is not an egg/zipfile." % filename
observer.exception(msg)
raise ValueError(msg)
# Extract files.
archive = zipfile.ZipFile(filename, 'r', allowZip64=True)
try:
name = archive.read('EGG-INFO/top_level.txt').split('\n')[0]
logger.log(LOG_DEBUG2, " name '%s'", name)
if observer.observer is not None:
# Collect totals.
total_files = 0.
total_bytes = 0.
for info in archive.infolist():
fname = info.filename
# Just being defensive.
if not fname.startswith(name) and \
not fname.startswith('EGG-INFO'): # pragma no cover
continue
total_files += 1
total_bytes += info.file_size
else:
total_files = 1. # Avoid divide-by-zero.
total_bytes = 1.
files = 0.
size = 0.
for info in archive.infolist():
fname = info.filename
# Just being defensive.
if not fname.startswith(name) and \
not fname.startswith('EGG-INFO'): # pragma no cover
continue
observer.extract(fname, files / total_files, size / total_bytes)
dirname = os.path.dirname(fname)
if dirname == 'EGG-INFO':
# Extract EGG-INFO as subdirectory.
archive.extract(fname, name)
else:
archive.extract(fname)
if sys.platform != 'win32':
# Set permissions, extract() doesn't.
rwx = (info.external_attr >> 16) & 0777
if rwx:
os.chmod(fname, rwx) # Only if something valid.
files += 1
size += info.file_size
finally:
archive.close()
# Create distribution from extracted files.
location = os.getcwd()
egg_info = os.path.join(location, name, 'EGG-INFO')
provider = pkg_resources.PathMetadata(location, egg_info)
dist = pkg_resources.Distribution.from_location(location,
os.path.basename(filename),
provider)
logger.log(LOG_DEBUG2, ' project_name: %s', dist.project_name)
logger.log(LOG_DEBUG2, ' version: %s', dist.version)
logger.log(LOG_DEBUG2, ' py_version: %s', dist.py_version)
logger.log(LOG_DEBUG2, ' platform: %s', dist.platform)
logger.log(LOG_DEBUG2, ' requires:')
for req in dist.requires():
logger.log(LOG_DEBUG2, ' %s', req)
# If any module didn't have a distribution, check that we can import it.
if provider.has_metadata('openmdao_orphans.txt'):
errors = 0
orphan_names = []
for mod in provider.get_metadata_lines('openmdao_orphans.txt'):
mod = mod.strip()
logger.log(LOG_DEBUG2, " checking for 'orphan' module: %s", mod)
try:
__import__(mod)
# Difficult to generate a distribution that can't be reloaded.
except ImportError: # pragma no cover
logger.error(
"Can't import %s, which didn't have a known"
" distribution when the egg was written.", mod)
orphan_names.append(mod)
errors += 1
# Difficult to generate a distribution that can't be reloaded.
if errors: # pragma no cover
plural = 's' if errors > 1 else ''
msg = "Couldn't import %d 'orphan' module%s: %s." \
% (errors, plural, orphan_names)
observer.exception(msg)
raise RuntimeError(msg)
return (name, dist)
bpy_cmd = self.get_finalized_command("build_py")
build_path = pkg_resources.normalize_path(bpy_cmd.build_lib)
# Build extensions
self.reinitialize_command('egg_info', egg_base=build_path)
self.run_command('egg_info')
self.reinitialize_command('build_ext', inplace=0)
self.run_command('build_ext')
# Fixup egg-link and easy-install.pth
ei_cmd = self.get_finalized_command("egg_info")
self.egg_path = build_path
self.dist.location = build_path
# XXX
self.dist._provider = pkg_resources.PathMetadata(
build_path, ei_cmd.egg_info)
else:
# Without 2to3 inplace works fine:
self.run_command('egg_info')
# Build extensions in-place
self.reinitialize_command('build_ext', inplace=1)
self.run_command('build_ext')
<<<<<<< HEAD
self.install_site_py() # ensure that target dir is site-safe
=======
>>>>>>> 7e5c5fbd6c824de4d4c2b62da3f7cae87d462119
if setuptools.bootstrap_install_from:
self.easy_install(setuptools.bootstrap_install_from)
setuptools.bootstrap_install_from = None
def fetch_build_egg(dist, req): # noqa: C901 # is too complex (16) # FIXME
"""Fetch an egg needed for building.
Use pip/wheel to fetch/build a wheel."""
warnings.warn(
"setuptools.installer is deprecated. Requirements should "
"be satisfied by a PEP 517 installer.",
SetuptoolsDeprecationWarning,
)
# Warn if wheel is not available
try:
pkg_resources.get_distribution('wheel')
except pkg_resources.DistributionNotFound:
dist.announce('WARNING: The wheel package is not available.', log.WARN)
# Ignore environment markers; if supplied, it is required.
req = strip_marker(req)
# Take easy_install options into account, but do not override relevant
# pip environment variables (like PIP_INDEX_URL or PIP_QUIET); they'll
# take precedence.
opts = dist.get_option_dict('easy_install')
if 'allow_hosts' in opts:
raise DistutilsError('the `allow-hosts` option is not supported '
'when using pip to install requirements.')
quiet = 'PIP_QUIET' not in os.environ and 'PIP_VERBOSE' not in os.environ
if 'PIP_INDEX_URL' in os.environ:
index_url = None
elif 'index_url' in opts:
index_url = opts['index_url'][1]
else:
index_url = None
find_links = (
_fixup_find_links(opts['find_links'][1])[:] if 'find_links' in opts
else []
)
if dist.dependency_links:
find_links.extend(dist.dependency_links)
eggs_dir = os.path.realpath(dist.get_egg_cache_dir())
environment = pkg_resources.Environment()
for egg_dist in pkg_resources.find_distributions(eggs_dir):
if egg_dist in req and environment.can_add(egg_dist):
return egg_dist
with tempfile.TemporaryDirectory() as tmpdir:
cmd = [
sys.executable, '-m', 'pip',
'--disable-pip-version-check',
'wheel', '--no-deps',
'-w', tmpdir,
]
if quiet:
cmd.append('--quiet')
if index_url is not None:
cmd.extend(('--index-url', index_url))
for link in find_links or []:
cmd.extend(('--find-links', link))
# If requirement is a PEP 508 direct URL, directly pass
# the URL to pip, as `req @ url` does not work on the
# command line.
cmd.append(req.url or str(req))
try:
subprocess.check_call(cmd)
except subprocess.CalledProcessError as e:
raise DistutilsError(str(e)) from e
wheel = Wheel(glob.glob(os.path.join(tmpdir, '*.whl'))[0])
dist_location = os.path.join(eggs_dir, wheel.egg_name())
wheel.install_as_egg(dist_location)
dist_metadata = pkg_resources.PathMetadata(
dist_location, os.path.join(dist_location, 'EGG-INFO'))
dist = pkg_resources.Distribution.from_filename(
dist_location, metadata=dist_metadata)
return dist
