Upgrade Python code to 3.10

Author: seddonym

docs/conf.py

@@ -1,4 +1,3 @@
-# -*- coding: utf-8 -*-
 #
 # Configuration file for the Sphinx documentation builder.
 #

src/grimp/adaptors/caching.py

@@ -2,7 +2,7 @@
 
 import json
 import logging
-from typing import Dict, List, Optional, Set, Tuple, Type
+from typing import Optional
 
 from grimp.application.ports.filesystem import AbstractFileSystem
 from grimp.application.ports.modulefinder import FoundPackage, ModuleFile
@@ -13,7 +13,7 @@
 from grimp import _rustgrimp as rust  # type: ignore[attr-defined]
 
 logger = logging.getLogger(__name__)
-PrimitiveFormat = Dict[str, List[Tuple[str, Optional[int], str]]]
+PrimitiveFormat = dict[str, list[tuple[str, Optional[int], str]]]
 
 
 class CacheFileNamer:
@@ -24,7 +24,7 @@ def make_meta_file_name(cls, found_package: FoundPackage) -> str:
     @classmethod
     def make_data_file_name(
         cls,
-        found_packages: Set[FoundPackage],
+        found_packages: set[FoundPackage],
         include_external_packages: bool,
         exclude_type_checking_imports: bool,
     ) -> str:
@@ -42,7 +42,7 @@ def make_data_file_name(
     @classmethod
     def make_data_file_unique_string(
         cls,
-        found_packages: Set[FoundPackage],
+        found_packages: set[FoundPackage],
         include_external_packages: bool,
         exclude_type_checking_imports: bool,
     ) -> str:
@@ -65,24 +65,24 @@ def make_data_file_unique_string(
 class Cache(AbstractCache):
     DEFAULT_CACHE_DIR = ".grimp_cache"
 
-    def __init__(self, *args, namer: Type[CacheFileNamer], **kwargs) -> None:
+    def __init__(self, *args, namer: type[CacheFileNamer], **kwargs) -> None:
         """
         Don't instantiate Cache directly; use Cache.setup().
         """
         super().__init__(*args, **kwargs)
-        self._mtime_map: Dict[str, float] = {}
-        self._data_map: Dict[Module, Set[DirectImport]] = {}
+        self._mtime_map: dict[str, float] = {}
+        self._data_map: dict[Module, set[DirectImport]] = {}
         self._namer = namer
 
     @classmethod
     def setup(
         cls,
         file_system: AbstractFileSystem,
-        found_packages: Set[FoundPackage],
+        found_packages: set[FoundPackage],
         include_external_packages: bool,
         exclude_type_checking_imports: bool = False,
-        cache_dir: Optional[str] = None,
-        namer: Type[CacheFileNamer] = CacheFileNamer,
+        cache_dir: str | None = None,
+        namer: type[CacheFileNamer] = CacheFileNamer,
     ) -> "Cache":
         cache = cls(
             file_system=file_system,
@@ -98,10 +98,10 @@ def setup(
         return cache
 
     @classmethod
-    def cache_dir_or_default(cls, cache_dir: Optional[str]) -> str:
+    def cache_dir_or_default(cls, cache_dir: str | None) -> str:
         return cache_dir or cls.DEFAULT_CACHE_DIR
 
-    def read_imports(self, module_file: ModuleFile) -> Set[DirectImport]:
+    def read_imports(self, module_file: ModuleFile) -> set[DirectImport]:
         try:
             cached_mtime = self._mtime_map[module_file.module.name]
         except KeyError:
@@ -118,7 +118,7 @@ def read_imports(self, module_file: ModuleFile) -> Set[DirectImport]:
 
     def write(
         self,
-        imports_by_module: Dict[Module, Set[DirectImport]],
+        imports_by_module: dict[Module, set[DirectImport]],
     ) -> None:
         self._write_marker_files_if_not_already_there()
         # Write data file.
@@ -165,13 +165,13 @@ def write(
     def _build_mtime_map(self) -> None:
         self._mtime_map = self._read_mtime_map_files()
 
-    def _read_mtime_map_files(self) -> Dict[str, float]:
-        all_mtimes: Dict[str, float] = {}
+    def _read_mtime_map_files(self) -> dict[str, float]:
+        all_mtimes: dict[str, float] = {}
         for found_package in self.found_packages:
             all_mtimes.update(self._read_mtime_map_file(found_package))
         return all_mtimes
 
-    def _read_mtime_map_file(self, found_package: FoundPackage) -> Dict[str, float]:
+    def _read_mtime_map_file(self, found_package: FoundPackage) -> dict[str, float]:
         meta_cache_filename = self.file_system.join(
             self.cache_dir, self._namer.make_meta_file_name(found_package)
         )
@@ -191,7 +191,7 @@ def _read_mtime_map_file(self, found_package: FoundPackage) -> Dict[str, float]:
     def _build_data_map(self) -> None:
         self._data_map = self._read_data_map_file()
 
-    def _read_data_map_file(self) -> Dict[Module, Set[DirectImport]]:
+    def _read_data_map_file(self) -> dict[Module, set[DirectImport]]:
         data_cache_filename = self.file_system.join(
             self.cache_dir,
             self._namer.make_data_file_name(

src/grimp/adaptors/filesystem.py

@@ -1,6 +1,6 @@
 import os
 import tokenize
-from typing import Iterator, List, Tuple
+from collections.abc import Iterator
 
 from grimp.application.ports.filesystem import AbstractFileSystem, BasicFileSystem
 from grimp import _rustgrimp as rust  # type: ignore[attr-defined]
@@ -18,13 +18,13 @@ def sep(self) -> str:
     def dirname(self, filename: str) -> str:
         return os.path.dirname(filename)
 
-    def walk(self, directory_name: str) -> Iterator[Tuple[str, List[str], List[str]]]:
+    def walk(self, directory_name: str) -> Iterator[tuple[str, list[str], list[str]]]:
         yield from os.walk(directory_name, followlinks=True)
 
     def join(self, *components: str) -> str:
         return os.path.join(*components)
 
-    def split(self, file_name: str) -> Tuple[str, str]:
+    def split(self, file_name: str) -> tuple[str, str]:
         return os.path.split(file_name)
 
     def read(self, file_name: str) -> str:

src/grimp/adaptors/modulefinder.py

@@ -1,5 +1,5 @@
 import logging
-from typing import Iterable, List
+from collections.abc import Iterable
 
 from grimp.application.ports import modulefinder
 from grimp.application.ports.filesystem import AbstractFileSystem
@@ -14,7 +14,7 @@ def find_package(
     ) -> modulefinder.FoundPackage:
         self.file_system = file_system
 
-        module_files: List[modulefinder.ModuleFile] = []
+        module_files: list[modulefinder.ModuleFile] = []
 
         for module_filename in self._get_python_files_inside_package(package_directory):
             module_name = self._module_name_from_filename(

src/grimp/adaptors/packagefinder.py

@@ -19,10 +19,8 @@ def determine_package_directory(
         # Attempt to locate the package file.
         spec = importlib.util.find_spec(package_name)
         if not spec:
-            logger.debug("sys.path: {}".format(sys.path))
-            raise ValueError(
-                "Could not find package '{}' in your Python path.".format(package_name)
-            )
+            logger.debug(f"sys.path: {sys.path}")
+            raise ValueError(f"Could not find package '{package_name}' in your Python path.")
 
         if spec.has_location and spec.origin:
             if not self._is_a_package(spec, file_system) or self._has_a_non_namespace_parent(spec):

src/grimp/application/graph.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
-from typing import List, Optional, Sequence, Set, Tuple, TypedDict
+from typing import TypedDict
+from collections.abc import Sequence
 from grimp.domain.analysis import PackageDependency, Route
 from grimp.domain.valueobjects import Layer
 from grimp import _rustgrimp as rust  # type: ignore[attr-defined]
@@ -18,7 +19,7 @@ class Import(TypedDict):
 
 # Corresponds to importer, imported.
 # Prefer this form to Import, as it's both more lightweight, and hashable.
-ImportTuple = Tuple[str, str]
+ImportTuple = tuple[str, str]
 
 
 class DetailedImport(Import):
@@ -33,22 +34,22 @@ class ImportGraph:
 
     def __init__(self) -> None:
         super().__init__()
-        self._cached_modules: Set[str] | None = None
+        self._cached_modules: set[str] | None = None
         self._rustgraph = rust.Graph()
 
     # Mechanics
     # ---------
 
     @property
-    def modules(self) -> Set[str]:
+    def modules(self) -> set[str]:
         """
         The names of all the modules in the graph.
         """
         if self._cached_modules is None:
             self._cached_modules = self._rustgraph.get_modules()
         return self._cached_modules
 
-    def find_matching_modules(self, expression: str) -> Set[str]:
+    def find_matching_modules(self, expression: str) -> set[str]:
         """
         Find all modules matching the passed expression.
 
@@ -135,8 +136,8 @@ def add_import(
         *,
         importer: str,
         imported: str,
-        line_number: Optional[int] = None,
-        line_contents: Optional[str] = None,
+        line_number: int | None = None,
+        line_contents: str | None = None,
     ) -> None:
         """
         Add a direct import between two modules to the graph. If the modules are not already
@@ -166,7 +167,7 @@ def count_imports(self) -> int:
     # Descendants
     # -----------
 
-    def find_children(self, module: str) -> Set[str]:
+    def find_children(self, module: str) -> set[str]:
         """
         Find all modules one level below the module. For example, the children of
         foo.bar might be foo.bar.one and foo.bar.two, but not foo.bar.two.green.
@@ -180,7 +181,7 @@ def find_children(self, module: str) -> Set[str]:
             raise ValueError("Cannot find children of a squashed module.")
         return self._rustgraph.find_children(module)
 
-    def find_descendants(self, module: str) -> Set[str]:
+    def find_descendants(self, module: str) -> set[str]:
         """
         Find all modules below the module. For example, the descendants of
         foo.bar might be foo.bar.one and foo.bar.two and foo.bar.two.green.
@@ -213,16 +214,16 @@ def direct_import_exists(
             importer=importer, imported=imported, as_packages=as_packages
         )
 
-    def find_modules_directly_imported_by(self, module: str) -> Set[str]:
+    def find_modules_directly_imported_by(self, module: str) -> set[str]:
         return self._rustgraph.find_modules_directly_imported_by(module)
 
-    def find_modules_that_directly_import(self, module: str) -> Set[str]:
+    def find_modules_that_directly_import(self, module: str) -> set[str]:
         if self._rustgraph.contains_module(module):
             # TODO panics if module isn't in modules.
             return self._rustgraph.find_modules_that_directly_import(module)
         return set()
 
-    def get_import_details(self, *, importer: str, imported: str) -> List[DetailedImport]:
+    def get_import_details(self, *, importer: str, imported: str) -> list[DetailedImport]:
         """
         Return available metadata relating to the direct imports between two modules, in the form:
         [
@@ -246,7 +247,7 @@ def get_import_details(self, *, importer: str, imported: str) -> List[DetailedIm
             imported=imported,
         )
 
-    def find_matching_direct_imports(self, import_expression: str) -> List[Import]:
+    def find_matching_direct_imports(self, import_expression: str) -> list[Import]:
         """
         Find all direct imports matching the passed expressions.
 
@@ -290,7 +291,7 @@ def find_matching_direct_imports(self, import_expression: str) -> List[Import]:
     # Indirect imports
     # ----------------
 
-    def find_downstream_modules(self, module: str, as_package: bool = False) -> Set[str]:
+    def find_downstream_modules(self, module: str, as_package: bool = False) -> set[str]:
         """
         Return a set of the names of all the modules that import (even indirectly) the
         supplied module name.
@@ -312,7 +313,7 @@ def find_downstream_modules(self, module: str, as_package: bool = False) -> Set[
         """
         return self._rustgraph.find_downstream_modules(module, as_package)
 
-    def find_upstream_modules(self, module: str, as_package: bool = False) -> Set[str]:
+    def find_upstream_modules(self, module: str, as_package: bool = False) -> set[str]:
         """
         Return a set of the names of all the modules that are imported (even indirectly) by the
         supplied module.
@@ -352,7 +353,7 @@ def find_shortest_chain(
 
     def find_shortest_chains(
         self, importer: str, imported: str, as_packages: bool = True
-    ) -> Set[Tuple[str, ...]]:
+    ) -> set[tuple[str, ...]]:
         """
         Find the shortest import chains that exist between the importer and imported, and
         between any modules contained within them if as_packages is True. Only one chain per
@@ -474,7 +475,7 @@ def __repr__(self) -> str:
             stringified_modules = "empty"
         return f"<{self.__class__.__name__}: {stringified_modules}>"
 
-    def __deepcopy__(self, memodict: dict) -> "ImportGraph":
+    def __deepcopy__(self, memodict: dict) -> ImportGraph:
         new_graph = ImportGraph()
         new_graph._rustgraph = self._rustgraph.clone()
         return new_graph

src/grimp/application/ports/caching.py

@@ -1,5 +1,3 @@
-from typing import Dict, Optional, Set
-
 from grimp.application.ports.modulefinder import FoundPackage, ModuleFile
 from grimp.domain.valueobjects import DirectImport, Module
 
@@ -16,7 +14,7 @@ def __init__(
         file_system: AbstractFileSystem,
         include_external_packages: bool,
         exclude_type_checking_imports: bool,
-        found_packages: Set[FoundPackage],
+        found_packages: set[FoundPackage],
         cache_dir: str,
     ) -> None:
         """
@@ -32,11 +30,11 @@ def __init__(
     def setup(
         cls,
         file_system: AbstractFileSystem,
-        found_packages: Set[FoundPackage],
+        found_packages: set[FoundPackage],
         *,
         include_external_packages: bool,
         exclude_type_checking_imports: bool = False,
-        cache_dir: Optional[str] = None,
+        cache_dir: str | None = None,
     ) -> "Cache":
         cache = cls(
             file_system=file_system,
@@ -47,15 +45,15 @@ def setup(
         )
         return cache
 
-    def read_imports(self, module_file: ModuleFile) -> Set[DirectImport]:
+    def read_imports(self, module_file: ModuleFile) -> set[DirectImport]:
         raise NotImplementedError
 
     def write(
         self,
-        imports_by_module: Dict[Module, Set[DirectImport]],
+        imports_by_module: dict[Module, set[DirectImport]],
     ) -> None:
         raise NotImplementedError
 
     @classmethod
-    def cache_dir_or_default(cls, cache_dir: Optional[str]) -> str:
+    def cache_dir_or_default(cls, cache_dir: str | None) -> str:
         raise NotImplementedError

src/grimp/application/ports/filesystem.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 import abc
-from typing import Iterator, List, Tuple
+from collections.abc import Iterator
 from typing import Protocol
 
 
@@ -28,7 +28,7 @@ def dirname(self, filename: str) -> str:
         raise NotImplementedError
 
     @abc.abstractmethod
-    def walk(self, directory_name: str) -> Iterator[Tuple[str, List[str], List[str]]]:
+    def walk(self, directory_name: str) -> Iterator[tuple[str, list[str], list[str]]]:
         """
         Given a directory, walk the file system recursively.
 
@@ -42,7 +42,7 @@ def join(self, *components: str) -> str:
         raise NotImplementedError
 
     @abc.abstractmethod
-    def split(self, file_name: str) -> Tuple[str, str]:
+    def split(self, file_name: str) -> tuple[str, str]:
         """
         Split the pathname path into a pair, (head, tail) where tail is the last pathname component
         and head is everything leading up to that. The tail part will never contain a slash;
@@ -105,7 +105,7 @@ class BasicFileSystem(Protocol):
 
     def join(self, *components: str) -> str: ...
 
-    def split(self, file_name: str) -> Tuple[str, str]: ...
+    def split(self, file_name: str) -> tuple[str, str]: ...
 
     def read(self, file_name: str) -> str: ...