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

pip/_internal/resolution/resolvelib/candidates.py

@@ -10,6 +10,7 @@ from pip._vendor.packaging.utils import NormalizedName, canonicalize_name
 from pip._vendor.packaging.version import Version
 
 from pip._internal.exceptions import (
+    FailedToPrepareCandidate,
     HashError,
     InstallationSubprocessError,
     InvalidInstalledPackage,
@@ -68,10 +69,8 @@ def make_install_req_from_link(
         line,
         user_supplied=template.user_supplied,
         comes_from=template.comes_from,
-        use_pep517=template.use_pep517,
         isolated=template.isolated,
         constraint=template.constraint,
-        global_options=template.global_options,
         hash_options=template.hash_options,
         config_settings=template.config_settings,
     )
@@ -85,15 +84,17 @@ def make_install_req_from_editable(
     link: Link, template: InstallRequirement
 ) -> InstallRequirement:
     assert template.editable, "template not editable"
+    if template.name:
+        req_string = f"{template.name} @ {link.url}"
+    else:
+        req_string = link.url
     ireq = install_req_from_editable(
-        link.url,
+        req_string,
         user_supplied=template.user_supplied,
         comes_from=template.comes_from,
-        use_pep517=template.use_pep517,
         isolated=template.isolated,
         constraint=template.constraint,
         permit_editable_wheels=template.permit_editable_wheels,
-        global_options=template.global_options,
         hash_options=template.hash_options,
         config_settings=template.config_settings,
     )
@@ -114,10 +115,8 @@ def _make_install_req_from_dist(
         line,
         user_supplied=template.user_supplied,
         comes_from=template.comes_from,
-        use_pep517=template.use_pep517,
         isolated=template.isolated,
         constraint=template.constraint,
-        global_options=template.global_options,
         hash_options=template.hash_options,
         config_settings=template.config_settings,
     )
@@ -244,9 +243,19 @@ class _InstallRequirementBackedCandidate(Candidate):
             e.req = self._ireq
             raise
         except InstallationSubprocessError as exc:
-            # The output has been presented already, so don't duplicate it.
-            exc.context = "See above for output."
-            raise
+            if isinstance(self._ireq.comes_from, InstallRequirement):
+                request_chain = self._ireq.comes_from.from_path()
+            else:
+                request_chain = self._ireq.comes_from
+
+            if request_chain is None:
+                request_chain = "directly requested"
+
+            raise FailedToPrepareCandidate(
+                package_name=self._ireq.name or str(self._link),
+                requirement_chain=request_chain,
+                failed_step=exc.command_description,
+            )
 
         self._check_metadata_consistency(dist)
         return dist
@@ -283,7 +292,7 @@ class LinkCandidate(_InstallRequirementBackedCandidate):
         assert ireq.link == link
         if ireq.link.is_wheel and not ireq.link.is_file:
             wheel = Wheel(ireq.link.filename)
-            wheel_name = canonicalize_name(wheel.name)
+            wheel_name = wheel.name
             assert name == wheel_name, f"{name!r} != {wheel_name!r} for wheel"
             # Version may not be present for PEP 508 direct URLs
             if version is not None:

pip/_internal/resolution/resolvelib/factory.py

@@ -695,9 +695,20 @@ class Factory:
                 "version: %s",
                 "; ".join(skipped_by_requires_python) or "none",
             )
+
+        # Check if only final releases are allowed for this package
+        version_type = "version"
+        if self._finder.release_control is not None:
+            allows_pre = self._finder.release_control.allows_prereleases(
+                canonicalize_name(req.project_name)
+            )
+            if allows_pre is False:
+                version_type = "final version"
+
         logger.critical(
-            "Could not find a version that satisfies the requirement %s "
+            "Could not find a %s that satisfies the requirement %s "
             "(from versions: %s)",
+            version_type,
             req_disp,
             ", ".join(versions) or "none",
         )
@@ -711,6 +722,21 @@ class Factory:
 
         return DistributionNotFound(f"No matching distribution found for {req}")
 
+    def _has_any_candidates(self, project_name: str) -> bool:
+        """
+        Check if there are any candidates available for the project name.
+        """
+        return any(
+            self.find_candidates(
+                project_name,
+                requirements={project_name: []},
+                incompatibilities={},
+                constraint=Constraint.empty(),
+                prefers_installed=True,
+                is_satisfied_by=lambda r, c: True,
+            )
+        )
+
     def get_installation_error(
         self,
         e: ResolutionImpossible[Requirement, Candidate],
@@ -796,6 +822,22 @@ class Factory:
             spec = constraints[key].specifier
             msg += f"\n    The user requested (constraint) {key}{spec}"
 
+        # Check for causes that had no candidates
+        causes = set()
+        for req, _ in e.causes:
+            causes.add(req.name)
+
+        no_candidates = {c for c in causes if not self._has_any_candidates(c)}
+        if no_candidates:
+            msg = (
+                msg
+                + "\n\n"
+                + "Additionally, some packages in these conflicts have no "
+                + "matching distributions available for your environment:"
+                + "\n    "
+                + "\n    ".join(sorted(no_candidates))
+            )
+
         msg = (
             msg
             + "\n\n"

pip/_internal/resolution/resolvelib/provider.py

@@ -100,6 +100,15 @@ class PipProvider(_ProviderBase):
         self._upgrade_strategy = upgrade_strategy
         self._user_requested = user_requested
 
+    @property
+    def constraints(self) -> dict[str, Constraint]:
+        """Public view of user-specified constraints.
+
+        Exposes the provider's constraints mapping without encouraging
+        external callers to reach into private attributes.
+        """
+        return self._constraints
+
     def identify(self, requirement_or_candidate: Requirement | Candidate) -> str:
         return requirement_or_candidate.name
 

pip/_internal/resolution/resolvelib/reporter.py

@@ -1,19 +1,21 @@
 from __future__ import annotations
 
 from collections import defaultdict
+from collections.abc import Mapping
 from logging import getLogger
 from typing import Any
 
 from pip._vendor.resolvelib.reporters import BaseReporter
 
-from .base import Candidate, Requirement
+from .base import Candidate, Constraint, Requirement
 
 logger = getLogger(__name__)
 
 
 class PipReporter(BaseReporter[Requirement, Candidate, str]):
-    def __init__(self) -> None:
+    def __init__(self, constraints: Mapping[str, Constraint] | None = None) -> None:
         self.reject_count_by_package: defaultdict[str, int] = defaultdict(int)
+        self._constraints = constraints or {}
 
         self._messages_at_reject_count = {
             1: (
@@ -35,25 +37,36 @@ class PipReporter(BaseReporter[Requirement, Candidate, str]):
         }
 
     def rejecting_candidate(self, criterion: Any, candidate: Candidate) -> None:
+        """Report a candidate being rejected.
+
+        Logs both the rejection count message (if applicable) and details about
+        the requirements and constraints that caused the rejection.
+        """
         self.reject_count_by_package[candidate.name] += 1
 
         count = self.reject_count_by_package[candidate.name]
-        if count not in self._messages_at_reject_count:
-            return
-
-        message = self._messages_at_reject_count[count]
-        logger.info("INFO: %s", message.format(package_name=candidate.name))
+        if count in self._messages_at_reject_count:
+            message = self._messages_at_reject_count[count]
+            logger.info("INFO: %s", message.format(package_name=candidate.name))
 
         msg = "Will try a different candidate, due to conflict:"
         for req_info in criterion.information:
             req, parent = req_info.requirement, req_info.parent
-            # Inspired by Factory.get_installation_error
             msg += "\n    "
             if parent:
                 msg += f"{parent.name} {parent.version} depends on "
             else:
                 msg += "The user requested "
             msg += req.format_for_error()
+
+        # Add any relevant constraints
+        if self._constraints:
+            name = candidate.name
+            constraint = self._constraints.get(name)
+            if constraint and constraint.specifier:
+                constraint_text = f"{name}{constraint.specifier}"
+                msg += f"\n    The user requested (constraint) {constraint_text}"
+
         logger.debug(msg)
 
 

pip/_internal/resolution/resolvelib/requirements.py

@@ -164,6 +164,12 @@ class RequiresPythonRequirement(Requirement):
         self._hash: int | None = None
         self._candidate = match
 
+        # Pre-compute candidate lookup to avoid repeated specifier checks
+        if specifier.contains(match.version, prereleases=True):
+            self._candidate_lookup: CandidateLookup = (match, None)
+        else:
+            self._candidate_lookup = (None, None)
+
     def __str__(self) -> str:
         return f"Python {self.specifier}"
 
@@ -197,9 +203,7 @@ class RequiresPythonRequirement(Requirement):
         return str(self)
 
     def get_candidate_lookup(self) -> CandidateLookup:
-        if self.specifier.contains(self._candidate.version, prereleases=True):
-            return self._candidate, None
-        return None, None
+        return self._candidate_lookup
 
     def is_satisfied_by(self, candidate: Candidate) -> bool:
         assert candidate.name == self._candidate.name, "Not Python candidate"

pip/_internal/resolution/resolvelib/resolver.py

@@ -87,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,
@@ -180,11 +181,6 @@ 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(

pip/_internal/self_outdated_check.py

@@ -9,7 +9,7 @@ import optparse
 import os.path
 import sys
 from dataclasses import dataclass
-from typing import Any, Callable
+from typing import Callable
 
 from pip._vendor.packaging.version import Version
 from pip._vendor.packaging.version import parse as parse_version
@@ -20,14 +20,21 @@ from pip._vendor.rich.text import Text
 from pip._internal.index.collector import LinkCollector
 from pip._internal.index.package_finder import PackageFinder
 from pip._internal.metadata import get_default_environment
+from pip._internal.models.release_control import ReleaseControl
 from pip._internal.models.selection_prefs import SelectionPreferences
 from pip._internal.network.session import PipSession
 from pip._internal.utils.compat import WINDOWS
+from pip._internal.utils.datetime import parse_iso_datetime
 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,
@@ -45,18 +52,9 @@ def _get_statefile_name(key: str) -> str:
     return name
 
 
-def _convert_date(isodate: str) -> datetime.datetime:
-    """Convert an ISO format string to a date.
-
-    Handles the format 2020-01-22T14:24:01Z (trailing Z)
-    which is not supported by older versions of fromisoformat.
-    """
-    return datetime.datetime.fromisoformat(isodate.replace("Z", "+00:00"))
-
-
 class SelfCheckState:
     def __init__(self, cache_dir: str) -> None:
-        self._state: dict[str, Any] = {}
+        self._state: dict[str, str] = {}
         self._statefile_path = None
 
         # Try to load the existing state
@@ -88,7 +86,7 @@ class SelfCheckState:
             return None
 
         # Determine if we need to refresh the state
-        last_check = _convert_date(self._state["last_check"])
+        last_check = parse_iso_datetime(self._state["last_check"])
         time_since_last_check = current_time - last_check
         if time_since_last_check > _WEEK:
             return None
@@ -100,13 +98,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
@@ -120,6 +120,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
@@ -179,7 +180,7 @@ def _get_current_remote_pip_version(
     # yanked version.
     selection_prefs = SelectionPreferences(
         allow_yanked=False,
-        allow_all_prereleases=False,  # Explicitly set to False
+        release_control=ReleaseControl(only_final={"pip"}),
     )
 
     finder = PackageFinder.create(

pip/_internal/utils/datetime.py

@@ -1,6 +1,7 @@
 """For when pip wants to check the date or time."""
 
 import datetime
+import sys
 
 
 def today_is_later_than(year: int, month: int, day: int) -> bool:
@@ -8,3 +9,20 @@ def today_is_later_than(year: int, month: int, day: int) -> bool:
     given = datetime.date(year, month, day)
 
     return today > given
+
+
+def parse_iso_datetime(isodate: str) -> datetime.datetime:
+    """Convert an ISO format string to a datetime.
+
+    Handles the format 2020-01-22T14:24:01Z (trailing Z)
+    which is not supported by older versions of fromisoformat.
+    """
+    # Python 3.11+ supports Z suffix natively in fromisoformat
+    if sys.version_info >= (3, 11):
+        return datetime.datetime.fromisoformat(isodate)
+    else:
+        return datetime.datetime.fromisoformat(
+            isodate.replace("Z", "+00:00")
+            if isodate.endswith("Z") and ("T" in isodate or " " in isodate.strip())
+            else isodate
+        )

pip/_internal/utils/filesystem.py

@@ -7,8 +7,9 @@ import random
 import sys
 from collections.abc import Generator
 from contextlib import contextmanager
+from pathlib import Path
 from tempfile import NamedTemporaryFile
-from typing import Any, BinaryIO, cast
+from typing import Any, BinaryIO, Callable, cast
 
 from pip._internal.utils.compat import get_path_uid
 from pip._internal.utils.misc import format_size
@@ -150,3 +151,53 @@ def directory_size(path: str) -> 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)
+
+
+def _subdirs_without_generic(
+    path: str, predicate: Callable[[str, list[str]], bool]
+) -> Generator[Path]:
+    """Yields every subdirectory of +path+ that has no files matching the
+    predicate under it."""
+
+    directories = []
+    excluded = set()
+
+    for root_str, _, filenames in os.walk(Path(path).resolve()):
+        root = Path(root_str)
+        if predicate(root_str, filenames):
+            # This directory should be excluded, so exclude it and all of its
+            # parent directories.
+            # The last item in root.parents is ".", so we ignore it.
+            #
+            # Wrapping this in `list()` is only needed for Python 3.9.
+            excluded.update(list(root.parents)[:-1])
+            excluded.add(root)
+        directories.append(root)
+
+    for d in sorted(directories, reverse=True):
+        if d not in excluded:
+            yield d
+
+
+def subdirs_without_files(path: str) -> Generator[Path]:
+    """Yields every subdirectory of +path+ that has no files under it."""
+    return _subdirs_without_generic(path, lambda root, filenames: len(filenames) > 0)
+
+
+def subdirs_without_wheels(path: str) -> Generator[Path]:
+    """Yields every subdirectory of +path+ that has no .whl files under it."""
+    return _subdirs_without_generic(
+        path, lambda root, filenames: any(x.endswith(".whl") for x in filenames)
+    )

pip/_internal/utils/logging.py

@@ -9,7 +9,7 @@ import sys
 import threading
 from collections.abc import Generator
 from dataclasses import dataclass
-from io import TextIOWrapper
+from io import StringIO, TextIOWrapper
 from logging import Filter
 from typing import Any, ClassVar
 
@@ -29,7 +29,7 @@ from pip._vendor.rich.style import Style
 from pip._internal.utils._log import VERBOSE, getLogger
 from pip._internal.utils.compat import WINDOWS
 from pip._internal.utils.deprecation import DEPRECATION_MSG_PREFIX
-from pip._internal.utils.misc import ensure_dir
+from pip._internal.utils.misc import StreamWrapper, ensure_dir
 
 _log_state = threading.local()
 _stdout_console = None
@@ -56,6 +56,38 @@ def _is_broken_pipe_error(exc_class: type[BaseException], exc: BaseException) ->
     return isinstance(exc, OSError) and exc.errno in (errno.EINVAL, errno.EPIPE)
 
 
+@contextlib.contextmanager
+def capture_logging() -> Generator[StringIO, None, None]:
+    """Capture all pip logs in a buffer temporarily."""
+    # Patching sys.std(out|err) directly is not viable as the caller
+    # may want to emit non-logging output (e.g. a rich spinner). To
+    # avoid capturing that, temporarily patch the root logging handlers
+    # to use new rich consoles that write to a StringIO.
+    handlers = {}
+    for handler in logging.getLogger().handlers:
+        if isinstance(handler, RichPipStreamHandler):
+            # Also store the handler's original console so it can be
+            # restored on context exit.
+            handlers[handler] = handler.console
+
+    fake_stream = StreamWrapper.from_stream(sys.stdout)
+    if not handlers:
+        yield fake_stream
+        return
+
+    # HACK: grab no_color attribute from a random handler console since
+    # it's a global option anyway.
+    no_color = next(iter(handlers.values())).no_color
+    fake_console = PipConsole(file=fake_stream, no_color=no_color, soft_wrap=True)
+    try:
+        for handler in handlers:
+            handler.console = fake_console
+        yield fake_stream
+    finally:
+        for handler, original_console in handlers.items():
+            handler.console = original_console
+
+
 @contextlib.contextmanager
 def indent_log(num: int = 2) -> Generator[None, None, None]:
     """

pip/_internal/utils/misc.py

@@ -182,10 +182,12 @@ def rmtree_errorhandler(
 def display_path(path: str) -> str:
     """Gives the display value for a given path, making it relative to cwd
     if possible."""
-    path = os.path.normcase(os.path.abspath(path))
-    if path.startswith(os.getcwd() + os.path.sep):
-        path = "." + path[len(os.getcwd()) :]
-    return path
+    try:
+        relative = Path(path).relative_to(Path.cwd())
+    except ValueError:
+        # If the path isn't relative to the CWD, leave it alone
+        return path
+    return os.path.join(".", relative)
 
 
 def backup_dir(dir: str, ext: str = ".bak") -> str:
@@ -541,14 +543,18 @@ class HiddenText:
     def __str__(self) -> str:
         return self.redacted
 
-    # This is useful for testing.
-    def __eq__(self, other: Any) -> bool:
-        if type(self) is not type(other):
-            return False
-
-        # The string being used for redaction doesn't also have to match,
-        # just the raw, original string.
-        return self.secret == other.secret
+    def __eq__(self, other: object) -> bool:
+        # Equality is particularly useful for testing.
+        if type(self) is type(other):
+            # The string being used for redaction doesn't also have to match,
+            # just the raw, original string.
+            return self.secret == cast(HiddenText, other).secret
+        return NotImplemented
+
+    # Disable hashing, since we have a custom __eq__ and don't need hash-ability
+    # (yet). The only required property of hashing is that objects which compare
+    # equal have the same hash value.
+    __hash__ = None  # type: ignore[assignment]
 
 
 def hide_value(value: str) -> HiddenText:

pip/_internal/utils/pylock.py

@@ -0,0 +1,116 @@
+from collections.abc import Iterable
+from pathlib import Path
+
+from pip._vendor.packaging.pylock import (
+    Package,
+    PackageArchive,
+    PackageDirectory,
+    PackageSdist,
+    PackageVcs,
+    PackageWheel,
+    Pylock,
+)
+from pip._vendor.packaging.version import Version
+
+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
+
+
+def _pylock_package_from_install_requirement(
+    ireq: InstallRequirement, base_dir: Path
+) -> Package:
+    base_dir = base_dir.resolve()
+    dist = ireq.get_dist()
+    download_info = ireq.download_info
+    assert download_info
+    package_version = None
+    package_vcs = None
+    package_directory = None
+    package_archive = None
+    package_sdist = None
+    package_wheels = None
+    if ireq.is_direct:
+        if isinstance(download_info.info, VcsInfo):
+            package_vcs = PackageVcs(
+                type=download_info.info.vcs,
+                url=download_info.url,
+                path=None,
+                requested_revision=download_info.info.requested_revision,
+                commit_id=download_info.info.commit_id,
+                subdirectory=download_info.subdirectory,
+            )
+        elif isinstance(download_info.info, DirInfo):
+            package_directory = PackageDirectory(
+                path=(
+                    Path(url_to_path(download_info.url))
+                    .resolve()
+                    .relative_to(base_dir)
+                    .as_posix()
+                ),
+                editable=(
+                    download_info.info.editable if download_info.info.editable else None
+                ),
+                subdirectory=download_info.subdirectory,
+            )
+        elif isinstance(download_info.info, ArchiveInfo):
+            if not download_info.info.hashes:
+                raise NotImplementedError()
+            package_archive = PackageArchive(
+                url=download_info.url,
+                path=None,
+                hashes=download_info.info.hashes,
+                subdirectory=download_info.subdirectory,
+            )
+        else:
+            # should never happen
+            raise NotImplementedError()
+    else:
+        package_version = dist.version
+        if isinstance(download_info.info, ArchiveInfo):
+            if not download_info.info.hashes:
+                raise NotImplementedError()
+            link = Link(download_info.url)
+            if link.is_wheel:
+                package_wheels = [
+                    PackageWheel(
+                        name=link.filename,
+                        url=download_info.url,
+                        hashes=download_info.info.hashes,
+                    )
+                ]
+            else:
+                package_sdist = PackageSdist(
+                    name=link.filename,
+                    url=download_info.url,
+                    hashes=download_info.info.hashes,
+                )
+        else:
+            # should never happen
+            raise NotImplementedError()
+    return Package(
+        name=dist.canonical_name,
+        version=package_version,
+        vcs=package_vcs,
+        directory=package_directory,
+        archive=package_archive,
+        sdist=package_sdist,
+        wheels=package_wheels,
+    )
+
+
+def pylock_from_install_requirements(
+    install_requirements: Iterable[InstallRequirement], base_dir: Path
+) -> Pylock:
+    return Pylock(
+        lock_version=Version("1.0"),
+        created_by="pip",
+        packages=sorted(
+            (
+                _pylock_package_from_install_requirement(ireq, base_dir)
+                for ireq in install_requirements
+            ),
+            key=lambda p: p.name,
+        ),
+    )