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

pip/_internal/resolution/resolvelib/resolver.py

@@ -1,8 +1,10 @@
+from __future__ import annotations
+
 import contextlib
 import functools
 import logging
 import os
-from typing import TYPE_CHECKING, Dict, List, Optional, Set, Tuple, cast
+from typing import TYPE_CHECKING, cast
 
 from pip._vendor.packaging.utils import canonicalize_name
 from pip._vendor.resolvelib import BaseReporter, ResolutionImpossible, ResolutionTooDeep
@@ -43,7 +45,7 @@ class Resolver(BaseResolver):
         self,
         preparer: RequirementPreparer,
         finder: PackageFinder,
-        wheel_cache: Optional[WheelCache],
+        wheel_cache: WheelCache | None,
         make_install_req: InstallRequirementProvider,
         use_user_site: bool,
         ignore_dependencies: bool,
@@ -51,7 +53,7 @@ class Resolver(BaseResolver):
         ignore_requires_python: bool,
         force_reinstall: bool,
         upgrade_strategy: str,
-        py_version_info: Optional[Tuple[int, ...]] = None,
+        py_version_info: tuple[int, ...] | None = None,
     ):
         super().__init__()
         assert upgrade_strategy in self._allowed_strategies
@@ -69,10 +71,10 @@ class Resolver(BaseResolver):
         )
         self.ignore_dependencies = ignore_dependencies
         self.upgrade_strategy = upgrade_strategy
-        self._result: Optional[Result] = None
+        self._result: Result | None = None
 
     def resolve(
-        self, root_reqs: List[InstallRequirement], check_supported_wheels: bool
+        self, root_reqs: list[InstallRequirement], check_supported_wheels: bool
     ) -> RequirementSet:
         collected = self.factory.collect_root_requirements(root_reqs)
         provider = PipProvider(
@@ -85,7 +87,8 @@ class Resolver(BaseResolver):
         if "PIP_RESOLVER_DEBUG" in os.environ:
             reporter: BaseReporter[Requirement, Candidate, str] = PipDebuggingReporter()
         else:
-            reporter = PipReporter()
+            reporter = PipReporter(constraints=provider.constraints)
+
         resolver: RLResolver[Requirement, Candidate, str] = RLResolver(
             provider,
             reporter,
@@ -178,16 +181,11 @@ class Resolver(BaseResolver):
 
             req_set.add_named_requirement(ireq)
 
-        reqs = req_set.all_requirements
-        self.factory.preparer.prepare_linked_requirements_more(reqs)
-        for req in reqs:
-            req.prepared = True
-            req.needs_more_preparation = False
         return req_set
 
     def get_installation_order(
         self, req_set: RequirementSet
-    ) -> List[InstallRequirement]:
+    ) -> list[InstallRequirement]:
         """Get order for installation of requirements in RequirementSet.
 
         The returned list contains a requirement before another that depends on
@@ -218,8 +216,8 @@ class Resolver(BaseResolver):
 
 
 def get_topological_weights(
-    graph: "DirectedGraph[Optional[str]]", requirement_keys: Set[str]
-) -> Dict[Optional[str], int]:
+    graph: DirectedGraph[str | None], requirement_keys: set[str]
+) -> dict[str | None, int]:
     """Assign weights to each node based on how "deep" they are.
 
     This implementation may change at any point in the future without prior
@@ -245,14 +243,25 @@ def get_topological_weights(
     We are only interested in the weights of packages that are in the
     requirement_keys.
     """
-    path: Set[Optional[str]] = set()
-    weights: Dict[Optional[str], int] = {}
+    path: set[str | None] = set()
+    weights: dict[str | None, list[int]] = {}
 
-    def visit(node: Optional[str]) -> None:
+    def visit(node: str | None) -> None:
         if node in path:
             # We hit a cycle, so we'll break it here.
             return
 
+        # The walk is exponential and for pathologically connected graphs (which
+        # are the ones most likely to contain cycles in the first place) it can
+        # take until the heat-death of the universe. To counter this we limit
+        # the number of attempts to visit (i.e. traverse through) any given
+        # node. We choose a value here which gives decent enough coverage for
+        # fairly well behaved graphs, and still limits the walk complexity to be
+        # linear in nature.
+        cur_weights = weights.get(node, [])
+        if len(cur_weights) >= 5:
+            return
+
         # Time to visit the children!
         path.add(node)
         for child in graph.iter_children(node):
@@ -262,14 +271,14 @@ def get_topological_weights(
         if node not in requirement_keys:
             return
 
-        last_known_parent_count = weights.get(node, 0)
-        weights[node] = max(last_known_parent_count, len(path))
+        cur_weights.append(len(path))
+        weights[node] = cur_weights
 
-    # Simplify the graph, pruning leaves that have no dependencies.
-    # This is needed for large graphs (say over 200 packages) because the
-    # `visit` function is exponentially slower then, taking minutes.
+    # Simplify the graph, pruning leaves that have no dependencies. This is
+    # needed for large graphs (say over 200 packages) because the `visit`
+    # function is slower for large/densely connected graphs, taking minutes.
     # See https://github.com/pypa/pip/issues/10557
-    # We will loop until we explicitly break the loop.
+    # We repeat the pruning step until we have no more leaves to remove.
     while True:
         leaves = set()
         for key in graph:
@@ -289,12 +298,13 @@ def get_topological_weights(
         for leaf in leaves:
             if leaf not in requirement_keys:
                 continue
-            weights[leaf] = weight
+            weights[leaf] = [weight]
         # Remove the leaves from the graph, making it simpler.
         for leaf in leaves:
             graph.remove(leaf)
 
-    # Visit the remaining graph.
+    # Visit the remaining graph, this will only have nodes to handle if the
+    # graph had a cycle in it, which the pruning step above could not handle.
     # `None` is guaranteed to be the root node by resolvelib.
     visit(None)
 
@@ -303,13 +313,15 @@ def get_topological_weights(
     difference = set(weights.keys()).difference(requirement_keys)
     assert not difference, difference
 
-    return weights
+    # Now give back all the weights, choosing the largest ones from what we
+    # accumulated.
+    return {node: max(wgts) for (node, wgts) in weights.items()}
 
 
 def _req_set_item_sorter(
-    item: Tuple[str, InstallRequirement],
-    weights: Dict[Optional[str], int],
-) -> Tuple[int, str]:
+    item: tuple[str, InstallRequirement],
+    weights: dict[str | None, int],
+) -> tuple[int, str]:
     """Key function used to sort install requirements for installation.
 
     Based on the "weight" mapping calculated in ``get_installation_order()``.

pip/_internal/self_outdated_check.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import datetime
 import functools
 import hashlib
@@ -7,7 +9,7 @@ import optparse
 import os.path
 import sys
 from dataclasses import dataclass
-from typing import Any, Callable, Dict, Optional
+from typing import Any, Callable
 
 from pip._vendor.packaging.version import Version
 from pip._vendor.packaging.version import parse as parse_version
@@ -25,7 +27,12 @@ from pip._internal.utils.entrypoints import (
     get_best_invocation_for_this_pip,
     get_best_invocation_for_this_python,
 )
-from pip._internal.utils.filesystem import adjacent_tmp_file, check_path_owner, replace
+from pip._internal.utils.filesystem import (
+    adjacent_tmp_file,
+    check_path_owner,
+    copy_directory_permissions,
+    replace,
+)
 from pip._internal.utils.misc import (
     ExternallyManagedEnvironment,
     check_externally_managed,
@@ -54,7 +61,7 @@ def _convert_date(isodate: str) -> datetime.datetime:
 
 class SelfCheckState:
     def __init__(self, cache_dir: str) -> None:
-        self._state: Dict[str, Any] = {}
+        self._state: dict[str, Any] = {}
         self._statefile_path = None
 
         # Try to load the existing state
@@ -74,7 +81,7 @@ class SelfCheckState:
     def key(self) -> str:
         return sys.prefix
 
-    def get(self, current_time: datetime.datetime) -> Optional[str]:
+    def get(self, current_time: datetime.datetime) -> str | None:
         """Check if we have a not-outdated version loaded already."""
         if not self._state:
             return None
@@ -98,13 +105,15 @@ class SelfCheckState:
         if not self._statefile_path:
             return
 
+        statefile_directory = os.path.dirname(self._statefile_path)
+
         # Check to make sure that we own the directory
-        if not check_path_owner(os.path.dirname(self._statefile_path)):
+        if not check_path_owner(statefile_directory):
             return
 
         # Now that we've ensured the directory is owned by this user, we'll go
         # ahead and make sure that all our directories are created.
-        ensure_dir(os.path.dirname(self._statefile_path))
+        ensure_dir(statefile_directory)
 
         state = {
             # Include the key so it's easy to tell which pip wrote the
@@ -118,6 +127,7 @@ class SelfCheckState:
 
         with adjacent_tmp_file(self._statefile_path) as f:
             f.write(text.encode())
+            copy_directory_permissions(statefile_directory, f)
 
         try:
             # Since we have a prefix-specific state file, we can just
@@ -165,7 +175,7 @@ def was_installed_by_pip(pkg: str) -> bool:
 
 def _get_current_remote_pip_version(
     session: PipSession, options: optparse.Values
-) -> Optional[str]:
+) -> str | None:
     # Lets use PackageFinder to see what the latest pip version is
     link_collector = LinkCollector.create(
         session,
@@ -196,8 +206,8 @@ def _self_version_check_logic(
     state: SelfCheckState,
     current_time: datetime.datetime,
     local_version: Version,
-    get_remote_version: Callable[[], Optional[str]],
-) -> Optional[UpgradePrompt]:
+    get_remote_version: Callable[[], str | None],
+) -> UpgradePrompt | None:
     remote_version_str = state.get(current_time)
     if remote_version_str is None:
         remote_version_str = get_remote_version()

pip/_internal/utils/appdirs.py

@@ -8,7 +8,6 @@ and eventually drop this after all usages are changed.
 
 import os
 import sys
-from typing import List
 
 from pip._vendor import platformdirs as _appdirs
 
@@ -40,7 +39,7 @@ def user_config_dir(appname: str, roaming: bool = True) -> str:
 
 # for the discussion regarding site_config_dir locations
 # see <https://github.com/pypa/pip/issues/1733>
-def site_config_dirs(appname: str) -> List[str]:
+def site_config_dirs(appname: str) -> list[str]:
     if sys.platform == "darwin":
         dirval = _appdirs.site_data_dir(appname, appauthor=False, multipath=True)
         return dirval.split(os.pathsep)

pip/_internal/utils/compat.py

@@ -7,7 +7,7 @@ import os
 import sys
 from typing import IO
 
-__all__ = ["get_path_uid", "stdlib_pkgs", "WINDOWS"]
+__all__ = ["get_path_uid", "stdlib_pkgs", "tomllib", "WINDOWS"]
 
 
 logger = logging.getLogger(__name__)
@@ -67,6 +67,12 @@ else:
         )
 
 
+if sys.version_info >= (3, 11):
+    import tomllib
+else:
+    from pip._vendor import tomli as tomllib
+
+
 # packages in the stdlib that may have installation metadata, but should not be
 # considered 'installed'.  this theoretically could be determined based on
 # dist.location (py27:`sysconfig.get_paths()['stdlib']`,

pip/_internal/utils/compatibility_tags.py

@@ -1,7 +1,8 @@
 """Generate and work with PEP 425 Compatibility Tags."""
 
+from __future__ import annotations
+
 import re
-from typing import List, Optional, Tuple
 
 from pip._vendor.packaging.tags import (
     PythonVersion,
@@ -19,12 +20,12 @@ from pip._vendor.packaging.tags import (
 _apple_arch_pat = re.compile(r"(.+)_(\d+)_(\d+)_(.+)")
 
 
-def version_info_to_nodot(version_info: Tuple[int, ...]) -> str:
+def version_info_to_nodot(version_info: tuple[int, ...]) -> str:
     # Only use up to the first two numbers.
     return "".join(map(str, version_info[:2]))
 
 
-def _mac_platforms(arch: str) -> List[str]:
+def _mac_platforms(arch: str) -> list[str]:
     match = _apple_arch_pat.match(arch)
     if match:
         name, major, minor, actual_arch = match.groups()
@@ -44,7 +45,7 @@ def _mac_platforms(arch: str) -> List[str]:
     return arches
 
 
-def _ios_platforms(arch: str) -> List[str]:
+def _ios_platforms(arch: str) -> list[str]:
     match = _apple_arch_pat.match(arch)
     if match:
         name, major, minor, actual_multiarch = match.groups()
@@ -64,7 +65,7 @@ def _ios_platforms(arch: str) -> List[str]:
     return arches
 
 
-def _android_platforms(arch: str) -> List[str]:
+def _android_platforms(arch: str) -> list[str]:
     match = re.fullmatch(r"android_(\d+)_(.+)", arch)
     if match:
         api_level, abi = match.groups()
@@ -74,7 +75,7 @@ def _android_platforms(arch: str) -> List[str]:
         return [arch]
 
 
-def _custom_manylinux_platforms(arch: str) -> List[str]:
+def _custom_manylinux_platforms(arch: str) -> list[str]:
     arches = [arch]
     arch_prefix, arch_sep, arch_suffix = arch.partition("_")
     if arch_prefix == "manylinux2014":
@@ -95,7 +96,7 @@ def _custom_manylinux_platforms(arch: str) -> List[str]:
     return arches
 
 
-def _get_custom_platforms(arch: str) -> List[str]:
+def _get_custom_platforms(arch: str) -> list[str]:
     arch_prefix, arch_sep, arch_suffix = arch.partition("_")
     if arch.startswith("macosx"):
         arches = _mac_platforms(arch)
@@ -110,7 +111,7 @@ def _get_custom_platforms(arch: str) -> List[str]:
     return arches
 
 
-def _expand_allowed_platforms(platforms: Optional[List[str]]) -> Optional[List[str]]:
+def _expand_allowed_platforms(platforms: list[str] | None) -> list[str] | None:
     if not platforms:
         return None
 
@@ -135,7 +136,7 @@ def _get_python_version(version: str) -> PythonVersion:
 
 
 def _get_custom_interpreter(
-    implementation: Optional[str] = None, version: Optional[str] = None
+    implementation: str | None = None, version: str | None = None
 ) -> str:
     if implementation is None:
         implementation = interpreter_name()
@@ -145,11 +146,11 @@ def _get_custom_interpreter(
 
 
 def get_supported(
-    version: Optional[str] = None,
-    platforms: Optional[List[str]] = None,
-    impl: Optional[str] = None,
-    abis: Optional[List[str]] = None,
-) -> List[Tag]:
+    version: str | None = None,
+    platforms: list[str] | None = None,
+    impl: str | None = None,
+    abis: list[str] | None = None,
+) -> list[Tag]:
     """Return a list of supported tags for each version specified in
     `versions`.
 
@@ -162,9 +163,9 @@ def get_supported(
     :param abis: specify a list of abis you want valid
         tags for, or None. If None, use the local interpreter abi.
     """
-    supported: List[Tag] = []
+    supported: list[Tag] = []
 
-    python_version: Optional[PythonVersion] = None
+    python_version: PythonVersion | None = None
     if version is not None:
         python_version = _get_python_version(version)
 

pip/_internal/utils/deprecation.py

@@ -2,9 +2,11 @@
 A module that implements tooling to enable easy warnings about deprecations.
 """
 
+from __future__ import annotations
+
 import logging
 import warnings
-from typing import Any, Optional, TextIO, Type, Union
+from typing import Any, TextIO
 
 from pip._vendor.packaging.version import parse
 
@@ -22,12 +24,12 @@ _original_showwarning: Any = None
 
 # Warnings <-> Logging Integration
 def _showwarning(
-    message: Union[Warning, str],
-    category: Type[Warning],
+    message: Warning | str,
+    category: type[Warning],
     filename: str,
     lineno: int,
-    file: Optional[TextIO] = None,
-    line: Optional[str] = None,
+    file: TextIO | None = None,
+    line: str | None = None,
 ) -> None:
     if file is not None:
         if _original_showwarning is not None:
@@ -55,10 +57,10 @@ def install_warning_logger() -> None:
 def deprecated(
     *,
     reason: str,
-    replacement: Optional[str],
-    gone_in: Optional[str],
-    feature_flag: Optional[str] = None,
-    issue: Optional[int] = None,
+    replacement: str | None,
+    gone_in: str | None,
+    feature_flag: str | None = None,
+    issue: int | None = None,
 ) -> None:
     """Helper to deprecate existing functionality.
 

pip/_internal/utils/direct_url_helpers.py

@@ -1,4 +1,4 @@
-from typing import Optional
+from __future__ import annotations
 
 from pip._internal.models.direct_url import ArchiveInfo, DirectUrl, DirInfo, VcsInfo
 from pip._internal.models.link import Link
@@ -37,7 +37,7 @@ def direct_url_for_editable(source_dir: str) -> DirectUrl:
 
 
 def direct_url_from_link(
-    link: Link, source_dir: Optional[str] = None, link_is_in_wheel_cache: bool = False
+    link: Link, source_dir: str | None = None, link_is_in_wheel_cache: bool = False
 ) -> DirectUrl:
     if link.is_vcs:
         vcs_backend = vcs.get_backend_for_scheme(link.scheme)

pip/_internal/utils/egg_link.py

@@ -1,7 +1,8 @@
+from __future__ import annotations
+
 import os
 import re
 import sys
-from typing import List, Optional
 
 from pip._internal.locations import site_packages, user_site
 from pip._internal.utils.virtualenv import (
@@ -15,7 +16,7 @@ __all__ = [
 ]
 
 
-def _egg_link_names(raw_name: str) -> List[str]:
+def _egg_link_names(raw_name: str) -> list[str]:
     """
     Convert a Name metadata value to a .egg-link name, by applying
     the same substitution as pkg_resources's safe_name function.
@@ -30,7 +31,7 @@ def _egg_link_names(raw_name: str) -> List[str]:
     ]
 
 
-def egg_link_path_from_sys_path(raw_name: str) -> Optional[str]:
+def egg_link_path_from_sys_path(raw_name: str) -> str | None:
     """
     Look for a .egg-link file for project name, by walking sys.path.
     """
@@ -43,7 +44,7 @@ def egg_link_path_from_sys_path(raw_name: str) -> Optional[str]:
     return None
 
 
-def egg_link_path_from_location(raw_name: str) -> Optional[str]:
+def egg_link_path_from_location(raw_name: str) -> str | None:
     """
     Return the path for the .egg-link file if it exists, otherwise, None.
 
@@ -61,7 +62,7 @@ def egg_link_path_from_location(raw_name: str) -> Optional[str]:
 
     This method will just return the first one found.
     """
-    sites: List[str] = []
+    sites: list[str] = []
     if running_under_virtualenv():
         sites.append(site_packages)
         if not virtualenv_no_global() and user_site:

pip/_internal/utils/entrypoints.py

@@ -1,8 +1,9 @@
+from __future__ import annotations
+
 import itertools
 import os
 import shutil
 import sys
-from typing import List, Optional
 
 from pip._internal.cli.main import main
 from pip._internal.utils.compat import WINDOWS
@@ -20,7 +21,7 @@ if WINDOWS:
     ]
 
 
-def _wrapper(args: Optional[List[str]] = None) -> int:
+def _wrapper(args: list[str] | None = None) -> int:
     """Central wrapper for all old entrypoints.
 
     Historically pip has had several entrypoints defined. Because of issues

pip/_internal/utils/filesystem.py

@@ -1,11 +1,14 @@
+from __future__ import annotations
+
 import fnmatch
 import os
 import os.path
 import random
 import sys
+from collections.abc import Generator
 from contextlib import contextmanager
 from tempfile import NamedTemporaryFile
-from typing import Any, BinaryIO, Generator, List, Union, cast
+from typing import Any, BinaryIO, cast
 
 from pip._internal.utils.compat import get_path_uid
 from pip._internal.utils.misc import format_size
@@ -115,17 +118,17 @@ def _test_writable_dir_win(path: str) -> bool:
     raise OSError("Unexpected condition testing for writable directory")
 
 
-def find_files(path: str, pattern: str) -> List[str]:
+def find_files(path: str, pattern: str) -> list[str]:
     """Returns a list of absolute paths of files beneath path, recursively,
     with filenames which match the UNIX-style shell glob pattern."""
-    result: List[str] = []
+    result: list[str] = []
     for root, _, files in os.walk(path):
         matches = fnmatch.filter(files, pattern)
         result.extend(os.path.join(root, f) for f in matches)
     return result
 
 
-def file_size(path: str) -> Union[int, float]:
+def file_size(path: str) -> int | float:
     # If it's a symlink, return 0.
     if os.path.islink(path):
         return 0
@@ -136,7 +139,7 @@ def format_file_size(path: str) -> str:
     return format_size(file_size(path))
 
 
-def directory_size(path: str) -> Union[int, float]:
+def directory_size(path: str) -> int | float:
     size = 0.0
     for root, _dirs, files in os.walk(path):
         for filename in files:
@@ -147,3 +150,15 @@ def directory_size(path: str) -> Union[int, float]:
 
 def format_directory_size(path: str) -> str:
     return format_size(directory_size(path))
+
+
+def copy_directory_permissions(directory: str, target_file: BinaryIO) -> None:
+    mode = (
+        os.stat(directory).st_mode & 0o666  # select read/write permissions of 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(target_file.fileno(), mode)
+    elif os.chmod in os.supports_follow_symlinks:
+        os.chmod(target_file.name, mode, follow_symlinks=False)

pip/_internal/utils/filetypes.py

@@ -1,20 +1,18 @@
 """Filetype information."""
 
-from typing import Tuple
-
 from pip._internal.utils.misc import splitext
 
 WHEEL_EXTENSION = ".whl"
-BZ2_EXTENSIONS: Tuple[str, ...] = (".tar.bz2", ".tbz")
-XZ_EXTENSIONS: Tuple[str, ...] = (
+BZ2_EXTENSIONS: tuple[str, ...] = (".tar.bz2", ".tbz")
+XZ_EXTENSIONS: tuple[str, ...] = (
     ".tar.xz",
     ".txz",
     ".tlz",
     ".tar.lz",
     ".tar.lzma",
 )
-ZIP_EXTENSIONS: Tuple[str, ...] = (".zip", WHEEL_EXTENSION)
-TAR_EXTENSIONS: Tuple[str, ...] = (".tar.gz", ".tgz", ".tar")
+ZIP_EXTENSIONS: tuple[str, ...] = (".zip", WHEEL_EXTENSION)
+TAR_EXTENSIONS: tuple[str, ...] = (".tar.gz", ".tgz", ".tar")
 ARCHIVE_EXTENSIONS = ZIP_EXTENSIONS + BZ2_EXTENSIONS + TAR_EXTENSIONS + XZ_EXTENSIONS
 
 

pip/_internal/utils/glibc.py

@@ -1,14 +1,15 @@
+from __future__ import annotations
+
 import os
 import sys
-from typing import Optional, Tuple
 
 
-def glibc_version_string() -> Optional[str]:
+def glibc_version_string() -> str | None:
     "Returns glibc version string, or None if not using glibc."
     return glibc_version_string_confstr() or glibc_version_string_ctypes()
 
 
-def glibc_version_string_confstr() -> Optional[str]:
+def glibc_version_string_confstr() -> str | None:
     "Primary implementation of glibc_version_string using os.confstr."
     # os.confstr is quite a bit faster than ctypes.DLL. It's also less likely
     # to be broken or missing. This strategy is used in the standard library
@@ -28,7 +29,7 @@ def glibc_version_string_confstr() -> Optional[str]:
     return version
 
 
-def glibc_version_string_ctypes() -> Optional[str]:
+def glibc_version_string_ctypes() -> str | None:
     "Fallback implementation of glibc_version_string using ctypes."
 
     try:
@@ -88,7 +89,7 @@ def glibc_version_string_ctypes() -> Optional[str]:
 # versions that was generated by pip 8.1.2 and earlier is useless and
 # misleading. Solution: instead of using platform, use our code that actually
 # works.
-def libc_ver() -> Tuple[str, str]:
+def libc_ver() -> tuple[str, str]:
     """Try to determine the glibc version
 
     Returns a tuple of strings (lib, version) which default to empty strings