trezor-firmware/core/tools/translations/validate_strings.py

from __future__ import annotations

import json
from dataclasses import dataclass
import sys

from helpers import HERE, TRANSLATIONS_DIR


@dataclass
class TooLong:
    key: str
    value: str
    lines: list[str]
    en: str
    lines_en: list[str]

    def __str__(self) -> str:
        return f"{self.key}: {self.value} --- {self.en} ({len(self.lines)} / {len(self.lines_en)})"


altcoins = [
    "binance",
    "cardano",
    "ethereum",
    "eos",
    "monero",
    "nem",
    "stellar",
    "solana",
    "ripple",
    "tezos",
]


def get_value(key: str) -> str:
    if "title" in key:
        return "title,1"
    if "button" in key:
        return "button,1"
    return "text,1"


# rules = {k: get_value(k) for k in translation_content}
# rules_file.write_text(json.dumps(rules, indent=2, sort_keys=True))

SCREEN_TEXT_WIDTHS = {"TT": 240 - 12, "TS3": 128}

FONT_MAPPING = {
    "TT": {
        "title": "bold",
        "text": "normal",
        "bold": "bold",
        "button": "bold",
    },
    "TS3": {
        "title": "bold",
        "text": "normal",
        "bold": "bold",
        "button": "normal",
    },
}

DEVICES = ["TT", "TS3"]

FONTS_FILE = HERE / "font_widths.json"

FONTS: dict[str, dict[str, dict[str, int]]] = json.loads(FONTS_FILE.read_text())


def will_fit(text: str, type: str, device: str, lines: int) -> bool:
    needed_lines = get_needed_lines(text, type, device)
    return needed_lines <= lines


def get_needed_lines(text: str, type: str, device: str) -> int:
    return len(assemble_lines(text, type, device))


# def assemble_lines(text: str, type: str, device: str) -> list[str]:
#     space_width = get_text_width(" ", type, device)
#     words = text.split(" ")
#     current_line_length = 0
#     current_line = []
#     assembled_lines: list[str] = []

#     screen_width = SCREEN_TEXT_WIDTHS[device]

#     for word in words:
#         word_width = get_text_width(word, type, device)
#         if current_line_length + word_width <= screen_width:
#             current_line.append(word)
#             current_line_length += word_width + space_width
#         else:
#             assembled_lines.append(" ".join(current_line))
#             current_line = [word]
#             current_line_length = word_width + space_width

#     assembled_lines.append(" ".join(current_line))
#     return assembled_lines


def assemble_lines(text: str, type: str, device: str) -> list[str]:
    space_width = get_text_width(" ", type, device)
    words = text.replace("\r", "\n").split(" ")  # Splitting explicitly by space
    current_line_length = 0
    current_line = []
    assembled_lines: list[str] = []

    screen_width = SCREEN_TEXT_WIDTHS[device]

    for word in words:
        segments = word.split("\n")
        for i, segment in enumerate(segments):
            if segment:
                segment_width = get_text_width(segment, type, device)
                if current_line_length + segment_width <= screen_width:
                    current_line.append(segment)
                    current_line_length += segment_width + space_width
                else:
                    assembled_lines.append(" ".join(current_line))
                    current_line = [segment]
                    current_line_length = segment_width + space_width
            # If this is not the last segment, add a newline
            if i < len(segments) - 1:
                assembled_lines.append(" ".join(current_line))
                current_line = []
                current_line_length = 0

    if current_line:  # Append the last line if it's not empty
        assembled_lines.append(" ".join(current_line))

    return assembled_lines


def fill_line_with_underscores(lines: list[str], type: str, device: str) -> list[str]:
    filled_lines: list[str] = []
    screen_width = SCREEN_TEXT_WIDTHS[device]

    for line in lines:
        line_width = get_text_width(line, type, device)
        while line_width < screen_width:
            line += "_"
            line_width = get_text_width(line, type, device)
        filled_lines.append(line[:-1])

    return filled_lines


def print_lines(lines: list[str]) -> None:
    for line in lines:
        print(line)


def get_text_width(text: str, type: str, device: str) -> int:
    font = FONT_MAPPING[device][type]
    widths = FONTS[device][font]
    return sum(widths.get(c, 8) for c in text)


def check(language: str) -> list[TooLong]:
    en_file = TRANSLATIONS_DIR / "en.json"
    en_content = json.loads(en_file.read_text())["translations"]

    translation_file = TRANSLATIONS_DIR / f"{language}.json"
    rules_file = HERE / "rules.json"
    rules_content = json.loads(rules_file.read_text())

    translation_content = json.loads(translation_file.read_text())["translations"]
    translation_content = {
        k: v.replace(" (TODO)", "") for k, v in translation_content.items()
    }
    translation_content = {
        k: v.replace(" (TOO LONG)", "") for k, v in translation_content.items()
    }

    wrong: dict[str, TooLong] = {}

    # new_rules: dict[str, str] = {}

    for k, v in list(translation_content.items())[:]:
        if k.split("__")[0] in altcoins:
            continue
        if k.split("__")[0] == "plurals":
            continue

        rule = rules_content.get(k)
        if not rule:
            print(f"Missing rule for {k}")
            continue
        type, lines = rule.split(",")
        lines = int(lines)

        # most_needed_lines = 0

        for model in DEVICES:
            if model == "TT" and k.startswith("tutorial"):
                continue

            if not will_fit(v, type, model, lines):
                too_long = TooLong(
                    k,
                    v,
                    assemble_lines(v, type, model),
                    en_content[k],
                    assemble_lines(en_content[k], type, model),
                )
                wrong[k] = too_long

    for _, too_long in wrong.items():
        print(too_long)

    print(len(wrong))

    return list(wrong.values())


def test() -> None:
    def test_fits_exactly(text: str, type: str, device: str, lines: int) -> None:
        assert not will_fit(text, type, device, lines - 1)
        assert will_fit(text, type, device, lines)

    for model in DEVICES:
        assert will_fit("Hello world", "title", model, 2)
        assert will_fit("Hello world", "title", model, 1)
        assert will_fit("By continuing you agree", "text", model, 1)
        assert not will_fit("Confirming a transaction", "text", model, 1)
        assert will_fit("Confirming a transaction", "text", model, 2)
        assert will_fit("Loading private seed is not recommended.", "text", model, 2)
        assert will_fit("CONFIRM TRANSACTION", "title", model, 1)
        assert not will_fit("RECEIVE ADDRESS (MULTISIG)", "title", model, 1)
        test_fits_exactly(
            "I have\nfour\nlines\rhere",
            "text",
            model,
            4,
        )

    assert will_fit("Choose level of details", "text", "TT", 1)
    test_fits_exactly(
        "Do you really want to enforce strict safety checks (recommended)?",
        "text",
        "TT",
        4,
    )


if __name__ == "__main__":
    lang = "de"
    if len(sys.argv) > 1:
        lang = sys.argv[1]

    test()
    check(lang)