youca-setup 0.1.0__py3-none-any.whl

youca_setup/__about__.py

@@ -0,0 +1,9 @@
+"""Metadata about the Youca Setup distribution."""
+
+__version__ = "0.1.0"
+__title__ = "youca-setup"
+__summary__ = (
+    "Youca Setup for Odoo - CLI tool to create, configure and manage Odoo development environments."
+)
+__license__ = "MIT"
+__uri__ = "https://github.com/Fitiafenohaja/youca-setup"

youca_setup/__init__.py

@@ -0,0 +1,16 @@
+"""Youca Setup for Odoo - CLI tool to create, configure and manage Odoo development environments.
+
+Youca Setup orchestrates existing tools (Docker, PostgreSQL, Git) to bootstrap and
+maintain an Odoo development environment with a minimal set of commands:
+
+    youca-setup init my-project
+    youca-setup start
+    youca-setup stop
+    youca-setup doctor
+"""
+
+from __future__ import annotations
+
+from youca_setup.__about__ import __version__
+
+__all__ = ["__version__"]

youca_setup/cli.py

@@ -0,0 +1,143 @@
+"""Main CLI entry point for Youca Setup.
+
+Builds the Typer application, registers every subcommand from the
+:mod:`youca_setup.commands` package and wires the Rich error rendering.
+"""
+
+from __future__ import annotations
+
+from typing import Annotated
+
+import rich
+import typer
+from rich.console import Console
+from rich.traceback import Traceback
+
+from youca_setup.__about__ import __title__, __version__
+
+APP_NAME = __title__
+APP_VERSION = __version__
+
+_VERBOSE = False
+
+app = typer.Typer(
+    name=APP_NAME,
+    help="Youca Setup for Odoo — create, configure and manage Odoo development environments.",
+    no_args_is_help=True,
+    pretty_exceptions_show_locals=False,
+    pretty_exceptions_short=True,
+    add_completion=True,
+)
+
+console = Console(stderr=True)
+
+
+def _version_callback(value: bool) -> None:
+    """Print the current version and exit when ``--version`` is given."""
+    if value:
+        console.print(f"{APP_NAME} version {APP_VERSION}")
+        raise typer.Exit()
+
+
+@app.callback()
+def main(
+    ctx: typer.Context,
+    verbose: Annotated[
+        bool,
+        typer.Option(
+            "--verbose", "-v", help="Enable verbose mode: print full tracebacks on errors."
+        ),
+    ] = False,
+    version: Annotated[
+        bool,
+        typer.Option(
+            "--version",
+            help="Show the version and exit.",
+            callback=_version_callback,
+            is_eager=True,
+        ),
+    ] = False,
+) -> None:
+    """CLI entry point.
+
+    Args:
+        ctx: Typer context shared across subcommands.
+        verbose: Whether to display full tracebacks on errors.
+        version: Whether the ``--version`` flag was passed.
+    """
+    ctx.obj = {"verbose": verbose}
+    global _VERBOSE
+    _VERBOSE = verbose
+
+
+def run() -> None:
+    """Run the CLI and render any uncaught error with Rich.
+
+    In debug mode (``--verbose``) the full traceback is shown; otherwise a
+    concise, actionable error message is printed.
+    """
+    try:
+        app()
+    except typer.Exit:
+        raise
+    except KeyboardInterrupt:
+        console.print("\n[bold yellow]Aborted by user.[/]")
+        raise typer.Exit(130) from None
+    except Exception as exc:  # noqa: BLE001 - top-level safety net.
+        if _VERBOSE:
+            console.print(Traceback(show_locals=False, suppress=[typer, rich]))
+        else:
+            console.print(f"[bold red]Error:[/] {exc}")
+            console.print("Re-run with [bold]--verbose[/] for a full traceback.")
+        raise typer.Exit(1) from exc
+
+
+def _register_commands() -> None:
+    """Register every subcommand on the CLI.
+
+    Single-command modules register their function directly as a top-level
+    command (``youca-setup start``, ``youca-setup info``, ...). The ``module`` group is
+    the only one with real subcommands and stays nested
+    (``youca-setup module create ...``).
+    """
+    from youca_setup.commands import (
+        backup,
+        doctor,
+        export,
+        import_cmd,
+        info,
+        init,
+        logs,
+        module,
+        projects,
+        remove,
+        restart,
+        restore,
+        shell,
+        start,
+        status,
+        stop,
+    )
+
+    app.command(name="init")(init.init)
+    app.command(name="start")(start.start)
+    app.command(name="stop")(stop.stop)
+    app.command(name="restart")(restart.restart)
+    app.command(name="status")(status.status)
+    app.command(name="logs")(logs.logs)
+    app.command(name="info")(info.info)
+    app.command(name="projects")(projects.projects)
+    app.command(name="remove")(remove.remove)
+    app.command(name="doctor")(doctor.doctor)
+    app.add_typer(module.app, name="module")
+    app.command(name="backup")(backup.backup)
+    app.command(name="restore")(restore.restore)
+    app.command(name="shell")(shell.shell)
+    app.command(name="export")(export.export)
+    app.command(name="import")(import_cmd.import_env)
+
+
+_register_commands()
+
+if __name__ == "__main__":
+    run()

youca_setup/commands/__init__.py

@@ -0,0 +1,21 @@
+"""Youca Setup CLI subcommands.
+
+Each subcommand lives in its own module and exposes a ``typer.Typer``
+instance named ``app``. The main application in :mod:`youca_setup.cli` registers
+them all at import time.
+"""
+
+from __future__ import annotations
+
+__all__ = [
+    "init",
+    "start",
+    "stop",
+    "restart",
+    "status",
+    "logs",
+    "doctor",
+    "module",
+    "backup",
+    "restore",
+]

youca_setup/commands/_port_utils.py

@@ -0,0 +1,48 @@
+"""Shared helpers for the lifecycle commands."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import typer
+from rich.console import Console
+from rich.prompt import Confirm
+
+from youca_setup.docker.compose import ComposeProject
+from youca_setup.project.config import ProjectConfig
+from youca_setup.utils.ports import find_free_port, is_port_free
+
+console = Console()
+
+
+def resolve_port_conflict(config: ProjectConfig, compose_file: Path) -> int | None:
+    """Check the HTTP port and, if occupied, switch to a free one.
+
+    Args:
+        config: Project configuration.
+        compose_file: Location of the Compose file.
+
+    Returns:
+        The resolved HTTP port, or ``None`` when nothing could be checked.
+
+    Raises:
+        typer.Exit: If the user declines the proposed alternative.
+    """
+    compose = ComposeProject(config, compose_file)
+    try:
+        port = compose.http_port()
+    except (FileNotFoundError, ValueError):
+        return None
+    if is_port_free(port):
+        return port
+    alternative = find_free_port(port)
+    accepted = Confirm.ask(
+        f"Port {port} is occupied. Use {alternative} instead?",
+        default=True,
+    )
+    if not accepted:
+        console.print("[bold red]Aborting: no free HTTP port chosen.[/]")
+        raise typer.Exit(code=1)
+    compose.set_http_port(alternative)
+    console.print(f"[yellow]Updated docker-compose.yml to use port {alternative}.[/]")
+    return alternative

youca_setup/commands/_state.py

@@ -0,0 +1,33 @@
+"""Shared helpers for the ``info`` and ``projects`` commands."""
+
+from __future__ import annotations
+
+from youca_setup.docker.manager import DockerManager
+from youca_setup.project.config import ProjectConfig
+
+
+def project_state(config: ProjectConfig) -> str:
+    """Return a human-readable state of the project's services.
+
+    Args:
+        config: Project configuration.
+
+    Returns:
+        ``"running"`` when both services are up, ``"partial"`` when only one
+        is, ``"stopped"`` when none exist, ``"unknown"`` when Docker is
+        unreachable, or ``"system"`` for non-Docker projects.
+    """
+    if not config.docker:
+        return "system"
+    manager = DockerManager(config)
+    try:
+        db = manager.container_status(f"{config.name}-db-1")
+        odoo = manager.container_status(f"{config.name}-odoo-1")
+    except RuntimeError:
+        return "unknown"
+    statuses = [status for status in (db, odoo) if status is not None]
+    if len(statuses) == 2 and all(status == "running" for status in statuses):
+        return "running"
+    if statuses:
+        return "partial"
+    return "stopped"

youca_setup/commands/backup.py

@@ -0,0 +1,47 @@
+"""The ``backup`` command - backup database, filestore and configuration."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Annotated
+
+import typer
+from rich.console import Console
+
+from youca_setup.project.backup import BackupManager
+from youca_setup.project.loader import load_project
+
+app = typer.Typer(help="Backup the Odoo project (database + filestore + config).")
+console = Console()
+
+
+@app.command()
+def backup(
+    database: Annotated[
+        str | None,
+        typer.Option("--database", "-d", help="Database name. Defaults to the project name."),
+    ] = None,
+    output_dir: Annotated[
+        str, typer.Option("--output", "-o", help="Directory where the archive is written.")
+    ] = "backups",
+) -> None:
+    """Create a timestamped archive of the current project.
+
+    The archive contains the database dump (custom format), the filestore
+    volume, ``config/`` and ``youca-setup.yaml``.
+
+    Args:
+        database: Database to dump.
+        output_dir: Destination directory for the archive.
+    """
+    config = load_project()
+    manager = BackupManager(config)
+    try:
+        path = manager.create_backup(
+            database=database,
+            output_dir=Path(output_dir),
+        )
+    except (FileNotFoundError, RuntimeError) as exc:
+        console.print(f"[bold red]Backup failed:[/] {exc}")
+        raise typer.Exit(code=1) from None
+    console.print(f"[green]Backup created:[/] {path}")

youca_setup/commands/doctor.py

@@ -0,0 +1,82 @@
+"""The ``doctor`` command - diagnose the development environment.
+
+Runs :mod:`youca_setup.diagnostics.checks` and, when asked, applies fixes from
+:mod:`youca_setup.diagnostics.fixer`.
+"""
+
+from __future__ import annotations
+
+from typing import Annotated
+
+import typer
+from rich.console import Console
+from rich.table import Table
+
+from youca_setup.diagnostics.checks import run_checks
+from youca_setup.diagnostics.fixer import Fixer, propose_fixes
+from youca_setup.project.config import ProjectConfig
+from youca_setup.project.loader import load_project
+
+app = typer.Typer(help="Check the environment for common issues.")
+console = Console()
+
+
+def _render(results: list[tuple[str, bool, str]]) -> None:
+    """Render check results as a Rich table.
+
+    Args:
+        results: ``(name, passed, message)`` rows.
+    """
+    table = Table(show_header=True, header_style="bold")
+    table.add_column("Check")
+    table.add_column("Status")
+    table.add_column("Detail")
+    for name, passed, message in results:
+        status = "[green]OK[/]" if passed else "[bold red]FAIL[/]"
+        table.add_row(name, status, message)
+    console.print(table)
+
+
+@app.command()
+def doctor(
+    fix: Annotated[
+        bool,
+        typer.Option(
+            "--fix",
+            "-f",
+            help="Attempt to fix detected issues (destructive actions ask for confirmation).",
+        ),
+    ] = False,
+    check: Annotated[
+        str | None,
+        typer.Option(
+            "--check", help="Run only the given check (e.g. 'docker', 'postgres', 'ports')."
+        ),
+    ] = None,
+) -> None:
+    """Diagnose Python, Docker, PostgreSQL, ports and project configuration.
+
+    Args:
+        fix: Whether issues should be auto-fixed where possible.
+        check: Restrict the run to a single named check.
+    """
+    try:
+        config: ProjectConfig | None = load_project()
+    except FileNotFoundError:
+        config = None
+
+    results = run_checks(config)
+    if check is not None:
+        results = [result for result in results if result.name == check]
+
+    _render([(result.name, result.passed, result.message) for result in results])
+
+    if not fix:
+        return
+
+    fixes = propose_fixes(config, results)
+    if not fixes:
+        console.print("[green]Nothing to fix.[/]")
+        return
+    Fixer().run(fixes)
+    console.print("[green]Done. Re-run 'youca-setup doctor' to confirm.[/]")

youca_setup/commands/export.py

@@ -0,0 +1,43 @@
+"""The ``export`` command - export the project environment as a portable archive.
+
+Creates a self-contained ``.tar.gz`` with the configuration files and addons,
+omitting the database dump, filestore and backups.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Annotated
+
+import typer
+from rich.console import Console
+from rich.panel import Panel
+
+from youca_setup.project.loader import load_project
+from youca_setup.project.transport import export_environment
+
+app = typer.Typer(help="Export the current project environment.")
+console = Console()
+
+
+@app.command()
+def export(
+    output: Annotated[
+        Path | None,
+        typer.Option("--output", "-o", help="Output archive path."),
+    ] = None,
+) -> None:
+    """Export the current project environment to a portable ``.tar.gz`` file.
+
+    Args:
+        output: Destination path for the archive; defaults to ``<name>.tar.gz``
+            in the current directory.
+    """
+    config = load_project()
+    archive = output or Path.cwd() / f"{config.name}-env.tar.gz"
+    try:
+        path = export_environment(config, archive)
+    except FileNotFoundError as exc:
+        console.print(f"[bold red]Error:[/] {exc}")
+        raise typer.Exit(1) from exc
+    console.print(Panel(f"[bold green]Environment exported to {path}.[/]"))

youca_setup/commands/import_cmd.py

@@ -0,0 +1,61 @@
+"""The ``import`` command - import a portable environment archive.
+
+Extracts the archive into a new project directory, registers the project and
+prints the next steps.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Annotated
+
+import typer
+from rich.console import Console
+from rich.panel import Panel
+
+from youca_setup.project import registry
+from youca_setup.project.transport import import_environment
+
+app = typer.Typer(help="Import a Youca Setup environment archive.")
+console = Console()
+
+
+@app.command(name="import")
+def import_env(
+    archive: Annotated[Path, typer.Argument(help="Path to the ``.tar.gz`` environment archive.")],
+    directory: Annotated[
+        Path | None,
+        typer.Option("--directory", "-d", help="Parent directory for the new project."),
+    ] = None,
+    yes: Annotated[bool, typer.Option("--yes", "-y", help="Skip confirmation prompts.")] = False,
+) -> None:
+    """Import a Youca Setup environment archive into a new project directory.
+
+    Args:
+        archive: Path to the ``.tar.gz`` archive.
+        directory: Parent directory for the project; defaults to cwd.
+        yes: Skip the confirmation prompt.
+    """
+    target_base = directory or Path.cwd()
+
+    try:
+        project_dir, config = import_environment(archive, target_base)
+    except FileNotFoundError as exc:
+        console.print(f"[bold red]Error:[/] {exc}")
+        raise typer.Exit(1) from exc
+    except FileExistsError as exc:
+        console.print(f"[bold red]Error:[/] {exc}")
+        raise typer.Exit(1) from exc
+    except ValueError as exc:
+        console.print(f"[bold red]Error:[/] {exc}")
+        raise typer.Exit(1) from exc
+
+    try:
+        registry.register(config, project_dir)
+    except OSError as exc:
+        console.print(f"[yellow]Could not register the project: {exc}[/]")
+
+    console.print(Panel(f"[bold green]Project '{config.name}' imported into {project_dir}.[/]"))
+    console.print("Next steps:\n")
+    console.print(f"  [bold]cd {project_dir}[/]")
+    console.print("  [bold]youca-setup start[/]")

youca_setup/commands/info.py

@@ -0,0 +1,42 @@
+"""The ``info`` command - show details of the current project."""
+
+from __future__ import annotations
+
+import typer
+from rich.console import Console
+from rich.table import Table
+
+from youca_setup.commands._state import project_state
+from youca_setup.project.loader import load_project
+
+app = typer.Typer(help="Show details of the current project.")
+console = Console()
+
+
+@app.command("info")
+def info() -> None:
+    """Print the configuration and state of the current project.
+
+    Raises:
+        FileNotFoundError: When run outside a Youca Setup project.
+    """
+    config = load_project()
+
+    table = Table(title=f"Youca Setup for Odoo — {config.name}", show_header=False)
+    table.add_column("Setting", style="cyan")
+    table.add_column("Value")
+
+    rows = [
+        ("Project name", config.name),
+        ("Odoo version", config.odoo_version),
+        ("PostgreSQL version", config.postgres_version),
+        ("PostgreSQL backend", config.postgres_backend),
+        ("Docker Compose", "yes" if config.docker else "no"),
+        ("HTTP port", str(config.http_port)),
+        ("Addons", ", ".join(config.addons) or "—"),
+        ("State", project_state(config)),
+    ]
+    for setting, value in rows:
+        table.add_row(setting, value)
+
+    console.print(table)