refactor: Run dynamic analysis once package is loaded

This allows us to use `all_members` when looking up fields and validators, which fixes an issue with models inherting from base ones.

Issue-19: #19

Author: pawamoy

src/griffe_pydantic/common.py

@@ -31,11 +31,11 @@
 
 
 def _model_fields(cls: Class) -> dict[str, Attribute]:
-    return {name: attr for name, attr in cls.members.items() if "pydantic-field" in attr.labels}  # type: ignore[misc]
+    return {name: attr for name, attr in cls.all_members.items() if "pydantic-field" in attr.labels}  # type: ignore[misc]
 
 
 def _model_validators(cls: Class) -> dict[str, Function]:
-    return {name: func for name, func in cls.members.items() if "pydantic-validator" in func.labels}  # type: ignore[misc]
+    return {name: func for name, func in cls.all_members.items() if "pydantic-validator" in func.labels}  # type: ignore[misc]
 
 
 def json_schema(model: type[BaseModel]) -> str:
@@ -69,7 +69,7 @@ def process_function(func: Function, cls: Class, fields: Sequence[str]) -> None:
         cls: A Griffe function representing the Pydantic validator.
     """
     func.labels = {"pydantic-validator"}
-    targets = [cls.members[field] for field in fields]
+    targets = [cls.all_members[field] for field in fields]
 
     func.extra[self_namespace].setdefault("targets", [])
     func.extra[self_namespace]["targets"].extend(targets)

src/griffe_pydantic/dynamic.py

@@ -2,54 +2,65 @@
 
 from __future__ import annotations
 
-from typing import TYPE_CHECKING
+from typing import Any, Callable
 
 from griffe import (
     Attribute,
     Class,
     Docstring,
     Function,
+    Kind,
     get_logger,
 )
 from pydantic.fields import FieldInfo
 
 from griffe_pydantic import common
 
-if TYPE_CHECKING:
-    from griffe import ObjectNode
-
 logger = get_logger(__name__)
 
 
-def process_attribute(node: ObjectNode, attr: Attribute, cls: Class) -> None:
+def process_attribute(obj: Any, attr: Attribute, cls: Class, *, processed: set[str]) -> None:
     """Handle Pydantic fields."""
+    if attr.canonical_path in processed:
+        return
+    processed.add(attr.canonical_path)
     if attr.name == "model_config":
-        cls.extra[common.self_namespace]["config"] = node.obj
+        cls.extra[common.self_namespace]["config"] = obj
         return
 
-    if not isinstance(node.obj, FieldInfo):
+    if not isinstance(obj, FieldInfo):
         return
 
     attr.labels = {"pydantic-field"}
-    attr.value = node.obj.default
+    attr.value = obj.default
     constraints = {}
     for constraint in common.field_constraints:
-        if (value := getattr(node.obj, constraint, None)) is not None:
+        if (value := getattr(obj, constraint, None)) is not None:
             constraints[constraint] = value
     attr.extra[common.self_namespace]["constraints"] = constraints
 
     # Populate docstring from the field's `description` argument.
-    if not attr.docstring and (docstring := node.obj.description):
+    if not attr.docstring and (docstring := obj.description):
         attr.docstring = Docstring(docstring, parent=attr)
 
 
-def process_function(node: ObjectNode, func: Function, cls: Class) -> None:
+def process_function(obj: Callable, func: Function, cls: Class, *, processed: set[str]) -> None:
     """Handle Pydantic field validators."""
-    if dec_info := getattr(node.obj, "decorator_info", None):
+    if func.canonical_path in processed:
+        return
+    processed.add(func.canonical_path)
+    if dec_info := getattr(obj, "decorator_info", None):
         common.process_function(func, cls, dec_info.fields)
 
 
-def process_class(node: ObjectNode, cls: Class) -> None:
+def process_class(obj: type, cls: Class, *, processed: set[str], schema: bool = False) -> None:
     """Detect and prepare Pydantic models."""
     common.process_class(cls)
-    cls.extra[common.self_namespace]["schema"] = common.json_schema(node.obj)
+    if schema:
+        cls.extra[common.self_namespace]["schema"] = common.json_schema(obj)
+    for member in cls.all_members.values():
+        kind = member.kind
+        if kind is Kind.ATTRIBUTE:
+            process_attribute(getattr(obj, member.name), member, cls, processed=processed)  # type: ignore[arg-type]
+        elif kind is Kind.FUNCTION:
+            process_function(getattr(obj, member.name), member, cls, processed=processed)  # type: ignore[arg-type]

src/griffe_pydantic/extension.py

@@ -6,10 +6,8 @@
 from typing import TYPE_CHECKING, Any
 
 from griffe import (
-    Attribute,
     Class,
     Extension,
-    Function,
     Module,
     get_logger,
 )
@@ -34,11 +32,14 @@ def __init__(self, *, schema: bool = False) -> None:
         """
         super().__init__()
         self.schema = schema
-        self.in_model: list[Class] = []
         self.processed: set[str] = set()
+        self.recorded: list[tuple[ObjectNode, Class]] = []
 
     def on_package_loaded(self, *, pkg: Module, **kwargs: Any) -> None:  # noqa: ARG002
         """Detect models once the whole package is loaded."""
+        for node, cls in self.recorded:
+            self.processed.add(cls.canonical_path)
+            dynamic.process_class(node.obj, cls, processed=self.processed, schema=self.schema)
         static.process_module(pkg, processed=self.processed, schema=self.schema)
 
     def on_class_instance(self, *, node: ast.AST | ObjectNode, cls: Class, **kwargs: Any) -> None:  # noqa: ARG002
@@ -54,36 +55,4 @@ def on_class_instance(self, *, node: ast.AST | ObjectNode, cls: Class, **kwargs:
             return
 
         if issubclass(node.obj, pydantic.BaseModel):
-            self.in_model.append(cls)
-            dynamic.process_class(node, cls)
-            self.processed.add(cls.canonical_path)
-
-    def on_attribute_instance(self, *, node: ast.AST | ObjectNode, attr: Attribute, **kwargs: Any) -> None:  # noqa: ARG002
-        """Handle Pydantic fields."""
-        # Prevent running during static analysis.
-        if isinstance(node, ast.AST):
-            return
-        if self.in_model:
-            cls = self.in_model[-1]
-            dynamic.process_attribute(node, attr, cls)
-            self.processed.add(attr.canonical_path)
-
-    def on_function_instance(self, *, node: ast.AST | ObjectNode, func: Function, **kwargs: Any) -> None:  # noqa: ARG002
-        """Handle Pydantic field validators."""
-        # Prevent running during static analysis.
-        if isinstance(node, ast.AST):
-            return
-        if self.in_model:
-            cls = self.in_model[-1]
-            dynamic.process_function(node, func, cls)
-            self.processed.add(func.canonical_path)
-
-    def on_class_members(self, *, node: ast.AST | ObjectNode, cls: Class, **kwargs: Any) -> None:  # noqa: ARG002
-        """Finalize the Pydantic model data."""
-        # Prevent running during static analysis.
-        if isinstance(node, ast.AST):
-            return
-
-        if self.in_model and cls is self.in_model[-1]:
-            # Pop last class from the heap.
-            self.in_model.pop()
+            self.recorded.append((node, cls))

src/griffe_pydantic/static.py

@@ -96,7 +96,16 @@ def process_attribute(attr: Attribute, cls: Class, *, processed: set[str]) -> No
         kwargs["default"] = attr.value
 
     if attr.name == "model_config":
-        cls.extra[common.self_namespace]["config"] = kwargs
+        config = {}
+        for key, value in kwargs.items():
+            if isinstance(value, str):
+                try:
+                    config[key] = ast.literal_eval(value)
+                except ValueError:
+                    config[key] = value
+            else:
+                config[key] = value
+        cls.extra[common.self_namespace]["config"] = config
         return
 
     attr.labels.add("pydantic-field")

tests/test_extension.py

@@ -5,12 +5,12 @@
 import logging
 from typing import TYPE_CHECKING
 
-from griffe import Extensions, temporary_visited_package
+import pytest
+from griffe import Extensions, temporary_inspected_package, temporary_visited_package
 
 from griffe_pydantic.extension import PydanticExtension
 
 if TYPE_CHECKING:
-    import pytest
     from mkdocstrings_handlers.python.handler import PythonHandler
 
 
@@ -58,9 +58,11 @@ class RegularClass(object):
 """
 
 
-def test_extension() -> None:
+@pytest.mark.parametrize("analysis", ["static", "dynamic"])
+def test_extension(analysis: str) -> None:
     """Test the extension."""
-    with temporary_visited_package(
+    loader = {"static": temporary_visited_package, "dynamic": temporary_inspected_package}[analysis]
+    with loader(
         "package",
         modules={"__init__.py": code},
         extensions=Extensions(PydanticExtension(schema=True)),
@@ -74,7 +76,7 @@ def test_extension() -> None:
         assert package.classes["ExampleModel"].labels == {"pydantic-model"}
 
         config = package.classes["ExampleModel"].extra["griffe_pydantic"]["config"]
-        assert config == {"frozen": "False"}
+        assert config == {"frozen": False}
 
         schema = package.classes["ExampleModel"].extra["griffe_pydantic"]["schema"]
         assert schema.startswith('{\n  "description"')