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

pip/_internal/commands/list.py

@@ -1,11 +1,14 @@
+from __future__ import annotations
+
 import json
 import logging
+from collections.abc import Generator, Sequence
 from email.parser import Parser
 from optparse import Values
-from typing import TYPE_CHECKING, Generator, List, Optional, Sequence, Tuple, cast
+from typing import TYPE_CHECKING, cast
 
 from pip._vendor.packaging.utils import canonicalize_name
-from pip._vendor.packaging.version import Version
+from pip._vendor.packaging.version import InvalidVersion, Version
 
 from pip._internal.cli import cmdoptions
 from pip._internal.cli.index_command import IndexGroupCommand
@@ -140,8 +143,8 @@ class ListCommand(IndexGroupCommand):
             super().handle_pip_version_check(options)
 
     def _build_package_finder(
-        self, options: Values, session: "PipSession"
-    ) -> "PackageFinder":
+        self, options: Values, session: PipSession
+    ) -> PackageFinder:
         """
         Create a package finder appropriate to this list command.
         """
@@ -162,7 +165,7 @@ class ListCommand(IndexGroupCommand):
             selection_prefs=selection_prefs,
         )
 
-    def run(self, options: Values, args: List[str]) -> int:
+    def run(self, options: Values, args: list[str]) -> int:
         if options.outdated and options.uptodate:
             raise CommandError("Options --outdated and --uptodate cannot be combined.")
 
@@ -204,8 +207,8 @@ class ListCommand(IndexGroupCommand):
         return SUCCESS
 
     def get_outdated(
-        self, packages: "_ProcessedDists", options: Values
-    ) -> "_ProcessedDists":
+        self, packages: _ProcessedDists, options: Values
+    ) -> _ProcessedDists:
         return [
             dist
             for dist in self.iter_packages_latest_infos(packages, options)
@@ -213,8 +216,8 @@ class ListCommand(IndexGroupCommand):
         ]
 
     def get_uptodate(
-        self, packages: "_ProcessedDists", options: Values
-    ) -> "_ProcessedDists":
+        self, packages: _ProcessedDists, options: Values
+    ) -> _ProcessedDists:
         return [
             dist
             for dist in self.iter_packages_latest_infos(packages, options)
@@ -222,8 +225,8 @@ class ListCommand(IndexGroupCommand):
         ]
 
     def get_not_required(
-        self, packages: "_ProcessedDists", options: Values
-    ) -> "_ProcessedDists":
+        self, packages: _ProcessedDists, options: Values
+    ) -> _ProcessedDists:
         dep_keys = {
             canonicalize_name(dep.name)
             for dist in packages
@@ -236,14 +239,14 @@ class ListCommand(IndexGroupCommand):
         return list({pkg for pkg in packages if pkg.canonical_name not in dep_keys})
 
     def iter_packages_latest_infos(
-        self, packages: "_ProcessedDists", options: Values
-    ) -> Generator["_DistWithLatestInfo", None, None]:
+        self, packages: _ProcessedDists, options: Values
+    ) -> Generator[_DistWithLatestInfo, None, None]:
         with self._build_session(options) as session:
             finder = self._build_package_finder(options, session)
 
             def latest_info(
-                dist: "_DistWithLatestInfo",
-            ) -> Optional["_DistWithLatestInfo"]:
+                dist: _DistWithLatestInfo,
+            ) -> _DistWithLatestInfo | None:
                 all_candidates = finder.find_all_candidates(dist.canonical_name)
                 if not options.pre:
                     # Remove prereleases
@@ -274,7 +277,7 @@ class ListCommand(IndexGroupCommand):
                     yield dist
 
     def output_package_listing(
-        self, packages: "_ProcessedDists", options: Values
+        self, packages: _ProcessedDists, options: Values
     ) -> None:
         packages = sorted(
             packages,
@@ -285,17 +288,19 @@ class ListCommand(IndexGroupCommand):
             self.output_package_listing_columns(data, header)
         elif options.list_format == "freeze":
             for dist in packages:
+                try:
+                    req_string = f"{dist.raw_name}=={dist.version}"
+                except InvalidVersion:
+                    req_string = f"{dist.raw_name}==={dist.raw_version}"
                 if options.verbose >= 1:
-                    write_output(
-                        "%s==%s (%s)", dist.raw_name, dist.version, dist.location
-                    )
+                    write_output("%s (%s)", req_string, dist.location)
                 else:
-                    write_output("%s==%s", dist.raw_name, dist.version)
+                    write_output(req_string)
         elif options.list_format == "json":
             write_output(format_for_json(packages, options))
 
     def output_package_listing_columns(
-        self, data: List[List[str]], header: List[str]
+        self, data: list[list[str]], header: list[str]
     ) -> None:
         # insert the header first: we need to know the size of column names
         if len(data) > 0:
@@ -312,8 +317,8 @@ class ListCommand(IndexGroupCommand):
 
 
 def format_for_columns(
-    pkgs: "_ProcessedDists", options: Values
-) -> Tuple[List[List[str]], List[str]]:
+    pkgs: _ProcessedDists, options: Values
+) -> tuple[list[list[str]], list[str]]:
     """
     Convert the package data into something usable
     by output_package_listing_columns.
@@ -324,7 +329,7 @@ def format_for_columns(
     if running_outdated:
         header.extend(["Latest", "Type"])
 
-    def wheel_build_tag(dist: BaseDistribution) -> Optional[str]:
+    def wheel_build_tag(dist: BaseDistribution) -> str | None:
         try:
             wheel_file = dist.read_text("WHEEL")
         except FileNotFoundError:
@@ -371,12 +376,16 @@ def format_for_columns(
     return data, header
 
 
-def format_for_json(packages: "_ProcessedDists", options: Values) -> str:
+def format_for_json(packages: _ProcessedDists, options: Values) -> str:
     data = []
     for dist in packages:
+        try:
+            version = str(dist.version)
+        except InvalidVersion:
+            version = dist.raw_version
         info = {
             "name": dist.raw_name,
-            "version": str(dist.version),
+            "version": version,
         }
         if options.verbose >= 1:
             info["location"] = dist.location or ""

pip/_internal/commands/lock.py

@@ -1,7 +1,6 @@
 import sys
 from optparse import Values
 from pathlib import Path
-from typing import List
 
 from pip._internal.cache import WheelCache
 from pip._internal.cli import cmdoptions
@@ -12,9 +11,6 @@ from pip._internal.cli.req_command import (
 from pip._internal.cli.status_codes import SUCCESS
 from pip._internal.models.pylock import Pylock, is_valid_pylock_file_name
 from pip._internal.operations.build.build_tracker import get_build_tracker
-from pip._internal.req.req_install import (
-    check_legacy_setup_py_options,
-)
 from pip._internal.utils.logging import getLogger
 from pip._internal.utils.misc import (
     get_pip_version,
@@ -60,6 +56,7 @@ class LockCommand(RequirementCommand):
         )
         self.cmd_opts.add_option(cmdoptions.requirements())
         self.cmd_opts.add_option(cmdoptions.constraints())
+        self.cmd_opts.add_option(cmdoptions.build_constraints())
         self.cmd_opts.add_option(cmdoptions.no_deps())
         self.cmd_opts.add_option(cmdoptions.pre())
 
@@ -70,7 +67,6 @@ class LockCommand(RequirementCommand):
         self.cmd_opts.add_option(cmdoptions.ignore_requires_python())
         self.cmd_opts.add_option(cmdoptions.no_build_isolation())
         self.cmd_opts.add_option(cmdoptions.use_pep517())
-        self.cmd_opts.add_option(cmdoptions.no_use_pep517())
         self.cmd_opts.add_option(cmdoptions.check_build_deps())
 
         self.cmd_opts.add_option(cmdoptions.config_settings())
@@ -90,7 +86,7 @@ class LockCommand(RequirementCommand):
         self.parser.insert_option_group(0, self.cmd_opts)
 
     @with_cleanup
-    def run(self, options: Values, args: List[str]) -> int:
+    def run(self, options: Values, args: list[str]) -> int:
         logger.verbose("Using %s", get_pip_version())
 
         logger.warning(
@@ -99,6 +95,8 @@ class LockCommand(RequirementCommand):
             "without prior warning."
         )
 
+        cmdoptions.check_build_constraints(options)
+
         session = self.get_default_session(options)
 
         finder = self._build_package_finder(
@@ -115,7 +113,6 @@ class LockCommand(RequirementCommand):
         )
 
         reqs = self.get_requirements(args, options, finder, session)
-        check_legacy_setup_py_options(options, reqs)
 
         wheel_cache = WheelCache(options.cache_dir)
 
@@ -143,7 +140,6 @@ class LockCommand(RequirementCommand):
             ignore_installed=True,
             ignore_requires_python=options.ignore_requires_python,
             upgrade_strategy="to-satisfy-only",
-            use_pep517=options.use_pep517,
         )
 
         self.trace_basic_info(finder)

pip/_internal/commands/search.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import logging
 import shutil
 import sys
@@ -5,7 +7,7 @@ import textwrap
 import xmlrpc.client
 from collections import OrderedDict
 from optparse import Values
-from typing import Dict, List, Optional, TypedDict
+from typing import TypedDict
 
 from pip._vendor.packaging.version import parse as parse_version
 
@@ -24,7 +26,7 @@ from pip._internal.utils.misc import write_output
 class TransformedHit(TypedDict):
     name: str
     summary: str
-    versions: List[str]
+    versions: list[str]
 
 
 logger = logging.getLogger(__name__)
@@ -49,7 +51,7 @@ class SearchCommand(Command, SessionCommandMixin):
 
         self.parser.insert_option_group(0, self.cmd_opts)
 
-    def run(self, options: Values, args: List[str]) -> int:
+    def run(self, options: Values, args: list[str]) -> int:
         if not args:
             raise CommandError("Missing required argument (search query).")
         query = args
@@ -65,7 +67,7 @@ class SearchCommand(Command, SessionCommandMixin):
             return SUCCESS
         return NO_MATCHES_FOUND
 
-    def search(self, query: List[str], options: Values) -> List[Dict[str, str]]:
+    def search(self, query: list[str], options: Values) -> list[dict[str, str]]:
         index_url = options.index
 
         session = self.get_default_session(options)
@@ -83,13 +85,13 @@ class SearchCommand(Command, SessionCommandMixin):
         return hits
 
 
-def transform_hits(hits: List[Dict[str, str]]) -> List["TransformedHit"]:
+def transform_hits(hits: list[dict[str, str]]) -> list[TransformedHit]:
     """
     The list from pypi is really a list of versions. We want a list of
     packages with the list of versions stored inline. This converts the
     list from pypi into one we can use.
     """
-    packages: Dict[str, TransformedHit] = OrderedDict()
+    packages: dict[str, TransformedHit] = OrderedDict()
     for hit in hits:
         name = hit["name"]
         summary = hit["summary"]
@@ -111,7 +113,7 @@ def transform_hits(hits: List[Dict[str, str]]) -> List["TransformedHit"]:
     return list(packages.values())
 
 
-def print_dist_installation_info(latest: str, dist: Optional[BaseDistribution]) -> None:
+def print_dist_installation_info(latest: str, dist: BaseDistribution | None) -> None:
     if dist is not None:
         with indent_log():
             if dist.version == latest:
@@ -128,15 +130,15 @@ def print_dist_installation_info(latest: str, dist: Optional[BaseDistribution])
                     write_output("LATEST:    %s", latest)
 
 
-def get_installed_distribution(name: str) -> Optional[BaseDistribution]:
+def get_installed_distribution(name: str) -> BaseDistribution | None:
     env = get_default_environment()
     return env.get_distribution(name)
 
 
 def print_results(
-    hits: List["TransformedHit"],
-    name_column_width: Optional[int] = None,
-    terminal_width: Optional[int] = None,
+    hits: list[TransformedHit],
+    name_column_width: int | None = None,
+    terminal_width: int | None = None,
 ) -> None:
     if not hits:
         return
@@ -172,5 +174,5 @@ def print_results(
             pass
 
 
-def highest_version(versions: List[str]) -> str:
+def highest_version(versions: list[str]) -> str:
     return max(versions, key=parse_version)

pip/_internal/commands/show.py

@@ -1,7 +1,10 @@
+from __future__ import annotations
+
 import logging
 import string
+from collections.abc import Generator, Iterable, Iterator
 from optparse import Values
-from typing import Generator, Iterable, Iterator, List, NamedTuple, Optional
+from typing import NamedTuple
 
 from pip._vendor.packaging.requirements import InvalidRequirement
 from pip._vendor.packaging.utils import canonicalize_name
@@ -44,7 +47,7 @@ class ShowCommand(Command):
 
         self.parser.insert_option_group(0, self.cmd_opts)
 
-    def run(self, options: Values, args: List[str]) -> int:
+    def run(self, options: Values, args: list[str]) -> int:
         if not args:
             logger.warning("ERROR: Please provide a package name or names.")
             return ERROR
@@ -62,24 +65,24 @@ class _PackageInfo(NamedTuple):
     name: str
     version: str
     location: str
-    editable_project_location: Optional[str]
-    requires: List[str]
-    required_by: List[str]
+    editable_project_location: str | None
+    requires: list[str]
+    required_by: list[str]
     installer: str
     metadata_version: str
-    classifiers: List[str]
+    classifiers: list[str]
     summary: str
     homepage: str
-    project_urls: List[str]
+    project_urls: list[str]
     author: str
     author_email: str
     license: str
     license_expression: str
-    entry_points: List[str]
-    files: Optional[List[str]]
+    entry_points: list[str]
+    files: list[str] | None
 
 
-def search_packages_info(query: List[str]) -> Generator[_PackageInfo, None, None]:
+def search_packages_info(query: list[str]) -> Generator[_PackageInfo, None, None]:
     """
     Gather details from installed distributions. Print distribution name,
     version, location, and installed files. Installed files requires a
@@ -132,7 +135,7 @@ def search_packages_info(query: List[str]) -> Generator[_PackageInfo, None, None
 
         files_iter = dist.iter_declared_entries()
         if files_iter is None:
-            files: Optional[List[str]] = None
+            files: list[str] | None = None
         else:
             files = sorted(files_iter)
 

pip/_internal/commands/uninstall.py

@@ -1,6 +1,5 @@
 import logging
 from optparse import Values
-from typing import List
 
 from pip._vendor.packaging.utils import canonicalize_name
 
@@ -62,7 +61,7 @@ class UninstallCommand(Command, SessionCommandMixin):
         self.cmd_opts.add_option(cmdoptions.override_externally_managed())
         self.parser.insert_option_group(0, self.cmd_opts)
 
-    def run(self, options: Values, args: List[str]) -> int:
+    def run(self, options: Values, args: list[str]) -> int:
         session = self.get_default_session(options)
 
         reqs_to_uninstall = {}

pip/_internal/commands/wheel.py

@@ -2,7 +2,6 @@ import logging
 import os
 import shutil
 from optparse import Values
-from typing import List
 
 from pip._internal.cache import WheelCache
 from pip._internal.cli import cmdoptions
@@ -12,7 +11,6 @@ from pip._internal.exceptions import CommandError
 from pip._internal.operations.build.build_tracker import get_build_tracker
 from pip._internal.req.req_install import (
     InstallRequirement,
-    check_legacy_setup_py_options,
 )
 from pip._internal.utils.misc import ensure_dir, normalize_path
 from pip._internal.utils.temp_dir import TempDirectory
@@ -58,9 +56,9 @@ class WheelCommand(RequirementCommand):
         self.cmd_opts.add_option(cmdoptions.prefer_binary())
         self.cmd_opts.add_option(cmdoptions.no_build_isolation())
         self.cmd_opts.add_option(cmdoptions.use_pep517())
-        self.cmd_opts.add_option(cmdoptions.no_use_pep517())
         self.cmd_opts.add_option(cmdoptions.check_build_deps())
         self.cmd_opts.add_option(cmdoptions.constraints())
+        self.cmd_opts.add_option(cmdoptions.build_constraints())
         self.cmd_opts.add_option(cmdoptions.editable())
         self.cmd_opts.add_option(cmdoptions.requirements())
         self.cmd_opts.add_option(cmdoptions.src())
@@ -77,8 +75,6 @@ class WheelCommand(RequirementCommand):
         )
 
         self.cmd_opts.add_option(cmdoptions.config_settings())
-        self.cmd_opts.add_option(cmdoptions.build_options())
-        self.cmd_opts.add_option(cmdoptions.global_options())
 
         self.cmd_opts.add_option(
             "--pre",
@@ -101,7 +97,9 @@ class WheelCommand(RequirementCommand):
         self.parser.insert_option_group(0, self.cmd_opts)
 
     @with_cleanup
-    def run(self, options: Values, args: List[str]) -> int:
+    def run(self, options: Values, args: list[str]) -> int:
+        cmdoptions.check_build_constraints(options)
+
         session = self.get_default_session(options)
 
         finder = self._build_package_finder(options, session)
@@ -118,7 +116,6 @@ class WheelCommand(RequirementCommand):
         )
 
         reqs = self.get_requirements(args, options, finder, session)
-        check_legacy_setup_py_options(options, reqs)
 
         wheel_cache = WheelCache(options.cache_dir)
 
@@ -139,29 +136,26 @@ class WheelCommand(RequirementCommand):
             options=options,
             wheel_cache=wheel_cache,
             ignore_requires_python=options.ignore_requires_python,
-            use_pep517=options.use_pep517,
         )
 
         self.trace_basic_info(finder)
 
         requirement_set = resolver.resolve(reqs, check_supported_wheels=True)
 
-        reqs_to_build: List[InstallRequirement] = []
+        preparer.prepare_linked_requirements_more(requirement_set.requirements.values())
+
+        reqs_to_build: list[InstallRequirement] = []
         for req in requirement_set.requirements.values():
             if req.is_wheel:
                 preparer.save_linked_requirement(req)
             else:
                 reqs_to_build.append(req)
 
-        preparer.prepare_linked_requirements_more(requirement_set.requirements.values())
-
         # build wheels
         build_successes, build_failures = build(
             reqs_to_build,
             wheel_cache=wheel_cache,
             verify=(not options.no_verify),
-            build_options=options.build_options or [],
-            global_options=options.global_options or [],
         )
         for req in build_successes:
             assert req.link and req.link.is_wheel

pip/_internal/configuration.py

@@ -11,11 +11,14 @@ Some terminology:
   A single word describing where the configuration key-value pair came from
 """
 
+from __future__ import annotations
+
 import configparser
 import locale
 import os
 import sys
-from typing import Any, Dict, Iterable, List, NewType, Optional, Tuple
+from collections.abc import Iterable
+from typing import Any, NewType
 
 from pip._internal.exceptions import (
     ConfigurationError,
@@ -50,12 +53,11 @@ logger = getLogger(__name__)
 def _normalize_name(name: str) -> str:
     """Make a name consistent regardless of source (environment or file)"""
     name = name.lower().replace("_", "-")
-    if name.startswith("--"):
-        name = name[2:]  # only prefer long opts
+    name = name.removeprefix("--")  # only prefer long opts
     return name
 
 
-def _disassemble_key(name: str) -> List[str]:
+def _disassemble_key(name: str) -> list[str]:
     if "." not in name:
         error_message = (
             "Key does not contain dot separated section and key. "
@@ -65,7 +67,7 @@ def _disassemble_key(name: str) -> List[str]:
     return name.split(".", 1)
 
 
-def get_configuration_files() -> Dict[Kind, List[str]]:
+def get_configuration_files() -> dict[Kind, list[str]]:
     global_config_files = [
         os.path.join(path, CONFIG_BASENAME) for path in appdirs.site_config_dirs("pip")
     ]
@@ -98,7 +100,7 @@ class Configuration:
     and the data stored is also nice.
     """
 
-    def __init__(self, isolated: bool, load_only: Optional[Kind] = None) -> None:
+    def __init__(self, isolated: bool, load_only: Kind | None = None) -> None:
         super().__init__()
 
         if load_only is not None and load_only not in VALID_LOAD_ONLY:
@@ -111,13 +113,13 @@ class Configuration:
         self.load_only = load_only
 
         # Because we keep track of where we got the data from
-        self._parsers: Dict[Kind, List[Tuple[str, RawConfigParser]]] = {
+        self._parsers: dict[Kind, list[tuple[str, RawConfigParser]]] = {
             variant: [] for variant in OVERRIDE_ORDER
         }
-        self._config: Dict[Kind, Dict[str, Any]] = {
+        self._config: dict[Kind, dict[str, dict[str, Any]]] = {
             variant: {} for variant in OVERRIDE_ORDER
         }
-        self._modified_parsers: List[Tuple[str, RawConfigParser]] = []
+        self._modified_parsers: list[tuple[str, RawConfigParser]] = []
 
     def load(self) -> None:
         """Loads configuration from configuration files and environment"""
@@ -125,7 +127,7 @@ class Configuration:
         if not self.isolated:
             self._load_environment_vars()
 
-    def get_file_to_edit(self) -> Optional[str]:
+    def get_file_to_edit(self) -> str | None:
         """Returns the file with highest priority in configuration"""
         assert self.load_only is not None, "Need to be specified a file to be editing"
 
@@ -134,7 +136,7 @@ class Configuration:
         except IndexError:
             return None
 
-    def items(self) -> Iterable[Tuple[str, Any]]:
+    def items(self) -> Iterable[tuple[str, Any]]:
         """Returns key-value pairs like dict.items() representing the loaded
         configuration
         """
@@ -145,7 +147,10 @@ class Configuration:
         orig_key = key
         key = _normalize_name(key)
         try:
-            return self._dictionary[key]
+            clean_config: dict[str, Any] = {}
+            for file_values in self._dictionary.values():
+                clean_config.update(file_values)
+            return clean_config[key]
         except KeyError:
             # disassembling triggers a more useful error message than simply
             # "No such key" in the case that the key isn't in the form command.option
@@ -168,7 +173,8 @@ class Configuration:
                 parser.add_section(section)
             parser.set(section, name, value)
 
-        self._config[self.load_only][key] = value
+        self._config[self.load_only].setdefault(fname, {})
+        self._config[self.load_only][fname][key] = value
         self._mark_as_modified(fname, parser)
 
     def unset_value(self, key: str) -> None:
@@ -178,11 +184,14 @@ class Configuration:
         self._ensure_have_load_only()
 
         assert self.load_only
-        if key not in self._config[self.load_only]:
-            raise ConfigurationError(f"No such key - {orig_key}")
-
         fname, parser = self._get_parser_to_modify()
 
+        if (
+            key not in self._config[self.load_only][fname]
+            and key not in self._config[self.load_only]
+        ):
+            raise ConfigurationError(f"No such key - {orig_key}")
+
         if parser is not None:
             section, name = _disassemble_key(key)
             if not (
@@ -197,8 +206,10 @@ class Configuration:
             if not parser.items(section):
                 parser.remove_section(section)
             self._mark_as_modified(fname, parser)
-
-        del self._config[self.load_only][key]
+        try:
+            del self._config[self.load_only][fname][key]
+        except KeyError:
+            del self._config[self.load_only][key]
 
     def save(self) -> None:
         """Save the current in-memory state."""
@@ -230,7 +241,7 @@ class Configuration:
         logger.debug("Will be working with %s variant only", self.load_only)
 
     @property
-    def _dictionary(self) -> Dict[str, Any]:
+    def _dictionary(self) -> dict[str, dict[str, Any]]:
         """A dictionary representing the loaded configuration."""
         # NOTE: Dictionaries are not populated if not loaded. So, conditionals
         #       are not needed here.
@@ -270,7 +281,8 @@ class Configuration:
 
         for section in parser.sections():
             items = parser.items(section)
-            self._config[variant].update(self._normalized_keys(section, items))
+            self._config[variant].setdefault(fname, {})
+            self._config[variant][fname].update(self._normalized_keys(section, items))
 
         return parser
 
@@ -297,13 +309,14 @@ class Configuration:
 
     def _load_environment_vars(self) -> None:
         """Loads configuration from environment variables"""
-        self._config[kinds.ENV_VAR].update(
+        self._config[kinds.ENV_VAR].setdefault(":env:", {})
+        self._config[kinds.ENV_VAR][":env:"].update(
             self._normalized_keys(":env:", self.get_environ_vars())
         )
 
     def _normalized_keys(
-        self, section: str, items: Iterable[Tuple[str, Any]]
-    ) -> Dict[str, Any]:
+        self, section: str, items: Iterable[tuple[str, Any]]
+    ) -> dict[str, Any]:
         """Normalizes items to construct a dictionary with normalized keys.
 
         This routine is where the names become keys and are made the same
@@ -315,7 +328,7 @@ class Configuration:
             normalized[key] = val
         return normalized
 
-    def get_environ_vars(self) -> Iterable[Tuple[str, str]]:
+    def get_environ_vars(self) -> Iterable[tuple[str, str]]:
         """Returns a generator with all environmental vars with prefix PIP_"""
         for key, val in os.environ.items():
             if key.startswith("PIP_"):
@@ -324,7 +337,7 @@ class Configuration:
                     yield name, val
 
     # XXX: This is patched in the tests.
-    def iter_config_files(self) -> Iterable[Tuple[Kind, List[str]]]:
+    def iter_config_files(self) -> Iterable[tuple[Kind, list[str]]]:
         """Yields variant and configuration files associated with it.
 
         This should be treated like items of a dictionary. The order
@@ -356,11 +369,11 @@ class Configuration:
         else:
             yield kinds.ENV, []
 
-    def get_values_in_config(self, variant: Kind) -> Dict[str, Any]:
+    def get_values_in_config(self, variant: Kind) -> dict[str, Any]:
         """Get values present in a config file"""
         return self._config[variant]
 
-    def _get_parser_to_modify(self) -> Tuple[str, RawConfigParser]:
+    def _get_parser_to_modify(self) -> tuple[str, RawConfigParser]:
         # Determine which parser to modify
         assert self.load_only
         parsers = self._parsers[self.load_only]