pip 25.1.1__py3-none-any.whl → 25.3__py3-none-any.whl

pip/_internal/metadata/importlib/_envs.py

@@ -1,10 +1,13 @@
+from __future__ import annotations
+
 import importlib.metadata
 import logging
 import os
 import pathlib
 import sys
 import zipfile
-from typing import Iterator, List, Optional, Sequence, Set, Tuple
+from collections.abc import Iterator, Sequence
+from typing import Optional
 
 from pip._vendor.packaging.utils import (
     InvalidWheelFilename,
@@ -47,10 +50,10 @@ class _DistributionFinder:
     installations as well. It's useful feature, after all.
     """
 
-    FoundResult = Tuple[importlib.metadata.Distribution, Optional[BasePath]]
+    FoundResult = tuple[importlib.metadata.Distribution, Optional[BasePath]]
 
     def __init__(self) -> None:
-        self._found_names: Set[NormalizedName] = set()
+        self._found_names: set[NormalizedName] = set()
 
     def _find_impl(self, location: str) -> Iterator[FoundResult]:
         """Find distributions in a location."""
@@ -80,7 +83,7 @@ class _DistributionFinder:
         """
         for dist, info_location in self._find_impl(location):
             if info_location is None:
-                installed_location: Optional[BasePath] = None
+                installed_location: BasePath | None = None
             else:
                 installed_location = info_location.parent
             yield Distribution(dist, info_location, installed_location)
@@ -119,7 +122,7 @@ class Environment(BaseEnvironment):
         return cls(sys.path)
 
     @classmethod
-    def from_paths(cls, paths: Optional[List[str]]) -> BaseEnvironment:
+    def from_paths(cls, paths: list[str] | None) -> BaseEnvironment:
         if paths is None:
             return cls(sys.path)
         return cls(paths)
@@ -130,7 +133,7 @@ class Environment(BaseEnvironment):
             yield from finder.find(location)
             yield from finder.find_legacy_editables(location)
 
-    def get_distribution(self, name: str) -> Optional[BaseDistribution]:
+    def get_distribution(self, name: str) -> BaseDistribution | None:
         canonical_name = canonicalize_name(name)
         matches = (
             distribution

pip/_internal/metadata/pkg_resources.py

@@ -1,16 +1,13 @@
+from __future__ import annotations
+
 import email.message
 import email.parser
 import logging
 import os
 import zipfile
+from collections.abc import Collection, Iterable, Iterator, Mapping
 from typing import (
-    Collection,
-    Iterable,
-    Iterator,
-    List,
-    Mapping,
     NamedTuple,
-    Optional,
 )
 
 from pip._vendor import pkg_resources
@@ -73,7 +70,7 @@ class InMemoryMetadata:
     def metadata_isdir(self, name: str) -> bool:
         return False
 
-    def metadata_listdir(self, name: str) -> List[str]:
+    def metadata_listdir(self, name: str) -> list[str]:
         return []
 
     def run_script(self, script_name: str, namespace: str) -> None:
@@ -85,7 +82,7 @@ class Distribution(BaseDistribution):
         self._dist = dist
         # This is populated lazily, to avoid loading metadata for all possible
         # distributions eagerly.
-        self.__extra_mapping: Optional[Mapping[NormalizedName, str]] = None
+        self.__extra_mapping: Mapping[NormalizedName, str] | None = None
 
     @property
     def _extra_mapping(self) -> Mapping[NormalizedName, str]:
@@ -155,11 +152,11 @@ class Distribution(BaseDistribution):
         return cls(dist)
 
     @property
-    def location(self) -> Optional[str]:
+    def location(self) -> str | None:
         return self._dist.location
 
     @property
-    def installed_location(self) -> Optional[str]:
+    def installed_location(self) -> str | None:
         egg_link = egg_link_path_from_location(self.raw_name)
         if egg_link:
             location = egg_link
@@ -170,7 +167,7 @@ class Distribution(BaseDistribution):
         return normalize_path(location)
 
     @property
-    def info_location(self) -> Optional[str]:
+    def info_location(self) -> str | None:
         return self._dist.egg_info
 
     @property
@@ -259,14 +256,14 @@ class Environment(BaseEnvironment):
         return cls(pkg_resources.working_set)
 
     @classmethod
-    def from_paths(cls, paths: Optional[List[str]]) -> BaseEnvironment:
+    def from_paths(cls, paths: list[str] | None) -> BaseEnvironment:
         return cls(pkg_resources.WorkingSet(paths))
 
     def _iter_distributions(self) -> Iterator[BaseDistribution]:
         for dist in self._ws:
             yield Distribution(dist)
 
-    def _search_distribution(self, name: str) -> Optional[BaseDistribution]:
+    def _search_distribution(self, name: str) -> BaseDistribution | None:
         """Find a distribution matching the ``name`` in the environment.
 
         This searches from *all* distributions available in the environment, to
@@ -278,7 +275,7 @@ class Environment(BaseEnvironment):
                 return dist
         return None
 
-    def get_distribution(self, name: str) -> Optional[BaseDistribution]:
+    def get_distribution(self, name: str) -> BaseDistribution | None:
         # Search the distribution by looking through the working set.
         dist = self._search_distribution(name)
         if dist:

pip/_internal/models/direct_url.py

@@ -1,10 +1,13 @@
 """PEP 610"""
 
+from __future__ import annotations
+
 import json
 import re
 import urllib.parse
+from collections.abc import Iterable
 from dataclasses import dataclass
-from typing import Any, ClassVar, Dict, Iterable, Optional, Type, TypeVar, Union
+from typing import Any, ClassVar, TypeVar, Union
 
 __all__ = [
     "DirectUrl",
@@ -25,8 +28,8 @@ class DirectUrlValidationError(Exception):
 
 
 def _get(
-    d: Dict[str, Any], expected_type: Type[T], key: str, default: Optional[T] = None
-) -> Optional[T]:
+    d: dict[str, Any], expected_type: type[T], key: str, default: T | None = None
+) -> T | None:
     """Get value from dictionary and verify expected type."""
     if key not in d:
         return default
@@ -39,7 +42,7 @@ def _get(
 
 
 def _get_required(
-    d: Dict[str, Any], expected_type: Type[T], key: str, default: Optional[T] = None
+    d: dict[str, Any], expected_type: type[T], key: str, default: T | None = None
 ) -> T:
     value = _get(d, expected_type, key, default)
     if value is None:
@@ -47,7 +50,7 @@ def _get_required(
     return value
 
 
-def _exactly_one_of(infos: Iterable[Optional["InfoType"]]) -> "InfoType":
+def _exactly_one_of(infos: Iterable[InfoType | None]) -> InfoType:
     infos = [info for info in infos if info is not None]
     if not infos:
         raise DirectUrlValidationError(
@@ -61,7 +64,7 @@ def _exactly_one_of(infos: Iterable[Optional["InfoType"]]) -> "InfoType":
     return infos[0]
 
 
-def _filter_none(**kwargs: Any) -> Dict[str, Any]:
+def _filter_none(**kwargs: Any) -> dict[str, Any]:
     """Make dict excluding None values."""
     return {k: v for k, v in kwargs.items() if v is not None}
 
@@ -72,10 +75,10 @@ class VcsInfo:
 
     vcs: str
     commit_id: str
-    requested_revision: Optional[str] = None
+    requested_revision: str | None = None
 
     @classmethod
-    def _from_dict(cls, d: Optional[Dict[str, Any]]) -> Optional["VcsInfo"]:
+    def _from_dict(cls, d: dict[str, Any] | None) -> VcsInfo | None:
         if d is None:
             return None
         return cls(
@@ -84,7 +87,7 @@ class VcsInfo:
             requested_revision=_get(d, str, "requested_revision"),
         )
 
-    def _to_dict(self) -> Dict[str, Any]:
+    def _to_dict(self) -> dict[str, Any]:
         return _filter_none(
             vcs=self.vcs,
             requested_revision=self.requested_revision,
@@ -97,19 +100,19 @@ class ArchiveInfo:
 
     def __init__(
         self,
-        hash: Optional[str] = None,
-        hashes: Optional[Dict[str, str]] = None,
+        hash: str | None = None,
+        hashes: dict[str, str] | None = None,
     ) -> None:
         # set hashes before hash, since the hash setter will further populate hashes
         self.hashes = hashes
         self.hash = hash
 
     @property
-    def hash(self) -> Optional[str]:
+    def hash(self) -> str | None:
         return self._hash
 
     @hash.setter
-    def hash(self, value: Optional[str]) -> None:
+    def hash(self, value: str | None) -> None:
         if value is not None:
             # Auto-populate the hashes key to upgrade to the new format automatically.
             # We don't back-populate the legacy hash key from hashes.
@@ -127,12 +130,12 @@ class ArchiveInfo:
         self._hash = value
 
     @classmethod
-    def _from_dict(cls, d: Optional[Dict[str, Any]]) -> Optional["ArchiveInfo"]:
+    def _from_dict(cls, d: dict[str, Any] | None) -> ArchiveInfo | None:
         if d is None:
             return None
         return cls(hash=_get(d, str, "hash"), hashes=_get(d, dict, "hashes"))
 
-    def _to_dict(self) -> Dict[str, Any]:
+    def _to_dict(self) -> dict[str, Any]:
         return _filter_none(hash=self.hash, hashes=self.hashes)
 
 
@@ -143,12 +146,12 @@ class DirInfo:
     editable: bool = False
 
     @classmethod
-    def _from_dict(cls, d: Optional[Dict[str, Any]]) -> Optional["DirInfo"]:
+    def _from_dict(cls, d: dict[str, Any] | None) -> DirInfo | None:
         if d is None:
             return None
         return cls(editable=_get_required(d, bool, "editable", default=False))
 
-    def _to_dict(self) -> Dict[str, Any]:
+    def _to_dict(self) -> dict[str, Any]:
         return _filter_none(editable=self.editable or None)
 
 
@@ -159,7 +162,7 @@ InfoType = Union[ArchiveInfo, DirInfo, VcsInfo]
 class DirectUrl:
     url: str
     info: InfoType
-    subdirectory: Optional[str] = None
+    subdirectory: str | None = None
 
     def _remove_auth_from_netloc(self, netloc: str) -> str:
         if "@" not in netloc:
@@ -192,7 +195,7 @@ class DirectUrl:
         self.from_dict(self.to_dict())
 
     @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> "DirectUrl":
+    def from_dict(cls, d: dict[str, Any]) -> DirectUrl:
         return DirectUrl(
             url=_get_required(d, str, "url"),
             subdirectory=_get(d, str, "subdirectory"),
@@ -205,7 +208,7 @@ class DirectUrl:
             ),
         )
 
-    def to_dict(self) -> Dict[str, Any]:
+    def to_dict(self) -> dict[str, Any]:
         res = _filter_none(
             url=self.redacted_url,
             subdirectory=self.subdirectory,
@@ -214,7 +217,7 @@ class DirectUrl:
         return res
 
     @classmethod
-    def from_json(cls, s: str) -> "DirectUrl":
+    def from_json(cls, s: str) -> DirectUrl:
         return cls.from_dict(json.loads(s))
 
     def to_json(self) -> str:

pip/_internal/models/format_control.py

@@ -1,4 +1,4 @@
-from typing import FrozenSet, Optional, Set
+from __future__ import annotations
 
 from pip._vendor.packaging.utils import canonicalize_name
 
@@ -12,8 +12,8 @@ class FormatControl:
 
     def __init__(
         self,
-        no_binary: Optional[Set[str]] = None,
-        only_binary: Optional[Set[str]] = None,
+        no_binary: set[str] | None = None,
+        only_binary: set[str] | None = None,
     ) -> None:
         if no_binary is None:
             no_binary = set()
@@ -36,7 +36,7 @@ class FormatControl:
         return f"{self.__class__.__name__}({self.no_binary}, {self.only_binary})"
 
     @staticmethod
-    def handle_mutual_excludes(value: str, target: Set[str], other: Set[str]) -> None:
+    def handle_mutual_excludes(value: str, target: set[str], other: set[str]) -> None:
         if value.startswith("-"):
             raise CommandError(
                 "--no-binary / --only-binary option requires 1 argument."
@@ -58,7 +58,7 @@ class FormatControl:
             other.discard(name)
             target.add(name)
 
-    def get_allowed_formats(self, canonical_name: str) -> FrozenSet[str]:
+    def get_allowed_formats(self, canonical_name: str) -> frozenset[str]:
         result = {"binary", "source"}
         if canonical_name in self.only_binary:
             result.discard("source")

pip/_internal/models/installation_report.py

@@ -1,4 +1,5 @@
-from typing import Any, Dict, Sequence
+from collections.abc import Sequence
+from typing import Any
 
 from pip._vendor.packaging.markers import default_environment
 
@@ -11,7 +12,7 @@ class InstallationReport:
         self._install_requirements = install_requirements
 
     @classmethod
-    def _install_req_to_dict(cls, ireq: InstallRequirement) -> Dict[str, Any]:
+    def _install_req_to_dict(cls, ireq: InstallRequirement) -> dict[str, Any]:
         assert ireq.download_info, f"No download_info for {ireq}"
         res = {
             # PEP 610 json for the download URL. download_info.archive_info.hashes may
@@ -39,7 +40,7 @@ class InstallationReport:
             res["requested_extras"] = sorted(ireq.extras)
         return res
 
-    def to_dict(self) -> Dict[str, Any]:
+    def to_dict(self) -> dict[str, Any]:
         return {
             "version": "1",
             "pip_version": __version__,

pip/_internal/models/link.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import functools
 import itertools
 import logging
@@ -5,17 +7,12 @@ import os
 import posixpath
 import re
 import urllib.parse
+from collections.abc import Mapping
 from dataclasses import dataclass
 from typing import (
     TYPE_CHECKING,
     Any,
-    Dict,
-    List,
-    Mapping,
     NamedTuple,
-    Optional,
-    Tuple,
-    Union,
 )
 
 from pip._internal.utils.deprecation import deprecated
@@ -69,8 +66,8 @@ class LinkHash:
         assert self.name in _SUPPORTED_HASHES
 
     @classmethod
-    @functools.lru_cache(maxsize=None)
-    def find_hash_url_fragment(cls, url: str) -> Optional["LinkHash"]:
+    @functools.cache
+    def find_hash_url_fragment(cls, url: str) -> LinkHash | None:
         """Search a string for a checksum algorithm name and encoded output value."""
         match = cls._hash_url_fragment_re.search(url)
         if match is None:
@@ -78,14 +75,14 @@ class LinkHash:
         name, value = match.groups()
         return cls(name=name, value=value)
 
-    def as_dict(self) -> Dict[str, str]:
+    def as_dict(self) -> dict[str, str]:
         return {self.name: self.value}
 
     def as_hashes(self) -> Hashes:
         """Return a Hashes instance which checks only for the current hash."""
         return Hashes({self.name: [self.value]})
 
-    def is_hash_allowed(self, hashes: Optional[Hashes]) -> bool:
+    def is_hash_allowed(self, hashes: Hashes | None) -> bool:
         """
         Return True if the current hash is allowed by `hashes`.
         """
@@ -98,14 +95,14 @@ class LinkHash:
 class MetadataFile:
     """Information about a core metadata file associated with a distribution."""
 
-    hashes: Optional[Dict[str, str]]
+    hashes: dict[str, str] | None
 
     def __post_init__(self) -> None:
         if self.hashes is not None:
             assert all(name in _SUPPORTED_HASHES for name in self.hashes)
 
 
-def supported_hashes(hashes: Optional[Dict[str, str]]) -> Optional[Dict[str, str]]:
+def supported_hashes(hashes: dict[str, str] | None) -> dict[str, str] | None:
     # Remove any unsupported hash types from the mapping. If this leaves no
     # supported hashes, return None
     if hashes is None:
@@ -134,7 +131,11 @@ def _clean_file_url_path(part: str) -> str:
     # 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))
+    ret = urllib.request.pathname2url(urllib.request.url2pathname(part))
+    if ret.startswith("///"):
+        # Remove any URL authority section, leaving only the URL path.
+        ret = ret.removeprefix("//")
+    return ret
 
 
 # percent-encoded:                   /
@@ -175,7 +176,11 @@ def _ensure_quoted_url(url: str) -> str:
     # 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.urlunsplit(result._replace(path=path))
+    # Temporarily replace scheme with file to ensure the URL generated by
+    # urlunsplit() contains an empty netloc (file://) as per RFC 1738.
+    ret = urllib.parse.urlunsplit(result._replace(scheme="file", path=path))
+    ret = result.scheme + ret[4:]  # Restore original scheme.
+    return ret
 
 
 def _absolute_link_url(base_url: str, url: str) -> str:
@@ -209,12 +214,12 @@ class Link:
     def __init__(
         self,
         url: str,
-        comes_from: Optional[Union[str, "IndexContent"]] = None,
-        requires_python: Optional[str] = None,
-        yanked_reason: Optional[str] = None,
-        metadata_file_data: Optional[MetadataFile] = None,
+        comes_from: str | IndexContent | None = None,
+        requires_python: str | None = None,
+        yanked_reason: str | None = None,
+        metadata_file_data: MetadataFile | None = None,
         cache_link_parsing: bool = True,
-        hashes: Optional[Mapping[str, str]] = None,
+        hashes: Mapping[str, str] | None = None,
     ) -> None:
         """
         :param url: url of the resource pointed to (href of the link)
@@ -274,9 +279,9 @@ class Link:
     @classmethod
     def from_json(
         cls,
-        file_data: Dict[str, Any],
+        file_data: dict[str, Any],
         page_url: str,
-    ) -> Optional["Link"]:
+    ) -> Link | None:
         """
         Convert an pypi json document from a simple repository page into a Link.
         """
@@ -325,10 +330,10 @@ class Link:
     @classmethod
     def from_element(
         cls,
-        anchor_attribs: Dict[str, Optional[str]],
+        anchor_attribs: dict[str, str | None],
         page_url: str,
         base_url: str,
-    ) -> Optional["Link"]:
+    ) -> Link | None:
         """
         Convert an anchor element's attributes in a simple repository page to a Link.
         """
@@ -441,7 +446,7 @@ class Link:
     def path(self) -> str:
         return self._path
 
-    def splitext(self) -> Tuple[str, str]:
+    def splitext(self) -> tuple[str, str]:
         return splitext(posixpath.basename(self.path.rstrip("/")))
 
     @property
@@ -460,7 +465,7 @@ class Link:
         r"^([A-Z0-9]|[A-Z0-9][A-Z0-9._-]*[A-Z0-9])$", re.IGNORECASE
     )
 
-    def _egg_fragment(self) -> Optional[str]:
+    def _egg_fragment(self) -> str | None:
         match = self._egg_fragment_re.search(self._url)
         if not match:
             return None
@@ -472,7 +477,7 @@ class Link:
             deprecated(
                 reason=f"{self} contains an egg fragment with a non-PEP 508 name.",
                 replacement="to use the req @ url syntax, and remove the egg fragment",
-                gone_in="25.2",
+                gone_in="26.0",
                 issue=13157,
             )
 
@@ -481,13 +486,13 @@ class Link:
     _subdirectory_fragment_re = re.compile(r"[#&]subdirectory=([^&]*)")
 
     @property
-    def subdirectory_fragment(self) -> Optional[str]:
+    def subdirectory_fragment(self) -> str | None:
         match = self._subdirectory_fragment_re.search(self._url)
         if not match:
             return None
         return match.group(1)
 
-    def metadata_link(self) -> Optional["Link"]:
+    def metadata_link(self) -> Link | None:
         """Return a link to the associated core metadata file (if any)."""
         if self.metadata_file_data is None:
             return None
@@ -500,11 +505,11 @@ class Link:
         return Hashes({k: [v] for k, v in self._hashes.items()})
 
     @property
-    def hash(self) -> Optional[str]:
+    def hash(self) -> str | None:
         return next(iter(self._hashes.values()), None)
 
     @property
-    def hash_name(self) -> Optional[str]:
+    def hash_name(self) -> str | None:
         return next(iter(self._hashes), None)
 
     @property
@@ -536,7 +541,7 @@ class Link:
     def has_hash(self) -> bool:
         return bool(self._hashes)
 
-    def is_hash_allowed(self, hashes: Optional[Hashes]) -> bool:
+    def is_hash_allowed(self, hashes: Hashes | None) -> bool:
         """
         Return True if the link has a hash and it is allowed by `hashes`.
         """
@@ -572,9 +577,9 @@ class _CleanResult(NamedTuple):
     """
 
     parsed: urllib.parse.SplitResult
-    query: Dict[str, List[str]]
+    query: dict[str, list[str]]
     subdirectory: str
-    hashes: Dict[str, str]
+    hashes: dict[str, str]
 
 
 def _clean_link(link: Link) -> _CleanResult:
@@ -603,6 +608,6 @@ def _clean_link(link: Link) -> _CleanResult:
     )
 
 
-@functools.lru_cache(maxsize=None)
+@functools.cache
 def links_equivalent(link1: Link, link2: Link) -> bool:
     return _clean_link(link1) == _clean_link(link2)