gOdoo-cli 0.7.0__py3-none-any.whl

godoo_cli/__init__.py

@@ -0,0 +1,2 @@
+from .cli import launch_cli
+from .version import __version__

godoo_cli/__main__.py

@@ -0,0 +1,5 @@
+"""Main CLI"""
+from .cli import launch_cli
+
+if __name__ == "__main__":
+    launch_cli()

godoo_cli/cli.py

@@ -0,0 +1,87 @@
+"""Main CLI."""
+from typing import Optional
+
+import typer
+from dotenv import load_dotenv
+from rich import print as rich_print
+
+from .cli_common import CommonCLI
+from .commands import (
+    backup_cli_app,
+    bootstrap_odoo,
+    db_cli_app,
+    launch_import,
+    launch_odoo,
+    odoo_shell,
+    odoo_test,
+    rpc_cli_app,
+    set_odoo_config,
+    source_cli_app,
+    uninstall_modules,
+)
+from .helpers.odoo_files import odoo_bin_get_version
+from .helpers.system import set_logging
+from .version import __version__
+
+CLI = CommonCLI()
+
+
+def main_callback(
+    verbose: Optional[bool] = typer.Option(
+        False,
+        "--verbose",
+        "-v",
+        envvar="GODOO_VERBOSE",
+        help="Verbose Logging with Error stacktraces",
+    )
+):
+    set_logging(verbose=verbose)
+
+
+@CLI.arg_annotator
+def print_versions(
+    odoo_main_path=CLI.odoo_paths.bin_path,
+):
+    """
+    Print gOdoo and Odoo Version info.
+    """
+    rich_print(f"gOdoo Version: [bold green]{__version__}[/bold green]")
+    odoo_version = odoo_bin_get_version(odoo_main_path)
+    rich_print(f"Odoo Version: [bold green]{odoo_version}[/bold green]")
+
+
+def main_cli():
+    load_dotenv(".env", override=True)
+
+    help_text = "gOdoo CLI for Interacting with Odoo"
+    app = typer.Typer(no_args_is_help=True, callback=main_callback, rich_markup_mode="rich", help=help_text)
+    # Nested Subcommands
+    app.add_typer(
+        typer_instance=rpc_cli_app(),
+        name="rpc",
+    )
+    app.add_typer(
+        typer_instance=db_cli_app(),
+        name="db",
+    )
+    app.add_typer(
+        typer_instance=source_cli_app(),
+        name="source",
+    )
+    app.add_typer(typer_instance=backup_cli_app(), name="backup")
+
+    # Normal Subcommands
+    app.command("version")(print_versions)
+    app.command("bootstrap")(bootstrap_odoo)
+    app.command("launch")(launch_odoo)
+    app.command("launch-import")(launch_import)
+    app.command("test")(odoo_test)
+    app.command("config")(set_odoo_config)
+    app.command("shell")(odoo_shell)
+    app.command("uninstall")(uninstall_modules)
+    return app
+
+
+def launch_cli():
+    app = main_cli()
+    app()

godoo_cli/cli_common.py

@@ -0,0 +1,183 @@
+from dataclasses import dataclass
+from pathlib import Path
+from typing import List, Optional
+
+from typer import Option
+from typer_common_functions import get_type_from_default, typer_retuner, typer_unpacker
+
+
+@dataclass
+class OdooLaunchArgs:
+    extra_cmd_args: List[str] = Option(None, help="extra agruments to pass to odoo-bin", rich_help_panel="Odoo")
+    multithread_worker_count: int = Option(
+        -1, help="count of worker threads. will enable proxy_mode if >0. (Autodetect with -1)", rich_help_panel="Odoo"
+    )
+    languages: str = Option("de_DE,en_US", help="languages to load by default", rich_help_panel="Odoo")
+    no_install_base: bool = Option(
+        False,
+        "--no-install-base",
+        help="dont install [bold]base[/bold] and [bold]web[/bold] module",
+        rich_help_panel="Odoo",
+    )
+    no_install_workspace_modules: bool = Option(
+        False,
+        "--no-install-workspace-modules",
+        help="dont automatically install modules found in [bold cyan]--workspace_path[/bold cyan]",
+        rich_help_panel="Odoo",
+    )
+    no_update_source: bool = Option(
+        False, "--no-update-source", help="Update Odoo Source and Thirdparty Addons", rich_help_panel="Source Code"
+    )
+    no_addons_remove_unspecified: bool = Option(
+        False,
+        "--no-addons-remove-unspecified",
+        help="don't remove unspecified addons if not '[bold cyan]--no-update-source[/bold cyan]'",
+        rich_help_panel="Source Code",
+    )
+    odoo_demo: bool = Option(False, "--odoo-demo", help="Load Demo Data", rich_help_panel="Odoo")
+    dev_mode: bool = Option(
+        False,
+        "--dev-mode",
+        help="Passes '[bold cyan]--dev xml,qweb,reload[/bold cyan]' to odoo",
+        rich_help_panel="Odoo",
+    )
+    log_file_path: Path = Option(None, dir_okay=False, writable=True, help="Logfile Path", rich_help_panel="Odoo")
+
+
+@dataclass
+class OdooPathCLIArgs:
+    bin_path: Path = Option(
+        ...,
+        envvar="ODOO_MAIN_FOLDER",
+        help="folder that contains odoo-bin",
+        rich_help_panel="Path Options",
+    )
+
+    conf_path: Path = Option(
+        ...,
+        envvar="ODOO_CONF_PATH",
+        help="odoo.conf path",
+        rich_help_panel="Path Options",
+    )
+
+    workspace_addon_path: Path = Option(
+        ...,
+        envvar="ODOO_WORKSPACE_ADDON_LOCATION",
+        help="path to dev workspace addons",
+        rich_help_panel="Path Options",
+    )
+    thirdparty_addon_path: Path = Option(
+        ...,
+        envvar="ODOO_THIRDPARTY_LOCATION",
+        help="folder that contains thirdparty repos like OCA",
+        rich_help_panel="Path Options",
+    )
+
+
+@dataclass
+class RpcCLIArgs:
+    rpc_host: str = Option(
+        ...,
+        envvar="ODOO_RPC_HOST",
+        help="Odoo RPC Host",
+        rich_help_panel="RPC Options",
+    )
+
+    rpc_user: str = Option(
+        ...,
+        envvar="ODOO_RPC_USER",
+        help="User for RPC login",
+        rich_help_panel="RPC Options",
+    )
+
+    rpc_password: str = Option(
+        ...,
+        envvar="ODOO_RPC_PASSWORD",
+        help="Password RPC Login Password",
+        rich_help_panel="RPC Options",
+    )
+    rpc_db_name: str = Option(
+        ...,
+        envvar=["ODOO_RPC_DB_NAME", "ODOO_MAIN_DB"],
+        help="RPC database name",
+        rich_help_panel="RPC Options",
+    )
+
+
+@dataclass
+class DatabaseCLIArgs:
+    db_filter: str = Option(
+        ...,
+        envvar="ODOO_DB_FILTER",
+        help="database filter for odoo_conf",
+        rich_help_panel="Database Options",
+    )
+    db_host: str = Option(
+        "",
+        envvar="ODOO_DB_HOST",
+        help="db hostname (empty for default socket)",
+        rich_help_panel="Database Options",
+    )
+    db_name: str = Option(
+        ...,
+        envvar="ODOO_MAIN_DB",
+        help="launch database name",
+        rich_help_panel="Database Options",
+    )
+    db_user: str = Option(
+        ...,
+        envvar="ODOO_DB_USER",
+        help="db user",
+        rich_help_panel="Database Options",
+    )
+    db_password: str = Option(
+        ...,
+        envvar="ODOO_DB_PASSWORD",
+        help="db password",
+        rich_help_panel="Database Options",
+    )
+    db_port: str = Option(
+        "",
+        envvar="ODOO_DB_PORT",
+        help="db host port (empty for socket)",
+        rich_help_panel="Database Options",
+    )
+
+
+@dataclass
+class SourceGetArgs:
+    mainfest_path: Path = Option(
+        "",
+        envvar="ODOO_MANIFEST",
+        help="godoo manifest path, when downloading odoo source (skip repo_url)",
+    )
+
+    source_download_archive: Optional[bool] = Option(
+        False,
+        "--source-download-archive",
+        envvar="SOURCE_CLONE_ARCHIVE",
+        help="When using a HTTPs Repo Url for Github we can download a snapshop without the Repo history",
+    )
+
+
+class CommonCLI:
+    def __init__(self) -> None:
+        self.odoo_paths = OdooPathCLIArgs
+        self.odoo_launch = OdooLaunchArgs
+        self.database = DatabaseCLIArgs
+        self.rpc = RpcCLIArgs
+        self.source = SourceGetArgs
+        self.returner = typer_retuner
+        self.unpacker = typer_unpacker
+
+    @property
+    def arg_annotator(self):
+        """Add type annotations for
+
+        Returns
+        -------
+        Callback
+            Annotator function with CommonCLI Props as arguments
+        """
+        my_args = self.__dict__
+        return get_type_from_default(*list(my_args.values()))

godoo_cli/commands/__init__.py

@@ -0,0 +1,9 @@
+from .bootstrap import bootstrap_odoo
+from .config import set_odoo_config
+from .db import db_cli_app
+from .launch import launch_import, launch_odoo
+from .rpc import rpc_cli_app
+from .shell import odoo_shell, uninstall_modules
+from .source_get import source_cli_app
+from .test import odoo_test
+from .backup import backup_cli_app

godoo_cli/commands/backup/__init__.py

@@ -0,0 +1 @@
+from .cli import backup_cli_app

godoo_cli/commands/backup/cli.py

@@ -0,0 +1,17 @@
+import typer
+
+from .load import load_instance_data
+from .pull import InstancePuller
+
+
+def backup_cli_app():
+    app = typer.Typer(
+        no_args_is_help=True,
+        help="Functions around Backing up and Restoring Odoo",
+    )
+    puller = InstancePuller()
+
+    app.command("pull")(puller.pull_instance_data)
+    app.command("load")(load_instance_data)
+
+    return app

godoo_cli/commands/backup/load.py

@@ -0,0 +1,110 @@
+import logging
+from pathlib import Path
+
+import typer
+from typing_extensions import Annotated
+
+from ...cli_common import CommonCLI
+from ..db.connection import DBConnection
+from .util import call_rsync, create_db, drop_db
+
+LOGGER = logging.getLogger(__name__)
+CLI = CommonCLI()
+
+
+def load_pg_dump(
+    dump_path: Path,
+    db_name: str,
+    db_host: str = None,
+    db_port: int = 0,
+    db_user: str = None,
+    db_password: str = None,
+):
+    """Drop and recreate db_name and restore dump_path into it."""
+    if not dump_path.exists():
+        raise FileNotFoundError("Cannot find PG dump @ %s" % dump_path)
+
+    conn = DBConnection(
+        db_name="postgres",
+        hostname=db_host,
+        port=db_port,
+        username=db_user,
+        password=db_password,
+    )
+
+    drop_db(conn, db_name)
+    create_db(conn, db_name)
+
+    conn.db_name = db_name
+
+    LOGGER.info(
+        "Loading DB Dump: %s [%s mb] --> %s",
+        dump_path,
+        round(dump_path.stat().st_size / (1024 * 1024), 2),
+        db_name,
+    )
+    if dump_path.suffix == ".dump":
+        command = "pg_restore --no-owner --format c --dbname %s --jobs 8 {} %s" % (db_name, dump_path)
+    else:
+        command = "cat %s | psql {} >/dev/null" % dump_path
+    load_return = conn.run_psql_shell_command(
+        command=command,
+        log_name="Reading DB",
+        text=True,
+        capture_output=True,
+    )
+    if load_return.returncode != 0:
+        raise typer.Exit(1)
+    LOGGER.info("Deleting RPC Import Cache using plain SQL")
+    with conn.connect() as cur:
+        cur.execute("DELETE FROM ir_config_parameter WHERE key='godoo_rpc_import_cache';")
+    return load_return.returncode
+
+
+@CLI.arg_annotator
+def load_instance_data(
+    source_folder: Annotated[
+        Path,
+        typer.Argument(
+            ...,
+            help="Source Folder to load data from.",
+            file_okay=False,
+            dir_okay=True,
+            exists=True,
+        ),
+    ],
+    filestore_target_folder: Annotated[
+        Path,
+        typer.Argument(
+            ...,
+            help="Target Folder to load filestore to.",
+            file_okay=False,
+            dir_okay=True,
+        ),
+    ],
+    db_host=CLI.database.db_host,
+    db_port=CLI.database.db_port,
+    db_name=CLI.database.db_name,
+    db_user=CLI.database.db_user,
+    db_password=CLI.database.db_password,
+    dump_file_name: Annotated[
+        str,
+        typer.Option(help="Optional Changeable filename of Odoo SQL Dump within source_folder"),
+    ] = "odoo.dump",
+):
+    """Copy Filestore cache and load SQL Dump into Postgres for gOdoo."""
+    load_pg_dump(
+        dump_path=source_folder / dump_file_name,
+        db_host=db_host,
+        db_port=db_port,
+        db_name=db_name,
+        db_user=db_user,
+        db_password=db_password,
+    )
+    LOGGER.info("Done Loading Odoo instance from %s", source_folder)
+
+    filestore_target_folder.mkdir(parents=True, exist_ok=True)
+    call_rsync(
+        source_folder=source_folder / "odoo_filestore",
+        target_folder=filestore_target_folder,
+    )

godoo_cli/commands/backup/pull.py

@@ -0,0 +1,134 @@
+import logging
+import subprocess
+from pathlib import Path
+
+import typer
+from rich.progress import track
+from typing_extensions import Annotated
+
+from ...cli_common import CommonCLI
+from ...helpers.system import typer_ask_overwrite_path
+
+LOGGER = logging.getLogger(__name__)
+CLI = CommonCLI()
+
+
+class InstancePuller:
+    ssh_hostname: str
+    ssh_user: str
+    pg_container: str  # Does Postgres Live in a container?
+    pg_user: str
+
+    def set_exec_target(self, command):
+        """Prepend ssh execution, if ssh args are provided"""
+        if self.ssh_hostname:
+            return f"ssh {self.ssh_user}@{self.ssh_hostname} '{command}'"
+        return command
+
+    def get_docker_volume_path(self, volume_name: str):
+        command = f"docker volume inspect {volume_name} | jq -r .[0].Mountpoint"
+        command = self.set_exec_target(command)
+        LOGGER.debug("Running: '%s'", command)
+        path = subprocess.run(
+            command,
+            shell=True,
+            capture_output=True,
+            text=True,
+        ).stdout.strip("\n")
+        LOGGER.debug("Docker Volume Path: %s", path)
+        return path
+
+    def rsync_filestore(self, filestore_folder, target_folder: Path):
+        src_path = filestore_folder
+        if self.ssh_hostname:
+            src_path = f"{self.ssh_user}@{self.ssh_hostname}:{src_path}/"
+
+        command = f"rsync --rsync-path 'sudo rsync' -a --no-perms --no-owner --no-group --delete --info=progress2 {src_path} {target_folder}"
+        LOGGER.info("Rysnc filestore from: %s", filestore_folder)
+        LOGGER.debug("Running: %s", command)
+        return subprocess.run(command, shell=True).returncode
+
+    def download_db_dump(self, db_name, target_sql_path: Path):
+        command = f"pg_dump --no-owner -Fc {db_name}"
+        if n := self.pg_container:
+            command = f"docker exec {n} {command}"
+            if u := self.pg_user:
+                command += f" -U {u}"
+        else:
+            # Lets assume we run pg_dump locally here.
+            # Totally need to think about a neat way to handle the multiple combinations of this.
+            if u := self.pg_user:
+                command = f"sudo -u {u} {command}"
+
+        command = self.set_exec_target(command)
+        LOGGER.info("Downloading DB Dump: %s", db_name)
+        target_sql_path.touch(exist_ok=True)
+        with target_sql_path.open("wb") as sql_dump_file:
+            LOGGER.debug("Running: %s", command)
+            dbdumper = subprocess.Popen(command, stdout=subprocess.PIPE, shell=True)
+            for line in track(dbdumper.stdout, description="Downloading DB Dump", show_speed=False):
+                sql_dump_file.write(line)
+
+    @CLI.arg_annotator
+    def pull_instance_data(
+        self,
+        target_folder: Annotated[
+            Path, typer.Argument(..., help="Target Folder to pull data to.", file_okay=False, dir_okay=True)
+        ],
+        ssh_user: Annotated[
+            str,
+            typer.Option(
+                ..., help="SSH User of remote instance.", rich_help_panel="Remote Options", envvar="ODOO_PULL_SSH_USER"
+            ),
+        ] = None,
+        ssh_hostname: Annotated[
+            str,
+            typer.Option(
+                help="SSH Hostname of remote instance.", rich_help_panel="Remote Options", envvar="ODOO_PULL_HOST"
+            ),
+        ] = None,
+        filestore_folder: Annotated[
+            Path,
+            typer.Option(help="Path to odoo web folder.", rich_help_panel="Filestore Options"),
+        ] = None,
+        filestore_volume: Annotated[
+            str,
+            typer.Option(
+                help="Alternative to valib-folder. A Docker volume name, that gets used to derive filestore-folder",
+                rich_help_panel="Filestore Options",
+            ),
+        ] = None,
+        pg_container: Annotated[
+            str,
+            typer.Option(
+                help="Postgres Container Name. (Optional)",
+                rich_help_panel="Database Options",
+            ),
+        ] = None,
+        pg_db_user=CLI.database.db_user,
+        pg_db_name=CLI.database.db_name,
+    ):
+        """Pull filestore folder and Database Dump and save to TARGET_FOLDER"""
+        self.ssh_hostname = ssh_hostname
+        self.ssh_user = ssh_user
+        filestore_target = target_folder / "odoo_filestore"
+        sql_target = target_folder / "odoo.dump"
+
+        if filestore_folder:
+            volume_path = filestore_folder
+        elif filestore_volume:
+            volume_path = self.get_docker_volume_path(filestore_volume)
+        else:
+            LOGGER.error("You need to either Supply a filestore-folder or a filestore-volume")
+            raise typer.Exit(1)
+
+        if not typer_ask_overwrite_path([filestore_target, sql_target]):
+            raise typer.Exit(2)
+
+        filestore_target.mkdir(parents=True, exist_ok=True)
+        self.rsync_filestore(volume_path, filestore_target)
+
+        self.pg_container = pg_container
+        self.pg_user = pg_db_user
+        self.download_db_dump(pg_db_name, sql_target)
+        LOGGER.info("Done Pulling Odoo Instance")

godoo_cli/commands/backup/util.py

@@ -0,0 +1,35 @@
+import subprocess
+from logging import getLogger
+from pathlib import Path
+
+from ..db.connection import DBConnection
+
+LOGGER = getLogger(__name__)
+
+
+def call_rsync(source_folder: Path, target_folder: Path, rsync_delete: bool = True):
+    """Copy Folder to anohter using Rsync"""
+    if not source_folder.exists() and not source_folder.glob("*"):
+        raise FileNotFoundError("Cannot find filestore Backup @ %s" % source_folder)
+    args = ["rsync", "-a", "--no-perms", "--no-owner", "--no-group", "--info=progress2"]
+    if rsync_delete:
+        args += ["--delete"]
+    args += [f"{source_folder}/", f"{target_folder}/"]
+    command = " ".join(map(str, args))
+    LOGGER.info("Rysnc filestore to: %s", source_folder)
+    LOGGER.debug("Running: %s", command)
+    return subprocess.run(command, shell=True).returncode
+
+
+def drop_db(connection: DBConnection, db_name: str):
+    """Drop a DB in postgres"""
+    with connection.connect() as cur:
+        LOGGER.info("Dropping DB: %s", db_name)
+        cur.execute("DROP DATABASE IF EXISTS %s" % db_name)
+
+
+def create_db(connection: DBConnection, db_name: str):
+    """Create DB In Postgres"""
+    with connection.connect() as cur:
+        LOGGER.info("Creating DB: %s", db_name)
+        cur.execute("CREATE DATABASE %s" % db_name)