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

pip/__init__.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-__version__ = "25.3"
+__version__ = "26.0"
 
 
 def main(args: list[str] | None = None) -> int:

pip/_internal/build_env.py

@@ -9,25 +9,37 @@ import site
 import sys
 import textwrap
 from collections import OrderedDict
-from collections.abc import Iterable
+from collections.abc import Iterable, Sequence
+from contextlib import AbstractContextManager as ContextManager
+from contextlib import nullcontext
+from io import StringIO
 from types import TracebackType
 from typing import TYPE_CHECKING, Protocol, TypedDict
 
 from pip._vendor.packaging.version import Version
 
 from pip import __file__ as pip_location
-from pip._internal.cli.spinners import open_spinner
+from pip._internal.cli.spinners import open_rich_spinner, open_spinner
+from pip._internal.exceptions import (
+    BuildDependencyInstallError,
+    DiagnosticPipError,
+    InstallWheelBuildError,
+    PipError,
+)
 from pip._internal.locations import get_platlib, get_purelib, get_scheme
 from pip._internal.metadata import get_default_environment, get_environment
 from pip._internal.utils.deprecation import deprecated
-from pip._internal.utils.logging import VERBOSE
+from pip._internal.utils.logging import VERBOSE, capture_logging
 from pip._internal.utils.packaging import get_requirement
 from pip._internal.utils.subprocess import call_subprocess
 from pip._internal.utils.temp_dir import TempDirectory, tempdir_kinds
 
 if TYPE_CHECKING:
+    from pip._internal.cache import WheelCache
     from pip._internal.index.package_finder import PackageFinder
+    from pip._internal.operations.build.build_tracker import BuildTracker
     from pip._internal.req.req_install import InstallRequirement
+    from pip._internal.resolution.base import BaseResolver
 
     class ExtraEnviron(TypedDict, total=False):
         extra_environ: dict[str, str]
@@ -188,6 +200,12 @@ class SubprocessBuildEnvironmentInstaller:
                 )
             )
 
+        if finder.release_control is not None:
+            # Use ordered args to preserve the user's original command-line order
+            # This is important because later flags can override earlier ones
+            for attr_name, value in finder.release_control.get_ordered_args():
+                args.extend(("--" + attr_name.replace("_", "-"), value))
+
         index_urls = finder.index_urls
         if index_urls:
             args.extend(["-i", index_urls[0]])
@@ -206,8 +224,6 @@ class SubprocessBuildEnvironmentInstaller:
             args.extend(["--cert", finder.custom_cert])
         if finder.client_cert:
             args.extend(["--client-cert", finder.client_cert])
-        if finder.allow_all_prereleases:
-            args.append("--pre")
         if finder.prefer_binary:
             args.append("--prefer-binary")
 
@@ -230,6 +246,8 @@ class SubprocessBuildEnvironmentInstaller:
             # in the isolated build environment
             extra_environ = {"extra_environ": {"_PIP_IN_BUILD_IGNORE_CONSTRAINTS": "1"}}
 
+        if finder.uploaded_prior_to:
+            args.extend(["--uploaded-prior-to", finder.uploaded_prior_to.isoformat()])
         args.append("--")
         args.extend(requirements)
 
@@ -245,6 +263,177 @@ class SubprocessBuildEnvironmentInstaller:
             )
 
 
+class InprocessBuildEnvironmentInstaller:
+    """
+    Build dependency installer that runs in the same pip process.
+
+    This contains a stripped down version of the install command with
+    only the logic necessary for installing build dependencies. The
+    finder, session, build tracker, and wheel cache are reused, but new
+    instances of everything else are created as needed.
+
+    Options are inherited from the parent install command unless
+    they don't make sense for build dependencies (in which case, they
+    are hard-coded, see comments below).
+    """
+
+    def __init__(
+        self,
+        *,
+        finder: PackageFinder,
+        build_tracker: BuildTracker,
+        wheel_cache: WheelCache,
+        build_constraints: Sequence[InstallRequirement] = (),
+        verbosity: int = 0,
+    ) -> None:
+        from pip._internal.operations.prepare import RequirementPreparer
+
+        self._finder = finder
+        self._build_constraints = build_constraints
+        self._wheel_cache = wheel_cache
+        self._level = 0
+
+        build_dir = TempDirectory(kind="build-env-install", globally_managed=True)
+        self._preparer = RequirementPreparer(
+            build_isolation_installer=self,
+            # Inherited options or state.
+            finder=finder,
+            session=finder._link_collector.session,
+            build_dir=build_dir.path,
+            build_tracker=build_tracker,
+            verbosity=verbosity,
+            # This is irrelevant as it only applies to editable requirements.
+            src_dir="",
+            # Hard-coded options (that should NOT be inherited).
+            download_dir=None,
+            build_isolation=True,
+            check_build_deps=False,
+            progress_bar="off",
+            # TODO: hash-checking should be extended to build deps, but that is
+            # deferred for later as it'd be a breaking change.
+            require_hashes=False,
+            use_user_site=False,
+            lazy_wheel=False,
+            legacy_resolver=False,
+        )
+
+    def install(
+        self,
+        requirements: Iterable[str],
+        prefix: _Prefix,
+        *,
+        kind: str,
+        for_req: InstallRequirement | None,
+    ) -> None:
+        """Install entrypoint. Manages output capturing and error handling."""
+        capture_logs = not logger.isEnabledFor(VERBOSE) and self._level == 0
+        if capture_logs:
+            # Hide the logs from the installation of build dependencies.
+            # They will be shown only if an error occurs.
+            capture_ctx: ContextManager[StringIO] = capture_logging()
+            spinner: ContextManager[None] = open_rich_spinner(f"Installing {kind}")
+        else:
+            # Otherwise, pass-through all logs (with a header).
+            capture_ctx, spinner = nullcontext(StringIO()), nullcontext()
+            logger.info("Installing %s ...", kind)
+
+        try:
+            self._level += 1
+            with spinner, capture_ctx as stream:
+                self._install_impl(requirements, prefix)
+
+        except DiagnosticPipError as exc:
+            # Format similar to a nested subprocess error, where the
+            # causing error is shown first, followed by the build error.
+            logger.info(textwrap.dedent(stream.getvalue()))
+            logger.error("%s", exc, extra={"rich": True})
+            logger.info("")
+            raise BuildDependencyInstallError(
+                for_req, requirements, cause=exc, log_lines=None
+            )
+
+        except Exception as exc:
+            logs: list[str] | None = textwrap.dedent(stream.getvalue()).splitlines()
+            if not capture_logs:
+                # If logs aren't being captured, then display the error inline
+                # with the rest of the logs.
+                logs = None
+                if isinstance(exc, PipError):
+                    logger.error("%s", exc)
+                else:
+                    logger.exception("pip crashed unexpectedly")
+            raise BuildDependencyInstallError(
+                for_req, requirements, cause=exc, log_lines=logs
+            )
+
+        finally:
+            self._level -= 1
+
+    def _install_impl(self, requirements: Iterable[str], prefix: _Prefix) -> None:
+        """Core build dependency install logic."""
+        from pip._internal.commands.install import installed_packages_summary
+        from pip._internal.req import install_given_reqs
+        from pip._internal.req.constructors import install_req_from_line
+        from pip._internal.wheel_builder import build
+
+        ireqs = [install_req_from_line(req, user_supplied=True) for req in requirements]
+        ireqs.extend(self._build_constraints)
+
+        resolver = self._make_resolver()
+        resolved_set = resolver.resolve(ireqs, check_supported_wheels=True)
+        self._preparer.prepare_linked_requirements_more(
+            resolved_set.requirements.values()
+        )
+
+        reqs_to_build = [
+            r for r in resolved_set.requirements_to_install if not r.is_wheel
+        ]
+        _, build_failures = build(reqs_to_build, self._wheel_cache, verify=True)
+        if build_failures:
+            raise InstallWheelBuildError(build_failures)
+
+        installed = install_given_reqs(
+            resolver.get_installation_order(resolved_set),
+            prefix=prefix.path,
+            # Hard-coded options (that should NOT be inherited).
+            root=None,
+            home=None,
+            warn_script_location=False,
+            use_user_site=False,
+            # As the build environment is ephemeral, it's wasteful to
+            # pre-compile everything since not all modules will be used.
+            pycompile=False,
+            progress_bar="off",
+        )
+
+        env = get_environment(list(prefix.lib_dirs))
+        if summary := installed_packages_summary(installed, env):
+            logger.info(summary)
+
+    def _make_resolver(self) -> BaseResolver:
+        """Create a new resolver for one time use."""
+        # Legacy installer never used the legacy resolver so create a
+        # resolvelib resolver directly. Yuck.
+        from pip._internal.req.constructors import install_req_from_req_string
+        from pip._internal.resolution.resolvelib.resolver import Resolver
+
+        return Resolver(
+            make_install_req=install_req_from_req_string,
+            # Inherited state.
+            preparer=self._preparer,
+            finder=self._finder,
+            wheel_cache=self._wheel_cache,
+            # Hard-coded options (that should NOT be inherited).
+            ignore_requires_python=False,
+            use_user_site=False,
+            ignore_dependencies=False,
+            ignore_installed=True,
+            force_reinstall=False,
+            upgrade_strategy="to-satisfy-only",
+            py_version_info=None,
+        )
+
+
 class BuildEnvironment:
     """Creates and manages an isolated environment to install build deps"""
 

pip/_internal/cli/base_command.py

@@ -235,6 +235,17 @@ class Command(CommandContextMixIn):
                 )
                 options.cache_dir = None
 
+        if (
+            "inprocess-build-deps" in options.features_enabled
+            and os.environ.get("PIP_CONSTRAINT", "")
+            and "build-constraint" not in options.features_enabled
+        ):
+            logger.warning(
+                "In-process build dependencies are enabled, "
+                "PIP_CONSTRAINT will have no effect for build dependencies"
+            )
+            options.features_enabled.append("build-constraint")
+
         return self._run_wrapper(level_number, options, args)
 
     def handler_map(self) -> dict[str, Callable[[Values, list[str]], None]]:

pip/_internal/cli/cmdoptions.py

@@ -27,7 +27,9 @@ from pip._internal.exceptions import CommandError
 from pip._internal.locations import USER_CACHE_DIR, get_src_prefix
 from pip._internal.models.format_control import FormatControl
 from pip._internal.models.index import PyPI
+from pip._internal.models.release_control import ReleaseControl
 from pip._internal.models.target_python import TargetPython
+from pip._internal.utils.datetime import parse_iso_datetime
 from pip._internal.utils.hashes import STRONG_HASHES
 from pip._internal.utils.misc import strtobool
 
@@ -426,6 +428,54 @@ def find_links() -> Option:
     )
 
 
+def _handle_uploaded_prior_to(
+    option: Option, opt: str, value: str, parser: OptionParser
+) -> None:
+    """
+    This is an optparse.Option callback for the --uploaded-prior-to option.
+
+    Parses an ISO 8601 datetime string. If no timezone is specified in the string,
+    local timezone is used.
+
+    Note: This option only works with indexes that provide upload-time metadata
+    as specified in the simple repository API:
+    https://packaging.python.org/en/latest/specifications/simple-repository-api/
+    """
+    if value is None:
+        return None
+
+    try:
+        uploaded_prior_to = parse_iso_datetime(value)
+        # Use local timezone if no offset is given in the ISO string.
+        if uploaded_prior_to.tzinfo is None:
+            uploaded_prior_to = uploaded_prior_to.astimezone()
+        parser.values.uploaded_prior_to = uploaded_prior_to
+    except ValueError as exc:
+        msg = (
+            f"invalid value: {value!r}: {exc}. "
+            f"Expected an ISO 8601 datetime string, "
+            f"e.g '2023-01-01' or '2023-01-01T00:00:00Z'"
+        )
+        raise_option_error(parser, option=option, msg=msg)
+
+
+def uploaded_prior_to() -> Option:
+    return Option(
+        "--uploaded-prior-to",
+        dest="uploaded_prior_to",
+        metavar="datetime",
+        action="callback",
+        callback=_handle_uploaded_prior_to,
+        type="str",
+        help=(
+            "Only consider packages uploaded prior to the given date time. "
+            "Accepts ISO 8601 strings (e.g., '2023-01-01T00:00:00Z'). "
+            "Uses local timezone if none specified. Only effective when "
+            "installing from indexes that provide upload-time metadata."
+        ),
+    )
+
+
 def trusted_host() -> Option:
     return Option(
         "--trusted-host",
@@ -479,6 +529,18 @@ def requirements() -> Option:
     )
 
 
+def requirements_from_scripts() -> Option:
+    return Option(
+        "--requirements-from-script",
+        action="append",
+        default=[],
+        dest="requirements_from_scripts",
+        metavar="file",
+        help="Install dependencies of the given script file"
+        "as defined by PEP 723 inline metadata. ",
+    )
+
+
 def editable() -> Option:
     return Option(
         "-e",
@@ -580,6 +642,86 @@ def only_binary() -> Option:
     )
 
 
+def _get_release_control(values: Values, option: Option) -> Any:
+    """Get a release_control object."""
+    return getattr(values, option.dest)
+
+
+def _handle_all_releases(
+    option: Option, opt_str: str, value: str, parser: OptionParser
+) -> None:
+    existing = _get_release_control(parser.values, option)
+    existing.handle_mutual_excludes(
+        value,
+        existing.all_releases,
+        existing.only_final,
+        "all_releases",
+    )
+
+
+def _handle_only_final(
+    option: Option, opt_str: str, value: str, parser: OptionParser
+) -> None:
+    existing = _get_release_control(parser.values, option)
+    existing.handle_mutual_excludes(
+        value,
+        existing.only_final,
+        existing.all_releases,
+        "only_final",
+    )
+
+
+def all_releases() -> Option:
+    release_control = ReleaseControl(set(), set())
+    return Option(
+        "--all-releases",
+        dest="release_control",
+        action="callback",
+        callback=_handle_all_releases,
+        type="str",
+        default=release_control,
+        help="Allow all release types (including pre-releases) for a package. "
+        "Can be supplied multiple times, and each time adds to the existing "
+        'value. Accepts either ":all:" to allow pre-releases for all '
+        'packages, ":none:" to empty the set (notice the colons), or one or '
+        "more package names with commas between them (no colons). Cannot be "
+        "used with --pre.",
+    )
+
+
+def only_final() -> Option:
+    release_control = ReleaseControl(set(), set())
+    return Option(
+        "--only-final",
+        dest="release_control",
+        action="callback",
+        callback=_handle_only_final,
+        type="str",
+        default=release_control,
+        help="Only allow final releases (no pre-releases) for a package. Can be "
+        "supplied multiple times, and each time adds to the existing value. "
+        'Accepts either ":all:" to disable pre-releases for all packages, '
+        '":none:" to empty the set, or one or more package names with commas '
+        "between them. Cannot be used with --pre.",
+    )
+
+
+def check_release_control_exclusive(options: Values) -> None:
+    """
+    Raise an error if --pre is used with --all-releases or --only-final,
+    and transform --pre into --all-releases :all: if used alone.
+    """
+    if not hasattr(options, "pre") or not options.pre:
+        return
+
+    release_control = options.release_control
+    if release_control.all_releases or release_control.only_final:
+        raise CommandError("--pre cannot be used with --all-releases or --only-final.")
+
+    # Transform --pre into --all-releases :all:
+    release_control.all_releases.add(":all:")
+
+
 platforms: Callable[..., Option] = partial(
     Option,
     "--platform",
@@ -832,6 +974,7 @@ ignore_requires_python: Callable[..., Option] = partial(
     help="Ignore the Requires-Python information.",
 )
 
+
 no_build_isolation: Callable[..., Option] = partial(
     Option,
     "--no-build-isolation",
@@ -1044,6 +1187,7 @@ use_new_feature: Callable[..., Option] = partial(
     choices=[
         "fast-deps",
         "build-constraint",
+        "inprocess-build-deps",
     ]
     + ALWAYS_ENABLED_FEATURES,
     help="Enable new functionality, that may be backward incompatible.",
@@ -1106,5 +1250,18 @@ index_group: dict[str, Any] = {
         extra_index_url,
         no_index,
         find_links,
+        uploaded_prior_to,
+    ],
+}
+
+package_selection_group: dict[str, Any] = {
+    "name": "Package Selection Options",
+    "options": [
+        pre,
+        all_releases,
+        only_final,
+        no_binary,
+        only_binary,
+        prefer_binary,
     ],
 }

pip/_internal/cli/index_command.py

@@ -23,6 +23,8 @@ from pip._internal.cli.command_context import CommandContextMixIn
 if TYPE_CHECKING:
     from ssl import SSLContext
 
+    from pip._vendor.packaging.utils import NormalizedName
+
     from pip._internal.network.session import PipSession
 
 logger = logging.getLogger(__name__)
@@ -103,6 +105,7 @@ class SessionCommandMixin(CommandContextMixIn):
         session = PipSession(
             cache=os.path.join(cache_dir, "http-v2") if cache_dir else None,
             retries=retries if retries is not None else options.retries,
+            resume_retries=options.resume_retries,
             trusted_hosts=options.trusted_hosts,
             index_urls=self._get_index_urls(options),
             ssl_context=ssl_context,
@@ -149,6 +152,23 @@ class IndexGroupCommand(Command, SessionCommandMixin):
     This also corresponds to the commands that permit the pip version check.
     """
 
+    def should_exclude_prerelease(
+        self, options: Values, package_name: NormalizedName
+    ) -> bool:
+        """
+        Determine if pre-releases should be excluded for a package.
+        """
+        # Check per-package release control settings
+        if options.release_control:
+            allow_prereleases = options.release_control.allows_prereleases(package_name)
+            if allow_prereleases is True:
+                return False  # Include pre-releases
+            elif allow_prereleases is False:
+                return True  # Exclude pre-releases
+
+        # No specific setting: exclude prereleases by default
+        return True
+
     def handle_pip_version_check(self, options: Values) -> None:
         """
         Do the pip version check if not disabled.

pip/_internal/cli/main.py

@@ -8,12 +8,6 @@ import os
 import sys
 import warnings
 
-from pip._internal.cli.autocompletion import autocomplete
-from pip._internal.cli.main_parser import parse_command
-from pip._internal.commands import create_command
-from pip._internal.exceptions import PipError
-from pip._internal.utils import deprecation
-
 logger = logging.getLogger(__name__)
 
 
@@ -45,6 +39,17 @@ logger = logging.getLogger(__name__)
 
 
 def main(args: list[str] | None = None) -> int:
+    # NOTE: Lazy imports to speed up import of this module,
+    # which is imported from the pip console script. This doesn't
+    # speed up normal pip execution, but might be important in the future
+    # if we use ``multiprocessing`` module,
+    # which imports __main__ for each spawned subprocess.
+    from pip._internal.cli.autocompletion import autocomplete
+    from pip._internal.cli.main_parser import parse_command
+    from pip._internal.commands import create_command
+    from pip._internal.exceptions import PipError
+    from pip._internal.utils import deprecation
+
     if args is None:
         args = sys.argv[1:]
 

pip/_internal/cli/main_parser.py

@@ -6,6 +6,8 @@ import os
 import subprocess
 import sys
 
+from pip._vendor.rich.markup import escape
+
 from pip._internal.build_env import get_runnable_pip
 from pip._internal.cli import cmdoptions
 from pip._internal.cli.parser import ConfigOptionParser, UpdatingDefaultsHelpFormatter
@@ -39,7 +41,7 @@ def create_main_parser() -> ConfigOptionParser:
 
     # create command listing for description
     description = [""] + [
-        f"{name:27} {command_info.summary}"
+        f"[optparse.longargs]{name:27}[/] {escape(command_info.summary)}"
         for name, command_info in commands_dict.items()
     ]
     parser.description = "\n".join(description)