gettext-tstrings 0.1.0a1__py3-none-any.whl

gettext_tstrings/__init__.py

@@ -0,0 +1,43 @@
+"""Gettext and extraction-tool integration for Python t-strings."""
+
+from .core import (
+    CompiledTemplate,
+    Translations,
+    Translator,
+    compile_template,
+    get_translations,
+    gettext,
+    ngettext,
+    npgettext,
+    ntr,
+    pgettext,
+    set_translations,
+    tr,
+    use_translations,
+)
+from .errors import InvalidTemplateError, InvalidTranslationError, TStringError
+from .lazy import LazyString, lazy_gettext, lazy_pgettext
+
+__all__ = [
+    "CompiledTemplate",
+    "InvalidTemplateError",
+    "InvalidTranslationError",
+    "LazyString",
+    "TStringError",
+    "Translations",
+    "Translator",
+    "compile_template",
+    "get_translations",
+    "gettext",
+    "lazy_gettext",
+    "lazy_pgettext",
+    "ngettext",
+    "npgettext",
+    "ntr",
+    "pgettext",
+    "set_translations",
+    "tr",
+    "use_translations",
+]
+
+__version__ = "0.1.0a1"

gettext_tstrings/_patterns.py

@@ -0,0 +1,93 @@
+"""Shared brace-pattern parsing helpers."""
+
+from __future__ import annotations
+
+import keyword
+from dataclasses import dataclass
+from functools import lru_cache
+from string import Formatter
+
+from .errors import InvalidTranslationError
+
+MARKER_COMMENT = "gettext-tstrings"
+_FORMATTER = Formatter()
+
+
+@dataclass(frozen=True, slots=True)
+class Pattern:
+    """A validated, cached translation pattern."""
+
+    chunks: tuple[tuple[str, str | None], ...]
+    fields: frozenset[str]
+
+
+def escape_literal(text: str) -> str:
+    """Escape braces in literal t-string segments for a brace-format pattern."""
+    return text.replace("{", "{{").replace("}", "}}")
+
+
+def validate_name(name: str) -> str:
+    """Return a safe, simple placeholder name or raise."""
+    normalized = name.strip()
+    if not normalized.isidentifier() or keyword.iskeyword(normalized):
+        raise InvalidTranslationError(
+            f"placeholder {name!r} is not a simple Python identifier",
+        )
+    return normalized
+
+
+@lru_cache(maxsize=4096)
+def parse_pattern(pattern: str) -> Pattern:
+    """Parse and cache a restricted brace pattern.
+
+    Only bare named placeholders are accepted. Formatting and conversion are
+    controlled by the source t-string and never by a catalog translation.
+    """
+    chunks: list[tuple[str, str | None]] = []
+    fields: set[str] = set()
+    try:
+        for literal, field_name, format_spec, conversion in _FORMATTER.parse(pattern):
+            if field_name is None:
+                chunks.append((literal, None))
+                continue
+
+            name = validate_name(field_name)
+            if format_spec or conversion:
+                raise InvalidTranslationError(
+                    f"translation placeholder {{{name}}} must not add "
+                    "a conversion or format specifier",
+                )
+            fields.add(name)
+            chunks.append((literal, name))
+    except ValueError as exc:
+        raise InvalidTranslationError(f"invalid translation pattern: {exc}") from exc
+    return Pattern(tuple(chunks), frozenset(fields))
+
+
+def require_fields(
+    *,
+    required: frozenset[str],
+    allowed: frozenset[str],
+    actual: frozenset[str],
+    label: str = "translation",
+) -> None:
+    """Require all necessary fields and reject unknown ones.
+
+    Placeholder occurrence counts are deliberately unrestricted: repeating a
+    known value can be grammatically necessary in a target language.
+    """
+    missing = required - actual
+    unexpected = actual - allowed
+    if not missing and not unexpected:
+        return
+
+    # 非ASCIIのホモグリフ名はASCII名と見分けがつかないため、
+    # 各名前を ascii() で可視化してから並べる。
+    details: list[str] = []
+    if missing:
+        details.append(f"missing [{', '.join(ascii(n) for n in sorted(missing))}]")
+    if unexpected:
+        details.append(f"unexpected [{', '.join(ascii(n) for n in sorted(unexpected))}]")
+    raise InvalidTranslationError(
+        f"{label} placeholders do not match source: {', '.join(details)}",
+    )

gettext_tstrings/checkers.py

@@ -0,0 +1,42 @@
+"""Catalog checker for messages emitted by the t-string extractor."""
+
+from __future__ import annotations
+
+from collections.abc import Iterable
+
+from babel.messages.catalog import Catalog, Message, TranslationError
+
+from ._patterns import MARKER_COMMENT, parse_pattern, require_fields
+from .errors import InvalidTranslationError
+
+
+def _strings(value: str | Iterable[str] | None) -> tuple[str, ...]:
+    if value is None:
+        return ()
+    if isinstance(value, str):
+        return (value,)
+    return tuple(value)
+
+
+def check_tstring(catalog: Catalog | None, message: Message) -> None:
+    """Validate placeholder integrity for extracted t-string messages."""
+    del catalog
+    if MARKER_COMMENT not in message.auto_comments:
+        return
+
+    source_patterns = _strings(message.id)
+    try:
+        source_fields = [parse_pattern(pattern).fields for pattern in source_patterns]
+        allowed = frozenset().union(*source_fields)
+        required = frozenset.intersection(*source_fields)
+
+        for translation in _strings(message.string):
+            if not translation:
+                continue
+            require_fields(
+                required=required,
+                allowed=allowed,
+                actual=parse_pattern(translation).fields,
+            )
+    except InvalidTranslationError as exc:
+        raise TranslationError(str(exc)) from exc