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

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.

pip/_internal/models/wheel.py

@@ -2,97 +2,38 @@
 name that have meaning.
 """
 
-import re
-from typing import Dict, Iterable, List, Optional
+from __future__ import annotations
+
+from collections.abc import Iterable
 
 from pip._vendor.packaging.tags import Tag
-from pip._vendor.packaging.utils import BuildTag, parse_wheel_filename
 from pip._vendor.packaging.utils import (
     InvalidWheelFilename as _PackagingInvalidWheelFilename,
 )
+from pip._vendor.packaging.utils import parse_wheel_filename
 
 from pip._internal.exceptions import InvalidWheelFilename
-from pip._internal.utils.deprecation import deprecated
 
 
 class Wheel:
     """A wheel file"""
 
-    legacy_wheel_file_re = re.compile(
-        r"""^(?P<namever>(?P<name>[^\s-]+?)-(?P<ver>[^\s-]*?))
-        ((-(?P<build>\d[^-]*?))?-(?P<pyver>[^\s-]+?)-(?P<abi>[^\s-]+?)-(?P<plat>[^\s-]+?)
-        \.whl|\.dist-info)$""",
-        re.VERBOSE,
-    )
-
     def __init__(self, filename: str) -> None:
         self.filename = filename
 
-        # To make mypy happy specify type hints that can come from either
-        # parse_wheel_filename or the legacy_wheel_file_re match.
-        self.name: str
-        self._build_tag: Optional[BuildTag] = None
-
         try:
             wheel_info = parse_wheel_filename(filename)
-            self.name, _version, self._build_tag, self.file_tags = wheel_info
-            self.version = str(_version)
         except _PackagingInvalidWheelFilename as e:
-            # Check if the wheel filename is in the legacy format
-            legacy_wheel_info = self.legacy_wheel_file_re.match(filename)
-            if not legacy_wheel_info:
-                raise InvalidWheelFilename(e.args[0]) from None
-
-            deprecated(
-                reason=(
-                    f"Wheel filename {filename!r} is not correctly normalised. "
-                    "Future versions of pip will raise the following error:\n"
-                    f"{e.args[0]}\n\n"
-                ),
-                replacement=(
-                    "to rename the wheel to use a correctly normalised "
-                    "name (this may require updating the version in "
-                    "the project metadata)"
-                ),
-                gone_in="25.3",
-                issue=12938,
-            )
-
-            self.name = legacy_wheel_info.group("name").replace("_", "-")
-            self.version = legacy_wheel_info.group("ver").replace("_", "-")
-
-            # Generate the file tags from the legacy wheel filename
-            pyversions = legacy_wheel_info.group("pyver").split(".")
-            abis = legacy_wheel_info.group("abi").split(".")
-            plats = legacy_wheel_info.group("plat").split(".")
-            self.file_tags = frozenset(
-                Tag(interpreter=py, abi=abi, platform=plat)
-                for py in pyversions
-                for abi in abis
-                for plat in plats
-            )
-
-    @property
-    def build_tag(self) -> BuildTag:
-        if self._build_tag is not None:
-            return self._build_tag
-
-        # Parse the build tag from the legacy wheel filename
-        legacy_wheel_info = self.legacy_wheel_file_re.match(self.filename)
-        assert legacy_wheel_info is not None, "guaranteed by filename validation"
-        build_tag = legacy_wheel_info.group("build")
-        match = re.match(r"^(\d+)(.*)$", build_tag)
-        assert match is not None, "guaranteed by filename validation"
-        build_tag_groups = match.groups()
-        self._build_tag = (int(build_tag_groups[0]), build_tag_groups[1])
-
-        return self._build_tag
-
-    def get_formatted_file_tags(self) -> List[str]:
+            raise InvalidWheelFilename(e.args[0]) from None
+
+        self.name, _version, self.build_tag, self.file_tags = wheel_info
+        self.version = str(_version)
+
+    def get_formatted_file_tags(self) -> list[str]:
         """Return the wheel's tags as a sorted list of strings."""
         return sorted(str(tag) for tag in self.file_tags)
 
-    def support_index_min(self, tags: List[Tag]) -> int:
+    def support_index_min(self, tags: list[Tag]) -> int:
         """Return the lowest index that one of the wheel's file_tag combinations
         achieves in the given list of supported tags.
 
@@ -111,7 +52,7 @@ class Wheel:
             raise ValueError()
 
     def find_most_preferred_tag(
-        self, tags: List[Tag], tag_to_priority: Dict[Tag, int]
+        self, tags: list[Tag], tag_to_priority: dict[Tag, int]
     ) -> int:
         """Return the priority of the most preferred tag that one of the wheel's file
         tag combinations achieves in the given list of supported tags using the given

pip/_internal/network/auth.py

@@ -4,6 +4,8 @@ Contains interface (MultiDomainBasicAuth) and associated glue code for
 providing credentials in the context of network requests.
 """
 
+from __future__ import annotations
+
 import logging
 import os
 import shutil
@@ -12,10 +14,10 @@ import sysconfig
 import typing
 import urllib.parse
 from abc import ABC, abstractmethod
-from functools import lru_cache
+from functools import cache
 from os.path import commonprefix
 from pathlib import Path
-from typing import Any, Dict, List, NamedTuple, Optional, Tuple
+from typing import Any, NamedTuple
 
 from pip._vendor.requests.auth import AuthBase, HTTPBasicAuth
 from pip._vendor.requests.models import Request, Response
@@ -48,9 +50,7 @@ class KeyRingBaseProvider(ABC):
     has_keyring: bool
 
     @abstractmethod
-    def get_auth_info(
-        self, url: str, username: Optional[str]
-    ) -> Optional[AuthInfo]: ...
+    def get_auth_info(self, url: str, username: str | None) -> AuthInfo | None: ...
 
     @abstractmethod
     def save_auth_info(self, url: str, username: str, password: str) -> None: ...
@@ -61,7 +61,7 @@ class KeyRingNullProvider(KeyRingBaseProvider):
 
     has_keyring = False
 
-    def get_auth_info(self, url: str, username: Optional[str]) -> Optional[AuthInfo]:
+    def get_auth_info(self, url: str, username: str | None) -> AuthInfo | None:
         return None
 
     def save_auth_info(self, url: str, username: str, password: str) -> None:
@@ -78,7 +78,7 @@ class KeyRingPythonProvider(KeyRingBaseProvider):
 
         self.keyring = keyring
 
-    def get_auth_info(self, url: str, username: Optional[str]) -> Optional[AuthInfo]:
+    def get_auth_info(self, url: str, username: str | None) -> AuthInfo | None:
         # Support keyring's get_credential interface which supports getting
         # credentials without a username. This is only available for
         # keyring>=15.2.0.
@@ -114,7 +114,7 @@ class KeyRingCliProvider(KeyRingBaseProvider):
     def __init__(self, cmd: str) -> None:
         self.keyring = cmd
 
-    def get_auth_info(self, url: str, username: Optional[str]) -> Optional[AuthInfo]:
+    def get_auth_info(self, url: str, username: str | None) -> AuthInfo | None:
         # This is the default implementation of keyring.get_credential
         # https://github.com/jaraco/keyring/blob/97689324abcf01bd1793d49063e7ca01e03d7d07/keyring/backend.py#L134-L139
         if username is not None:
@@ -126,7 +126,7 @@ class KeyRingCliProvider(KeyRingBaseProvider):
     def save_auth_info(self, url: str, username: str, password: str) -> None:
         return self._set_password(url, username, password)
 
-    def _get_password(self, service_name: str, username: str) -> Optional[str]:
+    def _get_password(self, service_name: str, username: str) -> str | None:
         """Mirror the implementation of keyring.get_password using cli"""
         if self.keyring is None:
             return None
@@ -159,7 +159,7 @@ class KeyRingCliProvider(KeyRingBaseProvider):
         return None
 
 
-@lru_cache(maxsize=None)
+@cache
 def get_keyring_provider(provider: str) -> KeyRingBaseProvider:
     logger.verbose("Keyring provider requested: %s", provider)
 
@@ -225,19 +225,19 @@ class MultiDomainBasicAuth(AuthBase):
     def __init__(
         self,
         prompting: bool = True,
-        index_urls: Optional[List[str]] = None,
+        index_urls: list[str] | None = None,
         keyring_provider: str = "auto",
     ) -> None:
         self.prompting = prompting
         self.index_urls = index_urls
-        self.keyring_provider = keyring_provider  # type: ignore[assignment]
-        self.passwords: Dict[str, AuthInfo] = {}
+        self.keyring_provider = keyring_provider
+        self.passwords: dict[str, AuthInfo] = {}
         # When the user is prompted to enter credentials and keyring is
         # available, we will offer to save them. If the user accepts,
         # this value is set to the credentials they entered. After the
         # request authenticates, the caller should call
         # ``save_credentials`` to save these.
-        self._credentials_to_save: Optional[Credentials] = None
+        self._credentials_to_save: Credentials | None = None
 
     @property
     def keyring_provider(self) -> KeyRingBaseProvider:
@@ -260,9 +260,9 @@ class MultiDomainBasicAuth(AuthBase):
 
     def _get_keyring_auth(
         self,
-        url: Optional[str],
-        username: Optional[str],
-    ) -> Optional[AuthInfo]:
+        url: str | None,
+        username: str | None,
+    ) -> AuthInfo | None:
         """Return the tuple auth for a given url from keyring."""
         # Do nothing if no url was provided
         if not url:
@@ -284,7 +284,7 @@ class MultiDomainBasicAuth(AuthBase):
             get_keyring_provider.cache_clear()
             return None
 
-    def _get_index_url(self, url: str) -> Optional[str]:
+    def _get_index_url(self, url: str) -> str | None:
         """Return the original index URL matching the requested URL.
 
         Cached or dynamically generated credentials may work against
@@ -391,7 +391,7 @@ class MultiDomainBasicAuth(AuthBase):
 
     def _get_url_and_credentials(
         self, original_url: str
-    ) -> Tuple[str, Optional[str], Optional[str]]:
+    ) -> tuple[str, str | None, str | None]:
         """Return the credentials to use for the provided URL.
 
         If allowed, netrc and keyring may be used to obtain the
@@ -454,9 +454,7 @@ class MultiDomainBasicAuth(AuthBase):
         return req
 
     # Factored out to allow for easy patching in tests
-    def _prompt_for_password(
-        self, netloc: str
-    ) -> Tuple[Optional[str], Optional[str], bool]:
+    def _prompt_for_password(self, netloc: str) -> tuple[str | None, str | None, bool]:
         username = ask_input(f"User for {netloc}: ") if self.prompting else None
         if not username:
             return None, None, False

pip/_internal/network/cache.py

@@ -1,15 +1,23 @@
 """HTTP cache implementation."""
 
+from __future__ import annotations
+
 import os
+import shutil
+from collections.abc import Generator
 from contextlib import contextmanager
 from datetime import datetime
-from typing import BinaryIO, Generator, Optional, Union
+from typing import Any, BinaryIO, Callable
 
 from pip._vendor.cachecontrol.cache import SeparateBodyBaseCache
 from pip._vendor.cachecontrol.caches import SeparateBodyFileCache
 from pip._vendor.requests.models import Response
 
-from pip._internal.utils.filesystem import adjacent_tmp_file, replace
+from pip._internal.utils.filesystem import (
+    adjacent_tmp_file,
+    copy_directory_permissions,
+    replace,
+)
 from pip._internal.utils.misc import ensure_dir
 
 
@@ -59,7 +67,7 @@ class SafeFileCache(SeparateBodyBaseCache):
         parts = list(hashed[:5]) + [hashed]
         return os.path.join(self.directory, *parts)
 
-    def get(self, key: str) -> Optional[bytes]:
+    def get(self, key: str) -> bytes | None:
         # The cache entry is only valid if both metadata and body exist.
         metadata_path = self._get_cache_path(key)
         body_path = metadata_path + ".body"
@@ -69,29 +77,27 @@ class SafeFileCache(SeparateBodyBaseCache):
             with open(metadata_path, "rb") as f:
                 return f.read()
 
-    def _write(self, path: str, data: bytes) -> None:
+    def _write_to_file(self, path: str, writer_func: Callable[[BinaryIO], Any]) -> None:
+        """Common file writing logic with proper permissions and atomic replacement."""
         with suppressed_cache_errors():
             ensure_dir(os.path.dirname(path))
 
             with adjacent_tmp_file(path) as f:
-                f.write(data)
+                writer_func(f)
                 # Inherit the read/write permissions of the cache directory
                 # to enable multi-user cache use-cases.
-                mode = (
-                    os.stat(self.directory).st_mode
-                    & 0o666  # select read/write permissions of cache directory
-                    | 0o600  # set owner read/write permissions
-                )
-                # Change permissions only if there is no risk of following a symlink.
-                if os.chmod in os.supports_fd:
-                    os.chmod(f.fileno(), mode)
-                elif os.chmod in os.supports_follow_symlinks:
-                    os.chmod(f.name, mode, follow_symlinks=False)
+                copy_directory_permissions(self.directory, f)
 
             replace(f.name, path)
 
+    def _write(self, path: str, data: bytes) -> None:
+        self._write_to_file(path, lambda f: f.write(data))
+
+    def _write_from_io(self, path: str, source_file: BinaryIO) -> None:
+        self._write_to_file(path, lambda f: shutil.copyfileobj(source_file, f))
+
     def set(
-        self, key: str, value: bytes, expires: Union[int, datetime, None] = None
+        self, key: str, value: bytes, expires: int | datetime | None = None
     ) -> None:
         path = self._get_cache_path(key)
         self._write(path, value)
@@ -103,7 +109,7 @@ class SafeFileCache(SeparateBodyBaseCache):
         with suppressed_cache_errors():
             os.remove(path + ".body")
 
-    def get_body(self, key: str) -> Optional[BinaryIO]:
+    def get_body(self, key: str) -> BinaryIO | None:
         # The cache entry is only valid if both metadata and body exist.
         metadata_path = self._get_cache_path(key)
         body_path = metadata_path + ".body"
@@ -115,3 +121,8 @@ class SafeFileCache(SeparateBodyBaseCache):
     def set_body(self, key: str, body: bytes) -> None:
         path = self._get_cache_path(key) + ".body"
         self._write(path, body)
+
+    def set_body_from_io(self, key: str, body_file: BinaryIO) -> None:
+        """Set the body of the cache entry from a file object."""
+        path = self._get_cache_path(key) + ".body"
+        self._write_from_io(path, body_file)