pip._internal.operations.check Namespace Reference

Data Structures
class	PackageDetails

Functions
Tuple[PackageSet, bool]	create_package_set_from_installed ()
CheckResult	check_package_set (PackageSet package_set, Optional[Callable[[str], bool]] should_ignore=None)
ConflictDetails	check_install_conflicts (List[InstallRequirement] to_install)
Set[NormalizedName]	_simulate_installation_of (List[InstallRequirement] to_install, PackageSet package_set)
Set[NormalizedName]	_create_whitelist (Set[NormalizedName] would_be_installed, PackageSet package_set)
None	warn_legacy_versions_and_specifiers (PackageSet package_set)

Variables
	logger = logging.getLogger(__name__)
	PackageSet = Dict[NormalizedName, PackageDetails]
	Missing = Tuple[NormalizedName, Requirement]
	Conflicting = Tuple[NormalizedName, DistributionVersion, Requirement]
	MissingDict = Dict[NormalizedName, List[Missing]]
	ConflictingDict = Dict[NormalizedName, List[Conflicting]]
	CheckResult = Tuple[MissingDict, ConflictingDict]
	ConflictDetails = Tuple[PackageSet, CheckResult]

Detailed Description

Validation of dependencies of packages

Function Documentation

_create_whitelist()

Set[NormalizedName] _create_whitelist ( Set[NormalizedName]  would_be_installed, PackageSet   package_set  )

protected

Definition at line 140 of file check.py.

) -> Set[NormalizedName]:
    packages_affected = set(would_be_installed)
 
    for package_name in package_set:
        if package_name in packages_affected:
            continue
 
        for req in package_set[package_name].dependencies:
            if canonicalize_name(req.name) in packages_affected:
                packages_affected.add(package_name)
                break
 
    return packages_affected
 
 

References i.

Referenced by pip._internal.operations.check.check_install_conflicts().

Here is the caller graph for this function:

_simulate_installation_of()

Set[NormalizedName] _simulate_installation_of ( List[InstallRequirement]  to_install, PackageSet   package_set  )

protected

Computes the version of packages after installing to_install.

Definition at line 121 of file check.py.

) -> Set[NormalizedName]:
    """Computes the version of packages after installing to_install."""
    # Keep track of packages that were installed
    installed = set()
 
    # Modify it as installing requirement_set would (assuming no errors)
    for inst_req in to_install:
        abstract_dist = make_distribution_for_install_requirement(inst_req)
        dist = abstract_dist.get_metadata_distribution()
        name = dist.canonical_name
        package_set[name] = PackageDetails(dist.version, list(dist.iter_dependencies()))
 
        installed.add(name)
 
    return installed
 
 

References i.

Referenced by pip._internal.operations.check.check_install_conflicts().

Here is the caller graph for this function:

check_install_conflicts()

ConflictDetails check_install_conflicts

(

List[InstallRequirement]

to_install

)

For checking if the dependency graph would be consistent after \
installing given requirements

Definition at line 101 of file check.py.

def check_install_conflicts(to_install: List[InstallRequirement]) -> ConflictDetails:
    """For checking if the dependency graph would be consistent after \
    installing given requirements
    """
    # Start from the current state
    package_set, _ = create_package_set_from_installed()
    # Install packages
    would_be_installed = _simulate_installation_of(to_install, package_set)
 
    # Only warn about directly-dependent packages; create a whitelist of them
    whitelist = _create_whitelist(would_be_installed, package_set)
 
    return (
        package_set,
        check_package_set(
            package_set, should_ignore=lambda name: name not in whitelist
        ),
    )
 
 

References pip._internal.operations.check._create_whitelist(), pip._internal.operations.check._simulate_installation_of(), and pip._internal.operations.check.create_package_set_from_installed().

Here is the call graph for this function:

check_package_set()

CheckResult check_package_set	(	PackageSet	package_set,
		Optional[Callable[[str], bool]]	should_ignore = None
	)

Check if a package set is consistent

If should_ignore is passed, it should be a callable that takes a
package name and returns a boolean.

Definition at line 54 of file check.py.

) -> CheckResult:
    """Check if a package set is consistent
 
    If should_ignore is passed, it should be a callable that takes a
    package name and returns a boolean.
    """
 
    warn_legacy_versions_and_specifiers(package_set)
 
    missing = {}
    conflicting = {}
 
    for package_name, package_detail in package_set.items():
        # Info about dependencies of package_name
        missing_deps: Set[Missing] = set()
        conflicting_deps: Set[Conflicting] = set()
 
        if should_ignore and should_ignore(package_name):
            continue
 
        for req in package_detail.dependencies:
            name = canonicalize_name(req.name)
 
            # Check if it's missing
            if name not in package_set:
                missed = True
                if req.marker is not None:
                    missed = req.marker.evaluate({"extra": ""})
                if missed:
                    missing_deps.add((name, req))
                continue
 
            # Check if there's a conflict
            version = package_set[name].version
            if not req.specifier.contains(version, prereleases=True):
                conflicting_deps.add((name, version, req))
 
        if missing_deps:
            missing[package_name] = sorted(missing_deps, key=str)
        if conflicting_deps:
            conflicting[package_name] = sorted(conflicting_deps, key=str)
 
    return missing, conflicting
 
 

References i.

create_package_set_from_installed()

Tuple[PackageSet, bool] create_package_set_from_installed

(

)

Converts a list of distributions into a PackageSet.

Definition at line 37 of file check.py.

def create_package_set_from_installed() -> Tuple[PackageSet, bool]:
    """Converts a list of distributions into a PackageSet."""
    package_set = {}
    problems = False
    env = get_default_environment()
    for dist in env.iter_installed_distributions(local_only=False, skip=()):
        name = dist.canonical_name
        try:
            dependencies = list(dist.iter_dependencies())
            package_set[name] = PackageDetails(dist.version, dependencies)
        except (OSError, ValueError) as e:
            # Don't crash on unreadable or broken metadata.
            logger.warning("Error parsing requirements for %s: %s", name, e)
            problems = True
    return package_set, problems
 
 

References i.

Referenced by pip._internal.operations.check.check_install_conflicts().

Here is the caller graph for this function:

warn_legacy_versions_and_specifiers()

None warn_legacy_versions_and_specifiers

(

PackageSet

package_set

)

Definition at line 157 of file check.py.

def warn_legacy_versions_and_specifiers(package_set: PackageSet) -> None:
    for project_name, package_details in package_set.items():
        if isinstance(package_details.version, LegacyVersion):
            deprecated(
                reason=(
                    f"{project_name} {package_details.version} "
                    f"has a non-standard version number."
                ),
                replacement=(
                    f"to upgrade to a newer version of {project_name} "
                    f"or contact the author to suggest that they "
                    f"release a version with a conforming version number"
                ),
                issue=12063,
                gone_in="23.3",
            )
        for dep in package_details.dependencies:
            if any(isinstance(spec, LegacySpecifier) for spec in dep.specifier):
                deprecated(
                    reason=(
                        f"{project_name} {package_details.version} "
                        f"has a non-standard dependency specifier {dep}."
                    ),
                    replacement=(
                        f"to upgrade to a newer version of {project_name} "
                        f"or contact the author to suggest that they "
                        f"release a version with a conforming dependency specifiers"
                    ),
                    issue=12063,
                    gone_in="23.3",
                )

References i.

Variable Documentation

CheckResult

CheckResult = Tuple[MissingDict, ConflictingDict]

Definition at line 33 of file check.py.

ConflictDetails

ConflictDetails = Tuple[PackageSet, CheckResult]

Definition at line 34 of file check.py.

Conflicting

Conflicting = Tuple[NormalizedName, DistributionVersion, Requirement]

Definition at line 29 of file check.py.

ConflictingDict

ConflictingDict = Dict[NormalizedName, List[Conflicting]]

Definition at line 32 of file check.py.

logger

logger = logging.getLogger(__name__)

Definition at line 18 of file check.py.

Missing

Missing = Tuple[NormalizedName, Requirement]

Definition at line 28 of file check.py.

MissingDict

MissingDict = Dict[NormalizedName, List[Missing]]

Definition at line 31 of file check.py.

PackageSet

PackageSet = Dict[NormalizedName, PackageDetails]

Definition at line 27 of file check.py.