introspection

docforge/loader/griffe_loader.py

@@ -0,0 +1,119 @@
+from __future__ import annotations
+
+import logging
+from typing import List, Optional
+
+from griffe import (
+    GriffeLoader as _GriffeLoader,
+    ModulesCollection,
+    LinesCollection,
+    Object,
+    AliasResolutionError,
+)
+
+from docforge.model import Module, Project, DocObject
+
+logger = logging.getLogger(__name__)
+
+
+class GriffeLoader:
+    """Loads Python modules using Griffe introspection."""
+
+    def __init__(self) -> None:
+        self._loader = _GriffeLoader(
+            modules_collection=ModulesCollection(),
+            lines_collection=LinesCollection(),
+        )
+
+    def load_project(
+        self,
+        module_paths: List[str],
+        project_name: Optional[str] = None,
+    ) -> Project:
+        if not module_paths:
+            raise ValueError("At least one module path must be provided")
+
+        if project_name is None:
+            project_name = module_paths[0].split(".")[0]
+
+        project = Project(name=project_name)
+
+        for module_path in module_paths:
+            try:
+                module = self.load_module(module_path)
+                project.add_module(module)
+            except Exception as e:
+                logger.error("Failed to load module %s: %s", module_path, e)
+                continue
+
+        return project
+
+    def load_module(self, path: str) -> Module:
+        try:
+            self._loader.load(path)
+            griffe_module = self._loader.modules_collection[path]
+        except Exception as e:
+            raise ImportError(f"Failed to load module '{path}': {e}") from e
+
+        return self._convert_module(griffe_module)
+
+    # -------------------------
+    # Conversion helpers
+    # -------------------------
+
+    def _convert_module(self, obj: Object) -> Module:
+        module = Module(
+            path=obj.path,
+            docstring=self._safe_docstring(obj),
+        )
+
+        for name, member in obj.members.items():
+            if name.startswith("_"):
+                continue
+            try:
+                module.add_object(self._convert_object(member))
+            except Exception as e:
+                logger.warning("Skipping member %s: %s", name, e)
+
+        return module
+
+    def _convert_object(self, obj: Object) -> DocObject:
+        kind = obj.kind.value
+        signature = self._safe_signature(obj)
+
+        doc_obj = DocObject(
+            name=obj.name,
+            kind=kind,
+            path=obj.path,
+            signature=signature,
+            docstring=self._safe_docstring(obj),
+        )
+
+        if hasattr(obj, "members"):
+            for name, member in obj.members.items():
+                if name.startswith("_"):
+                    continue
+                try:
+                    doc_obj.add_member(self._convert_object(member))
+                except Exception:
+                    continue
+
+        return doc_obj
+
+    # -------------------------
+    # Safe extractors
+    # -------------------------
+
+    def _safe_docstring(self, obj: Object) -> Optional[str]:
+        try:
+            return obj.docstring.value if obj.docstring else None
+        except AliasResolutionError:
+            return None
+
+    def _safe_signature(self, obj: Object) -> Optional[str]:
+        try:
+            if hasattr(obj, "signature") and obj.signature:
+                return str(obj.signature)
+        except AliasResolutionError:
+            return None
+        return None