gOdoo-cli 0.7.0__py3-none-any.whl

godoo_cli/commands/launch.py

@@ -0,0 +1,325 @@
+import logging
+import re
+import threading
+from pathlib import Path
+from typing import List
+
+import typer
+
+from ..cli_common import CommonCLI
+from ..helpers.odoo_files import get_odoo_module_paths, odoo_bin_get_version
+from ..helpers.system import run_cmd
+from .bootstrap import bootstrap_odoo
+from .rpc import import_to_odoo
+from .source_get import update_odoo_conf
+
+CLI = CommonCLI()
+
+LOGGER = logging.getLogger(__name__)
+
+
+def _launch_command(
+    odoo_path: Path,
+    odoo_conf_path: Path,
+    extra_cmd_args: List[str],
+    workspace_addon_path: Path,
+    upgrade_workspace_modules: bool = True,
+):
+    """Build Odoo Launch command
+
+    Parameters
+    ----------
+    odoo_path : Path
+        Path to odoo-bin folder
+    odoo_conf_path : Path
+        Path to odoo.conf
+    extra_cmd_args : List[str]
+        extra args to pass to odoo-bin
+    workspace_addon_path : Path
+        Path to dev workspace addons folder
+    upgrade_workspace_modules : bool, optional
+        upgrade workspace addons, by default True
+    """
+    upgrade_addons = [f.name for f in get_odoo_module_paths(workspace_addon_path)] if upgrade_workspace_modules else []
+    if any(["-u" in i or "--update" in i for i in extra_cmd_args]):
+        upgrade_addons = []
+    update_addon_string = "--update " + ",".join(upgrade_addons) if upgrade_addons else ""
+
+    odoo_cmd = [
+        str(odoo_path.absolute()) + "/odoo-bin",
+        update_addon_string,
+        f"-c {str(odoo_conf_path.absolute())}",
+    ] + extra_cmd_args
+    odoo_cmd = list(filter(None, odoo_cmd))
+    return " ".join(odoo_cmd)
+
+
+def pre_launch(
+    odoo_main_path: Path,
+    workspace_addon_path: Path,
+    thirdparty_addon_path: Path,
+    odoo_conf_path: Path,
+    db_filter: str,
+    db_host: str,
+    db_port: int,
+    db_name: str,
+    db_user: str,
+    db_password: str,
+    odoo_demo: bool,
+    dev_mode: bool,
+    multithread_worker_count: int = 0,
+    extra_launch_args: List[str] = None,
+    extra_bootstrap_args: List[str] = None,
+    log_file_path: Path = None,
+    install_workspace_addons: bool = True,
+    install_base: bool = True,
+    launch_or_bootstrap: bool = False,
+):
+    """Start Bootstrap if no config file is found. And return Launch CMD.
+
+    Parameters
+    ----------
+    odoo_main_path : Path
+        Path to Odoo-bin folder
+    workspace_addon_path : Path
+        Path to workspace addons
+    thirdparty_addon_path : Path
+        path to thirdparty addons folder
+    odoo_conf_path : Path
+        path to odoo conf
+    db_filter : str
+        odoo.conf db_filter
+    db_host : str
+        database host url. Empty string for Unix sock
+    db_port : int
+        database port. 0 for unix sock
+    db_name : str
+        odoo main database name
+    db_user : str
+        database user
+    db_password : str
+        database password
+    odoo_demo : bool
+        if false, add --without-demo to bootstrap
+    dev_mode : bool
+        add --dev... to cmd
+    install_base : bool
+        install web, and base
+    install_workspace_addons : bool
+        install all modules in workspace folder
+    extra_args : List[str]
+        extra launch CMD args
+    extra_bootstrap_args : List[str]
+        extra bootstrap cmd args
+    log_file_path : Path
+        path to odoo.log (stdout log if empty)
+    multithread_worker_count : int
+        count of multithread workser
+    launch_or_bootstrap: bool, optional
+        Only return launch cmd if bootstrap did not run
+
+    Returns
+    -------
+    Union[int,str]
+        Int return code of bootstrap if not 0 else launch cmd as string
+    """
+    LOGGER.info("Starting godoo Init Script")
+
+    extra_odoo_args = []
+    if log_file_path is not None:
+        log_file_path.unlink(missing_ok=True)
+        extra_odoo_args.append("--logfile " + str(log_file_path.absolute()))
+
+    bootstraped = odoo_conf_path.exists()
+    LOGGER.info("Bootstrap Flag Status: %s", bootstraped)
+    ret = ""
+    if not bootstraped:
+        _extra_bootstrap_args = extra_odoo_args.copy()
+        if ea := extra_bootstrap_args:
+            _extra_bootstrap_args += ea
+        if not odoo_demo:
+            _extra_bootstrap_args += ["--without-demo all"]
+        if not install_base:
+            install_workspace_addons = False
+        ret = bootstrap_odoo(
+            db_name=db_name,
+            db_filter=db_filter,
+            db_user=db_user,
+            db_password=db_password,
+            db_host=db_host,
+            db_port=db_port,
+            thirdparty_addon_path=thirdparty_addon_path,
+            odoo_main_path=odoo_main_path,
+            odoo_conf_path=odoo_conf_path,
+            extra_cmd_args=_extra_bootstrap_args,
+            no_install_base=not install_base,
+            no_install_workspace_modules=not install_workspace_addons,
+            multithread_worker_count=multithread_worker_count,
+        )
+        bootstraped = ret == 0
+        if not bootstraped:
+            return ret
+        if install_workspace_addons and bootstraped:
+            install_workspace_addons = False
+
+        if launch_or_bootstrap:
+            return
+
+    if ea := extra_launch_args:
+        extra_odoo_args += ea
+
+    odoo_main_path = odoo_main_path
+    odoo_version = odoo_bin_get_version(odoo_main_path)
+
+    update_odoo_conf(
+        odoo_conf_path=odoo_conf_path,
+        odoo_main_path=odoo_main_path,
+        workspace_addon_path=workspace_addon_path,
+        thirdparty_addon_path=thirdparty_addon_path,
+    )
+
+    if dev_mode:
+        extra_odoo_args.append("--dev xml,qweb,reload")
+        if "16.0" in odoo_version:
+            extra_odoo_args[-1] += ",werkzeug"
+
+    if multithread_worker_count == 0:
+        extra_odoo_args.append("--workers 0")
+
+    return _launch_command(
+        odoo_path=odoo_main_path,
+        odoo_conf_path=odoo_conf_path,
+        extra_cmd_args=extra_odoo_args,
+        workspace_addon_path=workspace_addon_path,
+        upgrade_workspace_modules=install_workspace_addons,
+    )
+
+
+@CLI.unpacker
+@CLI.arg_annotator
+def launch_odoo(
+    odoo_main_path=CLI.odoo_paths.bin_path,
+    workspace_addon_path=CLI.odoo_paths.workspace_addon_path,
+    thirdparty_addon_path=CLI.odoo_paths.thirdparty_addon_path,
+    odoo_conf_path=CLI.odoo_paths.conf_path,
+    db_filter=CLI.database.db_filter,
+    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,
+    odoo_demo=CLI.odoo_launch.odoo_demo,
+    dev_mode=CLI.odoo_launch.dev_mode,
+    no_install_base=CLI.odoo_launch.no_install_base,
+    no_install_workspace_modules=CLI.odoo_launch.no_install_workspace_modules,
+    extra_args=CLI.odoo_launch.extra_cmd_args,
+    extra_bootstrap_args=CLI.odoo_launch.extra_cmd_args,
+    log_file_path=CLI.odoo_launch.log_file_path,
+    multithread_worker_count=CLI.odoo_launch.multithread_worker_count,
+):
+    """
+    Launch Odoo, Bootstrap if bootstrapflag is not present.
+    """
+
+    launch_cmd = pre_launch(
+        odoo_main_path=odoo_main_path,
+        workspace_addon_path=workspace_addon_path,
+        thirdparty_addon_path=thirdparty_addon_path,
+        odoo_conf_path=odoo_conf_path,
+        db_filter=db_filter,
+        db_host=db_host,
+        db_port=db_port,
+        db_name=db_name,
+        db_user=db_user,
+        db_password=db_password,
+        odoo_demo=odoo_demo,
+        dev_mode=dev_mode,
+        install_base=not no_install_base,
+        install_workspace_addons=not no_install_workspace_modules,
+        extra_launch_args=extra_args,
+        extra_bootstrap_args=extra_bootstrap_args,
+        log_file_path=log_file_path,
+        multithread_worker_count=multithread_worker_count,
+    )
+
+    if not isinstance(launch_cmd, str):
+        LOGGER.error("godoo Launch Failed. Bootstrap unsuccessfull. Aborting Launch...")
+        return CLI.returner(launch_cmd)
+
+    LOGGER.info("Launching Odoo")
+    return CLI.returner(run_cmd(launch_cmd).returncode)
+
+
+@CLI.arg_annotator
+def launch_import(
+    load_data_path: List[Path] = typer.Argument(
+        ...,
+        help="Starts Async Importer Job with provided path(s).",
+    ),
+    odoo_main_path=CLI.odoo_paths.bin_path,
+    workspace_addon_path=CLI.odoo_paths.workspace_addon_path,
+    thirdparty_addon_path=CLI.odoo_paths.thirdparty_addon_path,
+    odoo_conf_path=CLI.odoo_paths.conf_path,
+    db_filter=CLI.database.db_filter,
+    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,
+    rpc_host=CLI.rpc.rpc_host,
+    rpc_user=CLI.rpc.rpc_user,
+    rpc_password=CLI.rpc.rpc_password,
+    odoo_demo=CLI.odoo_launch.odoo_demo,
+    dev_mode=CLI.odoo_launch.dev_mode,
+    no_install_base=CLI.odoo_launch.no_install_base,
+    no_install_workspace_modules=CLI.odoo_launch.no_install_workspace_modules,
+    extra_launch_args=CLI.odoo_launch.extra_cmd_args,
+    extra_bootstrap_args=CLI.odoo_launch.extra_cmd_args,
+    log_file_path=CLI.odoo_launch.log_file_path,
+    multithread_worker_count=CLI.odoo_launch.multithread_worker_count,
+):
+    """Bootstrap and Start odoo. Launches RPC import in second thread."""
+
+    launch_cmd = pre_launch(
+        odoo_main_path=odoo_main_path,
+        workspace_addon_path=workspace_addon_path,
+        thirdparty_addon_path=thirdparty_addon_path,
+        odoo_conf_path=odoo_conf_path,
+        db_filter=db_filter,
+        db_host=db_host,
+        db_port=db_port,
+        db_name=db_name,
+        db_user=db_user,
+        db_password=db_password,
+        odoo_demo=odoo_demo,
+        dev_mode=dev_mode,
+        install_base=not no_install_base,
+        install_workspace_addons=not no_install_workspace_modules,
+        extra_launch_args=extra_launch_args,
+        extra_bootstrap_args=extra_bootstrap_args,
+        log_file_path=log_file_path,
+        multithread_worker_count=multithread_worker_count,
+    )
+
+    if not isinstance(launch_cmd, str):
+        LOGGER.error("godoo Launch Failed. Bootstrap unsuccessfull. Aborting Launch...")
+        return CLI.returner(launch_cmd)
+
+    launch_cmd = re.sub(r"(--dev [\w,]+)(,reload)", r"\1", launch_cmd)  # Remove reload option from CMD String
+
+    LOGGER.info("Starting Data Importer Thread for: '%s'", ", ".join(map(str, load_data_path)))
+    loader_thread = threading.Thread(
+        target=import_to_odoo,
+        name="DataLoader",
+        kwargs={
+            "read_paths": load_data_path,
+            "rpc_host": rpc_host,
+            "rpc_database": db_name,
+            "rpc_user": rpc_user,
+            "rpc_password": rpc_password,
+        },
+    )
+    loader_thread.start()
+
+    LOGGER.info("Launching Odoo")
+    return CLI.returner(run_cmd(launch_cmd).returncode)

godoo_cli/commands/rpc/__init__.py

@@ -0,0 +1,8 @@
+"""
+Things that interact with Odoo RPC.
+Must Provide username and Password
+"""
+import typer
+
+from .cli import rpc_cli_app
+from .importer import import_to_odoo as import_to_odoo

godoo_cli/commands/rpc/cli.py

@@ -0,0 +1,34 @@
+import typer
+
+from .config_parameters import set_config_parameter
+from .importer import import_to_odoo
+from .modules import install_modules, uninstall_modules
+from .translations import dump_translations
+
+
+def modules_cli_app():
+    app = typer.Typer(
+        no_args_is_help=True,
+        help="Wrapper around Odoo modules. (Install/upgrade, etc)",
+    )
+
+    app.command(name="install")(install_modules)
+    app.command(name="uninstall")(uninstall_modules)
+    app.command(name="dump-translation")(dump_translations)
+    return app
+
+
+def rpc_cli_app():
+    app = typer.Typer(
+        no_args_is_help=True,
+        help="Functions that act on a running Odoo instance via RPC.",
+    )
+
+    app.add_typer(
+        typer_instance=modules_cli_app(),
+        name="modules",
+    )
+    app.command(name="set-config-param")(set_config_parameter)
+    app.command("import")(import_to_odoo)
+
+    return app

godoo_cli/commands/rpc/config_parameters.py

@@ -0,0 +1,48 @@
+import logging
+
+import typer
+from godoo_rpc.login import wait_for_odoo
+
+from ...cli_common import CommonCLI
+
+CLI = CommonCLI()
+LOGGER = logging.getLogger(__name__)
+
+
+@CLI.arg_annotator
+def set_config_parameter(
+    param_name: str = typer.Argument(..., help=r"name of ir.config.parameter"),
+    param_value: str = typer.Argument(..., help="Value to set config parameter to (:unlink to delete the parameter)"),
+    rpc_host=CLI.rpc.rpc_host,
+    rpc_database=CLI.rpc.rpc_db_name,
+    rpc_user=CLI.rpc.rpc_user,
+    rpc_password=CLI.rpc.rpc_password,
+):
+    """Create/Set/Delete ir.config_parameter in Odoo"""
+
+    odoo_api = wait_for_odoo(
+        odoo_host=rpc_host,
+        odoo_db=rpc_database,
+        odoo_user=rpc_user,
+        odoo_password=rpc_password,
+    )
+
+    paramteter_model = odoo_api.session.env["ir.config_parameter"]
+
+    param_id = paramteter_model.search([("key", "=", param_name)])
+    param = paramteter_model.browse(param_id[0]) if param_id else None
+
+    if param_value == ":unlink":
+        if param:
+            LOGGER.warning("Removing Config Parameter: %s", param_name)
+            param.unlink()
+        else:
+            LOGGER.info("Param '%s' does not exist", param_name)
+        return
+
+    if param:
+        LOGGER.info("Setting param value for %s", param_name)
+        param.value = param_value
+    else:
+        LOGGER.info("Creating new Config Parameter: %s", param_name)
+        paramteter_model.create({"key": param_name, "value": param_value})

godoo_cli/commands/rpc/importer.py

@@ -0,0 +1,70 @@
+"""
+Import read_path into Odoo.
+Will wait until Odoo is Online.
+Places Systemparam to Track if import was already done.
+"""
+
+import logging
+from pathlib import Path
+from typing import List
+
+import typer
+from godoo_rpc import import_data
+from godoo_rpc.login import wait_for_odoo
+
+from ...cli_common import CommonCLI
+
+CLI = CommonCLI()
+LOGGER = logging.getLogger(__name__)
+
+
+@CLI.unpacker
+@CLI.arg_annotator
+def import_to_odoo(
+    read_paths: List[Path] = typer.Argument(
+        ...,
+        readable=True,
+        exists=True,
+        help="Folder in which to search for import",
+    ),
+    rpc_host=CLI.rpc.rpc_host,
+    rpc_database=CLI.rpc.rpc_db_name,
+    rpc_user=CLI.rpc.rpc_user,
+    rpc_password=CLI.rpc.rpc_password,
+    file_regex: str = typer.Option(
+        r"(?P<module>.*)\.(csv|py|xlsx|json)$",
+        help="Regex for filesearch. Add group 'module' to set a Module for RPC import",
+    ),
+    product_image_regex: str = typer.Option(
+        r"(?P<default_code>\d{6})\.(jpeg|png|jpg)$",
+        help="Regex to search for Product images. Add Fields as regex group for Matching.",
+    ),
+    check_data_timestamp: bool = typer.Option(
+        True,
+        help="If true, Odoo remembers the Name of an uploaded File in a Serverparameter. Subsequent Imports will ignore the file if it hasnt changed.",
+    ),
+    skip_existing_ids: bool = typer.Option(False, help="Will skip import of already existing External IDs."),
+):
+    """
+    Import [bold green]csv, xlsx, json, .py [/bold green] files into Odoo.
+    Adds an ir.config_parameter containing timestamp of each imported file.
+    """
+    odoo_api = wait_for_odoo(
+        odoo_host=rpc_host,
+        odoo_db=rpc_database,
+        odoo_user=rpc_user,
+        odoo_password=rpc_password,
+    )
+
+    if missing_paths := [p for p in read_paths if not p.exists()]:
+        raise ValueError("Provided import Paths: %s doesn't exist", ", ".join(missing_paths))
+
+    for path in read_paths:
+        import_data(
+            odoo_api=odoo_api,
+            read_path=path.absolute(),
+            data_regex=file_regex,
+            product_image_regex=False if path.is_file() else product_image_regex,
+            check_dataset_timestamp=check_data_timestamp,
+            skip_existing_ids=skip_existing_ids,
+        )

godoo_cli/commands/rpc/modules.py

@@ -0,0 +1,144 @@
+import logging
+from typing import Any, List
+
+import typer
+from godoo_rpc import OdooApiWrapper
+from godoo_rpc.login import wait_for_odoo
+
+from ...cli_common import CommonCLI
+
+CLI = CommonCLI()
+LOGGER = logging.getLogger(__name__)
+
+
+def rpc_get_modules(odoo_api: OdooApiWrapper, module_query: str, valid_module_names: List[str] = None):
+    """Get ir.module.module records by a query search string.
+
+    Parameters
+    ----------
+    odoo_api : OdooApiWrapper
+        Odoo Wrapper
+    module_query : str
+        Custom query. Module name. Comma sep list of modules or % wildcards are supported
+    valid_module_names : List[str], optional
+        only allow certain model names to be returned, by default None
+
+    Returns
+    -------
+    _type_
+        _description_
+    """
+    mod_env = odoo_api.session.env["ir.module.module"]
+    mod_env.update_list()
+
+    base_domain = []
+    if "," in module_query:
+        search_domain = [("name", "in", module_query.split(","))]
+    else:
+        if "%" in module_query:
+            search_domain = [("name", "=ilike", module_query)]
+        else:
+            search_domain = [("name", "=", module_query)]
+
+    if valid_module_names:
+        base_domain.insert(1, "&")
+        base_domain.append(("name", "in", valid_module_names))
+
+    LOGGER.debug("Searching for Modules with Domain: %s", base_domain + search_domain)
+    if ids := mod_env.search(base_domain + search_domain):
+        modules = mod_env.browse(ids)
+        LOGGER.debug("Found Modules: %s", [(m.id, m.name, m.state) for m in modules])
+        return modules
+
+
+def rpc_install_modules(
+    modules: Any,
+    upgrade: bool = True,
+):
+    """Install and upgrade Modules to Database.
+
+    Parameters
+    ----------
+    modules : Iterable RPC ir.module.module records
+        List of
+    upgrade : bool, optional
+        Upgrade module if already installed, by default True
+    """
+    did_something = False
+    install_module_ids = [m.id for m in modules if m.state == "uninstalled"]
+    if install_module_ids:
+        install_modules = modules.browse(install_module_ids)
+        LOGGER.info("Installing Module: " + ", ".join(install_modules.mapped("name")))
+        install_modules.button_immediate_install()
+        did_something = True
+
+    if upgrade and (
+        up_module_ids := [m.id for m in modules if m.state == "installed" and m.id not in install_module_ids]
+    ):
+        up_modules = modules.browse(up_module_ids)
+        LOGGER.info("Updating Module: " + ", ".join(up_modules.mapped("name")))
+        up_modules.button_immediate_upgrade()
+        did_something = True
+    return did_something
+
+
+@CLI.arg_annotator
+def install_modules(
+    module_name_query: str = typer.Argument(
+        ..., help=r"Module Internal name(s), comma seperated. Will use ilike Match if \% is present"
+    ),
+    rpc_host=CLI.rpc.rpc_host,
+    rpc_database=CLI.rpc.rpc_db_name,
+    rpc_user=CLI.rpc.rpc_user,
+    rpc_password=CLI.rpc.rpc_password,
+    upgrade: bool = typer.Option(True, help="Upgrae Module if already installed"),
+):
+    """Install or upgrade Odoo modules via RPC. Can act on multiple modules with % wildcard"""
+
+    odoo_api = wait_for_odoo(
+        odoo_host=rpc_host,
+        odoo_db=rpc_database,
+        odoo_user=rpc_user,
+        odoo_password=rpc_password,
+    )
+
+    if modules := rpc_get_modules(odoo_api, module_name_query):
+        if rpc_install_modules(modules, upgrade=upgrade):
+            return
+        else:
+            LOGGER.warn("Found Modules, but didn't do anything on DB.")
+    else:
+        LOGGER.warn("Could not find modules with Query: '%s'", module_name_query)
+    return CLI.returner(1)
+
+
+@CLI.arg_annotator
+def uninstall_modules(
+    module_name_query: str = typer.Argument(
+        ..., help=r"Module Internal name(s), comma seperated. Will use ilike Match if \% is present"
+    ),
+    rpc_host=CLI.rpc.rpc_host,
+    rpc_database=CLI.rpc.rpc_db_name,
+    rpc_user=CLI.rpc.rpc_user,
+    rpc_password=CLI.rpc.rpc_password,
+):
+    """Uninstall odoo Modules via RPC. Can act on multiple modules with % wildcard"""
+
+    odoo_api = wait_for_odoo(
+        odoo_host=rpc_host,
+        odoo_db=rpc_database,
+        odoo_user=rpc_user,
+        odoo_password=rpc_password,
+    )
+
+    if modules := rpc_get_modules(odoo_api, module_name_query):
+        uninstall_module_ids = [m.id for m in modules if m.state == "installed"]
+        if uninstall_module_ids:
+            uninstall_modules = modules.browse(uninstall_module_ids)
+            LOGGER.info("Uninstalling Module: " + ", ".join(uninstall_modules.mapped("name")))
+            uninstall_modules.button_immediate_uninstall()
+        else:
+            LOGGER.warn("Found Modules, but didn't do anything on DB.")
+    else:
+        LOGGER.warn("Could not find modules with Query: '%s'", module_name_query)
+    return CLI.returner(1)