dependence 1.0.4__py3-none-any.whl → 1.0.5__py3-none-any.whl

dependence/__main__.py

@@ -1,13 +1,16 @@
 import sys
 from importlib import import_module
-from types import ModuleType
+from typing import TYPE_CHECKING
 
-from . import __name__ as _module_name
-from ._utilities import get_exception_text
+if TYPE_CHECKING:
+    from types import ModuleType
+
+from dependence import __name__ as _module_name
+from dependence._utilities import get_exception_text
 
 
 def _print_help() -> None:
-    print(
+    print(  # noqa: T201
         "Usage:\n"
         "  dependence <command> [options]\n\n"
         "Commands:\n"
@@ -47,7 +50,7 @@ def main() -> None:
             module = import_module(f"{_module_name}.{command}")
         module.main()  # type: ignore
     except ImportError:
-        print(get_exception_text())
+        print(get_exception_text())  # noqa: T201
         _print_help()
 
 

dependence/_utilities.py

@@ -1,9 +1,13 @@
+from __future__ import annotations
+
 import functools
 import json
 import os
 import re
 import sys
 from collections import deque
+from collections.abc import Container, Hashable, Iterable, MutableSet
+from collections.abc import Set as AbstractSet
 from configparser import ConfigParser, SectionProxy
 from enum import Enum, auto
 from glob import iglob
@@ -17,20 +21,9 @@ from subprocess import DEVNULL, PIPE, CalledProcessError, list2cmdline, run
 from traceback import format_exception
 from typing import (
     IO,
-    AbstractSet,
     Any,
     Callable,
-    Container,
-    Dict,
-    Hashable,
-    Iterable,
-    List,
-    MutableSet,
-    Optional,
-    Set,
-    Tuple,
     TypedDict,
-    Union,
     cast,
 )
 from warnings import warn
@@ -40,7 +33,7 @@ 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",)
+_BUILTIN_DISTRIBUTION_NAMES: tuple[str] = ("distribute",)
 _UNSAFE_CHARACTERS_PATTERN: re.Pattern = re.compile("[^A-Za-z0-9.]+")
 
 
@@ -48,7 +41,7 @@ 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 +81,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 +92,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 +107,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 +158,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 +173,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 +256,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
@@ -305,18 +298,16 @@ def get_configuration_file_type(path: str) -> ConfigurationFileType:
     basename: str = os.path.basename(path).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."
-        )
+    message: str = f"{path} is not a recognized type of configuration file."
+    raise ValueError(message)
 
 
 def is_configuration_file(path: str) -> bool:
@@ -333,7 +324,7 @@ class _EditablePackageMetadata(TypedDict):
     editable_project_location: str
 
 
-def _iter_editable_distribution_locations() -> Iterable[Tuple[str, str]]:
+def _iter_editable_distribution_locations() -> Iterable[tuple[str, str]]:
     metadata: _EditablePackageMetadata
     for metadata in json.loads(
         check_output(
@@ -354,7 +345,7 @@ def _iter_editable_distribution_locations() -> Iterable[Tuple[str, str]]:
 
 
 @functools.lru_cache
-def get_editable_distributions_locations() -> Dict[str, str]:
+def get_editable_distributions_locations() -> dict[str, str]:
     """
     Get a mapping of (normalized) editable distribution names to their
     locations.
@@ -384,12 +375,12 @@ def refresh_editable_distributions() -> None:
 
 
 @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
     return installed
@@ -425,7 +416,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 +450,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 +463,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 +522,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 +578,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 +594,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 +612,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 +630,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 +639,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
@@ -669,15 +664,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 +693,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 +707,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 +726,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 +754,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)
@@ -789,7 +783,7 @@ def get_editable_distribution_location(name: str) -> str:
     return get_editable_distributions_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 +813,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 +875,7 @@ def _get_requirement_name(requirement: Requirement) -> str:
     return normalize_name(requirement.name)
 
 
-def install_requirement(
-    requirement: Union[str, Requirement],
-    echo: bool = True,
-) -> None:
+def install_requirement(requirement: str | Requirement) -> None:
     """
     Install a requirement
 
@@ -899,13 +893,14 @@ 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, ...] = (
+    command: tuple[str, ...] = (
         sys.executable,
         "-m",
         "pip",
@@ -943,13 +938,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 +952,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)
@@ -987,9 +982,10 @@ def _install_requirement(
 def _get_requirement_distribution(
     requirement: Requirement,
     name: str,
+    *,
     reinstall: bool = True,
     echo: bool = False,
-) -> Optional[Distribution]:
+) -> Distribution | None:
     if name in _BUILTIN_DISTRIBUTION_NAMES:
         return None
     try:
@@ -1004,7 +1000,7 @@ def _get_requirement_distribution(
                 stacklevel=2,
             )
         # Attempt to install the requirement...
-        install_requirement(requirement, echo=echo)
+        install_requirement(requirement)
         return _get_requirement_distribution(
             requirement, name, reinstall=False, echo=echo
         )
@@ -1012,7 +1008,7 @@ def _get_requirement_distribution(
 
 def _iter_distribution_requirements(
     distribution: Distribution,
-    extras: Tuple[str, ...] = (),
+    extras: tuple[str, ...] = (),
     exclude: Container[str] = (),
 ) -> Iterable[Requirement]:
     if not distribution.requires:
@@ -1031,24 +1027,25 @@ 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(
+    distribution: Distribution | None = _get_requirement_distribution(
         requirement, name, echo=echo
     )
     if distribution is None:
         return ()
-    requirements: Tuple[Requirement, ...] = tuple(
+    requirements: tuple[Requirement, ...] = tuple(
         iter_distinct(
             _iter_distribution_requirements(
                 distribution,
@@ -1061,7 +1058,7 @@ 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(

dependence/freeze.py

@@ -1,12 +1,15 @@
+from __future__ import annotations
+
 import argparse
+from collections.abc import Iterable, MutableSet
 from fnmatch import fnmatch
 from functools import partial
 from importlib.metadata import Distribution
 from importlib.metadata import distribution as _get_distribution
 from itertools import chain
-from typing import Dict, Iterable, MutableSet, Optional, Tuple, cast
+from typing import cast
 
-from ._utilities import (
+from dependence._utilities import (
     get_distribution,
     get_required_distribution_names,
     get_requirement_string_distribution_name,
@@ -30,18 +33,18 @@ def _iter_sort_dependents_last(requirements: Iterable[str]) -> Iterable[str]:
     """
     requirements = list(requirements)
     distribution_name: str
-    distribution_requirement: Dict[str, str] = {
+    distribution_requirement: dict[str, str] = {
         get_requirement_string_distribution_name(requirement): requirement
         for requirement in requirements
     }
-    dependent_dependencies: Dict[str, MutableSet[str]] = {
+    dependent_dependencies: dict[str, MutableSet[str]] = {
         distribution_name: get_required_distribution_names(requirement)
         for distribution_name, requirement in distribution_requirement.items()
     }
     while dependent_dependencies:
         dependent: str
         dependencies: MutableSet[str]
-        item: Tuple[str, MutableSet[str]]
+        item: tuple[str, MutableSet[str]]
         for dependent, dependencies in sorted(  # noqa: C414
             tuple(dependent_dependencies.items()),
             key=lambda item: item[0].lower(),
@@ -73,15 +76,16 @@ def _iter_sort_dependents_last(requirements: Iterable[str]) -> Iterable[str]:
 
 def get_frozen_requirements(
     requirements: Iterable[str] = (),
+    *,
     exclude: Iterable[str] = (),
     exclude_recursive: Iterable[str] = (),
     no_version: Iterable[str] = (),
     dependency_order: bool = False,
     reverse: bool = False,
-    depth: Optional[int] = None,
-    include_pointers: Tuple[str, ...] = (),
-    exclude_pointers: Tuple[str, ...] = (),
-) -> Tuple[str, ...]:
+    depth: int | None = None,
+    include_pointers: tuple[str, ...] = (),
+    exclude_pointers: tuple[str, ...] = (),
+) -> tuple[str, ...]:
     """
     Get the (frozen) requirements for one or more specified distributions or
     configuration files.
@@ -183,7 +187,7 @@ def _iter_frozen_requirements(
     exclude: MutableSet[str],
     exclude_recursive: MutableSet[str],
     no_version: Iterable[str] = (),
-    depth: Optional[int] = None,
+    depth: int | None = None,
 ) -> Iterable[str]:
     def get_requirement_string(distribution_name: str) -> str:
         def distribution_name_matches_pattern(pattern: str) -> bool:
@@ -198,13 +202,13 @@ def _iter_frozen_requirements(
             distribution = get_distribution(distribution_name)
         except KeyError:
             # If the distribution is missing, install it
-            install_requirement(distribution_name, echo=False)
+            install_requirement(distribution_name)
             distribution = _get_distribution(distribution_name)
         return f"{distribution.metadata['Name']}=={distribution.version}"
 
     def get_required_distribution_names_(
         requirement_string: str,
-        depth_: Optional[int] = None,
+        depth_: int | None = None,
     ) -> MutableSet[str]:
         name: str = get_requirement_string_distribution_name(
             requirement_string
@@ -234,20 +238,20 @@ def _iter_frozen_requirements(
             )
         ),
     )
-    requirements = map(get_requirement_string, requirements)
-    return requirements
+    return map(get_requirement_string, requirements)
 
 
 def freeze(
     requirements: Iterable[str] = (),
+    *,
     exclude: Iterable[str] = (),
     exclude_recursive: Iterable[str] = (),
     no_version: Iterable[str] = (),
     dependency_order: bool = False,
     reverse: bool = False,
-    depth: Optional[int] = None,
-    include_pointers: Tuple[str, ...] = (),
-    exclude_pointers: Tuple[str, ...] = (),
+    depth: int | None = None,
+    include_pointers: tuple[str, ...] = (),
+    exclude_pointers: tuple[str, ...] = (),
 ) -> None:
     """
     Print the (frozen) requirements for one or more specified requirements or
@@ -273,7 +277,7 @@ def freeze(
         exclude_pointers: If not empty, these TOML tables will *not* be
             inspected (for pyproject.toml files)
     """
-    print(
+    print(  # noqa: T201
         "\n".join(
             get_frozen_requirements(
                 requirements=requirements,

dependence/update.py

@@ -1,23 +1,18 @@
+from __future__ import annotations
+
 import argparse
 import re
 from collections import deque
 from configparser import ConfigParser, SectionProxy
 from copy import deepcopy
 from dataclasses import dataclass
-from importlib.metadata import Distribution
 from io import StringIO
 from itertools import chain
 from typing import (
     IO,
+    TYPE_CHECKING,
     Any,
     Callable,
-    Dict,
-    Iterable,
-    List,
-    Optional,
-    Set,
-    Tuple,
-    Union,
 )
 
 import tomli
@@ -27,7 +22,7 @@ from packaging.specifiers import Specifier, SpecifierSet
 from packaging.version import Version
 from packaging.version import parse as parse_version
 
-from ._utilities import (
+from dependence._utilities import (
     ConfigurationFileType,
     get_configuration_file_type,
     get_installed_distributions,
@@ -38,6 +33,10 @@ from ._utilities import (
     normalize_name,
 )
 
+if TYPE_CHECKING:
+    from collections.abc import Iterable
+    from importlib.metadata import Distribution
+
 
 @dataclass
 class _Version:
@@ -48,7 +47,7 @@ class _Version:
     """
 
     epoch: int
-    release: Tuple[int, ...]
+    release: tuple[int, ...]
     pre: Any
     post: Any
     dev: Any
@@ -64,13 +63,14 @@ def _update_requirement_specifiers(
     """
     installed_version: Version = parse_version(installed_version_string)
     specifier: Specifier
-    updated_specifier_strings: List[str] = []
+    updated_specifier_strings: list[str] = []
     for specifier in requirement.specifier:  # type: ignore
         # Only update requirement to match our installed version
         # if the requirement is *inclusive*
         if ("=" in specifier.operator) and ("!" not in specifier.operator):
             specifier_version: Version = parse_version(specifier.version)
-            assert installed_version.release is not None
+            if installed_version.release is None:
+                raise ValueError(installed_version)
             if specifier_version.release is None:
                 updated_specifier_strings.append(f"{specifier.operator}")
             else:
@@ -117,7 +117,7 @@ def _update_requirement_specifiers(
 
 
 def _get_updated_requirement_string(
-    requirement_string: str, ignore: Set[str]
+    requirement_string: str, ignore: set[str]
 ) -> str:
     """
     This function updates version numbers in a requirement string to match
@@ -139,8 +139,8 @@ def _get_updated_requirement_string(
     return str(requirement)
 
 
-def _normalize_ignore_argument(ignore: Iterable[str]) -> Set[str]:
-    ignore_set: Set[str]
+def _normalize_ignore_argument(ignore: Iterable[str]) -> set[str]:
+    ignore_set: set[str]
     # Normalize/harmonize excluded project names
     if isinstance(ignore, str):
         ignore = (ignore,)
@@ -161,7 +161,7 @@ def _get_updated_requirements_txt(
     - data (str): The contents of a *requirements.txt* file
     - ignore ([str]): One or more project names to leave as-is
     """
-    ignore_set: Set[str] = _normalize_ignore_argument(ignore)
+    ignore_set: set[str] = _normalize_ignore_argument(ignore)
 
     def get_updated_requirement_string(requirement: str) -> str:
         return _get_updated_requirement_string(requirement, ignore=ignore_set)
@@ -184,7 +184,7 @@ def _get_updated_setup_cfg(
     - all_extra_name (str): An (optional) extra name which will
       consolidate requirements from all other extras
     """
-    ignore_set: Set[str] = _normalize_ignore_argument(ignore)
+    ignore_set: set[str] = _normalize_ignore_argument(ignore)
 
     def get_updated_requirement_string(requirement: str) -> str:
         return _get_updated_requirement_string(requirement, ignore=ignore_set)
@@ -202,10 +202,10 @@ def _get_updated_setup_cfg(
         )
     if "options.extras_require" in parser:
         extras_require: SectionProxy = parser["options.extras_require"]
-        all_extra_requirements: List[str] = []
+        all_extra_requirements: list[str] = []
         extra_name: str
         extra_requirements_string: str
-        extra_requirements: List[str]
+        extra_requirements: list[str]
         for extra_name, extra_requirements_string in extras_require.items():
             if extra_name != all_extra_name:
                 extra_requirements = list(
@@ -223,7 +223,7 @@ def _get_updated_setup_cfg(
             # We pre-pend an empty requirement string in order to]
             # force new-line creation at the beginning of the extra
             extras_require[all_extra_name] = "\n".join(
-                iter_distinct([""] + all_extra_requirements)
+                iter_distinct(["", *all_extra_requirements])
             )
     # Return as a string
     setup_cfg: str
@@ -246,10 +246,10 @@ def _get_updated_tox_ini(data: str, ignore: Iterable[str] = ()) -> str:
     - data (str): The contents of a **tox.ini** file
     - ignore ([str]): One or more project names to leave as-is
     """
-    ignore_set: Set[str] = _normalize_ignore_argument(ignore)
+    ignore_set: set[str] = _normalize_ignore_argument(ignore)
 
     def get_updated_requirement_string(requirement: str) -> str:
-        prefix: Optional[str] = None
+        prefix: str | None = None
         if ":" in requirement:
             prefix, requirement = requirement.split(":", maxsplit=1)
         requirement = _get_updated_requirement_string(
@@ -294,18 +294,18 @@ def _get_updated_tox_ini(data: str, ignore: Iterable[str] = ()) -> str:
 
 
 def _update_document_requirements(
-    document: Dict[str, Any],
+    document: dict[str, Any],
     ignore: Iterable[str] = (),
-    include_pointers: Tuple[str, ...] = (),
-    exclude_pointers: Tuple[str, ...] = (),
+    include_pointers: tuple[str, ...] = (),
+    exclude_pointers: tuple[str, ...] = (),
 ) -> None:
-    ignore_set: Set[str] = _normalize_ignore_argument(ignore)
+    ignore_set: set[str] = _normalize_ignore_argument(ignore)
 
     def get_updated_requirement_string(requirement: str) -> str:
         return _get_updated_requirement_string(requirement, ignore=ignore_set)
 
     # Find and update requirements
-    requirements_list: List[str]
+    requirements_list: list[str]
     for requirements_list in iter_find_requirements_lists(
         document,
         include_pointers=include_pointers,
@@ -323,8 +323,8 @@ def _get_updated_pyproject_toml(
     data: str,
     ignore: Iterable[str] = (),
     all_extra_name: str = "",
-    include_pointers: Tuple[str, ...] = (),
-    exclude_pointers: Tuple[str, ...] = (),
+    include_pointers: tuple[str, ...] = (),
+    exclude_pointers: tuple[str, ...] = (),
 ) -> str:
     """
     Return the contents of a *pyproject.toml* file, updated to reflect the
@@ -345,8 +345,8 @@ def _get_updated_pyproject_toml(
         The contents of the updated pyproject.toml file.
     """
     # Parse pyproject.toml
-    original_pyproject: Dict[str, Any] = tomli.loads(data)
-    updated_pyproject: Dict[str, Any] = deepcopy(original_pyproject)
+    original_pyproject: dict[str, Any] = tomli.loads(data)
+    updated_pyproject: dict[str, Any] = deepcopy(original_pyproject)
     # Find and update requirements
     _update_document_requirements(
         updated_pyproject,
@@ -355,13 +355,13 @@ def _get_updated_pyproject_toml(
         exclude_pointers=exclude_pointers,
     )
     # Update consolidated optional requirements
-    project_optional_dependencies: Dict[str, List[str]] = (
+    project_optional_dependencies: dict[str, list[str]] = (
         updated_pyproject.get("project", {}).get("optional-dependencies", {})
     )
     # Update an extra indicated to encompass all other extras
     if project_optional_dependencies and all_extra_name:
         key: str
-        dependencies: List[str]
+        dependencies: list[str]
         project_optional_dependencies[all_extra_name] = list(
             iter_distinct(
                 chain(
@@ -384,8 +384,8 @@ def _get_updated_pyproject_toml(
 def _get_updated_toml(
     data: str,
     ignore: Iterable[str] = (),
-    include_pointers: Tuple[str, ...] = (),
-    exclude_pointers: Tuple[str, ...] = (),
+    include_pointers: tuple[str, ...] = (),
+    exclude_pointers: tuple[str, ...] = (),
 ) -> str:
     """
     Return the contents of a TOML file, updated to reflect the
@@ -407,8 +407,8 @@ def _get_updated_toml(
         The contents of the updated TOML file.
     """
     # Parse pyproject.toml
-    original_pyproject: Dict[str, Any] = tomli.loads(data)
-    updated_pyproject: Dict[str, Any] = deepcopy(original_pyproject)
+    original_pyproject: dict[str, Any] = tomli.loads(data)
+    updated_pyproject: dict[str, Any] = deepcopy(original_pyproject)
     # Find and update requirements
     _update_document_requirements(
         updated_pyproject,
@@ -426,12 +426,12 @@ def _update(
     path: str,
     ignore: Iterable[str] = (),
     all_extra_name: str = "",
-    include_pointers: Tuple[str, ...] = (),
-    exclude_pointers: Tuple[str, ...] = (),
+    include_pointers: tuple[str, ...] = (),
+    exclude_pointers: tuple[str, ...] = (),
 ) -> None:
     data: str
     update_function: Callable[[str], str]
-    kwargs: Dict[str, Union[str, Iterable[str]]] = {}
+    kwargs: dict[str, str | Iterable[str]] = {}
     configuration_file_type: ConfigurationFileType = (
         get_configuration_file_type(path)
     )
@@ -457,18 +457,21 @@ def _update(
     elif configuration_file_type == ConfigurationFileType.REQUIREMENTS_TXT:
         update_function = _get_updated_requirements_txt
     else:
-        raise NotImplementedError(
-            f"Updating requirements for {path} is not supported"
-        )
+        msg = f"Updating requirements for {path} is not supported"
+        raise NotImplementedError(msg)
     kwargs["ignore"] = ignore
     file_io: IO[str]
     with open(path) as file_io:
         data = file_io.read()
     updated_data: str = update_function(data, **kwargs)
     if updated_data == data:
-        print(f"All requirements were already up-to-date in {path}")
+        print(  # noqa: T201
+            f"All requirements were already up-to-date in {path}"
+        )
     else:
-        print(f"Updating requirements in {path}")
+        print(  # noqa: T201
+            f"Updating requirements in {path}"
+        )
         with open(path, "w") as file_io:
             file_io.write(updated_data)
 
@@ -477,8 +480,8 @@ def update(
     paths: Iterable[str],
     ignore: Iterable[str] = (),
     all_extra_name: str = "",
-    include_pointers: Tuple[str, ...] = (),
-    exclude_pointers: Tuple[str, ...] = (),
+    include_pointers: tuple[str, ...] = (),
+    exclude_pointers: tuple[str, ...] = (),
 ) -> None:
     """
     Update requirement versions in the specified files.

{dependence-1.0.4.dist-info → dependence-1.0.5.dist-info}/METADATA

@@ -1,18 +1,18 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.4
 Name: dependence
-Version: 1.0.4
+Version: 1.0.5
 Summary: A dependency management tool for python projects
 Project-URL: Documentation, https://dependence.enorganic.org
 Project-URL: Repository, https://github.com/enorganic/dependence
 Author-email: david@belais.me
-License: MIT
+License-Expression: MIT
 Keywords: dependencies,requirements
-Requires-Python: ~=3.8
+Requires-Python: ~=3.9
 Requires-Dist: jsonpointer
 Requires-Dist: packaging
 Requires-Dist: pip
 Requires-Dist: setuptools>63
-Requires-Dist: tomli-w~=1.0
+Requires-Dist: tomli-w~=1.2
 Requires-Dist: tomli~=2.2
 Description-Content-Type: text/markdown
 

dependence-1.0.5.dist-info/RECORD

@@ -0,0 +1,10 @@
+dependence/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+dependence/__main__.py,sha256=7CMLje-1PBFD8Wl0Vixx7lYHP213nlhSOExXHB0nuI4,1631
+dependence/_utilities.py,sha256=UARyW3wV3zbMWLwIl3jUvA8aS97wOEi8wDQVLKPksP0,33875
+dependence/freeze.py,sha256=fqx1-pHaly4sxHjArRp0Dltb1fpg3njCNgp9OahwP7w,14877
+dependence/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+dependence/update.py,sha256=p6X5748YTN1Nn83WUm73iYpiKhj12JeTTeY6NKbF8ok,20132
+dependence-1.0.5.dist-info/METADATA,sha256=7tlSVTiKDOn1udE-7znCSTOOQ-Kor6IK73JDSYkn_bM,5581
+dependence-1.0.5.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+dependence-1.0.5.dist-info/entry_points.txt,sha256=NStO_B0D81ObVYr9zDs6LCy0whm0a8KCiiFHMmTwOVE,56
+dependence-1.0.5.dist-info/RECORD,,

{dependence-1.0.4.dist-info → dependence-1.0.5.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: hatchling 1.26.3
+Generator: hatchling 1.27.0
 Root-Is-Purelib: true
 Tag: py3-none-any

dependence-1.0.4.dist-info/RECORD

@@ -1,10 +0,0 @@
-dependence/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-dependence/__main__.py,sha256=myBIBZdez2jC3_dkVSE-mOLo39yKi2cF_0NuVXcXF1E,1528
-dependence/_utilities.py,sha256=gUFC6lzd3T60_-3kqzqTJRmmilzM64HRHz6rxjhJd9c,33697
-dependence/freeze.py,sha256=t9yoavc8h5OWA5za_tNrEQIGThFHy679O-6MnXUBZmQ,14855
-dependence/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-dependence/update.py,sha256=ymncDTVh9UxECQwOIcU3OWIfhvCP3kdQlyKfJH34CoU,19978
-dependence-1.0.4.dist-info/METADATA,sha256=YQEq7pvYyjuLn23mF7yUcztYyFK-K2UbzE0l27gWEvw,5570
-dependence-1.0.4.dist-info/WHEEL,sha256=C2FUgwZgiLbznR-k0b_5k3Ai_1aASOXDss3lzCUsUug,87
-dependence-1.0.4.dist-info/entry_points.txt,sha256=NStO_B0D81ObVYr9zDs6LCy0whm0a8KCiiFHMmTwOVE,56
-dependence-1.0.4.dist-info/RECORD,,