pip._internal.models.link Namespace Reference

Data Structures
class	_CleanResult
class	Link
class	LinkHash
class	MetadataFile

Functions
Optional[Dict[str, str]]	supported_hashes (Optional[Dict[str, str]] hashes)
str	_clean_url_path_part (str part)
str	_clean_file_url_path (str part)
str	_clean_url_path (str path, bool is_local_path)
str	_ensure_quoted_url (str url)
_CleanResult	_clean_link (Link link)
bool	links_equivalent (Link link1, Link link2)

Variables
	logger = logging.getLogger(__name__)
tuple	_SUPPORTED_HASHES = ("sha512", "sha384", "sha256", "sha224", "sha1", "md5")
	_reserved_chars_re = re.compile("(@|%2F)", re.IGNORECASE)

Function Documentation

_clean_file_url_path()

str _clean_file_url_path ( str  part )

protected

Clean the first part of a URL path that corresponds to a local
filesystem path (i.e. the first part after splitting on "@" characters).

Definition at line 128 of file link.py.

def _clean_file_url_path(part: str) -> str:
    """
    Clean the first part of a URL path that corresponds to a local
    filesystem path (i.e. the first part after splitting on "@" characters).
    """
    # We unquote prior to quoting to make sure nothing is double quoted.
    # Also, on Windows the path part might contain a drive letter which
    # should not be quoted. On Linux where drive letters do not
    # exist, the colon should be quoted. We rely on urllib.request
    # to do the right thing here.
    return urllib.request.pathname2url(urllib.request.url2pathname(part))
 
 
# percent-encoded:                   /

References i.

_clean_link()

_CleanResult _clean_link ( Link  link )

protected

Definition at line 553 of file link.py.

def _clean_link(link: Link) -> _CleanResult:
    parsed = link._parsed_url
    netloc = parsed.netloc.rsplit("@", 1)[-1]
    # According to RFC 8089, an empty host in file: means localhost.
    if parsed.scheme == "file" and not netloc:
        netloc = "localhost"
    fragment = urllib.parse.parse_qs(parsed.fragment)
    if "egg" in fragment:
        logger.debug("Ignoring egg= fragment in %s", link)
    try:
        # If there are multiple subdirectory values, use the first one.
        # This matches the behavior of Link.subdirectory_fragment.
        subdirectory = fragment["subdirectory"][0]
    except (IndexError, KeyError):
        subdirectory = ""
    # If there are multiple hash values under the same algorithm, use the
    # first one. This matches the behavior of Link.hash_value.
    hashes = {k: fragment[k][0] for k in _SUPPORTED_HASHES if k in fragment}
    return _CleanResult(
        parsed=parsed._replace(netloc=netloc, query="", fragment=""),
        query=urllib.parse.parse_qs(parsed.query),
        subdirectory=subdirectory,
        hashes=hashes,
    )
 
 
@functools.lru_cache(maxsize=None)

References i.

Referenced by pip._internal.models.link.links_equivalent().

Here is the caller graph for this function:

_clean_url_path()

str _clean_url_path ( str  path, bool  is_local_path  )

protected

Clean the path portion of a URL.

Definition at line 145 of file link.py.

def _clean_url_path(path: str, is_local_path: bool) -> str:
    """
    Clean the path portion of a URL.
    """
    if is_local_path:
        clean_func = _clean_file_url_path
    else:
        clean_func = _clean_url_path_part
 
    # Split on the reserved characters prior to cleaning so that
    # revision strings in VCS URLs are properly preserved.
    parts = _reserved_chars_re.split(path)
 
    cleaned_parts = []
    for to_clean, reserved in pairwise(itertools.chain(parts, [""])):
        cleaned_parts.append(clean_func(to_clean))
        # Normalize %xx escapes (e.g. %2f -> %2F)
        cleaned_parts.append(reserved.upper())
 
    return "".join(cleaned_parts)
 
 

References i.

Referenced by pip._internal.models.link._ensure_quoted_url().

Here is the caller graph for this function:

_clean_url_path_part()

str _clean_url_path_part ( str  part )

protected

Clean a "part" of a URL path (i.e. after splitting on "@" characters).

Definition at line 120 of file link.py.

def _clean_url_path_part(part: str) -> str:
    """
    Clean a "part" of a URL path (i.e. after splitting on "@" characters).
    """
    # We unquote prior to quoting to make sure nothing is double quoted.
    return urllib.parse.quote(urllib.parse.unquote(part))
 
 

References i.

_ensure_quoted_url()

str _ensure_quoted_url ( str  url )

protected

Make sure a link is fully quoted.
For example, if ' ' occurs in the URL, it will be replaced with "%20",
and without double-quoting other characters.

Definition at line 167 of file link.py.

def _ensure_quoted_url(url: str) -> str:
    """
    Make sure a link is fully quoted.
    For example, if ' ' occurs in the URL, it will be replaced with "%20",
    and without double-quoting other characters.
    """
    # Split the URL into parts according to the general structure
    # `scheme://netloc/path;parameters?query#fragment`.
    result = urllib.parse.urlparse(url)
    # If the netloc is empty, then the URL refers to a local filesystem path.
    is_local_path = not result.netloc
    path = _clean_url_path(result.path, is_local_path=is_local_path)
    return urllib.parse.urlunparse(result._replace(path=path))
 
 

References pip._internal.models.link._clean_url_path(), and i.

Referenced by Link.from_element(), and Link.from_json().

Here is the call graph for this function:

Here is the caller graph for this function:

links_equivalent()

bool links_equivalent	(	Link	link1,
		Link	link2
	)

Definition at line 580 of file link.py.

def links_equivalent(link1: Link, link2: Link) -> bool:
    return _clean_link(link1) == _clean_link(link2)

References pip._internal.models.link._clean_link().

Here is the call graph for this function:

supported_hashes()

Optional[Dict[str, str]] supported_hashes

(

Optional[Dict[str, str]]

hashes

)

Definition at line 109 of file link.py.

def supported_hashes(hashes: Optional[Dict[str, str]]) -> Optional[Dict[str, str]]:
    # Remove any unsupported hash types from the mapping. If this leaves no
    # supported hashes, return None
    if hashes is None:
        return None
    hashes = {n: v for n, v in hashes.items() if n in _SUPPORTED_HASHES}
    if not hashes:
        return None
    return hashes
 
 

References i.

Referenced by Link.from_element(), and Link.from_json().

Here is the caller graph for this function:

Variable Documentation

_reserved_chars_re

_reserved_chars_re = re.compile("(@|%2F)", re.IGNORECASE)

protected

Definition at line 142 of file link.py.

_SUPPORTED_HASHES

tuple _SUPPORTED_HASHES = ("sha512", "sha384", "sha256", "sha224", "sha1", "md5")

protected

Definition at line 41 of file link.py.

logger

logger = logging.getLogger(__name__)

Definition at line 36 of file link.py.