gOdoo-cli 0.0.2__py3-none-any.whl

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
+
+import typer
+from godoo_rpc import import_data
+from godoo_rpc.login import wait_for_odoo
+
+from ...helpers.cli import typer_unpacker
+from .cli import rpc_callback
+
+app = typer.Typer(callback=rpc_callback, no_args_is_help=True)
+LOGGER = logging.getLogger(__name__)
+
+
+@typer_unpacker
+def import_to_odoo(
+    ctx: typer.Context,
+    read_path: Path = typer.Argument(
+        ...,
+        readable=True,
+        exists=True,
+        help="Folder in which to search for import",
+    ),
+    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 Csv Files into Odoo.
+    Adds an ir.config_parameter for each imported file,
+    containing the modification time of the file.
+    Will Skip already matching Timestamps and only import files that are new.
+    """
+    odoo_api = wait_for_odoo(
+        odoo_host=ctx.obj.odoo_rpc_host,
+        odoo_db=ctx.obj.odoo_main_db,
+        odoo_user=ctx.obj.odoo_rpc_user,
+        odoo_password=ctx.obj.odoo_rpc_password,
+    )
+    if not read_path.exists():
+        raise ValueError("Provided import Path: %s doesn't exist", read_path)
+
+    if read_path.is_file():
+        product_image_regex = ""
+        file_regex = ""
+
+    import_data(
+        odoo_api=odoo_api,
+        read_path=read_path.absolute(),
+        data_regex=file_regex,
+        product_image_regex=product_image_regex,
+        check_dataset_timestamp=check_data_timestamp,
+        skip_existing_ids=skip_existing_ids,
+    )

godoo_cli/commands/rpc/modules.py

@@ -0,0 +1,108 @@
+import logging
+from typing import Any, List
+
+import typer
+from godoo_rpc import OdooApiWrapper
+from godoo_rpc.login import wait_for_odoo
+
+from ...helpers.cli import typer_retuner
+from .cli import rpc_callback
+
+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))
+
+    if ids := mod_env.search(base_domain + search_domain):
+        return mod_env.browse(ids)
+
+
+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
+
+    if install_module_ids := [m.id for m in modules if not m.installed]:
+        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.installed]):
+        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
+
+
+def install_modules(
+    ctx: typer.Context,
+    module_name_query: str = typer.Argument(..., help=r"Module Internal name. Will use ilike Match if \% is present"),
+    upgrade: bool = typer.Option(True, help="Upgrae Module if already installed"),
+):
+    """Upgrades or Installs Modules in Odoo via RPC."""
+
+    odoo_api = wait_for_odoo(
+        odoo_host=ctx.obj.odoo_rpc_host,
+        odoo_db=ctx.obj.odoo_main_db,
+        odoo_user=ctx.obj.odoo_rpc_user,
+        odoo_password=ctx.obj.odoo_rpc_password,
+    )
+
+    if modules := rpc_get_modules(odoo_api, module_name_query):
+        if rpc_install_modules(modules):
+            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 typer_retuner(1)
+
+
+def modules_cli_app():
+    app = typer.Typer(callback=rpc_callback, no_args_is_help=True)
+
+    app.command(name="install")(install_modules)
+    return app

godoo_cli/commands/rpc/translations.py

@@ -0,0 +1,94 @@
+import logging
+from base64 import b64decode
+from pathlib import Path
+
+import typer
+from godoo_rpc.login import wait_for_odoo
+
+from ...helpers.cli import typer_retuner
+from ...helpers.odoo_files import get_odoo_addons_in_folder
+from .cli import rpc_callback
+from .modules import rpc_get_modules
+
+app = typer.Typer(callback=rpc_callback, no_args_is_help=True)
+LOGGER = logging.getLogger(__name__)
+
+
+def dump_translation(module, target_path: Path):
+    """Dump Translation of a module into POT file.
+
+    Parameters
+    ----------
+    module : _type_
+        _description_
+    target_path : Path
+        _description_
+    """
+    trans_exp_mod = module.env["base.language.export"]
+
+    LOGGER.info("Exporting: %s --> %s", module.name, str(target_path))
+    trans_wiz_id = trans_exp_mod.create({"format": "po", "modules": [module.id]})
+    trans_wiz = trans_exp_mod.browse([trans_wiz_id])
+    trans_wiz.act_getfile()
+    trans_wiz = trans_exp_mod.browse([trans_wiz_id])
+    target_path.parent.mkdir(exist_ok=True)
+    target_path.write_bytes(b64decode(trans_wiz.data))
+
+
+def _dump_translations(
+    modules,
+    workspace_addon_path: Path,
+    upgrade_modules: bool = True,
+):
+    """Dump translations of given Modules into their addon folders.
+
+    Parameters
+    ----------
+    odoo_api : OdooApiWrapper
+        Odoo Api Wrapper
+    modules : _type_
+        Api Models of modules
+    workspace_addon_path : Path
+        path where those modules are installed
+    upgrade_modules : bool, optional
+        Wether to upgrade modules before dumping, by default True
+    """
+
+    if upgrade_modules:
+        LOGGER.info("Upgrading Modules: '%s'", ", ".join(modules.mapped("name")))
+        modules.button_immediate_upgrade()
+
+    for mod in modules:
+        ex_path: Path = workspace_addon_path / mod.name / "i18n"
+        pot_path: Path = ex_path / (mod.name + ".pot")
+        dump_translation(mod, pot_path)
+
+
+def dump_translations(
+    ctx: typer.Context,
+    module_query=typer.Argument(..., help="Module Name. Add % to force =ilike match. Only valid for Workspace Addons."),
+    upgrade_modules: bool = typer.Option(True, help="Upgrade modules before exporting"),
+):
+
+    addon_path = ctx.obj.workspace_addon_path
+    addon_folders = get_odoo_addons_in_folder(addon_path)
+    valid_module_names = [str(p.stem) for p in addon_folders]
+    LOGGER.debug("Found modules:\n%s", "\n".join(["\t" + mn for mn in valid_module_names]))
+
+    odoo_api = wait_for_odoo(
+        odoo_host=ctx.obj.odoo_rpc_host,
+        odoo_db=ctx.obj.odoo_main_db,
+        odoo_user=ctx.obj.odoo_rpc_user,
+        odoo_password=ctx.obj.odoo_rpc_password,
+    )
+
+    modules = rpc_get_modules(odoo_api, module_query, valid_module_names)
+    if not modules:
+        LOGGER.warning("No installed Modules found for Query string: '%s'", module_query)
+        return typer_retuner(1)
+
+    _dump_translations(
+        modules=modules,
+        workspace_addon_path=addon_path,
+        upgrade_modules=upgrade_modules,
+    )

godoo_cli/commands/shell.py

@@ -0,0 +1,42 @@
+import logging
+import os
+from typing import List
+
+import typer
+
+from ..helpers.cli import typer_retuner, typer_unpacker
+
+LOGGER = logging.getLogger(__name__)
+
+
+@typer_unpacker
+def uninstall_modules(
+    ctx: typer.Context,
+    module_list: List[str] = typer.Argument(..., help="List of Modules to uninstall"),
+):
+    """
+    Uninstall Given Modules from Odoo via shell.
+    """
+    module_list_str = str(list(module_list))
+    uninstall_cmd = f"env['ir.module.module'].search([('name','in',{module_list_str})]).filtered(lambda m: m.state not in ['uninstallable','uninstalled']).button_immediate_uninstall()"
+    uninstall_shell = f'echo "{uninstall_cmd}" | {str(ctx.obj.odoo_main_path.absolute())}/odoo-bin shell -c {str(ctx.obj.odoo_conf_path.absolute())} --no-http'
+    LOGGER.info("Launching Uninstaller: '%s'", uninstall_shell)
+    ret = os.system(uninstall_shell)
+    return typer_retuner(ret)
+
+
+@typer_unpacker
+def odoo_shell(
+    ctx: typer.Context,
+    pipe_in_command: str = typer.Argument(""),
+):
+    """
+    Start Odoo session in an Interactive shell.
+    """
+    shell_cmd = (
+        f"{str(ctx.obj.odoo_main_path.absolute())}/odoo-bin shell -c {str(ctx.obj.odoo_conf_path.absolute())} --no-http"
+    )
+    if pipe_in_command:
+        shell_cmd = f'echo "{pipe_in_command}" |' + shell_cmd
+    LOGGER.debug("Running Command: %s", shell_cmd)
+    os.system(shell_cmd)

godoo_cli/commands/source_get.py

@@ -0,0 +1,164 @@
+import configparser
+import logging
+import shutil
+import zipfile
+from enum import Enum
+from pathlib import Path
+from typing import List
+
+import typer
+from ruamel.yaml import YAML
+
+from ..git import GitUrl, git_ensure_addon_repos, git_ensure_odoo_repo
+from ..helpers import download_file
+from ..helpers.cli import typer_unpacker
+from ..helpers.odoo_files import get_odoo_addons_in_folder
+from ..helpers.repospec import remove_unused_folders
+
+LOGGER = logging.getLogger(__name__)
+
+
+class UpdateMode(str, Enum):
+    all = "all"
+    zip = "zip"
+    odoo = "odoo"
+    thirdparty = "thirdparty"
+
+
+def unzip_addons(zip_folder: Path, target_addon_folder: Path, remove_excess: bool = False):
+    """Take .zip files from zip_folder and extracts them into the odoo addons folder.
+
+    Parameters
+    ----------
+    zip_folder : Path
+        Where to look for zip files
+    target_addon_folder : Path
+        where to place them
+    remove_excess : bool , optional
+        remove all and then unzip, by default False
+    """
+    if remove_excess:
+        for folder in target_addon_folder.iterdir():
+            shutil.rmtree(folder)
+    LOGGER.info("Extracting Zip Addons to: %s", target_addon_folder)
+    for zip_file in zip_folder.glob("*.zip"):
+        target_addon_folder.mkdir(exist_ok=True, parents=True)
+        LOGGER.info("Extracting Zip Addon: %s", zip_file)
+        with zipfile.ZipFile(zip_file, "r") as zip_ref:
+            zip_ref.extractall(target_addon_folder)
+
+
+def update_odoo_conf_addon_paths(odoo_conf: Path, addon_paths: List[Path]):
+    """Update Odoo.Conf with Addon Paths
+
+    Parameters
+    ----------
+    odoo_conf : Path
+        odoo.conf location
+    addon_paths : List[Path]
+        list of paths
+    """
+    config = configparser.ConfigParser()
+    config.read(odoo_conf)
+    addon_paths = ",".join([str(p.absolute()) for p in addon_paths])
+    config["options"]["addons_path"] = addon_paths
+    LOGGER.info("Writing Addon Paths to Odoo Config.")
+    LOGGER.debug(addon_paths)
+    config.write(odoo_conf.open("w"))
+
+
+@typer_unpacker
+def get_source_file(
+    repospec_yml: Path = typer.Option(
+        "", envvar="ODOO_GITSPEC", help="godoo Repospec path, when downloading odoo source (skip repo_url)"
+    ),
+    repo_url: str = typer.Option("", help="git repo url, for specific repo (skip repospec_yml)"),
+    file_ref: str = typer.Option("", help="When not using repospec. File Branch, Commit, Tag..."),
+    file_path: str = typer.Option(..., help="Relative Filepath in Repository"),
+    save_path: Path = typer.Option(..., file_okay=True, dir_okay=False, help="Where to write the file"),
+):
+    """Get Raw file from git remote.
+    Either from the Odoo Repo defined in repospec file or from a custom Git remote.
+    """
+
+    if not repo_url and not repospec_yml:
+        raise ValueError("Need to provide either repospec_yml or repo_url")
+    if repospec_yml and not repo_url:
+        repospec = YAML().load(repospec_yml.resolve())
+        odoo_spec = repospec["odoo"]
+        repo_url = odoo_spec["url"]
+        file_ref = odoo_spec.get("commit") or odoo_spec.get("branch")
+    if not file_ref:
+        raise ValueError(
+            "Need to provide file ref. If you provided a repospec, make sure there is a branch or commit key in the odoo section"
+        )
+    git_url = GitUrl(repo_url)
+    file_url = git_url.get_file_raw_url(ref=file_ref, file_path=file_path)
+
+    return download_file(url=file_url, save_path=save_path)
+
+
+@typer_unpacker
+def get_source(
+    ctx: typer.Context,
+    repospec_yml: Path = typer.Option(
+        ..., envvar="ODOO_GITSPEC", help="Git.yml file, that specified what to download with wich prefix"
+    ),
+    thirdparty_addon_path: Path = typer.Option(
+        ..., envvar="ODOO_THIRDPARTY_LOCATION", help="Root folder of the Thirdparty addon repos"
+    ),
+    thirdparty_zip_source: Path = typer.Option(
+        ..., envvar="ODOO_THIRDPARTY_ZIP_LOCATION", help="Source folder, where to look for Addon zips"
+    ),
+    update_mode: UpdateMode = typer.Option(UpdateMode.all, help="What to Update"),
+    add_compare_comments: bool = typer.Option(
+        False, help="Wether to add github.com three dot compare links as comments."
+    ),
+    remove_unspecified_addons: bool = typer.Option(
+        False, help="Remove Addon folders that are not in YML or thirdparty.zip"
+    ),
+    force_fetch: bool = typer.Option(
+        False,
+        help="Forces origin fetch, regardless of current branch or commit sha (may be slow)",
+    ),
+):
+    """Update Odoo Source and Thirdparty source."""
+    LOGGER.info("Updating Addon Repos")
+    zip_addon_path = thirdparty_addon_path / "custom"
+
+    if update_mode in ["all", "zip"]:
+        unzip_addons(thirdparty_zip_source, zip_addon_path)
+
+    if update_mode in ["all", "odoo"]:
+        git_ensure_odoo_repo(
+            target_folder=ctx.obj.odoo_main_path,
+            repo_spec_file=repospec_yml,
+            force_fetch=force_fetch,
+            add_compare_comment=add_compare_comments,
+            download_archive=ctx.obj.source_download_archive,
+        )
+
+    if update_mode in ["all", "thirdparty"]:
+        git_repos = git_ensure_addon_repos(
+            root_folder=thirdparty_addon_path,
+            git_yml_path=repospec_yml,
+            generate_yml_compare_comments=add_compare_comments,
+            download_archive=ctx.obj.source_download_archive,
+        )
+    if remove_unspecified_addons:
+        remove_unused_folders(
+            thirdparty_addon_path=thirdparty_addon_path,
+            thirdparty_repos=git_repos.get("thirdparty", []),
+            keep_folders=[zip_addon_path],
+        )
+
+    if (conf_path := ctx.obj.odoo_conf_path).exists():
+        odoo_addon_paths = [ctx.obj.odoo_main_path / "addons"]
+        if get_odoo_addons_in_folder(ctx.obj.workspace_addon_path):
+            odoo_addon_paths.append(ctx.obj.workspace_addon_path)
+        if get_odoo_addons_in_folder(zip_addon_path):
+            odoo_addon_paths.append(zip_addon_path)
+        odoo_addon_paths += [
+            p for p in thirdparty_addon_path.iterdir() if p.is_dir() and not p.resolve() == zip_addon_path.resolve()
+        ]
+        update_odoo_conf_addon_paths(odoo_conf=conf_path, addon_paths=odoo_addon_paths)

godoo_cli/commands/test.py

@@ -0,0 +1,91 @@
+import logging
+import re
+from pathlib import Path
+from typing import List
+
+import typer
+
+from ..helpers.cli import typer_retuner
+from ..helpers.odoo_files import get_changed_modules, get_depends_of_modules, get_odoo_addons_in_folder
+from .launch import launch_odoo as launch_odoo
+
+LOGGER = logging.getLogger(__name__)
+
+
+def _test_modules_special_cases(in_modules: List[str], workspace_addon_path: Path):
+    if len(in_modules) == 1:
+        command = in_modules[0]
+        out_modules = []
+        if command == "all":
+            out_modules = get_odoo_addons_in_folder(workspace_addon_path)
+
+        if re_match := re.match(r"changes\:(.*)", command):
+            compare_branch = re_match.group(1)
+            changed_modules = get_changed_modules(addon_path=workspace_addon_path, diff_branch=compare_branch)
+            if not changed_modules:
+                return []
+            out_modules = get_depends_of_modules(workspace_addon_path, changed_modules)
+        if out_modules:
+            out_modules_with_tests = [p for p in out_modules if any(p.rglob("tests/__init__.py"))]
+            return [p.stem for p in out_modules_with_tests]
+    return in_modules
+
+
+def odoo_test(
+    ctx: typer.Context,
+    test_modules: List[str] = typer.Argument(
+        ...,
+        help="Modules to install and test (Use 'all' for all Workspace modules), ('changes:<branch> to compare git changes)",
+    ),
+    skip_test_modules: List[str] = typer.Option(
+        [], envvar="ODOO_TEST_SKIP_MODULES", help="Modules not to Test even if specified in test_modules"
+    ),
+    odoo_log_level: str = typer.Option("test", help="Log level"),
+):
+    workspace_addon_path = ctx.obj.workspace_addon_path
+
+    test_modules = _test_modules_special_cases(test_modules, workspace_addon_path)
+
+    skip_test_modules = [m for m in skip_test_modules if m in test_modules]  # Filter out skip mods that arent requested
+    if skip_test_modules:
+        LOGGER.info("Skipping Tests for Modules:\n%s", ", ".join(["\t" + m for m in skip_test_modules]))
+        test_modules = [m for m in test_modules if m not in skip_test_modules]
+
+    if not test_modules:
+        LOGGER.info("Nothing to Test. Skipping.")
+        return
+
+    test_module_list = ",".join(["/" + m for m in test_modules])
+    module_list = ",".join(test_modules)
+
+    LOGGER.info("Testing Odoo Modules:\n%s", "\n".join(sorted(["\t" + m for m in test_modules])))
+
+    bootstrap_args = [
+        "--test-enable",
+        f"--init {module_list}",
+    ]
+    if re.search("(sale|account)", test_module_list, re.IGNORECASE):
+        bootstrap_args[-1] += ",l10n_generic_coa"
+
+    bootstrap_args.append(f"--test-tags {test_module_list}")
+    bootstrap_args.append("--load-language en_US")
+    launch_args = [
+        f"-u {module_list}",
+        "--test-enable",
+        f"--log-level {odoo_log_level}",
+        "--stop-after-init",
+        "--no-http",
+        f"--test-tags {test_module_list}",
+    ]
+
+    ret = launch_odoo(
+        ctx=ctx,
+        install_workspace_addons=False,
+        extra_args=launch_args,
+        extra_bootstrap_args=bootstrap_args,
+        launch=False,
+        multithread_worker_count=0,
+        odoo_demo=True,
+        update_source=False,
+    )
+    return typer_retuner(ret)

godoo_cli/git/__init__.py

@@ -0,0 +1,4 @@
+from .git_odoo import git_ensure_odoo_repo
+from .git_odoo_addons import git_ensure_addon_repos
+from .git_repo import git_ensure_repo
+from .git_url import GitUrl

godoo_cli/git/git_odoo.py

@@ -0,0 +1,45 @@
+import logging
+from pathlib import Path
+
+from ..helpers.repospec import yaml_add_compare_commit, yaml_remove_compare_commit, yaml_roundtrip_loader
+from .git_repo import git_ensure_repo
+
+LOGGER = logging.getLogger(__name__)
+
+
+def git_ensure_odoo_repo(
+    target_folder: Path,
+    repo_spec_file: Path,
+    force_fetch: bool,
+    add_compare_comment: bool,
+    download_archive: bool,
+):
+    yaml = yaml_roundtrip_loader()
+    git_repos = yaml.load(repo_spec_file.resolve())
+    if not git_repos:
+        raise FileNotFoundError(f"Couldnt load yml file from: {str(repo_spec_file)}")
+
+    odoo_data = git_repos.get("odoo")
+    if not odoo_data:
+        raise KeyError(f"Could not find key 'odoo' in {str(repo_spec_file)}")
+
+    odoo_url = odoo_data["url"]
+    odoo_branch = odoo_data.get("branch", "master")
+    odoo_commit = odoo_data.get("commit", "")
+    if add_compare_comment:
+        yaml_add_compare_commit(odoo_data, odoo_branch)
+    else:
+        yaml_remove_compare_commit(odoo_data)
+
+    git_ensure_repo(
+        target_folder=target_folder,
+        repo_src=odoo_url,
+        branch=odoo_branch,
+        commit=odoo_commit,
+        pull=force_fetch,
+        zip_mode=download_archive,
+        filter="blob:none",
+        single_branch=True,
+    )
+
+    yaml.dump(git_repos, repo_spec_file)