translate_strings.py

#!/usr/bin/env python3
"""
translate_strings.py
Finds all Android locale strings.xml files under app/src/main/res/,
compares them to the source (values/strings.xml), translates any missing
strings via the Anthropic API, and writes the updated files back to disk.
Also writes /tmp/pr_body.md summarising what was changed for the PR.
"""

import os
import re
import sys
import json
import textwrap
import anthropic
from pathlib import Path
from lxml import etree

# ── Configuration ─────────────────────────────────────────────────────────────

SOURCE_DIR   = "app/src/main/res/values"
RES_BASE_DIR = "app/src/main/res"
PR_BODY_PATH = "/tmp/pr_body.md"

# Map Android locale folder suffix → human language name for the prompt
LOCALE_MAP = {
    "values-ar":     "Arabic",
    "values-zh-rTW": "Traditional Chinese (Taiwan)",
    "values-zh-rCN": "Simplified Chinese (Mainland China)",
    "values-fr":     "French",
    "values-de":     "German",
    "values-fa":     "Farsi (Persian)",
    "values-pa":     "Punjabi",
    "values-pl":     "Polish",
    "values-in":     "Indonesian",
    "values-es":     "Spanish",
    "values-sv":     "Swedish",
    "values-uk":     "Ukrainian",
    "values-ru":     "Russian",
    "values-tr":     "Turkish",
    "values-ja":     "Japanese",
    "values-ko":     "Korean",
    "values-hi":     "Hindi",
    "values-it":     "Italian",
    "values-pt-rBR": "Brazilian Portuguese",
}

# RTL languages that need android:textDirection="rtl" awareness (informational)
RTL_LOCALES = {"values-ar", "values-fa", "values-pa"}

BATCH_SIZE = 40   # strings per API call – keeps prompts manageable

# ── Helpers ───────────────────────────────────────────────────────────────────

def parse_strings(path: Path) -> dict[str, str]:
    """Return {name: text} for every translatable <string> in the file."""
    if not path.exists():
        return {}
    tree = etree.parse(str(path))
    result = {}
    for el in tree.getroot().findall("string"):
        name = el.get("name")
        translatable = el.get("translatable", "true")
        if name and translatable.lower() != "false":
            # Preserve inner XML (handles <b>, <i>, %1$s etc.)
            inner = (el.text or "") + "".join(
                etree.tostring(child, encoding="unicode") for child in el
            )
            result[name] = inner.strip()
    return result


def load_or_create_tree(path: Path):
    """Parse existing file or return a fresh <resources> tree."""
    if path.exists():
        return etree.parse(str(path))
    root = etree.Element("resources")
    root.addprevious(etree.Comment(" Auto-generated by translate_strings.py "))
    return etree.ElementTree(root)


def write_tree(tree, path: Path):
    path.parent.mkdir(parents=True, exist_ok=True)
    tree.write(
        str(path),
        encoding="utf-8",
        xml_declaration=True,
        pretty_print=True,
    )


def set_translated(tree, name: str, translated_text: str):
    """Insert or update a <string name="…"> element in the tree."""
    root = tree.getroot()
    existing = root.find(f'string[@name="{name}"]')
    if existing is not None:
        existing.text = translated_text
        return
    el = etree.SubElement(root, "string")
    el.set("name", name)
    el.text = translated_text


# ── Translation via Anthropic ─────────────────────────────────────────────────

def translate_batch(
    client: anthropic.Anthropic,
    language: str,
    batch: dict[str, str],
) -> dict[str, str]:
    """
    Send a batch of {name: english_text} to Claude and get back
    {name: translated_text}.
    Returns an empty dict on failure (strings will be skipped this run).
    """
    items_json = json.dumps(batch, ensure_ascii=False, indent=2)

    prompt = textwrap.dedent(f"""
        You are a professional mobile-app localisation expert.

        Translate the following Android string resource values from English into
        **{language}**.

        Rules:
        - Preserve ALL placeholder tokens exactly as-is: %1$s  %2$s  %d  %f  etc.
        - Preserve HTML tags exactly: <b>  </b>  <i>  </i>  <br/>  etc.
        - Preserve ampersand escapes: &amp;  &lt;  &gt;  \'  etc.
        - Do NOT translate the JSON keys (string resource names).
        - Do NOT add explanations or markdown — return ONLY valid JSON.
        - The app is a Litecoin cryptocurrency wallet called "Brainwallet".
          Keep "Brainwallet", "Litecoin", "LTC", "PIN", "QR" untranslated.
        - Use natural, friendly language suitable for a mobile finance app.

        Input JSON (keys are resource names, values are English strings):
        {items_json}

        Return a JSON object with the same keys and translated values.
    """).strip()

    try:
        message = client.messages.create(
            model="claude-opus-4-5",
            max_tokens=4096,
            messages=[{"role": "user", "content": prompt}],
        )
        raw = message.content[0].text.strip()
        # Strip possible ```json fences
        raw = re.sub(r"^```(?:json)?\s*", "", raw)
        raw = re.sub(r"\s*```$", "", raw)
        return json.loads(raw)
    except Exception as exc:
        print(f"  ⚠️  API/parse error for {language}: {exc}", file=sys.stderr)
        return {}


# ── Main ──────────────────────────────────────────────────────────────────────

def main():
    api_key = os.environ.get("ANTHROPIC_API_KEY")
    if not api_key:
        sys.exit("ERROR: ANTHROPIC_API_KEY environment variable not set.")

    client = anthropic.Anthropic(api_key=api_key)

    source_path = Path(SOURCE_DIR) / "strings.xml"
    if not source_path.exists():
        sys.exit(f"ERROR: Source file not found: {source_path}")

    source_strings = parse_strings(source_path)
    print(f"✅ Source: {len(source_strings)} translatable strings loaded.")

    pr_lines = [
        "## 🌍 Auto-translation summary\n",
        "| Language | New translations | File |",
        "|---|---|---|",
    ]

    for locale_dir, language in LOCALE_MAP.items():
        target_path = Path(RES_BASE_DIR) / locale_dir / "strings.xml"
        existing     = parse_strings(target_path)
        missing      = {
            k: v for k, v in source_strings.items()
            if k not in existing or not existing[k].strip()
        }

        if not missing:
            print(f"  ✔  {language}: nothing to translate.")
            pr_lines.append(f"| {language} | 0 (already complete) | `{target_path}` |")
            continue

        print(f"  🔄  {language}: {len(missing)} strings to translate …")
        tree = load_or_create_tree(target_path)

        translated_count = 0
        keys = list(missing.keys())
        for i in range(0, len(keys), BATCH_SIZE):
            chunk_keys = keys[i : i + BATCH_SIZE]
            batch      = {k: missing[k] for k in chunk_keys}
            result     = translate_batch(client, language, batch)

            for name, text in result.items():
                if name in batch:          # sanity-check key came from our batch
                    set_translated(tree, name, text)
                    translated_count += 1

        write_tree(tree, target_path)
        print(f"  ✅  {language}: {translated_count} strings written → {target_path}")
        pr_lines.append(f"| {language} | {translated_count} | `{target_path}` |")

    # Write PR body
    pr_body = "\n".join(pr_lines) + "\n\n---\n*Generated automatically by translate_strings.py*\n"
    Path(PR_BODY_PATH).write_text(pr_body, encoding="utf-8")
    print(f"\n📄 PR body written to {PR_BODY_PATH}")
    print("🎉 Translation run complete.")


if __name__ == "__main__":
    main()