fix(locales): preserve valid best-effort entries

Author: kingpanther13

scripts/generate_locales.py

@@ -64,6 +64,29 @@
 _FEATURE_KEY_RE = re.compile(r"^features\.([a-z0-9_]+)\.label$")
 
 
+def _validate_best_effort_messages(
+    value: object, *, context: str, path: Path
+) -> dict[str, str]:
+    """Drop invalid entries while retaining valid best-effort translations."""
+    if not isinstance(value, dict):
+        return _validate_string_map(value, context=context)
+
+    result: dict[str, str] = {}
+    for key, text in value.items():
+        try:
+            result.update(_validate_string_map({key: text}, context=context))
+        except ValueError as exc:
+            entry = (
+                f"{context}.{key}" if isinstance(key, str) else f"{context}[{key!r}]"
+            )
+            print(
+                f"::warning file={path}::Ignoring invalid best-effort locale "
+                f"entry {entry}: {exc}",
+                file=sys.stderr,
+            )
+    return result
+
+
 def load_catalogs() -> dict[str, dict[str, str]]:
     """Every canonical catalog's ``messages`` section, keyed by locale code.
 
@@ -77,9 +100,14 @@ def load_catalogs() -> dict[str, dict[str, str]]:
             data = json.loads(path.read_text(encoding="utf-8"))
             if not isinstance(data, dict):
                 raise ValueError(f"{path.name} must contain a JSON object")
-            catalogs[path.stem] = _validate_string_map(
-                data.get("messages"), context=f"{path.name}.messages"
-            )
+            context = f"{path.name}.messages"
+            messages = data.get("messages")
+            if is_best_effort_locale(path.stem):
+                catalogs[path.stem] = _validate_best_effort_messages(
+                    messages, context=context, path=path
+                )
+            else:
+                catalogs[path.stem] = _validate_string_map(messages, context=context)
         except (OSError, json.JSONDecodeError, ValueError) as exc:
             if not is_best_effort_locale(path.stem):
                 raise

src/ha_mcp/settings_ui/_i18n.py

@@ -96,7 +96,7 @@ def _load_catalog_file(path: Path) -> dict[str, Any]:
     """Load and validate one catalog without coupling it to its siblings."""
     try:
         raw = json.loads(path.read_text(encoding="utf-8"))
-    except (OSError, json.JSONDecodeError) as exc:
+    except (OSError, UnicodeError, json.JSONDecodeError) as exc:
         raise ImportError(f"Invalid settings UI locale catalog: {path}") from exc
     if not isinstance(raw, dict):
         raise ValueError(f"Locale catalog {path} must contain a JSON object")

tests/src/unit/test_generate_locales.py

@@ -50,6 +50,32 @@ def test_invalid_best_effort_catalog_warns_and_uses_english_fallback(
     assert "best-effort locale tlh" in stderr
 
 
+def test_invalid_best_effort_entries_warn_and_preserve_valid_messages(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+    capsys: pytest.CaptureFixture[str],
+) -> None:
+    locales = tmp_path / "locales"
+    locales.mkdir()
+    (locales / "en.json").write_text(
+        json.dumps({"messages": {"valid": "English", "blank": "Fallback"}}),
+        encoding="utf-8",
+    )
+    (locales / "tlh.json").write_text(
+        json.dumps({"messages": {"valid": "Qapla'", "blank": "", "non_string": 3}}),
+        encoding="utf-8",
+    )
+    monkeypatch.setattr(generate_locales, "LOCALES_DIR", locales)
+
+    catalogs = generate_locales.load_catalogs()
+
+    assert catalogs["tlh"] == {"valid": "Qapla'"}
+    stderr = capsys.readouterr().err
+    assert "Ignoring invalid best-effort locale entry" in stderr
+    assert "tlh.json.messages.blank" in stderr
+    assert "tlh.json.messages.non_string" in stderr
+
+
 class TestResolveText:
     def test_override_order_is_flavor_then_features_then_addon(self) -> None:
         messages = {

tests/src/unit/test_settings_ui_i18n.py

@@ -107,9 +107,12 @@ def test_invalid_best_effort_catalog_warns_without_blocking_other_locales(
     assert "Skipping best-effort locale tlh" in caplog.text
 
 
-def test_invalid_strict_catalog_still_blocks_loading(tmp_path: Path) -> None:
+@pytest.mark.parametrize("payload", [b"{not json", b"\xff"], ids=["json", "utf8"])
+def test_invalid_strict_catalog_still_blocks_loading(
+    tmp_path: Path, payload: bytes
+) -> None:
     _write_catalog(tmp_path, "en", native_name="English", messages={"a": "A"})
-    (tmp_path / "de.json").write_text("{not json", encoding="utf-8")
+    (tmp_path / "de.json").write_bytes(payload)
 
     with pytest.raises(ImportError, match=r"de\.json"):
         load_catalogs(tmp_path)