Voice et bot modif

venv/lib/python3.12/site-packages/pip/_internal/resolution/legacy/resolver.py

@@ -10,14 +10,14 @@ for sub-dependencies
     a. "first found, wins" (where the order is breadth first)
 """
 
-from __future__ import annotations
+# The following comment should be removed at some point in the future.
+# mypy: strict-optional=False
 
 import logging
 import sys
 from collections import defaultdict
-from collections.abc import Iterable
 from itertools import chain
-from typing import Optional
+from typing import DefaultDict, Iterable, List, Optional, Set, Tuple
 
 from pip._vendor.packaging import specifiers
 from pip._vendor.packaging.requirements import Requirement
@@ -52,12 +52,12 @@ from pip._internal.utils.packaging import check_requires_python
 
 logger = logging.getLogger(__name__)
 
-DiscoveredDependencies = defaultdict[Optional[str], list[InstallRequirement]]
+DiscoveredDependencies = DefaultDict[str, List[InstallRequirement]]
 
 
 def _check_dist_requires_python(
     dist: BaseDistribution,
-    version_info: tuple[int, int, int],
+    version_info: Tuple[int, int, int],
     ignore_requires_python: bool = False,
 ) -> None:
     """
@@ -104,8 +104,9 @@ def _check_dist_requires_python(
         return
 
     raise UnsupportedPythonVersion(
-        f"Package {dist.raw_name!r} requires a different Python: "
-        f"{version} not in {requires_python!r}"
+        "Package {!r} requires a different Python: {} not in {!r}".format(
+            dist.raw_name, version, requires_python
+        )
     )
 
 
@@ -120,7 +121,7 @@ class Resolver(BaseResolver):
         self,
         preparer: RequirementPreparer,
         finder: PackageFinder,
-        wheel_cache: WheelCache | None,
+        wheel_cache: Optional[WheelCache],
         make_install_req: InstallRequirementProvider,
         use_user_site: bool,
         ignore_dependencies: bool,
@@ -128,7 +129,7 @@ class Resolver(BaseResolver):
         ignore_requires_python: bool,
         force_reinstall: bool,
         upgrade_strategy: str,
-        py_version_info: tuple[int, ...] | None = None,
+        py_version_info: Optional[Tuple[int, ...]] = None,
     ) -> None:
         super().__init__()
         assert upgrade_strategy in self._allowed_strategies
@@ -155,7 +156,7 @@ class Resolver(BaseResolver):
         self._discovered_dependencies: DiscoveredDependencies = defaultdict(list)
 
     def resolve(
-        self, root_reqs: list[InstallRequirement], check_supported_wheels: bool
+        self, root_reqs: List[InstallRequirement], check_supported_wheels: bool
     ) -> RequirementSet:
         """Resolve what operations need to be done
 
@@ -177,7 +178,7 @@ class Resolver(BaseResolver):
         # exceptions cannot be checked ahead of time, because
         # _populate_link() needs to be called before we can make decisions
         # based on link type.
-        discovered_reqs: list[InstallRequirement] = []
+        discovered_reqs: List[InstallRequirement] = []
         hash_errors = HashErrors()
         for req in chain(requirement_set.all_requirements, discovered_reqs):
             try:
@@ -195,9 +196,9 @@ class Resolver(BaseResolver):
         self,
         requirement_set: RequirementSet,
         install_req: InstallRequirement,
-        parent_req_name: str | None = None,
-        extras_requested: Iterable[str] | None = None,
-    ) -> tuple[list[InstallRequirement], InstallRequirement | None]:
+        parent_req_name: Optional[str] = None,
+        extras_requested: Optional[Iterable[str]] = None,
+    ) -> Tuple[List[InstallRequirement], Optional[InstallRequirement]]:
         """Add install_req as a requirement to install.
 
         :param parent_req_name: The name of the requirement that needed this
@@ -245,9 +246,9 @@ class Resolver(BaseResolver):
             return [install_req], None
 
         try:
-            existing_req: InstallRequirement | None = requirement_set.get_requirement(
-                install_req.name
-            )
+            existing_req: Optional[
+                InstallRequirement
+            ] = requirement_set.get_requirement(install_req.name)
         except KeyError:
             existing_req = None
 
@@ -262,8 +263,9 @@ class Resolver(BaseResolver):
         )
         if has_conflicting_requirement:
             raise InstallationError(
-                f"Double requirement given: {install_req} "
-                f"(already in {existing_req}, name={install_req.name!r})"
+                "Double requirement given: {} (already in {}, name={!r})".format(
+                    install_req, existing_req, install_req.name
+                )
             )
 
         # When no existing requirement exists, add the requirement as a
@@ -321,12 +323,13 @@ class Resolver(BaseResolver):
         """
         # Don't uninstall the conflict if doing a user install and the
         # conflict is not a user install.
-        assert req.satisfied_by is not None
         if not self.use_user_site or req.satisfied_by.in_usersite:
             req.should_reinstall = True
         req.satisfied_by = None
 
-    def _check_skip_installed(self, req_to_install: InstallRequirement) -> str | None:
+    def _check_skip_installed(
+        self, req_to_install: InstallRequirement
+    ) -> Optional[str]:
         """Check if req_to_install should be skipped.
 
         This will check if the req is installed, and whether we should upgrade
@@ -378,7 +381,7 @@ class Resolver(BaseResolver):
         self._set_req_to_reinstall(req_to_install)
         return None
 
-    def _find_requirement_link(self, req: InstallRequirement) -> Link | None:
+    def _find_requirement_link(self, req: InstallRequirement) -> Optional[Link]:
         upgrade = self._is_upgrade_allowed(req)
         best_candidate = self.finder.find_requirement(req, upgrade)
         if not best_candidate:
@@ -418,8 +421,6 @@ class Resolver(BaseResolver):
 
         if self.wheel_cache is None or self.preparer.require_hashes:
             return
-
-        assert req.link is not None, "_find_requirement_link unexpectedly returned None"
         cache_entry = self.wheel_cache.get_cache_entry(
             link=req.link,
             package_name=req.name,
@@ -489,7 +490,7 @@ class Resolver(BaseResolver):
         self,
         requirement_set: RequirementSet,
         req_to_install: InstallRequirement,
-    ) -> list[InstallRequirement]:
+    ) -> List[InstallRequirement]:
         """Prepare a single requirements file.
 
         :return: A list of additional InstallRequirements to also install.
@@ -512,7 +513,7 @@ class Resolver(BaseResolver):
             ignore_requires_python=self.ignore_requires_python,
         )
 
-        more_reqs: list[InstallRequirement] = []
+        more_reqs: List[InstallRequirement] = []
 
         def add_req(subreq: Requirement, extras_requested: Iterable[str]) -> None:
             # This idiosyncratically converts the Requirement to str and let
@@ -533,7 +534,6 @@ class Resolver(BaseResolver):
         with indent_log():
             # We add req_to_install before its dependencies, so that we
             # can refer to it when adding dependencies.
-            assert req_to_install.name is not None
             if not requirement_set.has_requirement(req_to_install.name):
                 # 'unnamed' requirements will get added here
                 # 'unnamed' requirements can only come from being directly
@@ -570,7 +570,7 @@ class Resolver(BaseResolver):
 
     def get_installation_order(
         self, req_set: RequirementSet
-    ) -> list[InstallRequirement]:
+    ) -> List[InstallRequirement]:
         """Create the installation order.
 
         The installation order is topological - requirements are installed
@@ -581,7 +581,7 @@ class Resolver(BaseResolver):
         # installs the user specified things in the order given, except when
         # dependencies must come earlier to achieve topological order.
         order = []
-        ordered_reqs: set[InstallRequirement] = set()
+        ordered_reqs: Set[InstallRequirement] = set()
 
         def schedule(req: InstallRequirement) -> None:
             if req.satisfied_by or req in ordered_reqs: