o-update-po

#!/usr/bin/env python3
"""Tool to update translation files in an Odoo codebase"""

import argparse
import glob
import os
import subprocess
import sys

from pathlib import Path

from utils.terminal_logger import TerminalLogger, log


def update_translation_files(modules, lang_codes, addons_path, base_i18n_path, tl):
    log(f"💬 {tl.WHITE}{tl.B}Update Translations{tl.NOFORMAT}\n")

    log(f"Updating translations for modules {tl.B}{f'{tl.B_END}, {tl.B}'.join(modules)}{tl.B_END} ...")
    log("│")

    success = failure =False

    for i, module in enumerate(modules, start=1):
        last_module = i == len(modules)

        tree_prepend = "└──" if last_module else "├──"
        log(f"{tree_prepend} {tl.B}{module}{tl.B_END}")

        i18n_path = os.path.join(addons_path, module, "i18n")
        if module == "base":
            i18n_path = base_i18n_path
        if not os.path.exists(i18n_path):
            tree_prepend = "    └──" if last_module else "│   └──"
            log(f"{tree_prepend} {tl.BR_BLACK}No translations found!{tl.NOFORMAT}")
            continue

        po_files = sorted(filter(lambda f: f.endswith(".po"), os.listdir(i18n_path)))
        if lang_codes:
            po_files = filter(lambda po: po[:-2] in lang_codes, po_files)
        for j, po_file in enumerate(po_files, start=1):
            last_po_file = j == len(po_files)

            if last_module and last_po_file:
                tree_prepend = "    └──"
            elif last_po_file:
                tree_prepend = "│   └──"
            elif last_module:
                tree_prepend = "    ├──"
            else:
                tree_prepend = "│   ├──"

            po_file_path = os.path.join(i18n_path, po_file)
            pot_file_path = os.path.join(i18n_path, f"{module}.pot")

            result = subprocess.run(
                [
                    "msgmerge",
                    "--no-fuzzy-matching",
                    "-q",
                    po_file_path,
                    pot_file_path,
                ],
                capture_output=True,
            )
            if result.returncode:
                failure = True
                log(f"{tree_prepend} {tl.RED}{tl.B}!{tl.B_END} Updating {tl.U}{po_file_path}{tl.U_END} failed during {tl.I}msgmerge{tl.I_END}!{tl.NOFORMAT}")
                log(f"\n{result.stderr.decode()}\n")
                continue

            result = subprocess.run(
                [
                    "msgattrib",
                    "--no-fuzzy",
                    "--no-obsolete",
                    "-o",
                    po_file_path,
                ],
                input=result.stdout,
            )

            if result.returncode:
                failure = True
                log(f"{tree_prepend} {tl.RED}{tl.B}!{tl.B_END} Updating {tl.U}{po_file_path}{tl.U_END} failed during {tl.I}msgattrib{tl.I_END}!{tl.NOFORMAT}")
                log(f"\n{result.stderr.decode()}\n")
            else:
                success = True
                log(f"{tree_prepend} Updated {tl.U}{po_file_path}{tl.U_END} ✔️")

        if not last_module:
            log("│")

    if not success and failure:
        log(f"\n{tl.RED}{tl.B}!{tl.B_END} All translation files failed to update ...{tl.NOFORMAT}")
    elif success and failure:
        log(f"\n{tl.YELLOW}{tl.B}!{tl.B_END} Some translation files were updated correctly, while others failed ...{tl.NOFORMAT}")
    elif success and not failure:
        log(f"\n{tl.GREEN}All translation files were updated correctly!{tl.NOFORMAT} 💪")


def update_modules_translations(modules_per_path, lang_codes, base_i18n_path, tl):
    for modules_list, modules_path in modules_per_path:
        if not modules_list:
            continue

        update_translation_files(modules_list, lang_codes, modules_path, base_i18n_path, tl)


if __name__ == "__main__":
    parser = argparse.ArgumentParser(
        description="Update Odoo translation files (.po) according to a new version of its .pot file."
    )
    parser.add_argument("-m", "--modules", help="The list of modules to update (comma-separated)")
    parser.add_argument("-l", "--languages", help="The language codes to export (e.g. en,fr_BE) (default: all languages)")
    parser.add_argument("-c", "--community-path", default="odoo", help="The relative path to your Odoo Community repo (default: odoo)")
    parser.add_argument("-e", "--enterprise-path", default="enterprise", help="The relative path to your Odoo Enterprise repo (default: enterprise)")
    parser.add_argument("--no-color", action="store_true", help="Disable colors in the terminal")
    args = parser.parse_args()

    tl = TerminalLogger(args.no_color)

    log(f"🟣 {tl.MAGENTA}{tl.B}Odoo PO Update{tl.NOFORMAT}\n")

    base_i18n_path = os.path.join(Path(args.community_path).resolve(), "odoo/addons/base/i18n")
    community_modules_path = os.path.join(Path(args.community_path).resolve(), "addons")
    enterprise_modules_path = Path(args.enterprise_path).resolve()

    community_modules = {
        os.path.basename(os.path.dirname(f))
        for f in glob.glob(os.path.join(community_modules_path, "*/__manifest__.py"))
    }
    community_modules.add("base")

    enterprise_modules = {
        os.path.basename(os.path.dirname(f))
        for f in glob.glob(os.path.join(enterprise_modules_path, "*/__manifest__.py"))
    }

    if args.modules == "community":
        modules = community_modules
    elif args.modules == "enterprise":
        modules = enterprise_modules
    elif args.modules:
        modules = set(args.modules.split(","))
    else:
        log(f"{tl.RED}{tl.B}!{tl.B_END} No modules provided to update! Terminating the process ...{tl.NOFORMAT}")
        sys.exit(1)

    modules_per_path = [
        (sorted(listed_modules & modules), path)
        for listed_modules, path in [
            (community_modules, community_modules_path),
            (enterprise_modules, enterprise_modules_path),
        ]
    ]
    
    lang_codes = set(args.languages.split(",")) if args.languages else None

    update_modules_translations(modules_per_path, lang_codes, base_i18n_path, tl)