langflow/scripts/gp/extract_backend_strings.py

"""Extract translatable strings from Langflow component classes.

Walks the lfx.components package, reads class-level display_name/description
and field-level display_names directly from component class definitions
(no running server needed), and writes a flat GP-compatible JSON file.

Output format — hybrid key: human-readable path + content-hash suffix:
    "components.chatinput.display_name.a1b2c3d4": "Chat Input"
    "components.chatinput.description.f9e8d7c6": "Get chat inputs from the Playground."
    "components.chatinput.inputs.input_value.display_name.12345678": "Input Text"
    "components.chatinput.outputs.message.display_name.abcdef01": "Chat Message"

The norm_name is the component registry key lowercased with spaces removed.
The 8-char suffix is SHA-256(english_value)[:8].  When an English string
changes, its hash changes, the old key is orphaned, and GP issues a fresh
translation for the new key on the next upload/download cycle.

Usage:
    # From repo root with the backend virtualenv active:
    python scripts/gp/extract_backend_strings.py

    # Check only (exit 1 if en.json would change — use in CI):
    python scripts/gp/extract_backend_strings.py --check
"""

from __future__ import annotations

import argparse
import importlib
import json
import pkgutil
import sys
from pathlib import Path

OUTPUT_PATH = Path(__file__).parent.parent.parent / "src/backend/base/langflow/locales/en.json"
STARTER_PROJECTS_DIR = Path(__file__).parent.parent.parent / "src/backend/base/langflow/initial_setup/starter_projects"


def collect_strings() -> dict[str, str]:
    """Walk lfx.components and extract all translatable display_name strings."""
    from langflow.utils.i18n_keys import component_field_key as _component_field_key
    from langflow.utils.i18n_keys import normalize_component_key as _normalize_component_key
    from langflow.utils.i18n_keys import safe_flow_key as _safe_key

    try:
        import lfx.components as components_pkg
    except ImportError:
        print("ERROR: Could not import lfx.components. Run this script from inside the backend virtualenv.")
        sys.exit(1)

    flat: dict[str, str] = {}
    seen_names: set[str] = set()

    for _finder, modname, _ispkg in pkgutil.walk_packages(components_pkg.__path__, components_pkg.__name__ + "."):
        if "deactivated" in modname:
            continue

        try:
            module = importlib.import_module(modname)
        except Exception as e:  # noqa: BLE001
            print(f"  SKIP {modname}: {e}")
            continue

        for cls in vars(module).values():
            if not isinstance(cls, type):
                continue
            # Only process classes defined in this module (avoid re-processing imports)
            if getattr(cls, "__module__", None) != modname:
                continue
            # Component marker set by the base class
            if not getattr(cls, "code_class_base_inheritance", None):
                continue
            display_name = getattr(cls, "display_name", None)
            # Skip if not a plain string (e.g. @property descriptors on the class)
            if not isinstance(display_name, str) or not display_name:
                continue

            # Use cls.name if defined (stable identifier used in API), else class name
            component_key = getattr(cls, "name", None) or cls.__name__
            if not isinstance(component_key, str):
                component_key = cls.__name__

            if component_key in seen_names:
                continue
            seen_names.add(component_key)

            norm_key = _normalize_component_key(component_key)

            # Tier 1 — component-level
            flat[_component_field_key(norm_key, "display_name", display_name)] = display_name
            # If description is a @property, getattr on the class returns the descriptor
            # object (not a string).  Fall back to _base_description when that happens.
            raw_desc = cls.__dict__.get("description")
            if isinstance(raw_desc, property):
                description = getattr(cls, "_base_description", "") or ""
            else:
                description = getattr(cls, "description", "") or ""
            if isinstance(description, str) and description:
                flat[_component_field_key(norm_key, "description", description)] = description

            # Tier 2 — input field display_names, info, and placeholder
            for inp in getattr(cls, "inputs", []) or []:
                field_display = getattr(inp, "display_name", None)
                field_name = getattr(inp, "name", None)
                field_info = getattr(inp, "info", None)
                field_placeholder = getattr(inp, "placeholder", None)
                if isinstance(field_name, str) and field_name:
                    if isinstance(field_display, str) and field_display:
                        flat[_component_field_key(norm_key, f"inputs.{field_name}.display_name", field_display)] = (
                            field_display
                        )
                    if isinstance(field_info, str) and field_info:
                        flat[_component_field_key(norm_key, f"inputs.{field_name}.info", field_info)] = field_info
                    if isinstance(field_placeholder, str) and field_placeholder:
                        flat[_component_field_key(norm_key, f"inputs.{field_name}.placeholder", field_placeholder)] = (
                            field_placeholder
                        )

            # Tier 2 — output display_names and info
            for out in getattr(cls, "outputs", []) or []:
                out_display = getattr(out, "display_name", None)
                out_name = getattr(out, "name", None)
                out_info = getattr(out, "info", None)
                if isinstance(out_name, str) and out_name:
                    if isinstance(out_display, str) and out_display:
                        flat[_component_field_key(norm_key, f"outputs.{out_name}.display_name", out_display)] = (
                            out_display
                        )
                    if isinstance(out_info, str) and out_info:
                        flat[_component_field_key(norm_key, f"outputs.{out_name}.info", out_info)] = out_info

    # Tier 3 — starter project names & descriptions (auto-discovered from JSON files)
    starter_count = 0
    for project_file in sorted(STARTER_PROJECTS_DIR.glob("*.json")):
        try:
            with project_file.open(encoding="utf-8") as f:
                project = json.load(f)
        except Exception:  # noqa: BLE001, S112
            continue
        name = project.get("name")
        description = project.get("description", "")
        if name and isinstance(name, str):
            key = _safe_key(name)
            flat[f"starter_flows.{key}.name"] = name
            starter_count += 1
            if description and isinstance(description, str):
                flat[f"starter_flows.{key}.description"] = description

    print(f"Found {starter_count} starter project(s) in {STARTER_PROJECTS_DIR.name}/")

    # Tier 4 — note node descriptions in starter projects (keys baked by bake_note_keys.py)
    note_count = 0
    missing_keys: list[str] = []
    for project_file in sorted(STARTER_PROJECTS_DIR.glob("*.json")):
        try:
            with project_file.open(encoding="utf-8") as f:
                project = json.load(f)
        except Exception:  # noqa: BLE001, S112
            continue
        nodes = project.get("data", {}).get("nodes", [])
        for node in nodes:
            if node.get("type") != "noteNode":
                continue
            node_data = node.get("data", {}).get("node", {})
            i18n_key = node_data.get("i18n_key")
            description = node_data.get("description", "")
            if not i18n_key:
                missing_keys.append(project_file.name)
                continue
            if description and isinstance(description, str):
                flat[i18n_key] = description
                note_count += 1

    if missing_keys:
        print(
            f"WARNING: {len(missing_keys)} noteNode(s) are missing i18n_key. "
            "Run scripts/gp/bake_note_keys.py to assign keys."
        )
    print(f"Found {note_count} note node(s) across starter projects.")

    # Shared tool-mode output — injected dynamically on every component when tool_mode is
    # enabled, so it's never part of any component's static output list.  Uses the sentinel
    # norm "_toolmode" so the runtime translator can look it up with a single shared key.
    # Constants are inlined (not imported from lfx.base) so this script can run without
    # the full lfx package installed, matching the pattern used in bake_note_keys.py.
    _tool_output_name = "component_as_tool"
    _tool_output_display_name = "Toolset"
    flat[_component_field_key("_toolmode", f"outputs.{_tool_output_name}.display_name", _tool_output_display_name)] = (
        _tool_output_display_name
    )

    return dict(sorted(flat.items()))


def main() -> None:
    parser = argparse.ArgumentParser(description="Extract backend component strings to locales/en.json")
    parser.add_argument(
        "--check",
        action="store_true",
        help="Diff mode: exit 1 if en.json would change (use in CI)",
    )
    args = parser.parse_args()

    print("Scanning lfx.components for translatable strings...")
    strings = collect_strings()
    print(
        f"Found {len(strings)} translatable keys across "
        f"{sum(1 for k in strings if k.endswith('.display_name') and '.inputs.' not in k and '.outputs.' not in k)}"
        " components."
    )

    new_content = json.dumps(strings, ensure_ascii=False, indent=2) + "\n"

    if args.check:
        if OUTPUT_PATH.exists():
            existing = OUTPUT_PATH.read_text(encoding="utf-8")
            if existing == new_content:
                print("OK: locales/en.json is up to date.")
                sys.exit(0)
            else:
                print("FAIL: locales/en.json is out of sync. Run extract_backend_strings.py to update it.")
                sys.exit(1)
        else:
            print("FAIL: locales/en.json does not exist. Run extract_backend_strings.py to create it.")
            sys.exit(1)

    OUTPUT_PATH.parent.mkdir(parents=True, exist_ok=True)
    OUTPUT_PATH.write_text(new_content, encoding="utf-8")
    print(f"Written to {OUTPUT_PATH}")


if __name__ == "__main__":
    main()