odoo-addons-path 1.0.0__py3-none-any.whl

odoo_addons_path/__init__.py

@@ -0,0 +1,4 @@
+from .cli import app
+from .main import get_addons_path
+
+__all__ = ["app", "get_addons_path"]

odoo_addons_path/cli.py

@@ -0,0 +1,87 @@
+import glob
+from pathlib import Path
+from typing import Annotated
+
+import typer
+
+from .main import get_addons_path
+
+
+def _parse_paths(values: list[str] | None) -> list[Path]:
+    if not values:
+        return []
+    paths: list[Path] = []
+    for value in values:
+        for p_str in value.split(","):
+            p_str = p_str.strip()
+            if not p_str:
+                continue
+            p = Path(p_str).expanduser()
+            if "*" in str(p) or "?" in str(p) or "[" in str(p):
+                paths.extend(Path(g) for g in sorted(glob.glob(str(p), recursive=True)))
+            else:
+                paths.append(p)
+    return paths
+
+
+app = typer.Typer()
+
+
+@app.command()
+def main(
+    codebase: Annotated[
+        Path,
+        typer.Argument(
+            envvar="CODEBASE",
+            help="Path to the Odoo project. Can also be set via the CODEBASE environment variable.",
+            exists=True,
+            file_okay=False,
+            dir_okay=True,
+            resolve_path=True,
+        ),
+    ] = Path("./"),
+    addons_dir: Annotated[
+        list[str] | None,
+        typer.Option(
+            help=(
+                "Paths that are addon directories (contain Odoo modules) or "
+                "paths that contain addon directories (repositories with multiple Odoo modules). "
+                "Globs and comma-separated values are supported."
+            ),
+        ),
+    ] = None,
+    odoo_dir: Annotated[
+        str | None,
+        typer.Option(
+            help="Path containing the Odoo source code.",
+        ),
+    ] = None,
+    verbose: Annotated[
+        bool,
+        typer.Option(
+            "--verbose",
+            "-v",
+        ),
+    ] = False,
+):
+    """
+    Return addons_path constructor
+    """
+    odoo_dir_path = None
+    if odoo_dir:
+        odoo_dir_path = Path(odoo_dir).expanduser()
+        if not odoo_dir_path.exists():
+            typer.secho(f"Odoo dir {odoo_dir} not found.", fg=typer.colors.RED)
+            raise typer.Exit(1)
+
+    paths = _parse_paths(addons_dir)
+
+    addons_path = get_addons_path(
+        codebase=codebase,
+        addons_dir=paths,
+        odoo_dir=odoo_dir_path,
+        verbose=verbose,
+    )
+
+    if not verbose:
+        typer.echo(addons_path)

odoo_addons_path/detector.py

@@ -0,0 +1,246 @@
+from abc import ABC, abstractmethod
+from pathlib import Path
+from typing import Any, Optional
+
+import yaml
+
+
+class CodeBaseDetector(ABC):
+    _next_detector: Optional["CodeBaseDetector"] = None
+
+    def set_next(self, detector: "CodeBaseDetector") -> "CodeBaseDetector":
+        self._next_detector = detector
+        return detector
+
+    @abstractmethod
+    def detect(self, codebase: Path) -> tuple[str, dict[str, Any]] | None:
+        if self._next_detector:
+            return self._next_detector.detect(codebase)
+        return None
+
+
+class TrobzDetector(CodeBaseDetector):
+    def detect(self, codebase: Path) -> tuple[str, dict[str, Any]] | None:
+        if (codebase / ".trobz").is_dir():
+            addons_dirs = []
+            for item in (codebase / "addons").iterdir():
+                if item.is_dir():
+                    addons_dirs.append(item)
+            return (
+                "Trobz",
+                {
+                    "addons_dirs": addons_dirs,
+                    "addons_dir": [codebase / "project"],
+                    "odoo_dir": [
+                        codebase / "odoo/addons",
+                        codebase / "odoo/odoo/addons",
+                    ],
+                },
+            )
+        return super().detect(codebase)
+
+
+class DoodbaDetector(CodeBaseDetector):
+    """
+    ┌─ root/
+    │  └── odoo/
+    │      └── custom/
+    │          └── src/
+    │              ├── odoo/         # Odoo core addons
+    │              │   └── addons/
+    │              ├── private/
+    │              │   └── addon4/
+    │              └── submodule/
+    │                  └── addon1/
+    """
+
+    def detect(self, codebase: Path) -> tuple[str, dict[str, Any]] | None:
+        copier_answers_file = codebase / ".copier-answers.yml"
+        if not copier_answers_file.is_file():
+            return super().detect(codebase)
+        with open(copier_answers_file) as f:
+            try:
+                answers = yaml.safe_load(f)
+                if "doodba" in answers.get("_src_path", ""):
+                    addons_dirs = []
+                    path = codebase / "odoo" / "custom" / "src"
+                    if path.is_dir():
+                        for item in path.iterdir():
+                            if item.is_dir() and item.name not in ("odoo", "private"):
+                                addons_dirs.append(item)
+                        return (
+                            "Doodba",
+                            {
+                                "addons_dirs": addons_dirs,
+                                "addons_dir": [codebase / "odoo/custom/src/private"],
+                                "odoo_dir": [
+                                    codebase / "odoo/custom/src/odoo/addons",
+                                    codebase / "odoo/custom/src/odoo/odoo/addons",
+                                ],
+                            },
+                        )
+            except yaml.YAMLError:
+                pass
+        return super().detect(codebase)
+
+
+class C2CDetector(CodeBaseDetector):
+    """
+    Supports both legacy and new C2C project structures:
+
+    Legacy Layout:
+    ┌─ odoo/
+    │  ├── Dockerfile
+    │  ├── src/                # Odoo core source
+    │  │   ├── addons/
+    │  │   └── odoo/
+    │  │       └── addons/
+    │  ├── external-src/
+    │  │   └── custom-repo/
+    │  └── local-src/
+    │      └── addon2/
+
+    New Layout:
+    ┌─ root/
+    ├── Dockerfile
+    ├── odoo/
+    │  ├── addons/
+    │  │   └── addon1/
+    │  ├── dev-src/
+    │  │   └── addon2/
+    │  ├── paid-modules/
+    │  │   └── addon3/
+    │  └── external-src/
+    │       ├── custom-repo/
+    │       └── addon4/
+    """
+
+    def _find_docker_file(self, codebase: Path) -> Path | None:
+        for path in [codebase / "odoo" / "Dockerfile", codebase / "Dockerfile"]:
+            if path.is_file():
+                return path
+        return None
+
+    def _is_c2c_dockerfile(self, docker_file: Path) -> bool:
+        try:
+            with open(docker_file) as f:
+                content = f.read()
+                return "LABEL maintainer='Camptocamp'" in content or 'LABEL maintainer="Camptocamp"' in content
+        except (FileNotFoundError, PermissionError, OSError):
+            return False
+
+    def _collect_external_src_dirs(self, codebase: Path) -> list[Path]:
+        addons_dirs = []
+        external_src_dir = codebase / "odoo" / "external-src"
+        if external_src_dir.is_dir():
+            for item in external_src_dir.iterdir():
+                if item.is_dir():
+                    addons_dirs.append(item)
+        return addons_dirs
+
+    def _detect_legacy_layout(self, codebase: Path) -> bool:
+        odoo_src_dir = codebase / "odoo" / "src"
+        return odoo_src_dir.is_dir()
+
+    def _get_legacy_config(self, codebase: Path, addons_dirs: list[Path]) -> dict[str, Any]:
+        return {
+            "addons_dirs": addons_dirs,
+            "addons_dir": [codebase / "odoo/local-src"],
+            "odoo_dir": [
+                codebase / "odoo/src/addons",
+                codebase / "odoo/src/odoo/addons",
+            ],
+        }
+
+    def _get_new_config(self, codebase: Path, addons_dirs: list[Path]) -> dict[str, Any]:
+        addons_dir_paths = []
+        odoo_dir_paths = []
+
+        for dir_name in ["dev-src", "paid-modules"]:
+            dir_path = codebase / "odoo" / dir_name
+            if dir_path.is_dir():
+                addons_dir_paths.append(dir_path)
+
+        odoo_addons_dir = codebase / "odoo" / "addons"
+        if odoo_addons_dir.is_dir():
+            odoo_dir_paths.append(odoo_addons_dir)
+
+        return {
+            "addons_dirs": addons_dirs,
+            "addons_dir": addons_dir_paths,
+            "odoo_dir": odoo_dir_paths,
+        }
+
+    def detect(self, codebase: Path) -> tuple[str, dict[str, Any]] | None:
+        docker_file = self._find_docker_file(codebase)
+        if not docker_file or not self._is_c2c_dockerfile(docker_file):
+            return super().detect(codebase)
+
+        addons_dirs = self._collect_external_src_dirs(codebase)
+
+        if self._detect_legacy_layout(codebase):
+            return "Camptocamp (Legacy)", self._get_legacy_config(codebase, addons_dirs)
+        else:
+            return "Camptocamp", self._get_new_config(codebase, addons_dirs)
+
+
+class OdooShDetector(CodeBaseDetector):
+    """
+    Follow Odoo.sh mode
+    src/
+    ├── enterprise/         # Odoo Enterprise
+    ├── odoo/               # Odoo core
+    └── themes/
+    ├── user/               # user's submodule
+    │   └── OCA/
+    """
+
+    def detect(self, codebase: Path) -> tuple[str, dict[str, Any]] | None:
+        if (
+            (codebase / "enterprise").is_dir()
+            and (codebase / "odoo").is_dir()
+            and (codebase / "themes").is_dir()
+            and (codebase / "user").is_dir()
+        ):
+            addons_dirs = [codebase / "enterprise", codebase / "themes"]
+            for item in (codebase / "user").iterdir():
+                if item.is_dir():
+                    addons_dirs.append(item)
+            return (
+                "odoo.sh",
+                {
+                    "addons_dirs": addons_dirs,
+                    "addons_dir": [codebase / "project"],
+                    "odoo_dir": [
+                        codebase / "odoo/addons",
+                        codebase / "odoo/odoo/addons",
+                    ],
+                },
+            )
+        return super().detect(codebase)
+
+
+class GenericDetector(CodeBaseDetector):
+    """
+    A fallback detector that looks for any folder that contains __manifest__.py
+    """
+
+    def detect(self, codebase: Path) -> tuple[str, dict[str, Any]] | None:
+        manifest_files = []
+        for manifest_file in codebase.glob("**/__manifest__.py"):
+            # ignore setup folder in a module
+            if "setup" in manifest_file.parts:
+                continue
+            # ignore folder in a same folder
+            str_manifest_file = str(manifest_file)
+            if str_manifest_file.count("__manifest__.py") > 1:
+                continue
+            manifest_files.append(str_manifest_file)
+        if not manifest_files:
+            return super().detect(codebase)
+
+        addons_dirs = set()
+        for manifest_file in manifest_files:
+            addons_dirs.add(Path(manifest_file).parent.parent)
+
+        return "fallback", {"addons_dirs": list(addons_dirs)}

odoo_addons_path/main.py

@@ -0,0 +1,100 @@
+from pathlib import Path
+
+import typer
+
+from odoo_addons_path.detector import C2CDetector, DoodbaDetector, GenericDetector, OdooShDetector, TrobzDetector
+
+
+def _add_to_path(path_list: list[str], dirs_to_add: list[Path], is_sorted: bool = False):
+    if is_sorted:
+        dirs_to_add = sorted(dirs_to_add, key=lambda p: p.name)
+    for d in dirs_to_add:
+        if d.is_dir():
+            resolved_path = str(d.resolve())
+            if resolved_path not in path_list:
+                path_list.append(resolved_path)
+
+
+def _detect_codebase_layout(codebase: Path, verbose: bool = False) -> dict:
+    trobz = TrobzDetector()
+    c2c = C2CDetector()
+    odoo_sh = OdooShDetector()
+    doodba = DoodbaDetector()
+    fallback = GenericDetector()
+    trobz.set_next(c2c).set_next(odoo_sh).set_next(doodba).set_next(fallback)
+    res = trobz.detect(codebase)
+    if not res:
+        typer.secho("No codebase layout detected", fg=typer.colors.RED)
+        raise typer.Exit(1)
+    detector_name, detected_paths = res
+    if verbose:
+        typer.echo(f"Codebase layout: {detector_name}")
+    return detected_paths
+
+
+def _process_paths(
+    all_paths: dict[str, list[str]],
+    detected_paths: dict,
+    addons_dir: list[Path] | None,
+    odoo_dir: Path | None,
+):
+    if odoo_dir:
+        _add_to_path(
+            all_paths["odoo_dir"],
+            [odoo_dir / "addons", odoo_dir / "odoo" / "addons"],
+        )
+    if detected_paths.get("odoo_dir"):
+        _add_to_path(all_paths["odoo_dir"], detected_paths["odoo_dir"])
+
+    all_addon_paths_to_process = (
+        (addons_dir or []) + detected_paths.get("addons_dirs", []) + detected_paths.get("addons_dir", [])
+    )
+
+    result = []
+
+    for p in all_addon_paths_to_process:
+        if not p.is_dir():
+            continue
+        manifests = p.glob("**/__manifest__.py")
+        for manifest in sorted(manifests):
+            repo_path = manifest.parent.parent
+            if repo_path not in result:
+                result.append(repo_path)
+
+    _add_to_path(
+        all_paths["addon_repositories"],
+        result,
+        is_sorted=not bool(addons_dir),
+    )
+
+
+def get_addons_path(
+    codebase: Path,
+    addons_dir: list[Path] | None = None,
+    odoo_dir: Path | None = None,
+    verbose: bool = False,
+) -> str:
+    all_paths: dict[str, list[str]] = {
+        "odoo_dir": [],
+        "addon_repositories": [],
+    }
+
+    detected_paths = {}
+    if not addons_dir:
+        detected_paths = _detect_codebase_layout(codebase, verbose)
+
+    _process_paths(all_paths, detected_paths, addons_dir, odoo_dir)
+
+    result = [path for paths in all_paths.values() for path in paths]
+    addons_path = ",".join(result)
+
+    if verbose:
+        for category, paths in all_paths.items():
+            if paths:
+                typer.echo(f"\n# {category}")
+                for path in paths:
+                    typer.echo(path)
+        typer.echo("\n# addons_path")
+        typer.echo(addons_path)
+
+    return addons_path

odoo_addons_path-1.0.0.dist-info/METADATA

@@ -0,0 +1,62 @@
+Metadata-Version: 2.4
+Name: odoo-addons-path
+Version: 1.0.0
+Summary: Create the ultimate Odoo addons_path constructor
+Project-URL: Repository, https://github.com/trobz/odoo-addons-path
+Author-email: trisdoan <doanminhtri8183@gmail.com>
+Keywords: python
+Requires-Python: <4.0,>=3.10
+Requires-Dist: pyyaml
+Requires-Dist: typer>=0.19.2
+Description-Content-Type: text/markdown
+
+# odoo-addons-path
+
+A tool to auto-detect and construct Odoo `addons_path` for various project layouts.
+
+## Install
+
+```bash
+pip install odoo-addons-path
+```
+
+## Quick start
+
+### As a CLI tool
+
+```bash
+odoo-addons-path /path/to/your/odoo/project
+```
+
+#### Example: This will find addon directories that inside '18.0' directories
+```bash
+odoo-addons-path --addons-dir "./tests/data/repo-version-module/*/18.0"
+```
+
+#### Example: List of repo directories
+```bash
+odoo-addons-path --verbose --addons-dir "./tests/data/c2c-new/odoo/external-src/, ./tests/data/c2c/odoo/external-src/"
+```
+
+**Note:** The path to the codebase can also be set via the `CODEBASE` environment variable.
+
+### As a library
+
+```python
+from pathlib import Path
+from odoo_addons_path import get_addons_path
+
+addons_path = get_addons_path(Path("/path/to/your/odoo/project"))
+print(addons_path)
+```
+
+## Codebase layouts supported
+
+There are several out-of-the-box supported layouts:
+
+- `c2c`
+- `doodba`
+- `odoo.sh`
+- `trobz`
+
+For more details on the layouts, please refer to the `tests/data/` directory.

odoo_addons_path-1.0.0.dist-info/RECORD

@@ -0,0 +1,8 @@
+odoo_addons_path/__init__.py,sha256=9KUyE7AUseiDPwHNZ3v35BA9KYzsyPuAMV1hbo9baKI,93
+odoo_addons_path/cli.py,sha256=C6wgoGx7jfCeQWYlvNO1gQKJD4ghMyRqFRjvviutIzc,2234
+odoo_addons_path/detector.py,sha256=RTFVpTCvsN8La-NnYch0lTAFArkbnV1ZZ_BNsiFOzE0,8658
+odoo_addons_path/main.py,sha256=M61uCoeSdQYqhvm6Fc15WO3Kh2TaZkp5sUman_pzPtc,2965
+odoo_addons_path-1.0.0.dist-info/METADATA,sha256=-9MTSqnyem65crtXG7YuUtBnjsp2jhxRJu9KR5lwipQ,1445
+odoo_addons_path-1.0.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+odoo_addons_path-1.0.0.dist-info/entry_points.txt,sha256=m4J4eCgDvGLRCbp0yrKdSpj9QIlUOubSMan7cnvx2-g,62
+odoo_addons_path-1.0.0.dist-info/RECORD,,

odoo_addons_path-1.0.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.27.0
+Root-Is-Purelib: true
+Tag: py3-none-any

odoo_addons_path-1.0.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+odoo-addons-path = odoo_addons_path.cli:app