shortcutxl 0.3.76 → 0.3.78

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

@@ -18,12 +18,11 @@ from collections.abc import Collection, Mapping
 from dataclasses import dataclass
 
 from pip._vendor.packaging import pylock
-from pip._vendor.packaging.markers import Marker
+from pip._vendor.packaging.markers import InvalidMarker, Marker
 from pip._vendor.packaging.requirements import InvalidRequirement, Requirement
 from pip._vendor.packaging.utils import parse_sdist_filename, parse_wheel_filename
 
 from pip._internal.exceptions import InstallationError
-from pip._internal.models.format_control import FormatControl
 from pip._internal.models.index import PyPI, TestPyPI
 from pip._internal.models.link import Link
 from pip._internal.models.wheel import Wheel
@@ -55,7 +54,7 @@ logger = logging.getLogger(__name__)
 operators = ("~=", "==", "!=", "<=", ">=", "<", ">", "===")
 
 
-def _strip_extras(path: str) -> tuple[str, str | None]:
+def strip_extras(path: str) -> tuple[str, set[str]]:
     m = re.match(r"^(.+)(\[[^\]]+\])$", path)
     extras = None
     if m:
@@ -64,10 +63,10 @@ def _strip_extras(path: str) -> tuple[str, str | None]:
     else:
         path_no_extras = path
 
-    return path_no_extras, extras
+    return path_no_extras, _convert_extras(extras)
 
 
-def convert_extras(extras: str | None) -> set[str]:
+def _convert_extras(extras: str | None) -> set[str]:
     if not extras:
         return set()
     return get_requirement("placeholder" + extras.lower()).extras
@@ -120,7 +119,7 @@ def _parse_pip_syntax_editable(editable_req: str) -> tuple[str | None, str, set[
     url = editable_req
 
     # If a file path is specified with extras, strip off the extras.
-    url_no_extras, extras = _strip_extras(url)
+    url_no_extras, extras = strip_extras(url)
 
     if os.path.isdir(url_no_extras):
         # Treating it as code that has already been checked out
@@ -128,14 +127,7 @@ def _parse_pip_syntax_editable(editable_req: str) -> tuple[str | None, str, set[
 
     if url_no_extras.lower().startswith("file:"):
         package_name = Link(url_no_extras).egg_fragment
-        if extras:
-            return (
-                package_name,
-                url_no_extras,
-                get_requirement("placeholder" + extras.lower()).extras,
-            )
-        else:
-            return package_name, url_no_extras, set()
+        return (package_name, url_no_extras, extras)
 
     for version_control in vcs:
         if url.lower().startswith(f"{version_control}:"):
@@ -267,7 +259,6 @@ def install_req_from_editable(
     hash_options: dict[str, list[str]] | None = None,
     constraint: bool = False,
     user_supplied: bool = False,
-    permit_editable_wheels: bool = False,
     config_settings: dict[str, str | list[str]] | None = None,
 ) -> InstallRequirement:
     if constraint:
@@ -279,7 +270,6 @@ def install_req_from_editable(
         comes_from=comes_from,
         user_supplied=user_supplied,
         editable=True,
-        permit_editable_wheels=permit_editable_wheels,
         link=parts.link,
         constraint=constraint,
         isolated=isolated,
@@ -353,19 +343,22 @@ def parse_req_from_line(name: str, line_source: str | None) -> RequirementParts:
         if not markers_as_string:
             markers = None
         else:
-            markers = Marker(markers_as_string)
+            try:
+                markers = Marker(markers_as_string)
+            except InvalidMarker as exc:
+                raise InstallationError(f"Invalid requirement: {name.strip()!r}: {exc}")
     else:
         markers = None
     name = name.strip()
     req_as_string = None
     path = os.path.normpath(os.path.abspath(name))
     link = None
-    extras_as_string = None
 
     if is_url(name):
         link = Link(name)
+        extras: set[str] = set()
     else:
-        p, extras_as_string = _strip_extras(path)
+        p, extras = strip_extras(path)
         url = _get_url_from_path(p, name)
         if url is not None:
             link = Link(url)
@@ -388,8 +381,6 @@ def parse_req_from_line(name: str, line_source: str | None) -> RequirementParts:
     else:
         req_as_string = name
 
-    extras = convert_extras(extras_as_string)
-
     def with_source(text: str) -> str:
         if not line_source:
             return text
@@ -558,7 +549,6 @@ def install_req_drop_extras(ireq: InstallRequirement) -> InstallRequirement:
         extras=[],
         config_settings=ireq.config_settings,
         user_supplied=ireq.user_supplied,
-        permit_editable_wheels=ireq.permit_editable_wheels,
     )
 
 
@@ -594,65 +584,57 @@ def install_req_from_pylock_package(
         | pylock.PackageWheel
     ),
     pylock_path_or_url: str,
-    format_control: FormatControl,
     user_supplied: bool,
-) -> InstallRequirement:
-    pass
+) -> tuple[InstallRequirement, Link | None]:
+    """Construct an InstallRequirement from a pylock package and artifact.
+
+    If the artifact is a Sdist or Wheel, also return a locked Link which
+    is meant to override candidates from indexes or --find-links.
+    """
     # TODO: validate file size
     if isinstance(package_dist, pylock.PackageVcs):
-        return InstallRequirement(
-            req=Requirement(
-                f"{package.name} @ "
-                f"{package_vcs_requirement_url(pylock_path_or_url, package_dist)}"
+        req_url = package_vcs_requirement_url(pylock_path_or_url, package_dist)
+        return (
+            InstallRequirement(
+                req=Requirement(f"{package.name} @ {req_url}"),
+                comes_from=pylock_path_or_url,
+                user_supplied=user_supplied,
             ),
-            comes_from=pylock_path_or_url,
-            user_supplied=user_supplied,
+            None,
         )
     elif isinstance(package_dist, pylock.PackageArchive):
-        return InstallRequirement(
-            req=Requirement(
-                f"{package.name} @ "
-                f"{package_archive_requirement_url(pylock_path_or_url, package_dist)}"
+        req_url = package_archive_requirement_url(pylock_path_or_url, package_dist)
+        return (
+            InstallRequirement(
+                req=Requirement(f"{package.name} @ {req_url}"),
+                comes_from=pylock_path_or_url,
+                hash_options=_pylock_hashes_to_hash_options(package_dist.hashes),
+                user_supplied=user_supplied,
             ),
-            comes_from=pylock_path_or_url,
-            hash_options=_pylock_hashes_to_hash_options(package_dist.hashes),
-            user_supplied=user_supplied,
+            None,
         )
     elif isinstance(package_dist, pylock.PackageDirectory):
-        req = package_directory_requirement_url(pylock_path_or_url, package_dist)
+        req_url = package_directory_requirement_url(pylock_path_or_url, package_dist)
         if package_dist.editable:
-            return install_req_from_editable(
-                req,
-                comes_from=pylock_path_or_url,
-                user_supplied=user_supplied,
+            return (
+                install_req_from_editable(
+                    req_url,
+                    comes_from=pylock_path_or_url,
+                    user_supplied=user_supplied,
+                ),
+                None,
             )
         else:
-            return install_req_from_line(
-                req,
-                comes_from=pylock_path_or_url,
-                user_supplied=user_supplied,
+            return (
+                install_req_from_line(
+                    req_url,
+                    comes_from=pylock_path_or_url,
+                    user_supplied=user_supplied,
+                ),
+                None,
             )
     else:
         # wheel or sdist
-        allowed_formats = format_control.get_allowed_formats(package.name)
-        if (
-            isinstance(package_dist, pylock.PackageSdist)
-            and "source" not in allowed_formats
-        ):
-            raise InstallationError(
-                f"source distributions are not permitted for package {package.name!r} "
-                f"and there is no compatible wheel for it in {pylock_path_or_url!r}"
-            )
-        if (
-            isinstance(package_dist, pylock.PackageWheel)
-            and "binary" not in allowed_formats
-        ):
-            if not package.sdist:
-                raise InstallationError(
-                    f"binaries are not permitted for package {package.name!r} and "
-                    f"there is no source distribution for it in {pylock_path_or_url!r}"
-                )
-            package_dist = package.sdist
         version = package.version
         if isinstance(package_dist, pylock.PackageWheel):
             if not version:
@@ -669,9 +651,12 @@ def install_req_from_pylock_package(
         ireq = InstallRequirement(
             req=Requirement(f"{package.name}=={version}"),
             comes_from=pylock_path_or_url,
-            locked_link=Link(requirement_url),
-            locked_version=version,
             hash_options=_pylock_hashes_to_hash_options(package_dist.hashes),
             user_supplied=user_supplied,
         )
-        return ireq
+        locked_link = Link(
+            requirement_url,
+            comes_from=pylock_path_or_url,
+            upload_time=package_dist.upload_time,
+        )
+        return ireq, locked_link

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

@@ -5,7 +5,6 @@ Requirements file parsing
 from __future__ import annotations
 
 import codecs
-import locale
 import logging
 import optparse
 import os
@@ -13,13 +12,12 @@ import re
 import shlex
 import sys
 import urllib.parse
-from collections.abc import Generator, Iterable
+from collections.abc import Callable, Generator, Iterable
 from dataclasses import dataclass
 from optparse import Values
 from typing import (
     TYPE_CHECKING,
     Any,
-    Callable,
     NoReturn,
 )
 
@@ -27,6 +25,7 @@ from pip._internal.cli import cmdoptions
 from pip._internal.exceptions import InstallationError, RequirementsFileParseError
 from pip._internal.models.release_control import ReleaseControl
 from pip._internal.models.search_scope import SearchScope
+from pip._internal.utils.compat import get_locale_encoding
 
 if TYPE_CHECKING:
     from pip._internal.index.package_finder import PackageFinder
@@ -59,6 +58,7 @@ SUPPORTED_OPTIONS: list[Callable[..., optparse.Option]] = [
     cmdoptions.only_binary,
     cmdoptions.prefer_binary,
     cmdoptions.require_hashes,
+    cmdoptions.no_require_hashes,
     cmdoptions.pre,
     cmdoptions.all_releases,
     cmdoptions.only_final,
@@ -225,6 +225,8 @@ def handle_option_line(
         # percolate options upward
         if opts.require_hashes:
             options.require_hashes = opts.require_hashes
+        if opts.no_require_hashes:
+            options.no_require_hashes = opts.no_require_hashes
         if opts.features_enabled:
             options.features_enabled.extend(
                 f for f in opts.features_enabled if f not in options.features_enabled
@@ -519,8 +521,6 @@ def join_lines(lines_enum: ReqFileLines) -> ReqFileLines:
         assert primary_line_number is not None
         yield primary_line_number, "".join(new_line)
 
-    # TODO: handle space after '\'.
-
 
 def ignore_comments(lines_enum: ReqFileLines) -> ReqFileLines:
     """
@@ -608,7 +608,7 @@ def _decode_req_file(data: bytes, url: str) -> str:
     try:
         return data.decode(DEFAULT_ENCODING)
     except UnicodeDecodeError:
-        locale_encoding = locale.getpreferredencoding(False) or sys.getdefaultencoding()
+        locale_encoding = get_locale_encoding() or sys.getdefaultencoding()
         logging.warning(
             "unable to decode data from %s with default encoding %s, "
             "falling back to encoding from locale: %s. "

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

@@ -34,7 +34,6 @@ from pip._internal.models.direct_url import DirectUrl
 from pip._internal.models.link import Link
 from pip._internal.operations.build.metadata import generate_metadata
 from pip._internal.operations.build.metadata_editable import generate_editable_metadata
-from pip._internal.operations.install.wheel import install_wheel
 from pip._internal.pyproject import load_pyproject_toml, make_pyproject_path
 from pip._internal.req.req_uninstall import UninstallPathSet
 from pip._internal.utils.deprecation import deprecated
@@ -80,16 +79,12 @@ class InstallRequirement:
         constraint: bool = False,
         extras: Collection[str] = (),
         user_supplied: bool = False,
-        permit_editable_wheels: bool = False,
-        locked_link: Link | None = None,
-        locked_version: Version | None = None,
     ) -> None:
         assert req is None or isinstance(req, Requirement), req
         self.req = req
         self.comes_from = comes_from
         self.constraint = constraint
         self.editable = editable
-        self.permit_editable_wheels = permit_editable_wheels
 
         # source_dir is the local directory where the linked requirement is
         # located, or unpacked. In case unpacking is needed, creating and
@@ -109,14 +104,6 @@ class InstallRequirement:
             link = Link(req.url)
         self.link = self.original_link = link
 
-        # locked_link is the link from the lock file that must be used.
-        # A locked link InstallRequirement behaves similarly as a regular requirement
-        # that would be searched in indexes, except its artifact URL is known
-        # in advance. Notably, and contrarily to direct URL requirements and direct URL
-        # constraints, they do not cause the recording of direct_url.json.
-        self.locked_link = locked_link
-        self.locked_version = locked_version
-
         # When this InstallRequirement is a wheel obtained from the cache of locally
         # built wheels, this is the source link corresponding to the cache entry, which
         # was used to download and build the cached wheel.
@@ -180,6 +167,8 @@ class InstallRequirement:
         self.requirements_to_check: list[str] = []
 
         # The PEP 517 backend we should use to build the project
+        self._pep517_backend_spec: str
+        self._pep517_backend_path: str | None
         self.pep517_backend: BuildBackendHookCaller | None = None
 
         # This requirement needs more preparation before it can be built
@@ -496,11 +485,21 @@ class InstallRequirement:
         requires, backend, check, backend_path = pyproject_toml_data
         self.requirements_to_check = check
         self.pyproject_requires = requires
+        self._pep517_backend_spec = backend
+        self._pep517_backend_path = backend_path
+
+    def configure_backend(self, python_executable: str) -> None:
+        """Set up the build backend hook caller.
+
+        This is done separately after pyproject.toml loading as the backend
+        need to be called with the build environment's Python executable,
+        which can vary."""
         self.pep517_backend = ConfiguredBuildBackendHookCaller(
             self,
             self.unpacked_source_directory,
-            backend,
-            backend_path=backend_path,
+            self._pep517_backend_spec,
+            backend_path=self._pep517_backend_path,
+            python_executable=python_executable,
         )
 
     def editable_sanity_check(self) -> None:
@@ -516,7 +515,7 @@ class InstallRequirement:
                 f"Consider using a build backend that supports PEP 660."
             )
 
-    def prepare_metadata(self) -> None:
+    def prepare_metadata(self, allow_editables: bool) -> None:
         """Ensure that project metadata is available.
 
         Under PEP 517 and PEP 660, call the backend hook to prepare the metadata.
@@ -526,11 +525,7 @@ class InstallRequirement:
         details = self.name or f"from {self.link}"
 
         assert self.pep517_backend is not None
-        if (
-            self.editable
-            and self.permit_editable_wheels
-            and self.supports_pyproject_editable
-        ):
+        if self.editable and allow_editables and self.supports_pyproject_editable:
             self.metadata_directory = generate_editable_metadata(
                 build_env=self.build_env,
                 backend=self.pep517_backend,
@@ -774,7 +769,15 @@ class InstallRequirement:
         warn_script_location: bool = True,
         use_user_site: bool = False,
         pycompile: bool = True,
+        script_executable: str | None = None,
     ) -> None:
+        # Lazy import to avoid transitively importing `_vendor.distlib.compat`
+        # which in turn imports `urllib.request` which is slow.
+        # During an actual installation, `urllib.request` will end up imported anyway,
+        # but `req.req_install` (this module) is also imported from commands that
+        # don't actually install anything (e.g. `pip freeze` or `pip show`).
+        from pip._internal.operations.install.wheel import install_wheel
+
         assert self.req is not None
         scheme = get_scheme(
             self.req.name,
@@ -797,6 +800,7 @@ class InstallRequirement:
             warn_script_location=warn_script_location,
             direct_url=self.download_info if self.is_direct else None,
             requested=self.user_supplied,
+            script_executable=script_executable,
         )
         self.install_succeeded = True
 

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

@@ -4,9 +4,9 @@ import functools
 import os
 import sys
 import sysconfig
-from collections.abc import Generator, Iterable
+from collections.abc import Callable, Generator, Iterable
 from importlib.util import cache_from_source
-from typing import Any, Callable
+from typing import Any
 
 from pip._internal.exceptions import LegacyDistutilsInstall, UninstallMissingRecord
 from pip._internal.locations import get_bin_prefix, get_bin_user
@@ -96,14 +96,19 @@ def compact(paths: Iterable[str]) -> set[str]:
 
     sep = os.path.sep
     short_paths: set[str] = set()
+    prefixes: set[str] = set()
+
     for path in sorted(paths, key=len):
-        should_skip = any(
-            path.startswith(shortpath.rstrip("*"))
-            and path[len(shortpath.rstrip("*").rstrip(sep))] == sep
-            for shortpath in short_paths
-        )
-        if not should_skip:
+        current = path[:-1] if path.endswith(sep + "*") else path
+        parent = current.rstrip(sep)
+        while parent:
+            if parent in prefixes:
+                break
+            next_parent = os.path.dirname(parent).rstrip(sep)
+            parent = "" if next_parent == parent else next_parent
+        else:
             short_paths.add(path)
+            prefixes.add(current.rstrip(sep))
     return short_paths
 
 

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

@@ -1,10 +1,10 @@
-from typing import Callable, Optional
+from collections.abc import Callable
 
 from pip._internal.req.req_install import InstallRequirement
 from pip._internal.req.req_set import RequirementSet
 
 InstallRequirementProvider = Callable[
-    [str, Optional[InstallRequirement]], InstallRequirement
+    [str, InstallRequirement | None], InstallRequirement
 ]
 
 

package/xll/python/Lib/site-packages/pip/_internal/resolution/legacy/resolver.py

@@ -17,7 +17,6 @@ import sys
 from collections import defaultdict
 from collections.abc import Iterable
 from itertools import chain
-from typing import Optional
 
 from pip._vendor.packaging import specifiers
 from pip._vendor.packaging.requirements import Requirement
@@ -52,7 +51,7 @@ from pip._internal.utils.packaging import check_requires_python
 
 logger = logging.getLogger(__name__)
 
-DiscoveredDependencies = defaultdict[Optional[str], list[InstallRequirement]]
+DiscoveredDependencies = defaultdict[str | None, list[InstallRequirement]]
 
 
 def _check_dist_requires_python(
@@ -124,6 +123,7 @@ class Resolver(BaseResolver):
         make_install_req: InstallRequirementProvider,
         use_user_site: bool,
         ignore_dependencies: bool,
+        only_dependencies: bool,  # unused, for compatibility with new resolver
         ignore_installed: bool,
         ignore_requires_python: bool,
         force_reinstall: bool,

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

@@ -12,7 +12,7 @@ from pip._internal.models.link import Link, links_equivalent
 from pip._internal.req.req_install import InstallRequirement
 from pip._internal.utils.hashes import Hashes
 
-CandidateLookup = tuple[Optional["Candidate"], Optional[InstallRequirement]]
+CandidateLookup = tuple[Optional["Candidate"], InstallRequirement | None]
 
 
 def format_name(project: NormalizedName, extras: frozenset[NormalizedName]) -> str:

package/xll/python/Lib/site-packages/pip/_internal/resolution/resolvelib/candidates.py

@@ -101,7 +101,6 @@ def make_install_req_from_editable(
         comes_from=template.comes_from,
         isolated=template.isolated,
         constraint=template.constraint,
-        permit_editable_wheels=template.permit_editable_wheels,
         hash_options=template.hash_options,
         config_settings=template.config_settings,
     )

package/xll/python/Lib/site-packages/pip/_internal/resolution/resolvelib/factory.py

@@ -4,10 +4,9 @@ import contextlib
 import copy
 import functools
 import logging
-from collections.abc import Iterable, Iterator, Mapping, Sequence
+from collections.abc import Callable, Iterable, Iterator, Mapping, Sequence
 from typing import (
     TYPE_CHECKING,
-    Callable,
     NamedTuple,
     Protocol,
     TypeVar,
@@ -19,6 +18,7 @@ from pip._vendor.packaging.specifiers import SpecifierSet
 from pip._vendor.packaging.utils import NormalizedName, canonicalize_name
 from pip._vendor.packaging.version import InvalidVersion, Version
 from pip._vendor.resolvelib import ResolutionImpossible
+from pip._vendor.rich.markup import escape
 
 from pip._internal.cache import CacheEntry, WheelCache
 from pip._internal.exceptions import (
@@ -32,7 +32,6 @@ from pip._internal.exceptions import (
 )
 from pip._internal.index.package_finder import PackageFinder
 from pip._internal.metadata import BaseDistribution, get_default_environment
-from pip._internal.models.candidate import InstallationCandidate
 from pip._internal.models.link import Link
 from pip._internal.models.wheel import Wheel
 from pip._internal.operations.prepare import RequirementPreparer
@@ -214,8 +213,8 @@ class Factory:
                 except (MetadataInconsistent, MetadataInvalid) as e:
                     logger.info(
                         "Discarding [blue underline]%s[/]: [yellow]%s[reset]",
-                        link,
-                        e,
+                        escape(str(link)),
+                        escape(str(e)),
                         extra={"markup": True},
                     )
                     self._build_failures[link] = e
@@ -235,39 +234,14 @@ class Factory:
                 except MetadataInconsistent as e:
                     logger.info(
                         "Discarding [blue underline]%s[/]: [yellow]%s[reset]",
-                        link,
-                        e,
+                        escape(str(link)),
+                        escape(str(e)),
                         extra={"markup": True},
                     )
                     self._build_failures[link] = e
                     return None
             return self._link_candidate_cache[link]
 
-    def _get_locked_installation_candidate(
-        self, ireqs: Sequence[InstallRequirement], name: str, specifier: SpecifierSet
-    ) -> InstallationCandidate | None:
-        locked_ireqs = [ireq for ireq in ireqs if ireq.locked_link]
-        if not locked_ireqs:
-            return None
-        if len(locked_ireqs) > 1:
-            raise InstallationError(
-                f"Multiple locks provided for package {name!r} in "
-                f"{', '.join(str(lir.comes_from) for lir in locked_ireqs)}"
-            )
-        locked_ireq = locked_ireqs[0]
-        assert locked_ireq.locked_link
-        assert locked_ireq.locked_version
-        if not specifier.contains(locked_ireq.locked_version):
-            raise InstallationError(
-                f"Locked version {locked_ireq.locked_version!s} "
-                f"for package {name!r} from {locked_ireq.comes_from!r} "
-                f"is not compatible with other requirements "
-                f"for the same package ({specifier!s})"
-            )
-        return InstallationCandidate(
-            name, str(locked_ireq.locked_version), locked_ireq.locked_link
-        )
-
     def _iter_found_candidates(
         self,
         ireqs: Sequence[InstallRequirement],
@@ -335,20 +309,12 @@ class Factory:
             return candidate
 
         def iter_index_candidate_infos() -> Iterator[IndexCandidateInfo]:
-            if locked_ican := self._get_locked_installation_candidate(
-                ireqs, name, specifier
-            ):
-                # Locked InstallRequirements must behave as if they would have
-                # been found on an index, except the link is already known, so we don't
-                # ask the finder for the best candidate in that case.
-                icans = [locked_ican]
-            else:
-                result = self._finder.find_best_candidate(
-                    project_name=name,
-                    specifier=specifier,
-                    hashes=hashes,
-                )
-                icans = result.applicable_candidates
+            result = self._finder.find_best_candidate(
+                project_name=name,
+                specifier=specifier,
+                hashes=hashes,
+            )
+            icans = result.applicable_candidates
 
             # PEP 592: Yanked releases are ignored unless the specifier
             # explicitly pins a version (via '==' or '===') that can be
@@ -757,6 +723,7 @@ class Factory:
 
         # Check if only final releases are allowed for this package
         version_type = "version"
+        allows_pre = None
         if self._finder.release_control is not None:
             allows_pre = self._finder.release_control.allows_prereleases(
                 canonicalize_name(req.project_name)
@@ -764,12 +731,32 @@ class Factory:
             if allows_pre is False:
                 version_type = "final version"
 
-        logger.critical(
-            "Could not find a %s that satisfies the requirement %s (from versions: %s)",
-            version_type,
-            req_disp,
-            ", ".join(versions) or "none",
-        )
+        if len(cands) == 1 and cands[0].locked:
+            # The package finder ensures that requirements from pylock files
+            # have exactly one candidate. So we can provide a specific error
+            # message in this case.
+            if cands[0].version.is_prerelease and allows_pre is False:
+                logger.critical(
+                    "A pre-release version %s is specified in a provided lock file "
+                    "for %s but only final versions are allowed",
+                    cands[0].version,
+                    cands[0].name,
+                )
+            else:
+                logger.critical(
+                    "The requirement %s is not compatible with "
+                    "version %s specified in a provided lock file",
+                    req_disp,
+                    ", ".join(versions),
+                )
+        else:
+            logger.critical(
+                "Could not find a %s that satisfies the requirement %s "
+                "(from versions: %s)",
+                version_type,
+                req_disp,
+                ", ".join(versions) or "none",
+            )
         if str(req) == "requirements.txt":
             logger.info(
                 "HINT: You are attempting to install a package literally "