ci: Fix type-checking issues

Author: pawamoy

scripts/griffe_extensions.py

@@ -23,9 +23,14 @@ def on_attribute_instance(
         """Fetch descriptions from `Field` annotations."""
         if attr.docstring:
             return
+        annotation = attr.annotation
+        if not isinstance(annotation, griffe.ExprSubscript) or not isinstance(annotation.slice, griffe.ExprTuple):
+            return
         try:
-            field: griffe.ExprCall = attr.annotation.slice.elements[1]
-        except AttributeError:
+            field = annotation.slice.elements[1]
+        except IndexError:
+            return
+        if not isinstance(field, griffe.ExprCall):
             return
 
         if field.canonical_path == "mkdocstrings_handlers.python._internal.config._Field":

src/mkdocstrings_handlers/python/_internal/handler.py

@@ -228,18 +228,17 @@ def collect(self, identifier: str, options: PythonOptions) -> CollectorItem:
 
         parser_name = options.docstring_style
         parser = parser_name and Parser(parser_name)
-        parser_options = options.docstring_options
-        if parser_options is not None:
-            parser_options = asdict(parser_options)
-            parser_options = _filter_parser_options(parser, parser_options)
+        parser_options: dict[str, Any] | None = None
+        if options.docstring_options is not None:
+            parser_options = _filter_parser_options(parser, asdict(options.docstring_options))
 
         if unknown_module:
             extensions = self.normalize_extension_paths(options.extensions)
             loader = GriffeLoader(
                 extensions=load_extensions(*extensions),
                 search_paths=self._paths,
                 docstring_parser=parser,
-                docstring_options=parser_options,
+                docstring_options=parser_options,  # type: ignore[arg-type]
                 modules_collection=self._modules_collection,
                 lines_collection=self._lines_collection,
                 allow_inspection=options.allow_inspection,

src/mkdocstrings_handlers/python/_internal/rendering.py

@@ -420,22 +420,20 @@ def _keep_object(name: str, filters: Sequence[tuple[Pattern, bool]]) -> bool:
 
 
 def _parents(obj: Alias) -> set[str]:
-    parent: Object | Alias = obj.parent
-    parents = {obj.path, parent.path}
-    if parent.is_alias:
-        parents.add(parent.final_target.path)
-    while parent.parent:
-        parent = parent.parent
+    parents = {obj.path}
+    parent = obj.parent
+    while parent is not None:
         parents.add(parent.path)
-        if parent.is_alias:
+        if isinstance(parent, Alias):
             parents.add(parent.final_target.path)
+        parent = parent.parent
     return parents
 
 
 def _remove_cycles(objects: list[Object | Alias]) -> Iterator[Object | Alias]:
     suppress_errors = suppress(AliasResolutionError, CyclicAliasError)
     for obj in objects:
-        if obj.is_alias:
+        if isinstance(obj, Alias):
             with suppress_errors:
                 if obj.final_target.path in _parents(obj):
                     continue
@@ -784,6 +782,8 @@ def expand_identifier(self, identifier: str) -> str:
             obj = self.current_object
             while identifier and identifier[0] == ".":
                 identifier = identifier[1:]
+                if obj.parent is None:
+                    break
                 obj = obj.parent
             identifier = f"{obj.path}.{identifier}" if identifier else obj.path
 
@@ -814,12 +814,13 @@ def get_context(self) -> AutorefsHookInterface.Context:
             "module": "mod",
         }.get(self.current_object.kind.value.lower(), "obj")
         origin = self.current_object.path
-        try:
-            filepath = self.current_object.docstring.parent.filepath
-            lineno = self.current_object.docstring.lineno or 0
-        except AttributeError:
+        docstring = self.current_object.docstring
+        if docstring is None or docstring.parent is None:
             filepath = self.current_object.filepath
             lineno = 0
+        else:
+            filepath = docstring.parent.filepath
+            lineno = docstring.lineno or 0
 
         return AutorefsHookInterface.Context(
             domain="py",

tests/test_api.py

@@ -36,7 +36,7 @@ def _fixture_public_api(loader: griffe.GriffeLoader) -> griffe.Module:
 
 
 def _yield_public_objects(
-    obj: griffe.Module | griffe.Class,
+    obj: griffe.Module | griffe.Class | griffe.Alias,
     *,
     modules: bool = False,
     modulelevel: bool = True,
@@ -48,6 +48,7 @@ def _yield_public_objects(
             if member.is_module:
                 if member.is_alias or not member.is_public:
                     continue
+                assert isinstance(member, griffe.Module)
                 if modules:
                     yield member
                 yield from _yield_public_objects(
@@ -62,6 +63,7 @@ def _yield_public_objects(
             else:
                 continue
             if member.is_class and not modulelevel:
+                assert isinstance(member, (griffe.Class, griffe.Alias))
                 yield from _yield_public_objects(
                     member,
                     modules=modules,

tests/test_rendering.py

@@ -4,10 +4,10 @@
 
 import re
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any, Callable
+from typing import TYPE_CHECKING, Any, Callable, cast
 
 import pytest
-from griffe import ModulesCollection, temporary_visited_module
+from griffe import Alias, ModulesCollection, Object, temporary_visited_module
 
 from mkdocstrings_handlers.python._internal import rendering
 
@@ -78,7 +78,7 @@ def test_filter_objects(names: list[str], filter_params: dict[str, Any], expecte
         expected_names: Names expected to be kept.
     """
     objects = {name: _FakeObject(name) for name in names}
-    filtered = rendering.do_filter_objects(objects, **filter_params)
+    filtered = rendering.do_filter_objects(cast("dict[str, Object | Alias]", objects), **filter_params)
     filtered_names = {obj.name for obj in filtered}
     assert set(filtered_names) == set(expected_names)