odoo-typegen 0.1.2__py3-none-any.whl

odoo_typegen/__init__.py

@@ -0,0 +1 @@
+

odoo_typegen/cli.py

@@ -0,0 +1,87 @@
+from pathlib import Path
+
+from cyclopts import App
+
+from odoo_typegen.compiler.compiler import Compiler
+from odoo_typegen.compiler.environment_compiler import EnvironmentCompiler
+from odoo_typegen.compiler.model_compiler import ModelCompiler
+from odoo_typegen.emitter.type_emitter import TypeEmitter
+from odoo_typegen.registry.registry_service import RegistryService
+
+
+app = App()
+
+
+def _generate(
+    addon_path: Path,
+    output_path: Path,
+    odoo_path: Path | None = None,
+) -> tuple[Path, ...]:
+    registry = RegistryService(addon_path=addon_path).build()
+    models = Compiler().compile(registry)
+    environment = EnvironmentCompiler(odoo_path=odoo_path).compile(models)
+    core_models = ModelCompiler(odoo_path=odoo_path).compile()
+    emitter = TypeEmitter(output_path=output_path)
+
+    emitted_files = (
+        *emitter.emit(models),
+        *emitter.emit_environment(environment),
+        *emitter.emit_core_models(core_models),
+    )
+
+    for emitted_file in emitted_files:
+        print(emitted_file)
+
+    return emitted_files
+
+
+@app.default
+def default(
+    addon_path: Path,
+    output_path: Path = Path("typings"),
+    *,
+    odoo_path: Path | None = None,
+) -> None:
+    """Generate Python stub files for Odoo addons.
+
+    Parameters
+    ----------
+    addon_path: Path
+        Directory containing Odoo addon directories.
+    output_path: Path
+        Directory where generated .pyi files should be written. Defaults to
+        ./typings, which Pyright discovers automatically.
+    odoo_path: Path | None
+        Optional path to a local Odoo checkout used to overlay core stubs.
+    """
+    _generate(addon_path, output_path, odoo_path)
+
+
+@app.command
+def generate(
+    addon_path: Path,
+    output_path: Path = Path("typings"),
+    *,
+    odoo_path: Path | None = None,
+) -> None:
+    """Generate Python stub files for Odoo addons.
+
+    Parameters
+    ----------
+    addon_path: Path
+        Directory containing Odoo addon directories.
+    output_path: Path
+        Directory where generated .pyi files should be written. Defaults to
+        ./typings, which Pyright discovers automatically.
+    odoo_path: Path | None
+        Optional path to a local Odoo checkout used to overlay core stubs.
+    """
+    _generate(addon_path, output_path, odoo_path)
+
+
+def main() -> None:
+    app()
+
+
+if __name__ == "__main__":
+    main()

odoo_typegen/compiler/compiler.py

@@ -0,0 +1,288 @@
+from pathlib import Path
+
+import astroid
+from astroid import nodes
+
+from odoo_typegen.compiler.consolidated_model import (
+    ConsolidatedModel,
+    StubAttribute,
+    StubClass,
+    StubMethod,
+)
+from odoo_typegen.compiler.model_fragment import ModelFragment
+from odoo_typegen.compiler.model_index import ModelIndex
+from odoo_typegen.registry.module import Module
+from odoo_typegen.registry.registry import Registry
+
+
+class Compiler:
+    _FIELD_TYPES = {
+        "Char": "str",
+        "Text": "str",
+        "Selection": "str",
+        "Boolean": "bool",
+        "Integer": "int",
+        "Float": "float",
+        "Monetary": "float",
+    }
+
+    def compile(self, registry: Registry) -> tuple[ConsolidatedModel, ...]:
+        return self.consolidate(self.index_fragments(registry))
+
+    def index_fragments(self, registry: Registry) -> ModelIndex:
+        index = ModelIndex()
+        for module in registry.values():
+            self._compile_module(module, index)
+        return index
+
+    def consolidate(self, model_index: ModelIndex) -> tuple[ConsolidatedModel, ...]:
+        models: list[ConsolidatedModel] = []
+        for model_name, fragments in model_index.items():
+            attributes: list[StubAttribute] = []
+            methods: list[StubMethod] = []
+
+            for fragment in fragments:
+                class_node = self._find_fragment_class(fragment)
+                if class_node is None:
+                    continue
+
+                attributes.extend(self._extract_fields(fragment, class_node))
+                methods.extend(self._extract_methods(fragment, class_node))
+
+            models.append(
+                ConsolidatedModel(
+                    name=model_name,
+                    stub_class=StubClass(
+                        import_path=model_name,
+                        class_name=self._class_name_for_model(model_name),
+                        bases=("odoo.models.Model",),
+                        attributes=tuple(attributes),
+                        methods=tuple(methods),
+                    ),
+                )
+            )
+
+        return tuple(models)
+
+    def _compile_module(self, module: Module, index: ModelIndex) -> None:
+        self._compile_python_file(
+            module=module,
+            file=module.path / "__init__.py",
+            index=index,
+            seen=set(),
+        )
+
+    def _compile_python_file(
+        self,
+        module: Module,
+        file: Path,
+        index: ModelIndex,
+        seen: set[Path],
+    ) -> None:
+        if file in seen or not file.exists():
+            return
+
+        seen.add(file)
+        tree = astroid.parse(file.read_text())
+
+        for fragment in self._extract_model_fragments(module, file, tree):
+            model_name = self._effective_model_name(fragment)
+            if model_name is not None:
+                index.add(model_name, fragment)
+
+        for imported_file in self._resolve_local_imports(file, tree):
+            self._compile_python_file(module, imported_file, index, seen)
+
+    def _resolve_local_imports(
+        self,
+        file: Path,
+        tree: nodes.Module,
+    ) -> tuple[Path, ...]:
+        imported_files: list[Path] = []
+        package_path = file.parent
+
+        for node in tree.body:
+            if not isinstance(node, nodes.ImportFrom) or node.level != 1:
+                continue
+
+            for imported_name, _alias in node.names:
+                if imported_name == "*":
+                    continue
+
+                package_import = package_path / imported_name / "__init__.py"
+                module_import = package_path / f"{imported_name}.py"
+                if package_import.exists():
+                    imported_files.append(package_import)
+                elif module_import.exists():
+                    imported_files.append(module_import)
+
+        return tuple(imported_files)
+
+    def _extract_model_fragments(
+        self,
+        module: Module,
+        file: Path,
+        tree: nodes.Module,
+    ) -> tuple[ModelFragment, ...]:
+        fragments: list[ModelFragment] = []
+
+        for node in tree.body:
+            if not isinstance(node, nodes.ClassDef):
+                continue
+
+            name = None
+            inherits: tuple[str, ...] = ()
+            for statement in node.body:
+                if not isinstance(statement, nodes.Assign):
+                    continue
+
+                for target in statement.targets:
+                    if not isinstance(target, nodes.AssignName):
+                        continue
+                    if target.name == "_name":
+                        name = self._parse_string_literal(statement.value)
+                    elif target.name == "_inherit":
+                        inherits = self._parse_string_collection(statement.value)
+
+            if not inherits:
+                continue
+
+            fragments.append(
+                ModelFragment(
+                    module=module.name,
+                    file=file,
+                    class_name=node.name,
+                    name=name,
+                    inherits=inherits,
+                    line=node.lineno,
+                )
+            )
+
+        return tuple(fragments)
+
+    @staticmethod
+    def _parse_string_literal(node: nodes.NodeNG) -> str | None:
+        if isinstance(node, nodes.Const) and isinstance(node.value, str):
+            return node.value
+        return None
+
+    def _parse_string_collection(self, node: nodes.NodeNG) -> tuple[str, ...]:
+        literal = self._parse_string_literal(node)
+        if literal is not None:
+            return (literal,)
+
+        if not isinstance(node, nodes.List | nodes.Tuple):
+            return ()
+
+        values: list[str] = []
+        for item in node.elts:
+            literal = self._parse_string_literal(item)
+            if literal is None:
+                return ()
+            values.append(literal)
+
+        return tuple(values)
+
+    @staticmethod
+    def _effective_model_name(fragment: ModelFragment) -> str | None:
+        if fragment.name is not None:
+            return fragment.name
+
+        if len(fragment.inherits) == 1:
+            return fragment.inherits[0]
+
+        return None
+
+    def _find_fragment_class(self, fragment: ModelFragment) -> nodes.ClassDef | None:
+        tree = astroid.parse(fragment.file.read_text())
+        for node in tree.body:
+            if (
+                isinstance(node, nodes.ClassDef)
+                and node.name == fragment.class_name
+                and node.lineno == fragment.line
+            ):
+                return node
+        return None
+
+    def _extract_fields(
+        self,
+        fragment: ModelFragment,
+        class_node: nodes.ClassDef,
+    ) -> tuple[StubAttribute, ...]:
+        fields: list[StubAttribute] = []
+
+        for statement in class_node.body:
+            if not isinstance(statement, nodes.Assign):
+                continue
+
+            field_type = self._parse_field_type(statement.value)
+            if field_type is None:
+                continue
+
+            for target in statement.targets:
+                if not isinstance(target, nodes.AssignName):
+                    continue
+                fields.append(
+                    StubAttribute(
+                        name=target.name,
+                        type=field_type,
+                        module=fragment.module,
+                        file=fragment.file,
+                        line=statement.lineno,
+                    )
+                )
+
+        return tuple(fields)
+
+    def _extract_methods(
+        self,
+        fragment: ModelFragment,
+        class_node: nodes.ClassDef,
+    ) -> tuple[StubMethod, ...]:
+        methods: list[StubMethod] = []
+
+        for statement in class_node.body:
+            if not isinstance(statement, nodes.FunctionDef):
+                continue
+
+            methods.append(
+                StubMethod(
+                    name=statement.name,
+                    signature=self._method_signature(statement),
+                    module=fragment.module,
+                    file=fragment.file,
+                    line=statement.lineno,
+                )
+            )
+
+        return tuple(methods)
+
+    def _parse_field_type(self, node: nodes.NodeNG) -> str | None:
+        if not isinstance(node, nodes.Call):
+            return None
+
+        func = node.func
+        if not (
+            isinstance(func, nodes.Attribute)
+            and isinstance(func.expr, nodes.Name)
+            and func.expr.name == "fields"
+        ):
+            return None
+
+        return self._FIELD_TYPES.get(func.attrname, "Any")
+
+    @staticmethod
+    def _method_signature(node: nodes.FunctionDef) -> str:
+        return_type = "Any"
+        if node.returns is not None:
+            return_type = node.returns.as_string()
+
+        return f"def {node.name}({node.args.format_args()}) -> {return_type}"
+
+    @staticmethod
+    def _class_name_for_model(model_name: str) -> str:
+        return "".join(
+            part.capitalize()
+            for part in model_name.replace("_", ".").split(".")
+            if part
+        )

odoo_typegen/compiler/consolidated_model.py

@@ -0,0 +1,34 @@
+from pathlib import Path
+
+import pydantic
+
+
+class StubAttribute(pydantic.BaseModel):
+    name: str
+    type: str
+    module: str | None = None
+    file: Path | None = None
+    line: int | None = None
+
+
+class StubMethod(pydantic.BaseModel):
+    name: str
+    signature: str
+    decorators: tuple[str, ...] = ()
+    module: str | None = None
+    file: Path | None = None
+    line: int | None = None
+
+
+class StubClass(pydantic.BaseModel):
+    import_path: str
+    class_name: str
+    imports: tuple[str, ...] = ()
+    bases: tuple[str, ...] = ()
+    attributes: tuple[StubAttribute, ...] = ()
+    methods: tuple[StubMethod, ...] = ()
+
+
+class ConsolidatedModel(pydantic.BaseModel):
+    name: str
+    stub_class: StubClass

odoo_typegen/compiler/core_stub_compiler.py

@@ -0,0 +1,216 @@
+from pathlib import Path
+
+import astroid
+from astroid import nodes
+
+from odoo_typegen.compiler.consolidated_model import StubAttribute, StubClass, StubMethod
+
+
+class CoreStubCompiler:
+    _ALLOWED_PRIVATE_MEMBERS: set[str] = set()
+    _ALLOWED_DUNDERS = {
+        "__call__",
+        "__contains__",
+        "__getitem__",
+        "__iter__",
+        "__len__",
+    }
+    _SAFE_TYPES = {
+        "Any",
+        "None",
+        "bool",
+        "dict",
+        "float",
+        "int",
+        "list",
+        "object",
+        "str",
+        "tuple",
+        "typing.Any",
+        "typing.Iterator",
+        "typing.Literal",
+    }
+
+    def _extract_stub_class(
+        self,
+        source_file: Path,
+        class_name: str,
+        import_path: str,
+        imports: tuple[str, ...] = (),
+        bases: tuple[str, ...] = (),
+    ) -> StubClass:
+        class_node = self._find_class(source_file, class_name)
+        if class_node is None:
+            return StubClass(
+                import_path=import_path,
+                class_name=class_name,
+                imports=imports,
+                bases=bases,
+            )
+
+        return StubClass(
+            import_path=import_path,
+            class_name=class_name,
+            imports=imports,
+            bases=bases,
+            attributes=self._extract_attributes(class_node),
+            methods=self._extract_methods(class_node),
+        )
+
+    @staticmethod
+    def _find_class(source_file: Path, class_name: str) -> nodes.ClassDef | None:
+        if not source_file.is_file():
+            return None
+
+        tree = astroid.parse(source_file.read_text())
+        for node in tree.body:
+            if isinstance(node, nodes.ClassDef) and node.name == class_name:
+                return node
+        return None
+
+    def _extract_attributes(
+        self,
+        class_node: nodes.ClassDef,
+    ) -> tuple[StubAttribute, ...]:
+        attributes: list[StubAttribute] = []
+
+        for statement in class_node.body:
+            if isinstance(statement, nodes.AnnAssign):
+                name = self._assignment_name(statement.target)
+                if name is None or not self._is_public_member(name):
+                    continue
+                attributes.append(
+                    StubAttribute(
+                        name=name,
+                        type=self._safe_annotation(statement.annotation),
+                        line=statement.lineno,
+                    )
+                )
+            elif isinstance(statement, nodes.FunctionDef) and self._is_property(statement):
+                if not self._is_public_member(statement.name):
+                    continue
+                attributes.append(
+                    StubAttribute(
+                        name=statement.name,
+                        type=self._safe_annotation(statement.returns),
+                        line=statement.lineno,
+                    )
+                )
+
+        return tuple(attributes)
+
+    def _extract_methods(self, class_node: nodes.ClassDef) -> tuple[StubMethod, ...]:
+        methods: list[StubMethod] = []
+
+        for statement in class_node.body:
+            if not isinstance(statement, nodes.FunctionDef):
+                continue
+            if self._is_property(statement) or not self._is_public_member(statement.name):
+                continue
+
+            methods.append(
+                StubMethod(
+                    name=statement.name,
+                    signature=self._method_signature(statement),
+                    decorators=self._method_decorators(statement),
+                    line=statement.lineno,
+                )
+            )
+
+        return tuple(methods)
+
+    def _method_signature(self, node: nodes.FunctionDef) -> str:
+        return_type = self._safe_annotation(node.returns)
+        return f"def {node.name}({self._format_args(node.args)}) -> {return_type}"
+
+    def _format_args(self, args: nodes.Arguments) -> str:
+        formatted = args.format_args()
+        for annotation in self._annotations_in_args(args):
+            if annotation is None:
+                continue
+            raw_annotation = annotation.as_string()
+            safe_annotation = self._safe_annotation(annotation)
+            if raw_annotation != safe_annotation:
+                formatted = formatted.replace(f": {raw_annotation}", f": {safe_annotation}")
+        return formatted
+
+    @staticmethod
+    def _annotations_in_args(args: nodes.Arguments) -> tuple[nodes.NodeNG | None, ...]:
+        annotations: list[nodes.NodeNG | None] = []
+        annotations.extend(args.annotations)
+        annotations.extend(args.posonlyargs_annotations)
+        annotations.extend(args.kwonlyargs_annotations)
+        if args.varargannotation is not None:
+            annotations.append(args.varargannotation)
+        if args.kwargannotation is not None:
+            annotations.append(args.kwargannotation)
+        return tuple(annotations)
+
+    def _safe_annotation(self, annotation: nodes.NodeNG | None) -> str:
+        if annotation is None:
+            return "typing.Any"
+
+        rendered = annotation.as_string()
+        if self._is_safe_annotation(rendered):
+            return rendered
+        return "typing.Any"
+
+    def _is_safe_annotation(self, rendered: str) -> bool:
+        cleaned = (
+            rendered.replace(" | ", "|")
+            .replace("[", "|")
+            .replace("]", "|")
+            .replace(",", "|")
+            .replace("'", "")
+            .replace('"', "")
+        )
+        parts = {
+            part.strip()
+            for part in cleaned.split("|")
+            if part.strip()
+        }
+        return all(
+            part in self._SAFE_TYPES
+            or part.startswith("typing.")
+            or part in {"True", "False"}
+            for part in parts
+        )
+
+    def _is_public_member(self, name: str) -> bool:
+        return (
+            not name.startswith("_")
+            or name in self._ALLOWED_DUNDERS
+            or name in self._ALLOWED_PRIVATE_MEMBERS
+        )
+
+    @staticmethod
+    def _assignment_name(node: nodes.NodeNG) -> str | None:
+        if isinstance(node, nodes.AssignName):
+            return node.name
+        return None
+
+    @staticmethod
+    def _is_property(node: nodes.FunctionDef) -> bool:
+        for decorator in node.decorators.nodes if node.decorators is not None else ():
+            if isinstance(decorator, nodes.Name) and decorator.name == "property":
+                return True
+            if (
+                isinstance(decorator, nodes.Attribute)
+                and decorator.attrname == "cached_property"
+            ):
+                return True
+        return False
+
+    @staticmethod
+    def _method_decorators(node: nodes.FunctionDef) -> tuple[str, ...]:
+        decorators: list[str] = []
+        for decorator in node.decorators.nodes if node.decorators is not None else ():
+            if isinstance(decorator, nodes.Attribute):
+                name = decorator.as_string()
+            elif isinstance(decorator, nodes.Name):
+                name = decorator.name
+            else:
+                continue
+            if name in {"typing.overload", "overload"}:
+                decorators.append("@typing.overload")
+        return tuple(decorators)

odoo_typegen/compiler/environment_compiler.py

@@ -0,0 +1,74 @@
+from pathlib import Path
+
+from odoo_typegen.compiler.consolidated_model import ConsolidatedModel, StubClass, StubMethod
+from odoo_typegen.compiler.core_stub_compiler import CoreStubCompiler
+
+
+class EnvironmentCompiler(CoreStubCompiler):
+    def __init__(self, odoo_path: Path | None = None):
+        self._odoo_path = odoo_path
+
+    def compile(self, models: tuple[ConsolidatedModel, ...]) -> StubClass:
+        stub_class = self._extract_stub_class(
+            source_file=self._source_file(),
+            class_name="Environment",
+            import_path="odoo.orm.environments",
+            imports=self._imports_for(models),
+        )
+
+        methods = tuple(
+            method
+            for method in stub_class.methods
+            if method.name != "__getitem__"
+        )
+
+        return stub_class.model_copy(
+            update={
+                "methods": (
+                    *methods,
+                    *self._getitem_overloads(models),
+                ),
+            }
+        )
+
+    def _source_file(self) -> Path:
+        if self._odoo_path is None:
+            return Path()
+        return self._odoo_path / "odoo/orm/environments.py"
+
+    @staticmethod
+    def _imports_for(models: tuple[ConsolidatedModel, ...]) -> tuple[str, ...]:
+        imports = ["import typing"]
+        imports.extend(
+            f"from {model.stub_class.import_path} import {model.stub_class.class_name}"
+            for model in models
+        )
+        return tuple(imports)
+
+    @staticmethod
+    def _getitem_overloads(
+        models: tuple[ConsolidatedModel, ...],
+    ) -> tuple[StubMethod, ...]:
+        overloads: list[StubMethod] = []
+        for model in models:
+            overloads.append(
+                StubMethod(
+                    name="__getitem__",
+                    decorators=("@typing.overload",),
+                    signature=(
+                        "def __getitem__("
+                        "self, "
+                        f"model_name: typing.Literal[\"{model.name}\"]"
+                        f") -> {model.stub_class.class_name}"
+                    ),
+                )
+            )
+
+        overloads.append(
+            StubMethod(
+                name="__getitem__",
+                decorators=("@typing.overload",),
+                signature="def __getitem__(self, model_name: str) -> typing.Any",
+            )
+        )
+        return tuple(overloads)