gOdoo-cli 0.16.0__tar.gz → 0.17.0__tar.gz

{godoo_cli-0.16.0 → godoo_cli-0.17.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gOdoo-cli
-Version: 0.16.0
+Version: 0.17.0
 Summary: Wrapper around Odoo-Bin with some convinience RPC functions.
 Project-URL: repository, https://github.com/OpenJKSoftware/gOdoo
 Author-email: Joshua Kreuder <Joshua_Kreuder@outlook.com>

{godoo_cli-0.16.0 → godoo_cli-0.17.0}/addons/godoo_test_succ_mod/__manifest__.py

@@ -1,6 +1,6 @@
 {
     "name": "godoo Test Succ Module",
-    "version": "16.0.1.0.0",
+    "version": "19.0.1.0.0",
     "author": "Joshua Kreuder",
     "license": "AGPL-3",
     "depends": ["base"],

{godoo_cli-0.16.0 → godoo_cli-0.17.0}/src/godoo_cli/__about__.py

@@ -2,7 +2,7 @@
 
 from packaging import version
 
-__version__ = "0.16.0"  # Initial version, will be managed by Hatch
+__version__ = "0.17.0"  # Initial version, will be managed by Hatch
 
 
 def get_version_tuple() -> tuple[int, int, int]:

{godoo_cli-0.16.0 → godoo_cli-0.17.0}/src/godoo_cli/cli.py

@@ -38,14 +38,28 @@ def main_callback(
             help="Verbose Logging with Error stacktraces",
         ),
     ] = False,
+    log_filter: Annotated[
+        Optional[str],
+        typer.Option(
+            "--log-filter",
+            "-lf",
+            envvar="GODOO_LOG_FILTER",
+            help="Regex pattern to filter log output by logger name (e.g. 'odoo.test.suite')",
+        ),
+    ] = None,
 ):
-    """Configure the CLI's logging level.
+    """Configure the CLI's logging level and optional log filter.
 
     Args:
         verbose: If True, enables verbose logging with error stacktraces.
             Can be set via --verbose flag or GODOO_VERBOSE environment variable.
+        log_filter: Optional regex pattern to filter log records by logger name.
+            Can be set via --log-filter flag or GODOO_LOG_FILTER environment variable.
     """
-    set_logging(verbose=bool(verbose) if verbose is not None else False)
+    set_logging(
+        verbose=bool(verbose) if verbose is not None else False,
+        log_filter=log_filter,
+    )
 
 
 def main_cli():

{godoo_cli-0.16.0 → godoo_cli-0.17.0}/src/godoo_cli/commands/odoo_bin/shell.py

@@ -6,6 +6,7 @@ Odoo environment. It supports both interactive and script-based operations.
 """
 
 import logging
+import subprocess
 import sys
 from pathlib import Path
 from typing import Annotated, Optional
@@ -103,6 +104,10 @@ def odoo_shell_run_script(
     odoo_conf_path: Annotated[Path, CLI.odoo_paths.conf_path],
     db_name: Annotated[str, CLI.database.db_name],
     db_user: Annotated[str, CLI.database.db_user],
+    script_args: Annotated[
+        Optional[list[str]],
+        typer.Argument(help="Arguments to pass to the script"),
+    ] = None,
     db_host: Annotated[str, CLI.database.db_host] = "",
     db_port: Annotated[int, CLI.database.db_port] = 0,
     db_password: Annotated[str, CLI.database.db_password] = "",
@@ -111,6 +116,7 @@ def odoo_shell_run_script(
 
     This function executes a Python script in the Odoo shell environment,
     supporting both configuration file and direct database connection parameters.
+    Additional arguments after the script name are passed to the script as script_args list.
 
     Returns:
         int: 0 for success, non-zero for failure.
@@ -121,7 +127,7 @@ def odoo_shell_run_script(
         return CLI.returner(1)
 
     shell_cmd = f"{odoo_main_path.absolute()!s}/odoo-bin shell --no-http"
-    if odoo_conf_path.exists():
+    if odoo_conf_path and odoo_conf_path.exists():
         shell_cmd += f" -c {odoo_conf_path.absolute()!s}"
     else:
         LOGGER.warning("No Odoo Config File found at %s", odoo_conf_path)
@@ -130,8 +136,28 @@ def odoo_shell_run_script(
             return CLI.returner(1)
         shell_cmd += f" --db_host={db_host} --db_port={db_port} --database={db_name} --db_user={db_user} --db_password={db_password}"
 
-    LOGGER.info("Running Script: %s", script_path)
-    run_cmd(shell_cmd, stdin=script_path.open("r"))
+    # Prepare script with arguments
+    script_content = script_path.read_text()
+
+    # If script_args provided, prepend them as a list variable
+    if script_args:
+        args_str = repr(list(script_args))  # Safely convert to Python list literal
+        script_with_args = f"script_args = {args_str}\n\n{script_content}"
+        LOGGER.info("Running Script: %s with args: %s", script_path, script_args)
+    else:
+        script_with_args = f"script_args = []\n\n{script_content}"
+        LOGGER.info("Running Script: %s", script_path)
+
+    proc = subprocess.Popen(
+        shell_cmd,
+        shell=True,
+        stdin=subprocess.PIPE,
+        stdout=sys.stdout,
+        stderr=sys.stderr,
+        text=True,
+    )
+    proc.communicate(input=script_with_args)
+    return CLI.returner(proc.returncode)
 
 
 def odoo_pregenerate_assets(godoo_conf: GodooConfig):
@@ -144,15 +170,10 @@ def odoo_pregenerate_assets(godoo_conf: GodooConfig):
         NotImplementedError: If the Odoo version is not supported.
     """
     odoo_version = odoo_bin_get_version(odoo_main_repo_path=godoo_conf.odoo_install_folder)
-    if odoo_version.major == 16:
-        pregen_command = "env['ir.qweb']._pregenerate_assets_bundles();env.cr.commit()"
-    else:
-        msg = f"Odoo Version {odoo_version.raw} not supported in gOdoo for pregenerate_assets"
-        LOGGER.error(msg)
-        raise NotImplementedError(msg)
     LOGGER.info("Pregenerating Assets for Odoo version %s", odoo_version.raw)
-    odoo_shell(
-        pipe_in_command=pregen_command,
+    # Use the pregenerate_assets script which attempts multiple internal APIs.
+    odoo_shell_run_script(
+        script_name="pregenerate_assets",
         odoo_main_path=godoo_conf.odoo_install_folder,
         odoo_conf_path=godoo_conf.odoo_conf_path,
         db_name=godoo_conf.db_name,

godoo_cli-0.17.0/src/godoo_cli/commands/odoo_bin/shell_scripts/pregenerate_assets.py

@@ -0,0 +1,34 @@
+"""Script used by gOdoo to pregenerate asset bundles in the Odoo filestore.
+
+The script tries several internal APIs to be tolerant across multiple
+Odoo versions (16+). It prints which method succeeded or prints
+diagnostic information if all attempts fail.
+"""
+
+import contextlib
+
+from odoo import api
+
+env: api.Environment = env  # Just to silence pyright # pyright: ignore # NOQA
+
+try:
+    env["ir.qweb"]._pregenerate_assets_bundles()
+    print("pregenerated: ir.qweb._pregenerate_assets_bundles")
+except Exception:
+    try:
+        env["ir.qweb"]._pregenerate_assets()
+        print("pregenerated: ir.qweb._pregenerate_assets")
+    except Exception:
+        try:
+            env["ir.asset"]._pregenerate_bundles()
+            print("pregenerated: ir.asset._pregenerate_bundles")
+        except Exception:
+            print("pregenerate failed; exceptions:")
+            import traceback
+
+            with contextlib.suppress(Exception):
+                traceback.print_exc()
+
+# Commit any DB changes
+with contextlib.suppress(Exception):
+    env.cr.commit()

godoo_cli-0.17.0/src/godoo_cli/commands/odoo_bin/shell_scripts/render_report.py

@@ -0,0 +1,122 @@
+"""Render an Odoo report to HTML and print to stdout.
+
+This script renders a QWeb report for given record IDs and outputs the HTML.
+It is executed in the Odoo shell environment via:
+
+    godoo shell-script render_report <report_name> <record_id> [<record_id> ...]
+
+Example:
+    godoo shell-script render_report sale.report_saleorder 1
+    godoo shell-script render_report sale.report_saleorder 1 2 3
+
+Flags:
+    --keep-base64  Keep base64 content instead of replacing with placeholder
+
+"""
+
+import logging
+import re
+import sys
+from xml.dom import minidom
+
+from odoo import api
+
+LOGGER = logging.getLogger(__name__)
+
+env: api.Environment = env  # Just to silence pyright # pyright: ignore # NOQA
+
+# script_args is injected by godoo shell-script command
+script_args: list[str] = script_args  #  pyright: ignore # NOQA
+
+
+def replace_base64_with_placeholder(html_string: str) -> str:
+    """Replace base64 content with a placeholder.
+
+    Replaces long base64 strings (data URIs, embedded images, etc.) with
+    a placeholder to make output more readable.
+
+    Parameters
+    ----------
+    html_string : str
+        HTML string potentially containing base64 content
+
+    Returns:
+    -------
+    str
+        HTML string with base64 content replaced by placeholder
+    """
+    # Match data URIs with base64 content and replace with placeholder
+    # Matches patterns like: data:image/png;base64,... or similar
+    pattern = r"data:[^/]+/[^;]+;base64,[A-Za-z0-9+/]+={0,2}"
+    replacement = "data:[MIME];base64,[BASE64_CONTENT_PLACEHOLDER]"
+    return re.sub(pattern, replacement, html_string)
+
+
+def render_report(report_name: str, record_ids: list[int], replace_base64: bool = True):
+    """Render an Odoo report to HTML.
+
+    Parameters
+    ----------
+    report_name : str
+        Name of the report to render (e.g., 'sale.report_saleorder')
+    record_ids : list[int]
+        List of record IDs to render
+    replace_base64 : bool, optional
+        Replace base64 content with placeholder (True by default)
+    """
+    try:
+        report_model = env["ir.actions.report"]
+        html_content, _ = report_model._render_qweb_html(report_name, record_ids)
+
+        if html_content:
+            # Decode bytes to string
+            html_string = html_content.decode("utf-8") if isinstance(html_content, bytes) else html_content
+
+            # Replace base64 content with placeholder if enabled
+            if replace_base64:
+                html_string = replace_base64_with_placeholder(html_string)
+
+            # Try to pretty print the HTML
+            try:
+                dom = minidom.parseString(html_string)
+                pretty_html = dom.toprettyxml(indent="  ")
+                # Remove extra blank lines that minidom adds
+                print("\n".join([line for line in pretty_html.split("\n") if line.strip()]))
+            except Exception:
+                # If pretty printing fails, just print the raw HTML
+                print(html_string)
+        else:
+            LOGGER.error("Failed to render report: %s", report_name)
+            sys.exit(1)
+
+    except ValueError:
+        LOGGER.exception("Report not found")
+        sys.exit(1)
+    except Exception:
+        LOGGER.exception("Error rendering report %s", report_name)
+        sys.exit(1)
+
+
+# Main execution: Parse script_args and call render_report
+if not script_args:
+    LOGGER.error("Usage: godoo shell-script render_report <report_name> <record_id> [<record_id> ...] [--keep-base64]")
+    sys.exit(1)
+
+if len(script_args) < 2:
+    LOGGER.error("Missing arguments. Need at least report_name and one record_id")
+    sys.exit(1)
+
+# Check for --keep-base64 flag
+keep_base64_flag = "--keep-base64" in script_args
+filtered_args = [arg for arg in script_args if arg != "--keep-base64"]
+
+# Now extract report_name and record_ids from filtered args
+if len(filtered_args) < 2:
+    LOGGER.error("Missing arguments. Need at least report_name and one record_id")
+    sys.exit(1)
+
+report_name = filtered_args[0]
+record_ids = [int(rid) for rid in filtered_args[1:]]
+
+# render_report with replace_base64 being False if --keep-base64 was passed
+render_report(report_name, record_ids, replace_base64=not keep_base64_flag)

{godoo_cli-0.16.0 → godoo_cli-0.17.0}/src/godoo_cli/git/git_odoo_addons.py

@@ -69,9 +69,9 @@ def _merge_sources_into_repo(godoo_repo: GodooGitRepo) -> None:
         remote_name = f"merge_from_{merge_spec.url.split('/')[-1].replace('.git', '')}"
         remote = _ensure_remote(repo, remote_name, merge_spec.url)
         fetch_ref = merge_spec.ref
-        LOGGER.info("Merging ref %s from %s into %s", fetch_ref, merge_spec.url, godoo_repo.ref)
         remote.fetch(fetch_ref)
         merge_target = merge_spec.commit or f"{remote.name}/{merge_spec.branch or fetch_ref}"
+        LOGGER.info("Merging ref %s from %s into %s", fetch_ref, merge_spec.url, merge_target)
         repo.git.merge(
             merge_target,
             "--no-ff",

{godoo_cli-0.16.0 → godoo_cli-0.17.0}/src/godoo_cli/helpers/system.py

@@ -1,11 +1,16 @@
 """Helper functions around the host system."""
 
+import atexit
+import contextlib
 import datetime
 import logging
 import os
+import re
 import subprocess
+import sys
+import threading
 from pathlib import Path
-from typing import Any, Union
+from typing import Any, Optional, Union
 
 import click
 import requests
@@ -20,6 +25,100 @@ from . import cli as godoo_cli_helpers
 LOGGER = logging.getLogger(__name__)
 
 
+class RegexLogFilter(logging.Filter):
+    """A logging filter that only passes records whose logger name matches a regex pattern."""
+
+    def __init__(self, pattern: str) -> None:
+        """Compile and store the regex pattern used for filtering."""
+        super().__init__()
+        self._pattern = re.compile(pattern)
+
+    def filter(self, record: logging.LogRecord) -> bool:
+        """Return True only if the record's logger name matches the pattern."""
+        return bool(self._pattern.search(record.name))
+
+
+def _filter_thread_main(pattern: re.Pattern, r_fd: int, orig_fd: int) -> None:
+    """Read lines from r_fd and write only those matching pattern to orig_fd.
+
+    Lines that are part of a traceback block (starting with ``Traceback``) are
+    always emitted in full, regardless of the primary pattern, so that error
+    context is never silently dropped.
+    """
+    traceback_start_re = re.compile(rb"^Traceback ")
+    in_traceback = False
+
+    def should_emit(line_bytes: bytes) -> bool:
+        nonlocal in_traceback
+        if in_traceback:
+            # Tracebacks are delimited by an empty line; emit it, then leave traceback mode.
+            if not line_bytes.strip():
+                in_traceback = False
+            return True
+        if traceback_start_re.match(line_bytes):
+            in_traceback = True
+            return True
+        return bool(pattern.search(line_bytes.decode("utf-8", errors="replace")))
+
+    buf = b""
+    with os.fdopen(r_fd, "rb") as reader, os.fdopen(orig_fd, "wb") as writer:
+        while True:
+            chunk = reader.read(4096)
+            if not chunk:
+                # EOF - flush any unterminated line
+                if buf and should_emit(buf):
+                    writer.write(buf)
+                    writer.flush()
+                break
+            buf += chunk
+            while b"\n" in buf:
+                line, buf = buf.split(b"\n", 1)
+                if should_emit(line):
+                    writer.write(line + b"\n")
+                    writer.flush()
+
+
+def _install_fd_filter(pattern: re.Pattern) -> None:
+    """Redirect fd 1 and fd 2 through a pipe and filter each line by regex.
+
+    Saves the original stdout fd, creates a pipe, points fd 1 and fd 2 at the
+    pipe's write end, then starts a thread that reads from the read end
+    and forwards only lines matching *pattern* to the original stdout fd.
+    This intercepts output from both Python code and child subprocesses.
+    An atexit handler closes the write end and joins the thread so the last
+    lines are never lost.
+    """
+    orig_fd = os.dup(sys.stdout.fileno())  # save original stdout (e.g. fd 1 -> terminal)
+    r_fd, w_fd = os.pipe()
+    os.dup2(w_fd, 1)  # fd 1 now -> pipe write end
+    os.dup2(w_fd, 2)  # fd 2 now -> pipe write end
+    os.close(w_fd)
+
+    # Rebind Python's sys.stdout/stderr so buffered I/O goes to the new fd too
+    sys.stdout = os.fdopen(1, "w", buffering=1, closefd=False)
+    sys.stderr = sys.stdout
+
+    t = threading.Thread(
+        target=_filter_thread_main,
+        args=(pattern, r_fd, orig_fd),
+        daemon=True,
+        name="godoo-log-filter",
+    )
+    t.start()
+
+    def _cleanup() -> None:
+        # Flush Python-buffered output into the pipe, then close the write end.
+        # Closing fd 1 AND fd 2 sends EOF to the reader thread, letting it drain and exit.
+        with contextlib.suppress(Exception):
+            sys.stdout.flush()
+        for fd in (1, 2):
+            with contextlib.suppress(OSError):
+                os.close(fd)
+        t.join(timeout=10)
+
+    atexit.register(_cleanup)
+
+
 def run_cmd(command: str, **kwargs: dict[str, Any]) -> subprocess.CompletedProcess:
     """Runs command via subprocess.run."""
     LOGGER.debug("Running shell:\n%s", command)
@@ -40,8 +139,14 @@ def ensure_dotenv(varname: str) -> str:
     return var
 
 
-def set_logging(verbose: bool = False) -> None:
-    """Set the logging configuration according to passed arguments."""
+def set_logging(verbose: bool = False, log_filter: Optional[str] = None) -> None:
+    """Set the logging configuration according to passed arguments.
+
+    Args:
+        verbose: Enable DEBUG-level logging with rich tracebacks.
+        log_filter: Optional regex pattern; only log records whose logger name
+            matches the pattern will be emitted.
+    """
     if verbose:
         install_rich_traceback(suppress=[click, godoo_cli_helpers])
         logging.basicConfig(
@@ -68,6 +173,14 @@ def set_logging(verbose: bool = False) -> None:
             datefmt="%Y-%m-%d %H:%M:%S",
         )
 
+    if log_filter:
+        pattern = re.compile(log_filter)
+        regex_filter = RegexLogFilter(log_filter)
+        for handler in logging.root.handlers:
+            handler.addFilter(regex_filter)
+        _install_fd_filter(pattern)
+        LOGGER.debug("Log filter active: '%s'", log_filter)
+
 
 def download_file(url: str, save_path: Path, chunk_size: int = 128) -> None:
     """Download file from URL to specified path."""