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