dependence 1.0.2__py3-none-any.whl → 1.2.5__py3-none-any.whl

dependence/_utilities.py

@@ -1,7 +1,10 @@
+from __future__ import annotations
+
 import functools
 import json
 import os
 import re
+import shutil
 import sys
 from collections import deque
 from configparser import ConfigParser, SectionProxy
@@ -17,21 +20,11 @@ from subprocess import DEVNULL, PIPE, CalledProcessError, list2cmdline, run
 from traceback import format_exception
 from typing import (
     IO,
-    AbstractSet,
+    TYPE_CHECKING,
     Any,
-    Callable,
-    Container,
-    Dict,
-    Hashable,
-    Iterable,
-    List,
-    MutableSet,
-    Optional,
-    Set,
-    Tuple,
     TypedDict,
-    Union,
     cast,
+    overload,
 )
 from warnings import warn
 
@@ -40,15 +33,122 @@ from jsonpointer import resolve_pointer  # type: ignore
 from packaging.requirements import InvalidRequirement, Requirement
 from packaging.utils import canonicalize_name
 
-_BUILTIN_DISTRIBUTION_NAMES: Tuple[str] = ("distribute",)
+if TYPE_CHECKING:
+    from collections.abc import (
+        Callable,
+        Container,
+        Hashable,
+        Iterable,
+        MutableSet,
+    )
+    from collections.abc import (
+        Set as AbstractSet,
+    )
+
+_BUILTIN_DISTRIBUTION_NAMES: tuple[str] = ("distribute",)
 _UNSAFE_CHARACTERS_PATTERN: re.Pattern = re.compile("[^A-Za-z0-9.]+")
 
 
+class DefinitionExistsError(Exception):
+    """
+    This error is raised when an attempt is made to redefine
+    a singleton class instance.
+    """
+
+
+_module_locals: dict[str, Any] = locals()
+
+
+class Undefined:
+    """
+    This class is intended to indicate that a parameter has not been passed
+    to a keyword argument in situations where `None` is to be used as a
+    meaningful value.
+
+    The `Undefined` class is a singleton, so only one instance of this class
+    is permitted: `sob.UNDEFINED`.
+    """
+
+    __module__ = "sob"
+
+    def __init__(self) -> None:
+        # Only one instance of `Undefined` is permitted, so initialization
+        # checks to make sure this is the first use.
+        if "UNDEFINED" in _module_locals:
+            message: str = f"{self!r} may only be instantiated once."
+            raise DefinitionExistsError(message)
+
+    def __repr__(self) -> str:
+        # Represent instances of this class using the qualified name for the
+        # constant `UNDEFINED`.
+        return "sob.UNDEFINED"
+
+    def __bool__(self) -> bool:
+        # `UNDEFINED` cast as a boolean is `False` (as with `None`)
+        return False
+
+    def __hash__(self) -> int:
+        return 0
+
+    def __eq__(self, other: object) -> bool:
+        # Another object is only equal to this if it shares the same id, since
+        # there should only be one instance of this class defined
+        return other is self
+
+    def __reduce__(self) -> tuple[Callable[[], Undefined], tuple]:
+        return _undefined, ()
+
+
+UNDEFINED: Undefined = Undefined()
+
+
+def _undefined() -> Undefined:
+    return UNDEFINED
+
+
+cache: Any
+try:
+    from functools import cache  # type: ignore
+except ImportError:
+    from functools import lru_cache
+
+    cache = lru_cache(maxsize=None)
+
+
+def as_tuple(
+    user_function: Callable[..., Iterable[Any]],
+) -> Callable[..., tuple[Any, ...]]:
+    """
+    This is a decorator which will return an iterable as a tuple.
+    """
+
+    def wrapper(*args: Any, **kwargs: Any) -> tuple[Any, ...]:
+        return tuple(user_function(*args, **kwargs) or ())
+
+    return functools.update_wrapper(wrapper, user_function)
+
+
+def as_cached_tuple(
+    maxsize: int | None = None, *, typed: bool = False
+) -> Callable[[Callable[..., Iterable[Any]]], Callable[..., tuple[Any, ...]]]:
+    """
+    This is a decorator which will return an iterable as a tuple,
+    and cache that tuple.
+
+    Parameters:
+
+    - maxsize (int|None) = None: The maximum number of items to cache.
+    - typed (bool) = False: For class methods, should the cache be distinct for
+      sub-classes?
+    """
+    return functools.lru_cache(maxsize=maxsize, typed=typed)(as_tuple)
+
+
 def iter_distinct(items: Iterable[Hashable]) -> Iterable:
     """
     Yield distinct elements, preserving order
     """
-    visited: Set[Hashable] = set()
+    visited: set[Hashable] = set()
     item: Hashable
     for item in items:
         if item not in visited:
@@ -88,8 +188,9 @@ def iter_parse_delimited_values(
 
 
 def check_output(
-    args: Tuple[str, ...],
-    cwd: Union[str, Path] = "",
+    args: tuple[str, ...],
+    cwd: str | Path = "",
+    *,
     echo: bool = False,
 ) -> str:
     """
@@ -98,13 +199,13 @@ def check_output(
 
     Parameters:
 
-    - command (Tuple[str, ...]): The command to run
+    - command (tuple[str, ...]): The command to run
     """
     if echo:
         if cwd:
-            print("$", "cd", cwd, "&&", list2cmdline(args))
+            print("$", "cd", cwd, "&&", list2cmdline(args))  # noqa: T201
         else:
-            print("$", list2cmdline(args))
+            print("$", list2cmdline(args))  # noqa: T201
     output: str = run(
         args,
         stdout=PIPE,
@@ -113,7 +214,7 @@ def check_output(
         cwd=cwd or None,
     ).stdout.decode("utf-8", errors="ignore")
     if echo:
-        print(output)
+        print(output)  # noqa: T201
     return output
 
 
@@ -164,13 +265,13 @@ def deprecated(message: str = "") -> Callable[..., Callable[..., Any]]:
     return decorating_function
 
 
-def split_dot(path: str) -> Tuple[str, ...]:
+def split_dot(path: str) -> tuple[str, ...]:
     return tuple(path.split("."))
 
 
 def tuple_starts_with(
-    a: Tuple[str, ...],
-    b: Tuple[str, ...],
+    a: tuple[str, ...],
+    b: tuple[str, ...],
 ) -> bool:
     """
     Determine if tuple `a` starts with tuple `b`
@@ -179,18 +280,18 @@ def tuple_starts_with(
 
 
 def tuple_starts_with_any(
-    a: Tuple[str, ...],
-    bs: Tuple[Tuple[str, ...], ...],
+    a: tuple[str, ...],
+    bs: tuple[tuple[str, ...], ...],
 ) -> bool:
     """
     Determine if tuple `a` starts with any tuple in `bs`
     """
-    b: Tuple[str, ...]
+    b: tuple[str, ...]
     return any(tuple_starts_with(a, b) for b in bs)
 
 
 def iter_find_qualified_lists(
-    data: Union[Dict[str, Any], list],
+    data: dict[str, Any] | list,
     item_condition: Callable[[Any], bool],
     exclude_object_ids: AbstractSet[int] = frozenset(),
 ) -> Iterable[list]:
@@ -262,9 +363,8 @@ def iter_find_qualified_lists(
     if id(data) in exclude_object_ids:
         return
     if isinstance(data, dict):
-        _key: str
         value: Any
-        for _key, value in data.items():
+        for value in data.values():
             if isinstance(value, (list, dict)):
                 yield from iter_find_qualified_lists(
                     value, item_condition, exclude_object_ids
@@ -299,75 +399,143 @@ class ConfigurationFileType(Enum):
 
 
 @functools.lru_cache
-def get_configuration_file_type(path: str) -> ConfigurationFileType:
-    if not os.path.isfile(path):
+def get_configuration_file_type(
+    path: str | Path, default: Any = UNDEFINED
+) -> ConfigurationFileType:
+    if isinstance(path, str):
+        path = Path(path)
+    if not path.is_file():
         raise FileNotFoundError(path)
-    basename: str = os.path.basename(path).lower()
+    basename: str = path.name.lower()
     if basename == "setup.cfg":
         return ConfigurationFileType.SETUP_CFG
-    elif basename == "tox.ini":
+    if basename == "tox.ini":
         return ConfigurationFileType.TOX_INI
-    elif basename == "pyproject.toml":
+    if basename == "pyproject.toml":
         return ConfigurationFileType.PYPROJECT_TOML
-    elif basename.endswith(".txt"):
+    if basename.endswith(".txt"):
         return ConfigurationFileType.REQUIREMENTS_TXT
-    elif basename.endswith(".toml"):
+    if basename.endswith(".toml"):
         return ConfigurationFileType.TOML
-    else:
-        raise ValueError(
-            f"{path} is not a recognized type of configuration file."
+    if default is UNDEFINED:
+        message: str = (
+            f"{path!s} is not a recognized type of configuration file."
         )
+        raise ValueError(message)
+    return default
 
 
 def is_configuration_file(path: str) -> bool:
-    try:
-        get_configuration_file_type(path)
-    except (FileNotFoundError, ValueError):
-        return False
-    return True
+    return get_configuration_file_type(path, default=None) is not None
+
+
+@overload
+def iter_configuration_files(path: str) -> Iterable[str]: ...
+
+
+@overload
+def iter_configuration_files(path: Path) -> Iterable[Path]: ...
+
+
+def iter_configuration_files(path: str | Path) -> Iterable[Path | str]:
+    """
+    Iterate over the project configuration files for the given path.
+    If the path is a file path—yields only that path. If the path is a
+    directory, yields all configuration files in that directory.
+    """
+    if os.path.exists(path):
+        if os.path.isdir(path):
+            child: Path
+            for child in filter(
+                Path.is_file,
+                (
+                    path.iterdir()
+                    if isinstance(path, Path)
+                    else Path(path).iterdir()
+                ),
+            ):
+                if (
+                    get_configuration_file_type(child, default=None)
+                    is not None
+                ):
+                    yield (
+                        child
+                        if isinstance(path, Path)
+                        else str(child.absolute())
+                    )
+        elif get_configuration_file_type(path, default=None) is not None:
+            yield path
+
+
+def _iter_editable_project_locations() -> Iterable[tuple[str, str]]:
+    metadata: PackageMetadata
+    for name, metadata in map_pip_list().items():
+        editable_project_location: str | None = metadata.get(
+            "editable_project_location"
+        )
+        if editable_project_location:
+            yield (
+                name,
+                editable_project_location,
+            )
 
 
-class _EditablePackageMetadata(TypedDict):
+@functools.lru_cache
+def map_editable_project_locations() -> dict[str, str]:
+    """
+    Get a mapping of (normalized) editable distribution names to their
+    locations.
+    """
+    return dict(_iter_editable_project_locations())
+
+
+class PackageMetadata(TypedDict, total=False):
     name: str
     version: str
     editable_project_location: str
 
 
-def _iter_editable_distribution_locations() -> Iterable[Tuple[str, str]]:
-    metadata: _EditablePackageMetadata
-    for metadata in json.loads(
-        check_output(
-            (
-                sys.executable,
-                "-m",
-                "pip",
-                "list",
-                "--editable",
-                "--format=json",
-            )
+def _iter_pip_list() -> Iterable[tuple[str, PackageMetadata]]:
+    uv: str | None = shutil.which("uv")
+    command: tuple[str, ...]
+    if uv:
+        command = (
+            uv,
+            "pip",
+            "list",
+            "--python",
+            sys.executable,
+            "--format=json",
         )
-    ):
+    else:
+        # If `uv` is not available, use `pip`
+        command = (
+            sys.executable,
+            "-m",
+            "pip",
+            "list",
+            "--format=json",
+        )
+    metadata: PackageMetadata
+    for metadata in json.loads(check_output(command)):
         yield (
             normalize_name(metadata["name"]),
-            metadata["editable_project_location"],
+            metadata,
         )
 
 
-@functools.lru_cache
-def get_editable_distributions_locations() -> Dict[str, str]:
-    """
-    Get a mapping of (normalized) editable distribution names to their
-    locations.
-    """
-    return dict(_iter_editable_distribution_locations())
+@cache
+def map_pip_list() -> dict[str, PackageMetadata]:
+    return dict(_iter_pip_list())
 
 
 def cache_clear() -> None:
     """
     Clear distribution metadata caches
     """
+    map_pip_list.cache_clear()
     get_installed_distributions.cache_clear()
-    get_editable_distributions_locations.cache_clear()
+    map_editable_project_locations.cache_clear()
     is_editable.cache_clear()
     is_installed.cache_clear()
     get_requirement_string_distribution_name.cache_clear()
@@ -379,19 +547,25 @@ def refresh_editable_distributions() -> None:
     """
     name: str
     location: str
-    for name, location in get_editable_distributions_locations().items():
+    for name, location in map_editable_project_locations().items():
         _install_requirement_string(location, name=name, editable=True)
 
 
 @functools.lru_cache
-def get_installed_distributions() -> Dict[str, Distribution]:
+def get_installed_distributions() -> dict[str, Distribution]:
     """
     Return a dictionary of installed distributions.
     """
     refresh_editable_distributions()
-    installed: Dict[str, Distribution] = {}
+    installed: dict[str, Distribution] = {}
     for distribution in _get_distributions():
-        installed[normalize_name(distribution.metadata["Name"])] = distribution
+        name: str = distribution.metadata["Name"]
+        if distribution.version is None:
+            # If no version can be found, use pip to find the version
+            distribution.metadata["Version"] = (
+                map_pip_list().get(name, {}).get("version")
+            )
+        installed[normalize_name(name)] = distribution
     return installed
 
 
@@ -425,7 +599,7 @@ def is_requirement_string(requirement_string: str) -> bool:
 
 
 def _iter_file_requirement_strings(path: str) -> Iterable[str]:
-    lines: List[str]
+    lines: list[str]
     requirement_file_io: IO[str]
     with open(path) as requirement_file_io:
         lines = requirement_file_io.readlines()
@@ -459,7 +633,7 @@ def _iter_setup_cfg_requirement_strings(path: str) -> Iterable[str]:
 
 
 def _iter_tox_ini_requirement_strings(
-    path: Union[str, Path, ConfigParser] = "",
+    path: str | Path | ConfigParser = "",
     string: str = "",
 ) -> Iterable[str]:
     """
@@ -472,13 +646,19 @@ def _iter_tox_ini_requirement_strings(
     - string (str) = "": The contents of a tox.ini file
     """
     parser: ConfigParser = ConfigParser()
+    message: str
     if path:
-        assert (
-            not string
-        ), "Either `path` or `string` arguments may be provided, but not both"
+        if string:
+            message = (
+                "Either `path` or `string` arguments may be provided, but not "
+                "both"
+            )
+            raise ValueError(message)
         parser.read(path)
     else:
-        assert string, "Either a `path` or `string` argument must be provided"
+        if not string:
+            message = "Either a `path` or `string` argument must be provided"
+            raise ValueError(message)
         parser.read_string(string)
 
     def get_section_option_requirements(
@@ -525,10 +705,10 @@ def _is_installed_requirement_string(item: Any) -> bool:
 
 
 def iter_find_requirements_lists(
-    document: Union[Dict[str, Any], list],
-    include_pointers: Tuple[str, ...] = (),
-    exclude_pointers: Tuple[str, ...] = (),
-) -> Iterable[List[str]]:
+    document: dict[str, Any] | list,
+    include_pointers: tuple[str, ...] = (),
+    exclude_pointers: tuple[str, ...] = (),
+) -> Iterable[list[str]]:
     """
     Recursively yield all lists of valid requirement strings for installed
     packages. Exclusions are resolved before inclusions.
@@ -581,8 +761,8 @@ def iter_find_requirements_lists(
 
 def _iter_toml_requirement_strings(
     path: str,
-    include_pointers: Tuple[str, ...] = (),
-    exclude_pointers: Tuple[str, ...] = (),
+    include_pointers: tuple[str, ...] = (),
+    exclude_pointers: tuple[str, ...] = (),
 ) -> Iterable[str]:
     """
     Read a TOML file and yield the requirements found.
@@ -597,7 +777,7 @@ def _iter_toml_requirement_strings(
     # Parse pyproject.toml
     try:
         with open(path, "rb") as pyproject_io:
-            document: Dict[str, Any] = tomli.load(pyproject_io)
+            document: dict[str, Any] = tomli.load(pyproject_io)
     except FileNotFoundError:
         return
     # Find requirements
@@ -615,8 +795,8 @@ def _iter_toml_requirement_strings(
 def iter_configuration_file_requirement_strings(
     path: str,
     *,
-    include_pointers: Tuple[str, ...] = (),
-    exclude_pointers: Tuple[str, ...] = (),
+    include_pointers: tuple[str, ...] = (),
+    exclude_pointers: tuple[str, ...] = (),
 ) -> Iterable[str]:
     """
     Read a configuration file and yield the parsed requirements.
@@ -633,7 +813,7 @@ def iter_configuration_file_requirement_strings(
     )
     if configuration_file_type == ConfigurationFileType.SETUP_CFG:
         return _iter_setup_cfg_requirement_strings(path)
-    elif configuration_file_type in (
+    if configuration_file_type in (
         ConfigurationFileType.PYPROJECT_TOML,
         ConfigurationFileType.TOML,
     ):
@@ -642,13 +822,11 @@ def iter_configuration_file_requirement_strings(
             include_pointers=include_pointers,
             exclude_pointers=exclude_pointers,
         )
-    elif configuration_file_type == ConfigurationFileType.TOX_INI:
+    if configuration_file_type == ConfigurationFileType.TOX_INI:
         return _iter_tox_ini_requirement_strings(path=path)
-    else:
-        assert (
-            configuration_file_type == ConfigurationFileType.REQUIREMENTS_TXT
-        )
-        return _iter_file_requirement_strings(path)
+    if configuration_file_type != ConfigurationFileType.REQUIREMENTS_TXT:
+        raise ValueError(configuration_file_type)
+    return _iter_file_requirement_strings(path)
 
 
 @functools.lru_cache
@@ -656,7 +834,7 @@ def is_editable(name: str) -> bool:
     """
     Return `True` if the indicated distribution is an editable installation.
     """
-    return bool(normalize_name(name) in get_editable_distributions_locations())
+    return bool(normalize_name(name) in map_editable_project_locations())
 
 
 def _get_setup_cfg_metadata(path: str, key: str) -> str:
@@ -669,15 +847,14 @@ def _get_setup_cfg_metadata(path: str, key: str) -> str:
         parser.read(path)
         if "metadata" in parser:
             return parser.get("metadata", key, fallback="")
-        else:
-            warn(
-                f"No `metadata` section found in: {path}",
-                stacklevel=2,
-            )
+        warn(
+            f"No `metadata` section found in: {path}",
+            stacklevel=2,
+        )
     return ""
 
 
-def _get_setup_py_metadata(path: str, args: Tuple[str, ...]) -> str:
+def _get_setup_py_metadata(path: str, args: tuple[str, ...]) -> str:
     """
     Execute a setup.py script with `args` and return the response.
 
@@ -699,7 +876,7 @@ def _get_setup_py_metadata(path: str, args: Tuple[str, ...]) -> str:
             os.chdir(directory)
             path = os.path.join(directory, "setup.py")
         if os.path.isfile(path):
-            command: Tuple[str, ...] = (sys.executable, path) + args
+            command: tuple[str, ...] = (sys.executable, path, *args)
             try:
                 value = check_output(command).strip().split("\n")[-1]
             except CalledProcessError:
@@ -713,7 +890,7 @@ def _get_setup_py_metadata(path: str, args: Tuple[str, ...]) -> str:
                 setup_egg_info(directory)
                 try:
                     value = check_output(command).strip().split("\n")[-1]
-                except Exception:
+                except Exception:  # noqa: BLE001
                     warn(
                         f"A package name could not be found in {path}"
                         f"\nError ignored: {get_exception_text()}",
@@ -732,7 +909,7 @@ def _get_pyproject_toml_project_metadata(path: str, key: str) -> str:
     if os.path.isfile(path):
         pyproject_io: IO[str]
         with open(path) as pyproject_io:
-            pyproject: Dict[str, Any] = tomli.loads(pyproject_io.read())
+            pyproject: dict[str, Any] = tomli.loads(pyproject_io.read())
             if "project" in pyproject:
                 return pyproject["project"].get(key, "")
     return ""
@@ -760,15 +937,15 @@ def get_setup_distribution_version(path: str) -> str:
     )
 
 
-def _setup(arguments: Tuple[str, ...]) -> None:
+def _setup(arguments: tuple[str, ...]) -> None:
     try:
-        check_output((sys.executable, "setup.py") + arguments)
+        check_output((sys.executable, "setup.py", *arguments))
     except CalledProcessError:
         warn(f"Ignoring error: {get_exception_text()}", stacklevel=2)
 
 
 def _setup_location(
-    location: Union[str, Path], arguments: Iterable[Tuple[str, ...]]
+    location: str | Path, arguments: Iterable[tuple[str, ...]]
 ) -> None:
     if isinstance(location, str):
         location = Path(location)
@@ -786,10 +963,10 @@ def _setup_location(
 
 
 def get_editable_distribution_location(name: str) -> str:
-    return get_editable_distributions_locations().get(normalize_name(name), "")
+    return map_editable_project_locations().get(normalize_name(name), "")
 
 
-def setup_egg_info(directory: Union[str, Path], egg_base: str = "") -> None:
+def setup_egg_info(directory: str | Path, egg_base: str = "") -> None:
     """
     Refresh egg-info for the editable package installed in
     `directory` (only applicable for packages using a `setup.py` script)
@@ -819,27 +996,30 @@ def get_requirement(
 ) -> Requirement:
     try:
         return Requirement(requirement_string)
-    except InvalidRequirement:
+    except InvalidRequirement as error:
         # Try to parse the requirement as an installation target location,
         # such as can be used with `pip install`
         location: str = requirement_string
         extras: str = ""
         if "[" in requirement_string and requirement_string.endswith("]"):
-            parts: List[str] = requirement_string.split("[")
+            parts: list[str] = requirement_string.split("[")
             location = "[".join(parts[:-1])
             extras = f"[{parts[-1]}"
         location = os.path.abspath(location)
         name: str = get_setup_distribution_name(location)
-        assert name, f"No distribution found in {location}"
+        if not name:
+            message: str = f"No distribution found in {location}"
+            raise FileNotFoundError(message) from error
         return Requirement(f"{name}{extras}")
 
 
 def get_required_distribution_names(
     requirement_string: str,
+    *,
     exclude: Iterable[str] = (),
     recursive: bool = True,
     echo: bool = False,
-    depth: Optional[int] = None,
+    depth: int | None = None,
 ) -> MutableSet[str]:
     """
     Return a `tuple` of all distribution names which are required by the
@@ -878,10 +1058,11 @@ def _get_requirement_name(requirement: Requirement) -> str:
     return normalize_name(requirement.name)
 
 
-def install_requirement(
-    requirement: Union[str, Requirement],
-    echo: bool = True,
-) -> None:
+@deprecated(
+    "dependence._utilities.install_requirement is deprecated and will be "
+    "removed in a future release."
+)
+def install_requirement(requirement: str | Requirement) -> None:
     """
     Install a requirement
 
@@ -899,27 +1080,51 @@ def install_requirement(
 def _install_requirement_string(
     requirement_string: str,
     name: str = "",
+    *,
     editable: bool = False,
 ) -> None:
     """
     Install a requirement string with no dependencies, compilation, build
     isolation, etc.
     """
-    command: Tuple[str, ...] = (
-        sys.executable,
-        "-m",
-        "pip",
-        "install",
-        "--no-deps",
-        "--no-compile",
-    )
-    if editable:
-        command += (
-            "-e",
-            requirement_string,
+    command: tuple[str, ...]
+    uv: str | None = shutil.which("uv")
+    if uv:
+        command = (
+            uv,
+            "pip",
+            "install",
+            "--python",
+            sys.executable,
+            "--no-deps",
+            "--no-compile",
+            *(
+                (
+                    "-e",
+                    requirement_string,
+                )
+                if editable
+                else (requirement_string,)
+            ),
         )
     else:
-        command += (requirement_string,)
+        # If `uv` is not available, use `pip`
+        command = (
+            sys.executable,
+            "-m",
+            "pip",
+            "install",
+            "--no-deps",
+            "--no-compile",
+            *(
+                (
+                    "-e",
+                    requirement_string,
+                )
+                if editable
+                else (requirement_string,)
+            ),
+        )
     try:
         check_output(command)
     except CalledProcessError as error:
@@ -943,13 +1148,13 @@ def _install_requirement_string(
             )
         )
         if not editable:
-            print(message)
-            raise error
+            print(message)  # noqa: T201
+            raise
         try:
-            check_output(command + ("--force-reinstall",))
-        except CalledProcessError as retry_error:
-            print(message)
-            raise retry_error
+            check_output((*command, "--force-reinstall"))
+        except CalledProcessError:
+            print(message)  # noqa: T201
+            raise
 
 
 def _install_requirement(
@@ -957,7 +1162,7 @@ def _install_requirement(
 ) -> None:
     requirement_string: str = str(requirement)
     # Get the distribution name
-    distribution: Optional[Distribution] = None
+    distribution: Distribution | None = None
     editable_location: str = ""
     try:
         distribution = _get_distribution(requirement.name)
@@ -984,35 +1189,20 @@ def _install_requirement(
     cache_clear()
 
 
-def _get_requirement_distribution(
-    requirement: Requirement,
+def _get_installed_distribution(
     name: str,
-    reinstall: bool = True,
-    echo: bool = False,
-) -> Optional[Distribution]:
+) -> Distribution | None:
     if name in _BUILTIN_DISTRIBUTION_NAMES:
         return None
     try:
         return get_installed_distributions()[name]
     except KeyError:
-        if not reinstall:
-            raise
-        if echo:
-            warn(
-                f'The required distribution "{name}" was not installed, '
-                "attempting to install it now...",
-                stacklevel=2,
-            )
-        # Attempt to install the requirement...
-        install_requirement(requirement, echo=echo)
-        return _get_requirement_distribution(
-            requirement, name, reinstall=False, echo=echo
-        )
+        return None
 
 
 def _iter_distribution_requirements(
     distribution: Distribution,
-    extras: Tuple[str, ...] = (),
+    extras: tuple[str, ...] = (),
     exclude: Container[str] = (),
 ) -> Iterable[Requirement]:
     if not distribution.requires:
@@ -1031,24 +1221,23 @@ def _iter_distribution_requirements(
 
 def _iter_requirement_names(
     requirement: Requirement,
+    *,
     exclude: MutableSet[str],
     recursive: bool = True,
     echo: bool = False,
-    depth: Optional[int] = None,
+    depth: int | None = None,
 ) -> Iterable[str]:
     name: str = normalize_name(requirement.name)
-    extras: Tuple[str, ...] = tuple(requirement.extras)
+    extras: tuple[str, ...] = tuple(requirement.extras)
     if name in exclude:
         return ()
     # Ensure we don't follow the same requirement again, causing cyclic
     # recursion
     exclude.add(name)
-    distribution: Optional[Distribution] = _get_requirement_distribution(
-        requirement, name, echo=echo
-    )
+    distribution: Distribution | None = _get_installed_distribution(name)
     if distribution is None:
         return ()
-    requirements: Tuple[Requirement, ...] = tuple(
+    requirements: tuple[Requirement, ...] = tuple(
         iter_distinct(
             _iter_distribution_requirements(
                 distribution,
@@ -1061,13 +1250,13 @@ def _iter_requirement_names(
 
     def iter_requirement_names_(
         requirement_: Requirement,
-        depth_: Optional[int] = None,
+        depth_: int | None = None,
     ) -> Iterable[str]:
         if (depth_ is None) or depth_ >= 0:
             yield from _iter_requirement_names(
                 requirement_,
                 exclude=cast(
-                    MutableSet[str],
+                    "MutableSet[str]",
                     exclude
                     | (
                         lateral_exclude - {_get_requirement_name(requirement_)}