gOdoo-cli 0.7.0__py3-none-any.whl

godoo_cli/helpers/odoo_files.py

@@ -0,0 +1,278 @@
+"""Functions that operate on Odoos Source Code."""
+import logging
+from ast import literal_eval
+from pathlib import Path
+from typing import List, Union
+
+from git import Repo
+
+from .system import run_cmd
+
+LOGGER = logging.getLogger(__name__)
+
+
+def odoo_bin_get_version(odoo_main_repo_path: Path) -> str:
+    """Get Odoo Version by calling 'odoo-bin --version'
+
+    Parameters
+    ----------
+    odoo_main_repo_path : Path
+        Path to odoo-bin folder
+
+    Returns
+    -------
+    str
+        odoo-bin --version output
+    """
+    odoo_bin_path = odoo_main_repo_path / "odoo-bin"
+    version_out = run_cmd(f"{odoo_bin_path.absolute()} --version", capture_output=True, text=True)
+    return version_out.stdout
+
+
+def get_zip_addon_path(thirdparty_path: Path) -> Path:
+    return thirdparty_path / "custom"
+
+
+def folder_is_odoo_module(folder: Path) -> bool:
+    """Wether folder is a valid odoo module.
+
+    Parameters
+    ----------
+    folder : Path
+        Folder to check
+
+    Returns
+    -------
+    bool
+        true if folder contains a module
+    """
+    return folder.is_dir() and any(folder.glob("__manifest__.py"))
+
+
+def get_odoo_module_paths(search_folders: Union[List[Path], Path]) -> List[Path]:
+    """List all Valid odoo module names in one or many Odoo addons folder.
+
+    Parameters
+    ----------
+    search_folders : Path
+        Folder(s) to search in.
+
+    Returns
+    -------
+    List[Path]
+        List of Valid Module Folders within search_folder
+    """
+    if not isinstance(search_folders, List):
+        search_folders = [search_folders]
+
+    module_paths = []
+    for folder in search_folders:
+        if not folder.exists():
+            return
+        for folder in folder.iterdir():
+            if folder_is_odoo_module(folder):
+                module_paths.append(folder)
+    return module_paths
+
+
+def get_changed_modules(
+    addon_path: Path,
+    diff_branch: str,
+) -> List[Path]:
+    """Get Paths of changed modules since git diff.
+
+    Parameters
+    ----------
+    addon_path : Path
+        Folder in git repo where to look for changes
+    diff_branch : str
+        Branch or diffable ref for git
+
+    Returns
+    -------
+    List[Path]
+        List of Paths where something has changed since git diff
+    """
+    addon_path = addon_path.absolute()
+    repo = Repo(addon_path, search_parent_directories=True)
+    git_root = Path(repo.git.rev_parse("--show-toplevel"))
+    changed_module_files = []
+    for change in repo.git.diff("--name-status", diff_branch).split("\n"):
+        path = git_root / change.split("\t")[1]
+        if addon_path in path.parents:
+            changed_module_files.append(path)
+
+    changed_module_folders = []
+    for f in changed_module_files:
+        for pf in f.parents:
+            if pf.absolute() == addon_path.absolute():
+                break
+            if pf.absolute() not in changed_module_folders and folder_is_odoo_module(pf):
+                changed_module_folders.append(pf.absolute())
+    if changed_module_folders:
+        LOGGER.debug(
+            "Found Modules changed to branch '%s':\n %s",
+            diff_branch,
+            "\n".join(["\t" + str(f) for f in changed_module_folders]),
+        )
+    return changed_module_folders
+
+
+def get_depends_of_module(
+    all_modules: List[Path],
+    module_to_check: Path,
+    already_done_modules: List[Path] = None,
+):
+    """Recursively Searches sub dependencies for Odoo modules.
+
+
+    Parameters
+    ----------
+    all_modules : List[Path]
+        List of Path objects pointing to odoo modules
+    module_to_check : Path
+        path with odoo module
+    already_done_modules : List[Path], optional
+        Only used internally for recursion caching, by default None
+
+    Returns
+    -------
+    List[Path]
+        Paths to dependency modules
+    """
+    manifest_path = module_to_check / "__manifest__.py"
+
+    if not already_done_modules:
+        already_done_modules = []
+    if module_to_check.absolute() in already_done_modules:
+        return []
+    already_done_modules.append(module_to_check.absolute())
+
+    manifest = literal_eval(manifest_path.read_text())
+    module_depends = manifest.get("depends", [])
+    sub_depends = []
+    for dep in module_depends:
+        dep_path = [p for p in all_modules if p.stem == dep]
+        if dep_path:
+            dep_path = dep_path[0]
+            if dep_path.absolute() in already_done_modules:
+                continue
+            sub_depends.append(dep_path.absolute())
+            sub_depends += get_depends_of_module(all_modules, dep_path, already_done_modules)
+        elif dep != "base":
+            LOGGER.warn("Could not find Dependency: '%s' in available modules", dep)
+
+    return list(set(sub_depends))
+
+
+def get_addon_paths(
+    odoo_main_repo: Path,
+    workspace_addon_path: Path,
+    thirdparty_addon_path: Path,
+) -> List[Path]:
+    """Get Odoo Addon Paths for odoo.conf.
+
+    Parameters
+    ----------
+    odoo_main_repo : Path
+        Path to main odoo repo
+    workspace_addon_path : Path
+        Path to workspace addons
+    thirdparty_addon_path : Path
+        path to git cloned addon repos
+
+    Returns
+    -------
+    List[Path]
+        List of valid addon Paths
+    """
+    odoo_addon_paths = [odoo_main_repo / "addons"]
+    if get_odoo_module_paths(workspace_addon_path):
+        odoo_addon_paths.append(workspace_addon_path)
+    zip_addon_path = get_zip_addon_path(thirdparty_addon_path)
+    zip_addon_repos = [f for f in zip_addon_path.iterdir() if f.is_dir() and get_odoo_module_paths(f)]
+    odoo_addon_paths += zip_addon_repos
+    git_thirdparty_addon_repos = [
+        p for p in thirdparty_addon_path.iterdir() if p.is_dir() and not p.resolve() == zip_addon_path.resolve()
+    ]
+    odoo_addon_paths += git_thirdparty_addon_repos
+    return odoo_addon_paths
+
+
+def _get_odoo_main_path(addon_paths: List[Path]) -> Path:
+    """Get Odoo main path by location of odoo-bin from addon folders.
+
+    Parameters
+    ----------
+    addon_paths : List[Path]
+        List of possible paths
+
+    Returns
+    -------
+    Path
+        Path with odoo-bin and main addons folder
+    """
+    for path in addon_paths:
+        # The main odoo addon path is odoo/addons.
+        # so one up should be the launch script
+        bin_path = path.parent / "odoo-bin"
+        if bin_path.exists() and bin_path.is_file():
+            return path
+
+
+def _get_python_requirements_of_modules(addon_paths: List[Path], filter_module_names: List[str] = None):
+    """Install python requirements mentioned in module manifests
+
+    Parameters
+    ----------
+    addon_paths : List[Path]
+        Paths to look for addons. (same as odoo-bin)
+    filter_module_names : List[str], optional
+        Modules to look for manifests, by default all available modules
+    """
+    available_modules = get_odoo_module_paths(addon_paths)
+    available_module_names = [p.stem for p in available_modules]
+
+    if not filter_module_names:
+        filter_module_names = available_module_names
+    filter_module_names = [f for f in filter_module_names if f != "base"]
+
+    LOGGER.debug("Checking python requirements of Modules: %s", sorted(filter_module_names))
+    if unavailable_modules := set(filter_module_names).difference(available_module_names):
+        LOGGER.warning("Could not find __manifest__ for: %s", unavailable_modules)
+        LOGGER.debug("Search Paths:\n%s", "\n".join(map(str, addon_paths)))
+
+    check_modules = [mp for mp in available_modules if mp.stem in filter_module_names]
+
+    if odoo_main_path := _get_odoo_main_path(addon_paths):
+        # When the Odoo main path is in the supplied path, exclude those modules.
+        # Odoos base requirements are set in their requirements.txt
+        LOGGER.debug("Py install: Excluding Odoo main Modules in: '%s'", odoo_main_path)
+        check_modules = [mp for mp in check_modules if odoo_main_path not in mp.parents]
+
+    check_modules_dependencies = []
+    for module in check_modules:
+        check_modules_dependencies += get_depends_of_module(
+            available_modules, module, already_done_modules=check_modules_dependencies
+        )
+    LOGGER.debug(
+        "adding children of requested modules to check list:\n%s",
+        "\n".join(sorted([p.stem for p in check_modules_dependencies])),
+    )
+
+    check_modules += check_modules_dependencies
+
+    check_modules = set(check_modules)
+
+    if not check_modules:
+        LOGGER.debug("No Modules provided to check for python Requirements")
+        return
+    python_depends = []
+    for module_path in check_modules:
+        LOGGER.debug("Checking for External Depends: %s", module_path)
+        manifest_path = module_path / "__manifest__.py"
+        manifest = literal_eval(manifest_path.read_text())
+        if module_depends := manifest.get("external_dependencies", {}).get("python"):
+            python_depends += module_depends
+
+    return list(set(python_depends))

godoo_cli/helpers/odoo_manifest.py

@@ -0,0 +1,112 @@
+import logging
+import shutil
+from pathlib import Path
+from typing import List
+
+from ruamel.yaml import YAML
+
+from ..git.git_url import GitUrl
+
+LOGGER = logging.getLogger(__name__)
+
+
+def remove_unused_folders(thirdparty_addon_path: Path, thirdparty_repos, keep_folders: List[Path]):
+    """Remove folders that are not included in git_repos anymore
+
+    Parameters
+    ----------
+    thirdparty_addon_path : Path
+        Folder to check for deletions
+    thirdparty_repos : Dict
+        Dict of Prefix:[dict[url],..]
+    """
+    allowed_folders = []
+    keep_folders_absolute = [p.absolute() for p in keep_folders]
+    for prefix in thirdparty_repos:
+        for repo in thirdparty_repos[prefix]:
+            repo_url = GitUrl(repo["url"])
+            allowed_folders.append(f"{prefix}_{repo_url.name}")
+    for folder in thirdparty_addon_path.iterdir():
+        if not folder.is_dir() or folder.absolute() in keep_folders_absolute:
+            continue
+        if folder.stem not in allowed_folders:
+            LOGGER.info("Removing unspecified Addon Folder: %s", folder)
+            shutil.rmtree(folder)
+
+
+def update_yml(
+    repo_yml,
+    generate_yml_compare_comments: bool = False,
+):
+    """Process yaml after thirdparty clone.
+
+    Parameters
+    ----------
+    repo_yml : Yaml Dict
+        Ruamel Yaml Dict of prefix and list of repos (url,commit,branch)
+    generate_yml_compare_comments : bool, optional
+        add github compare links as comment to repo yml, by default False
+    """
+    thirdparty_repos = repo_yml["thirdparty"]
+    odoo_default_branch = repo_yml["odoo"].get("branch")
+    if not odoo_default_branch:
+        LOGGER.error("Odoo Key in manifest missing branch argument.")
+        return
+
+    for prefix in thirdparty_repos:
+        for repo in thirdparty_repos[prefix]:
+            if generate_yml_compare_comments:
+                yaml_add_compare_commit(repo, odoo_default_branch)
+            else:
+                yaml_remove_compare_commit(repo)
+
+
+def yaml_add_compare_commit(repo_dict, compare_target: str):
+    """Add comment with Compare URL to Repo:
+
+    Parameters
+    ----------
+    repo_dict : _type_
+        Yaml Dict of url and commit
+    compare_target : str
+        git ref to compare to
+    """
+    git_url = GitUrl(repo_dict["url"])
+    try:
+        compare_url = git_url.get_compare_url(repo_dict["commit"], compare_target)
+        repo_dict.yaml_add_eol_comment(compare_url, "commit")
+    except Exception as e:
+        LOGGER.warn(f"Cannot Generate compare URL for: {git_url.url}")
+        LOGGER.debug(e)
+
+
+def yaml_remove_compare_commit(repo_dict):
+    """Remove Comments that have /compare/ in them.
+
+    Parameters
+    ----------
+    repo_dict : RuamelYaml Dict
+        yaml dict
+    """
+    del_list = []
+    for target, comments in repo_dict.ca.items.items():
+        for subcomment in comments:
+            if subcomment and "/compare/" in subcomment.value:
+                del_list.append(target)
+
+    for target in del_list:
+        del repo_dict.ca.items[target]
+
+
+def yaml_roundtrip_loader() -> YAML:
+    """Return Ruamel Roundtrip loader.
+
+    Returns
+    -------
+    YAML
+        Yaml Loader
+    """
+    yaml = YAML()
+    yaml.preserve_quotes = True
+    yaml.indent(mapping=2, sequence=4, offset=2)
+    return yaml

godoo_cli/helpers/system.py

@@ -0,0 +1,176 @@
+"""Helper functions around the host system"""
+import datetime
+import logging
+import os
+import subprocess
+from pathlib import Path
+from typing import List, Union
+
+import click
+import requests
+from rich.console import Console
+from rich.logging import RichHandler
+from rich.prompt import Confirm
+from rich.table import Table
+from rich.traceback import install as install_rich_traceback
+
+from . import cli as godoo_cli_helpers
+
+LOGGER = logging.getLogger(__name__)
+
+
+def run_cmd(command: str, log_name: str = "", **kwargs) -> subprocess.CompletedProcess:
+    """Runs command via subprocess.run
+
+    Parameters
+    ----------
+    command : str
+        Command string
+    **kwargs
+        get passed down to Run
+
+    Returns
+    -------
+    CompletedProcess
+    """
+    LOGGER.debug("Running shell: '%s'", command)
+    if not kwargs.get("shell"):
+        kwargs["shell"] = True
+    proc = subprocess.run(command, **kwargs)
+    if proc.returncode != 0 and log_name:
+        LOGGER.error("Failed: %s", log_name)
+    return proc
+
+
+def ensure_dotenv(varname: str) -> str:
+    """
+    Load Env Var.
+    Raise Error if not Set.
+
+    Parameters
+    ----------
+    varname : str
+        env var name
+
+    Returns
+    -------
+    str
+        env value
+
+    Raises
+    ------
+    ReferenceError
+        if env var is none
+    """
+    var = os.getenv(varname)
+    if var is None:
+        raise ReferenceError(f"Env Variable: {varname} is not set")
+    return var
+
+
+def set_logging(verbose: bool = False) -> None:
+    """
+    Set the Logging Config according to passed arguments.
+
+    Parameters
+    ----------
+    verbose : bool
+        Wether to Log debug Messages
+    """
+    if verbose:
+        install_rich_traceback(suppress=[click, godoo_cli_helpers])
+        logging.basicConfig(
+            level=logging.DEBUG,
+            format="{message}",
+            style="{",
+            handlers=[
+                RichHandler(
+                    level=logging.DEBUG,
+                    show_path=True,
+                    rich_tracebacks=True,
+                    tracebacks_show_locals=True,
+                )
+            ],
+            datefmt="%Y-%m-%d %H:%M:%S",
+        )
+    else:
+        logging.basicConfig(
+            level=logging.INFO,
+            format="{message}",
+            style="{",
+            handlers=[RichHandler(level=logging.INFO, show_path=False, rich_tracebacks=False)],
+            datefmt="%Y-%m-%d %H:%M:%S",
+        )
+
+
+def download_file(url: str, save_path: Path, chunk_size: int = 128) -> None:
+    """Download file from URL.
+
+    Parameters
+    ----------
+    url : _type_
+        url to get file from
+    save_path : _type_
+        Where to save the file
+    chunk_size : int, optional
+        Chunk size to iterate over request, by default 128
+    """
+    LOGGER.debug("Downloading File: '%s' to '%s'", url, save_path)
+    r = requests.get(url, stream=True)
+    with open(save_path, "wb") as fd:
+        for chunk in r.iter_content(chunk_size=chunk_size):
+            fd.write(chunk)
+
+
+def typer_ask_overwrite_path(paths: Union[List[Path], Path]) -> bool:
+    """Checks if the provided Paths do already exist.
+    Ignores 0 size files and empty folders.
+    Prints table of Paths with size and Changedate.
+    Prompts user to continue or abort typer.
+
+    Returns
+    ---------
+    False, when we shall not overwrite files.
+    True, when there are no files to override or we should override
+    """
+    if isinstance(paths, Path):
+        paths = [paths]
+
+    def path_exists(path: Path):
+        """If Path exists and is no empty dir"""
+        if path.is_dir():
+            return bool(path.glob("*"))
+        else:
+            return path.exists() and path.stat().st_size
+
+    existing_paths = [p for p in paths if path_exists(p)]
+    if not existing_paths:
+        return True
+    table = Table()
+    table.add_column("Name")
+    table.add_column("Size", justify="right")
+    table.add_column("Date Changed")
+
+    def file_or_folder_size_mb(path: Path) -> float:
+        """Get size of file or all files in folder summed in MB"""
+
+        def file_size_mb(file: Path) -> float:
+            """Get size of file in MB"""
+            return file.stat().st_size / (1024 * 1024)
+
+        if path.is_file():
+            return file_size_mb(path)
+        else:
+            return sum([file_size_mb(f) for f in path.rglob("*")])
+
+    for p in existing_paths:
+        timestamp = datetime.datetime.fromtimestamp(p.stat().st_mtime)
+        path_size = round(file_or_folder_size_mb(p), 2)
+        table.add_row(p.name, f"{path_size}mb", timestamp.strftime("%Y-%m-%d: %H:%M:%S"))
+    LOGGER.warning("Found Existing Odoo Files:")
+    Console().print(table)
+    override = Confirm.ask("override?")
+    if override:
+        return True
+    LOGGER.info("Aborting")
+    return False

godoo_cli/version.py

@@ -0,0 +1 @@
+__version__ = "0.7.0"