shortcutxl 0.3.76 → 0.3.78

package/xll/python/Lib/site-packages/pip/_internal/build_env/venv.py

@@ -0,0 +1,145 @@
+from __future__ import annotations
+
+import os
+import sys
+import sysconfig
+from collections.abc import Iterable
+from types import TracebackType
+from typing import TYPE_CHECKING
+
+from pip._internal.build_env.base import (
+    BuildEnvironment,
+    BuildEnvironmentInstaller,
+    Prefix,
+)
+from pip._internal.exceptions import VenvCreationError, VenvImportError
+from pip._internal.utils.temp_dir import TempDirectory, tempdir_kinds
+
+if TYPE_CHECKING:
+    from pip._internal.req.req_install import InstallRequirement
+
+
+def _get_venv_path_from_sysconfig(name: str, env_dir: str) -> str:
+    vars = {
+        "base": env_dir,
+        "platbase": env_dir,
+    }
+    return sysconfig.get_path(name, scheme="venv", vars=vars)
+
+
+class VenvBuildEnvironment(BuildEnvironment):
+    """A venv-based build environment."""
+
+    def __init__(self, installer: BuildEnvironmentInstaller) -> None:
+        # We defer this import because certain distributions of Python do not include
+        # a functional venv out of the box.
+        try:
+            import venv
+        except ImportError:
+            raise VenvImportError
+
+        self._env_path = TempDirectory(
+            kind=tempdir_kinds.BUILD_ENV, globally_managed=True
+        ).path
+        # Use symlinks to support relocatable Python installations on POSIX, including
+        # python-build-standalone. This matches upstream venv CLI's behaviour.
+        env = venv.EnvBuilder(symlinks=(os.name != "nt"))
+        try:
+            context = env.ensure_directories(self._env_path)
+            env.create(self._env_path)
+        except OSError as e:
+            raise VenvCreationError(str(e))
+
+        if sys.version_info >= (3, 12):
+            # The context object was only documented in Python 3.12
+            self.lib_dirs = [context.lib_path]
+            self._bin_path = context.bin_path
+        elif sys.version_info[:2] == (3, 11):
+            # On Python 3.11, we can use sysconfig.
+            self.lib_dirs = [_get_venv_path_from_sysconfig("purelib", self._env_path)]
+            self._bin_path = _get_venv_path_from_sysconfig("scripts", self._env_path)
+        else:
+            # Otherwise, we need to manually construct all the paths... sigh.
+            if sys.platform == "win32":
+                libpath = os.path.join(self._env_path, "Lib", "site-packages")
+            else:
+                python = "pypy" if sys.implementation.name == "pypy" else "python"
+                libpath = os.path.join(
+                    self._env_path,
+                    "lib",
+                    f"{python}{sys.version_info.major}.{sys.version_info.minor}",
+                    "site-packages",
+                )
+            self.lib_dirs = [libpath]
+            # Same reasoning for try-except as for python_executable below.
+            try:
+                self._bin_path = context.bin_path
+            except AttributeError:
+                scripts_dir = "Scripts" if os.name == "nt" else "bin"
+                self._bin_path = os.path.join(self._env_path, scripts_dir)
+
+        # There are enough ways trying to construct the Python executable path can go
+        # wrong that we're better off assuming that the context object has the right
+        # attributes, and only when they don't exist do we try to guess.
+        #
+        # These attributes seem to exist in every CPython version after 3.10.1 and
+        # are documented to exist on 3.12 and higher.
+        try:
+            self.python_executable = context.env_exec_cmd
+        except AttributeError:
+            try:
+                self.python_executable = context.env_exe
+            except AttributeError:
+                executable_name = "python.exe" if os.name == "nt" else "python"
+                self.python_executable = os.path.join(self._bin_path, executable_name)
+
+        self._save_env: dict[str, str | None] = {}
+        self._installer = installer
+
+        if not os.path.exists(self.python_executable):
+            # This error is only likely on Windows due to interference from AV software.
+            raise VenvCreationError(
+                f"Python executable failed to copy to {self.python_executable}"
+            )
+
+    def __enter__(self) -> None:
+        # We want backend calls to be able to use binaries installed as if this
+        # virtual environment was "activated".
+        self._save_env = {
+            name: os.environ.get(name, None) for name in ("PATH", "PYTHONPATH")
+        }
+
+        new_path = [self._bin_path]
+        if old_path := self._save_env["PATH"]:
+            new_path.extend(old_path.split(os.pathsep))
+        # However, we don't want a pre-existing PYTHONPATH to influence the
+        # backend calls.
+        os.environ.update({"PATH": os.pathsep.join(new_path), "PYTHONPATH": ""})
+
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_val: BaseException | None,
+        exc_tb: TracebackType | None,
+    ) -> None:
+        for varname, old_value in self._save_env.items():
+            if old_value is None:
+                os.environ.pop(varname, None)
+            else:
+                os.environ[varname] = old_value
+
+    def install_requirements(
+        self,
+        requirements: Iterable[str],
+        prefix_as_string: str,
+        *,
+        kind: str,
+        for_req: InstallRequirement | None = None,
+    ) -> None:
+        if not requirements:
+            return
+
+        # TODO: when better support for installing to arbitrary Python environments
+        # is added, replace this prefix hack with that.
+        prefix = Prefix(self._env_path, venv_executable=self.python_executable)
+        self._installer.install(requirements, prefix, kind=kind, for_req=for_req)

package/xll/python/Lib/site-packages/pip/_internal/build_env/virtual.py

@@ -0,0 +1,139 @@
+from __future__ import annotations
+
+import os
+import site
+import sys
+import textwrap
+from collections import OrderedDict
+from collections.abc import Iterable
+from types import TracebackType
+from typing import TYPE_CHECKING
+
+from pip._internal.build_env.base import (
+    BuildEnvironment,
+    BuildEnvironmentInstaller,
+    Prefix,
+)
+from pip._internal.utils.temp_dir import TempDirectory, tempdir_kinds
+
+if TYPE_CHECKING:
+    from pip._internal.req.req_install import InstallRequirement
+
+
+def get_system_sitepackages() -> set[str]:
+    """Get system site packages, as a normalized set of strings."""
+    system_sites = site.getsitepackages()
+    return {os.path.normcase(path) for path in system_sites}
+
+
+class VirtualBuildEnvironment(BuildEnvironment):
+    """Legacy build environment implementation.
+
+    Patches sys.path and uses sitecustomize.py to isolate Python processes. It has
+    known bugs and weird edge cases, but it exists as a fallback for platforms where
+    the venv module is unavailable or dysfunctional.
+    """
+
+    def __init__(self, installer: BuildEnvironmentInstaller) -> None:
+        self.python_executable = sys.executable
+        self.installer = installer
+        temp_dir = TempDirectory(kind=tempdir_kinds.BUILD_ENV, globally_managed=True)
+
+        self._prefixes = OrderedDict(
+            (name, Prefix(os.path.join(temp_dir.path, name)))
+            for name in ("normal", "overlay")
+        )
+
+        self._bin_dirs: list[str] = []
+        self.lib_dirs: list[str] = []
+        for prefix in reversed(list(self._prefixes.values())):
+            self._bin_dirs.append(prefix.bin_dir)
+            self.lib_dirs.extend(prefix.lib_dirs)
+
+        # Customize site to:
+        # - ensure .pth files are honored
+        # - prevent access to system site packages
+        system_sites = get_system_sitepackages()
+
+        self._site_dir = os.path.join(temp_dir.path, "site")
+        if not os.path.exists(self._site_dir):
+            os.mkdir(self._site_dir)
+        with open(
+            os.path.join(self._site_dir, "sitecustomize.py"), "w", encoding="utf-8"
+        ) as fp:
+            fp.write(textwrap.dedent("""
+                import os, site, sys
+
+                # First, discover all system-sites related paths.
+                original_sys_path = sys.path[:]
+                # Clear sys.path so addsitedir() will add system site paths and paths
+                # added by contained .pth files to sys.path reliably. This is necessary
+                # since Python 3.15, which notably no longer re-executes .pth files for
+                # known paths.
+                sys.path = []
+                known_paths = set()
+                for path in {system_sites!r}:
+                    site.addsitedir(path, known_paths=known_paths)
+                system_paths = set(os.path.normcase(path) for path in sys.path)
+
+                # Drop discovered system-sites related paths.
+                original_sys_path = [
+                    path for path in original_sys_path
+                    if os.path.normcase(path) not in system_paths
+                ]
+                sys.path = original_sys_path
+
+                # Second, add lib directories.
+                # ensuring .pth file are processed.
+                for path in {lib_dirs!r}:
+                    assert not path in sys.path
+                    site.addsitedir(path)
+                """).format(system_sites=system_sites, lib_dirs=self.lib_dirs))
+
+    def __enter__(self) -> None:
+        self._save_env = {
+            name: os.environ.get(name, None)
+            for name in ("PATH", "PYTHONNOUSERSITE", "PYTHONPATH")
+        }
+
+        path = self._bin_dirs[:]
+        old_path = self._save_env["PATH"]
+        if old_path:
+            path.extend(old_path.split(os.pathsep))
+
+        pythonpath = [self._site_dir]
+
+        os.environ.update(
+            {
+                "PATH": os.pathsep.join(path),
+                "PYTHONNOUSERSITE": "1",
+                "PYTHONPATH": os.pathsep.join(pythonpath),
+            }
+        )
+
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_val: BaseException | None,
+        exc_tb: TracebackType | None,
+    ) -> None:
+        for varname, old_value in self._save_env.items():
+            if old_value is None:
+                os.environ.pop(varname, None)
+            else:
+                os.environ[varname] = old_value
+
+    def install_requirements(
+        self,
+        requirements: Iterable[str],
+        prefix_as_string: str,
+        *,
+        kind: str,
+        for_req: InstallRequirement | None = None,
+    ) -> None:
+        prefix = self._prefixes[prefix_as_string]
+        assert not prefix.setup
+        prefix.setup = True
+        if not requirements:
+            return
+        self.installer.install(requirements, prefix, kind=kind, for_req=for_req)

package/xll/python/Lib/site-packages/pip/_internal/cache.py

@@ -134,10 +134,13 @@ class SimpleWheelCache(Cache):
     ) -> Link:
         candidates = []
 
+        if link.is_existing_dir():
+            return link
         if not package_name:
             return link
 
         canonical_package_name = canonicalize_name(package_name)
+        supported_tags_set = set(supported_tags)
         for wheel_name, wheel_dir in self._get_candidates(link, canonical_package_name):
             try:
                 wheel = Wheel(wheel_name)
@@ -152,7 +155,7 @@ class SimpleWheelCache(Cache):
                     package_name,
                 )
                 continue
-            if not wheel.supported(supported_tags):
+            if not wheel.supported(supported_tags_set):
                 # Built for a different python/arch/etc
                 continue
             candidates.append(

package/xll/python/Lib/site-packages/pip/_internal/cli/autocompletion.py

@@ -11,7 +11,6 @@ from typing import Any
 
 from pip._internal.cli.main_parser import create_main_parser
 from pip._internal.commands import commands_dict, create_command
-from pip._internal.metadata import get_default_environment
 
 
 def autocomplete() -> None:
@@ -51,6 +50,10 @@ def autocomplete() -> None:
             "uninstall",
         ]
         if should_list_installed:
+            # NOTE: this import is deferred until absolutely necessary as it's slow,
+            # and it's important that autocompletion is fast.
+            from pip._internal.metadata import get_default_environment
+
             env = get_default_environment()
             lc = current.lower()
             installed = [

package/xll/python/Lib/site-packages/pip/_internal/cli/base_command.py

@@ -9,9 +9,8 @@ import optparse
 import os
 import sys
 import traceback
-from collections.abc import Iterator
+from collections.abc import Callable, Iterator
 from optparse import Values
-from typing import Callable
 
 from pip._vendor.rich import reconfigure
 from pip._vendor.rich import traceback as rich_traceback
@@ -20,6 +19,7 @@ from pip._internal.cli import cmdoptions
 from pip._internal.cli.command_context import CommandContextMixIn
 from pip._internal.cli.parser import ConfigOptionParser, UpdatingDefaultsHelpFormatter
 from pip._internal.cli.status_codes import (
+    BROKEN_STDOUT,
     ERROR,
     PREVIOUS_BUILD_DIR_ERROR,
     UNKNOWN_ERROR,
@@ -147,7 +147,15 @@ class Command(CommandContextMixIn):
             except OSError:
                 pass
 
-            return ERROR
+            # redirect stdout to os.devnull so that the exit cleanup doesn't
+            # produce "BrokenPipeError" when exiting.
+            devnull = os.open(os.devnull, os.O_WRONLY)
+            try:
+                os.dup2(devnull, 1)
+            finally:
+                os.close(devnull)
+
+            return BROKEN_STDOUT
         except KeyboardInterrupt:
             logger.critical("Operation cancelled by user")
             logger.debug("Exception information:", exc_info=True)
@@ -244,17 +252,6 @@ 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]]:

package/xll/python/Lib/site-packages/pip/_internal/cli/cmdoptions.py

@@ -16,11 +16,12 @@ import os
 import pathlib
 import re
 import textwrap
+from collections.abc import Callable
 from datetime import datetime, timedelta, timezone
 from functools import partial
 from optparse import SUPPRESS_HELP, Option, OptionGroup, OptionParser, Values
 from textwrap import dedent
-from typing import Any, Callable
+from typing import Any
 
 from pip._vendor.packaging.utils import canonicalize_name
 
@@ -31,7 +32,6 @@ 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 import pylock as pylock_utils
 from pip._internal.utils.datetime import parse_iso_datetime
 from pip._internal.utils.hashes import STRONG_HASHES
 from pip._internal.utils.misc import strtobool
@@ -65,6 +65,37 @@ def make_option_group(group: dict[str, Any], parser: ConfigOptionParser) -> Opti
     return option_group
 
 
+def check_only_deps_option_does_not_conflict(options: Values) -> None:
+    """Function for determining if --only-deps and other incompatible options are
+    specified.
+
+    :param options: The OptionParser options.
+    """
+    if not options.only_dependencies:
+        return
+    conflicts = []
+    if options.ignore_dependencies:
+        conflicts.append("'--no-deps'")
+    if "legacy-resolver" in options.deprecated_features_enabled:
+        conflicts.append("'--use-deprecated legacy-resolver'")
+    if options.requirements:
+        conflicts.append("'--requirement'")
+    if options.requirements_from_scripts:
+        conflicts.append("'--requirements-from-script'")
+    if options.dependency_groups:
+        conflicts.append("'--group'")
+    if conflicts:
+        if len(conflicts) > 1:
+            conflicts[-1] = "or " + conflicts[-1]
+        conflict_message = ", ".join(conflicts)
+        raise CommandError(
+            f"Cannot use '--only-dependencies' in combination with {conflict_message}. "
+            "If this is unexpected, please refer to the user guide:\n"
+            "\n"
+            "    https://pip.pypa.io/en/stable/user_guide/#installing-only-dependencies"
+        )
+
+
 def check_dist_restriction(options: Values, check_target: bool = False) -> None:
     """Function for determining if custom platform options are allowed.
 
@@ -104,13 +135,17 @@ def check_dist_restriction(options: Values, check_target: bool = False) -> None:
                 "installing via '--target' or using '--dry-run'"
             )
 
-    for filename in options.requirements:
-        if dist_restriction_set and pylock_utils.is_valid_pylock_filename(filename):
-            raise CommandError(
-                "Patform and interpreter constraints using "
-                "--python-version, --platform, --abi, or --implementation, "
-                f"are not supported when selecting requirements from {filename!r}"
-            )
+    if dist_restriction_set:
+        # Lazy import to keep CLI startup fast
+        from pip._internal.utils import pylock as pylock_utils
+
+        for filename in options.requirements:
+            if pylock_utils.is_valid_pylock_filename(filename):
+                raise CommandError(
+                    "Platform and interpreter constraints using "
+                    "--python-version, --platform, --abi, or --implementation, "
+                    f"are not supported when selecting requirements from {filename!r}"
+                )
 
 
 def check_build_constraints(options: Values) -> None:
@@ -310,10 +345,19 @@ proxy: Callable[..., Option] = partial(
     "--proxy",
     dest="proxy",
     type="str",
-    default="",
+    default=None,
     help="Specify a proxy in the form scheme://[user:passwd@]proxy.server:port.",
 )
 
+no_proxy_env: Callable[..., Option] = partial(
+    Option,
+    "--no-proxy-env",
+    dest="no_proxy_env",
+    action="store_true",
+    default=False,
+    help="Do not read proxy configuration from environment variables.",
+)
+
 retries: Callable[..., Option] = partial(
     Option,
     "--retries",
@@ -497,7 +541,7 @@ def uploaded_prior_to() -> Option:
             "Accepts an ISO 8601 datetime (e.g., '2023-01-01T00:00:00Z', "
             "uses local timezone if none specified) or a duration in days "
             "(e.g., 'P3D' for packages uploaded at least 3 days ago). "
-            "Only effective when installing from indexes that provide "
+            "Only effective when using indexes that provide "
             "upload-time metadata."
         ),
     )
@@ -646,12 +690,13 @@ def no_binary() -> Option:
         callback=_handle_no_binary,
         type="str",
         default=format_control,
-        help="Do not use binary packages. Can be supplied multiple times, and "
-        'each time adds to the existing value. Accepts either ":all:" to '
-        'disable all binary packages, ":none:" to empty the set (notice '
-        "the colons), or one or more package names with commas between "
-        "them (no colons). Note that some packages are tricky to compile "
-        "and may fail to install when this option is used on them.",
+        help="Do not download binary packages. Cached binary packages may still "
+        "be used. Can be supplied multiple times, and each time adds to "
+        "the existing value. Accepts either ':all:' to disable all binary "
+        "packages, ':none:' to empty the set (notice the colons), or one "
+        "or more package names with commas between them (no colons). "
+        "Note that some packages are tricky to compile and may fail to "
+        "install when this option is used on them.",
     )
 
 
@@ -821,15 +866,13 @@ python_version: Callable[..., Option] = partial(
     callback=_handle_python_version,
     type="str",
     default=None,
-    help=dedent(
-        """\
+    help=dedent("""\
     The Python interpreter version to use for wheel and "Requires-Python"
     compatibility checks. Defaults to a version derived from the running
     interpreter. The version can be specified using up to three dot-separated
     integers (e.g. "3" for 3.0.0, "3.7" for 3.7.0, or "3.7.3"). A major-minor
     version can also be given as a string without dots (e.g. "37" for 3.7.0).
-    """
-    ),
+    """),
 )
 
 
@@ -958,6 +1001,60 @@ no_deps: Callable[..., Option] = partial(
 )
 
 
+def _handle_refresh_package(
+    option: Option, opt_str: str, value: str, parser: OptionParser
+) -> None:
+    if value.startswith("-"):
+        raise CommandError("--refresh-package option requires 1 argument.")
+
+    existing: set[str] = getattr(parser.values, option.dest)
+
+    new = value.split(",")
+    while ":all:" in new:
+        existing.clear()
+        existing.add(":all:")
+        del new[: new.index(":all:") + 1]
+        if ":none:" not in new:
+            return
+
+    for name in new:
+        if name == ":none:":
+            existing.clear()
+        else:
+            existing.add(canonicalize_name(name))
+
+
+def refresh_package() -> Option:
+    return Option(
+        "--refresh-package",
+        dest="refresh_package",
+        action="callback",
+        callback=_handle_refresh_package,
+        type="str",
+        default=set(),
+        help="Refresh package index information for the given packages instead "
+        "of using cached responses. Accepts ':all:' to apply "
+        "to all packages, or a comma-separated list of package names.",
+    )
+
+
+only_deps: Callable[..., Option] = partial(
+    Option,
+    "--only-deps",
+    "--only-dependencies",
+    dest="only_dependencies",
+    action="store_true",
+    default=False,
+    help=(
+        "Take only the dependencies of the provided requirements into account, "
+        "not the requirements themselves. Cannot be used in combination with "
+        "--no-deps, --group, --requirement, or --requirements-from-script. "
+        "No user-supplied requirements will be handled, even if they were "
+        "dependencies of other user-supplied requirements."
+    ),
+)
+
+
 def _handle_dependency_group(
     option: Option, opt: str, value: str, parser: OptionParser
 ) -> None:
@@ -1165,6 +1262,17 @@ require_hashes: Callable[..., Option] = partial(
 )
 
 
+no_require_hashes: Callable[..., Option] = partial(
+    Option,
+    "--no-require-hashes",
+    dest="no_require_hashes",
+    action="store_true",
+    default=False,
+    help="Do not automatically enable --require-hashes "
+    "when encountering a requirement with hashes.",
+)
+
+
 list_path: Callable[..., Option] = partial(
     PipOption,
     "--path",
@@ -1206,6 +1314,7 @@ no_python_version_warning: Callable[..., Option] = partial(
 ALWAYS_ENABLED_FEATURES = [
     "truststore",  # always on since 24.2
     "no-binary-enable-wheel-cache",  # always on since 23.1
+    "build-constraint",  # always on since 26.2
 ]
 
 use_new_feature: Callable[..., Option] = partial(
@@ -1217,8 +1326,8 @@ use_new_feature: Callable[..., Option] = partial(
     default=[],
     choices=[
         "fast-deps",
-        "build-constraint",
         "inprocess-build-deps",
+        "venv-isolation",
     ]
     + ALWAYS_ENABLED_FEATURES,
     help="Enable new functionality, that may be backward incompatible.",
@@ -1257,6 +1366,7 @@ general_group: dict[str, Any] = {
         no_input,
         keyring_provider,
         proxy,
+        no_proxy_env,
         retries,
         timeout,
         exists_action,
@@ -1280,6 +1390,7 @@ index_group: dict[str, Any] = {
         index_url,
         extra_index_url,
         no_index,
+        refresh_package,
         find_links,
         uploaded_prior_to,
     ],

package/xll/python/Lib/site-packages/pip/_internal/cli/index_command.py

@@ -107,6 +107,7 @@ class SessionCommandMixin(CommandContextMixIn):
             trusted_hosts=options.trusted_hosts,
             index_urls=self._get_index_urls(options),
             ssl_context=ssl_context,
+            refresh_package=getattr(options, "refresh_package", set()),
         )
 
         # Handle custom ca-bundles from the user
@@ -121,14 +122,18 @@ class SessionCommandMixin(CommandContextMixIn):
         if options.timeout or timeout:
             session.timeout = timeout if timeout is not None else options.timeout
 
-        # Handle configured proxies
-        if options.proxy:
-            session.proxies = {
-                "http": options.proxy,
-                "https": options.proxy,
-            }
+        # An explicit --proxy (including "" to disable proxying) or --no-proxy-env
+        # makes the session ignore environment proxies; unset --proxy is None.
+        if options.proxy is not None or options.no_proxy_env:
+            if options.proxy:
+                session.proxies = {
+                    "http": options.proxy,
+                    "https": options.proxy,
+                }
             session.trust_env = False
+            # Keep "" so an empty --proxy reaches build subprocesses.
             session.pip_proxy = options.proxy
+            session.pip_no_proxy_env = options.no_proxy_env
 
         # Determine if we can prompt the user for authentication or not
         session.auth.prompting = not options.no_input