odoo-dev 0.1.0__py3-none-any.whl

odoo_dev/commands/setup.py

@@ -0,0 +1,364 @@
+"""Setup commands for initializing Odoo development environment."""
+
+import subprocess
+from pathlib import Path
+from typing import Annotated
+
+import typer
+
+from odoo_dev.config import load_config
+from odoo_dev.utils.console import error, success, warning
+
+
+def setup(
+    community: bool = typer.Option(
+        False, "--community", help="Set up Community edition only (skip Enterprise repos)"
+    ),
+) -> None:
+    """Complete setup: clone Odoo repos, configure VSCode, build image."""
+    cfg = load_config()
+
+    success("Setting up complete Odoo development environment...")
+
+    # Initialize/update git submodules first
+    _init_submodules(cfg)
+
+    # Clone/update Odoo repositories
+    if community:
+        warning("Setting up Community Edition")
+    _clone_odoo_repos(cfg, community_only=community)
+
+    # Set up VSCode configuration
+    success("\nSetting up VSCode configuration...")
+    vscode(cfg)
+
+    # Set up local virtual environment
+    success("\nSetting up local Python virtual environment...")
+    warning(f"This will install system dependencies and Python {cfg.python_version} if needed")
+    setup_venv()
+
+    # Prompt for Docker setup
+    warning("\nDo you want to set up the Docker environment?")
+    if typer.confirm("Continue with Docker setup?", default=True):
+        success("\nBuilding Docker image...")
+        from odoo_dev.commands.docker import build
+        build(community=community)
+    else:
+        warning("Skipping Docker setup. Run 'odoo-dev build' later.")
+
+    success("\nSetup complete! You can now:")
+    success("  - Start Odoo with Docker: odoo-dev start")
+    success("  - Use local Python environment: source .venv/bin/activate")
+    success("  - Debug with VSCode: Use the configured launch profiles")
+
+
+def setup_venv() -> None:
+    """Set up local Python virtual environment for development."""
+    cfg = load_config()
+
+    # Create config file first
+    _setup_odoo_config(cfg)
+
+    success(f"Setting up Python virtual environment for Odoo {cfg.odoo_version}...")
+
+    # Install system dependencies
+    _install_system_dependencies()
+
+    # Ensure uv is available
+    if subprocess.run(["which", "uv"], capture_output=True).returncode != 0:
+        success("Installing uv package manager...")
+        subprocess.run(
+            ["curl", "-LsSf", "https://astral.sh/uv/install.sh"],
+            stdout=subprocess.PIPE,
+        )
+        # Would pipe to sh, but let's be explicit
+        warning("Please install uv manually: curl -LsSf https://astral.sh/uv/install.sh | sh")
+
+    # Create virtual environment
+    if not cfg.venv_path.exists():
+        success("Creating new Python virtual environment...")
+        subprocess.run(
+            ["uv", "venv", str(cfg.venv_path), "--python", cfg.python_version],
+            check=True,
+        )
+    else:
+        warning("Virtual environment already exists. Skipping creation.")
+
+    # Update PYTHONPATH in activate script
+    _update_python_path(cfg)
+
+    # Install requirements
+    venv_pip = ["uv", "pip", "install", "--python", str(cfg.venv_path / "bin" / "python")]
+
+    # Install Odoo requirements
+    odoo_requirements = cfg.project_dir / "odoo" / "requirements.txt"
+    if odoo_requirements.exists():
+        success("Installing Odoo requirements...")
+        # Create temp requirements with psycopg2-binary substitution
+        temp_req = cfg.project_dir / "temp_requirements.txt"
+        content = odoo_requirements.read_text()
+        content = content.replace("psycopg2==", "psycopg2-binary>=")
+        temp_req.write_text(content)
+        subprocess.run([*venv_pip, "-r", str(temp_req)])
+        temp_req.unlink()
+
+    # Install project requirements
+    project_requirements = cfg.project_dir / "requirements.txt"
+    if project_requirements.exists():
+        success("Installing project requirements...")
+        subprocess.run([*venv_pip, "-r", str(project_requirements)])
+
+    # Install dev tools
+    success("Installing development tools...")
+    subprocess.run([*venv_pip, "pytest", "pytest-odoo", "debugpy", "manifestoo", "coverage"])
+
+    success("\nVirtual environment setup complete!")
+    success(f"To activate: source {cfg.venv_path}/bin/activate")
+
+
+def vscode(cfg=None) -> None:
+    """Set up VSCode configuration for debugging."""
+    if cfg is None:
+        cfg = load_config()
+
+    vscode_dir = cfg.project_dir / ".vscode"
+    vscode_dir.mkdir(exist_ok=True)
+
+    template_dir = cfg.script_dir / "templates" / "vscode"
+
+    # Copy template files
+    import shutil
+
+    for template_file in ["launch.json", "tasks.json"]:
+        src = template_dir / template_file
+        dst = vscode_dir / template_file
+        if src.exists():
+            shutil.copy(src, dst)
+            success(f"Copied {template_file}")
+
+    # Only copy settings.json if it doesn't exist
+    settings_src = template_dir / "settings.json"
+    settings_dst = vscode_dir / "settings.json"
+    if settings_src.exists() and not settings_dst.exists():
+        shutil.copy(settings_src, settings_dst)
+        success("Copied settings.json")
+    elif settings_dst.exists():
+        warning("settings.json already exists. Skipping.")
+
+    success("VSCode configuration set up successfully!")
+
+
+def _init_submodules(cfg) -> None:
+    """Initialize and update git submodules if present."""
+    gitmodules = cfg.project_dir / ".gitmodules"
+
+    if not gitmodules.exists():
+        return
+
+    success("Initializing git submodules...")
+
+    result = subprocess.run(
+        ["git", "submodule", "update", "--init", "--recursive"],
+        cwd=cfg.project_dir,
+        capture_output=True,
+        text=True,
+    )
+
+    if result.returncode == 0:
+        success("Git submodules initialized.")
+    else:
+        warning(f"Submodule initialization had issues: {result.stderr}")
+
+
+def _setup_odoo_config(cfg, community_only: bool = False) -> None:
+    """Create odoo.conf configuration file."""
+    conf_dir = cfg.project_dir / "conf"
+    conf_file = conf_dir / "odoo.conf"
+
+    # Create conf directory
+    conf_dir.mkdir(exist_ok=True)
+
+    if conf_file.exists():
+        warning(f"Config file already exists at {conf_file}")
+        return
+
+    success("Creating Odoo configuration file...")
+
+    # Build addons path
+    addons_paths = [
+        str(cfg.project_dir / "odoo" / "addons"),
+        str(cfg.project_dir / "odoo" / "odoo" / "addons"),
+    ]
+
+    if not community_only:
+        addons_paths.append(str(cfg.project_dir / "enterprise"))
+
+    addons_paths.extend([
+        str(cfg.project_dir / "design-themes"),
+        str(cfg.project_dir / "addons"),
+    ])
+
+    # Filter to only existing paths
+    addons_paths = [p for p in addons_paths if Path(p).exists()]
+
+    config_content = f"""[options]
+addons_path = {",".join(addons_paths)}
+admin_passwd = admin
+db_user = odoo
+db_password = odoo
+"""
+
+    conf_file.write_text(config_content)
+    conf_file.chmod(0o600)
+    success(f"Config file created at {conf_file}")
+
+
+def _clone_odoo_repos(cfg, community_only: bool = False) -> None:
+    """Clone or update Odoo repositories."""
+    success("Setting up Odoo repositories...")
+
+    if community_only:
+        warning("Community edition mode: Enterprise repositories will be skipped")
+
+    repos = [
+        (f"git@github.com:odoo/odoo.git", "odoo", cfg.odoo_version),
+        (f"git@github.com:odoo/design-themes.git", "design-themes", cfg.odoo_version),
+    ]
+
+    # Add enterprise if not community only
+    if not community_only:
+        repos.append(
+            (f"git@github.com:odoo/enterprise.git", "enterprise", cfg.odoo_version)
+        )
+
+    # Add industry for Odoo 18+
+    if cfg.odoo_version.startswith("18") or cfg.odoo_version.startswith("19"):
+        repos.append(
+            (f"git@github.com:odoo/industry.git", "industry", cfg.odoo_version)
+        )
+
+    for repo_url, repo_dir, branch in repos:
+        repo_path = cfg.project_dir / repo_dir
+
+        if repo_path.exists():
+            warning(f"Updating {repo_dir} repository...")
+            subprocess.run(
+                ["git", "fetch", "--depth", "1", "origin", branch],
+                cwd=repo_path,
+            )
+            subprocess.run(["git", "checkout", branch], cwd=repo_path)
+            subprocess.run(
+                ["git", "pull", "--ff-only", "origin", branch],
+                cwd=repo_path,
+            )
+        else:
+            warning(f"Cloning {repo_dir} repository...")
+            subprocess.run(
+                [
+                    "git",
+                    "clone",
+                    "--depth",
+                    "1",
+                    "--branch",
+                    branch,
+                    repo_url,
+                    str(repo_path),
+                ],
+                cwd=cfg.project_dir,
+            )
+
+    success("Odoo repositories setup complete.")
+
+
+def _install_system_dependencies() -> None:
+    """Install system dependencies based on OS."""
+    import platform
+
+    system = platform.system()
+
+    if system == "Darwin":
+        success("Installing dependencies for macOS...")
+        subprocess.run(
+            [
+                "brew",
+                "install",
+                "postgresql",
+                "libpq",
+                "openssl",
+                "libxml2",
+                "libxslt",
+            ],
+            check=False,
+        )
+    elif system == "Linux":
+        success("Installing dependencies for Linux...")
+        subprocess.run(
+            [
+                "sudo",
+                "apt-get",
+                "update",
+            ],
+            check=False,
+        )
+        subprocess.run(
+            [
+                "sudo",
+                "apt-get",
+                "install",
+                "-y",
+                "--no-install-recommends",
+                "build-essential",
+                "libldap2-dev",
+                "libpq-dev",
+                "libsasl2-dev",
+                "libssl-dev",
+                "libxml2-dev",
+                "libxslt1-dev",
+                "postgresql-client",
+            ],
+            check=False,
+        )
+    else:
+        warning(f"Unsupported OS: {system}. Please install dependencies manually.")
+
+
+def _update_python_path(cfg) -> None:
+    """Update PYTHONPATH in venv activate script."""
+    activate_script = cfg.venv_path / "bin" / "activate"
+
+    if not activate_script.exists():
+        return
+
+    content = activate_script.read_text()
+
+    # Check if already modified
+    if "# Odoo PYTHONPATH setup" in content:
+        return
+
+    pythonpath_setup = '''
+# Odoo PYTHONPATH setup
+if [ -z "$_OLD_VIRTUAL_PYTHONPATH" ]; then
+    _OLD_VIRTUAL_PYTHONPATH="$PYTHONPATH"
+fi
+
+ODOO_PYTHONPATH=""
+for dir in "odoo" "enterprise" "design-themes" "industry" "addons"; do
+    if [ -d "$VIRTUAL_ENV/../$dir" ]; then
+        if [ -z "$ODOO_PYTHONPATH" ]; then
+            ODOO_PYTHONPATH="$VIRTUAL_ENV/../$dir"
+        else
+            ODOO_PYTHONPATH="$ODOO_PYTHONPATH:$VIRTUAL_ENV/../$dir"
+        fi
+    fi
+done
+
+if [ -n "$ODOO_PYTHONPATH" ]; then
+    PYTHONPATH="$ODOO_PYTHONPATH${_OLD_VIRTUAL_PYTHONPATH:+:$_OLD_VIRTUAL_PYTHONPATH}"
+    export PYTHONPATH
+fi
+# End Odoo PYTHONPATH setup
+'''
+
+    content += pythonpath_setup
+    activate_script.write_text(content)
+    success("PYTHONPATH updated in virtual environment activation script.")

odoo_dev/config.py

@@ -0,0 +1,101 @@
+"""Configuration loading and project detection."""
+
+import os
+from dataclasses import dataclass
+from pathlib import Path
+
+
+@dataclass
+class ProjectConfig:
+    """Configuration for an Odoo development project."""
+
+    project_dir: Path
+    script_dir: Path
+    odoo_version: str
+    python_version: str
+    project_name: str
+
+    @property
+    def venv_path(self) -> Path:
+        """Path to the Python virtual environment."""
+        return self.project_dir / ".venv"
+
+    @property
+    def config_file(self) -> Path:
+        """Path to the local odoo.conf file."""
+        return self.project_dir / "conf" / "odoo.conf"
+
+    @property
+    def docker_config_file(self) -> Path:
+        """Path to the Docker odoo.conf file."""
+        return self.script_dir / "odoo.conf"
+
+    @property
+    def odoo_bin(self) -> Path:
+        """Path to the odoo-bin executable."""
+        return self.project_dir / "odoo" / "odoo-bin"
+
+    @property
+    def addons_dir(self) -> Path:
+        """Path to the project's custom addons directory."""
+        return self.project_dir / "addons"
+
+
+def find_project_root(start: Path | None = None) -> Path:
+    """Walk up directory tree to find git repository root.
+
+    Args:
+        start: Starting directory. Defaults to current working directory.
+
+    Returns:
+        Path to the git repository root, or current directory if not found.
+    """
+    current = start or Path.cwd()
+    while current != current.parent:
+        git_path = current / ".git"
+        # .git can be a directory (normal repo) or a file (submodule/worktree)
+        if git_path.is_dir() or git_path.is_file():
+            return current
+        current = current.parent
+    return Path.cwd()
+
+
+def load_dotenv(path: Path) -> None:
+    """Load environment variables from a .env file.
+
+    Args:
+        path: Path to the .env file.
+    """
+    if not path.exists():
+        return
+
+    for line in path.read_text().splitlines():
+        line = line.strip()
+        if line and not line.startswith("#") and "=" in line:
+            key, _, value = line.partition("=")
+            # Don't override existing environment variables
+            os.environ.setdefault(key.strip(), value.strip())
+
+
+def load_config(project_dir: Path | None = None) -> ProjectConfig:
+    """Load configuration from environment and .env file.
+
+    Args:
+        project_dir: Optional project directory override.
+
+    Returns:
+        ProjectConfig with all settings loaded.
+    """
+    if project_dir is None:
+        project_dir = find_project_root()
+
+    # Load .env if it exists
+    load_dotenv(project_dir / ".env")
+
+    return ProjectConfig(
+        project_dir=project_dir,
+        script_dir=project_dir / ".odoo-deploy",
+        odoo_version=os.getenv("ODOO_VERSION", "18.0"),
+        python_version=os.getenv("PYTHON_VERSION", "3.12"),
+        project_name=project_dir.name,
+    )

odoo_dev/utils/__init__.py

@@ -0,0 +1 @@
+"""Utility modules for odoo-dev."""

odoo_dev/utils/console.py

@@ -0,0 +1,25 @@
+"""Console output helpers with colored formatting."""
+
+from rich.console import Console
+
+console = Console()
+
+
+def success(msg: str) -> None:
+    """Print a success message in green."""
+    console.print(f"[green]{msg}[/green]")
+
+
+def warning(msg: str) -> None:
+    """Print a warning message in yellow."""
+    console.print(f"[yellow]{msg}[/yellow]")
+
+
+def error(msg: str) -> None:
+    """Print an error message in red."""
+    console.print(f"[red]{msg}[/red]")
+
+
+def info(msg: str) -> None:
+    """Print an info message."""
+    console.print(msg)

odoo_dev-0.1.0.dist-info/METADATA

@@ -0,0 +1,133 @@
+Metadata-Version: 2.4
+Name: odoo-dev
+Version: 0.1.0
+Summary: Odoo Development Environment Helper
+Requires-Python: >=3.12
+Requires-Dist: rich>=13.0.0
+Requires-Dist: typer>=0.9.0
+Description-Content-Type: text/markdown
+
+# odoo-dev
+
+A CLI tool for managing Odoo development environments. Handles local Python setup, Docker containers, database operations, and more.
+
+## Installation
+
+```bash
+# Install with uv (recommended)
+uv tool install odoo-dev
+
+# Or with pip
+pip install odoo-dev
+```
+
+## Quick Start
+
+```bash
+# In your Odoo project directory
+cd my-odoo-project
+
+# Full setup: clone Odoo repos, create venv, configure VSCode
+odoo-dev setup
+
+# Or for community edition only
+odoo-dev setup --community
+```
+
+## Commands
+
+### Local Development (default)
+
+```bash
+odoo-dev run                      # Start Odoo locally
+odoo-dev run -d mydb --dev reload # With hot reload
+odoo-dev run --debug              # With debugpy (VSCode attach)
+odoo-dev shell mydb               # Open Odoo shell
+odoo-dev update base -d mydb      # Update modules
+odoo-dev test my_module           # Run tests with coverage
+odoo-dev scaffold my_module       # Create new module
+```
+
+### Database Operations
+
+```bash
+odoo-dev db list                  # List databases
+odoo-dev db restore backup.zip    # Restore from backup
+odoo-dev db restore backup.zip mydb --no-neutralize
+odoo-dev db drop mydb             # Drop database
+odoo-dev db neutralize mydb       # Disable emails/crons
+```
+
+### Docker (optional)
+
+```bash
+odoo-dev docker start             # Start containers
+odoo-dev docker stop              # Stop containers
+odoo-dev docker logs              # View logs
+odoo-dev docker build             # Rebuild image
+odoo-dev docker shell mydb        # Shell in container
+odoo-dev docker psql              # PostgreSQL shell
+```
+
+### Setup Commands
+
+```bash
+odoo-dev setup                    # Full setup
+odoo-dev setup --community        # Community edition only
+odoo-dev setup-venv               # Just create venv
+odoo-dev vscode                   # Configure VSCode debugging
+```
+
+## Project Structure
+
+odoo-dev expects this project structure:
+
+```
+my-odoo-project/
+├── .env                 # Optional: ODOO_VERSION, PYTHON_VERSION
+├── addons/              # Your custom addons
+├── requirements.txt     # Project-specific Python deps
+├── odoo/                # Cloned by setup
+├── enterprise/          # Cloned by setup (unless --community)
+├── design-themes/       # Cloned by setup
+├── .venv/               # Created by setup
+└── conf/
+    └── odoo.conf        # Created by setup
+```
+
+## Configuration
+
+Create a `.env` file in your project root:
+
+```bash
+ODOO_VERSION=18.0
+PYTHON_VERSION=3.12
+```
+
+## Requirements
+
+- Python 3.12+
+- uv (recommended) or pip
+- Git
+- PostgreSQL (for local development)
+- Docker (optional, for containerized development)
+
+## Development
+
+```bash
+# Clone and install for development
+git clone git@git.bemade.org:bemade/odoo-dev.git
+cd odoo-dev
+uv sync
+
+# Run tests
+uv run pytest                 # All tests
+uv run pytest -m "not slow"   # Fast tests only
+
+# Build
+uv build
+```
+
+## License
+
+MIT

odoo_dev-0.1.0.dist-info/RECORD

@@ -0,0 +1,14 @@
+odoo_dev/__init__.py,sha256=k91qzqyJaW_n2LwmsJoDER8z90x2wcVNODzKACLUxKc,66
+odoo_dev/cli.py,sha256=SqY07yLgOGEUkrUvbBM9Sfon87nUUbM_wDk96n_pScg,714
+odoo_dev/config.py,sha256=LbWsJbcvIfE5fbxkZK_iItaYDhiB0t8mF6wQk2d8hpM,2865
+odoo_dev/commands/__init__.py,sha256=yOxitS1Oes2ZS95F0nXyw3LDOBXCFWmudZInYbTu1eQ,33
+odoo_dev/commands/db.py,sha256=7DnI28y2YpugnjoMkyTYymLMZ5MjNagfD6T15RWvZ0c,9605
+odoo_dev/commands/docker.py,sha256=I5dvxRX4uHzwBwTM7d7yhMphge8fdKoqjXCKo_-7FQw,5386
+odoo_dev/commands/run.py,sha256=FPi_rIyMOWadZfMPin0TXHbdBcW1YIuqUseBEhr4PnE,11882
+odoo_dev/commands/setup.py,sha256=M67rE1qWA2iYA3S15cZAt_-Za2iXWau1QAbt-nvOCQU,11260
+odoo_dev/utils/__init__.py,sha256=EDPdElYZN3cPJtZIkNjXFoItz1mPBPUsasQzb6mRrss,36
+odoo_dev/utils/console.py,sha256=bRbXVD15QiMhdU8Rp4cyaoA1-J8vFX8r16TwsYurUug,549
+odoo_dev-0.1.0.dist-info/METADATA,sha256=stKenzdej2YmQ_ubYOG2vsHzZdAGT6zhQu9re0gHkQE,3155
+odoo_dev-0.1.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+odoo_dev-0.1.0.dist-info/entry_points.txt,sha256=EKJCgGArQtoRNYRBRcbkRfIXO_APFkYujr2u8-UCfXo,46
+odoo_dev-0.1.0.dist-info/RECORD,,

odoo_dev-0.1.0.dist-info/WHEEL

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

odoo_dev-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+odoo-dev = odoo_dev.cli:app