odoo-dev 1.4.0__tar.gz → 1.5.0__tar.gz

odoo_dev-1.5.0/.release-please-manifest.json

@@ -0,0 +1,3 @@
+{
+  ".": "1.5.0"
+}

{odoo_dev-1.4.0 → odoo_dev-1.5.0}/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog
 
+## [1.5.0](https://github.com/bemade/odoo-dev/compare/v1.4.0...v1.5.0) (2026-10-01)
+
+
+### Features
+
+* **setup:** project-local data_dir, addon manifest deps, ADMIN_PASSWD ([#23](https://github.com/bemade/odoo-dev/issues/23)) ([60c931e](https://github.com/bemade/odoo-dev/commit/60c931e3cf38c025895eb183d1a3a1ee929931e2))
+
+
+### Bug Fixes
+
+* **vendor:** ignore local python bytecode in vendor check, fail on tracked bytecode ([#25](https://github.com/bemade/odoo-dev/issues/25)) ([8d679af](https://github.com/bemade/odoo-dev/commit/8d679af962d96002a1ff978e6229ffeaf063250c))
+
 ## [1.4.0](https://github.com/bemade/odoo-dev/compare/v1.3.0...v1.4.0) (2026-09-04)
 
 

{odoo_dev-1.4.0 → odoo_dev-1.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: odoo-dev
-Version: 1.4.0
+Version: 1.5.0
 Summary: Odoo Development Environment Helper
 Project-URL: Homepage, https://github.com/bemade/odoo-dev
 Project-URL: Repository, https://github.com/bemade/odoo-dev
@@ -236,8 +236,20 @@ PYTHON_VERSION=3.12
 # DB_PORT=5432
 # DB_USER=odoo
 # DB_PASSWORD=odoo
+
+# Optional — Odoo master password, written into conf/odoo.conf by `setup`.
+# Defaults to "admin".
+# ADMIN_PASSWD=admin
 ```
 
+`setup` also points `data_dir` at a project-local `.odoo-data/` (git-ignored)
+rather than the shared `~/.local/share/Odoo`, so filestores, sessions and the
+addons cache stay scoped to the checkout they belong to.
+
+Python packages declared in your addons' manifests — `external_dependencies`
+*and* the OCA `test_external_dependencies` convention, across both `addons/`
+and `vendored/` — are installed into the venv by `setup`.
+
 ## Requirements
 
 - Python 3.12+

{odoo_dev-1.4.0 → odoo_dev-1.5.0}/README.md

@@ -221,8 +221,20 @@ PYTHON_VERSION=3.12
 # DB_PORT=5432
 # DB_USER=odoo
 # DB_PASSWORD=odoo
+
+# Optional — Odoo master password, written into conf/odoo.conf by `setup`.
+# Defaults to "admin".
+# ADMIN_PASSWD=admin
 ```
 
+`setup` also points `data_dir` at a project-local `.odoo-data/` (git-ignored)
+rather than the shared `~/.local/share/Odoo`, so filestores, sessions and the
+addons cache stay scoped to the checkout they belong to.
+
+Python packages declared in your addons' manifests — `external_dependencies`
+*and* the OCA `test_external_dependencies` convention, across both `addons/`
+and `vendored/` — are installed into the venv by `setup`.
+
 ## Requirements
 
 - Python 3.12+

{odoo_dev-1.4.0 → odoo_dev-1.5.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "odoo-dev"
-version = "1.4.0"
+version = "1.5.0"
 description = "Odoo Development Environment Helper"
 readme = "README.md"
 requires-python = ">=3.12"

odoo_dev-1.5.0/src/odoo_dev/__init__.py

@@ -0,0 +1,3 @@
+"""Odoo Development Environment Helper."""
+
+__version__ = "1.5.0"  # x-release-please-version

{odoo_dev-1.4.0 → odoo_dev-1.5.0}/src/odoo_dev/commands/run.py

@@ -1,6 +1,7 @@
 """Local Odoo runtime commands."""
 
 import os
+import shutil
 import signal
 import subprocess
 import sys
@@ -582,6 +583,25 @@ def _drop_database(cfg, db_name: str) -> None:
         warning(f"Failed to drop test database {db_name}")
         if result.stderr:
             warning(result.stderr.strip())
+        return
+
+    # dropdb only removes the database. odoo-bin's own `db drop` deletes the
+    # filestore too, so the fallback has to, or every test run leaks a
+    # filestore directory that nothing ever cleans up.
+    _drop_filestore(cfg, db_name)
+
+
+def _drop_filestore(cfg, db_name: str) -> None:
+    """Remove the filestore directory belonging to a dropped database."""
+    from odoo_dev.config import read_data_dir
+
+    filestore = read_data_dir(cfg.config_file) / "filestore" / db_name
+    if not filestore.is_dir():
+        return
+    try:
+        shutil.rmtree(filestore)
+    except OSError as exc:
+        warning(f"Could not remove filestore {filestore}: {exc}")
 
 
 def _terminate_connections(db_name: str, db_config: dict[str, str]) -> None:

{odoo_dev-1.4.0 → odoo_dev-1.5.0}/src/odoo_dev/commands/setup.py

@@ -1,5 +1,6 @@
 """Setup commands for initializing Odoo development environment."""
 
+import ast
 import importlib.resources
 import os
 import shutil
@@ -248,10 +249,85 @@ def setup_venv() -> None:
         [*venv_pip, "pytest", "pytest-odoo", "debugpy", "manifestoo", "coverage"]
     )
 
+    # Install the external Python dependencies our addons declare
+    _install_manifest_python_deps(cfg, venv_pip)
+
     success("\nVirtual environment setup complete!")
     success(f"To activate: source {cfg.venv_path}/bin/activate")
 
 
+def _manifest_test_deps(addons_dir: Path) -> set[str]:
+    """Collect ``test_external_dependencies`` python packages from manifests.
+
+    This is an OCA convention rather than an Odoo core manifest key, so
+    manifestoo does not report it -- but the packages are needed to *run* the
+    tests of addons that declare it (e.g. pdfminer.six). Manifests that are not
+    plain literals are skipped rather than failing setup.
+    """
+    deps: set[str] = set()
+    if not addons_dir.is_dir():
+        return deps
+    for manifest_path in sorted(addons_dir.glob("*/__manifest__.py")):
+        try:
+            manifest = ast.literal_eval(manifest_path.read_text())
+        except (SyntaxError, ValueError):
+            warning(f"Could not parse {manifest_path}, skipping its test deps")
+            continue
+        if not isinstance(manifest, dict):
+            continue
+        test_deps = manifest.get("test_external_dependencies") or {}
+        deps.update(test_deps.get("python") or [])
+    return deps
+
+
+def _manifest_runtime_deps(addons_dir: Path, venv_python: Path) -> set[str]:
+    """Collect ``external_dependencies`` python packages via manifestoo."""
+    if not addons_dir.is_dir():
+        return set()
+    result = subprocess.run(
+        [
+            str(venv_python),
+            "-m",
+            "manifestoo",
+            "--select-addons-dir",
+            str(addons_dir),
+            "list-external-dependencies",
+            "python",
+        ],
+        capture_output=True,
+        text=True,
+    )
+    if result.returncode != 0:
+        warning(f"manifestoo failed for {addons_dir}: {result.stderr.strip()}")
+        return set()
+    return {line.strip() for line in result.stdout.splitlines() if line.strip()}
+
+
+def _install_manifest_python_deps(cfg, venv_pip: list[str]) -> None:
+    """Install the Python packages our addons declare in their manifests.
+
+    Covers both ``addons/`` (client-specific) and ``vendored/`` (shared), and
+    both runtime and test dependencies. Without this, a module whose tests need
+    an external package installs fine and then fails at test time.
+    """
+    venv_python = cfg.venv_path / "bin" / "python"
+    deps: set[str] = set()
+    for addons_dir in (cfg.addons_dir, cfg.vendored_dir):
+        deps |= _manifest_runtime_deps(addons_dir, venv_python)
+        deps |= _manifest_test_deps(addons_dir)
+
+    if not deps:
+        return
+
+    success(f"Installing addon manifest dependencies: {', '.join(sorted(deps))}")
+    result = subprocess.run([*venv_pip, *sorted(deps)])
+    if result.returncode != 0:
+        warning(
+            "Some addon dependencies failed to install; tests that need them "
+            "will fail until they are installed manually."
+        )
+
+
 def vscode(cfg=None) -> None:
     """Set up VSCode configuration for debugging."""
     if cfg is None:
@@ -334,6 +410,7 @@ def _setup_odoo_config(cfg, community_only: bool = False) -> None:
 
     if conf_file.exists():
         warning(f"Config file already exists at {conf_file}")
+        _ensure_data_dir_configured(cfg, conf_file)
         return
 
     success("Creating Odoo configuration file...")
@@ -366,6 +443,8 @@ def _setup_odoo_config(cfg, community_only: bool = False) -> None:
     db_host = os.getenv("DB_HOST", "")
     db_port = os.getenv("DB_PORT", "")
 
+    admin_passwd = os.getenv("ADMIN_PASSWD", "admin")
+
     db_lines = []
     if db_host:
         db_lines.append(f"db_host = {db_host}")
@@ -377,15 +456,55 @@ def _setup_odoo_config(cfg, community_only: bool = False) -> None:
     config_content = (
         "[options]\n"
         f"addons_path = {','.join(addons_paths)}\n"
-        "admin_passwd = admin\n"
+        f"data_dir = {cfg.data_dir}\n"
+        f"admin_passwd = {admin_passwd}\n"
         f"{chr(10).join(db_lines)}\n"
     )
 
     conf_file.write_text(config_content)
     conf_file.chmod(0o600)
+    _gitignore_data_dir(cfg)
     success(f"Config file created at {conf_file}")
 
 
+def _ensure_data_dir_configured(cfg, conf_file: Path) -> None:
+    """Add ``data_dir`` to an odoo.conf that predates it.
+
+    Existing projects already have a conf file, so the generator's early return
+    would otherwise leave them on the shared ``~/.local/share/Odoo``. Only a
+    missing key is filled in — an explicit data_dir is left alone.
+    """
+    content = conf_file.read_text()
+    if any(
+        line.strip().partition("=")[0].strip() == "data_dir"
+        for line in content.splitlines()
+    ):
+        return
+
+    lines = content.splitlines()
+    for i, line in enumerate(lines):
+        if line.strip() == "[options]":
+            lines.insert(i + 1, f"data_dir = {cfg.data_dir}")
+            break
+    else:
+        lines.append(f"data_dir = {cfg.data_dir}")
+    conf_file.write_text("\n".join(lines) + "\n")
+    _gitignore_data_dir(cfg)
+    success(f"Added data_dir = {cfg.data_dir} to {conf_file}")
+
+
+def _gitignore_data_dir(cfg) -> None:
+    """Ensure the project-local data directory is git-ignored."""
+    gitignore = cfg.project_dir / ".gitignore"
+    entry = f"{cfg.data_dir.name}/"
+    lines = gitignore.read_text().splitlines() if gitignore.exists() else []
+    if entry in (line.strip() for line in lines):
+        return
+    lines.append(entry)
+    gitignore.write_text("\n".join(lines) + "\n")
+    success(f"Added {entry} to .gitignore")
+
+
 def _setup_docker_files(cfg, community_only: bool = False) -> None:
     """Copy Docker templates to .odoo-deploy directory."""
     success("Setting up Docker files...")
@@ -434,9 +553,11 @@ def _generate_docker_odoo_conf(
     if has_vendored:
         addons_paths.append("/opt/project/vendored")
 
+    admin_passwd = os.getenv("ADMIN_PASSWD", "admin")
+
     return f"""[options]
 addons_path = {",".join(addons_paths)}
-admin_passwd = admin
+admin_passwd = {admin_passwd}
 db_host = db
 db_port = 5432
 db_user = odoo

{odoo_dev-1.4.0 → odoo_dev-1.5.0}/src/odoo_dev/config.py

@@ -59,6 +59,28 @@ def read_db_config(config_file: Path) -> "DbConfig":
     return db
 
 
+# Odoo's own fallback when ``data_dir`` is absent from odoo.conf.
+DEFAULT_ODOO_DATA_DIR = Path.home() / ".local" / "share" / "Odoo"
+
+
+def read_data_dir(config_file: Path) -> Path:
+    """Read ``data_dir`` from an odoo.conf file.
+
+    Args:
+        config_file: Path to odoo.conf.
+
+    Returns:
+        The configured data directory, or Odoo's default when the file is
+        missing or does not set one.
+    """
+    if config_file.exists():
+        for line in config_file.read_text().splitlines():
+            key, sep, value = line.strip().partition("=")
+            if sep and key.strip() == "data_dir":
+                return Path(value.strip()).expanduser()
+    return DEFAULT_ODOO_DATA_DIR
+
+
 @dataclass
 class ProjectConfig:
     """Configuration for an Odoo development project."""
@@ -74,6 +96,18 @@ class ProjectConfig:
         """Path to the Python virtual environment."""
         return self.project_dir / ".venv"
 
+    @property
+    def data_dir(self) -> Path:
+        """Path to the project-local Odoo data directory.
+
+        Odoo defaults to a single shared ``~/.local/share/Odoo`` for every
+        project on the machine, which mixes filestores, sessions and the addons
+        cache across unrelated checkouts and leaves orphaned filestores behind
+        whenever a database is dropped without odoo-bin. Keeping it in-project
+        scopes all of that to the checkout it belongs to.
+        """
+        return self.project_dir / ".odoo-data"
+
     @property
     def config_file(self) -> Path:
         """Path to the local odoo.conf file."""

{odoo_dev-1.4.0 → odoo_dev-1.5.0}/src/odoo_dev/vendor/materialize.py

@@ -9,7 +9,9 @@ latter two and follows symlinks), which is what makes ``vendor check`` trustwort
 Python bytecode (``__pycache__/``, ``*.pyc``, ``*.pyo``) is excluded from the
 comparison: running or testing a vendored addon locally compiles it in place, and
 those artifacts are gitignored build output that is neither part of the pinned
-source nor present in a fresh CI checkout.
+source nor present in a fresh CI checkout. A directory holding nothing but
+bytecode (e.g. a ``tests/`` whose sources a pin bump removed) is skipped too: git
+does not track empty directories, so CI never sees it.
 """
 
 from __future__ import annotations
@@ -69,12 +71,20 @@ _BYTECODE_DIRS = {"__pycache__"}
 _BYTECODE_SUFFIXES = (".pyc", ".pyo")
 
 
+def is_bytecode(rel: str) -> bool:
+    """True if ``rel`` is python bytecode or lies inside a ``__pycache__`` dir."""
+    parts = Path(rel).parts
+    return rel.endswith(_BYTECODE_SUFFIXES) or any(
+        p in _BYTECODE_DIRS for p in parts
+    )
+
+
 def _entries(root: Path) -> dict:
     """Map each path relative to ``root`` to a comparable fingerprint.
 
     - symlink -> ("link", target)          (never dereferenced)
     - file    -> ("file", exec_bit, sha1)
-    - dir     -> ("dir",)
+    - dir     -> ("dir",)              (only if it holds a file or link)
 
     Python bytecode is skipped entirely (see the module docstring).
     """
@@ -104,7 +114,14 @@ def _entries(root: Path) -> dict:
             else:
                 exec_bit = 1 if os.stat(p).st_mode & 0o100 else 0
                 out[rel] = ("file", exec_bit, _sha1(p))
-    return out
+    # Like git, a directory exists only through its contents.
+    occupied = {
+        str(parent)
+        for rel, v in out.items()
+        if v[0] != "dir"
+        for parent in Path(rel).parents
+    }
+    return {rel: v for rel, v in out.items() if v[0] != "dir" or rel in occupied}
 
 
 def _sha1(path: Path) -> str:

{odoo_dev-1.4.0 → odoo_dev-1.5.0}/src/odoo_dev/vendor/verify.py

@@ -6,7 +6,8 @@ Assertions (any failure => non-empty problem list => CI red):
   3. moved-tag tripwire (when the entry carries a ``version`` tag);
   4. external python deps of vendored manifests are present in ``requirements.txt``;
   5. no addon name in both ``addons/`` and ``vendored/`` (double-load);
-  6. no file under ``vendored/`` is gitignored (it would be dropped at commit);
+  6. no file under ``vendored/`` is gitignored (it would be dropped at commit),
+     and no python bytecode under it is tracked by git (it is not in the pin);
   7. (``allow_hybrid=False`` only) no ``addons/`` symlink still points into a
      ``.repos/`` submodule — i.e. the repo is fully vendored, not a hybrid.
 The gate writes nothing.
@@ -23,7 +24,7 @@ from pathlib import Path
 from typing import Optional
 
 from odoo_dev.vendor.lock import Lockfile
-from odoo_dev.vendor.materialize import extract_subtree, tree_diff
+from odoo_dev.vendor.materialize import extract_subtree, is_bytecode, tree_diff
 from odoo_dev.vendor.sources import get_source_at, tag_resolves_to
 
 _MANIFEST_NAMES = ("__manifest__.py", "__openerp__.py")
@@ -124,6 +125,9 @@ def gitignored_under_vendored(project_dir: Path) -> list:
     ``check-ignore`` (not a tracked-vs-on-disk comparison) is the right probe: it
     reports exactly the paths git would drop, and consults the index, so neither a
     not-yet-staged ``vendor add`` nor a deliberate ``git add -f`` is a false alarm.
+
+    Python bytecode is not probed: it is never part of a pin, so ignoring it is
+    correct (and :func:`tracked_bytecode_under_vendored` catches the opposite).
     """
     project_dir = Path(project_dir)
     vendored = project_dir / "vendored"
@@ -132,7 +136,8 @@ def gitignored_under_vendored(project_dir: Path) -> list:
     rels = [
         str(p.relative_to(project_dir))
         for p in sorted(vendored.rglob("*"))
-        if p.is_symlink() or p.is_file()
+        if (p.is_symlink() or p.is_file())
+        and not is_bytecode(str(p.relative_to(vendored)))
     ]
     if not rels:
         return []
@@ -149,6 +154,39 @@ def gitignored_under_vendored(project_dir: Path) -> list:
     return [line for line in res.stdout.splitlines() if line.strip()]
 
 
+def tracked_bytecode_under_vendored(project_dir: Path) -> list:
+    """Python bytecode under ``vendored/`` that git tracks (index or HEAD).
+
+    :func:`tree_diff` skips bytecode so local test runs don't fail the gate, which
+    would also hide a ``.pyc`` that was committed by mistake. Untracked or
+    gitignored bytecode is fine; tracked bytecode ships a tree the pin does not
+    describe.
+    """
+    project_dir = Path(project_dir)
+    if not (project_dir / "vendored").is_dir() or not (project_dir / ".git").exists():
+        return []
+    res = subprocess.run(
+        ["git", "-C", str(project_dir), "ls-files", "-z", "--", "vendored"],
+        capture_output=True,
+        text=True,
+    )
+    if res.returncode != 0:
+        return []
+    return [
+        rel
+        for rel in res.stdout.split("\0")
+        if rel and is_bytecode(rel[len("vendored/"):])
+    ]
+
+
+def _has_source(addon_dir: Path) -> bool:
+    """True if ``addon_dir`` holds anything besides python bytecode."""
+    return any(
+        (p.is_file() or p.is_symlink()) and not is_bytecode(str(p.relative_to(addon_dir)))
+        for p in addon_dir.rglob("*")
+    )
+
+
 def verify(
     project_dir: Path,
     lock: Lockfile,
@@ -167,7 +205,7 @@ def verify(
     problems: list = []
 
     vendored_dirs = (
-        {p.name for p in vendored.iterdir() if p.is_dir()}
+        {p.name for p in vendored.iterdir() if p.is_dir() and _has_source(p)}
         if vendored.exists()
         else set()
     )
@@ -227,6 +265,13 @@ def verify(
             f"(add a '!vendored/**' negation, keep it last)"
         )
 
+    for rel in tracked_bytecode_under_vendored(project_dir):
+        problems.append(
+            f"{rel}: python bytecode under vendored/ is tracked by git — it is not "
+            f"part of the pin (git rm --cached it; ignore '**/__pycache__/' after "
+            f"the '!vendored/**' negation)"
+        )
+
     if not allow_hybrid:
         for name in hybrid_submodule_addons(project_dir):
             problems.append(

odoo_dev-1.5.0/tests/test_drop_filestore.py

@@ -0,0 +1,49 @@
+"""Tests for filestore cleanup on the dropdb fallback path."""
+
+from pathlib import Path
+
+import pytest
+
+from odoo_dev.commands.run import _drop_filestore
+from odoo_dev.config import ProjectConfig
+
+
+@pytest.fixture
+def cfg(tmp_path: Path) -> ProjectConfig:
+    (tmp_path / "conf").mkdir()
+    return ProjectConfig(
+        project_dir=tmp_path,
+        script_dir=tmp_path / ".odoo-deploy",
+        odoo_version="19.0",
+        python_version="3.12",
+        project_name="proj",
+    )
+
+
+class TestDropFilestore:
+    """The dropdb fallback must clean up the filestore odoo-bin would have."""
+
+    def test_removes_filestore_for_dropped_db(self, cfg):
+        cfg.config_file.write_text(f"[options]\ndata_dir = {cfg.data_dir}\n")
+        filestore = cfg.data_dir / "filestore" / "test_123"
+        filestore.mkdir(parents=True)
+        (filestore / "blob").write_text("x")
+
+        _drop_filestore(cfg, "test_123")
+
+        assert not filestore.exists()
+
+    def test_leaves_other_filestores_alone(self, cfg):
+        cfg.config_file.write_text(f"[options]\ndata_dir = {cfg.data_dir}\n")
+        keep = cfg.data_dir / "filestore" / "other_db"
+        keep.mkdir(parents=True)
+
+        _drop_filestore(cfg, "test_123")
+
+        assert keep.exists()
+
+    def test_missing_filestore_is_not_an_error(self, cfg):
+        cfg.config_file.write_text(f"[options]\ndata_dir = {cfg.data_dir}\n")
+
+        _drop_filestore(cfg, "test_123")
+

{odoo_dev-1.4.0 → odoo_dev-1.5.0}/tests/test_integration.py

@@ -90,12 +90,21 @@ def cleanup_fixture_env():
         "conf",
         ".vscode",
         ".odoo-deploy",
+        ".odoo-data",
     ]
     for dirname in created_dirs:
         dir_path = FIXTURE_DIR / dirname
         if dir_path.exists():
             shutil.rmtree(dir_path, ignore_errors=True)
 
+    # setup adds .odoo-data/ to the project's .gitignore; the fixture is a
+    # tracked submodule, so restore it rather than leaving the tree dirty.
+    subprocess.run(
+        ["git", "checkout", "--", ".gitignore"],
+        cwd=FIXTURE_DIR,
+        capture_output=True,
+    )
+
 
 @pytest.fixture(scope="session")
 def setup_fixture_env():

{odoo_dev-1.4.0 → odoo_dev-1.5.0}/tests/test_setup.py

@@ -179,7 +179,14 @@ class TestLocalOdooConf:
         cfg = _make_cfg(tmp_path)
         (tmp_path / "conf").mkdir()
         _setup_odoo_config(cfg)
-        assert "vendored" not in cfg.config_file.read_text()
+        # Scoped to addons_path: data_dir also embeds project_dir, whose tmp
+        # path can itself contain "vendored".
+        addons_path = next(
+            line
+            for line in cfg.config_file.read_text().splitlines()
+            if line.startswith("addons_path")
+        )
+        assert "vendored" not in addons_path
 
     def test_local_conf_includes_vendored_when_present(self, tmp_path: Path):
         from odoo_dev.commands.setup import _setup_odoo_config

odoo_dev-1.5.0/tests/test_setup_data_dir.py

@@ -0,0 +1,179 @@
+"""Tests for the project-local data_dir and manifest dependency install."""
+
+from pathlib import Path
+from unittest.mock import patch
+
+import pytest
+
+from odoo_dev.commands.setup import (
+    _ensure_data_dir_configured,
+    _gitignore_data_dir,
+    _install_manifest_python_deps,
+    _manifest_test_deps,
+    _setup_odoo_config,
+)
+from odoo_dev.config import DEFAULT_ODOO_DATA_DIR, ProjectConfig, read_data_dir
+
+
+@pytest.fixture
+def cfg(tmp_path: Path) -> ProjectConfig:
+    (tmp_path / "conf").mkdir()
+    return ProjectConfig(
+        project_dir=tmp_path,
+        script_dir=tmp_path / ".odoo-deploy",
+        odoo_version="19.0",
+        python_version="3.12",
+        project_name="proj",
+    )
+
+
+def _write_manifest(addons_dir: Path, name: str, body: str) -> None:
+    mod = addons_dir / name
+    mod.mkdir(parents=True)
+    (mod / "__manifest__.py").write_text(body)
+
+
+class TestDataDirConfig:
+    def test_generated_config_sets_project_local_data_dir(self, cfg):
+        _setup_odoo_config(cfg)
+
+        content = cfg.config_file.read_text()
+        assert f"data_dir = {cfg.project_dir / '.odoo-data'}" in content
+
+    def test_generated_config_gitignores_data_dir(self, cfg):
+        _setup_odoo_config(cfg)
+
+        assert ".odoo-data/" in (cfg.project_dir / ".gitignore").read_text()
+
+    def test_existing_config_gains_data_dir(self, cfg):
+        cfg.config_file.write_text("[options]\nadmin_passwd = admin\n")
+
+        _setup_odoo_config(cfg)
+
+        lines = cfg.config_file.read_text().splitlines()
+        assert lines[0] == "[options]"
+        assert lines[1] == f"data_dir = {cfg.data_dir}"
+        assert "admin_passwd = admin" in lines
+
+    def test_existing_data_dir_is_not_overwritten(self, cfg):
+        cfg.config_file.write_text("[options]\ndata_dir = /srv/odoo-data\n")
+
+        _ensure_data_dir_configured(cfg, cfg.config_file)
+
+        assert "/srv/odoo-data" in cfg.config_file.read_text()
+        assert str(cfg.data_dir) not in cfg.config_file.read_text()
+
+    def test_gitignore_entry_is_not_duplicated(self, cfg):
+        (cfg.project_dir / ".gitignore").write_text(".odoo-data/\n.venv/\n")
+
+        _gitignore_data_dir(cfg)
+
+        content = (cfg.project_dir / ".gitignore").read_text()
+        assert content.count(".odoo-data/") == 1
+
+
+class TestReadDataDir:
+    def test_reads_configured_value(self, tmp_path: Path):
+        conf = tmp_path / "odoo.conf"
+        conf.write_text("[options]\ndata_dir = /srv/odoo-data\n")
+
+        assert read_data_dir(conf) == Path("/srv/odoo-data")
+
+    def test_falls_back_to_odoo_default(self, tmp_path: Path):
+        conf = tmp_path / "odoo.conf"
+        conf.write_text("[options]\nadmin_passwd = admin\n")
+
+        assert read_data_dir(conf) == DEFAULT_ODOO_DATA_DIR
+
+    def test_missing_file_falls_back_to_odoo_default(self, tmp_path: Path):
+        assert read_data_dir(tmp_path / "nope.conf") == DEFAULT_ODOO_DATA_DIR
+
+
+class TestManifestTestDeps:
+    def test_collects_test_external_dependencies(self, tmp_path: Path):
+        _write_manifest(
+            tmp_path,
+            "mod_a",
+            "{'name': 'A', 'test_external_dependencies': {'python': ['pdfminer.six']}}",
+        )
+
+        assert _manifest_test_deps(tmp_path) == {"pdfminer.six"}
+
+    def test_ignores_runtime_dependencies(self, tmp_path: Path):
+        _write_manifest(
+            tmp_path,
+            "mod_a",
+            "{'name': 'A', 'external_dependencies': {'python': ['openpyxl']}}",
+        )
+
+        assert _manifest_test_deps(tmp_path) == set()
+
+    def test_skips_unparseable_manifest(self, tmp_path: Path):
+        _write_manifest(tmp_path, "mod_a", "{'name': 'A', 'x': undefined_name}")
+        _write_manifest(
+            tmp_path,
+            "mod_b",
+            "{'name': 'B', 'test_external_dependencies': {'python': ['freezegun']}}",
+        )
+
+        assert _manifest_test_deps(tmp_path) == {"freezegun"}
+
+    def test_missing_dir_is_empty(self, tmp_path: Path):
+        assert _manifest_test_deps(tmp_path / "nope") == set()
+
+
+class TestInstallManifestPythonDeps:
+    def test_installs_runtime_and_test_deps_from_both_dirs(self, cfg):
+        _write_manifest(
+            cfg.addons_dir,
+            "mod_a",
+            "{'name': 'A', 'test_external_dependencies': {'python': ['freezegun']}}",
+        )
+        _write_manifest(
+            cfg.vendored_dir,
+            "mod_b",
+            "{'name': 'B', 'test_external_dependencies': {'python': ['pdfminer.six']}}",
+        )
+
+        with patch("odoo_dev.commands.setup._manifest_runtime_deps") as runtime:
+            runtime.side_effect = [{"openpyxl"}, {"xlsxwriter"}]
+            with patch("odoo_dev.commands.setup.subprocess.run") as run:
+                run.return_value.returncode = 0
+                _install_manifest_python_deps(cfg, ["uv", "pip", "install"])
+
+        installed = set(run.call_args[0][0][3:])
+        assert installed == {"openpyxl", "xlsxwriter", "freezegun", "pdfminer.six"}
+
+    def test_no_deps_installs_nothing(self, cfg):
+        cfg.addons_dir.mkdir()
+
+        with patch("odoo_dev.commands.setup._manifest_runtime_deps", return_value=set()):
+            with patch("odoo_dev.commands.setup.subprocess.run") as run:
+                _install_manifest_python_deps(cfg, ["uv", "pip", "install"])
+
+        run.assert_not_called()
+
+
+class TestAdminPasswd:
+    """admin_passwd follows the same .env pattern as the DB settings."""
+
+    def test_local_conf_defaults_to_admin(self, cfg, monkeypatch):
+        monkeypatch.delenv("ADMIN_PASSWD", raising=False)
+
+        _setup_odoo_config(cfg)
+
+        assert "admin_passwd = admin\n" in cfg.config_file.read_text()
+
+    def test_local_conf_honours_env(self, cfg, monkeypatch):
+        monkeypatch.setenv("ADMIN_PASSWD", "s3cret")
+
+        _setup_odoo_config(cfg)
+
+        assert "admin_passwd = s3cret\n" in cfg.config_file.read_text()
+
+    def test_docker_conf_honours_env(self, monkeypatch):
+        from odoo_dev.commands.setup import _generate_docker_odoo_conf
+
+        monkeypatch.setenv("ADMIN_PASSWD", "s3cret")
+
+        assert "admin_passwd = s3cret\n" in _generate_docker_odoo_conf()

{odoo_dev-1.4.0 → odoo_dev-1.5.0}/tests/test_vendor_verify.py

@@ -243,3 +243,63 @@ def test_verify_strict_ignores_non_repos_symlink(tmp_path):
     (proj / "addons").mkdir(exist_ok=True)
     (proj / "addons" / "external").symlink_to(Path("../elsewhere"))
     assert verify(proj, lock, cache_dir=tmp_path / "cache", allow_hybrid=False) == []
+
+
+# --- python bytecode left behind by running/testing vendored addons -----------
+
+
+def _compile_in_place(proj: Path) -> list:
+    """Simulate ``odoo-dev test``: drop bytecode beside the vendored sources.
+
+    Includes the two shapes that outlive a pin bump: a subdir whose sources are
+    gone but whose ``__pycache__`` remains, and a whole ex-addon left as nothing
+    but bytecode (git does not track the empty dirs, so CI never sees either).
+    """
+    pycs = [
+        "vendored/shared_addon/__pycache__/models.cpython-312.pyc",
+        "vendored/shared_addon/tests/__pycache__/test_x.cpython-312.pyc",
+        "vendored/removed_addon/__pycache__/__init__.cpython-312.pyc",
+    ]
+    for rel in pycs:
+        p = proj / rel
+        p.parent.mkdir(parents=True, exist_ok=True)
+        p.write_bytes(b"\x00compiled")
+    return pycs
+
+
+def test_verify_green_with_untracked_bytecode_outside_git(tmp_path):
+    proj, lock = _sync_clean(tmp_path)
+    _compile_in_place(proj)
+    assert verify(proj, lock, cache_dir=tmp_path / "cache") == []
+
+
+def test_verify_green_with_gitignored_bytecode(tmp_path):
+    """Regression: ignoring ``__pycache__`` after ``!vendored/**`` is correct
+    hygiene, but the gitignore probe reported every local .pyc as a file git
+    would drop, failing the gate after any local test run.
+    """
+    repo, sha = _source_repo(tmp_path)
+    proj, lock = _git_project(
+        tmp_path,
+        LockEntry("shared_addon", str(repo), sha),
+        "!vendored/**\n**/__pycache__/\n",
+    )
+    sync_addons(proj, lock, cache_dir=tmp_path / "cache")
+    _compile_in_place(proj)
+    assert verify(proj, lock, cache_dir=tmp_path / "cache") == []
+
+
+def test_verify_red_when_bytecode_is_tracked(tmp_path):
+    """Bytecode committed under vendored/ is not in the pin; it must fail."""
+    repo, sha = _source_repo(tmp_path)
+    proj, lock = _git_project(
+        tmp_path,
+        LockEntry("shared_addon", str(repo), sha),
+        "!vendored/**\n**/__pycache__/\n",
+    )
+    sync_addons(proj, lock, cache_dir=tmp_path / "cache")
+    pycs = _compile_in_place(proj)
+    _git(proj, "add", "-f", pycs[0])
+    problems = verify(proj, lock, cache_dir=tmp_path / "cache")
+    assert len(problems) == 1
+    assert pycs[0] in problems[0] and "tracked" in problems[0]

{odoo_dev-1.4.0 → odoo_dev-1.5.0}/uv.lock

@@ -96,7 +96,7 @@ wheels = [
 
 [[package]]
 name = "odoo-dev"
-version = "1.2.3"
+version = "1.4.0"
 source = { editable = "." }
 dependencies = [
     { name = "pyyaml" },

odoo_dev-1.4.0/.release-please-manifest.json

@@ -1,3 +0,0 @@
-{
-  ".": "1.4.0"
-}

odoo_dev-1.4.0/src/odoo_dev/__init__.py

@@ -1,3 +0,0 @@
-"""Odoo Development Environment Helper."""
-
-__version__ = "1.4.0"  # x-release-please-version