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

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="25.3",
                 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)

pip/_internal/models/pylock.py

@@ -1,17 +1,22 @@
+from __future__ import annotations
+
 import dataclasses
 import re
+from collections.abc import Iterable
 from dataclasses import dataclass
 from pathlib import Path
-from typing import Any, Dict, Iterable, List, Optional, Tuple
+from typing import TYPE_CHECKING, Any
 
 from pip._vendor import tomli_w
-from pip._vendor.typing_extensions import Self
 
 from pip._internal.models.direct_url import ArchiveInfo, DirInfo, VcsInfo
 from pip._internal.models.link import Link
 from pip._internal.req.req_install import InstallRequirement
 from pip._internal.utils.urls import url_to_path
 
+if TYPE_CHECKING:
+    from typing_extensions import Self
+
 PYLOCK_FILE_NAME_RE = re.compile(r"^pylock\.([^.]+)\.toml$")
 
 
@@ -19,70 +24,70 @@ def is_valid_pylock_file_name(path: Path) -> bool:
     return path.name == "pylock.toml" or bool(re.match(PYLOCK_FILE_NAME_RE, path.name))
 
 
-def _toml_dict_factory(data: List[Tuple[str, Any]]) -> Dict[str, Any]:
+def _toml_dict_factory(data: list[tuple[str, Any]]) -> dict[str, Any]:
     return {key.replace("_", "-"): value for key, value in data if value is not None}
 
 
 @dataclass
 class PackageVcs:
     type: str
-    url: Optional[str]
+    url: str | None
     # (not supported) path: Optional[str]
-    requested_revision: Optional[str]
+    requested_revision: str | None
     commit_id: str
-    subdirectory: Optional[str]
+    subdirectory: str | None
 
 
 @dataclass
 class PackageDirectory:
     path: str
-    editable: Optional[bool]
-    subdirectory: Optional[str]
+    editable: bool | None
+    subdirectory: str | None
 
 
 @dataclass
 class PackageArchive:
-    url: Optional[str]
+    url: str | None
     # (not supported) path: Optional[str]
     # (not supported) size: Optional[int]
     # (not supported) upload_time: Optional[datetime]
-    hashes: Dict[str, str]
-    subdirectory: Optional[str]
+    hashes: dict[str, str]
+    subdirectory: str | None
 
 
 @dataclass
 class PackageSdist:
     name: str
     # (not supported) upload_time: Optional[datetime]
-    url: Optional[str]
+    url: str | None
     # (not supported) path: Optional[str]
     # (not supported) size: Optional[int]
-    hashes: Dict[str, str]
+    hashes: dict[str, str]
 
 
 @dataclass
 class PackageWheel:
     name: str
     # (not supported) upload_time: Optional[datetime]
-    url: Optional[str]
+    url: str | None
     # (not supported) path: Optional[str]
     # (not supported) size: Optional[int]
-    hashes: Dict[str, str]
+    hashes: dict[str, str]
 
 
 @dataclass
 class Package:
     name: str
-    version: Optional[str] = None
+    version: str | None = None
     # (not supported) marker: Optional[str]
     # (not supported) requires_python: Optional[str]
     # (not supported) dependencies
-    vcs: Optional[PackageVcs] = None
-    directory: Optional[PackageDirectory] = None
-    archive: Optional[PackageArchive] = None
+    vcs: PackageVcs | None = None
+    directory: PackageDirectory | None = None
+    archive: PackageArchive | None = None
     # (not supported) index: Optional[str]
-    sdist: Optional[PackageSdist] = None
-    wheels: Optional[List[PackageWheel]] = None
+    sdist: PackageSdist | None = None
+    wheels: list[PackageWheel] | None = None
     # (not supported) attestation_identities: Optional[List[Dict[str, Any]]]
     # (not supported) tool: Optional[Dict[str, Any]]
 
@@ -162,7 +167,7 @@ class Pylock:
     # (not supported) extras: List[str] = []
     # (not supported) dependency_groups: List[str] = []
     created_by: str = "pip"
-    packages: List[Package] = dataclasses.field(default_factory=list)
+    packages: list[Package] = dataclasses.field(default_factory=list)
     # (not supported) tool: Optional[Dict[str, Any]]
 
     def as_toml(self) -> str:

pip/_internal/models/search_scope.py

@@ -4,7 +4,6 @@ import os
 import posixpath
 import urllib.parse
 from dataclasses import dataclass
-from typing import List
 
 from pip._vendor.packaging.utils import canonicalize_name
 
@@ -23,15 +22,15 @@ class SearchScope:
 
     __slots__ = ["find_links", "index_urls", "no_index"]
 
-    find_links: List[str]
-    index_urls: List[str]
+    find_links: list[str]
+    index_urls: list[str]
     no_index: bool
 
     @classmethod
     def create(
         cls,
-        find_links: List[str],
-        index_urls: List[str],
+        find_links: list[str],
+        index_urls: list[str],
         no_index: bool,
     ) -> "SearchScope":
         """
@@ -42,7 +41,7 @@ class SearchScope:
         # it and if it exists, use the normalized version.
         # This is deliberately conservative - it might be fine just to
         # blindly normalize anything starting with a ~...
-        built_find_links: List[str] = []
+        built_find_links: list[str] = []
         for link in find_links:
             if link.startswith("~"):
                 new_link = normalize_path(link)
@@ -104,7 +103,7 @@ class SearchScope:
             )
         return "\n".join(lines)
 
-    def get_index_urls_locations(self, project_name: str) -> List[str]:
+    def get_index_urls_locations(self, project_name: str) -> list[str]:
         """Returns the locations found via self.index_urls
 
         Checks the url_name on the main (first in the list) index and

pip/_internal/models/selection_prefs.py

@@ -1,4 +1,4 @@
-from typing import Optional
+from __future__ import annotations
 
 from pip._internal.models.format_control import FormatControl
 
@@ -27,9 +27,9 @@ class SelectionPreferences:
         self,
         allow_yanked: bool,
         allow_all_prereleases: bool = False,
-        format_control: Optional[FormatControl] = None,
+        format_control: FormatControl | None = None,
         prefer_binary: bool = False,
-        ignore_requires_python: Optional[bool] = None,
+        ignore_requires_python: bool | None = None,
     ) -> None:
         """Create a SelectionPreferences object.
 

pip/_internal/models/target_python.py

@@ -1,5 +1,6 @@
+from __future__ import annotations
+
 import sys
-from typing import List, Optional, Set, Tuple
 
 from pip._vendor.packaging.tags import Tag
 
@@ -26,10 +27,10 @@ class TargetPython:
 
     def __init__(
         self,
-        platforms: Optional[List[str]] = None,
-        py_version_info: Optional[Tuple[int, ...]] = None,
-        abis: Optional[List[str]] = None,
-        implementation: Optional[str] = None,
+        platforms: list[str] | None = None,
+        py_version_info: tuple[int, ...] | None = None,
+        abis: list[str] | None = None,
+        implementation: str | None = None,
     ) -> None:
         """
         :param platforms: A list of strings or None. If None, searches for
@@ -62,8 +63,8 @@ class TargetPython:
         self.py_version_info = py_version_info
 
         # This is used to cache the return value of get_(un)sorted_tags.
-        self._valid_tags: Optional[List[Tag]] = None
-        self._valid_tags_set: Optional[Set[Tag]] = None
+        self._valid_tags: list[Tag] | None = None
+        self._valid_tags_set: set[Tag] | None = None
 
     def format_given(self) -> str:
         """
@@ -85,7 +86,7 @@ class TargetPython:
             f"{key}={value!r}" for key, value in key_values if value is not None
         )
 
-    def get_sorted_tags(self) -> List[Tag]:
+    def get_sorted_tags(self) -> list[Tag]:
         """
         Return the supported PEP 425 tags to check wheel candidates against.
 
@@ -110,7 +111,7 @@ class TargetPython:
 
         return self._valid_tags
 
-    def get_unsorted_tags(self) -> Set[Tag]:
+    def get_unsorted_tags(self) -> set[Tag]:
         """Exactly the same as get_sorted_tags, but returns a set.
 
         This is important for performance.