pip._internal.index.package_finder Namespace Reference

Data Structures
class	BestCandidateResult
class	CandidateEvaluator
class	CandidatePreferences
class	LinkEvaluator
class	LinkType
class	PackageFinder

Functions
bool	_check_link_requires_python (Link link, Tuple[int, int, int] version_info, bool ignore_requires_python=False)
List[InstallationCandidate]	filter_unallowed_hashes (List[InstallationCandidate] candidates, Optional[Hashes] hashes, str project_name)
int	_find_name_version_sep (str fragment, str canonical_name)
Optional[str]	_extract_version_from_fragment (str fragment, str canonical_name)

Variables
	logger = getLogger(__name__)
	BuildTag = Union[Tuple[()], Tuple[int, str]]
	CandidateSortingKey = Tuple[int, int, int, _BaseVersion, Optional[int], BuildTag]

Detailed Description

Routines related to PyPI, indexes

Function Documentation

_check_link_requires_python()

bool _check_link_requires_python ( Link  link, Tuple[int, int, int]  version_info, bool   ignore_requires_python = False  )

protected

Return whether the given Python version is compatible with a link'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.

Definition at line 51 of file package_finder.py.

) -> bool:
    """
    Return whether the given Python version is compatible with a link'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.
    """
    try:
        is_compatible = check_requires_python(
            link.requires_python,
            version_info=version_info,
        )
    except specifiers.InvalidSpecifier:
        logger.debug(
            "Ignoring invalid Requires-Python (%r) for link: %s",
            link.requires_python,
            link,
        )
    else:
        if not is_compatible:
            version = ".".join(map(str, version_info))
            if not ignore_requires_python:
                logger.verbose(
                    "Link requires a different Python (%s not in: %r): %s",
                    version,
                    link.requires_python,
                    link,
                )
                return False
 
            logger.debug(
                "Ignoring failed Requires-Python check (%s not in: %r) for link: %s",
                version,
                link.requires_python,
                link,
            )
 
    return True
 
 

References i.

Referenced by LinkEvaluator.evaluate_link().

Here is the caller graph for this function:

_extract_version_from_fragment()

Optional[str] _extract_version_from_fragment ( str  fragment, str  canonical_name  )

protected

Parse the version string from a <package>+<version> filename
"fragment" (stem) or egg fragment.

:param fragment: The string to parse. E.g. foo-2.1
:param canonical_name: The canonicalized name of the package this
    belongs to.

Definition at line 1014 of file package_finder.py.

def _extract_version_from_fragment(fragment: str, canonical_name: str) -> Optional[str]:
    """Parse the version string from a <package>+<version> filename
    "fragment" (stem) or egg fragment.
 
    :param fragment: The string to parse. E.g. foo-2.1
    :param canonical_name: The canonicalized name of the package this
        belongs to.
    """
    try:
        version_start = _find_name_version_sep(fragment, canonical_name) + 1
    except ValueError:
        return None
    version = fragment[version_start:]
    if not version:
        return None
    return version

References pip._internal.index.package_finder._find_name_version_sep().

Referenced by LinkEvaluator.evaluate_link().

Here is the call graph for this function:

Here is the caller graph for this function:

_find_name_version_sep()

int _find_name_version_sep ( str  fragment, str  canonical_name  )

protected

Find the separator's index based on the package's canonical name.

:param fragment: A <package>+<version> filename "fragment" (stem) or
    egg fragment.
:param canonical_name: The package's canonical name.

This function is needed since the canonicalized name does not necessarily
have the same length as the egg info's name part. An example::

>>> fragment = 'foo__bar-1.0'
>>> canonical_name = 'foo-bar'
>>> _find_name_version_sep(fragment, canonical_name)
8

Definition at line 988 of file package_finder.py.

def _find_name_version_sep(fragment: str, canonical_name: str) -> int:
    """Find the separator's index based on the package's canonical name.
 
    :param fragment: A <package>+<version> filename "fragment" (stem) or
        egg fragment.
    :param canonical_name: The package's canonical name.
 
    This function is needed since the canonicalized name does not necessarily
    have the same length as the egg info's name part. An example::
 
    >>> fragment = 'foo__bar-1.0'
    >>> canonical_name = 'foo-bar'
    >>> _find_name_version_sep(fragment, canonical_name)
    8
    """
    # Project name and version must be separated by one single dash. Find all
    # occurrences of dashes; if the string in front of it matches the canonical
    # name, this is the one separating the name and version parts.
    for i, c in enumerate(fragment):
        if c != "-":
            continue
        if canonicalize_name(fragment[:i]) == canonical_name:
            return i
    raise ValueError(f"{fragment} does not match {canonical_name}")
 
 

References i.

Referenced by pip._internal.index.package_finder._extract_version_from_fragment().

Here is the caller graph for this function:

filter_unallowed_hashes()

List[InstallationCandidate] filter_unallowed_hashes	(	List[InstallationCandidate]	candidates,
		Optional[Hashes]	hashes,
		str	project_name
	)

Filter out candidates whose hashes aren't allowed, and return a new
list of candidates.

If at least one candidate has an allowed hash, then all candidates with
either an allowed hash or no hash specified are returned.  Otherwise,
the given candidates are returned.

Including the candidates with no hash specified when there is a match
allows a warning to be logged if there is a more preferred candidate
with no hash specified.  Returning all candidates in the case of no
matches lets pip report the hash of the candidate that would otherwise
have been installed (e.g. permitting the user to more easily update
their requirements file with the desired hash).

Definition at line 252 of file package_finder.py.

) -> List[InstallationCandidate]:
    """
    Filter out candidates whose hashes aren't allowed, and return a new
    list of candidates.
 
    If at least one candidate has an allowed hash, then all candidates with
    either an allowed hash or no hash specified are returned.  Otherwise,
    the given candidates are returned.
 
    Including the candidates with no hash specified when there is a match
    allows a warning to be logged if there is a more preferred candidate
    with no hash specified.  Returning all candidates in the case of no
    matches lets pip report the hash of the candidate that would otherwise
    have been installed (e.g. permitting the user to more easily update
    their requirements file with the desired hash).
    """
    if not hashes:
        logger.debug(
            "Given no hashes to check %s links for project %r: "
            "discarding no candidates",
            len(candidates),
            project_name,
        )
        # Make sure we're not returning back the given value.
        return list(candidates)
 
    matches_or_no_digest = []
    # Collect the non-matches for logging purposes.
    non_matches = []
    match_count = 0
    for candidate in candidates:
        link = candidate.link
        if not link.has_hash:
            pass
        elif link.is_hash_allowed(hashes=hashes):
            match_count += 1
        else:
            non_matches.append(candidate)
            continue
 
        matches_or_no_digest.append(candidate)
 
    if match_count:
        filtered = matches_or_no_digest
    else:
        # Make sure we're not returning back the given value.
        filtered = list(candidates)
 
    if len(filtered) == len(candidates):
        discard_message = "discarding no candidates"
    else:
        discard_message = "discarding {} non-matches:\n  {}".format(
            len(non_matches),
            "\n  ".join(str(candidate.link) for candidate in non_matches),
        )
 
    logger.debug(
        "Checked %s links for project %r against %s hashes "
        "(%s matches, %s no digest): %s",
        len(candidates),
        project_name,
        hashes.digest_count,
        match_count,
        len(matches_or_no_digest) - match_count,
        discard_message,
    )
 
    return filtered
 
 

References i.

Referenced by CandidateEvaluator.get_applicable_candidates().

Here is the caller graph for this function:

Variable Documentation

BuildTag

BuildTag = Union[Tuple[()], Tuple[int, str]]

Definition at line 47 of file package_finder.py.

CandidateSortingKey

CandidateSortingKey = Tuple[int, int, int, _BaseVersion, Optional[int], BuildTag]

Definition at line 48 of file package_finder.py.

logger

logger = getLogger(__name__)

Definition at line 45 of file package_finder.py.