120 lines
3.3 KiB
Python
120 lines
3.3 KiB
Python
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
|