Wala shell

Advanced PHP File Manager

Server IP: 127.0.0.1 | PHP Version: 8.3.30 | Domains Hosted: 54

Name	Size	Last Modified
📁 ..	-	2026-03-21 15:45
📄 __init__.py from __future__ import annotations from pip._internal.utils import _log # init_logging() must be called before any call to logging.getLogger() # which happens at import of most modules. _log.init_logging() def main(args: list[str] \| None = None) -> int: """This is preserved for old console scripts that may still be referencing it. For additional details, see https://github.com/pypa/pip/issues/7498. """ from pip._internal.utils.entrypoints import _wrapper return _wrapper(args)	511 B	2026-01-20 12:58
📁 __pycache__	-	2026-03-21 15:45
📄 build_env.py """Build Environment used for isolation during sdist building""" from __future__ import annotations import logging import os import pathlib import site import sys import textwrap from collections import OrderedDict from collections.abc import Iterable from types import TracebackType from typing import TYPE_CHECKING, Protocol, TypedDict from pip._vendor.packaging.version import Version from pip import __file__ as pip_location from pip._internal.cli.spinners import open_spinner from pip._internal.locations import get_platlib, get_purelib, get_scheme from pip._internal.metadata import get_default_environment, get_environment from pip._internal.utils.deprecation import deprecated from pip._internal.utils.logging import VERBOSE from pip._internal.utils.packaging import get_requirement from pip._internal.utils.subprocess import call_subprocess from pip._internal.utils.temp_dir import TempDirectory, tempdir_kinds if TYPE_CHECKING: from pip._internal.index.package_finder import PackageFinder from pip._internal.req.req_install import InstallRequirement class ExtraEnviron(TypedDict, total=False): extra_environ: dict[str, str] logger = logging.getLogger(__name__) def _dedup(a: str, b: str) -> tuple[str] \| tuple[str, str]: return (a, b) if a != b else (a,) class _Prefix: def __init__(self, path: str) -> None: self.path = path self.setup = False scheme = get_scheme("", prefix=path) self.bin_dir = scheme.scripts self.lib_dirs = _dedup(scheme.purelib, scheme.platlib) def get_runnable_pip() -> str: """Get a file to pass to a Python executable, to run the currently-running pip. This is used to run a pip subprocess, for installing requirements into the build environment. """ source = pathlib.Path(pip_location).resolve().parent if not source.is_dir(): # This would happen if someone is using pip from inside a zip file. In that # case, we can use that directly. return str(source) return os.fsdecode(source / "__pip-runner__.py") def _get_system_sitepackages() -> set[str]: """Get system site packages Usually from site.getsitepackages, but fallback on `get_purelib()/get_platlib()` if unavailable (e.g. in a virtualenv created by virtualenv<20) Returns normalized set of strings. """ if hasattr(site, "getsitepackages"): system_sites = site.getsitepackages() else: # virtualenv < 20 overwrites site.py without getsitepackages # fallback on get_purelib/get_platlib. # this is known to miss things, but shouldn't in the cases # where getsitepackages() has been removed (inside a virtualenv) system_sites = [get_purelib(), get_platlib()] return {os.path.normcase(path) for path in system_sites} class BuildEnvironmentInstaller(Protocol): """ Interface for installing build dependencies into an isolated build environment. """ def install( self, requirements: Iterable[str], prefix: _Prefix, , kind: str, for_req: InstallRequirement \| None, ) -> None: ... class SubprocessBuildEnvironmentInstaller: """ Install build dependencies by calling pip in a subprocess. """ def __init__( self, finder: PackageFinder, build_constraints: list[str] \| None = None, build_constraint_feature_enabled: bool = False, ) -> None: self.finder = finder self._build_constraints = build_constraints or [] self._build_constraint_feature_enabled = build_constraint_feature_enabled def _deprecation_constraint_check(self) -> None: """ Check for deprecation warning: PIP_CONSTRAINT affecting build environments. This warns when build-constraint feature is NOT enabled and PIP_CONSTRAINT is not empty. """ if self._build_constraint_feature_enabled or self._build_constraints: return pip_constraint = os.environ.get("PIP_CONSTRAINT") if not pip_constraint or not pip_constraint.strip(): return deprecated( reason=( "Setting PIP_CONSTRAINT will not affect " "build constraints in the future," ), replacement=( "to specify build constraints using --build-constraint or " "PIP_BUILD_CONSTRAINT. To disable this warning without " "any build constraints set --use-feature=build-constraint or " 'PIP_USE_FEATURE="build-constraint"' ), gone_in="26.2", issue=None, ) def install( self, requirements: Iterable[str], prefix: _Prefix, , kind: str, for_req: InstallRequirement \| None, ) -> None: self._deprecation_constraint_check() finder = self.finder args: list[str] = [ sys.executable, get_runnable_pip(), "install", "--ignore-installed", "--no-user", "--prefix", prefix.path, "--no-warn-script-location", "--disable-pip-version-check", # As the build environment is ephemeral, it's wasteful to # pre-compile everything, especially as not every Python # module will be used/compiled in most cases. "--no-compile", # The prefix specified two lines above, thus # target from config file or env var should be ignored "--target", "", ] if logger.getEffectiveLevel() <= logging.DEBUG: args.append("-vv") elif logger.getEffectiveLevel() <= VERBOSE: args.append("-v") for format_control in ("no_binary", "only_binary"): formats = getattr(finder.format_control, format_control) args.extend( ( "--" + format_control.replace("_", "-"), ",".join(sorted(formats or {":none:"})), ) ) index_urls = finder.index_urls if index_urls: args.extend(["-i", index_urls[0]]) for extra_index in index_urls[1:]: args.extend(["--extra-index-url", extra_index]) else: args.append("--no-index") for link in finder.find_links: args.extend(["--find-links", link]) if finder.proxy: args.extend(["--proxy", finder.proxy]) for host in finder.trusted_hosts: args.extend(["--trusted-host", host]) if finder.custom_cert: args.extend(["--cert", finder.custom_cert]) if finder.client_cert: args.extend(["--client-cert", finder.client_cert]) if finder.allow_all_prereleases: args.append("--pre") if finder.prefer_binary: args.append("--prefer-binary") # Handle build constraints if self._build_constraint_feature_enabled: args.extend(["--use-feature", "build-constraint"]) if self._build_constraints: # Build constraints must be passed as both constraints # and build constraints, so that nested builds receive # build constraints for constraint_file in self._build_constraints: args.extend(["--constraint", constraint_file]) args.extend(["--build-constraint", constraint_file]) extra_environ: ExtraEnviron = {} if self._build_constraint_feature_enabled and not self._build_constraints: # If there are no build constraints but the build constraints # feature is enabled then we must ignore regular constraints # in the isolated build environment extra_environ = {"extra_environ": {"_PIP_IN_BUILD_IGNORE_CONSTRAINTS": "1"}} args.append("--") args.extend(requirements) identify_requirement = ( f" for {for_req.name}" if for_req and for_req.name else "" ) with open_spinner(f"Installing {kind}") as spinner: call_subprocess( args, command_desc=f"installing {kind}{identify_requirement}", spinner=spinner, *extra_environ, ) class BuildEnvironment: """Creates and manages an isolated environment to install build deps""" def __init__(self, installer: BuildEnvironmentInstaller) -> None: self.installer = installer temp_dir = TempDirectory(kind=tempdir_kinds.BUILD_ENV, globally_managed=True) self._prefixes = OrderedDict( (name, _Prefix(os.path.join(temp_dir.path, name))) for name in ("normal", "overlay") ) self._bin_dirs: list[str] = [] self._lib_dirs: list[str] = [] for prefix in reversed(list(self._prefixes.values())): self._bin_dirs.append(prefix.bin_dir) self._lib_dirs.extend(prefix.lib_dirs) # Customize site to: # - ensure .pth files are honored # - prevent access to system site packages system_sites = _get_system_sitepackages() self._site_dir = os.path.join(temp_dir.path, "site") if not os.path.exists(self._site_dir): os.mkdir(self._site_dir) with open( os.path.join(self._site_dir, "sitecustomize.py"), "w", encoding="utf-8" ) as fp: fp.write( textwrap.dedent( """ import os, site, sys # First, drop system-sites related paths. original_sys_path = sys.path[:] known_paths = set() for path in {system_sites!r}: site.addsitedir(path, known_paths=known_paths) system_paths = set( os.path.normcase(path) for path in sys.path[len(original_sys_path):] ) original_sys_path = [ path for path in original_sys_path if os.path.normcase(path) not in system_paths ] sys.path = original_sys_path # Second, add lib directories. # ensuring .pth file are processed. for path in {lib_dirs!r}: assert not path in sys.path site.addsitedir(path) """ ).format(system_sites=system_sites, lib_dirs=self._lib_dirs) ) def __enter__(self) -> None: self._save_env = { name: os.environ.get(name, None) for name in ("PATH", "PYTHONNOUSERSITE", "PYTHONPATH") } path = self._bin_dirs[:] old_path = self._save_env["PATH"] if old_path: path.extend(old_path.split(os.pathsep)) pythonpath = [self._site_dir] os.environ.update( { "PATH": os.pathsep.join(path), "PYTHONNOUSERSITE": "1", "PYTHONPATH": os.pathsep.join(pythonpath), } ) def __exit__( self, exc_type: type[BaseException] \| None, exc_val: BaseException \| None, exc_tb: TracebackType \| None, ) -> None: for varname, old_value in self._save_env.items(): if old_value is None: os.environ.pop(varname, None) else: os.environ[varname] = old_value def check_requirements( self, reqs: Iterable[str] ) -> tuple[set[tuple[str, str]], set[str]]: """Return 2 sets: - conflicting requirements: set of (installed, wanted) reqs tuples - missing requirements: set of reqs """ missing = set() conflicting = set() if reqs: env = ( get_environment(self._lib_dirs) if hasattr(self, "_lib_dirs") else get_default_environment() ) for req_str in reqs: req = get_requirement(req_str) # We're explicitly evaluating with an empty extra value, since build # environments are not provided any mechanism to select specific extras. if req.marker is not None and not req.marker.evaluate({"extra": ""}): continue dist = env.get_distribution(req.name) if not dist: missing.add(req_str) continue if isinstance(dist.version, Version): installed_req_str = f"{req.name}=={dist.version}" else: installed_req_str = f"{req.name}==={dist.version}" if not req.specifier.contains(dist.version, prereleases=True): conflicting.add((installed_req_str, req_str)) # FIXME: Consider direct URL? return conflicting, missing def install_requirements( self, requirements: Iterable[str], prefix_as_string: str, , kind: str, for_req: InstallRequirement \| None = None, ) -> None: prefix = self._prefixes[prefix_as_string] assert not prefix.setup prefix.setup = True if not requirements: return self.installer.install(requirements, prefix, kind=kind, for_req=for_req) class NoOpBuildEnvironment(BuildEnvironment): """A no-op drop-in replacement for BuildEnvironment""" def __init__(self) -> None: pass def __enter__(self) -> None: pass def __exit__( self, exc_type: type[BaseException] \| None, exc_val: BaseException \| None, exc_tb: TracebackType \| None, ) -> None: pass def cleanup(self) -> None: pass def install_requirements( self, requirements: Iterable[str], prefix_as_string: str, *, kind: str, for_req: InstallRequirement \| None = None, ) -> None: raise NotImplementedError()	13.87 KB	2026-01-20 12:58
📄 cache.py """Cache Management""" from __future__ import annotations import hashlib import json import logging import os from pathlib import Path from typing import Any from pip._vendor.packaging.tags import Tag, interpreter_name, interpreter_version from pip._vendor.packaging.utils import canonicalize_name from pip._internal.exceptions import InvalidWheelFilename from pip._internal.models.direct_url import DirectUrl from pip._internal.models.link import Link from pip._internal.models.wheel import Wheel from pip._internal.utils.temp_dir import TempDirectory, tempdir_kinds from pip._internal.utils.urls import path_to_url logger = logging.getLogger(__name__) ORIGIN_JSON_NAME = "origin.json" def _hash_dict(d: dict[str, str]) -> str: """Return a stable sha224 of a dictionary.""" s = json.dumps(d, sort_keys=True, separators=(",", ":"), ensure_ascii=True) return hashlib.sha224(s.encode("ascii")).hexdigest() class Cache: """An abstract class - provides cache directories for data from links :param cache_dir: The root of the cache. """ def __init__(self, cache_dir: str) -> None: super().__init__() assert not cache_dir or os.path.isabs(cache_dir) self.cache_dir = cache_dir or None def _get_cache_path_parts(self, link: Link) -> list[str]: """Get parts of part that must be os.path.joined with cache_dir""" # We want to generate an url to use as our cache key, we don't want to # just reuse the URL because it might have other items in the fragment # and we don't care about those. key_parts = {"url": link.url_without_fragment} if link.hash_name is not None and link.hash is not None: key_parts[link.hash_name] = link.hash if link.subdirectory_fragment: key_parts["subdirectory"] = link.subdirectory_fragment # Include interpreter name, major and minor version in cache key # to cope with ill-behaved sdists that build a different wheel # depending on the python version their setup.py is being run on, # and don't encode the difference in compatibility tags. # https://github.com/pypa/pip/issues/7296 key_parts["interpreter_name"] = interpreter_name() key_parts["interpreter_version"] = interpreter_version() # Encode our key url with sha224, we'll use this because it has similar # security properties to sha256, but with a shorter total output (and # thus less secure). However the differences don't make a lot of # difference for our use case here. hashed = _hash_dict(key_parts) # We want to nest the directories some to prevent having a ton of top # level directories where we might run out of sub directories on some # FS. parts = [hashed[:2], hashed[2:4], hashed[4:6], hashed[6:]] return parts def _get_candidates(self, link: Link, canonical_package_name: str) -> list[Any]: can_not_cache = not self.cache_dir or not canonical_package_name or not link if can_not_cache: return [] path = self.get_path_for_link(link) if os.path.isdir(path): return [(candidate, path) for candidate in os.listdir(path)] return [] def get_path_for_link(self, link: Link) -> str: """Return a directory to store cached items in for link.""" raise NotImplementedError() def get( self, link: Link, package_name: str \| None, supported_tags: list[Tag], ) -> Link: """Returns a link to a cached item if it exists, otherwise returns the passed link. """ raise NotImplementedError() class SimpleWheelCache(Cache): """A cache of wheels for future installs.""" def __init__(self, cache_dir: str) -> None: super().__init__(cache_dir) def get_path_for_link(self, link: Link) -> str: """Return a directory to store cached wheels for link Because there are M wheels for any one sdist, we provide a directory to cache them in, and then consult that directory when looking up cache hits. We only insert things into the cache if they have plausible version numbers, so that we don't contaminate the cache with things that were not unique. E.g. ./package might have dozens of installs done for it and build a version of 0.0...and if we built and cached a wheel, we'd end up using the same wheel even if the source has been edited. :param link: The link of the sdist for which this will cache wheels. """ parts = self._get_cache_path_parts(link) assert self.cache_dir # Store wheels within the root cache_dir return os.path.join(self.cache_dir, "wheels", *parts) def get( self, link: Link, package_name: str \| None, supported_tags: list[Tag], ) -> Link: candidates = [] if not package_name: return link canonical_package_name = canonicalize_name(package_name) for wheel_name, wheel_dir in self._get_candidates(link, canonical_package_name): try: wheel = Wheel(wheel_name) except InvalidWheelFilename: continue if wheel.name != canonical_package_name: logger.debug( "Ignoring cached wheel %s for %s as it " "does not match the expected distribution name %s.", wheel_name, link, package_name, ) continue if not wheel.supported(supported_tags): # Built for a different python/arch/etc continue candidates.append( ( wheel.support_index_min(supported_tags), wheel_name, wheel_dir, ) ) if not candidates: return link _, wheel_name, wheel_dir = min(candidates) return Link(path_to_url(os.path.join(wheel_dir, wheel_name))) class EphemWheelCache(SimpleWheelCache): """A SimpleWheelCache that creates it's own temporary cache directory""" def __init__(self) -> None: self._temp_dir = TempDirectory( kind=tempdir_kinds.EPHEM_WHEEL_CACHE, globally_managed=True, ) super().__init__(self._temp_dir.path) class CacheEntry: def __init__( self, link: Link, persistent: bool, ): self.link = link self.persistent = persistent self.origin: DirectUrl \| None = None origin_direct_url_path = Path(self.link.file_path).parent / ORIGIN_JSON_NAME if origin_direct_url_path.exists(): try: self.origin = DirectUrl.from_json( origin_direct_url_path.read_text(encoding="utf-8") ) except Exception as e: logger.warning( "Ignoring invalid cache entry origin file %s for %s (%s)", origin_direct_url_path, link.filename, e, ) class WheelCache(Cache): """Wraps EphemWheelCache and SimpleWheelCache into a single Cache This Cache allows for gracefully degradation, using the ephem wheel cache when a certain link is not found in the simple wheel cache first. """ def __init__(self, cache_dir: str) -> None: super().__init__(cache_dir) self._wheel_cache = SimpleWheelCache(cache_dir) self._ephem_cache = EphemWheelCache() def get_path_for_link(self, link: Link) -> str: return self._wheel_cache.get_path_for_link(link) def get_ephem_path_for_link(self, link: Link) -> str: return self._ephem_cache.get_path_for_link(link) def get( self, link: Link, package_name: str \| None, supported_tags: list[Tag], ) -> Link: cache_entry = self.get_cache_entry(link, package_name, supported_tags) if cache_entry is None: return link return cache_entry.link def get_cache_entry( self, link: Link, package_name: str \| None, supported_tags: list[Tag], ) -> CacheEntry \| None: """Returns a CacheEntry with a link to a cached item if it exists or None. The cache entry indicates if the item was found in the persistent or ephemeral cache. """ retval = self._wheel_cache.get( link=link, package_name=package_name, supported_tags=supported_tags, ) if retval is not link: return CacheEntry(retval, persistent=True) retval = self._ephem_cache.get( link=link, package_name=package_name, supported_tags=supported_tags, ) if retval is not link: return CacheEntry(retval, persistent=False) return None @staticmethod def record_download_origin(cache_dir: str, download_info: DirectUrl) -> None: origin_path = Path(cache_dir) / ORIGIN_JSON_NAME if origin_path.exists(): try: origin = DirectUrl.from_json(origin_path.read_text(encoding="utf-8")) except Exception as e: logger.warning( "Could not read origin file %s in cache entry (%s). " "Will attempt to overwrite it.", origin_path, e, ) else: # TODO: use DirectUrl.equivalent when # https://github.com/pypa/pip/pull/10564 is merged. if origin.url != download_info.url: logger.warning( "Origin URL %s in cache entry %s does not match download URL " "%s. This is likely a pip bug or a cache corruption issue. " "Will overwrite it with the new value.", origin.url, cache_dir, download_info.url, ) origin_path.write_text(download_info.to_json(), encoding="utf-8")	10.1 KB	2026-01-20 12:58
📁 cli	-	2026-03-21 15:45
📁 commands	-	2026-03-21 15:45
📄 configuration.py """Configuration management setup Some terminology: - name As written in config files. - value Value associated with a name - key Name combined with it's section (section.name) - variant A single word describing where the configuration key-value pair came from """ from __future__ import annotations import configparser import locale import os import sys from collections.abc import Iterable from typing import Any, NewType from pip._internal.exceptions import ( ConfigurationError, ConfigurationFileCouldNotBeLoaded, ) from pip._internal.utils import appdirs from pip._internal.utils.compat import WINDOWS from pip._internal.utils.logging import getLogger from pip._internal.utils.misc import ensure_dir, enum RawConfigParser = configparser.RawConfigParser # Shorthand Kind = NewType("Kind", str) CONFIG_BASENAME = "pip.ini" if WINDOWS else "pip.conf" ENV_NAMES_IGNORED = "version", "help" # The kinds of configurations there are. kinds = enum( USER="user", # User Specific GLOBAL="global", # System Wide SITE="site", # [Virtual] Environment Specific ENV="env", # from PIP_CONFIG_FILE ENV_VAR="env-var", # from Environment Variables ) OVERRIDE_ORDER = kinds.GLOBAL, kinds.USER, kinds.SITE, kinds.ENV, kinds.ENV_VAR VALID_LOAD_ONLY = kinds.USER, kinds.GLOBAL, kinds.SITE logger = getLogger(__name__) # NOTE: Maybe use the optionx attribute to normalize keynames. def _normalize_name(name: str) -> str: """Make a name consistent regardless of source (environment or file)""" name = name.lower().replace("_", "-") name = name.removeprefix("--") # only prefer long opts return name def _disassemble_key(name: str) -> list[str]: if "." not in name: error_message = ( "Key does not contain dot separated section and key. " f"Perhaps you wanted to use 'global.{name}' instead?" ) raise ConfigurationError(error_message) return name.split(".", 1) def get_configuration_files() -> dict[Kind, list[str]]: global_config_files = [ os.path.join(path, CONFIG_BASENAME) for path in appdirs.site_config_dirs("pip") ] site_config_file = os.path.join(sys.prefix, CONFIG_BASENAME) legacy_config_file = os.path.join( os.path.expanduser("~"), "pip" if WINDOWS else ".pip", CONFIG_BASENAME, ) new_config_file = os.path.join(appdirs.user_config_dir("pip"), CONFIG_BASENAME) return { kinds.GLOBAL: global_config_files, kinds.SITE: [site_config_file], kinds.USER: [legacy_config_file, new_config_file], } class Configuration: """Handles management of configuration. Provides an interface to accessing and managing configuration files. This class converts provides an API that takes "section.key-name" style keys and stores the value associated with it as "key-name" under the section "section". This allows for a clean interface wherein the both the section and the key-name are preserved in an easy to manage form in the configuration files and the data stored is also nice. """ def __init__(self, isolated: bool, load_only: Kind \| None = None) -> None: super().__init__() if load_only is not None and load_only not in VALID_LOAD_ONLY: raise ConfigurationError( "Got invalid value for load_only - should be one of {}".format( ", ".join(map(repr, VALID_LOAD_ONLY)) ) ) self.isolated = isolated self.load_only = load_only # Because we keep track of where we got the data from self._parsers: dict[Kind, list[tuple[str, RawConfigParser]]] = { variant: [] for variant in OVERRIDE_ORDER } self._config: dict[Kind, dict[str, dict[str, Any]]] = { variant: {} for variant in OVERRIDE_ORDER } self._modified_parsers: list[tuple[str, RawConfigParser]] = [] def load(self) -> None: """Loads configuration from configuration files and environment""" self._load_config_files() if not self.isolated: self._load_environment_vars() def get_file_to_edit(self) -> str \| None: """Returns the file with highest priority in configuration""" assert self.load_only is not None, "Need to be specified a file to be editing" try: return self._get_parser_to_modify()[0] except IndexError: return None def items(self) -> Iterable[tuple[str, Any]]: """Returns key-value pairs like dict.items() representing the loaded configuration """ return self._dictionary.items() def get_value(self, key: str) -> Any: """Get a value from the configuration.""" orig_key = key key = _normalize_name(key) try: clean_config: dict[str, Any] = {} for file_values in self._dictionary.values(): clean_config.update(file_values) return clean_config[key] except KeyError: # disassembling triggers a more useful error message than simply # "No such key" in the case that the key isn't in the form command.option _disassemble_key(key) raise ConfigurationError(f"No such key - {orig_key}") def set_value(self, key: str, value: Any) -> None: """Modify a value in the configuration.""" key = _normalize_name(key) self._ensure_have_load_only() assert self.load_only fname, parser = self._get_parser_to_modify() if parser is not None: section, name = _disassemble_key(key) # Modify the parser and the configuration if not parser.has_section(section): parser.add_section(section) parser.set(section, name, value) self._config[self.load_only].setdefault(fname, {}) self._config[self.load_only][fname][key] = value self._mark_as_modified(fname, parser) def unset_value(self, key: str) -> None: """Unset a value in the configuration.""" orig_key = key key = _normalize_name(key) self._ensure_have_load_only() assert self.load_only fname, parser = self._get_parser_to_modify() if ( key not in self._config[self.load_only][fname] and key not in self._config[self.load_only] ): raise ConfigurationError(f"No such key - {orig_key}") if parser is not None: section, name = _disassemble_key(key) if not ( parser.has_section(section) and parser.remove_option(section, name) ): # The option was not removed. raise ConfigurationError( "Fatal Internal error [id=1]. Please report as a bug." ) # The section may be empty after the option was removed. if not parser.items(section): parser.remove_section(section) self._mark_as_modified(fname, parser) try: del self._config[self.load_only][fname][key] except KeyError: del self._config[self.load_only][key] def save(self) -> None: """Save the current in-memory state.""" self._ensure_have_load_only() for fname, parser in self._modified_parsers: logger.info("Writing to %s", fname) # Ensure directory exists. ensure_dir(os.path.dirname(fname)) # Ensure directory's permission(need to be writeable) try: with open(fname, "w") as f: parser.write(f) except OSError as error: raise ConfigurationError( f"An error occurred while writing to the configuration file " f"{fname}: {error}" ) # # Private routines # def _ensure_have_load_only(self) -> None: if self.load_only is None: raise ConfigurationError("Needed a specific file to be modifying.") logger.debug("Will be working with %s variant only", self.load_only) @property def _dictionary(self) -> dict[str, dict[str, Any]]: """A dictionary representing the loaded configuration.""" # NOTE: Dictionaries are not populated if not loaded. So, conditionals # are not needed here. retval = {} for variant in OVERRIDE_ORDER: retval.update(self._config[variant]) return retval def _load_config_files(self) -> None: """Loads configuration from configuration files""" config_files = dict(self.iter_config_files()) if config_files[kinds.ENV][0:1] == [os.devnull]: logger.debug( "Skipping loading configuration files due to " "environment's PIP_CONFIG_FILE being os.devnull" ) return for variant, files in config_files.items(): for fname in files: # If there's specific variant set in `load_only`, load only # that variant, not the others. if self.load_only is not None and variant != self.load_only: logger.debug("Skipping file '%s' (variant: %s)", fname, variant) continue parser = self._load_file(variant, fname) # Keeping track of the parsers used self._parsers[variant].append((fname, parser)) def _load_file(self, variant: Kind, fname: str) -> RawConfigParser: logger.verbose("For variant '%s', will try loading '%s'", variant, fname) parser = self._construct_parser(fname) for section in parser.sections(): items = parser.items(section) self._config[variant].setdefault(fname, {}) self._config[variant][fname].update(self._normalized_keys(section, items)) return parser def _construct_parser(self, fname: str) -> RawConfigParser: parser = configparser.RawConfigParser() # If there is no such file, don't bother reading it but create the # parser anyway, to hold the data. # Doing this is useful when modifying and saving files, where we don't # need to construct a parser. if os.path.exists(fname): locale_encoding = locale.getpreferredencoding(False) try: parser.read(fname, encoding=locale_encoding) except UnicodeDecodeError: # See https://github.com/pypa/pip/issues/4963 raise ConfigurationFileCouldNotBeLoaded( reason=f"contains invalid {locale_encoding} characters", fname=fname, ) except configparser.Error as error: # See https://github.com/pypa/pip/issues/4893 raise ConfigurationFileCouldNotBeLoaded(error=error) return parser def _load_environment_vars(self) -> None: """Loads configuration from environment variables""" self._config[kinds.ENV_VAR].setdefault(":env:", {}) self._config[kinds.ENV_VAR][":env:"].update( self._normalized_keys(":env:", self.get_environ_vars()) ) def _normalized_keys( self, section: str, items: Iterable[tuple[str, Any]] ) -> dict[str, Any]: """Normalizes items to construct a dictionary with normalized keys. This routine is where the names become keys and are made the same regardless of source - configuration files or environment. """ normalized = {} for name, val in items: key = section + "." + _normalize_name(name) normalized[key] = val return normalized def get_environ_vars(self) -> Iterable[tuple[str, str]]: """Returns a generator with all environmental vars with prefix PIP_""" for key, val in os.environ.items(): if key.startswith("PIP_"): name = key[4:].lower() if name not in ENV_NAMES_IGNORED: yield name, val # XXX: This is patched in the tests. def iter_config_files(self) -> Iterable[tuple[Kind, list[str]]]: """Yields variant and configuration files associated with it. This should be treated like items of a dictionary. The order here doesn't affect what gets overridden. That is controlled by OVERRIDE_ORDER. However this does control the order they are displayed to the user. It's probably most ergonomic to display things in the same order as OVERRIDE_ORDER """ # SMELL: Move the conditions out of this function env_config_file = os.environ.get("PIP_CONFIG_FILE", None) config_files = get_configuration_files() yield kinds.GLOBAL, config_files[kinds.GLOBAL] # per-user config is not loaded when env_config_file exists should_load_user_config = not self.isolated and not ( env_config_file and os.path.exists(env_config_file) ) if should_load_user_config: # The legacy config file is overridden by the new config file yield kinds.USER, config_files[kinds.USER] # virtualenv config yield kinds.SITE, config_files[kinds.SITE] if env_config_file is not None: yield kinds.ENV, [env_config_file] else: yield kinds.ENV, [] def get_values_in_config(self, variant: Kind) -> dict[str, Any]: """Get values present in a config file""" return self._config[variant] def _get_parser_to_modify(self) -> tuple[str, RawConfigParser]: # Determine which parser to modify assert self.load_only parsers = self._parsers[self.load_only] if not parsers: # This should not happen if everything works correctly. raise ConfigurationError( "Fatal Internal error [id=2]. Please report as a bug." ) # Use the highest priority parser. return parsers[-1] # XXX: This is patched in the tests. def _mark_as_modified(self, fname: str, parser: RawConfigParser) -> None: file_parser_tuple = (fname, parser) if file_parser_tuple not in self._modified_parsers: self._modified_parsers.append(file_parser_tuple) def __repr__(self) -> str: return f"{self.__class__.__name__}({self._dictionary!r})"	14.23 KB	2026-01-20 12:58
📁 distributions	-	2026-03-21 15:45
📄 exceptions.py """Exceptions used throughout package. This module MUST NOT try to import from anything within `pip._internal` to operate. This is expected to be importable from any/all files within the subpackage and, thus, should not depend on them. """ from __future__ import annotations import configparser import contextlib import locale import logging import pathlib import re import sys from collections.abc import Iterator from itertools import chain, groupby, repeat from typing import TYPE_CHECKING, Literal from pip._vendor.packaging.requirements import InvalidRequirement from pip._vendor.packaging.version import InvalidVersion from pip._vendor.rich.console import Console, ConsoleOptions, RenderResult from pip._vendor.rich.markup import escape from pip._vendor.rich.text import Text if TYPE_CHECKING: from hashlib import _Hash from pip._vendor.requests.models import Request, Response from pip._internal.metadata import BaseDistribution from pip._internal.network.download import _FileDownload from pip._internal.req.req_install import InstallRequirement logger = logging.getLogger(__name__) # # Scaffolding # def _is_kebab_case(s: str) -> bool: return re.match(r"^[a-z]+(-[a-z]+)$", s) is not None def _prefix_with_indent( s: Text \| str, console: Console, , prefix: str, indent: str, ) -> Text: if isinstance(s, Text): text = s else: text = console.render_str(s) return console.render_str(prefix, overflow="ignore") + console.render_str( f"\n{indent}", overflow="ignore" ).join(text.split(allow_blank=True)) class PipError(Exception): """The base pip error.""" class DiagnosticPipError(PipError): """An error, that presents diagnostic information to the user. This contains a bunch of logic, to enable pretty presentation of our error messages. Each error gets a unique reference. Each error can also include additional context, a hint and/or a note -- which are presented with the main error message in a consistent style. This is adapted from the error output styling in `sphinx-theme-builder`. """ reference: str def __init__( self, , kind: Literal["error", "warning"] = "error", reference: str \| None = None, message: str \| Text, context: str \| Text \| None, hint_stmt: str \| Text \| None, note_stmt: str \| Text \| None = None, link: str \| None = None, ) -> None: # Ensure a proper reference is provided. if reference is None: assert hasattr(self, "reference"), "error reference not provided!" reference = self.reference assert _is_kebab_case(reference), "error reference must be kebab-case!" self.kind = kind self.reference = reference self.message = message self.context = context self.note_stmt = note_stmt self.hint_stmt = hint_stmt self.link = link super().__init__(f"<{self.__class__.__name__}: {self.reference}>") def __repr__(self) -> str: return ( f"<{self.__class__.__name__}(" f"reference={self.reference!r}, " f"message={self.message!r}, " f"context={self.context!r}, " f"note_stmt={self.note_stmt!r}, " f"hint_stmt={self.hint_stmt!r}" ")>" ) def __rich_console__( self, console: Console, options: ConsoleOptions, ) -> RenderResult: colour = "red" if self.kind == "error" else "yellow" yield f"[{colour} bold]{self.kind}[/]: [bold]{self.reference}[/]" yield "" if not options.ascii_only: # Present the main message, with relevant context indented. if self.context is not None: yield _prefix_with_indent( self.message, console, prefix=f"[{colour}]×[/] ", indent=f"[{colour}]│[/] ", ) yield _prefix_with_indent( self.context, console, prefix=f"[{colour}]╰─>[/] ", indent=f"[{colour}] [/] ", ) else: yield _prefix_with_indent( self.message, console, prefix="[red]×[/] ", indent=" ", ) else: yield self.message if self.context is not None: yield "" yield self.context if self.note_stmt is not None or self.hint_stmt is not None: yield "" if self.note_stmt is not None: yield _prefix_with_indent( self.note_stmt, console, prefix="[magenta bold]note[/]: ", indent=" ", ) if self.hint_stmt is not None: yield _prefix_with_indent( self.hint_stmt, console, prefix="[cyan bold]hint[/]: ", indent=" ", ) if self.link is not None: yield "" yield f"Link: {self.link}" # # Actual Errors # class ConfigurationError(PipError): """General exception in configuration""" class InstallationError(PipError): """General exception during installation""" class FailedToPrepareCandidate(InstallationError): """Raised when we fail to prepare a candidate (i.e. fetch and generate metadata). This is intentionally not a diagnostic error, since the output will be presented above this error, when this occurs. This should instead present information to the user. """ def __init__( self, , package_name: str, requirement_chain: str, failed_step: str ) -> None: super().__init__(f"Failed to build '{package_name}' when {failed_step.lower()}") self.package_name = package_name self.requirement_chain = requirement_chain self.failed_step = failed_step class MissingPyProjectBuildRequires(DiagnosticPipError): """Raised when pyproject.toml has `build-system`, but no `build-system.requires`.""" reference = "missing-pyproject-build-system-requires" def __init__(self, , package: str) -> None: super().__init__( message=f"Can not process {escape(package)}", context=Text( "This package has an invalid pyproject.toml file.\n" "The [build-system] table is missing the mandatory `requires` key." ), note_stmt="This is an issue with the package mentioned above, not pip.", hint_stmt=Text("See PEP 518 for the detailed specification."), ) class InvalidPyProjectBuildRequires(DiagnosticPipError): """Raised when pyproject.toml an invalid `build-system.requires`.""" reference = "invalid-pyproject-build-system-requires" def __init__(self, , package: str, reason: str) -> None: super().__init__( message=f"Can not process {escape(package)}", context=Text( "This package has an invalid `build-system.requires` key in " f"pyproject.toml.\n{reason}" ), note_stmt="This is an issue with the package mentioned above, not pip.", hint_stmt=Text("See PEP 518 for the detailed specification."), ) class NoneMetadataError(PipError): """Raised when accessing a Distribution's "METADATA" or "PKG-INFO". This signifies an inconsistency, when the Distribution claims to have the metadata file (if not, raise ``FileNotFoundError`` instead), but is not actually able to produce its content. This may be due to permission errors. """ def __init__( self, dist: BaseDistribution, metadata_name: str, ) -> None: """ :param dist: A Distribution object. :param metadata_name: The name of the metadata being accessed (can be "METADATA" or "PKG-INFO"). """ self.dist = dist self.metadata_name = metadata_name def __str__(self) -> str: # Use `dist` in the error message because its stringification # includes more information, like the version and location. return f"None {self.metadata_name} metadata found for distribution: {self.dist}" class UserInstallationInvalid(InstallationError): """A --user install is requested on an environment without user site.""" def __str__(self) -> str: return "User base directory is not specified" class InvalidSchemeCombination(InstallationError): def __str__(self) -> str: before = ", ".join(str(a) for a in self.args[:-1]) return f"Cannot set {before} and {self.args[-1]} together" class DistributionNotFound(InstallationError): """Raised when a distribution cannot be found to satisfy a requirement""" class RequirementsFileParseError(InstallationError): """Raised when a general error occurs parsing a requirements file line.""" class BestVersionAlreadyInstalled(PipError): """Raised when the most up-to-date version of a package is already installed.""" class BadCommand(PipError): """Raised when virtualenv or a command is not found""" class CommandError(PipError): """Raised when there is an error in command-line arguments""" class PreviousBuildDirError(PipError): """Raised when there's a previous conflicting build directory""" class NetworkConnectionError(PipError): """HTTP connection error""" def __init__( self, error_msg: str, response: Response \| None = None, request: Request \| None = None, ) -> None: """ Initialize NetworkConnectionError with `request` and `response` objects. """ self.response = response self.request = request self.error_msg = error_msg if ( self.response is not None and not self.request and hasattr(response, "request") ): self.request = self.response.request super().__init__(error_msg, response, request) def __str__(self) -> str: return str(self.error_msg) class InvalidWheelFilename(InstallationError): """Invalid wheel filename.""" class UnsupportedWheel(InstallationError): """Unsupported wheel.""" class InvalidWheel(InstallationError): """Invalid (e.g. corrupt) wheel.""" def __init__(self, location: str, name: str): self.location = location self.name = name def __str__(self) -> str: return f"Wheel '{self.name}' located at {self.location} is invalid." class MetadataInconsistent(InstallationError): """Built metadata contains inconsistent information. This is raised when the metadata contains values (e.g. name and version) that do not match the information previously obtained from sdist filename, user-supplied ``#egg=`` value, or an install requirement name. """ def __init__( self, ireq: InstallRequirement, field: str, f_val: str, m_val: str ) -> None: self.ireq = ireq self.field = field self.f_val = f_val self.m_val = m_val def __str__(self) -> str: return ( f"Requested {self.ireq} has inconsistent {self.field}: " f"expected {self.f_val!r}, but metadata has {self.m_val!r}" ) class MetadataInvalid(InstallationError): """Metadata is invalid.""" def __init__(self, ireq: InstallRequirement, error: str) -> None: self.ireq = ireq self.error = error def __str__(self) -> str: return f"Requested {self.ireq} has invalid metadata: {self.error}" class InstallationSubprocessError(DiagnosticPipError, InstallationError): """A subprocess call failed.""" reference = "subprocess-exited-with-error" def __init__( self, , command_description: str, exit_code: int, output_lines: list[str] \| None, ) -> None: if output_lines is None: output_prompt = Text("No available output.") else: output_prompt = ( Text.from_markup(f"[red][{len(output_lines)} lines of output][/]\n") + Text("".join(output_lines)) + Text.from_markup(R"[red]\[end of output][/]") ) super().__init__( message=( f"[green]{escape(command_description)}[/] did not run successfully.\n" f"exit code: {exit_code}" ), context=output_prompt, hint_stmt=None, note_stmt=( "This error originates from a subprocess, and is likely not a " "problem with pip." ), ) self.command_description = command_description self.exit_code = exit_code def __str__(self) -> str: return f"{self.command_description} exited with {self.exit_code}" class MetadataGenerationFailed(DiagnosticPipError, InstallationError): reference = "metadata-generation-failed" def __init__( self, , package_details: str, ) -> None: super().__init__( message="Encountered error while generating package metadata.", context=escape(package_details), hint_stmt="See above for details.", note_stmt="This is an issue with the package mentioned above, not pip.", ) def __str__(self) -> str: return "metadata generation failed" class HashErrors(InstallationError): """Multiple HashError instances rolled into one for reporting""" def __init__(self) -> None: self.errors: list[HashError] = [] def append(self, error: HashError) -> None: self.errors.append(error) def __str__(self) -> str: lines = [] self.errors.sort(key=lambda e: e.order) for cls, errors_of_cls in groupby(self.errors, lambda e: e.__class__): lines.append(cls.head) lines.extend(e.body() for e in errors_of_cls) if lines: return "\n".join(lines) return "" def __bool__(self) -> bool: return bool(self.errors) class HashError(InstallationError): """ A failure to verify a package against known-good hashes :cvar order: An int sorting hash exception classes by difficulty of recovery (lower being harder), so the user doesn't bother fretting about unpinned packages when he has deeper issues, like VCS dependencies, to deal with. Also keeps error reports in a deterministic order. :cvar head: A section heading for display above potentially many exceptions of this kind :ivar req: The InstallRequirement that triggered this error. This is pasted on after the exception is instantiated, because it's not typically available earlier. """ req: InstallRequirement \| None = None head = "" order: int = -1 def body(self) -> str: """Return a summary of me for display under the heading. This default implementation simply prints a description of the triggering requirement. :param req: The InstallRequirement that provoked this error, with its link already populated by the resolver's _populate_link(). """ return f" {self._requirement_name()}" def __str__(self) -> str: return f"{self.head}\n{self.body()}" def _requirement_name(self) -> str: """Return a description of the requirement that triggered me. This default implementation returns long description of the req, with line numbers """ return str(self.req) if self.req else "unknown package" class VcsHashUnsupported(HashError): """A hash was provided for a version-control-system-based requirement, but we don't have a method for hashing those.""" order = 0 head = ( "Can't verify hashes for these requirements because we don't " "have a way to hash version control repositories:" ) class DirectoryUrlHashUnsupported(HashError): """A hash was provided for a version-control-system-based requirement, but we don't have a method for hashing those.""" order = 1 head = ( "Can't verify hashes for these file:// requirements because they " "point to directories:" ) class HashMissing(HashError): """A hash was needed for a requirement but is absent.""" order = 2 head = ( "Hashes are required in --require-hashes mode, but they are " "missing from some requirements. Here is a list of those " "requirements along with the hashes their downloaded archives " "actually had. Add lines like these to your requirements files to " "prevent tampering. (If you did not enable --require-hashes " "manually, note that it turns on automatically when any package " "has a hash.)" ) def __init__(self, gotten_hash: str) -> None: """ :param gotten_hash: The hash of the (possibly malicious) archive we just downloaded """ self.gotten_hash = gotten_hash def body(self) -> str: # Dodge circular import. from pip._internal.utils.hashes import FAVORITE_HASH package = None if self.req: # In the case of URL-based requirements, display the original URL # seen in the requirements file rather than the package name, # so the output can be directly copied into the requirements file. package = ( self.req.original_link if self.req.is_direct # In case someone feeds something downright stupid # to InstallRequirement's constructor. else getattr(self.req, "req", None) ) return " {} --hash={}:{}".format( package or "unknown package", FAVORITE_HASH, self.gotten_hash ) class HashUnpinned(HashError): """A requirement had a hash specified but was not pinned to a specific version.""" order = 3 head = ( "In --require-hashes mode, all requirements must have their " "versions pinned with ==. These do not:" ) class HashMismatch(HashError): """ Distribution file hash values don't match. :ivar package_name: The name of the package that triggered the hash mismatch. Feel free to write to this after the exception is raise to improve its error message. """ order = 4 head = ( "THESE PACKAGES DO NOT MATCH THE HASHES FROM THE REQUIREMENTS " "FILE. If you have updated the package versions, please update " "the hashes. Otherwise, examine the package contents carefully; " "someone may have tampered with them." ) def __init__(self, allowed: dict[str, list[str]], gots: dict[str, _Hash]) -> None: """ :param allowed: A dict of algorithm names pointing to lists of allowed hex digests :param gots: A dict of algorithm names pointing to hashes we actually got from the files under suspicion """ self.allowed = allowed self.gots = gots def body(self) -> str: return f" {self._requirement_name()}:\n{self._hash_comparison()}" def _hash_comparison(self) -> str: """ Return a comparison of actual and expected hash values. Example:: Expected sha256 abcdeabcdeabcdeabcdeabcdeabcdeabcdeabcdeabcde or 123451234512345123451234512345123451234512345 Got bcdefbcdefbcdefbcdefbcdefbcdefbcdefbcdefbcdef """ def hash_then_or(hash_name: str) -> chain[str]: # For now, all the decent hashes have 6-char names, so we can get # away with hard-coding space literals. return chain([hash_name], repeat(" or")) lines: list[str] = [] for hash_name, expecteds in self.allowed.items(): prefix = hash_then_or(hash_name) lines.extend((f" Expected {next(prefix)} {e}") for e in expecteds) lines.append( f" Got {self.gots[hash_name].hexdigest()}\n" ) return "\n".join(lines) class UnsupportedPythonVersion(InstallationError): """Unsupported python version according to Requires-Python package metadata.""" class ConfigurationFileCouldNotBeLoaded(ConfigurationError): """When there are errors while loading a configuration file""" def __init__( self, reason: str = "could not be loaded", fname: str \| None = None, error: configparser.Error \| None = None, ) -> None: super().__init__(error) self.reason = reason self.fname = fname self.error = error def __str__(self) -> str: if self.fname is not None: message_part = f" in {self.fname}." else: assert self.error is not None message_part = f".\n{self.error}\n" return f"Configuration file {self.reason}{message_part}" _DEFAULT_EXTERNALLY_MANAGED_ERROR = f"""\ The Python environment under {sys.prefix} is managed externally, and may not be manipulated by the user. Please use specific tooling from the distributor of the Python installation to interact with this environment instead. """ class ExternallyManagedEnvironment(DiagnosticPipError): """The current environment is externally managed. This is raised when the current environment is externally managed, as defined by `PEP 668`_. The ``EXTERNALLY-MANAGED`` configuration is checked and displayed when the error is bubbled up to the user. :param error: The error message read from ``EXTERNALLY-MANAGED``. """ reference = "externally-managed-environment" def __init__(self, error: str \| None) -> None: if error is None: context = Text(_DEFAULT_EXTERNALLY_MANAGED_ERROR) else: context = Text(error) super().__init__( message="This environment is externally managed", context=context, note_stmt=( "If you believe this is a mistake, please contact your " "Python installation or OS distribution provider. " "You can override this, at the risk of breaking your Python " "installation or OS, by passing --break-system-packages." ), hint_stmt=Text("See PEP 668 for the detailed specification."), ) @staticmethod def _iter_externally_managed_error_keys() -> Iterator[str]: # LC_MESSAGES is in POSIX, but not the C standard. The most common # platform that does not implement this category is Windows, where # using other categories for console message localization is equally # unreliable, so we fall back to the locale-less vendor message. This # can always be re-evaluated when a vendor proposes a new alternative. try: category = locale.LC_MESSAGES except AttributeError: lang: str \| None = None else: lang, _ = locale.getlocale(category) if lang is not None: yield f"Error-{lang}" for sep in ("-", "_"): before, found, _ = lang.partition(sep) if not found: continue yield f"Error-{before}" yield "Error" @classmethod def from_config( cls, config: pathlib.Path \| str, ) -> ExternallyManagedEnvironment: parser = configparser.ConfigParser(interpolation=None) try: parser.read(config, encoding="utf-8") section = parser["externally-managed"] for key in cls._iter_externally_managed_error_keys(): with contextlib.suppress(KeyError): return cls(section[key]) except KeyError: pass except (OSError, UnicodeDecodeError, configparser.ParsingError): from pip._internal.utils._log import VERBOSE exc_info = logger.isEnabledFor(VERBOSE) logger.warning("Failed to read %s", config, exc_info=exc_info) return cls(None) class UninstallMissingRecord(DiagnosticPipError): reference = "uninstall-no-record-file" def __init__(self, , distribution: BaseDistribution) -> None: installer = distribution.installer if not installer or installer == "pip": dep = f"{distribution.raw_name}=={distribution.version}" hint = Text.assemble( "You might be able to recover from this via: ", (f"pip install --force-reinstall --no-deps {dep}", "green"), ) else: hint = Text( f"The package was installed by {installer}. " "You should check if it can uninstall the package." ) super().__init__( message=Text(f"Cannot uninstall {distribution}"), context=( "The package's contents are unknown: " f"no RECORD file was found for {distribution.raw_name}." ), hint_stmt=hint, ) class LegacyDistutilsInstall(DiagnosticPipError): reference = "uninstall-distutils-installed-package" def __init__(self, , distribution: BaseDistribution) -> None: super().__init__( message=Text(f"Cannot uninstall {distribution}"), context=( "It is a distutils installed project and thus we cannot accurately " "determine which files belong to it which would lead to only a partial " "uninstall." ), hint_stmt=None, ) class InvalidInstalledPackage(DiagnosticPipError): reference = "invalid-installed-package" def __init__( self, *, dist: BaseDistribution, invalid_exc: InvalidRequirement \| InvalidVersion, ) -> None: installed_location = dist.installed_location if isinstance(invalid_exc, InvalidRequirement): invalid_type = "requirement" else: invalid_type = "version" super().__init__( message=Text( f"Cannot process installed package {dist} " + (f"in {installed_location!r} " if installed_location else "") + f"because it has an invalid {invalid_type}:\n{invalid_exc.args[0]}" ), context=( "Starting with pip 24.1, packages with invalid " f"{invalid_type}s can not be processed." ), hint_stmt="To proceed this package must be uninstalled.", ) class IncompleteDownloadError(DiagnosticPipError): """Raised when the downloader receives fewer bytes than advertised in the Content-Length header.""" reference = "incomplete-download" def __init__(self, download: _FileDownload) -> None: # Dodge circular import. from pip._internal.utils.misc import format_size assert download.size is not None download_status = ( f"{format_size(download.bytes_received)}/{format_size(download.size)}" ) if download.reattempts: retry_status = f"after {download.reattempts + 1} attempts " hint = "Use --resume-retries to configure resume attempt limit." else: # Download retrying is not enabled. retry_status = "" hint = "Consider using --resume-retries to enable download resumption." message = Text( f"Download failed {retry_status}because not enough bytes " f"were received ({download_status})" ) super().__init__( message=message, context=f"URL: {download.link.redacted_url}", hint_stmt=hint, note_stmt="This is an issue with network connectivity, not pip.", ) class ResolutionTooDeepError(DiagnosticPipError): """Raised when the dependency resolver exceeds the maximum recursion depth.""" reference = "resolution-too-deep" def __init__(self) -> None: super().__init__( message="Dependency resolution exceeded maximum depth", context=( "Pip cannot resolve the current dependencies as the dependency graph " "is too complex for pip to solve efficiently." ), hint_stmt=( "Try adding lower bounds to constrain your dependencies, " "for example: 'package>=2.0.0' instead of just 'package'. " ), link="https://pip.pypa.io/en/stable/topics/dependency-resolution/#handling-resolution-too-deep-errors", ) class InstallWheelBuildError(DiagnosticPipError): reference = "failed-wheel-build-for-install" def __init__(self, failed: list[InstallRequirement]) -> None: super().__init__( message=( "Failed to build installable wheels for some " "pyproject.toml based projects" ), context=", ".join(r.name for r in failed), # type: ignore hint_stmt=None, )	28.9 KB	2026-01-20 12:58
📁 index	-	2026-03-21 15:45
📁 locations	-	2026-03-21 15:45
📄 main.py from __future__ import annotations def main(args: list[str] \| None = None) -> int: """This is preserved for old console scripts that may still be referencing it. For additional details, see https://github.com/pypa/pip/issues/7498. """ from pip._internal.utils.entrypoints import _wrapper return _wrapper(args)	338 B	2026-01-20 12:58
📁 metadata	-	2026-03-21 15:45
📁 models	-	2026-03-21 15:45
📁 network	-	2026-03-21 15:45
📁 operations	-	2026-03-21 15:45
📄 pyproject.py from __future__ import annotations import os from collections import namedtuple from typing import Any from pip._vendor.packaging.requirements import InvalidRequirement from pip._internal.exceptions import ( InstallationError, InvalidPyProjectBuildRequires, MissingPyProjectBuildRequires, ) from pip._internal.utils.compat import tomllib from pip._internal.utils.packaging import get_requirement def _is_list_of_str(obj: Any) -> bool: return isinstance(obj, list) and all(isinstance(item, str) for item in obj) def make_pyproject_path(unpacked_source_directory: str) -> str: return os.path.join(unpacked_source_directory, "pyproject.toml") BuildSystemDetails = namedtuple( "BuildSystemDetails", ["requires", "backend", "check", "backend_path"] ) def load_pyproject_toml( pyproject_toml: str, setup_py: str, req_name: str ) -> BuildSystemDetails: """Load the pyproject.toml file. Parameters: pyproject_toml - Location of the project's pyproject.toml file setup_py - Location of the project's setup.py file req_name - The name of the requirement we're processing (for error reporting) Returns: None if we should use the legacy code path, otherwise a tuple ( requirements from pyproject.toml, name of PEP 517 backend, requirements we should check are installed after setting up the build environment directory paths to import the backend from (backend-path), relative to the project root. ) """ has_pyproject = os.path.isfile(pyproject_toml) has_setup = os.path.isfile(setup_py) if not has_pyproject and not has_setup: raise InstallationError( f"{req_name} does not appear to be a Python project: " f"neither 'setup.py' nor 'pyproject.toml' found." ) if has_pyproject: with open(pyproject_toml, encoding="utf-8") as f: pp_toml = tomllib.loads(f.read()) build_system = pp_toml.get("build-system") else: build_system = None if build_system is None: # In the absence of any explicit backend specification, we # assume the setuptools backend that most closely emulates the # traditional direct setup.py execution, and require wheel and # a version of setuptools that supports that backend. build_system = { "requires": ["setuptools>=40.8.0"], "build-backend": "setuptools.build_meta:__legacy__", } # Ensure that the build-system section in pyproject.toml conforms # to PEP 518. # Specifying the build-system table but not the requires key is invalid if "requires" not in build_system: raise MissingPyProjectBuildRequires(package=req_name) # Error out if requires is not a list of strings requires = build_system["requires"] if not _is_list_of_str(requires): raise InvalidPyProjectBuildRequires( package=req_name, reason="It is not a list of strings.", ) # Each requirement must be valid as per PEP 508 for requirement in requires: try: get_requirement(requirement) except InvalidRequirement as error: raise InvalidPyProjectBuildRequires( package=req_name, reason=f"It contains an invalid requirement: {requirement!r}", ) from error backend = build_system.get("build-backend") backend_path = build_system.get("backend-path", []) check: list[str] = [] if backend is None: # If the user didn't specify a backend, we assume they want to use # the setuptools backend. But we can't be sure they have included # a version of setuptools which supplies the backend. So we # make a note to check that this requirement is present once # we have set up the environment. # This is quite a lot of work to check for a very specific case. But # the problem is, that case is potentially quite common - projects that # adopted PEP 518 early for the ability to specify requirements to # execute setup.py, but never considered needing to mention the build # tools themselves. The original PEP 518 code had a similar check (but # implemented in a different way). backend = "setuptools.build_meta:__legacy__" check = ["setuptools>=40.8.0"] return BuildSystemDetails(requires, backend, check, backend_path)	4.45 KB	2026-01-20 12:58
📁 req	-	2026-03-21 15:45
📁 resolution	-	2026-03-21 15:45
📄 self_outdated_check.py from __future__ import annotations import datetime import functools import hashlib import json import logging import optparse import os.path import sys from dataclasses import dataclass from typing import Any, Callable from pip._vendor.packaging.version import Version from pip._vendor.packaging.version import parse as parse_version from pip._vendor.rich.console import Group from pip._vendor.rich.markup import escape from pip._vendor.rich.text import Text from pip._internal.index.collector import LinkCollector from pip._internal.index.package_finder import PackageFinder from pip._internal.metadata import get_default_environment from pip._internal.models.selection_prefs import SelectionPreferences from pip._internal.network.session import PipSession from pip._internal.utils.compat import WINDOWS from pip._internal.utils.entrypoints import ( get_best_invocation_for_this_pip, get_best_invocation_for_this_python, ) from pip._internal.utils.filesystem import ( adjacent_tmp_file, check_path_owner, copy_directory_permissions, replace, ) from pip._internal.utils.misc import ( ExternallyManagedEnvironment, check_externally_managed, ensure_dir, ) _WEEK = datetime.timedelta(days=7) logger = logging.getLogger(__name__) def _get_statefile_name(key: str) -> str: key_bytes = key.encode() name = hashlib.sha224(key_bytes).hexdigest() return name def _convert_date(isodate: str) -> datetime.datetime: """Convert an ISO format string to a date. Handles the format 2020-01-22T14:24:01Z (trailing Z) which is not supported by older versions of fromisoformat. """ return datetime.datetime.fromisoformat(isodate.replace("Z", "+00:00")) class SelfCheckState: def __init__(self, cache_dir: str) -> None: self._state: dict[str, Any] = {} self._statefile_path = None # Try to load the existing state if cache_dir: self._statefile_path = os.path.join( cache_dir, "selfcheck", _get_statefile_name(self.key) ) try: with open(self._statefile_path, encoding="utf-8") as statefile: self._state = json.load(statefile) except (OSError, ValueError, KeyError): # Explicitly suppressing exceptions, since we don't want to # error out if the cache file is invalid. pass @property def key(self) -> str: return sys.prefix def get(self, current_time: datetime.datetime) -> str \| None: """Check if we have a not-outdated version loaded already.""" if not self._state: return None if "last_check" not in self._state: return None if "pypi_version" not in self._state: return None # Determine if we need to refresh the state last_check = _convert_date(self._state["last_check"]) time_since_last_check = current_time - last_check if time_since_last_check > _WEEK: return None return self._state["pypi_version"] def set(self, pypi_version: str, current_time: datetime.datetime) -> None: # If we do not have a path to cache in, don't bother saving. if not self._statefile_path: return statefile_directory = os.path.dirname(self._statefile_path) # Check to make sure that we own the directory if not check_path_owner(statefile_directory): return # Now that we've ensured the directory is owned by this user, we'll go # ahead and make sure that all our directories are created. ensure_dir(statefile_directory) state = { # Include the key so it's easy to tell which pip wrote the # file. "key": self.key, "last_check": current_time.isoformat(), "pypi_version": pypi_version, } text = json.dumps(state, sort_keys=True, separators=(",", ":")) with adjacent_tmp_file(self._statefile_path) as f: f.write(text.encode()) copy_directory_permissions(statefile_directory, f) try: # Since we have a prefix-specific state file, we can just # overwrite whatever is there, no need to check. replace(f.name, self._statefile_path) except OSError: # Best effort. pass @dataclass class UpgradePrompt: old: str new: str def __rich__(self) -> Group: if WINDOWS: pip_cmd = f"{get_best_invocation_for_this_python()} -m pip" else: pip_cmd = get_best_invocation_for_this_pip() notice = "[bold][[reset][blue]notice[reset][bold]][reset]" return Group( Text(), Text.from_markup( f"{notice} A new release of pip is available: " f"[red]{self.old}[reset] -> [green]{self.new}[reset]" ), Text.from_markup( f"{notice} To update, run: " f"[green]{escape(pip_cmd)} install --upgrade pip" ), ) def was_installed_by_pip(pkg: str) -> bool: """Checks whether pkg was installed by pip This is used not to display the upgrade message when pip is in fact installed by system package manager, such as dnf on Fedora. """ dist = get_default_environment().get_distribution(pkg) return dist is not None and "pip" == dist.installer def _get_current_remote_pip_version( session: PipSession, options: optparse.Values ) -> str \| None: # Lets use PackageFinder to see what the latest pip version is link_collector = LinkCollector.create( session, options=options, suppress_no_index=True, ) # Pass allow_yanked=False so we don't suggest upgrading to a # yanked version. selection_prefs = SelectionPreferences( allow_yanked=False, allow_all_prereleases=False, # Explicitly set to False ) finder = PackageFinder.create( link_collector=link_collector, selection_prefs=selection_prefs, ) best_candidate = finder.find_best_candidate("pip").best_candidate if best_candidate is None: return None return str(best_candidate.version) def _self_version_check_logic( *, state: SelfCheckState, current_time: datetime.datetime, local_version: Version, get_remote_version: Callable[[], str \| None], ) -> UpgradePrompt \| None: remote_version_str = state.get(current_time) if remote_version_str is None: remote_version_str = get_remote_version() if remote_version_str is None: logger.debug("No remote pip version found") return None state.set(remote_version_str, current_time) remote_version = parse_version(remote_version_str) logger.debug("Remote version of pip: %s", remote_version) logger.debug("Local version of pip: %s", local_version) pip_installed_by_pip = was_installed_by_pip("pip") logger.debug("Was pip installed by pip? %s", pip_installed_by_pip) if not pip_installed_by_pip: return None # Only suggest upgrade if pip is installed by pip. local_version_is_older = ( local_version < remote_version and local_version.base_version != remote_version.base_version ) if local_version_is_older: return UpgradePrompt(old=str(local_version), new=remote_version_str) return None def pip_self_version_check(session: PipSession, options: optparse.Values) -> None: """Check for an update for pip. Limit the frequency of checks to once per week. State is stored either in the active virtualenv or in the user's USER_CACHE_DIR keyed off the prefix of the pip script path. """ installed_dist = get_default_environment().get_distribution("pip") if not installed_dist: return try: check_externally_managed() except ExternallyManagedEnvironment: return upgrade_prompt = _self_version_check_logic( state=SelfCheckState(cache_dir=options.cache_dir), current_time=datetime.datetime.now(datetime.timezone.utc), local_version=installed_dist.version, get_remote_version=functools.partial( _get_current_remote_pip_version, session, options ), ) if upgrade_prompt is not None: logger.warning("%s", upgrade_prompt, extra={"rich": True})	8.27 KB	2026-01-20 12:58
📁 utils	-	2026-03-21 15:56
📁 vcs	-	2026-03-21 15:45
📄 wheel_builder.py """Orchestrator for building wheels from InstallRequirements.""" from __future__ import annotations import logging import os.path import re from collections.abc import Iterable from tempfile import TemporaryDirectory from pip._vendor.packaging.utils import canonicalize_name, canonicalize_version from pip._vendor.packaging.version import InvalidVersion, Version from pip._internal.cache import WheelCache from pip._internal.exceptions import InvalidWheelFilename, UnsupportedWheel from pip._internal.metadata import FilesystemWheel, get_wheel_distribution from pip._internal.models.link import Link from pip._internal.models.wheel import Wheel from pip._internal.operations.build.wheel import build_wheel_pep517 from pip._internal.operations.build.wheel_editable import build_wheel_editable from pip._internal.req.req_install import InstallRequirement from pip._internal.utils.logging import indent_log from pip._internal.utils.misc import ensure_dir, hash_file from pip._internal.utils.urls import path_to_url from pip._internal.vcs import vcs logger = logging.getLogger(__name__) _egg_info_re = re.compile(r"([a-z0-9_.]+)-([a-z0-9_.!+-]+)", re.IGNORECASE) BuildResult = tuple[list[InstallRequirement], list[InstallRequirement]] def _contains_egg_info(s: str) -> bool: """Determine whether the string looks like an egg_info. :param s: The string to parse. E.g. foo-2.1 """ return bool(_egg_info_re.search(s)) def _should_cache( req: InstallRequirement, ) -> bool \| None: """ Return whether a built InstallRequirement can be stored in the persistent wheel cache, assuming the wheel cache is available. """ if req.editable or not req.source_dir: # never cache editable requirements return False if req.link and req.link.is_vcs: # VCS checkout. Do not cache # unless it points to an immutable commit hash. assert not req.editable assert req.source_dir vcs_backend = vcs.get_backend_for_scheme(req.link.scheme) assert vcs_backend if vcs_backend.is_immutable_rev_checkout(req.link.url, req.source_dir): return True return False assert req.link base, ext = req.link.splitext() if _contains_egg_info(base): return True # Otherwise, do not cache. return False def _get_cache_dir( req: InstallRequirement, wheel_cache: WheelCache, ) -> str: """Return the persistent or temporary cache directory where the built wheel need to be stored. """ cache_available = bool(wheel_cache.cache_dir) assert req.link if cache_available and _should_cache(req): cache_dir = wheel_cache.get_path_for_link(req.link) else: cache_dir = wheel_cache.get_ephem_path_for_link(req.link) return cache_dir def _verify_one(req: InstallRequirement, wheel_path: str) -> None: canonical_name = canonicalize_name(req.name or "") w = Wheel(os.path.basename(wheel_path)) if w.name != canonical_name: raise InvalidWheelFilename( f"Wheel has unexpected file name: expected {canonical_name!r}, " f"got {w.name!r}", ) dist = get_wheel_distribution(FilesystemWheel(wheel_path), canonical_name) dist_verstr = str(dist.version) if canonicalize_version(dist_verstr) != canonicalize_version(w.version): raise InvalidWheelFilename( f"Wheel has unexpected file name: expected {dist_verstr!r}, " f"got {w.version!r}", ) metadata_version_value = dist.metadata_version if metadata_version_value is None: raise UnsupportedWheel("Missing Metadata-Version") try: metadata_version = Version(metadata_version_value) except InvalidVersion: msg = f"Invalid Metadata-Version: {metadata_version_value}" raise UnsupportedWheel(msg) if metadata_version >= Version("1.2") and not isinstance(dist.version, Version): raise UnsupportedWheel( f"Metadata 1.2 mandates PEP 440 version, but {dist_verstr!r} is not" ) def _build_one( req: InstallRequirement, output_dir: str, verify: bool, editable: bool, ) -> str \| None: """Build one wheel. :return: The filename of the built wheel, or None if the build failed. """ artifact = "editable" if editable else "wheel" try: ensure_dir(output_dir) except OSError as e: logger.warning( "Building %s for %s failed: %s", artifact, req.name, e, ) return None # Install build deps into temporary directory (PEP 518) with req.build_env: wheel_path = _build_one_inside_env(req, output_dir, editable) if wheel_path and verify: try: _verify_one(req, wheel_path) except (InvalidWheelFilename, UnsupportedWheel) as e: logger.warning("Built %s for %s is invalid: %s", artifact, req.name, e) return None return wheel_path def _build_one_inside_env( req: InstallRequirement, output_dir: str, editable: bool, ) -> str \| None: with TemporaryDirectory(dir=output_dir) as wheel_directory: assert req.name assert req.metadata_directory assert req.pep517_backend if editable: wheel_path = build_wheel_editable( name=req.name, backend=req.pep517_backend, metadata_directory=req.metadata_directory, wheel_directory=wheel_directory, ) else: wheel_path = build_wheel_pep517( name=req.name, backend=req.pep517_backend, metadata_directory=req.metadata_directory, wheel_directory=wheel_directory, ) if wheel_path is not None: wheel_name = os.path.basename(wheel_path) dest_path = os.path.join(output_dir, wheel_name) try: wheel_hash, length = hash_file(wheel_path) # We can do a replace here because wheel_path is guaranteed to # be in the same filesystem as output_dir. This will perform an # atomic rename, which is necessary to avoid concurrency issues # when populating the cache. os.replace(wheel_path, dest_path) logger.info( "Created wheel for %s: filename=%s size=%d sha256=%s", req.name, wheel_name, length, wheel_hash.hexdigest(), ) logger.info("Stored in directory: %s", output_dir) return dest_path except Exception as e: logger.warning( "Building wheel for %s failed: %s", req.name, e, ) return None def build( requirements: Iterable[InstallRequirement], wheel_cache: WheelCache, verify: bool, ) -> BuildResult: """Build wheels. :return: The list of InstallRequirement that succeeded to build and the list of InstallRequirement that failed to build. """ if not requirements: return [], [] # Build the wheels. logger.info( "Building wheels for collected packages: %s", ", ".join(req.name for req in requirements), # type: ignore ) with indent_log(): build_successes, build_failures = [], [] for req in requirements: assert req.name cache_dir = _get_cache_dir(req, wheel_cache) wheel_file = _build_one( req, cache_dir, verify, req.editable and req.permit_editable_wheels, ) if wheel_file: # Record the download origin in the cache if req.download_info is not None: # download_info is guaranteed to be set because when we build an # InstallRequirement it has been through the preparer before, but # let's be cautious. wheel_cache.record_download_origin(cache_dir, req.download_info) # Update the link for this. req.link = Link(path_to_url(wheel_file)) req.local_file_path = req.link.file_path assert req.link.is_wheel build_successes.append(req) else: build_failures.append(req) # notify success/failure if build_successes: logger.info( "Successfully built %s", " ".join([req.name for req in build_successes]), # type: ignore ) if build_failures: logger.info( "Failed to build %s", " ".join([req.name for req in build_failures]), # type: ignore ) # Return a list of requirements that failed to build return build_successes, build_failures	8.8 KB	2026-01-20 12:58

Edit File:

Terminal