shortcutxl 0.3.76 → 0.3.78

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

@@ -62,6 +62,7 @@ class WheelCommand(RequirementCommand):
         self.cmd_opts.add_option(cmdoptions.src())
         self.cmd_opts.add_option(cmdoptions.ignore_requires_python())
         self.cmd_opts.add_option(cmdoptions.no_deps())
+        self.cmd_opts.add_option(cmdoptions.only_deps())
         self.cmd_opts.add_option(cmdoptions.progress_bar())
 
         self.cmd_opts.add_option(
@@ -75,6 +76,7 @@ class WheelCommand(RequirementCommand):
         self.cmd_opts.add_option(cmdoptions.config_settings())
 
         self.cmd_opts.add_option(cmdoptions.require_hashes())
+        self.cmd_opts.add_option(cmdoptions.no_require_hashes())
 
         index_opts = cmdoptions.make_option_group(
             cmdoptions.index_group,
@@ -94,6 +96,7 @@ class WheelCommand(RequirementCommand):
     def run(self, options: Values, args: list[str]) -> int:
         cmdoptions.check_build_constraints(options)
         cmdoptions.check_release_control_exclusive(options)
+        cmdoptions.check_only_deps_option_does_not_conflict(options)
 
         session = self.get_default_session(options)
 
@@ -123,6 +126,7 @@ class WheelCommand(RequirementCommand):
             download_dir=options.wheel_dir,
             use_user_site=False,
             verbosity=self.verbosity,
+            allow_editables=False,
         )
 
         resolver = self.make_resolver(
@@ -151,6 +155,7 @@ class WheelCommand(RequirementCommand):
             reqs_to_build,
             wheel_cache=wheel_cache,
             verify=(not options.no_verify),
+            allow_editables=False,
         )
         for req in build_successes:
             assert req.link and req.link.is_wheel
@@ -160,8 +165,9 @@ class WheelCommand(RequirementCommand):
                 shutil.copy(req.local_file_path, options.wheel_dir)
             except OSError as e:
                 logger.warning(
-                    "Building wheel for %s failed: %s",
+                    "Failed to copy built wheel %s to %s: %s",
                     req.name,
+                    options.wheel_dir,
                     e,
                 )
                 build_failures.append(req)

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

@@ -14,7 +14,6 @@ Some terminology:
 from __future__ import annotations
 
 import configparser
-import locale
 import os
 import sys
 from collections.abc import Iterable
@@ -25,7 +24,7 @@ from pip._internal.exceptions import (
     ConfigurationFileCouldNotBeLoaded,
 )
 from pip._internal.utils import appdirs
-from pip._internal.utils.compat import WINDOWS
+from pip._internal.utils.compat import WINDOWS, get_locale_encoding
 from pip._internal.utils.logging import getLogger
 from pip._internal.utils.misc import ensure_dir, enum
 
@@ -293,7 +292,7 @@ class Configuration:
         # Doing this is useful when modifying and saving files, where we don't
         # need to construct a parser.
         if os.path.exists(fname):
-            locale_encoding = locale.getpreferredencoding(False)
+            locale_encoding = get_locale_encoding()
             try:
                 parser.read(fname, encoding=locale_encoding)
             except UnicodeDecodeError:

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

@@ -7,7 +7,7 @@ from pip._internal.metadata.base import BaseDistribution
 from pip._internal.req import InstallRequirement
 
 if TYPE_CHECKING:
-    from pip._internal.build_env import BuildEnvironmentInstaller
+    from pip._internal.build_env import BuildEnvironmentInstaller, BuildIsolationMode
 
 
 class AbstractDistribution(metaclass=abc.ABCMeta):
@@ -33,7 +33,8 @@ class AbstractDistribution(metaclass=abc.ABCMeta):
         super().__init__()
         self.req = req
 
-    @abc.abstractproperty
+    @property
+    @abc.abstractmethod
     def build_tracker_id(self) -> str | None:
         """A string that uniquely identifies this requirement to the build tracker.
 
@@ -49,7 +50,8 @@ class AbstractDistribution(metaclass=abc.ABCMeta):
     def prepare_distribution_metadata(
         self,
         build_env_installer: BuildEnvironmentInstaller,
-        build_isolation: bool,
+        build_isolation: BuildIsolationMode,
         check_build_deps: bool,
+        allow_editables: bool,
     ) -> None:
         raise NotImplementedError()

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

@@ -6,7 +6,7 @@ from pip._internal.distributions.base import AbstractDistribution
 from pip._internal.metadata import BaseDistribution
 
 if TYPE_CHECKING:
-    from pip._internal.build_env import BuildEnvironmentInstaller
+    from pip._internal.build_env import BuildEnvironmentInstaller, BuildIsolationMode
 
 
 class InstalledDistribution(AbstractDistribution):
@@ -27,7 +27,8 @@ class InstalledDistribution(AbstractDistribution):
     def prepare_distribution_metadata(
         self,
         build_env_installer: BuildEnvironmentInstaller,
-        build_isolation: bool,
+        build_isolation: BuildIsolationMode,
         check_build_deps: bool,
+        allow_editables: bool,
     ) -> None:
         pass

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

@@ -4,7 +4,12 @@ import logging
 from collections.abc import Iterable
 from typing import TYPE_CHECKING
 
-from pip._internal.build_env import BuildEnvironment
+from pip._internal.build_env import (
+    BuildIsolationMode,
+    NoOpBuildEnvironment,
+    VenvBuildEnvironment,
+    VirtualBuildEnvironment,
+)
 from pip._internal.distributions.base import AbstractDistribution
 from pip._internal.exceptions import InstallationError
 from pip._internal.metadata import BaseDistribution
@@ -35,24 +40,28 @@ class SourceDistribution(AbstractDistribution):
     def prepare_distribution_metadata(
         self,
         build_env_installer: BuildEnvironmentInstaller,
-        build_isolation: bool,
+        build_isolation: BuildIsolationMode,
         check_build_deps: bool,
+        allow_editables: bool,
     ) -> None:
-        # Load pyproject.toml
+        # Load pyproject.toml and set up backend environment
         self.req.load_pyproject_toml()
+        self._prepare_build_env(build_isolation, build_env_installer)
 
         # Set up the build isolation, if this requirement should be isolated
-        if build_isolation:
+        if build_isolation != "off":
             # Setup an isolated environment and install the build backend static
             # requirements in it.
-            self._prepare_build_backend(build_env_installer)
+            self._prepare_build_backend()
             # Check that the build backend supports PEP 660. This cannot be done
             # earlier because we need to setup the build backend to verify it
             # supports build_editable, nor can it be done later, because we want
             # to avoid installing build requirements needlessly.
             self.req.editable_sanity_check()
             # Install the dynamic build requirements.
-            self._install_build_reqs(build_env_installer)
+            self._install_build_reqs(
+                build_env_installer, allow_editables=allow_editables
+            )
         else:
             # When not using build isolation, we still need to check that
             # the build backend supports PEP 660.
@@ -68,20 +77,33 @@ class SourceDistribution(AbstractDistribution):
                 self._raise_conflicts("the backend dependencies", conflicting)
             if missing:
                 self._raise_missing_reqs(missing)
-        self.req.prepare_metadata()
+        self.req.prepare_metadata(allow_editables)
 
-    def _prepare_build_backend(
-        self, build_env_installer: BuildEnvironmentInstaller
+    def _prepare_build_env(
+        self,
+        build_isolation: BuildIsolationMode,
+        build_env_installer: BuildEnvironmentInstaller,
     ) -> None:
-        # Isolate in a BuildEnvironment and install the build-time
-        # requirements.
+        if build_isolation == "virtual":
+            self.req.build_env = VirtualBuildEnvironment(build_env_installer)
+        elif build_isolation == "venv":
+            self.req.build_env = VenvBuildEnvironment(build_env_installer)
+
+        self.req.configure_backend(self.req.build_env.python_executable)
+
+    def _prepare_build_backend(self) -> None:
+        # Install the pyproject.toml declared build-time requirements.
         pyproject_requires = self.req.pyproject_requires
         assert pyproject_requires is not None
+        assert not isinstance(self.req.build_env, NoOpBuildEnvironment)
 
-        self.req.build_env = BuildEnvironment(build_env_installer)
-        self.req.build_env.install_requirements(
-            pyproject_requires, "overlay", kind="build dependencies", for_req=self.req
-        )
+        with self.req.build_env:
+            self.req.build_env.install_requirements(
+                pyproject_requires,
+                "overlay",
+                kind="build dependencies",
+                for_req=self.req,
+            )
         conflicting, missing = self.req.build_env.check_requirements(
             self.req.requirements_to_check
         )
@@ -117,14 +139,16 @@ class SourceDistribution(AbstractDistribution):
                 return backend.get_requires_for_build_editable()
 
     def _install_build_reqs(
-        self, build_env_installer: BuildEnvironmentInstaller
+        self,
+        build_env_installer: BuildEnvironmentInstaller,
+        allow_editables: bool,
     ) -> None:
         # Install any extra build dependencies that the backend requests.
         # This must be done in a second pass, as the pyproject.toml
         # dependencies must be installed before we can call the backend.
         if (
             self.req.editable
-            and self.req.permit_editable_wheels
+            and allow_editables
             and self.req.supports_pyproject_editable
         ):
             build_reqs = self._get_build_requires_editable()
@@ -133,9 +157,10 @@ class SourceDistribution(AbstractDistribution):
         conflicting, missing = self.req.build_env.check_requirements(build_reqs)
         if conflicting:
             self._raise_conflicts("the backend dependencies", conflicting)
-        self.req.build_env.install_requirements(
-            missing, "normal", kind="backend dependencies", for_req=self.req
-        )
+        with self.req.build_env:
+            self.req.build_env.install_requirements(
+                missing, "normal", kind="backend dependencies", for_req=self.req
+            )
 
     def _raise_conflicts(
         self, conflicting_with: str, conflicting_reqs: set[tuple[str, str]]

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

@@ -12,7 +12,7 @@ from pip._internal.metadata import (
 )
 
 if TYPE_CHECKING:
-    from pip._internal.build_env import BuildEnvironmentInstaller
+    from pip._internal.build_env import BuildEnvironmentInstaller, BuildIsolationMode
 
 
 class WheelDistribution(AbstractDistribution):
@@ -38,7 +38,8 @@ class WheelDistribution(AbstractDistribution):
     def prepare_distribution_metadata(
         self,
         build_env_installer: BuildEnvironmentInstaller,
-        build_isolation: bool,
+        build_isolation: BuildIsolationMode,
         check_build_deps: bool,
+        allow_editables: bool,
     ) -> None:
         pass

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

@@ -11,6 +11,7 @@ import configparser
 import contextlib
 import locale
 import logging
+import os
 import pathlib
 import re
 import sys
@@ -28,6 +29,7 @@ from pip._vendor.rich.text import Text
 if TYPE_CHECKING:
     from hashlib import _Hash
 
+    from pip._vendor import urllib3
     from pip._vendor.requests.models import PreparedRequest, Request, Response
 
     from pip._internal.metadata import BaseDistribution
@@ -337,6 +339,119 @@ class NetworkConnectionError(PipError):
         return str(self.error_msg)
 
 
+class ConnectionFailedError(DiagnosticPipError):
+    reference = "connection-failed"
+
+    def __init__(self, url: str, host: str, error: Exception) -> None:
+        from http.client import RemoteDisconnected
+
+        from pip._vendor.urllib3.exceptions import (
+            NameResolutionError,
+            NewConnectionError,
+            ProtocolError,
+        )
+
+        details = str(error)
+        if isinstance(error, NameResolutionError):
+            parts = details.split("Failed to resolve ", maxsplit=1)
+            if len(parts) == 2:
+                details = "Failed to resolve IP address for " + parts[1]
+        elif isinstance(error, NewConnectionError):
+            parts = details.split("Failed to establish a new connection: ", maxsplit=1)
+            if len(parts) == 2:
+                _, details = parts
+        elif isinstance(error, ProtocolError):
+            try:
+                reason = error.args[1]
+            except IndexError:
+                pass
+            else:
+                if isinstance(reason, (RemoteDisconnected, ConnectionResetError)):
+                    details = (
+                        "the connection was closed without a reply from the server."
+                    )
+
+        super().__init__(
+            message=(
+                f"Failed to connect to [magenta]{escape(host)}[/] while fetching "
+                f"{escape(url)}"
+            ),
+            context=Text(details),
+            hint_stmt=(
+                "Are you connected to the Internet? If so, check whether your system "
+                f"can connect to [magenta]{escape(host)}[/] before trying again. "
+                "There may be a firewall or proxy that's preventing the connection."
+            ),
+        )
+
+
+class ConnectionTimeoutError(DiagnosticPipError):
+    reference = "connection-timeout"
+
+    def __init__(
+        self,
+        url: str,
+        host: str,
+        *,
+        kind: Literal["connect", "read"],
+        timeout: float,
+    ) -> None:
+        context = Text.assemble(
+            (host, "magenta"), f" didn't respond within {timeout} seconds"
+        )
+        if kind == "connect":
+            context.append(" (while establishing a connection)")
+        super().__init__(
+            message=f"Unable to fetch {escape(url)}",
+            context=context,
+            hint_stmt=(
+                "This is probably a temporary issue with the remote server or the "
+                "network connection. If this error persists, check the network "
+                "configuration. There may be a firewall or proxy that's preventing "
+                "the connection."
+            ),
+        )
+
+
+class SSLMissingError(DiagnosticPipError):
+    reference = "ssl-missing"
+
+    def __init__(self, url: str) -> None:
+        super().__init__(
+            message=f"Failed to establish a secure connection for {escape(url)}",
+            context="The 'ssl' module is unavailable but required for HTTPS URLs",
+            hint_stmt=None,
+        )
+
+
+class SSLVerificationError(DiagnosticPipError):
+    reference = "ssl-verification-failed"
+
+    def __init__(self, url: str, host: str, error: urllib3.exceptions.SSLError) -> None:
+        message = (
+            "Failed to establish a secure connection to "
+            f"[magenta]{escape(host)}[/] while fetching {escape(url)}"
+        )
+        hint = "You may need to use --cert or check your proxy/firewall configuration"
+        super().__init__(message=message, context=Text(str(error)), hint_stmt=hint)
+
+
+class ProxyConnectionError(DiagnosticPipError):
+    reference = "proxy-connection-failed"
+
+    def __init__(
+        self, url: str, proxy: str, error: urllib3.exceptions.ProxyError
+    ) -> None:
+        super().__init__(
+            message=(
+                "Failed to connect to proxy "
+                f"[magenta]{escape(proxy)}[/] while fetching {escape(url)}"
+            ),
+            context=Text(str(error)),
+            hint_stmt="This is likely a proxy configuration issue.",
+        )
+
+
 class InvalidWheelFilename(InstallationError):
     """Invalid wheel filename."""
 
@@ -379,6 +494,23 @@ class MetadataInconsistent(InstallationError):
         )
 
 
+class SidecarMetadataInconsistent(MetadataInconsistent):
+    """The wheel's METADATA disagrees with its PEP 658 ``.metadata`` file.
+
+    Raised after the wheel has been downloaded and hash-verified, when a
+    resolver-affecting field in the wheel's embedded ``METADATA`` does not
+    match the value taken from the remote ``.metadata`` sidecar that drove
+    resolution. ``f_val`` is the sidecar value, ``m_val`` is the wheel value.
+    """
+
+    def __str__(self) -> str:
+        return (
+            f"Requested {self.ireq} has inconsistent {self.field} between "
+            f"its PEP 658 .metadata file and the wheel's METADATA: "
+            f"sidecar has {self.f_val!r}, wheel has {self.m_val!r}"
+        )
+
+
 class MetadataInvalid(InstallationError):
     """Metadata is invalid."""
 
@@ -969,3 +1101,45 @@ class BuildDependencyInstallError(DiagnosticPipError):
         super().__init__(
             message=message, context=context, hint_stmt=None, note_stmt=note
         )
+
+
+class VenvImportError(DiagnosticPipError):
+    """Raised when 'venv' can't be imported."""
+
+    reference = "venv-import-error"
+
+    def __init__(self) -> None:
+        if sys.platform != "linux":
+            hint_stmt = None
+        else:
+            hint_stmt = (
+                "If this is an OS-provided Python, it's likely that your OS "
+                "package maintainers have split Python's standard library across "
+                "multiple OS packages."
+            )
+        super().__init__(
+            message="Cannot import the 'venv' module of the Python standard library",
+            context=(
+                "This is a symptom of a broken/modified Python, which cannot be used "
+                "with pip."
+            ),
+            note_stmt="This is an issue with the Python installation itself, not pip.",
+            hint_stmt=hint_stmt,
+        )
+
+
+class VenvCreationError(DiagnosticPipError):
+    """Raised when a virtual environment can't be created."""
+
+    reference = "venv-creation-error"
+
+    def __init__(self, context: str) -> None:
+        if os.name == "nt":
+            hint = "This may be caused by running antivirus software."
+        else:
+            hint = None
+        super().__init__(
+            message="Cannot create a virtual environment",
+            context=Text(context),
+            hint_stmt=hint,
+        )

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

@@ -12,21 +12,27 @@ import json
 import logging
 import os
 import urllib.parse
-from collections.abc import Iterable, MutableMapping, Sequence
+from collections.abc import Callable, Iterable, MutableMapping, Sequence
 from dataclasses import dataclass
 from html.parser import HTMLParser
 from optparse import Values
 from typing import (
-    Callable,
     NamedTuple,
     Protocol,
 )
 
-from pip._vendor import requests
+from pip._vendor.packaging.utils import canonicalize_name
 from pip._vendor.requests import Response
-from pip._vendor.requests.exceptions import RetryError, SSLError
-
-from pip._internal.exceptions import NetworkConnectionError
+from pip._vendor.requests.exceptions import RetryError
+
+from pip._internal.exceptions import (
+    ConnectionFailedError,
+    ConnectionTimeoutError,
+    NetworkConnectionError,
+    ProxyConnectionError,
+    SSLMissingError,
+    SSLVerificationError,
+)
 from pip._internal.models.link import Link
 from pip._internal.models.search_scope import SearchScope
 from pip._internal.network.session import PipSession
@@ -80,7 +86,7 @@ def _ensure_api_header(response: Response) -> None:
     ):
         return
 
-    raise _NotAPIContent(content_type, response.request.method)
+    raise _NotAPIContent(content_type, response.request.method)  # type: ignore[arg-type]
 
 
 class _NotHTTP(Exception):
@@ -105,7 +111,11 @@ def _ensure_api_response(url: str, session: PipSession) -> None:
     _ensure_api_header(resp)
 
 
-def _get_simple_response(url: str, session: PipSession) -> Response:
+def _get_simple_response(
+    url: str,
+    session: PipSession,
+    force_revalidate: bool = False,
+) -> Response:
     """Access an Simple API response with GET, and return the response.
 
     This consists of three parts:
@@ -123,32 +133,24 @@ def _get_simple_response(url: str, session: PipSession) -> Response:
 
     logger.debug("Getting page %s", redact_auth_from_url(url))
 
-    resp = session.get(
-        url,
-        headers={
-            "Accept": ", ".join(
-                [
-                    "application/vnd.pypi.simple.v1+json",
-                    "application/vnd.pypi.simple.v1+html; q=0.1",
-                    "text/html; q=0.01",
-                ]
-            ),
-            # We don't want to blindly returned cached data for
-            # /simple/, because authors generally expecting that
-            # twine upload && pip install will function, but if
-            # they've done a pip install in the last ~10 minutes
-            # it won't. Thus by setting this to zero we will not
-            # blindly use any cached data, however the benefit of
-            # using max-age=0 instead of no-cache, is that we will
-            # still support conditional requests, so we will still
-            # minimize traffic sent in cases where the page hasn't
-            # changed at all, we will just always incur the round
-            # trip for the conditional GET now instead of only
-            # once per 10 minutes.
-            # For more information, please see pypa/pip#5670.
-            "Cache-Control": "max-age=0",
-        },
-    )
+    headers = {
+        "Accept": ", ".join(
+            [
+                "application/vnd.pypi.simple.v1+json",
+                "application/vnd.pypi.simple.v1+html; q=0.1",
+                "text/html; q=0.01",
+            ]
+        ),
+    }
+
+    if force_revalidate:
+        # Using max-age=0 rather than no-cache still supports conditional
+        # requests, minimizing traffic when the page hasn't changed.
+        # See pypa/pip#5670.
+        logger.debug("Refreshing package index response.")
+        headers["Cache-Control"] = "max-age=0"
+
+    resp = session.get(url, headers=headers)
     raise_for_status(resp)
 
     # The check for archives above only works if the url ends with
@@ -316,7 +318,12 @@ def _make_index_content(
     )
 
 
-def _get_index_content(link: Link, *, session: PipSession) -> IndexContent | None:
+def _get_index_content(
+    link: Link,
+    *,
+    session: PipSession,
+    force_revalidate: bool = False,
+) -> IndexContent | None:
     url = link.url.split("#", 1)[0]
 
     # Check for VCS schemes that do not support lookup as web pages.
@@ -343,7 +350,9 @@ def _get_index_content(link: Link, *, session: PipSession) -> IndexContent | Non
         logger.debug(" file: URL is directory, getting %s", url)
 
     try:
-        resp = _get_simple_response(url, session=session)
+        resp = _get_simple_response(
+            url, session=session, force_revalidate=force_revalidate
+        )
     except _NotHTTP:
         logger.warning(
             "Skipping page %s because it looks like an archive, and cannot "
@@ -359,18 +368,17 @@ def _get_index_content(link: Link, *, session: PipSession) -> IndexContent | Non
             exc.request_desc,
             exc.content_type,
         )
-    except NetworkConnectionError as exc:
-        _handle_get_simple_fail(link, exc)
-    except RetryError as exc:
+    except (RetryError, NetworkConnectionError) as exc:
         _handle_get_simple_fail(link, exc)
-    except SSLError as exc:
-        reason = "There was a problem confirming the ssl certificate: "
-        reason += str(exc)
+    except (SSLVerificationError, SSLMissingError) as exc:
+        reason = f"There was a problem confirming the ssl certificate: {exc.context}"
         _handle_get_simple_fail(link, reason, meth=logger.info)
-    except requests.ConnectionError as exc:
-        _handle_get_simple_fail(link, f"connection error: {exc}")
-    except requests.Timeout:
-        _handle_get_simple_fail(link, "timed out")
+    except ConnectionFailedError as exc:
+        _handle_get_simple_fail(link, f"connection error: {exc.context}")
+    except ProxyConnectionError as exc:
+        _handle_get_simple_fail(link, f"proxy connection error: {exc.context}")
+    except ConnectionTimeoutError as exc:
+        _handle_get_simple_fail(link, str(exc.context))
     else:
         return _make_index_content(resp, cache_link_parsing=link.cache_link_parsing)
     return None
@@ -435,11 +443,25 @@ class LinkCollector:
     def find_links(self) -> list[str]:
         return self.search_scope.find_links
 
-    def fetch_response(self, location: Link) -> IndexContent | None:
+    def fetch_response(
+        self, location: Link, package_name: str | None = None
+    ) -> IndexContent | None:
         """
         Fetch an HTML page containing package links.
         """
-        return _get_index_content(location, session=self.session)
+        # By default we may return cached /simple/ responses. Users can force
+        # revalidation to ensure newly uploaded distributions become visible
+        # immediately after publication. See pypa/pip#5670.
+        force_revalidate = self.session.refresh_package
+        should_force_revalidate = ":all:" in force_revalidate or (
+            package_name is not None
+            and canonicalize_name(package_name) in force_revalidate
+        )
+        return _get_index_content(
+            location,
+            session=self.session,
+            force_revalidate=should_force_revalidate,
+        )
 
     def collect_sources(
         self,