refactor(typing): Replace Any with precise types across codebase

conftest.py

@@ -22,7 +22,7 @@
 @pytest.fixture(autouse=True)
 def add_doctest_fixtures(
     request: pytest.FixtureRequest,
-    doctest_namespace: dict[str, t.Any],
+    doctest_namespace: dict[str, object],
 ) -> None:
     """Harness pytest fixtures to doctests namespace."""
     from _pytest.doctest import DoctestItem

scripts/generate_gitlab.py

@@ -12,7 +12,6 @@
 
 import requests
 import yaml
-from libvcs.sync.git import GitRemote
 
 from vcspull.cli.sync import CouldNotGuessVCSFromURL, guess_vcs
 
@@ -108,11 +107,10 @@
         "path": path / reponame,
         "url": f"git+ssh://{url_to_repo}",
         "remotes": {
-            "origin": GitRemote(
-                name="origin",
-                fetch_url=f"ssh://{url_to_repo}",
-                push_url=f"ssh://{url_to_repo}",
-            ),
+            "origin": {
+                "fetch_url": f"ssh://{url_to_repo}",
+                "push_url": f"ssh://{url_to_repo}",
+            },
         },
         "vcs": vcs,
     }

src/vcspull/_internal/config_reader.py

@@ -8,7 +8,7 @@
 import yaml
 
 FormatLiteral = t.Literal["json", "yaml"]
-RawConfigData: t.TypeAlias = dict[t.Any, t.Any]
+RawConfigData: t.TypeAlias = dict[str, object]
 
 
 class ConfigReader:
@@ -25,7 +25,7 @@ def __init__(self, content: RawConfigData) -> None:
         self.content = content
 
     @staticmethod
-    def _load(fmt: FormatLiteral, content: str) -> dict[str, t.Any]:
+    def _load(fmt: FormatLiteral, content: str) -> dict[str, object]:
         """Load raw config data and directly return it.
 
         >>> ConfigReader._load("json", '{ "session_name": "my session" }')
@@ -36,14 +36,14 @@ def _load(fmt: FormatLiteral, content: str) -> dict[str, t.Any]:
         """
         if fmt == "yaml":
             return t.cast(
-                "dict[str, t.Any]",
+                "dict[str, object]",
                 yaml.load(
                     content,
                     Loader=yaml.SafeLoader,
                 ),
             )
         if fmt == "json":
-            return t.cast("dict[str, t.Any]", json.loads(content))
+            return t.cast("dict[str, object]", json.loads(content))
         msg = f"{fmt} not supported in configuration"
         raise NotImplementedError(msg)
 
@@ -71,7 +71,7 @@ def load(cls, fmt: FormatLiteral, content: str) -> ConfigReader:
         )
 
     @classmethod
-    def _from_file(cls, path: pathlib.Path) -> dict[str, t.Any]:
+    def _from_file(cls, path: pathlib.Path) -> dict[str, object]:
         r"""Load data from file path directly to dictionary.
 
         **YAML file**
@@ -175,7 +175,7 @@ def _dump(
         fmt: FormatLiteral,
         content: RawConfigData,
         indent: int = 2,
-        **kwargs: t.Any,
+        **kwargs: object,
     ) -> str:
         r"""Dump directly.
 
@@ -200,7 +200,7 @@ def _dump(
         msg = f"{fmt} not supported in config"
         raise NotImplementedError(msg)
 
-    def dump(self, fmt: FormatLiteral, indent: int = 2, **kwargs: t.Any) -> str:
+    def dump(self, fmt: FormatLiteral, indent: int = 2, **kwargs: object) -> str:
         r"""Dump via ConfigReader instance.
 
         >>> cfg = ConfigReader({ "session_name": "my session" })
@@ -222,23 +222,23 @@ class _DuplicateTrackingSafeLoader(yaml.SafeLoader):
 
     def __init__(self, stream: str) -> None:
         super().__init__(stream)
-        self.top_level_key_values: dict[t.Any, list[t.Any]] = {}
+        self.top_level_key_values: dict[object, list[object]] = {}
         self._mapping_depth = 0
-        self.top_level_items: list[tuple[t.Any, t.Any]] = []
+        self.top_level_items: list[tuple[object, object]] = []
 
 
 def _duplicate_tracking_construct_mapping(
     loader: _DuplicateTrackingSafeLoader,
     node: yaml.nodes.MappingNode,
     deep: bool = False,
-) -> dict[t.Any, t.Any]:
+) -> dict[object, object]:
     loader._mapping_depth += 1
     loader.flatten_mapping(node)
-    mapping: dict[t.Any, t.Any] = {}
+    mapping: dict[object, object] = {}
 
     for key_node, value_node in node.value:
         construct = t.cast(
-            "t.Callable[[yaml.nodes.Node], t.Any]",
+            "t.Callable[[yaml.nodes.Node], object]",
             loader.construct_object,
         )
         key = construct(key_node)
@@ -268,28 +268,28 @@ def __init__(
         self,
         content: RawConfigData,
         *,
-        duplicate_sections: dict[str, list[t.Any]] | None = None,
-        top_level_items: list[tuple[str, t.Any]] | None = None,
+        duplicate_sections: dict[str, list[object]] | None = None,
+        top_level_items: list[tuple[str, object]] | None = None,
     ) -> None:
         super().__init__(content)
         self._duplicate_sections = duplicate_sections or {}
         self._top_level_items = top_level_items or []
 
     @property
-    def duplicate_sections(self) -> dict[str, list[t.Any]]:
+    def duplicate_sections(self) -> dict[str, list[object]]:
         """Mapping of top-level keys to the list of duplicated values."""
         return self._duplicate_sections
 
     @property
-    def top_level_items(self) -> list[tuple[str, t.Any]]:
+    def top_level_items(self) -> list[tuple[str, object]]:
         """Ordered list of top-level items, including duplicates."""
         return copy.deepcopy(self._top_level_items)
 
     @classmethod
     def _load_yaml_with_duplicates(
         cls,
         content: str,
-    ) -> tuple[dict[str, t.Any], dict[str, list[t.Any]], list[tuple[str, t.Any]]]:
+    ) -> tuple[dict[str, object], dict[str, list[object]], list[tuple[str, object]]]:
         loader = _DuplicateTrackingSafeLoader(content)
 
         try:
@@ -299,12 +299,12 @@ def _load_yaml_with_duplicates(
             dispose()
 
         if data is None:
-            loaded: dict[str, t.Any] = {}
+            loaded: dict[str, object] = {}
         else:
             if not isinstance(data, dict):
                 msg = "Loaded configuration is not a mapping"
                 raise TypeError(msg)
-            loaded = t.cast("dict[str, t.Any]", data)
+            loaded = t.cast("dict[str, object]", data)
 
         duplicate_sections = {
             t.cast("str", key): values
@@ -323,7 +323,7 @@ def _load_yaml_with_duplicates(
     def _load_from_path(
         cls,
         path: pathlib.Path,
-    ) -> tuple[dict[str, t.Any], dict[str, list[t.Any]], list[tuple[str, t.Any]]]:
+    ) -> tuple[dict[str, object], dict[str, list[object]], list[tuple[str, object]]]:
         if path.suffix.lower() in {".yaml", ".yml"}:
             content = path.read_text(encoding="utf-8")
             return cls._load_yaml_with_duplicates(content)
@@ -340,14 +340,14 @@ def from_file(cls, path: pathlib.Path) -> DuplicateAwareConfigReader:
         )
 
     @classmethod
-    def _from_file(cls, path: pathlib.Path) -> dict[str, t.Any]:
+    def _from_file(cls, path: pathlib.Path) -> dict[str, object]:
         content, _, _ = cls._load_from_path(path)
         return content
 
     @classmethod
     def load_with_duplicates(
         cls,
         path: pathlib.Path,
-    ) -> tuple[dict[str, t.Any], dict[str, list[t.Any]], list[tuple[str, t.Any]]]:
+    ) -> tuple[dict[str, object], dict[str, list[object]], list[tuple[str, object]]]:
         reader = cls.from_file(path)
         return reader.content, reader.duplicate_sections, reader.top_level_items

src/vcspull/_internal/private_path.py

@@ -34,7 +34,11 @@ class PrivatePath(PrivatePathBase):
     '~/notes.txt'
     """
 
-    def __new__(cls, *args: t.Any, **kwargs: t.Any) -> PrivatePath:
+    def __new__(
+        cls,
+        *args: str | os.PathLike[str],
+        **kwargs: object,
+    ) -> PrivatePath:
         return super().__new__(cls, *args, **kwargs)
 
     @classmethod

src/vcspull/cli/__init__.py

@@ -25,6 +25,16 @@
 log = logging.getLogger(__name__)
 
 
+SubparserTuple: t.TypeAlias = tuple[
+    argparse.ArgumentParser,
+    argparse.ArgumentParser,
+    argparse.ArgumentParser,
+    argparse.ArgumentParser,
+    argparse.ArgumentParser,
+    argparse.ArgumentParser,
+]
+
+
 def build_description(
     intro: str,
     example_blocks: t.Sequence[tuple[str | None, t.Sequence[str]]],
@@ -208,7 +218,7 @@ def build_description(
 @overload
 def create_parser(
     return_subparsers: t.Literal[True],
-) -> tuple[argparse.ArgumentParser, t.Any]: ...
+) -> tuple[argparse.ArgumentParser, SubparserTuple]: ...
 
 
 @overload
@@ -217,7 +227,7 @@ def create_parser(return_subparsers: t.Literal[False]) -> argparse.ArgumentParse
 
 def create_parser(
     return_subparsers: bool = False,
-) -> argparse.ArgumentParser | tuple[argparse.ArgumentParser, t.Any]:
+) -> argparse.ArgumentParser | tuple[argparse.ArgumentParser, SubparserTuple]:
     """Create CLI argument parser for vcspull."""
     parser = argparse.ArgumentParser(
         prog="vcspull",

src/vcspull/cli/_formatter.py

@@ -35,11 +35,21 @@
 }
 
 
+class _HelpTheme(t.Protocol):
+    heading: str
+    reset: str
+    label: str
+    long_option: str
+    short_option: str
+    prog: str
+    action: str
+
+
 class VcspullHelpFormatter(argparse.RawDescriptionHelpFormatter):
     """Render description blocks while colorizing example sections when possible."""
 
     def _fill_text(self, text: str, width: int, indent: str) -> str:
-        theme = getattr(self, "_theme", None)
+        theme = t.cast("_HelpTheme | None", getattr(self, "_theme", None))
         if not text or theme is None:
             return super()._fill_text(text, width, indent)
 
@@ -93,7 +103,7 @@ def _colorize_example_line(
         self,
         content: str,
         *,
-        theme: t.Any,
+        theme: _HelpTheme,
         expect_value: bool,
     ) -> _ColorizedLine:
         parts: list[str] = []