odoo-project 0.1__tar.gz

odoo_project-0.1/.gitignore

@@ -0,0 +1,27 @@
+# macOS
+.DS_Store/
+
+# editors
+/.idea/
+
+# direnv
+.envrc
+
+# Python
+__pycache__/
+/.venv
+/dist/
+/.python-version
+
+# coverage
+/.coverage
+/coverage.*
+
+# docs
+/docs/_build/
+/site/
+
+# project
+/odoo_*.zip
+/test_*
+/test-

odoo_project-0.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Dmitry Voronin
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

odoo_project-0.1/PKG-INFO

@@ -0,0 +1,15 @@
+Metadata-Version: 2.5
+Name: odoo-project
+Version: 0.1
+Summary: Object models for Odoo modules and projects
+Project-URL: repository, https://github.com/odoo-ru/odoo-project
+Project-URL: documentation, https://odoo-ru.github.io/odoo-project/
+Author-email: Dmitry Voronin <voronin.odoo@gmail.com>
+License-Expression: MIT
+License-File: LICENSE
+Classifier: Development Status :: 3 - Alpha
+Classifier: Framework :: Odoo :: 20.0
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.12
+Requires-Dist: attrs>=26.1.0
+Requires-Dist: tomlkit>=0.15.2

odoo_project-0.1/README.md

@@ -0,0 +1,38 @@
+Odoo Project
+============
+[![PyPI Version](https://img.shields.io/pypi/v/odoo-project)](https://pypi.org/project/odoo-project/ "Latest version on PyPI")
+![PyPI Status](https://img.shields.io/pypi/status/odoo-project)
+![Python Versions](https://img.shields.io/pypi/pyversions/odoo-project)
+[![PyPI Versions from Framework Classifiers](https://img.shields.io/pypi/frameworkversions/odoo/odoo-project?color=A24689)](https://www.odoo.com/documentation/20.0/developer/reference.html "Odoo 20.0 developer docs")
+[![Github Pages](https://img.shields.io/badge/github-pages-blue?logo=github)](https://odoo-ru.github.io/odoo-project/ "Documentation")
+[![Coverage](https://coveralls.io/repos/github/odoo-ru/odoo-project/badge.svg?branch=main)](https://coveralls.io/github/odoo-ru/odoo-project?branch=main "Coverage")
+
+Model Objects for Odoo modules and projects.
+
+Install
+-------
+```console
+uv add odoo-project
+```
+
+Usage
+-----
+```python
+from odoo_project import OdooModule
+
+module = OdooModule('./hr_payroll')
+```
+See [documentation](https://odoo-ru.github.io/odoo-project/).
+
+Development
+-----------
+```console
+git clone git@github.com:odoo-ru/odoo-project.git
+
+cd odoo-project
+```
+
+Run tests:
+```console
+uv run pytest
+```

odoo_project-0.1/odoo_project/__init__.py

@@ -0,0 +1,6 @@
+from odoo_project.module import OdooModule, OdooModuleManifest
+
+__all__ = [
+    'OdooModule',
+    'OdooModuleManifest',
+]

odoo_project-0.1/odoo_project/config.py

@@ -0,0 +1,18 @@
+from dataclasses import dataclass, field
+
+import tomlkit
+
+
+@dataclass(order=True)
+class Config:
+    project_module_dirs: list[str] = field(default_factory=list)
+    third_party_module_dirs: list[str] = field(default_factory=list)
+    include_modules: list[str] = field(default_factory=list)
+    exclude_modules: list[str] = field(default_factory=list)
+
+
+def read_config(path):
+    with path.open() as config_file:
+        config = tomlkit.load(config_file)
+
+    return Config(**config.unwrap())

odoo_project-0.1/odoo_project/module.py

@@ -0,0 +1,250 @@
+import ast
+from collections.abc import Iterable
+from functools import cached_property
+from pathlib import Path
+
+from attr import Factory
+from attrs import define
+
+
+class AutoInstallTypeError(TypeError):
+    def __init__(self, value):
+        super().__init__(f'Invalid type of manifest auto_install: {type(value)}')
+
+
+class CacheModuleMeta(type):
+    def __init__(cls, what, bases, dict):
+        super().__init__(what, bases, dict)
+        cls._modules_cache = {}
+
+    def __call__(cls, path, *args, cache_module=True, **kwargs):
+        if isinstance(path, str):
+            path = Path(path)
+
+        path = path.resolve()
+
+        if cache_module and path in cls._modules_cache:
+            return cls._modules_cache[path]
+
+        instance = super().__call__(path, *args, **kwargs)
+        if cache_module:
+            cls._modules_cache[path] = instance
+        return instance
+
+
+README_FILE_NAMES = ['README.rst', 'README.md', 'README.txt', 'README']
+STATIC_DESCRIPTION_ICON = 'static/description/icon.png'
+
+
+@define(slots=True)
+class OdooModuleManifest:
+    """
+    A wrapper around the values of an Odoo module manifest file.
+
+    Designed for convenient access to manifest values
+    without computing certain fields as Odoo does.
+    It exposes all known manifest fields as class attributes.
+    Missing values are automatically populated with defaults, empty lists, empty dicts, or `None`.
+    """
+    name: str
+    version: str = '1.0'
+    summary: str | None = None
+    description: str | None = None
+    website: str | None = None
+    license: str = 'LGPL-3'
+    category: str = 'Uncategorized'
+    sequence: int = 100
+    icon: str | None = None
+
+    author: str | None = None
+    contributors: str | None = None
+    maintainer: str | None = None
+
+    installable: bool = True
+    application: bool = False
+    depends: list[str] = Factory(list)
+    auto_install: bool | list[str] = False
+    external_dependencies: dict | None = Factory(dict)
+
+    data: list[str] = Factory(list)
+    demo: list[str] = Factory(list)
+    assets: dict[str, list[str]] = Factory(dict)
+
+    pre_init_hook: str | None = None
+    post_init_hook: str | None = None
+    uninstall_hook: str | None = None
+    post_load: str | None = None
+
+    # Odoo 20 modules fields
+    iap_paid_service: bool = False
+    # l10n_* modules
+    countries: list[str] = Factory(list)
+    # theme_* + hr
+    images: list[str] = Factory(list)
+    # theme_* + website
+    configurator_snippets: dict[str, list[str]] = Factory(dict)
+    # theme_*
+    configurator_snippets_addons: dict[str, dict] = Factory(dict)
+    theme_customizations: dict[str, dict] = Factory(dict)
+    # l10n_cr modules. Incorrect field
+    url: str | None = None
+    # some hr, some pos and other modules
+    other_files: list[str] = Factory(list)
+    # account
+    kpi_providers: list[str] = Factory(list)
+    # web, api_doc, auth_signup
+    bootstrap: bool = False
+    # website
+    new_page_templates: dict[str, dict] = Factory(dict)
+
+    @classmethod
+    def from_path(cls, path: Path):
+        """Read values from directory `__manifest__.py` file."""
+        with (path / '__manifest__.py').open() as manifest_file:
+            # TODO keep file content
+            manifest_dict = ast.literal_eval(manifest_file.read())
+            return cls(**manifest_dict)
+
+
+# Use attrs.define to enable cached_property with slots.
+# https://discuss.python.org/t/extensible-cached-property/105188
+# https://github.com/python-attrs/attrs/pull/1200
+@define(
+    slots=True,
+    init=False,
+    repr=False,
+    eq=False,
+)
+class OdooModule(metaclass=CacheModuleMeta):
+    """
+    Represents an Odoo module directory.
+
+    Designed to work with module files, including the manifest, data, and translations.
+    The implementation is independent of the Odoo version, does not import `odoo`,
+    and does not rely on Odoo code.
+    """
+    path: Path
+    """Module dir path"""
+    name: str
+    """Module dir name <small>aka</small> Technical name"""
+
+    def __init__(self, path: Path):
+        if not is_module(path):
+            raise ValueError(path)
+
+        self.path = path
+        self.name = path.name
+
+    def __fspath__(self):
+        return str(self.path)
+
+    def __truediv__(self, path: Path | str) -> Path:
+        """Returns the path relative to the module directory."""
+        return self.path / path
+
+    def __repr__(self):
+        return f'OdooModule({str(self.path)!r})'
+
+    def __eq__(self, other):
+        return self.path == other.path
+
+    def __hash__(self):
+        return hash(self.path)
+
+    @cached_property
+    def manifest(self) -> OdooModuleManifest:
+        """Returns parsed manifest object"""
+        return OdooModuleManifest.from_path(self.path)
+
+    @cached_property
+    def readme_path(self) -> Path | None:
+        """
+        Returns first of existing files or `None`:
+
+        1. README.rst
+        2. README.md
+        3. README.txt
+        4. README
+        """
+        for readme_file_name in README_FILE_NAMES:
+            readme_file_path = self / readme_file_name
+            if readme_file_path.is_file():
+                return readme_file_path
+        return None
+
+    @cached_property
+    def icon_path(self) -> str:
+        """
+        Returns first available option:
+
+        1. Manifest icon value if it is specified.
+        2. `/<module>/static/description/icon.png` if file exists.
+        3. Fallback to `/base/static/description/icon.png`.
+        """
+        if self.manifest.icon:
+            return self.manifest.icon
+
+        if (self / STATIC_DESCRIPTION_ICON).is_file():
+            return f'/{self.name}/{STATIC_DESCRIPTION_ICON}'
+
+        return f'/base/{STATIC_DESCRIPTION_ICON}'
+
+    @cached_property
+    def dependencies(self) -> frozenset[str]:
+        """
+        Returns manifest `depends` wrapped into `frozenset`.
+        Adds `base` if it's empty.
+        """
+        if not self.manifest.depends and self.name != 'base':
+            return frozenset({'base'})
+        return frozenset(self.manifest.depends)
+
+    @cached_property
+    def is_auto_install(self) -> bool:
+        """
+        Returns True if manifest `auto_install` is True or Iterable.
+        """
+        if isinstance(self.manifest.auto_install, bool):
+            return self.manifest.auto_install
+        if isinstance(self.manifest.auto_install, Iterable):
+            return True
+        raise AutoInstallTypeError(self.manifest.auto_install)
+
+    @cached_property
+    def auto_install_depends(self) -> frozenset[str]:
+        """
+        Return frozenset depends on manifest `auto_install` value.
+        If it's True returns `self.dependencies`.
+        If it's False returns empty set.
+        If it's list returns frozenset of its values.
+        """
+        if self.manifest.auto_install is False:
+            return frozenset()
+        if self.manifest.auto_install is True:
+            return self.dependencies
+        if isinstance(self.manifest.auto_install, Iterable):
+            return frozenset(self.manifest.auto_install)
+        raise AutoInstallTypeError(self.manifest.auto_install)
+
+    def is_installable(self, serie):
+        adopted_version = adapt_version(self.manifest.version, serie)
+        return self.manifest.installable and adopted_version.startswith(serie + '.')
+
+
+SERIE_LENGTH = 2
+FULL_VERSION_MIN_LENGTH = 4
+
+
+def adapt_version(version, serie):
+    """
+    Adapt module version by prefix Odoo major version.
+    Odoo 20: adapt_version at odoo/modules/module.py:589:1
+    """
+    version_parts = version.split('.')
+    if len(version_parts) < FULL_VERSION_MIN_LENGTH and '.'.join(version_parts[:SERIE_LENGTH]) != serie:
+        return f'{serie}.{version}'
+    return version
+
+
+def is_module(path: Path):
+    return (path / '__manifest__.py').is_file()

odoo_project-0.1/odoo_project/module_set.py

@@ -0,0 +1,44 @@
+import functools
+
+
+# What is the correct (or best) way to subclass the Python set class, adding a new instance variable?
+# https://stackoverflow.com/questions/798442
+def wrap(method):
+    @functools.wraps(method)
+    def wrapped_method(*args, **kwargs):
+        return OdooModuleSet(method(*args, **kwargs))
+    return wrapped_method
+
+
+class OdooModuleSet(set):
+    # @cached_property
+    @property
+    def names_list(self):
+        return sorted(self.names)
+
+    # @cached_property
+    @property
+    def names(self):
+        return {module.name for module in self}
+
+    def depends(self):
+        return set().union(*[module.dependencies for module in self]) - self.names
+
+    def sorted(self):
+        return sorted(self, key=lambda m: m.name)
+
+    for method in [
+        '__or__',
+        '__and__',
+        '__sub__',
+        'difference',
+        'difference_update',
+        'intersection_update',
+        'symmetric_difference',
+        'symmetric_difference_update',
+        'intersection',
+        'union',
+        'copy',
+    ]:
+        # ruff:ignore[exec-builtin]
+        exec(f'{method} = wrap(set.{method})')

odoo_project-0.1/odoo_project/project.py

@@ -0,0 +1,224 @@
+import dataclasses
+from collections.abc import Container, Iterable
+from functools import cached_property, lru_cache
+from pathlib import Path
+
+from odoo_project.config import Config, read_config
+from odoo_project.module import OdooModule, is_module
+from odoo_project.module_set import OdooModuleSet
+
+
+class OdooProject:
+    def __init__(self, path, **options):
+        self.path = Path(path).resolve()
+
+        config_dict = dataclasses.asdict(self.project_file_config)
+        config_dict.update(options)
+        self.project_config = Config(**config_dict)
+
+    @property
+    def project_file_config(self):
+        return read_config(self.path / 'odoo-project.toml')
+
+    @property
+    def project_module_paths(self):
+        return [(self.path / path) for path in self.project_config.project_module_dirs]
+
+    @property
+    def third_party_module_paths(self):
+        return [(self.path / path) for path in self.project_config.third_party_module_dirs]
+
+    @cached_property
+    def modules_paths(self):
+        # In fact core_modules_path is os.path.join(odoo.tools.config['root_path'], 'addons').
+        # We don't want to import odoo. It's long one second almost.
+
+        # ruff:ignore[import-outside-top-level]
+        import importlib
+        odoo_module_spec = importlib.util.find_spec('odoo')
+        odoo_module_path = odoo_module_spec.submodule_search_locations[0]
+        core_modules_path = Path(odoo_module_path, 'addons').resolve()
+
+        return (
+            self.project_module_paths
+            + self.third_party_module_paths
+            + [core_modules_path]
+        )
+
+    def collect_modules(self, paths: Iterable[Path], exclude: Container[str] = ()):
+        modules = OdooModuleSet()
+        for module_path in paths:
+            for subdir in module_path.iterdir():
+                if subdir.name not in exclude and is_module(subdir):
+                    modules.add(OdooModule(subdir))
+        return modules
+
+    # ruff:ignore[cached-instance-method]
+    @lru_cache(maxsize=1024)
+    def module(self, module_name):
+        for modules_path in self.modules_paths:
+            module_path = modules_path / module_name
+            if is_module(module_path):
+                # TODO Cache?
+                return OdooModule(module_path)
+        msg = f'No module found: {module_name}'
+        raise LookupError(msg)
+
+    def find_modules(self, module_names):
+        return OdooModuleSet(self.module(module_name) for module_name in module_names)
+
+    @property
+    def required_modules(self) -> OdooModuleSet:
+        return (
+            self.collect_modules(self.project_module_paths, exclude=self.project_config.exclude_modules)
+            | self.find_modules(self.project_config.include_modules)
+        )
+
+    def expand_dependencies(self, modules):
+        modules_to_check_depends = modules
+
+        while True:
+            module_depends_names = modules_to_check_depends.depends()
+            if module_depends_names:
+                modules_to_check_depends = self.find_modules(module_depends_names)
+                modules |= modules_to_check_depends
+            else:
+                break
+
+        return modules
+
+    def auto_install_modules(self, modules: OdooModuleSet):
+        auto_install_modules = OdooModuleSet()
+        for module in self.collect_modules(self.modules_paths, exclude=modules.names):
+            if module.is_auto_install and set(module.depends) <= modules.names:
+                auto_install_modules.add(module)
+        return auto_install_modules
+
+    @property
+    def installed_modules(self):
+        modules = self.expand_dependencies(self.required_modules)
+
+        while True:
+            auto_install_modules = self.auto_install_modules(modules)
+            if auto_install_modules:
+                modules |= auto_install_modules
+            else:
+                break
+
+        return modules
+
+    def topologic_dependencies(self, modules: OdooModuleSet):
+        result = []
+        visited = set()
+
+        def visit(modd):
+            if modd not in visited:
+                visited.add(modd)
+                if modd in modules:
+                    for depend_module in self.find_modules(modd.depends).sorted():
+                        visit(depend_module)
+                    result.append(modd)
+
+        for module in modules.sorted():
+            visit(module)
+
+        return result
+
+    # @lru_cache
+    def installed_modules_list(self, *, inversed=False):
+        modules = self.topologic_dependencies(self.installed_modules)
+        if inversed:
+            modules = modules.reverse()
+        return modules
+
+    # =======================================================================
+    def module_graph(self, module_name):
+        processed_modules = set()
+
+        def recursive_module_graph(module):
+            edges = []
+            processed_modules.add(module)
+            for dependency_module_name in module.depends:
+                dependency_module = self.module(dependency_module_name)
+                edges.append((module, dependency_module))
+                if dependency_module not in processed_modules:
+                    edges.extend(self.module_graph(dependency_module))
+            return edges
+
+        return recursive_module_graph(self.module(module_name))
+
+    # ============= create db ====================
+    def cache_key(self, module_names, timestamp):
+        raise NotImplementedError
+
+    # Env
+    @cached_property
+    def env(self):
+        # Keep ref on generator force close generator later
+        return self._get_env('soma', self.installed_modules)
+
+    def _get_env(self, db_name, installed_modules: OdooModule | OdooModuleSet):
+        # ruff:ignore[unsorted-imports]
+        # ruff:ignore[import-outside-top-level]
+        from unittest import mock
+        # ruff:ignore[import-outside-top-level]
+        import odoo
+        # ruff:ignore[import-outside-top-level]
+        from odoo_project.database_mock import CursorMock, FakeDatabase
+
+        CursorMock.databases[db_name] = FakeDatabase(installed_modules)
+
+        with (
+            mock.patch('odoo.sql_db.Cursor', CursorMock),
+            odoo.registry(db_name).cursor() as cr,
+        ):
+            return odoo.api.Environment(cr, odoo.SUPERUSER_ID, {})
+
+    # ========== Translation ==========
+    def search_translation(self, tupl, lang=None):
+        for module in self.installed_modules_list():
+            translations = module.translations(lang or self.lang)
+            if tupl in translations:
+                return translations[tupl]
+        return None
+
+    def code_translation(self, file_path, value, lineno=None):
+        return self.search_translation(('code', file_path, lineno, value))
+
+    def selection(self, model_name, field_name, value, lang=None):
+        field = self.env[model_name]._fields[field_name]
+        for selection_value, _selection_string in field.selection:
+            if value == selection_value:
+                break
+        else:
+            msg = 'Invalid selection value'
+            raise ValueError(msg)
+        return self.search_translation(('selection', f'{model_name},{field_name}', '0', _selection_string), lang=lang)
+
+    def constraint(self, model, value):
+        return self.search_translation(('constraint', model, '0', value))
+
+    def sql_constraint(self, model, value):
+        return self.search_translation(('sql_constraint', model, '0', value))
+
+    def model_translation(self, model_name, field_name, xml_id, origin, lang=None):
+        return self.search_translation(('model', f'{model_name},{field_name}', xml_id, origin), lang=lang)
+
+    def model_description(self, model_name, lang=None):
+        model = self.env[model_name]
+        if not lang:
+            # ruff:ignore[private-member-access]
+            return model._description
+        # ruff:ignore[private-member-access]
+        xml_id = f'{model._original_module}.model_{model_name.replace(".", "_")}'
+        xml_id = None
+        # ruff:ignore[private-member-access]
+        return self.model_translation('ir.model', 'name', xml_id, model._description, lang=lang)
+
+    def field_description(self, model_name, field_name, lang=None):
+        field = self.env[model_name]._fields[field_name]
+        if not lang:
+            return field.string
+        # ruff:ignore[private-member-access]
+        xml_id = f'{field._module}.field_{model_name.replace(".", "_")}_{field_name}'
+        return self.model_translation('ir.model.fields', 'field_description', xml_id, field.string, lang=lang)

odoo_project-0.1/odoo_project/utils.py

@@ -0,0 +1,13 @@
+from pathlib import Path
+
+
+def import_odoo():
+    # ruff:ignore[import-outside-top-level]
+    import odoo
+
+    return odoo
+
+
+def odoo_core_modules_path():
+    odoo = import_odoo()
+    return Path(odoo.__path__[0]) / 'addons'

odoo_project-0.1/pyproject.toml

@@ -0,0 +1,57 @@
+[project]
+name = "odoo-project"
+dynamic = ["version"]
+description = "Object models for Odoo modules and projects"
+authors = [
+    { name = "Dmitry Voronin", email = "voronin.odoo@gmail.com" }
+]
+urls.repository = "https://github.com/odoo-ru/odoo-project"
+urls.documentation = "https://odoo-ru.github.io/odoo-project/"
+license = "MIT"
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Programming Language :: Python :: 3.12",
+    "Framework :: Odoo :: 20.0",
+]
+requires-python = ">=3.12"
+dependencies = [
+    "attrs>=26.1.0",
+    "tomlkit>=0.15.2",
+]
+
+[dependency-groups]
+dev = [
+    "ipython>=9.17.1",
+    "manifestoo>=1.1",
+    "mkdocstrings[python]>=1.0.8",
+    "pytest>=9.1.1",
+    "pytest-cov>=7.1.0",
+    "pytest-xdist>=3.8.0",
+    "sphinx>=9.1.1",
+    "sphinx-autobuild>=2025.8.25",
+    "zensical>=0.0.72",
+]
+
+[project.scripts]
+odoo-project = "odoo_project:main"
+
+[build-system]
+requires = ["hatchling", "hatch-vcs"]
+build-backend = "hatchling.build"
+
+[tool.hatch.version]
+source = "vcs"
+raw-options = { local_scheme = "no-local-version" }
+
+[tool.hatch.build.targets.sdist]
+include = [
+    "odoo_project",
+    "README.md",
+]
+
+[tool.uv]
+preview-features = ["centralized-project-envs"]
+
+[tool.uv.sources]
+odoo = { path = "odoo_20.0.20261018.zip" }
+