File manager - Edit - /home/newsbmcs.com/public_html/static/img/logo/resolution.tar
Back
base.py 0000644 00000001107 15030103266 0006023 0 ustar 00 from typing import Callable, List, Optional from pip._internal.req.req_install import InstallRequirement from pip._internal.req.req_set import RequirementSet InstallRequirementProvider = Callable[ [str, Optional[InstallRequirement]], InstallRequirement ] class BaseResolver: def resolve( self, root_reqs: List[InstallRequirement], check_supported_wheels: bool ) -> RequirementSet: raise NotImplementedError() def get_installation_order( self, req_set: RequirementSet ) -> List[InstallRequirement]: raise NotImplementedError() __pycache__/__init__.cpython-310.pyc 0000644 00000000261 15030103266 0013207 0 ustar 00 o �h � @ s d S )N� r r r �T/usr/local/CyberCP/lib/python3.10/site-packages/pip/_internal/resolution/__init__.py�<module> s __pycache__/base.cpython-310.pyc 0000644 00000002005 15030103266 0012360 0 ustar 00 o �hG � @ sR d dl mZmZmZ d dlmZ d dlmZ eeee gef Z G dd� d�Z dS )� )�Callable�List�Optional)�InstallRequirement)�RequirementSetc @ s< e Zd Zdee dedefdd�Zdedee fdd�Zd S ) � BaseResolver� root_reqs�check_supported_wheels�returnc C � t � ��N��NotImplementedError)�selfr r � r �P/usr/local/CyberCP/lib/python3.10/site-packages/pip/_internal/resolution/base.py�resolve � zBaseResolver.resolve�req_setc C r r r )r r r r r �get_installation_order r z#BaseResolver.get_installation_orderN) �__name__� __module__� __qualname__r r �boolr r r r r r r r s �� ���r N) �typingr r r � pip._internal.req.req_installr �pip._internal.req.req_setr �str�InstallRequirementProviderr r r r r �<module> s � legacy/resolver.py 0000644 00000057004 15030103266 0010225 0 ustar 00 """Dependency Resolution The dependency resolution in pip is performed as follows: for top-level requirements: a. only one spec allowed per project, regardless of conflicts or not. otherwise a "double requirement" exception is raised b. they override sub-dependency requirements. for sub-dependencies a. "first found, wins" (where the order is breadth first) """ import logging import sys from collections import defaultdict from itertools import chain from typing import DefaultDict, Iterable, List, Optional, Set, Tuple from pip._vendor.packaging import specifiers from pip._vendor.packaging.requirements import Requirement from pip._internal.cache import WheelCache from pip._internal.exceptions import ( BestVersionAlreadyInstalled, DistributionNotFound, HashError, HashErrors, InstallationError, NoneMetadataError, UnsupportedPythonVersion, ) from pip._internal.index.package_finder import PackageFinder from pip._internal.metadata import BaseDistribution from pip._internal.models.link import Link from pip._internal.models.wheel import Wheel from pip._internal.operations.prepare import RequirementPreparer from pip._internal.req.req_install import ( InstallRequirement, check_invalid_constraint_type, ) from pip._internal.req.req_set import RequirementSet from pip._internal.resolution.base import BaseResolver, InstallRequirementProvider from pip._internal.utils import compatibility_tags from pip._internal.utils.compatibility_tags import get_supported from pip._internal.utils.direct_url_helpers import direct_url_from_link from pip._internal.utils.logging import indent_log from pip._internal.utils.misc import normalize_version_info from pip._internal.utils.packaging import check_requires_python logger = logging.getLogger(__name__) DiscoveredDependencies = DefaultDict[Optional[str], List[InstallRequirement]] def _check_dist_requires_python( dist: BaseDistribution, version_info: Tuple[int, int, int], ignore_requires_python: bool = False, ) -> None: """ Check whether the given Python version is compatible with a distribution's "Requires-Python" value. :param version_info: A 3-tuple of ints representing the Python major-minor-micro version to check. :param ignore_requires_python: Whether to ignore the "Requires-Python" value if the given Python version isn't compatible. :raises UnsupportedPythonVersion: When the given Python version isn't compatible. """ # This idiosyncratically converts the SpecifierSet to str and let # check_requires_python then parse it again into SpecifierSet. But this # is the legacy resolver so I'm just not going to bother refactoring. try: requires_python = str(dist.requires_python) except FileNotFoundError as e: raise NoneMetadataError(dist, str(e)) try: is_compatible = check_requires_python( requires_python, version_info=version_info, ) except specifiers.InvalidSpecifier as exc: logger.warning( "Package %r has an invalid Requires-Python: %s", dist.raw_name, exc ) return if is_compatible: return version = ".".join(map(str, version_info)) if ignore_requires_python: logger.debug( "Ignoring failed Requires-Python check for package %r: %s not in %r", dist.raw_name, version, requires_python, ) return raise UnsupportedPythonVersion( f"Package {dist.raw_name!r} requires a different Python: " f"{version} not in {requires_python!r}" ) class Resolver(BaseResolver): """Resolves which packages need to be installed/uninstalled to perform \ the requested operation without breaking the requirements of any package. """ _allowed_strategies = {"eager", "only-if-needed", "to-satisfy-only"} def __init__( self, preparer: RequirementPreparer, finder: PackageFinder, wheel_cache: Optional[WheelCache], make_install_req: InstallRequirementProvider, use_user_site: bool, ignore_dependencies: bool, ignore_installed: bool, ignore_requires_python: bool, force_reinstall: bool, upgrade_strategy: str, py_version_info: Optional[Tuple[int, ...]] = None, ) -> None: super().__init__() assert upgrade_strategy in self._allowed_strategies if py_version_info is None: py_version_info = sys.version_info[:3] else: py_version_info = normalize_version_info(py_version_info) self._py_version_info = py_version_info self.preparer = preparer self.finder = finder self.wheel_cache = wheel_cache self.upgrade_strategy = upgrade_strategy self.force_reinstall = force_reinstall self.ignore_dependencies = ignore_dependencies self.ignore_installed = ignore_installed self.ignore_requires_python = ignore_requires_python self.use_user_site = use_user_site self._make_install_req = make_install_req self._discovered_dependencies: DiscoveredDependencies = defaultdict(list) def resolve( self, root_reqs: List[InstallRequirement], check_supported_wheels: bool ) -> RequirementSet: """Resolve what operations need to be done As a side-effect of this method, the packages (and their dependencies) are downloaded, unpacked and prepared for installation. This preparation is done by ``pip.operations.prepare``. Once PyPI has static dependency metadata available, it would be possible to move the preparation to become a step separated from dependency resolution. """ requirement_set = RequirementSet(check_supported_wheels=check_supported_wheels) for req in root_reqs: if req.constraint: check_invalid_constraint_type(req) self._add_requirement_to_set(requirement_set, req) # Actually prepare the files, and collect any exceptions. Most hash # exceptions cannot be checked ahead of time, because # _populate_link() needs to be called before we can make decisions # based on link type. discovered_reqs: List[InstallRequirement] = [] hash_errors = HashErrors() for req in chain(requirement_set.all_requirements, discovered_reqs): try: discovered_reqs.extend(self._resolve_one(requirement_set, req)) except HashError as exc: exc.req = req hash_errors.append(exc) if hash_errors: raise hash_errors return requirement_set def _add_requirement_to_set( self, requirement_set: RequirementSet, install_req: InstallRequirement, parent_req_name: Optional[str] = None, extras_requested: Optional[Iterable[str]] = None, ) -> Tuple[List[InstallRequirement], Optional[InstallRequirement]]: """Add install_req as a requirement to install. :param parent_req_name: The name of the requirement that needed this added. The name is used because when multiple unnamed requirements resolve to the same name, we could otherwise end up with dependency links that point outside the Requirements set. parent_req must already be added. Note that None implies that this is a user supplied requirement, vs an inferred one. :param extras_requested: an iterable of extras used to evaluate the environment markers. :return: Additional requirements to scan. That is either [] if the requirement is not applicable, or [install_req] if the requirement is applicable and has just been added. """ # If the markers do not match, ignore this requirement. if not install_req.match_markers(extras_requested): logger.info( "Ignoring %s: markers '%s' don't match your environment", install_req.name, install_req.markers, ) return [], None # If the wheel is not supported, raise an error. # Should check this after filtering out based on environment markers to # allow specifying different wheels based on the environment/OS, in a # single requirements file. if install_req.link and install_req.link.is_wheel: wheel = Wheel(install_req.link.filename) tags = compatibility_tags.get_supported() if requirement_set.check_supported_wheels and not wheel.supported(tags): raise InstallationError( f"{wheel.filename} is not a supported wheel on this platform." ) # This next bit is really a sanity check. assert ( not install_req.user_supplied or parent_req_name is None ), "a user supplied req shouldn't have a parent" # Unnamed requirements are scanned again and the requirement won't be # added as a dependency until after scanning. if not install_req.name: requirement_set.add_unnamed_requirement(install_req) return [install_req], None try: existing_req: Optional[InstallRequirement] = ( requirement_set.get_requirement(install_req.name) ) except KeyError: existing_req = None has_conflicting_requirement = ( parent_req_name is None and existing_req and not existing_req.constraint and existing_req.extras == install_req.extras and existing_req.req and install_req.req and existing_req.req.specifier != install_req.req.specifier ) if has_conflicting_requirement: raise InstallationError( f"Double requirement given: {install_req} " f"(already in {existing_req}, name={install_req.name!r})" ) # When no existing requirement exists, add the requirement as a # dependency and it will be scanned again after. if not existing_req: requirement_set.add_named_requirement(install_req) # We'd want to rescan this requirement later return [install_req], install_req # Assume there's no need to scan, and that we've already # encountered this for scanning. if install_req.constraint or not existing_req.constraint: return [], existing_req does_not_satisfy_constraint = install_req.link and not ( existing_req.link and install_req.link.path == existing_req.link.path ) if does_not_satisfy_constraint: raise InstallationError( f"Could not satisfy constraints for '{install_req.name}': " "installation from path or url cannot be " "constrained to a version" ) # If we're now installing a constraint, mark the existing # object for real installation. existing_req.constraint = False # If we're now installing a user supplied requirement, # mark the existing object as such. if install_req.user_supplied: existing_req.user_supplied = True existing_req.extras = tuple( sorted(set(existing_req.extras) | set(install_req.extras)) ) logger.debug( "Setting %s extras to: %s", existing_req, existing_req.extras, ) # Return the existing requirement for addition to the parent and # scanning again. return [existing_req], existing_req def _is_upgrade_allowed(self, req: InstallRequirement) -> bool: if self.upgrade_strategy == "to-satisfy-only": return False elif self.upgrade_strategy == "eager": return True else: assert self.upgrade_strategy == "only-if-needed" return req.user_supplied or req.constraint def _set_req_to_reinstall(self, req: InstallRequirement) -> None: """ Set a requirement to be installed. """ # Don't uninstall the conflict if doing a user install and the # conflict is not a user install. assert req.satisfied_by is not None if not self.use_user_site or req.satisfied_by.in_usersite: req.should_reinstall = True req.satisfied_by = None def _check_skip_installed( self, req_to_install: InstallRequirement ) -> Optional[str]: """Check if req_to_install should be skipped. This will check if the req is installed, and whether we should upgrade or reinstall it, taking into account all the relevant user options. After calling this req_to_install will only have satisfied_by set to None if the req_to_install is to be upgraded/reinstalled etc. Any other value will be a dist recording the current thing installed that satisfies the requirement. Note that for vcs urls and the like we can't assess skipping in this routine - we simply identify that we need to pull the thing down, then later on it is pulled down and introspected to assess upgrade/ reinstalls etc. :return: A text reason for why it was skipped, or None. """ if self.ignore_installed: return None req_to_install.check_if_exists(self.use_user_site) if not req_to_install.satisfied_by: return None if self.force_reinstall: self._set_req_to_reinstall(req_to_install) return None if not self._is_upgrade_allowed(req_to_install): if self.upgrade_strategy == "only-if-needed": return "already satisfied, skipping upgrade" return "already satisfied" # Check for the possibility of an upgrade. For link-based # requirements we have to pull the tree down and inspect to assess # the version #, so it's handled way down. if not req_to_install.link: try: self.finder.find_requirement(req_to_install, upgrade=True) except BestVersionAlreadyInstalled: # Then the best version is installed. return "already up-to-date" except DistributionNotFound: # No distribution found, so we squash the error. It will # be raised later when we re-try later to do the install. # Why don't we just raise here? pass self._set_req_to_reinstall(req_to_install) return None def _find_requirement_link(self, req: InstallRequirement) -> Optional[Link]: upgrade = self._is_upgrade_allowed(req) best_candidate = self.finder.find_requirement(req, upgrade) if not best_candidate: return None # Log a warning per PEP 592 if necessary before returning. link = best_candidate.link if link.is_yanked: reason = link.yanked_reason or "<none given>" msg = ( # Mark this as a unicode string to prevent # "UnicodeEncodeError: 'ascii' codec can't encode character" # in Python 2 when the reason contains non-ascii characters. "The candidate selected for download or install is a " f"yanked version: {best_candidate}\n" f"Reason for being yanked: {reason}" ) logger.warning(msg) return link def _populate_link(self, req: InstallRequirement) -> None: """Ensure that if a link can be found for this, that it is found. Note that req.link may still be None - if the requirement is already installed and not needed to be upgraded based on the return value of _is_upgrade_allowed(). If preparer.require_hashes is True, don't use the wheel cache, because cached wheels, always built locally, have different hashes than the files downloaded from the index server and thus throw false hash mismatches. Furthermore, cached wheels at present have undeterministic contents due to file modification times. """ if req.link is None: req.link = self._find_requirement_link(req) if self.wheel_cache is None or self.preparer.require_hashes: return assert req.link is not None, "_find_requirement_link unexpectedly returned None" cache_entry = self.wheel_cache.get_cache_entry( link=req.link, package_name=req.name, supported_tags=get_supported(), ) if cache_entry is not None: logger.debug("Using cached wheel link: %s", cache_entry.link) if req.link is req.original_link and cache_entry.persistent: req.cached_wheel_source_link = req.link if cache_entry.origin is not None: req.download_info = cache_entry.origin else: # Legacy cache entry that does not have origin.json. # download_info may miss the archive_info.hashes field. req.download_info = direct_url_from_link( req.link, link_is_in_wheel_cache=cache_entry.persistent ) req.link = cache_entry.link def _get_dist_for(self, req: InstallRequirement) -> BaseDistribution: """Takes a InstallRequirement and returns a single AbstractDist \ representing a prepared variant of the same. """ if req.editable: return self.preparer.prepare_editable_requirement(req) # satisfied_by is only evaluated by calling _check_skip_installed, # so it must be None here. assert req.satisfied_by is None skip_reason = self._check_skip_installed(req) if req.satisfied_by: return self.preparer.prepare_installed_requirement(req, skip_reason) # We eagerly populate the link, since that's our "legacy" behavior. self._populate_link(req) dist = self.preparer.prepare_linked_requirement(req) # NOTE # The following portion is for determining if a certain package is # going to be re-installed/upgraded or not and reporting to the user. # This should probably get cleaned up in a future refactor. # req.req is only avail after unpack for URL # pkgs repeat check_if_exists to uninstall-on-upgrade # (#14) if not self.ignore_installed: req.check_if_exists(self.use_user_site) if req.satisfied_by: should_modify = ( self.upgrade_strategy != "to-satisfy-only" or self.force_reinstall or self.ignore_installed or req.link.scheme == "file" ) if should_modify: self._set_req_to_reinstall(req) else: logger.info( "Requirement already satisfied (use --upgrade to upgrade): %s", req, ) return dist def _resolve_one( self, requirement_set: RequirementSet, req_to_install: InstallRequirement, ) -> List[InstallRequirement]: """Prepare a single requirements file. :return: A list of additional InstallRequirements to also install. """ # Tell user what we are doing for this requirement: # obtain (editable), skipping, processing (local url), collecting # (remote url or package name) if req_to_install.constraint or req_to_install.prepared: return [] req_to_install.prepared = True # Parse and return dependencies dist = self._get_dist_for(req_to_install) # This will raise UnsupportedPythonVersion if the given Python # version isn't compatible with the distribution's Requires-Python. _check_dist_requires_python( dist, version_info=self._py_version_info, ignore_requires_python=self.ignore_requires_python, ) more_reqs: List[InstallRequirement] = [] def add_req(subreq: Requirement, extras_requested: Iterable[str]) -> None: # This idiosyncratically converts the Requirement to str and let # make_install_req then parse it again into Requirement. But this is # the legacy resolver so I'm just not going to bother refactoring. sub_install_req = self._make_install_req(str(subreq), req_to_install) parent_req_name = req_to_install.name to_scan_again, add_to_parent = self._add_requirement_to_set( requirement_set, sub_install_req, parent_req_name=parent_req_name, extras_requested=extras_requested, ) if parent_req_name and add_to_parent: self._discovered_dependencies[parent_req_name].append(add_to_parent) more_reqs.extend(to_scan_again) with indent_log(): # We add req_to_install before its dependencies, so that we # can refer to it when adding dependencies. assert req_to_install.name is not None if not requirement_set.has_requirement(req_to_install.name): # 'unnamed' requirements will get added here # 'unnamed' requirements can only come from being directly # provided by the user. assert req_to_install.user_supplied self._add_requirement_to_set( requirement_set, req_to_install, parent_req_name=None ) if not self.ignore_dependencies: if req_to_install.extras: logger.debug( "Installing extra requirements: %r", ",".join(req_to_install.extras), ) missing_requested = sorted( set(req_to_install.extras) - set(dist.iter_provided_extras()) ) for missing in missing_requested: logger.warning( "%s %s does not provide the extra '%s'", dist.raw_name, dist.version, missing, ) available_requested = sorted( set(dist.iter_provided_extras()) & set(req_to_install.extras) ) for subreq in dist.iter_dependencies(available_requested): add_req(subreq, extras_requested=available_requested) return more_reqs def get_installation_order( self, req_set: RequirementSet ) -> List[InstallRequirement]: """Create the installation order. The installation order is topological - requirements are installed before the requiring thing. We break cycles at an arbitrary point, and make no other guarantees. """ # The current implementation, which we may change at any point # installs the user specified things in the order given, except when # dependencies must come earlier to achieve topological order. order = [] ordered_reqs: Set[InstallRequirement] = set() def schedule(req: InstallRequirement) -> None: if req.satisfied_by or req in ordered_reqs: return if req.constraint: return ordered_reqs.add(req) for dep in self._discovered_dependencies[req.name]: schedule(dep) order.append(req) for install_req in req_set.requirements.values(): schedule(install_req) return order legacy/__init__.py 0000644 00000000000 15030103266 0010103 0 ustar 00 resolvelib/requirements.py 0000644 00000017601 15030103266 0012010 0 ustar 00 from typing import Any, Optional from pip._vendor.packaging.specifiers import SpecifierSet from pip._vendor.packaging.utils import NormalizedName, canonicalize_name from pip._internal.req.constructors import install_req_drop_extras from pip._internal.req.req_install import InstallRequirement from .base import Candidate, CandidateLookup, Requirement, format_name class ExplicitRequirement(Requirement): def __init__(self, candidate: Candidate) -> None: self.candidate = candidate def __str__(self) -> str: return str(self.candidate) def __repr__(self) -> str: return f"{self.__class__.__name__}({self.candidate!r})" def __hash__(self) -> int: return hash(self.candidate) def __eq__(self, other: Any) -> bool: if not isinstance(other, ExplicitRequirement): return False return self.candidate == other.candidate @property def project_name(self) -> NormalizedName: # No need to canonicalize - the candidate did this return self.candidate.project_name @property def name(self) -> str: # No need to canonicalize - the candidate did this return self.candidate.name def format_for_error(self) -> str: return self.candidate.format_for_error() def get_candidate_lookup(self) -> CandidateLookup: return self.candidate, None def is_satisfied_by(self, candidate: Candidate) -> bool: return candidate == self.candidate class SpecifierRequirement(Requirement): def __init__(self, ireq: InstallRequirement) -> None: assert ireq.link is None, "This is a link, not a specifier" self._ireq = ireq self._equal_cache: Optional[str] = None self._hash: Optional[int] = None self._extras = frozenset(canonicalize_name(e) for e in self._ireq.extras) @property def _equal(self) -> str: if self._equal_cache is not None: return self._equal_cache self._equal_cache = str(self._ireq) return self._equal_cache def __str__(self) -> str: return str(self._ireq.req) def __repr__(self) -> str: return f"{self.__class__.__name__}({str(self._ireq.req)!r})" def __eq__(self, other: object) -> bool: if not isinstance(other, SpecifierRequirement): return NotImplemented return self._equal == other._equal def __hash__(self) -> int: if self._hash is not None: return self._hash self._hash = hash(self._equal) return self._hash @property def project_name(self) -> NormalizedName: assert self._ireq.req, "Specifier-backed ireq is always PEP 508" return canonicalize_name(self._ireq.req.name) @property def name(self) -> str: return format_name(self.project_name, self._extras) def format_for_error(self) -> str: # Convert comma-separated specifiers into "A, B, ..., F and G" # This makes the specifier a bit more "human readable", without # risking a change in meaning. (Hopefully! Not all edge cases have # been checked) parts = [s.strip() for s in str(self).split(",")] if len(parts) == 0: return "" elif len(parts) == 1: return parts[0] return ", ".join(parts[:-1]) + " and " + parts[-1] def get_candidate_lookup(self) -> CandidateLookup: return None, self._ireq def is_satisfied_by(self, candidate: Candidate) -> bool: assert candidate.name == self.name, ( f"Internal issue: Candidate is not for this requirement " f"{candidate.name} vs {self.name}" ) # We can safely always allow prereleases here since PackageFinder # already implements the prerelease logic, and would have filtered out # prerelease candidates if the user does not expect them. assert self._ireq.req, "Specifier-backed ireq is always PEP 508" spec = self._ireq.req.specifier return spec.contains(candidate.version, prereleases=True) class SpecifierWithoutExtrasRequirement(SpecifierRequirement): """ Requirement backed by an install requirement on a base package. Trims extras from its install requirement if there are any. """ def __init__(self, ireq: InstallRequirement) -> None: assert ireq.link is None, "This is a link, not a specifier" self._ireq = install_req_drop_extras(ireq) self._equal_cache: Optional[str] = None self._hash: Optional[int] = None self._extras = frozenset(canonicalize_name(e) for e in self._ireq.extras) @property def _equal(self) -> str: if self._equal_cache is not None: return self._equal_cache self._equal_cache = str(self._ireq) return self._equal_cache def __eq__(self, other: object) -> bool: if not isinstance(other, SpecifierWithoutExtrasRequirement): return NotImplemented return self._equal == other._equal def __hash__(self) -> int: if self._hash is not None: return self._hash self._hash = hash(self._equal) return self._hash class RequiresPythonRequirement(Requirement): """A requirement representing Requires-Python metadata.""" def __init__(self, specifier: SpecifierSet, match: Candidate) -> None: self.specifier = specifier self._specifier_string = str(specifier) # for faster __eq__ self._hash: Optional[int] = None self._candidate = match def __str__(self) -> str: return f"Python {self.specifier}" def __repr__(self) -> str: return f"{self.__class__.__name__}({str(self.specifier)!r})" def __hash__(self) -> int: if self._hash is not None: return self._hash self._hash = hash((self._specifier_string, self._candidate)) return self._hash def __eq__(self, other: Any) -> bool: if not isinstance(other, RequiresPythonRequirement): return False return ( self._specifier_string == other._specifier_string and self._candidate == other._candidate ) @property def project_name(self) -> NormalizedName: return self._candidate.project_name @property def name(self) -> str: return self._candidate.name def format_for_error(self) -> str: return str(self) def get_candidate_lookup(self) -> CandidateLookup: if self.specifier.contains(self._candidate.version, prereleases=True): return self._candidate, None return None, None def is_satisfied_by(self, candidate: Candidate) -> bool: assert candidate.name == self._candidate.name, "Not Python candidate" # We can safely always allow prereleases here since PackageFinder # already implements the prerelease logic, and would have filtered out # prerelease candidates if the user does not expect them. return self.specifier.contains(candidate.version, prereleases=True) class UnsatisfiableRequirement(Requirement): """A requirement that cannot be satisfied.""" def __init__(self, name: NormalizedName) -> None: self._name = name def __str__(self) -> str: return f"{self._name} (unavailable)" def __repr__(self) -> str: return f"{self.__class__.__name__}({str(self._name)!r})" def __eq__(self, other: object) -> bool: if not isinstance(other, UnsatisfiableRequirement): return NotImplemented return self._name == other._name def __hash__(self) -> int: return hash(self._name) @property def project_name(self) -> NormalizedName: return self._name @property def name(self) -> str: return self._name def format_for_error(self) -> str: return str(self) def get_candidate_lookup(self) -> CandidateLookup: return None, None def is_satisfied_by(self, candidate: Candidate) -> bool: return False resolvelib/base.py 0000644 00000011637 15030103266 0010202 0 ustar 00 from dataclasses import dataclass from typing import FrozenSet, Iterable, Optional, Tuple from pip._vendor.packaging.specifiers import SpecifierSet from pip._vendor.packaging.utils import NormalizedName from pip._vendor.packaging.version import Version from pip._internal.models.link import Link, links_equivalent from pip._internal.req.req_install import InstallRequirement from pip._internal.utils.hashes import Hashes CandidateLookup = Tuple[Optional["Candidate"], Optional[InstallRequirement]] def format_name(project: NormalizedName, extras: FrozenSet[NormalizedName]) -> str: if not extras: return project extras_expr = ",".join(sorted(extras)) return f"{project}[{extras_expr}]" @dataclass(frozen=True) class Constraint: specifier: SpecifierSet hashes: Hashes links: FrozenSet[Link] @classmethod def empty(cls) -> "Constraint": return Constraint(SpecifierSet(), Hashes(), frozenset()) @classmethod def from_ireq(cls, ireq: InstallRequirement) -> "Constraint": links = frozenset([ireq.link]) if ireq.link else frozenset() return Constraint(ireq.specifier, ireq.hashes(trust_internet=False), links) def __bool__(self) -> bool: return bool(self.specifier) or bool(self.hashes) or bool(self.links) def __and__(self, other: InstallRequirement) -> "Constraint": if not isinstance(other, InstallRequirement): return NotImplemented specifier = self.specifier & other.specifier hashes = self.hashes & other.hashes(trust_internet=False) links = self.links if other.link: links = links.union([other.link]) return Constraint(specifier, hashes, links) def is_satisfied_by(self, candidate: "Candidate") -> bool: # Reject if there are any mismatched URL constraints on this package. if self.links and not all(_match_link(link, candidate) for link in self.links): return False # We can safely always allow prereleases here since PackageFinder # already implements the prerelease logic, and would have filtered out # prerelease candidates if the user does not expect them. return self.specifier.contains(candidate.version, prereleases=True) class Requirement: @property def project_name(self) -> NormalizedName: """The "project name" of a requirement. This is different from ``name`` if this requirement contains extras, in which case ``name`` would contain the ``[...]`` part, while this refers to the name of the project. """ raise NotImplementedError("Subclass should override") @property def name(self) -> str: """The name identifying this requirement in the resolver. This is different from ``project_name`` if this requirement contains extras, where ``project_name`` would not contain the ``[...]`` part. """ raise NotImplementedError("Subclass should override") def is_satisfied_by(self, candidate: "Candidate") -> bool: return False def get_candidate_lookup(self) -> CandidateLookup: raise NotImplementedError("Subclass should override") def format_for_error(self) -> str: raise NotImplementedError("Subclass should override") def _match_link(link: Link, candidate: "Candidate") -> bool: if candidate.source_link: return links_equivalent(link, candidate.source_link) return False class Candidate: @property def project_name(self) -> NormalizedName: """The "project name" of the candidate. This is different from ``name`` if this candidate contains extras, in which case ``name`` would contain the ``[...]`` part, while this refers to the name of the project. """ raise NotImplementedError("Override in subclass") @property def name(self) -> str: """The name identifying this candidate in the resolver. This is different from ``project_name`` if this candidate contains extras, where ``project_name`` would not contain the ``[...]`` part. """ raise NotImplementedError("Override in subclass") @property def version(self) -> Version: raise NotImplementedError("Override in subclass") @property def is_installed(self) -> bool: raise NotImplementedError("Override in subclass") @property def is_editable(self) -> bool: raise NotImplementedError("Override in subclass") @property def source_link(self) -> Optional[Link]: raise NotImplementedError("Override in subclass") def iter_dependencies(self, with_requires: bool) -> Iterable[Optional[Requirement]]: raise NotImplementedError("Override in subclass") def get_install_requirement(self) -> Optional[InstallRequirement]: raise NotImplementedError("Override in subclass") def format_for_error(self) -> str: raise NotImplementedError("Subclass should override") resolvelib/factory.py 0000644 00000077623 15030103266 0010746 0 ustar 00 import contextlib import functools import logging from typing import ( TYPE_CHECKING, Callable, Dict, FrozenSet, Iterable, Iterator, List, Mapping, NamedTuple, Optional, Protocol, Sequence, Set, Tuple, TypeVar, cast, ) from pip._vendor.packaging.requirements import InvalidRequirement from pip._vendor.packaging.specifiers import SpecifierSet from pip._vendor.packaging.utils import NormalizedName, canonicalize_name from pip._vendor.packaging.version import InvalidVersion, Version from pip._vendor.resolvelib import ResolutionImpossible from pip._internal.cache import CacheEntry, WheelCache from pip._internal.exceptions import ( DistributionNotFound, InstallationError, InvalidInstalledPackage, MetadataInconsistent, MetadataInvalid, UnsupportedPythonVersion, UnsupportedWheel, ) from pip._internal.index.package_finder import PackageFinder from pip._internal.metadata import BaseDistribution, get_default_environment from pip._internal.models.link import Link from pip._internal.models.wheel import Wheel from pip._internal.operations.prepare import RequirementPreparer from pip._internal.req.constructors import ( install_req_drop_extras, install_req_from_link_and_ireq, ) from pip._internal.req.req_install import ( InstallRequirement, check_invalid_constraint_type, ) from pip._internal.resolution.base import InstallRequirementProvider from pip._internal.utils.compatibility_tags import get_supported from pip._internal.utils.hashes import Hashes from pip._internal.utils.packaging import get_requirement from pip._internal.utils.virtualenv import running_under_virtualenv from .base import Candidate, Constraint, Requirement from .candidates import ( AlreadyInstalledCandidate, BaseCandidate, EditableCandidate, ExtrasCandidate, LinkCandidate, RequiresPythonCandidate, as_base_candidate, ) from .found_candidates import FoundCandidates, IndexCandidateInfo from .requirements import ( ExplicitRequirement, RequiresPythonRequirement, SpecifierRequirement, SpecifierWithoutExtrasRequirement, UnsatisfiableRequirement, ) if TYPE_CHECKING: class ConflictCause(Protocol): requirement: RequiresPythonRequirement parent: Candidate logger = logging.getLogger(__name__) C = TypeVar("C") Cache = Dict[Link, C] class CollectedRootRequirements(NamedTuple): requirements: List[Requirement] constraints: Dict[str, Constraint] user_requested: Dict[str, int] class Factory: def __init__( self, finder: PackageFinder, preparer: RequirementPreparer, make_install_req: InstallRequirementProvider, wheel_cache: Optional[WheelCache], use_user_site: bool, force_reinstall: bool, ignore_installed: bool, ignore_requires_python: bool, py_version_info: Optional[Tuple[int, ...]] = None, ) -> None: self._finder = finder self.preparer = preparer self._wheel_cache = wheel_cache self._python_candidate = RequiresPythonCandidate(py_version_info) self._make_install_req_from_spec = make_install_req self._use_user_site = use_user_site self._force_reinstall = force_reinstall self._ignore_requires_python = ignore_requires_python self._build_failures: Cache[InstallationError] = {} self._link_candidate_cache: Cache[LinkCandidate] = {} self._editable_candidate_cache: Cache[EditableCandidate] = {} self._installed_candidate_cache: Dict[str, AlreadyInstalledCandidate] = {} self._extras_candidate_cache: Dict[ Tuple[int, FrozenSet[NormalizedName]], ExtrasCandidate ] = {} self._supported_tags_cache = get_supported() if not ignore_installed: env = get_default_environment() self._installed_dists = { dist.canonical_name: dist for dist in env.iter_installed_distributions(local_only=False) } else: self._installed_dists = {} @property def force_reinstall(self) -> bool: return self._force_reinstall def _fail_if_link_is_unsupported_wheel(self, link: Link) -> None: if not link.is_wheel: return wheel = Wheel(link.filename) if wheel.supported(self._finder.target_python.get_unsorted_tags()): return msg = f"{link.filename} is not a supported wheel on this platform." raise UnsupportedWheel(msg) def _make_extras_candidate( self, base: BaseCandidate, extras: FrozenSet[str], *, comes_from: Optional[InstallRequirement] = None, ) -> ExtrasCandidate: cache_key = (id(base), frozenset(canonicalize_name(e) for e in extras)) try: candidate = self._extras_candidate_cache[cache_key] except KeyError: candidate = ExtrasCandidate(base, extras, comes_from=comes_from) self._extras_candidate_cache[cache_key] = candidate return candidate def _make_candidate_from_dist( self, dist: BaseDistribution, extras: FrozenSet[str], template: InstallRequirement, ) -> Candidate: try: base = self._installed_candidate_cache[dist.canonical_name] except KeyError: base = AlreadyInstalledCandidate(dist, template, factory=self) self._installed_candidate_cache[dist.canonical_name] = base if not extras: return base return self._make_extras_candidate(base, extras, comes_from=template) def _make_candidate_from_link( self, link: Link, extras: FrozenSet[str], template: InstallRequirement, name: Optional[NormalizedName], version: Optional[Version], ) -> Optional[Candidate]: base: Optional[BaseCandidate] = self._make_base_candidate_from_link( link, template, name, version ) if not extras or base is None: return base return self._make_extras_candidate(base, extras, comes_from=template) def _make_base_candidate_from_link( self, link: Link, template: InstallRequirement, name: Optional[NormalizedName], version: Optional[Version], ) -> Optional[BaseCandidate]: # TODO: Check already installed candidate, and use it if the link and # editable flag match. if link in self._build_failures: # We already tried this candidate before, and it does not build. # Don't bother trying again. return None if template.editable: if link not in self._editable_candidate_cache: try: self._editable_candidate_cache[link] = EditableCandidate( link, template, factory=self, name=name, version=version, ) except (MetadataInconsistent, MetadataInvalid) as e: logger.info( "Discarding [blue underline]%s[/]: [yellow]%s[reset]", link, e, extra={"markup": True}, ) self._build_failures[link] = e return None return self._editable_candidate_cache[link] else: if link not in self._link_candidate_cache: try: self._link_candidate_cache[link] = LinkCandidate( link, template, factory=self, name=name, version=version, ) except MetadataInconsistent as e: logger.info( "Discarding [blue underline]%s[/]: [yellow]%s[reset]", link, e, extra={"markup": True}, ) self._build_failures[link] = e return None return self._link_candidate_cache[link] def _iter_found_candidates( self, ireqs: Sequence[InstallRequirement], specifier: SpecifierSet, hashes: Hashes, prefers_installed: bool, incompatible_ids: Set[int], ) -> Iterable[Candidate]: if not ireqs: return () # The InstallRequirement implementation requires us to give it a # "template". Here we just choose the first requirement to represent # all of them. # Hopefully the Project model can correct this mismatch in the future. template = ireqs[0] assert template.req, "Candidates found on index must be PEP 508" name = canonicalize_name(template.req.name) extras: FrozenSet[str] = frozenset() for ireq in ireqs: assert ireq.req, "Candidates found on index must be PEP 508" specifier &= ireq.req.specifier hashes &= ireq.hashes(trust_internet=False) extras |= frozenset(ireq.extras) def _get_installed_candidate() -> Optional[Candidate]: """Get the candidate for the currently-installed version.""" # If --force-reinstall is set, we want the version from the index # instead, so we "pretend" there is nothing installed. if self._force_reinstall: return None try: installed_dist = self._installed_dists[name] except KeyError: return None try: # Don't use the installed distribution if its version # does not fit the current dependency graph. if not specifier.contains(installed_dist.version, prereleases=True): return None except InvalidVersion as e: raise InvalidInstalledPackage(dist=installed_dist, invalid_exc=e) candidate = self._make_candidate_from_dist( dist=installed_dist, extras=extras, template=template, ) # The candidate is a known incompatibility. Don't use it. if id(candidate) in incompatible_ids: return None return candidate def iter_index_candidate_infos() -> Iterator[IndexCandidateInfo]: result = self._finder.find_best_candidate( project_name=name, specifier=specifier, hashes=hashes, ) icans = result.applicable_candidates # PEP 592: Yanked releases are ignored unless the specifier # explicitly pins a version (via '==' or '===') that can be # solely satisfied by a yanked release. all_yanked = all(ican.link.is_yanked for ican in icans) def is_pinned(specifier: SpecifierSet) -> bool: for sp in specifier: if sp.operator == "===": return True if sp.operator != "==": continue if sp.version.endswith(".*"): continue return True return False pinned = is_pinned(specifier) # PackageFinder returns earlier versions first, so we reverse. for ican in reversed(icans): if not (all_yanked and pinned) and ican.link.is_yanked: continue func = functools.partial( self._make_candidate_from_link, link=ican.link, extras=extras, template=template, name=name, version=ican.version, ) yield ican.version, func return FoundCandidates( iter_index_candidate_infos, _get_installed_candidate(), prefers_installed, incompatible_ids, ) def _iter_explicit_candidates_from_base( self, base_requirements: Iterable[Requirement], extras: FrozenSet[str], ) -> Iterator[Candidate]: """Produce explicit candidates from the base given an extra-ed package. :param base_requirements: Requirements known to the resolver. The requirements are guaranteed to not have extras. :param extras: The extras to inject into the explicit requirements' candidates. """ for req in base_requirements: lookup_cand, _ = req.get_candidate_lookup() if lookup_cand is None: # Not explicit. continue # We've stripped extras from the identifier, and should always # get a BaseCandidate here, unless there's a bug elsewhere. base_cand = as_base_candidate(lookup_cand) assert base_cand is not None, "no extras here" yield self._make_extras_candidate(base_cand, extras) def _iter_candidates_from_constraints( self, identifier: str, constraint: Constraint, template: InstallRequirement, ) -> Iterator[Candidate]: """Produce explicit candidates from constraints. This creates "fake" InstallRequirement objects that are basically clones of what "should" be the template, but with original_link set to link. """ for link in constraint.links: self._fail_if_link_is_unsupported_wheel(link) candidate = self._make_base_candidate_from_link( link, template=install_req_from_link_and_ireq(link, template), name=canonicalize_name(identifier), version=None, ) if candidate: yield candidate def find_candidates( self, identifier: str, requirements: Mapping[str, Iterable[Requirement]], incompatibilities: Mapping[str, Iterator[Candidate]], constraint: Constraint, prefers_installed: bool, is_satisfied_by: Callable[[Requirement, Candidate], bool], ) -> Iterable[Candidate]: # Collect basic lookup information from the requirements. explicit_candidates: Set[Candidate] = set() ireqs: List[InstallRequirement] = [] for req in requirements[identifier]: cand, ireq = req.get_candidate_lookup() if cand is not None: explicit_candidates.add(cand) if ireq is not None: ireqs.append(ireq) # If the current identifier contains extras, add requires and explicit # candidates from entries from extra-less identifier. with contextlib.suppress(InvalidRequirement): parsed_requirement = get_requirement(identifier) if parsed_requirement.name != identifier: explicit_candidates.update( self._iter_explicit_candidates_from_base( requirements.get(parsed_requirement.name, ()), frozenset(parsed_requirement.extras), ), ) for req in requirements.get(parsed_requirement.name, []): _, ireq = req.get_candidate_lookup() if ireq is not None: ireqs.append(ireq) # Add explicit candidates from constraints. We only do this if there are # known ireqs, which represent requirements not already explicit. If # there are no ireqs, we're constraining already-explicit requirements, # which is handled later when we return the explicit candidates. if ireqs: try: explicit_candidates.update( self._iter_candidates_from_constraints( identifier, constraint, template=ireqs[0], ), ) except UnsupportedWheel: # If we're constrained to install a wheel incompatible with the # target architecture, no candidates will ever be valid. return () # Since we cache all the candidates, incompatibility identification # can be made quicker by comparing only the id() values. incompat_ids = {id(c) for c in incompatibilities.get(identifier, ())} # If none of the requirements want an explicit candidate, we can ask # the finder for candidates. if not explicit_candidates: return self._iter_found_candidates( ireqs, constraint.specifier, constraint.hashes, prefers_installed, incompat_ids, ) return ( c for c in explicit_candidates if id(c) not in incompat_ids and constraint.is_satisfied_by(c) and all(is_satisfied_by(req, c) for req in requirements[identifier]) ) def _make_requirements_from_install_req( self, ireq: InstallRequirement, requested_extras: Iterable[str] ) -> Iterator[Requirement]: """ Returns requirement objects associated with the given InstallRequirement. In most cases this will be a single object but the following special cases exist: - the InstallRequirement has markers that do not apply -> result is empty - the InstallRequirement has both a constraint (or link) and extras -> result is split in two requirement objects: one with the constraint (or link) and one with the extra. This allows centralized constraint handling for the base, resulting in fewer candidate rejections. """ if not ireq.match_markers(requested_extras): logger.info( "Ignoring %s: markers '%s' don't match your environment", ireq.name, ireq.markers, ) elif not ireq.link: if ireq.extras and ireq.req is not None and ireq.req.specifier: yield SpecifierWithoutExtrasRequirement(ireq) yield SpecifierRequirement(ireq) else: self._fail_if_link_is_unsupported_wheel(ireq.link) # Always make the link candidate for the base requirement to make it # available to `find_candidates` for explicit candidate lookup for any # set of extras. # The extras are required separately via a second requirement. cand = self._make_base_candidate_from_link( ireq.link, template=install_req_drop_extras(ireq) if ireq.extras else ireq, name=canonicalize_name(ireq.name) if ireq.name else None, version=None, ) if cand is None: # There's no way we can satisfy a URL requirement if the underlying # candidate fails to build. An unnamed URL must be user-supplied, so # we fail eagerly. If the URL is named, an unsatisfiable requirement # can make the resolver do the right thing, either backtrack (and # maybe find some other requirement that's buildable) or raise a # ResolutionImpossible eventually. if not ireq.name: raise self._build_failures[ireq.link] yield UnsatisfiableRequirement(canonicalize_name(ireq.name)) else: # require the base from the link yield self.make_requirement_from_candidate(cand) if ireq.extras: # require the extras on top of the base candidate yield self.make_requirement_from_candidate( self._make_extras_candidate(cand, frozenset(ireq.extras)) ) def collect_root_requirements( self, root_ireqs: List[InstallRequirement] ) -> CollectedRootRequirements: collected = CollectedRootRequirements([], {}, {}) for i, ireq in enumerate(root_ireqs): if ireq.constraint: # Ensure we only accept valid constraints problem = check_invalid_constraint_type(ireq) if problem: raise InstallationError(problem) if not ireq.match_markers(): continue assert ireq.name, "Constraint must be named" name = canonicalize_name(ireq.name) if name in collected.constraints: collected.constraints[name] &= ireq else: collected.constraints[name] = Constraint.from_ireq(ireq) else: reqs = list( self._make_requirements_from_install_req( ireq, requested_extras=(), ) ) if not reqs: continue template = reqs[0] if ireq.user_supplied and template.name not in collected.user_requested: collected.user_requested[template.name] = i collected.requirements.extend(reqs) # Put requirements with extras at the end of the root requires. This does not # affect resolvelib's picking preference but it does affect its initial criteria # population: by putting extras at the end we enable the candidate finder to # present resolvelib with a smaller set of candidates to resolvelib, already # taking into account any non-transient constraints on the associated base. This # means resolvelib will have fewer candidates to visit and reject. # Python's list sort is stable, meaning relative order is kept for objects with # the same key. collected.requirements.sort(key=lambda r: r.name != r.project_name) return collected def make_requirement_from_candidate( self, candidate: Candidate ) -> ExplicitRequirement: return ExplicitRequirement(candidate) def make_requirements_from_spec( self, specifier: str, comes_from: Optional[InstallRequirement], requested_extras: Iterable[str] = (), ) -> Iterator[Requirement]: """ Returns requirement objects associated with the given specifier. In most cases this will be a single object but the following special cases exist: - the specifier has markers that do not apply -> result is empty - the specifier has both a constraint and extras -> result is split in two requirement objects: one with the constraint and one with the extra. This allows centralized constraint handling for the base, resulting in fewer candidate rejections. """ ireq = self._make_install_req_from_spec(specifier, comes_from) return self._make_requirements_from_install_req(ireq, requested_extras) def make_requires_python_requirement( self, specifier: SpecifierSet, ) -> Optional[Requirement]: if self._ignore_requires_python: return None # Don't bother creating a dependency for an empty Requires-Python. if not str(specifier): return None return RequiresPythonRequirement(specifier, self._python_candidate) def get_wheel_cache_entry( self, link: Link, name: Optional[str] ) -> Optional[CacheEntry]: """Look up the link in the wheel cache. If ``preparer.require_hashes`` is True, don't use the wheel cache, because cached wheels, always built locally, have different hashes than the files downloaded from the index server and thus throw false hash mismatches. Furthermore, cached wheels at present have nondeterministic contents due to file modification times. """ if self._wheel_cache is None: return None return self._wheel_cache.get_cache_entry( link=link, package_name=name, supported_tags=self._supported_tags_cache, ) def get_dist_to_uninstall(self, candidate: Candidate) -> Optional[BaseDistribution]: # TODO: Are there more cases this needs to return True? Editable? dist = self._installed_dists.get(candidate.project_name) if dist is None: # Not installed, no uninstallation required. return None # We're installing into global site. The current installation must # be uninstalled, no matter it's in global or user site, because the # user site installation has precedence over global. if not self._use_user_site: return dist # We're installing into user site. Remove the user site installation. if dist.in_usersite: return dist # We're installing into user site, but the installed incompatible # package is in global site. We can't uninstall that, and would let # the new user installation to "shadow" it. But shadowing won't work # in virtual environments, so we error out. if running_under_virtualenv() and dist.in_site_packages: message = ( f"Will not install to the user site because it will lack " f"sys.path precedence to {dist.raw_name} in {dist.location}" ) raise InstallationError(message) return None def _report_requires_python_error( self, causes: Sequence["ConflictCause"] ) -> UnsupportedPythonVersion: assert causes, "Requires-Python error reported with no cause" version = self._python_candidate.version if len(causes) == 1: specifier = str(causes[0].requirement.specifier) message = ( f"Package {causes[0].parent.name!r} requires a different " f"Python: {version} not in {specifier!r}" ) return UnsupportedPythonVersion(message) message = f"Packages require a different Python. {version} not in:" for cause in causes: package = cause.parent.format_for_error() specifier = str(cause.requirement.specifier) message += f"\n{specifier!r} (required by {package})" return UnsupportedPythonVersion(message) def _report_single_requirement_conflict( self, req: Requirement, parent: Optional[Candidate] ) -> DistributionNotFound: if parent is None: req_disp = str(req) else: req_disp = f"{req} (from {parent.name})" cands = self._finder.find_all_candidates(req.project_name) skipped_by_requires_python = self._finder.requires_python_skipped_reasons() versions_set: Set[Version] = set() yanked_versions_set: Set[Version] = set() for c in cands: is_yanked = c.link.is_yanked if c.link else False if is_yanked: yanked_versions_set.add(c.version) else: versions_set.add(c.version) versions = [str(v) for v in sorted(versions_set)] yanked_versions = [str(v) for v in sorted(yanked_versions_set)] if yanked_versions: # Saying "version X is yanked" isn't entirely accurate. # https://github.com/pypa/pip/issues/11745#issuecomment-1402805842 logger.critical( "Ignored the following yanked versions: %s", ", ".join(yanked_versions) or "none", ) if skipped_by_requires_python: logger.critical( "Ignored the following versions that require a different python " "version: %s", "; ".join(skipped_by_requires_python) or "none", ) logger.critical( "Could not find a version that satisfies the requirement %s " "(from versions: %s)", req_disp, ", ".join(versions) or "none", ) if str(req) == "requirements.txt": logger.info( "HINT: You are attempting to install a package literally " 'named "requirements.txt" (which cannot exist). Consider ' "using the '-r' flag to install the packages listed in " "requirements.txt" ) return DistributionNotFound(f"No matching distribution found for {req}") def get_installation_error( self, e: "ResolutionImpossible[Requirement, Candidate]", constraints: Dict[str, Constraint], ) -> InstallationError: assert e.causes, "Installation error reported with no cause" # If one of the things we can't solve is "we need Python X.Y", # that is what we report. requires_python_causes = [ cause for cause in e.causes if isinstance(cause.requirement, RequiresPythonRequirement) and not cause.requirement.is_satisfied_by(self._python_candidate) ] if requires_python_causes: # The comprehension above makes sure all Requirement instances are # RequiresPythonRequirement, so let's cast for convenience. return self._report_requires_python_error( cast("Sequence[ConflictCause]", requires_python_causes), ) # Otherwise, we have a set of causes which can't all be satisfied # at once. # The simplest case is when we have *one* cause that can't be # satisfied. We just report that case. if len(e.causes) == 1: req, parent = e.causes[0] if req.name not in constraints: return self._report_single_requirement_conflict(req, parent) # OK, we now have a list of requirements that can't all be # satisfied at once. # A couple of formatting helpers def text_join(parts: List[str]) -> str: if len(parts) == 1: return parts[0] return ", ".join(parts[:-1]) + " and " + parts[-1] def describe_trigger(parent: Candidate) -> str: ireq = parent.get_install_requirement() if not ireq or not ireq.comes_from: return f"{parent.name}=={parent.version}" if isinstance(ireq.comes_from, InstallRequirement): return str(ireq.comes_from.name) return str(ireq.comes_from) triggers = set() for req, parent in e.causes: if parent is None: # This is a root requirement, so we can report it directly trigger = req.format_for_error() else: trigger = describe_trigger(parent) triggers.add(trigger) if triggers: info = text_join(sorted(triggers)) else: info = "the requested packages" msg = ( f"Cannot install {info} because these package versions " "have conflicting dependencies." ) logger.critical(msg) msg = "\nThe conflict is caused by:" relevant_constraints = set() for req, parent in e.causes: if req.name in constraints: relevant_constraints.add(req.name) msg = msg + "\n " if parent: msg = msg + f"{parent.name} {parent.version} depends on " else: msg = msg + "The user requested " msg = msg + req.format_for_error() for key in relevant_constraints: spec = constraints[key].specifier msg += f"\n The user requested (constraint) {key}{spec}" msg = ( msg + "\n\n" + "To fix this you could try to:\n" + "1. loosen the range of package versions you've specified\n" + "2. remove package versions to allow pip to attempt to solve " + "the dependency conflict\n" ) logger.info(msg) return DistributionNotFound( "ResolutionImpossible: for help visit " "https://pip.pypa.io/en/latest/topics/dependency-resolution/" "#dealing-with-dependency-conflicts" ) resolvelib/__pycache__/found_candidates.cpython-310.pyc 0000644 00000012131 15030103266 0017107 0 ustar 00 o �h� � @ s d Z ddlZddlZddlmZ ddlmZmZmZm Z m Z m Z m Z ddl mZ ddlmZ ddlmZ e�e�Ze eeg e e f f ZerLee ZneZd e e d e e fd d �Zd ed e e d e e fdd�Zd ed e e d e e fdd�ZG dd� de�ZdS )a� Utilities to lazily create and visit candidates found. Creating and visiting a candidate is a *very* costly operation. It involves fetching, extracting, potentially building modules from source, and verifying distribution metadata. It is therefore crucial for performance to keep everything here lazy all the way down, so we only touch candidates that we absolutely need, and not "download the world" when we only need one version of something. � N)�Sequence)� TYPE_CHECKING�Any�Callable�Iterator�Optional�Set�Tuple)� _BaseVersion)�MetadataInvalid� )� Candidate�infos�returnc c s� � t � }| D ]=\}}||v rqz|� }W n! ty5 } zt�d||jj|� |�|� W Y d}~qd}~ww |du r;q|V |�|� qdS )z�Iterator for ``FoundCandidates``. This iterator is used when the package is not already installed. Candidates from index come later in their normal ordering. zpIgnoring version %s of %s since it has invalid metadata: %s Please use pip<24.1 if you need to use this version.N)�setr �logger�warning�ireq�name�add)r �versions_found�version�func� candidate�e� r �g/usr/local/CyberCP/lib/python3.10/site-packages/pip/_internal/resolution/resolvelib/found_candidates.py� _iter_built* s, � � �� �r � installedc c sL � | V | j h}|D ]\}}||v rq |� }|du rq |V |�|� q dS )aK Iterator for ``FoundCandidates``. This iterator is used when the resolver prefers the already-installed candidate and NOT to upgrade. The installed candidate is therefore always yielded first, and candidates from index come later in their normal ordering, except skipped when the version is already installed. N)r r �r r r r r r r r r �_iter_built_with_prependedI s � �r c c st � t � }|D ]'\}}||v rq| j|kr | V |�| j� |� }|du r%q|V |�|� q| j|vr8| V dS dS )a� Iterator for ``FoundCandidates``. This iterator is used when the resolver prefers to upgrade an already-installed package. Candidates from index are returned in their normal ordering, except replaced when the version is already installed. The implementation iterates through and yields other candidates, inserting the installed candidate exactly once before we start yielding older or equivalent candidates, or after all other candidates if they are all newer. N)r r r r r r r �_iter_built_with_inserted_ s � �r! c @ s� e Zd ZdZdeg ee f dee de de e fdd�Z de d e fd d �Zd ee fd d �Zd e fdd�Zejdd�d e fdd��ZdS )�FoundCandidatesac A lazy sequence to provide candidates to the resolver. The intended usage is to return this from `find_matches()` so the resolver can iterate through the sequence multiple times, but only access the index page when remote packages are actually needed. This improve performances when suitable candidates are already installed on disk. � get_infosr �prefers_installed�incompatible_idsc C s || _ || _|| _|| _d S �N)� _get_infos� _installed�_prefers_installed�_incompatible_ids)�selfr# r r$ r% r r r �__init__� s zFoundCandidates.__init__�indexr c C � t d���Nz don't do this��NotImplementedError)r+ r- r r r � __getitem__� � zFoundCandidates.__getitem__c sJ � � � }� js t|�}n� jrt� j|�}nt� j|�}� fdd�|D �S )Nc 3 s" � | ] }t |�� jvr|V qd S r& )�idr* )�.0�c�r+ r r � <genexpr>� s � z+FoundCandidates.__iter__.<locals>.<genexpr>)r' r( r r) r r! )r+ r �iteratorr r7 r �__iter__� s zFoundCandidates.__iter__c C r. r/ r0 r7 r r r �__len__� r3 zFoundCandidates.__len__r )�maxsizec C s | j r| jrdS t| �S )NT)r) r( �anyr7 r r r �__bool__� s zFoundCandidates.__bool__N)�__name__� __module__� __qualname__�__doc__r r �IndexCandidateInfor r �boolr �intr, r r2 r: r; � functools� lru_cacher> r r r r r" s ��� � r" ) rB rF �logging�collections.abcr �typingr r r r r r r � pip._vendor.packaging.versionr �pip._internal.exceptionsr �baser � getLoggerr? r rC �SequenceCandidater r r! r" r r r r �<module> s: $ �� ��� � resolvelib/__pycache__/candidates.cpython-310.pyc 0000644 00000045770 15030103266 0015733 0 ustar 00 o �h!N � @ s� d dl Z d dlZd dlmZmZmZmZmZmZm Z m Z d dl m Z d dl mZmZ d dlmZ d dlmZmZmZmZmZ d dlmZ d dlmZm Z d d l m Z d d l m Z m!Z! d d l"m#Z# d d l$m%Z% d d l&m'Z' ddl(m)Z)m*Z*m+Z+ er~ddl,m-Z- e �.e/�Z0e d Z1e ed�Z2de)dee1 fdd�Z3dede#de#fdd�Z4dede#de#fdd �Z5d ede#de#fd d �Z6G d d!� d!e)�Z7G d"d#� d#e7�Z8G d$d%� d%e7�Z9G d&d'� d'e)�Z:G d(d)� d)e)�Z;G d*d+� d+e)�Z<dS ),� N)� TYPE_CHECKING�Any� FrozenSet�Iterable�Optional�Tuple�Union�cast)�InvalidRequirement)�NormalizedName�canonicalize_name)�Version)� HashError�InstallationSubprocessError�InvalidInstalledPackage�MetadataInconsistent�MetadataInvalid)�BaseDistribution)�Link�links_equivalent)�Wheel)�install_req_from_editable�install_req_from_line)�InstallRequirement)�direct_url_from_link)�normalize_version_info� )� Candidate� Requirement� format_name)�Factory)�AlreadyInstalledCandidate�EditableCandidate� LinkCandidatez <Python from Requires-Python>� candidate�returnc C s t ttf}t| |�r | S dS )z%The runtime version of BaseCandidate.N)r! r" r# � isinstance)r$ �base_candidate_classes� r( �a/usr/local/CyberCP/lib/python3.10/site-packages/pip/_internal/resolution/resolvelib/candidates.py�as_base_candidate, s � r* �link�templatec C sj |j rJ d��|jrt|j�}n| j}t||j|j|j|j|j |j |j |j d� }|j |_ | |_|j|_|S )Nztemplate is editable�� user_supplied� comes_from� use_pep517�isolated� constraint�global_options� hash_options�config_settings)�editable�req�str�urlr r. r/ r0 r1 r2 r3 r4 r5 � original_linkr+ �extras)r+ r, �line�ireqr( r( r) �make_install_req_from_link8 s& � r> c C sJ |j sJ d��t| j|j|j|j|j|j|j|j |j |j d� }|j |_ |S )Nztemplate not editable) r. r/ r0 r1 r2 �permit_editable_wheelsr3 r4 r5 ) r6 r r9 r. r/ r0 r1 r2 r? r3 r4 r5 r; )r+ r, r= r( r( r) � make_install_req_from_editableQ s � r@ �distc C st |j r t|j �}n|jr| j� d|jj� �}n | j� d| j� �}t||j|j|j |j |j |j |j |jd� }| |_|S )Nz @ z==r- )r7 r8 r+ �canonical_namer9 �versionr r. r/ r0 r1 r2 r3 r4 r5 � satisfied_by)rA r, r< r= r( r( r) �_make_install_req_from_diste s$ � rE c @ sB e Zd ZU dZeed< dZ d-dedededd d e e d e e d dfd d�Z d e fdd�Zd e fdd�Zd efdd�Zded efdd�Zed e e fdd��Zed e fdd��Zed e fd d ��Zed e fd d ��Zd e fd d!�Zd efd"d#�Zded dfd$d%�Z d efd&d'�Z d(ed e e e fd)d*�Z d e e fd+d,�Z!dS ).�"_InstallRequirementBackedCandidatea� A candidate backed by an ``InstallRequirement``. This represents a package request with the target not being already in the environment, and needs to be fetched and installed. The backing ``InstallRequirement`` is responsible for most of the leg work; this class exposes appropriate information to the resolver. :param link: The link passed to the ``InstallRequirement``. The backing ``InstallRequirement`` will use this link to fetch the distribution. :param source_link: The link this candidate "originates" from. This is different from ``link`` when the link is found in the wheel cache. ``link`` would point to the wheel cache, while this points to the found remote link (e.g. from pypi.org). rA FNr+ � source_linkr= �factoryr �namerC r% c C s8 || _ || _|| _|| _|| _|| _| �� | _d | _d S �N) �_link� _source_link�_factory�_ireq�_name�_version�_preparerA �_hash)�selfr+ rG r= rH rI rC r( r( r) �__init__� s z+_InstallRequirementBackedCandidate.__init__c C s | j � d| j� �S )N� �rI rC �rS r( r( r) �__str__� s z*_InstallRequirementBackedCandidate.__str__c C s | j j� dt| j��d�S �N�(�))� __class__�__name__r8 rK rW r( r( r) �__repr__� s z+_InstallRequirementBackedCandidate.__repr__c C s( | j d ur| j S t| j| jf�| _ | j S rJ )rR �hashr\ rK rW r( r( r) �__hash__� s z+_InstallRequirementBackedCandidate.__hash__�otherc C s t || j�r t| j|j�S dS �NF)r& r\ r rK �rS ra r( r( r) �__eq__� s z)_InstallRequirementBackedCandidate.__eq__c C � | j S rJ )rL rW r( r( r) rG � � z._InstallRequirementBackedCandidate.source_linkc C s | j du r | jj| _ | j S )�:The normalised name of the project the candidate refers toN)rO rA rB rW r( r( r) � project_name� s z/_InstallRequirementBackedCandidate.project_namec C re rJ �rh rW r( r( r) rI � rf z'_InstallRequirementBackedCandidate.namec C � | j d u r | jj| _ | j S rJ �rP rA rC rW r( r( r) rC � � z*_InstallRequirementBackedCandidate.versionc C s2 | j � d| j� d| jjr| jj� d�S | j� d�S )NrU z (from r[ )rI rC rK �is_file� file_pathrW r( r( r) �format_for_error� s ����z3_InstallRequirementBackedCandidate.format_for_errorc C s t d��)NzOverride in subclass)�NotImplementedErrorrW r( r( r) �_prepare_distribution� s z8_InstallRequirementBackedCandidate._prepare_distributionc C s� | j dur| j |jkrt| jd| j |j��| jdur.| j|jkr.t| jdt| j�t|j���zt|�t|� � ��� W dS t yP } zt | jt|���d}~ww )z:Check for consistency of project name and version of dist.NrI rC ) rO rB r rN rP rC r8 �list�iter_dependencies�iter_provided_extrasr r )rS rA �er( r( r) �_check_metadata_consistency� s( �� ��z>_InstallRequirementBackedCandidate._check_metadata_consistencyc C s\ z| � � }W n ty } z| j|_� d }~w ty& } zd|_� d }~ww | �|� |S )NzSee above for output.)rq r rN r7 r �contextrv )rS rA ru �excr( r( r) rQ � s ��� z+_InstallRequirementBackedCandidate._prepare� with_requiresc c sN � |r| j �� nd}|D ]}| j�t|�| j�E d H q | j�| j j�V d S �Nr( )rA rs rM �make_requirements_from_specr8 rN � make_requires_python_requirement�requires_python)rS ry �requires�rr( r( r) rs � s � z4_InstallRequirementBackedCandidate.iter_dependenciesc C re rJ )rN rW r( r( r) �get_install_requirement s z:_InstallRequirementBackedCandidate.get_install_requirement�NN)"r] � __module__� __qualname__�__doc__r �__annotations__� is_installedr r r r r rT r8 rX r^ �intr` r �boolrd �propertyrG rh rI rC ro rq rv rQ r r rs r� r( r( r( r) rF } sN ������� �rF c �V e Zd ZdZ ddededddee dee d df � fd d � Z d e fd d �Z � Z S )r# FNr+ r, rH r rI rC r% c s0 |}|� ||�}|d urt�d|j� |j}t||�}|j|ks"J �|jjr\|jjs\t|jj�} t | j �} || ksCJ |�d| �d���|d ur\t | j �} || ks\J |�d| �d|� ���|d ur�|jjsfJ �|jjslJ �|j rx|j|ju rx||_|jd ur�|j|_nt||j d�|_t� j||||||d� d S )NzUsing cached wheel link: %sz != z for wheelz for wheel )�link_is_in_wheel_cache�r+ rG r= rH rI rC )�get_wheel_cache_entry�logger�debugr+ r> �is_wheelrm r �filenamer rI r rC � persistentr: �cached_wheel_source_link�origin� download_infor �superrT ) rS r+ r, rH rI rC rG � cache_entryr= �wheel� wheel_name� wheel_version�r\ r( r) rT sD � � �zLinkCandidate.__init__c C s | j j}|j| jdd�S )NT)�parallel_builds)rM �preparer�prepare_linked_requirementrN )rS r� r( r( r) rq 9 s z#LinkCandidate._prepare_distributionr� � r] r� r� � is_editabler r r r r rT r rq � __classcell__r( r( r� r) r# s$ �������1r# c r� )r" TNr+ r, rH r rI rC r% c s" t � j||t||�|||d� d S )Nr� )r� rT r@ )rS r+ r, rH rI rC r� r( r) rT A s �zEditableCandidate.__init__c C s | j j�| j�S rJ )rM r� � prepare_editable_requirementrN rW r( r( r) rq R � z'EditableCandidate._prepare_distributionr� r� r( r( r� r) r" > s$ �������r" c @ s� e Zd ZdZdZdededdddfdd �Zdefd d �Z defd d �Z de de fdd�Z defdd�Zedefdd��Zedefdd��Zedefdd��Zede fdd��Zdefdd �Zd e deee fd d �Zdee fd d!�Z dS )"r! TNrA r, rH r r% c C s6 || _ t||�| _|| _d | _d}|j�| j|� d S )Nzalready satisfied)rA rE rN rM rP r� � prepare_installed_requirement)rS rA r, rH � skip_reasonr( r( r) rT Z s z"AlreadyInstalledCandidate.__init__c C s t | j�S rJ )r8 rA rW r( r( r) rX l s z!AlreadyInstalledCandidate.__str__c C s | j j� d| j�d�S rY )r\ r] rA rW r( r( r) r^ o s z"AlreadyInstalledCandidate.__repr__ra c C s& t |t�stS | j|jko| j|jkS rJ )r& r! �NotImplementedrI rC rc r( r( r) rd r s z AlreadyInstalledCandidate.__eq__c C � t | j| jf�S rJ )r_ rI rC rW r( r( r) r` w r� z"AlreadyInstalledCandidate.__hash__c C � | j jS rJ )rA rB rW r( r( r) rh z � z&AlreadyInstalledCandidate.project_namec C re rJ ri rW r( r( r) rI ~ rf z AlreadyInstalledCandidate.namec C rj rJ rk rW r( r( r) rC � rl z!AlreadyInstalledCandidate.versionc C r� rJ )rA r6 rW r( r( r) r� � r� z%AlreadyInstalledCandidate.is_editablec C s | j � d| j� d�S )NrU z (Installed)rV rW r( r( r) ro � s z*AlreadyInstalledCandidate.format_for_errorry c c sd � |sd S z| j �� D ]}| j�t|�| j�E d H q W d S ty1 } zt| j |d�d �d }~ww )N)rA � invalid_exc)rA rs rM r{ r8 rN r r )rS ry r rx r( r( r) rs � s � ���z+AlreadyInstalledCandidate.iter_dependenciesc C � d S rJ r( rW r( r( r) r� � � z1AlreadyInstalledCandidate.get_install_requirement) r] r� r� r� rG r r rT r8 rX r^ �objectr� rd r� r` r� r rh rI r rC r� ro r r r rs r� r( r( r( r) r! V s6 ��� � r! c @ s e Zd ZdZdd�dedee dee ddfdd �Z defd d �Z defd d �Z de fdd�Z dedefdd�Zedefdd��Zedefdd��Zedefdd��Zdefdd�Zedefdd ��Zedefd d ��Zedee fd d ��Zd!ede ee fd"d#�Z dee fd$d%�Z dS )&�ExtrasCandidatea� A candidate that has 'extras', indicating additional dependencies. Requirements can be for a project with dependencies, something like foo[extra]. The extras don't affect the project/version being installed directly, but indicate that we need additional dependencies. We model that by having an artificial ExtrasCandidate that wraps the "base" candidate. The ExtrasCandidate differs from the base in the following ways: 1. It has a unique name, of the form foo[extra]. This causes the resolver to treat it as a separate node in the dependency graph. 2. When we're getting the candidate's dependencies, a) We specify that we want the extra dependencies as well. b) We add a dependency on the base candidate. See below for why this is needed. 3. We return None for the underlying InstallRequirement, as the base candidate will provide it, and we don't want to end up with duplicates. The dependency on the base candidate is needed so that the resolver can't decide that it should recommend foo[extra1] version 1.0 and foo[extra2] version 2.0. Having those candidates depend on foo=1.0 and foo=2.0 respectively forces the resolver to recognise that this is a conflict. N)r/ �baser; r/ r% c C s: || _ tdd� |D ��| _|dur|| _dS | j j| _dS )a� :param comes_from: the InstallRequirement that led to this candidate if it differs from the base's InstallRequirement. This will often be the case in the sense that this candidate's requirement has the extras while the base's does not. Unlike the InstallRequirement backed candidates, this requirement is used solely for reporting purposes, it does not do any leg work. c s � � | ]}t |�V qd S rJ )r )�.0ru r( r( r) � <genexpr>� � � z+ExtrasCandidate.__init__.<locals>.<genexpr>N)r� � frozensetr; rN � _comes_from)rS r� r; r/ r( r( r) rT � s zExtrasCandidate.__init__c C s, t | j��dd�\}}d�|d�| j�|�S )NrU r z {}[{}] {}�,)r8 r� �split�format�joinr; )rS rI �restr( r( r) rX � s zExtrasCandidate.__str__c C s | j j� d| j�d| j�d�S )Nz(base=z , extras=r[ )r\ r] r� r; rW r( r( r) r^ � s zExtrasCandidate.__repr__c C r� rJ )r_ r� r; rW r( r( r) r` � r� zExtrasCandidate.__hash__ra c C s( t || j�r| j|jko| j|jkS dS rb )r& r\ r� r; rc r( r( r) rd � s zExtrasCandidate.__eq__c C r� rJ )r� rh rW r( r( r) rh � r� z ExtrasCandidate.project_namec C s t | jj| j�S )rg )r r� rh r; rW r( r( r) rI � s zExtrasCandidate.namec C r� rJ )r� rC rW r( r( r) rC � r� zExtrasCandidate.versionc C s d� | j�� d�t| j���S )Nz{} [{}]z, )r� r� ro r� �sortedr; rW r( r( r) ro � s �z ExtrasCandidate.format_for_errorc C r� rJ )r� r� rW r( r( r) r� � r� z ExtrasCandidate.is_installedc C r� rJ )r� r� rW r( r( r) r� � r� zExtrasCandidate.is_editablec C r� rJ )r� rG rW r( r( r) rG � r� zExtrasCandidate.source_linkry c c s� � | j j}|�| j �V |sd S | j�| j j�� �}| j�| j j�� �}t|�D ] }t � d| j j | j |� q(| j j� |�D ]}|�t|�| j|�E d H q=d S )Nz%%s %s does not provide the extra '%s')r� rM � make_requirement_from_candidater; � intersectionrA rt � differencer� r� �warningrI rC rs r{ r8 r� )rS ry rH � valid_extras�invalid_extras�extrar r( r( r) rs � s* � � ��z!ExtrasCandidate.iter_dependenciesc C r� rJ r( rW r( r( r) r� s z'ExtrasCandidate.get_install_requirement) r] r� r� r� � BaseCandidater r8 r r rT rX r^ r� r` r r� rd r� r rh rI r rC ro r� r� r rG r r rs r� r( r( r( r) r� � s> ���� � r� c @ s� e Zd ZdZdZdeeedf ddfdd�Zde fdd �Z e de fd d ��Z e de fd d ��Ze defdd��Zde fdd�Zdedeee fdd�Zdee fdd�ZdS )�RequiresPythonCandidateFN�py_version_info.r% c C s> |d ur t |�}ntjd d� }td�dd� |D ���| _d S )N� �.c s r� rJ )r8 )r� �cr( r( r) r� " r� z3RequiresPythonCandidate.__init__.<locals>.<genexpr>)r �sys� version_infor r� rP )rS r� r� r( r( r) rT s z RequiresPythonCandidate.__init__c C � d| j � �S �NzPython �rP rW r( r( r) rX ( � z RequiresPythonCandidate.__str__c C � t S rJ ��REQUIRES_PYTHON_IDENTIFIERrW r( r( r) rh + � z$RequiresPythonCandidate.project_namec C r� rJ r� rW r( r( r) rI / r� z RequiresPythonCandidate.namec C re rJ r� rW r( r( r) rC 3 rf z RequiresPythonCandidate.versionc C r� r� )rC rW r( r( r) ro 7 r� z(RequiresPythonCandidate.format_for_errorry c C s dS rz r( )rS ry r( r( r) rs : r� z)RequiresPythonCandidate.iter_dependenciesc C r� rJ r( rW r( r( r) r� = r� z/RequiresPythonCandidate.get_install_requirement)r] r� r� r� rG r r r� rT r8 rX r� r rh rI r rC ro r� r r rs r r� r( r( r( r) r� s r� )=�loggingr� �typingr r r r r r r r �"pip._vendor.packaging.requirementsr �pip._vendor.packaging.utilsr r � pip._vendor.packaging.versionr �pip._internal.exceptionsr r r r r �pip._internal.metadatar �pip._internal.models.linkr r �pip._internal.models.wheelr � pip._internal.req.constructorsr r � pip._internal.req.req_installr �&pip._internal.utils.direct_url_helpersr �pip._internal.utils.miscr r� r r r rH r � getLoggerr] r� r� r� r* r> r@ rE rF r# r" r! r� r� r( r( r( r) �<module> sf ( � �� ��� ��� � 9G| resolvelib/__pycache__/__init__.cpython-310.pyc 0000644 00000000274 15030103266 0015361 0 ustar 00 o �h � @ s d S )N� r r r �_/usr/local/CyberCP/lib/python3.10/site-packages/pip/_internal/resolution/resolvelib/__init__.py�<module> s resolvelib/__pycache__/reporter.cpython-310.pyc 0000644 00000007262 15030103266 0015470 0 ustar 00 o �h` � @ sp d dl mZ d dlmZ d dlmZmZ d dlmZ ddl m Z m Z ee �Z G dd� de�ZG d d � d e�Zd S ) � )� defaultdict)� getLogger)�Any� DefaultDict)� BaseReporter� )� Candidate� Requirementc @ s, e Zd Zd dd�Zdededdfdd�ZdS ) � PipReporter�returnNc C s t t�| _dddd�| _d S )Nz�pip is looking at multiple versions of {package_name} to determine which version is compatible with other requirements. This could take a while.z�pip is still looking at multiple versions of {package_name} to determine which version is compatible with other requirements. This could take a while.z�This is taking longer than usual. You might need to provide the dependency resolver with stricter constraints to reduce runtime. See https://pip.pypa.io/warnings/backtracking for guidance. If you want to abort this run, press Ctrl + C.)r � � )r �int�reject_count_by_package�_messages_at_reject_count��self� r �_/usr/local/CyberCP/lib/python3.10/site-packages/pip/_internal/resolution/resolvelib/reporter.py�__init__ s �zPipReporter.__init__� criterion� candidatec C s� | j |j d7 < | j |j }|| jvrd S | j| }t�d|j|jd�� d}|jD ]&}|j|j}}|d7 }|rH||j� d|j � d�7 }n|d7 }||� � 7 }q,t� |� d S ) Nr zINFO: %s)� package_namez0Will try a different candidate, due to conflict:z � z depends on zThe user requested ) r �namer �logger�info�format� information� requirement�parent�version�format_for_error�debug) r r r �count�message�msg�req_info�reqr r r r �rejecting_candidate# s z PipReporter.rejecting_candidate�r N)�__name__� __module__� __qualname__r r r r) r r r r r s r c @ s� e Zd ZdZddd�Zdeddfdd�Zded eddfd d �Zd eddfd d �Z de de ddfdd�Z dede ddfdd�Z de ddfdd�ZdS )�PipDebuggingReporterz9A reporter that does an info log for every event it sees.r Nc C s t �d� d S )NzReporter.starting()�r r r r r r �starting= s z PipDebuggingReporter.starting�indexc C � t �d|� d S )NzReporter.starting_round(%r)r/ )r r1 r r r �starting_round@ � z#PipDebuggingReporter.starting_round�statec C s t �d|� t �d||� d S )Nz Reporter.ending_round(%r, state)z Reporter.ending_round(%r, %r))r r r# )r r1 r5 r r r � ending_roundC s z!PipDebuggingReporter.ending_roundc C r2 )NzReporter.ending(%r)r/ )r r5 r r r �endingG r4 zPipDebuggingReporter.endingr r c C � t �d||� d S )Nz#Reporter.adding_requirement(%r, %r)r/ )r r r r r r �adding_requirementJ � z'PipDebuggingReporter.adding_requirementr r c C r8 )Nz$Reporter.rejecting_candidate(%r, %r)r/ )r r r r r r r) M r: z(PipDebuggingReporter.rejecting_candidatec C r2 )NzReporter.pinning(%r)r/ )r r r r r �pinningP r4 z PipDebuggingReporter.pinningr* )r+ r, r- �__doc__r0 r r3 r r6 r7 r r r9 r) r; r r r r r. : s r. N)� collectionsr �loggingr �typingr r � pip._vendor.resolvelib.reportersr �baser r r+ r r r. r r r r �<module> s . resolvelib/__pycache__/provider.cpython-310.pyc 0000644 00000017503 15030103266 0015457 0 ustar 00 o �h�& � @ s d dl Z d dlZd dlmZ d dlmZmZmZmZm Z m Z m Z m Z d dl mZ ddlmZmZmZ ddlmZ ddlmZ erZd d l mZ d d lmZ eeef Zeeeef Z neZ e d �Z e d �Z d e ee f dede de e e f fdd�Z G dd� de �Z dS )� N)� lru_cache)� TYPE_CHECKING�Dict�Iterable�Iterator�Mapping�Sequence�TypeVar�Union)�AbstractProvider� )� Candidate� Constraint� Requirement)�REQUIRES_PYTHON_IDENTIFIER)�Factory)� Preference)�RequirementInformation�D�V�mapping� identifier�default�returnc C s8 || v r| | S |� d�\}}}|r|| v r| | S |S )ai Get item from a package name lookup mapping with a resolver identifier. This extra logic is needed when the target mapping is keyed by package name, which cannot be directly looked up with an identifier (which may contain requested extras). Additional logic is added to also look up a value by "cleaning up" the extras from the identifier. �[)� partition)r r r �name� open_bracket�_� r �_/usr/local/CyberCP/lib/python3.10/site-packages/pip/_internal/resolution/resolvelib/provider.py�_get_with_identifier6 s r! c @ s, e Zd ZdZdedeeef dededeee f ddf d d �Z d e e e f defd d �Zdedeee f deeee f deeed f ded ddf dd�Zdedeeee f deeee f dee fdd�Zedd�d e d e defd d ��Zd e dee fd d!�Zededed defd"d#��ZdS )$� PipProvidera� Pip's provider implementation for resolvelib. :params constraints: A mapping of constraints specified by the user. Keys are canonicalized project names. :params ignore_dependencies: Whether the user specified ``--no-deps``. :params upgrade_strategy: The user-specified upgrade strategy. :params user_requested: A set of canonicalized package names that the user supplied for pip to install/upgrade. �factory� constraints�ignore_dependencies�upgrade_strategy�user_requestedr Nc C s2 || _ || _|| _|| _|| _t�dd� �| _d S )Nc S s t jS �N)�math�infr r r r �<lambda>g s z&PipProvider.__init__.<locals>.<lambda>)�_factory� _constraints�_ignore_dependencies�_upgrade_strategy�_user_requested� collections� defaultdict� _known_depths)�selfr# r$ r% r& r' r r r �__init__Z s zPipProvider.__init__�requirement_or_candidatec C s |j S r( )r )r4 r6 r r r �identifyi s zPipProvider.identifyr � resolutions� candidates� information�PreferenceInformation�backtrack_causesr c sF z t t|| �� W n ty d}Y nw d}|r*dd� || D �}t|� \}} nd\}} dd� dd� | D �D �} |d u} td d� | D ��} t| �} z� j| }W n( tyz tj }|ru� fd d�|| D �}t d d� |D ��d }ntj }Y nw d }|� j |< � j� |tj �}|t k}� �||�}| | | | ||| |fS )a� Produce a sort key for given requirement based on preference. The lower the return value is, the more preferred this group of arguments is. Currently pip considers the following in order: * Prefer if any of the known requirements is "direct", e.g. points to an explicit URL. * If equal, prefer if any requirement is "pinned", i.e. contains operator ``===`` or ``==``. * If equal, calculate an approximate "depth" and resolve requirements closer to the user-specified requirements first. If the depth cannot by determined (eg: due to no matching parents), it is considered infinite. * Order user-specified requirements by the order they are specified. * If equal, prefers "non-free" requirements, i.e. contains at least one operator, such as ``>=`` or ``<``. * If equal, order alphabetically for consistency (helps debuggability). FTc s s � | ] \}}|� � V qd S r( )�get_candidate_lookup)�.0�rr r r r � <genexpr>� s � z-PipProvider.get_preference.<locals>.<genexpr>)Nr c S s g | ] }|D ]}|j �qqS r )�operator)r> � specifier_set� specifierr r r � <listcomp>� s ���z.PipProvider.get_preference.<locals>.<listcomp>c s s � | ]}|r|j V qd S r( )rC )r> �ireqr r r r@ � s � Nc s s � | ] }|d d� dkV qd S )N� z==r )r> �opr r r r@ � s � c 3 s, � | ]\}}|d ur� j |j ndV qd S )Ng )r3 r )r> r �parent�r4 r r r@ � s � � �c s s � | ]}|V qd S r( r )r> �dr r r r@ � s � g �?)�next�iter� StopIteration�zip�any�boolr0 �KeyErrorr) r* �minr3 �getr �is_backtrack_cause)r4 r r8 r9 r: r< �has_information�lookups� candidate�ireqs� operators�direct�pinned�unfree�requested_order� parent_depths�inferred_depth�requires_python�backtrack_causer rI r �get_preferencel sT � � ��� �zPipProvider.get_preference� requirements�incompatibilitiesc sJ dt dtf� fdd� }t� j|t�� d�}� jj|||||� |� jd�S )Nr r c s4 � j dkrdS � j dkrt� j| dd�}|duS dS )a� Are upgrades allowed for this project? This checks the upgrade strategy, and whether the project was one that the user specified in the command line, in order to decide whether we should upgrade if there's a newer version available. (Note that we don't need access to the `--upgrade` flag, because an upgrade strategy of "to-satisfy-only" means that `--upgrade` was not specified). �eagerTzonly-if-neededN�r F)r/ r! r0 )r � user_orderrI r r �_eligible_for_upgrade� s �z7PipProvider.find_matches.<locals>._eligible_for_upgraderf )r rc � constraint�prefers_installedrd �is_satisfied_by) �strrP r! r- r �emptyr, �find_candidatesrk )r4 r rc rd rh ri r rI r � find_matches� s ��zPipProvider.find_matches)�maxsize� requirementrW c C s |� |�S r( )rk )r4 rq rW r r r rk � s zPipProvider.is_satisfied_byc C s | j }dd� |�|�D �S )Nc S s g | ]}|d ur|�qS r( r )r> r? r r r rD � s z0PipProvider.get_dependencies.<locals>.<listcomp>)r. �iter_dependencies)r4 rW � with_requiresr r r �get_dependencies� s z PipProvider.get_dependenciesc C s8 |D ]}| |j jkr dS |jr| |jjkr dS qdS )NTF)rq r rH )r r< ra r r r rT � s �z PipProvider.is_backtrack_cause)�__name__� __module__� __qualname__�__doc__r r rl r rP �intr5 r r r r7 r r r r rb ro r rk rt � staticmethodrT r r r r r" O sb � ��� � �� ���� �[��� �*���r" )!r1 r) � functoolsr �typingr r r r r r r r � pip._vendor.resolvelib.providersr �baser r r r9 r r# r r � pip._vendor.resolvelib.resolversr r; rl � _ProviderBaser r r! r" r r r r �<module> s4 ( ��� � resolvelib/__pycache__/resolver.cpython-310.pyc 0000644 00000021035 15030103266 0015461 0 ustar 00 o �h01 � @ s� d dl Z d dlZd dlZd dlZd dlmZmZmZmZm Z m Z m Z d dl m Z d dlmZmZ d dlmZ d dlmZ d dlmZ d dlmZ d d lmZ d d lm Z d d l m Z d d l m Z d d l!m"Z"m#Z# d dl$m%Z% d dl&m'Z'm(Z( d dl)m*Z* ddl+m,Z,m-Z- ddl.m/Z/ er�d dl0m1Z2 e2e-e,e3f Z1e�4e5�Z6G dd� de"�Zddde e3 deee3 e7f fdd �Z8d e e3e f d eee3 e7f de e7e3f fd d �Z9dS )!� N)� TYPE_CHECKING�Dict�List�Optional�Set�Tuple�cast��canonicalize_name)� BaseReporter�ResolutionImpossible)�Resolver)� DirectedGraph)� WheelCache)� PackageFinder)�RequirementPreparer)�install_req_extend_extras)�InstallRequirement)�RequirementSet)� BaseResolver�InstallRequirementProvider)� PipProvider)�PipDebuggingReporter� PipReporter)�get_requirement� )� Candidate� Requirement)�Factory)�Resultc s� e Zd Zh d�Z ddededee dede de d e d e d e d e d ee e df f� fdd� Z dee de defdd�Zdedee fdd�Z� ZS )r > �only-if-needed�to-satisfy-only�eagerN�preparer�finder� wheel_cache�make_install_req� use_user_site�ignore_dependencies�ignore_installed�ignore_requires_python�force_reinstall�upgrade_strategy�py_version_info.c sJ t � �� | | jv s J �t|||||| ||| d� | _|| _| | _d | _d S )N) r$ r# r& r% r' r+ r) r* r- )�super�__init__�_allowed_strategiesr �factoryr( r, �_result) �selfr# r$ r% r& r' r( r) r* r+ r, r- �� __class__� �_/usr/local/CyberCP/lib/python3.10/site-packages/pip/_internal/resolution/resolvelib/resolver.pyr/ ) s � zResolver.__init__� root_reqs�check_supported_wheels�returnc C s$ | j �|�}t| j |j| j| j|jd�}dtjv r t � }nt � }t ||�}zd}|j |j |d� }| _W n tyN } z| j �td| �|j�} | | �d } ~ ww t|d�} t|j�� dd� d �D ]�} | �� } | d u r�| j| jkr�t�t�� | � | j�}| � t |t | j�j �� W d � n1 s�w Y q_| j � | �}|d u r�d | _!n4| j j"r�d | _!n,|j#| j#kr�d | _!n"| j$s�|j%r�d | _!n| j&r�| j&j'r�| j&j(r�t)�*d | j� q_d | _!nq_| j&}|r�|j+r�d j,| j| j#||j-p�dd�}t)�.|� | � | � q_| j/}| j j0�1|� |D ] }d |_2d |_3�q| S )N)r1 � constraintsr( r, �user_requested�PIP_RESOLVER_DEBUGi@ )� max_roundsz,ResolutionImpossible[Requirement, Candidate])r9 c S s | j | jkS �N)�name� project_name)�cr6 r6 r7 �<lambda>p s z"Resolver.resolve.<locals>.<lambda>)�keyFTz�%s is already installed with the same version as the provided wheel. Use --force-reinstall to force an installation of the wheel.z�The candidate selected for download or install is a yanked version: {name!r} candidate (version {version} at {link}) Reason for being yanked: {reason}z <none given>)r@ �version�link�reason)4r1 �collect_root_requirementsr r; r( r, r< �os�environr r � RLResolver�resolve� requirementsr2 r �get_installation_errorr r �sorted�mapping�values�get_install_requirementr@ rA � contextlib�suppress�KeyErrorr �add_named_requirementr �extras�get_dist_to_uninstall�should_reinstallr+ rE � is_editable�editable� source_link�is_file�is_wheel�logger�info� is_yanked�format� yanked_reason�warning�all_requirementsr# � prepare_linked_requirements_more�prepared�needs_more_preparation)r3 r8 r9 � collected�provider�reporter�resolver�#limit_how_complex_resolution_can_be�result�e�error�req_set� candidate�ireq�req�installed_distrF �msg�reqsr6 r6 r7 rL I s� � ����� � �� � � � zResolver.resolverq c C sd | j dus J d��|jsg S | j j}t|t|j�� ��}t|j�� tj t |d�dd�}dd� |D �S )aZ Get order for installation of requirements in RequirementSet. The returned list contains a requirement before another that depends on it. This helps ensure that the environment is kept consistent as they get installed one-by-one. The current implementation creates a topological ordering of the dependency graph, giving more weight to packages with less or no dependencies, while breaking any cycles in the graph at arbitrary points. We make no guarantees about where the cycle would be broken, other than it *would* be broken. Nzmust call resolve() first)�weightsT)rD �reversec S s g | ]\}}|�qS r6 r6 )�.0�_rs r6 r6 r7 � <listcomp>� s z3Resolver.get_installation_order.<locals>.<listcomp>) r2 rM �graph�get_topological_weights�set�keysrO �items� functools�partial�_req_set_item_sorter)r3 rq r} rx � sorted_itemsr6 r6 r7 �get_installation_order� s �z Resolver.get_installation_orderr? )�__name__� __module__� __qualname__r0 r r r r r �bool�strr �intr/ r r r rL r� � __classcell__r6 r6 r4 r7 r & sL �������� � � � � �� �p��r r} z DirectedGraph[Optional[str]]�requirement_keysr: c s� t � �i �dtt ddf� ����fdd� � t � }� D ]}|du r#q � �|�D ]} n|�|� q |s5n t� �d }|D ] }|�vrDq=|�|< q=|D ]}� �|� qKq�d� t ��� ����}|rgJ |���S )a� Assign weights to each node based on how "deep" they are. This implementation may change at any point in the future without prior notice. We first simplify the dependency graph by pruning any leaves and giving them the highest weight: a package without any dependencies should be installed first. This is done again and again in the same way, giving ever less weight to the newly found leaves. The loop stops when no leaves are left: all remaining packages have at least one dependency left in the graph. Then we continue with the remaining graph, by taking the length for the longest path to any node from root, ignoring any paths that contain a single node twice (i.e. cycles). This is done through a depth-first search through the graph, while keeping track of the path to the node. Cycles in the graph result would result in node being revisited while also being on its own path. In this case, take no action. This helps ensure we don't get stuck in a cycle. When assigning weight, the longer path (i.e. larger length) is preferred. We are only interested in the weights of packages that are in the requirement_keys. �noder: Nc sf | �v rd S �� | � � �| �D ]}�|� q��| � | �vr"d S ��| d�}t|t����| < d S )Nr )�add� iter_children�remove�get�max�len)r� �child�last_known_parent_count�r} �pathr� �visitrx r6 r7 r� � s z&get_topological_weights.<locals>.visitTr ) r r r� r� r� r� r� r� � difference)r} r� �leavesrD �_child�weight�leafr� r6 r� r7 r~ � s4 " � � r~ �itemrx c C s t | d �}|| |fS )a) Key function used to sort install requirements for installation. Based on the "weight" mapping calculated in ``get_installation_order()``. The canonical package name is returned as the second member as a tie- breaker to ensure the result is predictable, which is useful in tests. r r )r� rx r@ r6 r6 r7 r� 2 s r� ):rS r� �loggingrI �typingr r r r r r r �pip._vendor.packaging.utilsr �pip._vendor.resolvelibr r r rK � pip._vendor.resolvelib.structsr �pip._internal.cacher �"pip._internal.index.package_finderr � pip._internal.operations.preparer � pip._internal.req.constructorsr � pip._internal.req.req_installr �pip._internal.req.req_setr � pip._internal.resolution.baser r �,pip._internal.resolution.resolvelib.providerr �,pip._internal.resolution.resolvelib.reporterr r � pip._internal.utils.packagingr �baser r r1 r � pip._vendor.resolvelib.resolversr �RLResultr� � getLoggerr� r_ r� r~ r� r6 r6 r6 r7 �<module> sR $ 4�� �Y �� � resolvelib/__pycache__/requirements.cpython-310.pyc 0000644 00000024265 15030103266 0016353 0 ustar 00 o �h� � @ s� d dl mZmZ d dlmZ d dlmZmZ d dlm Z d dl m Z ddl m Z mZmZmZ G dd � d e�ZG d d � d e�ZG d d � d e�ZG dd� de�ZG dd� de�ZdS )� )�Any�Optional)� SpecifierSet)�NormalizedName�canonicalize_name)�install_req_drop_extras)�InstallRequirement� )� Candidate�CandidateLookup� Requirement� format_namec @ s� e Zd Zdeddfdd�Zdefdd�Zdefdd �Zdefd d �Z d e de fd d�Z e defdd��Ze defdd��Zdefdd�Zdefdd�Zdede fdd�ZdS )�ExplicitRequirement� candidate�returnNc C � || _ d S �N�r ��selfr � r �c/usr/local/CyberCP/lib/python3.10/site-packages/pip/_internal/resolution/resolvelib/requirements.py�__init__ � z ExplicitRequirement.__init__c C � t | j�S r )�strr �r r r r �__str__ r zExplicitRequirement.__str__c C s | j j� d| j�d�S �N�(�))� __class__�__name__r r r r r �__repr__ s z ExplicitRequirement.__repr__c C r r )�hashr r r r r �__hash__ r z ExplicitRequirement.__hash__�otherc C s t |t�sdS | j|jkS �NF)� isinstancer r �r r& r r r �__eq__ � zExplicitRequirement.__eq__c C � | j jS r )r � project_namer r r r r- � z ExplicitRequirement.project_namec C r, r )r �namer r r r r/ # r. zExplicitRequirement.namec C s | j �� S r )r �format_for_errorr r r r r0 ( r z$ExplicitRequirement.format_for_errorc C s | j d fS r r r r r r �get_candidate_lookup+ r z(ExplicitRequirement.get_candidate_lookupc C s || j kS r r r r r r �is_satisfied_by. r z#ExplicitRequirement.is_satisfied_by)r" � __module__� __qualname__r r r r r# �intr% r �boolr* �propertyr r- r/ r0 r r1 r2 r r r r r s r c @ s� e Zd Zdeddfdd�Zedefdd��Zdefdd �Zdefd d �Z d e de fd d�Z de fdd�Zedefdd��Zedefdd��Zdefdd�Zdefdd�Zdede fdd�ZdS ) �SpecifierRequirement�ireqr Nc C s@ |j d u s J d��|| _d | _d | _tdd� | jjD ��| _d S )N� This is a link, not a specifierc s � � | ]}t |�V qd S r �r ��.0�er r r � <genexpr>8 � � z0SpecifierRequirement.__init__.<locals>.<genexpr>)�link�_ireq� _equal_cache�_hash� frozenset�extras�_extras�r r9 r r r r 3 s z SpecifierRequirement.__init__c C �" | j d ur| j S t| j�| _ | j S r �rD r rC r r r r �_equal: � zSpecifierRequirement._equalc C s t | jj�S r )r rC �reqr r r r r B � z SpecifierRequirement.__str__c C s | j j� dt| jj��d�S r )r! r" r rC rN r r r r r# E s z SpecifierRequirement.__repr__r& c C � t |t�stS | j|jkS r )r( r8 �NotImplementedrL r) r r r r* H r+ zSpecifierRequirement.__eq__c C rJ r �rE r$ rL r r r r r% M � z SpecifierRequirement.__hash__c C s | j jsJ d��t| j jj�S )N�'Specifier-backed ireq is always PEP 508)rC rN r r/ r r r r r- T s z!SpecifierRequirement.project_namec C s t | j| j�S r )r r- rH r r r r r/ Y s zSpecifierRequirement.namec C sZ dd� t | ��d�D �}t|�dkrdS t|�dkr |d S d�|d d� �d |d S ) Nc S s g | ]}|� � �qS r )�strip)r> �sr r r � <listcomp>b s z9SpecifierRequirement.format_for_error.<locals>.<listcomp>�,r � r z, ���z and )r �split�len�join)r �partsr r r r0 ] s z%SpecifierRequirement.format_for_errorc C s d | j fS r )rC r r r r r1 j r z)SpecifierRequirement.get_candidate_lookupr c C sN |j | j ksJ d|j � d| j � ���| jjsJ d��| jjj}|j|jdd�S )Nz6Internal issue: Candidate is not for this requirement z vs rT T�� prereleases)r/ rC rN � specifier�contains�version)r r �specr r r r2 m s ��� z$SpecifierRequirement.is_satisfied_by)r" r3 r4 r r r7 r rL r r# �objectr6 r* r5 r% r r- r/ r0 r r1 r r2 r r r r r8 2 s r8 c @ sT e Zd ZdZdeddfdd�Zedefdd��Zd e de fd d �Z de fd d �Z dS )�!SpecifierWithoutExtrasRequirementz� Requirement backed by an install requirement on a base package. Trims extras from its install requirement if there are any. r9 r Nc C sD |j d u s J d��t|�| _d | _d | _tdd� | jjD ��| _d S )Nr: c s r; r r< r= r r r r@ � rA z=SpecifierWithoutExtrasRequirement.__init__.<locals>.<genexpr>)rB r rC rD rE rF rG rH rI r r r r � s z*SpecifierWithoutExtrasRequirement.__init__c C rJ r rK r r r r rL � rM z(SpecifierWithoutExtrasRequirement._equalr& c C rP r )r( rf rQ rL r) r r r r* � r+ z(SpecifierWithoutExtrasRequirement.__eq__c C rJ r rR r r r r r% � rS z*SpecifierWithoutExtrasRequirement.__hash__)r" r3 r4 �__doc__r r r7 r rL re r6 r* r5 r% r r r r rf z s rf c @ s� e Zd ZdZdededdfdd�Zdefdd �Zdefd d �Z de fd d �Z de de fdd�Zedefdd��Zedefdd��Zdefdd�Zdefdd�Zdede fdd�ZdS ) �RequiresPythonRequirementz4A requirement representing Requires-Python metadata.ra �matchr Nc C s || _ t|�| _d | _|| _d S r )ra r �_specifier_stringrE � _candidate)r ra ri r r r r � s z"RequiresPythonRequirement.__init__c C s d| j � �S )NzPython )ra r r r r r � rO z!RequiresPythonRequirement.__str__c C � | j j� dt| j��d�S r )r! r" r ra r r r r r# � � z"RequiresPythonRequirement.__repr__c C s( | j d ur| j S t| j| jf�| _ | j S r )rE r$ rj rk r r r r r% � s z"RequiresPythonRequirement.__hash__r& c C s& t |t�sdS | j|jko| j|jkS r' )r( rh rj rk r) r r r r* � s �z RequiresPythonRequirement.__eq__c C r, r )rk r- r r r r r- � � z&RequiresPythonRequirement.project_namec C r, r )rk r/ r r r r r/ � rn z RequiresPythonRequirement.namec C � t | �S r �r r r r r r0 � � z*RequiresPythonRequirement.format_for_errorc C s" | j j| jjdd�r| jd fS dS )NTr_ �NN)ra rb rk rc r r r r r1 � s z.RequiresPythonRequirement.get_candidate_lookupr c C s( |j | jj ks J d��| jj|jdd�S )NzNot Python candidateTr_ )r/ rk ra rb rc r r r r r2 � s z)RequiresPythonRequirement.is_satisfied_by)r" r3 r4 rg r r r r r r# r5 r% r r6 r* r7 r r- r/ r0 r r1 r2 r r r r rh � s rh c @ s� e Zd ZdZdeddfdd�Zdefdd�Zdefd d �Zd e de fd d �Z de fdd�Z edefdd��Zedefdd��Zdefdd�Zdefdd�Zdede fdd�ZdS )�UnsatisfiableRequirementz'A requirement that cannot be satisfied.r/ r Nc C r r ��_name)r r/ r r r r � r z!UnsatisfiableRequirement.__init__c C s | j � d�S )Nz (unavailable)rt r r r r r � rO z UnsatisfiableRequirement.__str__c C rl r )r! r" r ru r r r r r# � rm z!UnsatisfiableRequirement.__repr__r& c C rP r )r( rs rQ ru r) r r r r* � r+ z UnsatisfiableRequirement.__eq__c C r r )r$ ru r r r r r% � r z!UnsatisfiableRequirement.__hash__c C � | j S r rt r r r r r- � � z%UnsatisfiableRequirement.project_namec C rv r rt r r r r r/ � rw z UnsatisfiableRequirement.namec C ro r rp r r r r r0 � rq z)UnsatisfiableRequirement.format_for_errorc C � dS )Nrr r r r r r r1 � � z-UnsatisfiableRequirement.get_candidate_lookupr c C rx r' r r r r r r2 � ry z(UnsatisfiableRequirement.is_satisfied_by)r" r3 r4 rg r r r r r# re r6 r* r5 r% r7 r- r/ r0 r r1 r r2 r r r r rs � s rs N)�typingr r � pip._vendor.packaging.specifiersr �pip._vendor.packaging.utilsr r � pip._internal.req.constructorsr � pip._internal.req.req_installr �baser r r r r r8 rf rh rs r r r r �<module> s &H"6 resolvelib/__pycache__/base.cpython-310.pyc 0000644 00000013700 15030103266 0014532 0 ustar 00 o �h� � @ s� d dl mZ d dlmZmZmZmZ d dlmZ d dl m Z d dl m Z d dl mZmZ d dlmZ d dlmZ eed ee f Zd e d ee d efd d�Zedd�G dd� d��ZG dd� d�Zdedd d efdd�ZG dd � d �ZdS )� )� dataclass)� FrozenSet�Iterable�Optional�Tuple)� SpecifierSet)�NormalizedName)�Version)�Link�links_equivalent)�InstallRequirement)�Hashes� Candidate�project�extras�returnc C s& |s| S d� t|��}| � d|� d�S )N�,�[�])�join�sorted)r r � extras_expr� r �[/usr/local/CyberCP/lib/python3.10/site-packages/pip/_internal/resolution/resolvelib/base.py� format_name s r T)�frozenc @ s� e Zd ZU eed< eed< ee ed< eddd��Z ede dd fdd ��Z de fd d �Z d e dd fd d�Zddde fdd�ZdS )� Constraint� specifier�hashes�linksr c C s t t� t� t� �S �N)r r r � frozenset)�clsr r r �empty s zConstraint.empty�ireqc C s. |j r t|j g�nt� }t|j|jdd�|�S �NF)�trust_internet)�linkr! r r r )r" r$ r r r r � from_ireq s zConstraint.from_ireqc C s t | j�pt | j�pt | j�S r )�boolr r r ��selfr r r �__bool__% s zConstraint.__bool__�otherc C sR t |t�stS | j|j@ }| j|jdd�@ }| j}|jr#|�|jg�}t|||�S r% ) � isinstancer �NotImplementedr r r r' �unionr )r+ r- r r r r r r �__and__( s zConstraint.__and__� candidater c s4 | j rt� fdd�| j D ��sdS | jj� jdd�S )Nc 3 s � | ]}t |� �V qd S r )� _match_link)�.0r' �r2 r r � <genexpr>4 s � z-Constraint.is_satisfied_by.<locals>.<genexpr>FT)� prereleases)r �allr �contains�version�r+ r2 r r5 r �is_satisfied_by2 s zConstraint.is_satisfied_byN)r r )�__name__� __module__� __qualname__r �__annotations__r r r � classmethodr# r r( r) r, r1 r< r r r r r s r c @ s^ e Zd Zedefdd��Zedefdd��Zdddefdd �Z de fd d �Z defd d �Z dS )� Requirementr c C � t d��)z�The "project name" of a requirement. This is different from ``name`` if this requirement contains extras, in which case ``name`` would contain the ``[...]`` part, while this refers to the name of the project. �Subclass should override��NotImplementedErrorr* r r r � project_name= � zRequirement.project_namec C rC )z�The name identifying this requirement in the resolver. This is different from ``project_name`` if this requirement contains extras, where ``project_name`` would not contain the ``[...]`` part. rD rE r* r r r �nameG � zRequirement.namer2 r c C s dS �NFr r; r r r r< P s zRequirement.is_satisfied_byc C rC �NrD rE r* r r r �get_candidate_lookupS � z Requirement.get_candidate_lookupc C rC rL rE r* r r r �format_for_errorV rN z Requirement.format_for_errorN) r= r> r? �propertyr rG �strrI r) r< �CandidateLookuprM rO r r r r rB < s rB r' r2 c C s |j r t| |j �S dS rK )� source_linkr )r' r2 r r r r3 Z s r3 c @ s� e Zd Zedefdd��Zedefdd��Zedefdd��Z ede fdd ��Z ede fd d ��Z ede e fd d ��Zde dee e fdd�Zde e fdd�Zdefdd�ZdS )r r c C rC )z�The "project name" of the candidate. This is different from ``name`` if this candidate contains extras, in which case ``name`` would contain the ``[...]`` part, while this refers to the name of the project. �Override in subclassrE r* r r r rG a rH zCandidate.project_namec C rC )z�The name identifying this candidate in the resolver. This is different from ``project_name`` if this candidate contains extras, where ``project_name`` would not contain the ``[...]`` part. rT rE r* r r r rI k rJ zCandidate.namec C rC �NrT rE r* r r r r: t � zCandidate.versionc C rC rU rE r* r r r � is_installedx rV zCandidate.is_installedc C rC rU rE r* r r r � is_editable| rV zCandidate.is_editablec C rC rU rE r* r r r rS � rV zCandidate.source_link� with_requiresc C rC rU rE )r+ rY r r r �iter_dependencies� rN zCandidate.iter_dependenciesc C rC rU rE r* r r r �get_install_requirement� rN z!Candidate.get_install_requirementc C rC rL rE r* r r r rO � rN zCandidate.format_for_errorN)r= r> r? rP r rG rQ rI r r: r) rW rX r r rS r rB rZ r r[ rO r r r r r ` s N) � dataclassesr �typingr r r r � pip._vendor.packaging.specifiersr �pip._vendor.packaging.utilsr � pip._vendor.packaging.versionr �pip._internal.models.linkr r � pip._internal.req.req_installr �pip._internal.utils.hashesr rR rQ r r rB r) r3 r r r r r �<module> s % resolvelib/__pycache__/factory.cpython-310.pyc 0000644 00000052231 15030103266 0015271 0 ustar 00 o �h� � @ s, d dl Z d dlZd dlZd dlmZmZmZmZmZm Z m Z m Z m Z m Z mZmZmZmZmZmZ d dlmZ d dlmZ d dlmZmZ d dlm Z m Z d dl m Z d dl m!Z!m"Z" d d l#m$Z$m%Z%m&Z&m'Z'm(Z(m)Z)m*Z* d d l+m,Z, d d l-m.Z.m/Z/ d d l0m1Z1 d d l2m3Z3 d dl4m5Z5 d dl6m7Z7m8Z8 d dl9m:Z:m;Z; d dl<m=Z= d dl>m?Z? d dl@mAZA d dlBmCZC d dlDmEZE ddlFmGZGmHZHmIZI ddlJmKZKmLZLmMZMmNZNmOZOmPZPmQZQ ddlRmSZSmTZT ddlUmVZVmWZWmXZXmYZYmZZZ er�G dd � d e�Z[e�\e]�Z^ed �Z_ee1e_f Z`G d d � d e �ZaG d d!� d!�ZbdS )"� N)� TYPE_CHECKING�Callable�Dict� FrozenSet�Iterable�Iterator�List�Mapping� NamedTuple�Optional�Protocol�Sequence�Set�Tuple�TypeVar�cast)�InvalidRequirement)� SpecifierSet)�NormalizedName�canonicalize_name)�InvalidVersion�Version)�ResolutionImpossible)� CacheEntry� WheelCache)�DistributionNotFound�InstallationError�InvalidInstalledPackage�MetadataInconsistent�MetadataInvalid�UnsupportedPythonVersion�UnsupportedWheel)� PackageFinder)�BaseDistribution�get_default_environment)�Link)�Wheel)�RequirementPreparer)�install_req_drop_extras� install_req_from_link_and_ireq)�InstallRequirement� check_invalid_constraint_type)�InstallRequirementProvider)� get_supported)�Hashes)�get_requirement)�running_under_virtualenv� )� Candidate� Constraint� Requirement)�AlreadyInstalledCandidate� BaseCandidate�EditableCandidate�ExtrasCandidate� LinkCandidate�RequiresPythonCandidate�as_base_candidate)�FoundCandidates�IndexCandidateInfo)�ExplicitRequirement�RequiresPythonRequirement�SpecifierRequirement�!SpecifierWithoutExtrasRequirement�UnsatisfiableRequirementc @ s e Zd ZU eed< eed< dS )� ConflictCause� requirement�parentN)�__name__� __module__� __qualname__r? �__annotations__r2 � rJ rJ �^/usr/local/CyberCP/lib/python3.10/site-packages/pip/_internal/resolution/resolvelib/factory.pyrC O s rC �Cc @ s: e Zd ZU ee ed< eeef ed< eee f ed< dS )�CollectedRootRequirements� requirements� constraints�user_requestedN) rF rG rH r r4 rI r �strr3 �intrJ rJ rJ rK rM Z s rM c @ s� e Zd Z dWdedededee dededed ed ee e d f d dfd d�Z e d efdd��Z ded dfdd�Zdd�dedee dee d efdd�Zdedee ded efd d �Zdedee ded ee d ee d ee f d d!�Zdeded ee d ee d ee f d"d#�Z d$e e d%e d&e d'ed(e e d e!e f d)d*�Z"d+e!e# dee d e$e fd,d-�Z%d.ed/e&ded e$e fd0d1�Z'd.ed2e(ee!e# f d3e(ee$e f d/e&d'ed4e)e#egef d e!e fd5d6�Z*d7ed8e!e d e$e# fd9d:�Z+d;e,e d e-fd<d=�Z.d>ed e/fd?d@�Z0 AdXd%edee d8e!e d e$e# fdBdC�Z1d%e d ee# fdDdE�Z2ded ee d ee3 fdFdG�Z4d>ed ee fdHdI�Z5dJe dK d e6fdLdM�Z7dNe#dOee d e8fdPdQ�Z9dRdSdTe:ee&f d e;fdUdV�Z<dS )Y�FactoryN�finder�preparer�make_install_req� wheel_cache� use_user_site�force_reinstall�ignore_installed�ignore_requires_python�py_version_info.�returnc C s� || _ || _|| _t| �| _|| _|| _|| _|| _i | _ i | _ i | _ i | _ i | _ t� | _|s@t� } dd� | jdd�D �| _d S i | _d S )Nc S s i | ]}|j |�qS rJ )�canonical_name)�.0�distrJ rJ rK � <dictcomp>� s ��z$Factory.__init__.<locals>.<dictcomp>F)� local_only)�_finderrU � _wheel_cacher: �_python_candidate�_make_install_req_from_spec�_use_user_site�_force_reinstall�_ignore_requires_python�_build_failures�_link_candidate_cache�_editable_candidate_cache�_installed_candidate_cache�_extras_candidate_cacher- �_supported_tags_cacher$ � iter_installed_distributions�_installed_dists) �selfrT rU rV rW rX rY rZ r[ r\ �envrJ rJ rK �__init__a s* � � zFactory.__init__c C s | j S �N)rh �rr rJ rJ rK rY � s zFactory.force_reinstall�linkc C s> |j sd S t|j�}|�| jj�� �rd S |j� d�}t|��)Nz+ is not a supported wheel on this platform.)�is_wheelr& �filename� supportedrc � target_python�get_unsorted_tagsr! )rr rw �wheel�msgrJ rJ rK �"_fail_if_link_is_unsupported_wheel� s z*Factory._fail_if_link_is_unsupported_wheel�� comes_from�base�extrasr� c C sX t |�tdd� |D ��f}z| j| }W |S ty+ t|||d�}|| j|< Y |S w )Nc s s � | ]}t |�V qd S ru )r )r_ �erJ rJ rK � <genexpr>� � � z1Factory._make_extras_candidate.<locals>.<genexpr>r� )�id� frozensetrn �KeyErrorr8 )rr r� r� r� � cache_key� candidaterJ rJ rK �_make_extras_candidate� s � �z Factory._make_extras_candidater` �templatec C sV z| j |j }W n ty t||| d�}|| j |j< Y nw |s#|S | j|||d�S )N)�factoryr� )rm r^ r� r5 r� )rr r` r� r� r� rJ rJ rK �_make_candidate_from_dist� s �z!Factory._make_candidate_from_dist�name�versionc C s0 | � ||||�}|r|d u r|S | j|||d�S )Nr� )� _make_base_candidate_from_linkr� )rr rw r� r� r� r� r� rJ rJ rK �_make_candidate_from_link� s � z!Factory._make_candidate_from_linkc C s || j v rd S |jrH|| jvrCzt||| ||d�| j|< W n% ttfyB } ztjd||ddid� || j |< W Y d }~d S d }~ww | j| S || jvrzt ||| ||d�| j|< W n# ty~ } ztjd||ddid� || j |< W Y d }~d S d }~ww | j| S )N)r� r� r� z3Discarding [blue underline]%s[/]: [yellow]%s[reset]�markupT)�extra) rj �editablerl r7 r r �logger�infork r9 )rr rw r� r� r� r� rJ rJ rK r� � sZ �� �� �� �� z&Factory._make_base_candidate_from_link�ireqs� specifier�hashes�prefers_installed�incompatible_idsc s� |sdS |d ��j sJ d��t�j j��t� � |D ] }|j s#J d���|j jM ��|jdd�M �� t|j�O � qdtt f� �����fdd� }dt t f� �����fd d � }t ||� |��S ) NrJ r z)Candidates found on index must be PEP 508F)�trust_internetr] c s� �j rdS z�j� } W n ty Y dS w z �j| jdd�s#W dS W n ty6 } zt| |d��d}~ww �j| � �d�}t|��v rGdS |S )z6Get the candidate for the currently-installed version.NT)� prereleases)r` � invalid_exc)r` r� r� ) rh rq r� �containsr� r r r� r� )�installed_distr� r� )r� r� r� rr r� r� rJ rK �_get_installed_candidate s. �� ��� z@Factory._iter_found_candidates.<locals>._get_installed_candidatec 3 s� � �j j���d�} | j}tdd� |D ��}dtdtfdd�}|��}t|�D ] }|r-|s2|jjr2q't j �j |j� ��|j d�}|j |fV q'd S ) N)� project_namer� r� c s s � | ]}|j jV qd S ru )rw � is_yanked)r_ �icanrJ rJ rK r� = r� zUFactory._iter_found_candidates.<locals>.iter_index_candidate_infos.<locals>.<genexpr>r� r] c S s< | D ]}|j dkr dS |j dkrq|j�d�rq dS dS )Nz===T�==z.*F)�operatorr� �endswith)r� �sprJ rJ rK � is_pinned? s zUFactory._iter_found_candidates.<locals>.iter_index_candidate_infos.<locals>.is_pinned)rw r� r� r� r� ) rc �find_best_candidate�applicable_candidates�allr �bool�reversedrw r� � functools�partialr� r� )�result�icans� all_yankedr� �pinnedr� �func)r� r� r� rr r� r� rJ rK �iter_index_candidate_infos2 s. �� ��zBFactory._iter_found_candidates.<locals>.iter_index_candidate_infos) �reqr r� r� r� r� r� r r2 r r= r< ) rr r� r� r� r� r� �ireqr� r� rJ )r� r� r� r� rr r� r� rK �_iter_found_candidates� s& (�z Factory._iter_found_candidates�base_requirementsc c sL � |D ] }|� � \}}|du rqt|�}|dus J d��| �||�V qdS )a8 Produce explicit candidates from the base given an extra-ed package. :param base_requirements: Requirements known to the resolver. The requirements are guaranteed to not have extras. :param extras: The extras to inject into the explicit requirements' candidates. Nzno extras here)�get_candidate_lookupr; r� )rr r� r� r� � lookup_cand�_� base_candrJ rJ rK �#_iter_explicit_candidates_from_basea s � �z+Factory._iter_explicit_candidates_from_base� identifier� constraintc c sB � |j D ]}| �|� | j|t||�t|�dd�}|r |V qdS )z�Produce explicit candidates from constraints. This creates "fake" InstallRequirement objects that are basically clones of what "should" be the template, but with original_link set to link. N�r� r� r� )�linksr r� r) r )rr r� r� r� rw r� rJ rJ rK �!_iter_candidates_from_constraintsw s � ���z)Factory._iter_candidates_from_constraintsrN �incompatibilities�is_satisfied_byc sZ t � }g }�� D ]} | �� \} } | d ur|�| � | d ur#|�| � q t�t��; t��} | j�kr]|� | � �� | jd�t | j ��� �� | jg �D ]} | �� \} } | d ur\|�| � qKW d � n1 sgw Y |r�z|� | j�� |d d�� W n ty� Y dS w dd� |� �d�D ��|s�| �|� j� j|��S � ����fdd�|D �S )NrJ r )r� c S s h | ]}t |��qS rJ )r� )r_ �crJ rJ rK � <setcomp>� � z*Factory.find_candidates.<locals>.<setcomp>c 3 sF � | ] � t � ��vr��� �rt� �fd d��� D ��r� V qdS )c 3 s � | ]}�|� �V qd S ru rJ )r_ r� )r� r� rJ rK r� � s � z4Factory.find_candidates.<locals>.<genexpr>.<genexpr>N)r� r� r� )r_ �r� r� � incompat_idsr� rN )r� rK r� � s � ����z*Factory.find_candidates.<locals>.<genexpr>)�setr� �add�append� contextlib�suppressr r/ r� �updater� �getr� r� r� r! r� r� r� )rr r� rN r� r� r� r� �explicit_candidatesr� r� �candr� �parsed_requirementr� rJ r� rK �find_candidates� s` � �� � ��� ���zFactory.find_candidatesr� �requested_extrasc c s� � |� |�st�d|j|j� dS |js,|jr%|jdur%|jjr%t |�V t |�V dS | � |j� | j |j|jr=t |�n||jrFt|j�nddd�}|du rb|jsX| j|j �tt|j��V dS | �|�V |jrz| �| �|t|j���V dS dS )aW Returns requirement objects associated with the given InstallRequirement. In most cases this will be a single object but the following special cases exist: - the InstallRequirement has markers that do not apply -> result is empty - the InstallRequirement has both a constraint (or link) and extras -> result is split in two requirement objects: one with the constraint (or link) and one with the extra. This allows centralized constraint handling for the base, resulting in fewer candidate rejections. z6Ignoring %s: markers '%s' don't match your environmentNr� )� match_markersr� r� r� �markersrw r� r� r� rA r@ r r� r( r rj rB � make_requirement_from_candidater� r� )rr r� r� r� rJ rJ rK �#_make_requirements_from_install_req� s8 � � � ��z+Factory._make_requirements_from_install_req� root_ireqsc C s� t g i i �}t|�D ]_\}}|jrDt|�}|rt|��|�� s q |js'J d��t|j�}||jv r;|j| |M < q t � |�|j|< q t | j |dd��}|sPq |d }|j rc|j|jvrc||j|j< |j�|� q |jjdd� d� |S )NzConstraint must be namedrJ )r� r c S s | j | jkS ru )r� r� )�rrJ rJ rK �<lambda>5 s z3Factory.collect_root_requirements.<locals>.<lambda>)�key)rM � enumerater� r+ r r� r� r rO r3 � from_ireq�listr� � user_suppliedrP rN �extend�sort) rr r� � collected�ir� �problemr� �reqsr� rJ rJ rK �collect_root_requirements s6 �� z!Factory.collect_root_requirementsr� c C s t |�S ru )r> )rr r� rJ rJ rK r� 8 s z'Factory.make_requirement_from_candidaterJ c C s | � ||�}| �||�S )a( Returns requirement objects associated with the given specifier. In most cases this will be a single object but the following special cases exist: - the specifier has markers that do not apply -> result is empty - the specifier has both a constraint and extras -> result is split in two requirement objects: one with the constraint and one with the extra. This allows centralized constraint handling for the base, resulting in fewer candidate rejections. )rf r� )rr r� r� r� r� rJ rJ rK �make_requirements_from_spec= s z#Factory.make_requirements_from_specc C s" | j rd S t|�s d S t|| j�S ru )ri rQ r? re )rr r� rJ rJ rK � make_requires_python_requirementO s z(Factory.make_requires_python_requirementc C s" | j du rdS | j j||| jd�S )a� Look up the link in the wheel cache. If ``preparer.require_hashes`` is True, don't use the wheel cache, because cached wheels, always built locally, have different hashes than the files downloaded from the index server and thus throw false hash mismatches. Furthermore, cached wheels at present have nondeterministic contents due to file modification times. N)rw � package_name�supported_tags)rd �get_cache_entryro )rr rw r� rJ rJ rK �get_wheel_cache_entryZ s �z Factory.get_wheel_cache_entryc C sZ | j �|j�}|d u r d S | js|S |jr|S t� r+|jr+d|j� d|j� �}t |��d S )NzNWill not install to the user site because it will lack sys.path precedence to z in ) rq r� r� rg � in_usersiter0 �in_site_packages�raw_name�locationr )rr r� r` �messagerJ rJ rK �get_dist_to_uninstallm s ���z Factory.get_dist_to_uninstall�causesrC c C s� |sJ d��| j j}t|�dkr+t|d jj�}d|d jj�d|� d|��}t|�S d|� d�}|D ]}|j� � }t|jj�}|d |�d |� d �7 }q3t|�S ) Nz,Requires-Python error reported with no causer1 r zPackage z requires a different Python: z not in z%Packages require a different Python. z not in:� z (required by �)) re r� �lenrQ rD r� rE r� r �format_for_error)rr r� r� r� r� �cause�packagerJ rJ rK � _report_requires_python_error� s" ��� z%Factory._report_requires_python_errorr� rE c C s |d u r t |�}n |� d|j� d�}| j�|j�}| j�� }t� }t� }|D ]}|jr/|jjnd} | r:|� |j � q&|� |j � q&dd� t |�D �} dd� t |�D �} | r`t � dd�| �p^d � |rmt � d d �|�pkd � t � d |d�| �pwd � t |�d kr�t �d� td|� ��S )Nz (from r� Fc S � g | ]}t |��qS rJ �rQ �r_ �vrJ rJ rK � <listcomp>� r� z?Factory._report_single_requirement_conflict.<locals>.<listcomp>c S r rJ r r rJ rJ rK r � r� z)Ignored the following yanked versions: %s�, �nonezJIgnored the following versions that require a different python version: %sz; zNCould not find a version that satisfies the requirement %s (from versions: %s)zrequirements.txtz�HINT: You are attempting to install a package literally named "requirements.txt" (which cannot exist). Consider using the '-r' flag to install the packages listed in requirements.txtz#No matching distribution found for )rQ r� rc �find_all_candidatesr� � requires_python_skipped_reasonsr� rw r� r� r� �sortedr� �critical�joinr� r ) rr r� rE �req_disp�cands�skipped_by_requires_python� versions_set�yanked_versions_setr� r� �versions�yanked_versionsrJ rJ rK �#_report_single_requirement_conflict� sD � � � �z+Factory._report_single_requirement_conflictr� z,ResolutionImpossible[Requirement, Candidate]rO c s� |j sJ d��� fdd�|j D �}|r� �td|��S t|j �dkr4|j d \}}|j|vr4� �||�S dtt dtfd d �}d tdtfd d �}t � }|j D ]\}}|d u r[|� � } n||�} |� | � qN|rn|t |��} nd} d| � d�} t �| � d} t � } |j D ],\}}|j|v r�| � |j� | d } |r�| |j� d|j� d� } n| d } | |� � } q�| D ]} || j}| d| � |� �7 } q�| d d d d d } t �| � td �S ) Nz)Installation error reported with no causec s* g | ]}t |jt�r|j�� j�s|�qS rJ )� isinstancerD r? r� re )r_ r� rv rJ rK r � s � ��z2Factory.get_installation_error.<locals>.<listcomp>zSequence[ConflictCause]r1 r �partsr] c S s2 t | �dkr | d S d�| d d� �d | d S )Nr1 r r ���z and )r� r )r rJ rJ rK � text_join� s z1Factory.get_installation_error.<locals>.text_joinrE c S sF | � � }|r |js| j� d| j� �S t|jt�r t|jj�S t|j�S )Nr� )�get_install_requirementr� r� r� r r* rQ )rE r� rJ rJ rK �describe_trigger� s z8Factory.get_installation_error.<locals>.describe_triggerzthe requested packageszCannot install z> because these package versions have conflicting dependencies.z The conflict is caused by:z � z depends on zThe user requested z% The user requested (constraint) z z To fix this you could try to: z91. loosen the range of package versions you've specified z<2. remove package versions to allow pip to attempt to solve zthe dependency conflict z�ResolutionImpossible: for help visit https://pip.pypa.io/en/latest/topics/dependency-resolution/#dealing-with-dependency-conflicts)r� r r r� r� r r rQ r2 r� r� r� r r� r r� r� r� r )rr r� rO �requires_python_causesr� rE r r �triggers�triggerr� r~ �relevant_constraintsr� �specrJ rv rK �get_installation_error� sn �� � ������ �z Factory.get_installation_errorru )rJ )=rF rG rH r" r' r, r r r� r rR rt �propertyrY r% r r6 r rQ r* r8 r� r# r2 r� r r r� r� r r r. r r r� r4 r r� r3 r� r r r� r� r rM r� r> r� r� r� r r� r� r r r r r r r! rJ rJ rJ rK rS ` sX �������� � � �'���� ���� ������ ����� �9����� �f�� ���� ������� �L�� �5� �*� � ���� �� � �� � � ��� �4� ��rS )cr� r� �logging�typingr r r r r r r r r r r r r r r r �"pip._vendor.packaging.requirementsr � pip._vendor.packaging.specifiersr �pip._vendor.packaging.utilsr r � pip._vendor.packaging.versionr r �pip._vendor.resolvelibr �pip._internal.cacher r �pip._internal.exceptionsr r r r r r r! �"pip._internal.index.package_finderr" �pip._internal.metadatar# r$ �pip._internal.models.linkr% �pip._internal.models.wheelr& � pip._internal.operations.preparer' � pip._internal.req.constructorsr( r) � pip._internal.req.req_installr* r+ � pip._internal.resolution.baser, �&pip._internal.utils.compatibility_tagsr- �pip._internal.utils.hashesr. � pip._internal.utils.packagingr/ � pip._internal.utils.virtualenvr0 r� r2 r3 r4 � candidatesr5 r6 r7 r8 r9 r: r; �found_candidatesr< r= rN r> r? r@ rA rB rC � getLoggerrF r� rL �CacherM rS rJ rJ rJ rK �<module> sD H $ $ resolvelib/resolver.py 0000644 00000030460 15030103266 0011124 0 ustar 00 import contextlib import functools import logging import os from typing import TYPE_CHECKING, Dict, List, Optional, Set, Tuple, cast from pip._vendor.packaging.utils import canonicalize_name from pip._vendor.resolvelib import BaseReporter, ResolutionImpossible from pip._vendor.resolvelib import Resolver as RLResolver from pip._vendor.resolvelib.structs import DirectedGraph from pip._internal.cache import WheelCache from pip._internal.index.package_finder import PackageFinder from pip._internal.operations.prepare import RequirementPreparer from pip._internal.req.constructors import install_req_extend_extras from pip._internal.req.req_install import InstallRequirement from pip._internal.req.req_set import RequirementSet from pip._internal.resolution.base import BaseResolver, InstallRequirementProvider from pip._internal.resolution.resolvelib.provider import PipProvider from pip._internal.resolution.resolvelib.reporter import ( PipDebuggingReporter, PipReporter, ) from pip._internal.utils.packaging import get_requirement from .base import Candidate, Requirement from .factory import Factory if TYPE_CHECKING: from pip._vendor.resolvelib.resolvers import Result as RLResult Result = RLResult[Requirement, Candidate, str] logger = logging.getLogger(__name__) class Resolver(BaseResolver): _allowed_strategies = {"eager", "only-if-needed", "to-satisfy-only"} def __init__( self, preparer: RequirementPreparer, finder: PackageFinder, wheel_cache: Optional[WheelCache], make_install_req: InstallRequirementProvider, use_user_site: bool, ignore_dependencies: bool, ignore_installed: bool, ignore_requires_python: bool, force_reinstall: bool, upgrade_strategy: str, py_version_info: Optional[Tuple[int, ...]] = None, ): super().__init__() assert upgrade_strategy in self._allowed_strategies self.factory = Factory( finder=finder, preparer=preparer, make_install_req=make_install_req, wheel_cache=wheel_cache, use_user_site=use_user_site, force_reinstall=force_reinstall, ignore_installed=ignore_installed, ignore_requires_python=ignore_requires_python, py_version_info=py_version_info, ) self.ignore_dependencies = ignore_dependencies self.upgrade_strategy = upgrade_strategy self._result: Optional[Result] = None def resolve( self, root_reqs: List[InstallRequirement], check_supported_wheels: bool ) -> RequirementSet: collected = self.factory.collect_root_requirements(root_reqs) provider = PipProvider( factory=self.factory, constraints=collected.constraints, ignore_dependencies=self.ignore_dependencies, upgrade_strategy=self.upgrade_strategy, user_requested=collected.user_requested, ) if "PIP_RESOLVER_DEBUG" in os.environ: reporter: BaseReporter = PipDebuggingReporter() else: reporter = PipReporter() resolver: RLResolver[Requirement, Candidate, str] = RLResolver( provider, reporter, ) try: limit_how_complex_resolution_can_be = 200000 result = self._result = resolver.resolve( collected.requirements, max_rounds=limit_how_complex_resolution_can_be ) except ResolutionImpossible as e: error = self.factory.get_installation_error( cast("ResolutionImpossible[Requirement, Candidate]", e), collected.constraints, ) raise error from e req_set = RequirementSet(check_supported_wheels=check_supported_wheels) # process candidates with extras last to ensure their base equivalent is # already in the req_set if appropriate. # Python's sort is stable so using a binary key function keeps relative order # within both subsets. for candidate in sorted( result.mapping.values(), key=lambda c: c.name != c.project_name ): ireq = candidate.get_install_requirement() if ireq is None: if candidate.name != candidate.project_name: # extend existing req's extras with contextlib.suppress(KeyError): req = req_set.get_requirement(candidate.project_name) req_set.add_named_requirement( install_req_extend_extras( req, get_requirement(candidate.name).extras ) ) continue # Check if there is already an installation under the same name, # and set a flag for later stages to uninstall it, if needed. installed_dist = self.factory.get_dist_to_uninstall(candidate) if installed_dist is None: # There is no existing installation -- nothing to uninstall. ireq.should_reinstall = False elif self.factory.force_reinstall: # The --force-reinstall flag is set -- reinstall. ireq.should_reinstall = True elif installed_dist.version != candidate.version: # The installation is different in version -- reinstall. ireq.should_reinstall = True elif candidate.is_editable or installed_dist.editable: # The incoming distribution is editable, or different in # editable-ness to installation -- reinstall. ireq.should_reinstall = True elif candidate.source_link and candidate.source_link.is_file: # The incoming distribution is under file:// if candidate.source_link.is_wheel: # is a local wheel -- do nothing. logger.info( "%s is already installed with the same version as the " "provided wheel. Use --force-reinstall to force an " "installation of the wheel.", ireq.name, ) continue # is a local sdist or path -- reinstall ireq.should_reinstall = True else: continue link = candidate.source_link if link and link.is_yanked: # The reason can contain non-ASCII characters, Unicode # is required for Python 2. msg = ( "The candidate selected for download or install is a " "yanked version: {name!r} candidate (version {version} " "at {link})\nReason for being yanked: {reason}" ).format( name=candidate.name, version=candidate.version, link=link, reason=link.yanked_reason or "<none given>", ) logger.warning(msg) req_set.add_named_requirement(ireq) reqs = req_set.all_requirements self.factory.preparer.prepare_linked_requirements_more(reqs) for req in reqs: req.prepared = True req.needs_more_preparation = False return req_set def get_installation_order( self, req_set: RequirementSet ) -> List[InstallRequirement]: """Get order for installation of requirements in RequirementSet. The returned list contains a requirement before another that depends on it. This helps ensure that the environment is kept consistent as they get installed one-by-one. The current implementation creates a topological ordering of the dependency graph, giving more weight to packages with less or no dependencies, while breaking any cycles in the graph at arbitrary points. We make no guarantees about where the cycle would be broken, other than it *would* be broken. """ assert self._result is not None, "must call resolve() first" if not req_set.requirements: # Nothing is left to install, so we do not need an order. return [] graph = self._result.graph weights = get_topological_weights(graph, set(req_set.requirements.keys())) sorted_items = sorted( req_set.requirements.items(), key=functools.partial(_req_set_item_sorter, weights=weights), reverse=True, ) return [ireq for _, ireq in sorted_items] def get_topological_weights( graph: "DirectedGraph[Optional[str]]", requirement_keys: Set[str] ) -> Dict[Optional[str], int]: """Assign weights to each node based on how "deep" they are. This implementation may change at any point in the future without prior notice. We first simplify the dependency graph by pruning any leaves and giving them the highest weight: a package without any dependencies should be installed first. This is done again and again in the same way, giving ever less weight to the newly found leaves. The loop stops when no leaves are left: all remaining packages have at least one dependency left in the graph. Then we continue with the remaining graph, by taking the length for the longest path to any node from root, ignoring any paths that contain a single node twice (i.e. cycles). This is done through a depth-first search through the graph, while keeping track of the path to the node. Cycles in the graph result would result in node being revisited while also being on its own path. In this case, take no action. This helps ensure we don't get stuck in a cycle. When assigning weight, the longer path (i.e. larger length) is preferred. We are only interested in the weights of packages that are in the requirement_keys. """ path: Set[Optional[str]] = set() weights: Dict[Optional[str], int] = {} def visit(node: Optional[str]) -> None: if node in path: # We hit a cycle, so we'll break it here. return # Time to visit the children! path.add(node) for child in graph.iter_children(node): visit(child) path.remove(node) if node not in requirement_keys: return last_known_parent_count = weights.get(node, 0) weights[node] = max(last_known_parent_count, len(path)) # Simplify the graph, pruning leaves that have no dependencies. # This is needed for large graphs (say over 200 packages) because the # `visit` function is exponentially slower then, taking minutes. # See https://github.com/pypa/pip/issues/10557 # We will loop until we explicitly break the loop. while True: leaves = set() for key in graph: if key is None: continue for _child in graph.iter_children(key): # This means we have at least one child break else: # No child. leaves.add(key) if not leaves: # We are done simplifying. break # Calculate the weight for the leaves. weight = len(graph) - 1 for leaf in leaves: if leaf not in requirement_keys: continue weights[leaf] = weight # Remove the leaves from the graph, making it simpler. for leaf in leaves: graph.remove(leaf) # Visit the remaining graph. # `None` is guaranteed to be the root node by resolvelib. visit(None) # Sanity check: all requirement keys should be in the weights, # and no other keys should be in the weights. difference = set(weights.keys()).difference(requirement_keys) assert not difference, difference return weights def _req_set_item_sorter( item: Tuple[str, InstallRequirement], weights: Dict[Optional[str], int], ) -> Tuple[int, str]: """Key function used to sort install requirements for installation. Based on the "weight" mapping calculated in ``get_installation_order()``. The canonical package name is returned as the second member as a tie- breaker to ensure the result is predictable, which is useful in tests. """ name = canonicalize_name(item[0]) return weights[name], name resolvelib/found_candidates.py 0000644 00000014357 15030103266 0012564 0 ustar 00 """Utilities to lazily create and visit candidates found. Creating and visiting a candidate is a *very* costly operation. It involves fetching, extracting, potentially building modules from source, and verifying distribution metadata. It is therefore crucial for performance to keep everything here lazy all the way down, so we only touch candidates that we absolutely need, and not "download the world" when we only need one version of something. """ import functools import logging from collections.abc import Sequence from typing import TYPE_CHECKING, Any, Callable, Iterator, Optional, Set, Tuple from pip._vendor.packaging.version import _BaseVersion from pip._internal.exceptions import MetadataInvalid from .base import Candidate logger = logging.getLogger(__name__) IndexCandidateInfo = Tuple[_BaseVersion, Callable[[], Optional[Candidate]]] if TYPE_CHECKING: SequenceCandidate = Sequence[Candidate] else: # For compatibility: Python before 3.9 does not support using [] on the # Sequence class. # # >>> from collections.abc import Sequence # >>> Sequence[str] # Traceback (most recent call last): # File "<stdin>", line 1, in <module> # TypeError: 'ABCMeta' object is not subscriptable # # TODO: Remove this block after dropping Python 3.8 support. SequenceCandidate = Sequence def _iter_built(infos: Iterator[IndexCandidateInfo]) -> Iterator[Candidate]: """Iterator for ``FoundCandidates``. This iterator is used when the package is not already installed. Candidates from index come later in their normal ordering. """ versions_found: Set[_BaseVersion] = set() for version, func in infos: if version in versions_found: continue try: candidate = func() except MetadataInvalid as e: logger.warning( "Ignoring version %s of %s since it has invalid metadata:\n" "%s\n" "Please use pip<24.1 if you need to use this version.", version, e.ireq.name, e, ) # Mark version as found to avoid trying other candidates with the same # version, since they most likely have invalid metadata as well. versions_found.add(version) else: if candidate is None: continue yield candidate versions_found.add(version) def _iter_built_with_prepended( installed: Candidate, infos: Iterator[IndexCandidateInfo] ) -> Iterator[Candidate]: """Iterator for ``FoundCandidates``. This iterator is used when the resolver prefers the already-installed candidate and NOT to upgrade. The installed candidate is therefore always yielded first, and candidates from index come later in their normal ordering, except skipped when the version is already installed. """ yield installed versions_found: Set[_BaseVersion] = {installed.version} for version, func in infos: if version in versions_found: continue candidate = func() if candidate is None: continue yield candidate versions_found.add(version) def _iter_built_with_inserted( installed: Candidate, infos: Iterator[IndexCandidateInfo] ) -> Iterator[Candidate]: """Iterator for ``FoundCandidates``. This iterator is used when the resolver prefers to upgrade an already-installed package. Candidates from index are returned in their normal ordering, except replaced when the version is already installed. The implementation iterates through and yields other candidates, inserting the installed candidate exactly once before we start yielding older or equivalent candidates, or after all other candidates if they are all newer. """ versions_found: Set[_BaseVersion] = set() for version, func in infos: if version in versions_found: continue # If the installed candidate is better, yield it first. if installed.version >= version: yield installed versions_found.add(installed.version) candidate = func() if candidate is None: continue yield candidate versions_found.add(version) # If the installed candidate is older than all other candidates. if installed.version not in versions_found: yield installed class FoundCandidates(SequenceCandidate): """A lazy sequence to provide candidates to the resolver. The intended usage is to return this from `find_matches()` so the resolver can iterate through the sequence multiple times, but only access the index page when remote packages are actually needed. This improve performances when suitable candidates are already installed on disk. """ def __init__( self, get_infos: Callable[[], Iterator[IndexCandidateInfo]], installed: Optional[Candidate], prefers_installed: bool, incompatible_ids: Set[int], ): self._get_infos = get_infos self._installed = installed self._prefers_installed = prefers_installed self._incompatible_ids = incompatible_ids def __getitem__(self, index: Any) -> Any: # Implemented to satisfy the ABC check. This is not needed by the # resolver, and should not be used by the provider either (for # performance reasons). raise NotImplementedError("don't do this") def __iter__(self) -> Iterator[Candidate]: infos = self._get_infos() if not self._installed: iterator = _iter_built(infos) elif self._prefers_installed: iterator = _iter_built_with_prepended(self._installed, infos) else: iterator = _iter_built_with_inserted(self._installed, infos) return (c for c in iterator if id(c) not in self._incompatible_ids) def __len__(self) -> int: # Implemented to satisfy the ABC check. This is not needed by the # resolver, and should not be used by the provider either (for # performance reasons). raise NotImplementedError("don't do this") @functools.lru_cache(maxsize=1) def __bool__(self) -> bool: if self._prefers_installed and self._installed: return True return any(self) resolvelib/candidates.py 0000644 00000047041 15030103266 0011365 0 ustar 00 import logging import sys from typing import TYPE_CHECKING, Any, FrozenSet, Iterable, Optional, Tuple, Union, cast from pip._vendor.packaging.requirements import InvalidRequirement from pip._vendor.packaging.utils import NormalizedName, canonicalize_name from pip._vendor.packaging.version import Version from pip._internal.exceptions import ( HashError, InstallationSubprocessError, InvalidInstalledPackage, MetadataInconsistent, MetadataInvalid, ) from pip._internal.metadata import BaseDistribution from pip._internal.models.link import Link, links_equivalent from pip._internal.models.wheel import Wheel from pip._internal.req.constructors import ( install_req_from_editable, install_req_from_line, ) from pip._internal.req.req_install import InstallRequirement from pip._internal.utils.direct_url_helpers import direct_url_from_link from pip._internal.utils.misc import normalize_version_info from .base import Candidate, Requirement, format_name if TYPE_CHECKING: from .factory import Factory logger = logging.getLogger(__name__) BaseCandidate = Union[ "AlreadyInstalledCandidate", "EditableCandidate", "LinkCandidate", ] # Avoid conflicting with the PyPI package "Python". REQUIRES_PYTHON_IDENTIFIER = cast(NormalizedName, "<Python from Requires-Python>") def as_base_candidate(candidate: Candidate) -> Optional[BaseCandidate]: """The runtime version of BaseCandidate.""" base_candidate_classes = ( AlreadyInstalledCandidate, EditableCandidate, LinkCandidate, ) if isinstance(candidate, base_candidate_classes): return candidate return None def make_install_req_from_link( link: Link, template: InstallRequirement ) -> InstallRequirement: assert not template.editable, "template is editable" if template.req: line = str(template.req) else: line = link.url ireq = install_req_from_line( line, user_supplied=template.user_supplied, comes_from=template.comes_from, use_pep517=template.use_pep517, isolated=template.isolated, constraint=template.constraint, global_options=template.global_options, hash_options=template.hash_options, config_settings=template.config_settings, ) ireq.original_link = template.original_link ireq.link = link ireq.extras = template.extras return ireq def make_install_req_from_editable( link: Link, template: InstallRequirement ) -> InstallRequirement: assert template.editable, "template not editable" ireq = install_req_from_editable( link.url, user_supplied=template.user_supplied, comes_from=template.comes_from, use_pep517=template.use_pep517, isolated=template.isolated, constraint=template.constraint, permit_editable_wheels=template.permit_editable_wheels, global_options=template.global_options, hash_options=template.hash_options, config_settings=template.config_settings, ) ireq.extras = template.extras return ireq def _make_install_req_from_dist( dist: BaseDistribution, template: InstallRequirement ) -> InstallRequirement: if template.req: line = str(template.req) elif template.link: line = f"{dist.canonical_name} @ {template.link.url}" else: line = f"{dist.canonical_name}=={dist.version}" ireq = install_req_from_line( line, user_supplied=template.user_supplied, comes_from=template.comes_from, use_pep517=template.use_pep517, isolated=template.isolated, constraint=template.constraint, global_options=template.global_options, hash_options=template.hash_options, config_settings=template.config_settings, ) ireq.satisfied_by = dist return ireq class _InstallRequirementBackedCandidate(Candidate): """A candidate backed by an ``InstallRequirement``. This represents a package request with the target not being already in the environment, and needs to be fetched and installed. The backing ``InstallRequirement`` is responsible for most of the leg work; this class exposes appropriate information to the resolver. :param link: The link passed to the ``InstallRequirement``. The backing ``InstallRequirement`` will use this link to fetch the distribution. :param source_link: The link this candidate "originates" from. This is different from ``link`` when the link is found in the wheel cache. ``link`` would point to the wheel cache, while this points to the found remote link (e.g. from pypi.org). """ dist: BaseDistribution is_installed = False def __init__( self, link: Link, source_link: Link, ireq: InstallRequirement, factory: "Factory", name: Optional[NormalizedName] = None, version: Optional[Version] = None, ) -> None: self._link = link self._source_link = source_link self._factory = factory self._ireq = ireq self._name = name self._version = version self.dist = self._prepare() self._hash: Optional[int] = None def __str__(self) -> str: return f"{self.name} {self.version}" def __repr__(self) -> str: return f"{self.__class__.__name__}({str(self._link)!r})" def __hash__(self) -> int: if self._hash is not None: return self._hash self._hash = hash((self.__class__, self._link)) return self._hash def __eq__(self, other: Any) -> bool: if isinstance(other, self.__class__): return links_equivalent(self._link, other._link) return False @property def source_link(self) -> Optional[Link]: return self._source_link @property def project_name(self) -> NormalizedName: """The normalised name of the project the candidate refers to""" if self._name is None: self._name = self.dist.canonical_name return self._name @property def name(self) -> str: return self.project_name @property def version(self) -> Version: if self._version is None: self._version = self.dist.version return self._version def format_for_error(self) -> str: return ( f"{self.name} {self.version} " f"(from {self._link.file_path if self._link.is_file else self._link})" ) def _prepare_distribution(self) -> BaseDistribution: raise NotImplementedError("Override in subclass") def _check_metadata_consistency(self, dist: BaseDistribution) -> None: """Check for consistency of project name and version of dist.""" if self._name is not None and self._name != dist.canonical_name: raise MetadataInconsistent( self._ireq, "name", self._name, dist.canonical_name, ) if self._version is not None and self._version != dist.version: raise MetadataInconsistent( self._ireq, "version", str(self._version), str(dist.version), ) # check dependencies are valid # TODO performance: this means we iterate the dependencies at least twice, # we may want to cache parsed Requires-Dist try: list(dist.iter_dependencies(list(dist.iter_provided_extras()))) except InvalidRequirement as e: raise MetadataInvalid(self._ireq, str(e)) def _prepare(self) -> BaseDistribution: try: dist = self._prepare_distribution() except HashError as e: # Provide HashError the underlying ireq that caused it. This # provides context for the resulting error message to show the # offending line to the user. e.req = self._ireq raise except InstallationSubprocessError as exc: # The output has been presented already, so don't duplicate it. exc.context = "See above for output." raise self._check_metadata_consistency(dist) return dist def iter_dependencies(self, with_requires: bool) -> Iterable[Optional[Requirement]]: requires = self.dist.iter_dependencies() if with_requires else () for r in requires: yield from self._factory.make_requirements_from_spec(str(r), self._ireq) yield self._factory.make_requires_python_requirement(self.dist.requires_python) def get_install_requirement(self) -> Optional[InstallRequirement]: return self._ireq class LinkCandidate(_InstallRequirementBackedCandidate): is_editable = False def __init__( self, link: Link, template: InstallRequirement, factory: "Factory", name: Optional[NormalizedName] = None, version: Optional[Version] = None, ) -> None: source_link = link cache_entry = factory.get_wheel_cache_entry(source_link, name) if cache_entry is not None: logger.debug("Using cached wheel link: %s", cache_entry.link) link = cache_entry.link ireq = make_install_req_from_link(link, template) assert ireq.link == link if ireq.link.is_wheel and not ireq.link.is_file: wheel = Wheel(ireq.link.filename) wheel_name = canonicalize_name(wheel.name) assert name == wheel_name, f"{name!r} != {wheel_name!r} for wheel" # Version may not be present for PEP 508 direct URLs if version is not None: wheel_version = Version(wheel.version) assert ( version == wheel_version ), f"{version!r} != {wheel_version!r} for wheel {name}" if cache_entry is not None: assert ireq.link.is_wheel assert ireq.link.is_file if cache_entry.persistent and template.link is template.original_link: ireq.cached_wheel_source_link = source_link if cache_entry.origin is not None: ireq.download_info = cache_entry.origin else: # Legacy cache entry that does not have origin.json. # download_info may miss the archive_info.hashes field. ireq.download_info = direct_url_from_link( source_link, link_is_in_wheel_cache=cache_entry.persistent ) super().__init__( link=link, source_link=source_link, ireq=ireq, factory=factory, name=name, version=version, ) def _prepare_distribution(self) -> BaseDistribution: preparer = self._factory.preparer return preparer.prepare_linked_requirement(self._ireq, parallel_builds=True) class EditableCandidate(_InstallRequirementBackedCandidate): is_editable = True def __init__( self, link: Link, template: InstallRequirement, factory: "Factory", name: Optional[NormalizedName] = None, version: Optional[Version] = None, ) -> None: super().__init__( link=link, source_link=link, ireq=make_install_req_from_editable(link, template), factory=factory, name=name, version=version, ) def _prepare_distribution(self) -> BaseDistribution: return self._factory.preparer.prepare_editable_requirement(self._ireq) class AlreadyInstalledCandidate(Candidate): is_installed = True source_link = None def __init__( self, dist: BaseDistribution, template: InstallRequirement, factory: "Factory", ) -> None: self.dist = dist self._ireq = _make_install_req_from_dist(dist, template) self._factory = factory self._version = None # This is just logging some messages, so we can do it eagerly. # The returned dist would be exactly the same as self.dist because we # set satisfied_by in _make_install_req_from_dist. # TODO: Supply reason based on force_reinstall and upgrade_strategy. skip_reason = "already satisfied" factory.preparer.prepare_installed_requirement(self._ireq, skip_reason) def __str__(self) -> str: return str(self.dist) def __repr__(self) -> str: return f"{self.__class__.__name__}({self.dist!r})" def __eq__(self, other: object) -> bool: if not isinstance(other, AlreadyInstalledCandidate): return NotImplemented return self.name == other.name and self.version == other.version def __hash__(self) -> int: return hash((self.name, self.version)) @property def project_name(self) -> NormalizedName: return self.dist.canonical_name @property def name(self) -> str: return self.project_name @property def version(self) -> Version: if self._version is None: self._version = self.dist.version return self._version @property def is_editable(self) -> bool: return self.dist.editable def format_for_error(self) -> str: return f"{self.name} {self.version} (Installed)" def iter_dependencies(self, with_requires: bool) -> Iterable[Optional[Requirement]]: if not with_requires: return try: for r in self.dist.iter_dependencies(): yield from self._factory.make_requirements_from_spec(str(r), self._ireq) except InvalidRequirement as exc: raise InvalidInstalledPackage(dist=self.dist, invalid_exc=exc) from None def get_install_requirement(self) -> Optional[InstallRequirement]: return None class ExtrasCandidate(Candidate): """A candidate that has 'extras', indicating additional dependencies. Requirements can be for a project with dependencies, something like foo[extra]. The extras don't affect the project/version being installed directly, but indicate that we need additional dependencies. We model that by having an artificial ExtrasCandidate that wraps the "base" candidate. The ExtrasCandidate differs from the base in the following ways: 1. It has a unique name, of the form foo[extra]. This causes the resolver to treat it as a separate node in the dependency graph. 2. When we're getting the candidate's dependencies, a) We specify that we want the extra dependencies as well. b) We add a dependency on the base candidate. See below for why this is needed. 3. We return None for the underlying InstallRequirement, as the base candidate will provide it, and we don't want to end up with duplicates. The dependency on the base candidate is needed so that the resolver can't decide that it should recommend foo[extra1] version 1.0 and foo[extra2] version 2.0. Having those candidates depend on foo=1.0 and foo=2.0 respectively forces the resolver to recognise that this is a conflict. """ def __init__( self, base: BaseCandidate, extras: FrozenSet[str], *, comes_from: Optional[InstallRequirement] = None, ) -> None: """ :param comes_from: the InstallRequirement that led to this candidate if it differs from the base's InstallRequirement. This will often be the case in the sense that this candidate's requirement has the extras while the base's does not. Unlike the InstallRequirement backed candidates, this requirement is used solely for reporting purposes, it does not do any leg work. """ self.base = base self.extras = frozenset(canonicalize_name(e) for e in extras) self._comes_from = comes_from if comes_from is not None else self.base._ireq def __str__(self) -> str: name, rest = str(self.base).split(" ", 1) return "{}[{}] {}".format(name, ",".join(self.extras), rest) def __repr__(self) -> str: return f"{self.__class__.__name__}(base={self.base!r}, extras={self.extras!r})" def __hash__(self) -> int: return hash((self.base, self.extras)) def __eq__(self, other: Any) -> bool: if isinstance(other, self.__class__): return self.base == other.base and self.extras == other.extras return False @property def project_name(self) -> NormalizedName: return self.base.project_name @property def name(self) -> str: """The normalised name of the project the candidate refers to""" return format_name(self.base.project_name, self.extras) @property def version(self) -> Version: return self.base.version def format_for_error(self) -> str: return "{} [{}]".format( self.base.format_for_error(), ", ".join(sorted(self.extras)) ) @property def is_installed(self) -> bool: return self.base.is_installed @property def is_editable(self) -> bool: return self.base.is_editable @property def source_link(self) -> Optional[Link]: return self.base.source_link def iter_dependencies(self, with_requires: bool) -> Iterable[Optional[Requirement]]: factory = self.base._factory # Add a dependency on the exact base # (See note 2b in the class docstring) yield factory.make_requirement_from_candidate(self.base) if not with_requires: return # The user may have specified extras that the candidate doesn't # support. We ignore any unsupported extras here. valid_extras = self.extras.intersection(self.base.dist.iter_provided_extras()) invalid_extras = self.extras.difference(self.base.dist.iter_provided_extras()) for extra in sorted(invalid_extras): logger.warning( "%s %s does not provide the extra '%s'", self.base.name, self.version, extra, ) for r in self.base.dist.iter_dependencies(valid_extras): yield from factory.make_requirements_from_spec( str(r), self._comes_from, valid_extras, ) def get_install_requirement(self) -> Optional[InstallRequirement]: # We don't return anything here, because we always # depend on the base candidate, and we'll get the # install requirement from that. return None class RequiresPythonCandidate(Candidate): is_installed = False source_link = None def __init__(self, py_version_info: Optional[Tuple[int, ...]]) -> None: if py_version_info is not None: version_info = normalize_version_info(py_version_info) else: version_info = sys.version_info[:3] self._version = Version(".".join(str(c) for c in version_info)) # We don't need to implement __eq__() and __ne__() since there is always # only one RequiresPythonCandidate in a resolution, i.e. the host Python. # The built-in object.__eq__() and object.__ne__() do exactly what we want. def __str__(self) -> str: return f"Python {self._version}" @property def project_name(self) -> NormalizedName: return REQUIRES_PYTHON_IDENTIFIER @property def name(self) -> str: return REQUIRES_PYTHON_IDENTIFIER @property def version(self) -> Version: return self._version def format_for_error(self) -> str: return f"Python {self.version}" def iter_dependencies(self, with_requires: bool) -> Iterable[Optional[Requirement]]: return () def get_install_requirement(self) -> Optional[InstallRequirement]: return None resolvelib/provider.py 0000644 00000023317 15030103266 0011120 0 ustar 00 import collections import math from functools import lru_cache from typing import ( TYPE_CHECKING, Dict, Iterable, Iterator, Mapping, Sequence, TypeVar, Union, ) from pip._vendor.resolvelib.providers import AbstractProvider from .base import Candidate, Constraint, Requirement from .candidates import REQUIRES_PYTHON_IDENTIFIER from .factory import Factory if TYPE_CHECKING: from pip._vendor.resolvelib.providers import Preference from pip._vendor.resolvelib.resolvers import RequirementInformation PreferenceInformation = RequirementInformation[Requirement, Candidate] _ProviderBase = AbstractProvider[Requirement, Candidate, str] else: _ProviderBase = AbstractProvider # Notes on the relationship between the provider, the factory, and the # candidate and requirement classes. # # The provider is a direct implementation of the resolvelib class. Its role # is to deliver the API that resolvelib expects. # # Rather than work with completely abstract "requirement" and "candidate" # concepts as resolvelib does, pip has concrete classes implementing these two # ideas. The API of Requirement and Candidate objects are defined in the base # classes, but essentially map fairly directly to the equivalent provider # methods. In particular, `find_matches` and `is_satisfied_by` are # requirement methods, and `get_dependencies` is a candidate method. # # The factory is the interface to pip's internal mechanisms. It is stateless, # and is created by the resolver and held as a property of the provider. It is # responsible for creating Requirement and Candidate objects, and provides # services to those objects (access to pip's finder and preparer). D = TypeVar("D") V = TypeVar("V") def _get_with_identifier( mapping: Mapping[str, V], identifier: str, default: D, ) -> Union[D, V]: """Get item from a package name lookup mapping with a resolver identifier. This extra logic is needed when the target mapping is keyed by package name, which cannot be directly looked up with an identifier (which may contain requested extras). Additional logic is added to also look up a value by "cleaning up" the extras from the identifier. """ if identifier in mapping: return mapping[identifier] # HACK: Theoretically we should check whether this identifier is a valid # "NAME[EXTRAS]" format, and parse out the name part with packaging or # some regular expression. But since pip's resolver only spits out three # kinds of identifiers: normalized PEP 503 names, normalized names plus # extras, and Requires-Python, we can cheat a bit here. name, open_bracket, _ = identifier.partition("[") if open_bracket and name in mapping: return mapping[name] return default class PipProvider(_ProviderBase): """Pip's provider implementation for resolvelib. :params constraints: A mapping of constraints specified by the user. Keys are canonicalized project names. :params ignore_dependencies: Whether the user specified ``--no-deps``. :params upgrade_strategy: The user-specified upgrade strategy. :params user_requested: A set of canonicalized package names that the user supplied for pip to install/upgrade. """ def __init__( self, factory: Factory, constraints: Dict[str, Constraint], ignore_dependencies: bool, upgrade_strategy: str, user_requested: Dict[str, int], ) -> None: self._factory = factory self._constraints = constraints self._ignore_dependencies = ignore_dependencies self._upgrade_strategy = upgrade_strategy self._user_requested = user_requested self._known_depths: Dict[str, float] = collections.defaultdict(lambda: math.inf) def identify(self, requirement_or_candidate: Union[Requirement, Candidate]) -> str: return requirement_or_candidate.name def get_preference( self, identifier: str, resolutions: Mapping[str, Candidate], candidates: Mapping[str, Iterator[Candidate]], information: Mapping[str, Iterable["PreferenceInformation"]], backtrack_causes: Sequence["PreferenceInformation"], ) -> "Preference": """Produce a sort key for given requirement based on preference. The lower the return value is, the more preferred this group of arguments is. Currently pip considers the following in order: * Prefer if any of the known requirements is "direct", e.g. points to an explicit URL. * If equal, prefer if any requirement is "pinned", i.e. contains operator ``===`` or ``==``. * If equal, calculate an approximate "depth" and resolve requirements closer to the user-specified requirements first. If the depth cannot by determined (eg: due to no matching parents), it is considered infinite. * Order user-specified requirements by the order they are specified. * If equal, prefers "non-free" requirements, i.e. contains at least one operator, such as ``>=`` or ``<``. * If equal, order alphabetically for consistency (helps debuggability). """ try: next(iter(information[identifier])) except StopIteration: # There is no information for this identifier, so there's no known # candidates. has_information = False else: has_information = True if has_information: lookups = (r.get_candidate_lookup() for r, _ in information[identifier]) candidate, ireqs = zip(*lookups) else: candidate, ireqs = None, () operators = [ specifier.operator for specifier_set in (ireq.specifier for ireq in ireqs if ireq) for specifier in specifier_set ] direct = candidate is not None pinned = any(op[:2] == "==" for op in operators) unfree = bool(operators) try: requested_order: Union[int, float] = self._user_requested[identifier] except KeyError: requested_order = math.inf if has_information: parent_depths = ( self._known_depths[parent.name] if parent is not None else 0.0 for _, parent in information[identifier] ) inferred_depth = min(d for d in parent_depths) + 1.0 else: inferred_depth = math.inf else: inferred_depth = 1.0 self._known_depths[identifier] = inferred_depth requested_order = self._user_requested.get(identifier, math.inf) # Requires-Python has only one candidate and the check is basically # free, so we always do it first to avoid needless work if it fails. requires_python = identifier == REQUIRES_PYTHON_IDENTIFIER # Prefer the causes of backtracking on the assumption that the problem # resolving the dependency tree is related to the failures that caused # the backtracking backtrack_cause = self.is_backtrack_cause(identifier, backtrack_causes) return ( not requires_python, not direct, not pinned, not backtrack_cause, inferred_depth, requested_order, not unfree, identifier, ) def find_matches( self, identifier: str, requirements: Mapping[str, Iterator[Requirement]], incompatibilities: Mapping[str, Iterator[Candidate]], ) -> Iterable[Candidate]: def _eligible_for_upgrade(identifier: str) -> bool: """Are upgrades allowed for this project? This checks the upgrade strategy, and whether the project was one that the user specified in the command line, in order to decide whether we should upgrade if there's a newer version available. (Note that we don't need access to the `--upgrade` flag, because an upgrade strategy of "to-satisfy-only" means that `--upgrade` was not specified). """ if self._upgrade_strategy == "eager": return True elif self._upgrade_strategy == "only-if-needed": user_order = _get_with_identifier( self._user_requested, identifier, default=None, ) return user_order is not None return False constraint = _get_with_identifier( self._constraints, identifier, default=Constraint.empty(), ) return self._factory.find_candidates( identifier=identifier, requirements=requirements, constraint=constraint, prefers_installed=(not _eligible_for_upgrade(identifier)), incompatibilities=incompatibilities, is_satisfied_by=self.is_satisfied_by, ) @lru_cache(maxsize=None) def is_satisfied_by(self, requirement: Requirement, candidate: Candidate) -> bool: return requirement.is_satisfied_by(candidate) def get_dependencies(self, candidate: Candidate) -> Sequence[Requirement]: with_requires = not self._ignore_dependencies return [r for r in candidate.iter_dependencies(with_requires) if r is not None] @staticmethod def is_backtrack_cause( identifier: str, backtrack_causes: Sequence["PreferenceInformation"] ) -> bool: for backtrack_cause in backtrack_causes: if identifier == backtrack_cause.requirement.name: return True if backtrack_cause.parent and identifier == backtrack_cause.parent.name: return True return False resolvelib/reporter.py 0000644 00000006140 15030103266 0011123 0 ustar 00 from collections import defaultdict from logging import getLogger from typing import Any, DefaultDict from pip._vendor.resolvelib.reporters import BaseReporter from .base import Candidate, Requirement logger = getLogger(__name__) class PipReporter(BaseReporter): def __init__(self) -> None: self.reject_count_by_package: DefaultDict[str, int] = defaultdict(int) self._messages_at_reject_count = { 1: ( "pip is looking at multiple versions of {package_name} to " "determine which version is compatible with other " "requirements. This could take a while." ), 8: ( "pip is still looking at multiple versions of {package_name} to " "determine which version is compatible with other " "requirements. This could take a while." ), 13: ( "This is taking longer than usual. You might need to provide " "the dependency resolver with stricter constraints to reduce " "runtime. See https://pip.pypa.io/warnings/backtracking for " "guidance. If you want to abort this run, press Ctrl + C." ), } def rejecting_candidate(self, criterion: Any, candidate: Candidate) -> None: self.reject_count_by_package[candidate.name] += 1 count = self.reject_count_by_package[candidate.name] if count not in self._messages_at_reject_count: return message = self._messages_at_reject_count[count] logger.info("INFO: %s", message.format(package_name=candidate.name)) msg = "Will try a different candidate, due to conflict:" for req_info in criterion.information: req, parent = req_info.requirement, req_info.parent # Inspired by Factory.get_installation_error msg += "\n " if parent: msg += f"{parent.name} {parent.version} depends on " else: msg += "The user requested " msg += req.format_for_error() logger.debug(msg) class PipDebuggingReporter(BaseReporter): """A reporter that does an info log for every event it sees.""" def starting(self) -> None: logger.info("Reporter.starting()") def starting_round(self, index: int) -> None: logger.info("Reporter.starting_round(%r)", index) def ending_round(self, index: int, state: Any) -> None: logger.info("Reporter.ending_round(%r, state)", index) logger.debug("Reporter.ending_round(%r, %r)", index, state) def ending(self, state: Any) -> None: logger.info("Reporter.ending(%r)", state) def adding_requirement(self, requirement: Requirement, parent: Candidate) -> None: logger.info("Reporter.adding_requirement(%r, %r)", requirement, parent) def rejecting_candidate(self, criterion: Any, candidate: Candidate) -> None: logger.info("Reporter.rejecting_candidate(%r, %r)", criterion, candidate) def pinning(self, candidate: Candidate) -> None: logger.info("Reporter.pinning(%r)", candidate) resolvelib/__init__.py 0000644 00000000000 15030103266 0011005 0 ustar 00 __init__.py 0000644 00000000000 15030103266 0006637 0 ustar 00
| ver. 1.4 |
Github
|
.
| PHP 8.2.28 | Generation time: 0.03 |
proxy
|
phpinfo
|
Settings