fastapi-rosetta 0.1.0__py3-none-any.whl

fastapi_rosetta/__init__.py

@@ -0,0 +1,20 @@
+from __future__ import annotations
+
+from .conf import (
+    RosettaConfig,
+    configure,
+    get_settings,
+    reset_settings,
+    update_settings,
+)
+from .routers import mount_static, router
+
+__all__ = [
+    "RosettaConfig",
+    "configure",
+    "get_settings",
+    "mount_static",
+    "reset_settings",
+    "router",
+    "update_settings",
+]

fastapi_rosetta/access.py

@@ -0,0 +1,104 @@
+from __future__ import annotations
+
+import importlib
+from collections.abc import Callable
+from typing import Any, cast
+
+from .conf import get_settings
+
+AccessControl = Callable[[object], bool]
+LanguageAccessControl = Callable[[object, str], bool]
+
+
+def can_translate(user: object) -> bool:
+    return get_access_control_function()(user)
+
+
+def can_translate_language(
+    user: object,
+    language_code: str,
+) -> bool:
+    settings = get_settings()
+
+    if not settings.language_groups:
+        return can_translate(user)
+
+    return get_language_access_control_function()(
+        user,
+        language_code,
+    )
+
+
+def get_access_control_function() -> AccessControl:
+    settings = get_settings()
+
+    access_function = settings.access_control_function
+
+    if access_function is None:
+        return allow_all
+
+    if callable(access_function):
+        return cast(
+            AccessControl,
+            access_function,
+        )
+
+    if isinstance(access_function, str):
+        module_name, func_name = access_function.rsplit(".", 1)
+
+        module = importlib.import_module(module_name)
+
+        return cast(
+            AccessControl,
+            getattr(module, func_name),
+        )
+
+    raise TypeError(
+        "access_control_function must be " "callable, import path string or None."
+    )
+
+
+def get_language_access_control_function() -> LanguageAccessControl:
+    settings = get_settings()
+
+    access_function: Any = getattr(
+        settings,
+        "language_access_control_function",
+        None,
+    )
+
+    if access_function is None:
+        return default_language_access_control
+
+    if callable(access_function):
+        return cast(
+            LanguageAccessControl,
+            access_function,
+        )
+
+    if isinstance(access_function, str):
+        module_name, func_name = access_function.rsplit(".", 1)
+
+        module = importlib.import_module(module_name)
+
+        return cast(
+            LanguageAccessControl,
+            getattr(module, func_name),
+        )
+
+    raise TypeError(
+        "language_access_control_function "
+        "must be callable, import path string "
+        "or None."
+    )
+
+
+def allow_all(user: object) -> bool:
+    return True
+
+
+def default_language_access_control(
+    user: object,
+    language_code: str,
+) -> bool:
+    return can_translate(user)

fastapi_rosetta/conf/__init__.py

@@ -0,0 +1,130 @@
+from __future__ import annotations
+
+from threading import Lock
+from typing import Any
+
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class RosettaConfig(BaseModel):
+    model_config = ConfigDict(
+        extra="forbid",
+        validate_assignment=True,
+    )
+
+    messages_per_page: int = 10
+
+    enable_translation_suggestions: bool = False
+
+    yandex_translate_key: str | None = None
+    azure_client_secret: str | None = None
+
+    google_application_credentials_path: str | None = None
+    google_project_id: str | None = None
+
+    deepl_auth_key: str | None = None
+
+    openai_api_key: str | None = None
+    openai_prompt_template: str | None = None
+
+    main_language: str | None = None
+
+    messages_source_language_code: str = "en"
+    messages_source_language_name: str = "English"
+
+    access_control_function: str | None = None
+
+    wsgi_auto_reload: bool = False
+    uwsgi_auto_reload: bool = False
+
+    excluded_applications: tuple[str, ...] = ()
+
+    pofile_wrap_width: int = 78
+
+    storage_class: str = "fastapi_rosetta.storage.MemoryRosettaStorage"
+
+    enable_reflang: bool = False
+
+    pofilenames: tuple[str, ...] = ("messages.po",)
+
+    cache_name: str = "default"
+
+    requires_auth: bool = True
+
+    locale_paths: tuple[str, ...] = ()
+    excluded_paths: tuple[str, ...] = ()
+
+    language_groups: bool = False
+
+    auto_compile: bool = True
+
+    show_occurrences: bool = True
+
+    deepl_languages: dict[str, str] = Field(
+        default_factory=dict,
+    )
+    openai_base_url: str | None = None
+
+    openai_model: str = "gpt-4.1-mini"
+
+    languages: tuple[tuple[str, str], ...] = ()
+
+    login_url: str = "/login/"
+
+    languages_bidi: frozenset[str] = frozenset(
+        {"he", "ar", "ar-dz", "ckb", "fa", "ur"},
+    )
+
+    static_url_prefix: str = "/rosetta/static"
+
+
+_lock = Lock()
+
+_settings = RosettaConfig()
+
+
+def configure(config: RosettaConfig) -> None:
+    """
+    Configure fastapi-rosetta.
+
+    Example:
+        configure(
+            RosettaConfig(
+                messages_per_page=50,
+                auto_compile=False,
+            )
+        )
+    """
+    global _settings
+
+    with _lock:
+        _settings = config
+
+
+def get_settings() -> RosettaConfig:
+    return _settings
+
+
+def reset_settings() -> None:
+    """
+    Mainly useful for tests.
+    """
+    global _settings
+
+    with _lock:
+        _settings = RosettaConfig()
+
+
+def update_settings(**kwargs: Any) -> None:
+    """
+    Partially update existing settings.
+
+    Example:
+        update_settings(auto_compile=False)
+    """
+    global _settings
+
+    with _lock:
+        _settings = _settings.model_copy(
+            update=kwargs,
+        )

fastapi_rosetta/dependencies.py

@@ -0,0 +1,34 @@
+from __future__ import annotations
+
+from typing import Annotated
+from urllib.parse import quote
+
+from fastapi import Depends, HTTPException, Request
+
+from .access import can_translate
+from .conf import get_settings
+
+
+class AnonymousUser:
+    first_name = "Anonymous"
+    last_name = "User"
+    email = "anonymous@user.tld"
+
+
+def get_user(request: Request) -> object:
+    return getattr(request.state, "user", AnonymousUser())
+
+
+def require_translate(
+    request: Request,
+    user: Annotated[object, Depends(get_user)],
+) -> object:
+    settings = get_settings()
+    if settings.requires_auth and not can_translate(user):
+        login_url = settings.login_url
+        next_url = quote(str(request.url), safe="")
+        raise HTTPException(
+            status_code=302,
+            headers={"Location": f"{login_url}?next={next_url}"},
+        )
+    return user

fastapi_rosetta/jinja.py

@@ -0,0 +1,256 @@
+from __future__ import annotations
+
+import gettext
+import json
+import re
+from collections.abc import Callable
+from functools import lru_cache
+from pathlib import Path
+from typing import Any
+
+from jinja2 import Environment, FileSystemLoader, select_autoescape
+from jinja2.runtime import Undefined
+from markupsafe import Markup, escape
+
+from .access import can_translate
+from .conf import RosettaConfig, get_settings
+
+__all__ = [
+    "TabIndexCounter",
+    "get_jinja_environment",
+    "register_jinja_filters",
+    "render_template",
+    "RosettaSettingsView",
+]
+
+
+RX = re.compile(r"(%(\([^\s\)]*\))?[sd]|\{[\w\d_]+?\})")
+
+
+@lru_cache
+def get_translation(
+    language: str,
+) -> gettext.GNUTranslations | gettext.NullTranslations:
+
+    settings = get_settings()
+
+    locale_paths = [
+        Path(__file__).parent / "locale",
+    ]
+
+    if settings.locale_paths:
+        locale_paths.extend(Path(path) for path in settings.locale_paths)
+
+    for locale_path in locale_paths:
+        try:
+            return gettext.translation(
+                "messages",
+                localedir=str(locale_path),
+                languages=[language],
+            )
+        except FileNotFoundError:
+            continue
+
+    return gettext.NullTranslations()
+
+
+def gettext_lazy(
+    language: str,
+) -> Callable[[str], str]:
+    return get_translation(language).gettext
+
+
+class RosettaSettingsView:
+    """Expose RosettaConfig fields with legacy uppercase names for templates."""
+
+    _ALIASES = {
+        "MESSAGES_PER_PAGE": "messages_per_page",
+        "ENABLE_TRANSLATION_SUGGESTIONS": "enable_translation_suggestions",
+        "YANDEX_TRANSLATE_KEY": "yandex_translate_key",
+        "AZURE_CLIENT_SECRET": "azure_client_secret",
+        "GOOGLE_APPLICATION_CREDENTIALS_PATH": ("google_application_credentials_path"),
+        "GOOGLE_PROJECT_ID": "google_project_id",
+        "DEEPL_AUTH_KEY": "deepl_auth_key",
+        "OPENAI_API_KEY": "openai_api_key",
+        "MAIN_LANGUAGE": "main_language",
+        "MESSAGES_SOURCE_LANGUAGE_CODE": "messages_source_language_code",
+        "MESSAGES_SOURCE_LANGUAGE_NAME": "messages_source_language_name",
+        "WSGI_AUTO_RELOAD": "wsgi_auto_reload",
+        "UWSGI_AUTO_RELOAD": "uwsgi_auto_reload",
+        "EXCLUDED_APPLICATIONS": "excluded_applications",
+        "POFILE_WRAP_WIDTH": "pofile_wrap_width",
+        "STORAGE_CLASS": "storage_class",
+        "ENABLE_REFLANG": "enable_reflang",
+        "POFILENAMES": "pofilenames",
+        "CACHE_NAME": "cache_name",
+        "REQUIRES_AUTH": "requires_auth",
+        "LOCALE_PATHS": "locale_paths",
+        "EXCLUDED_PATHS": "excluded_paths",
+        "LANGUAGE_GROUPS": "language_groups",
+        "AUTO_COMPILE": "auto_compile",
+        "SHOW_OCCURRENCES": "show_occurrences",
+        "DEEPL_LANGUAGES": "deepl_languages",
+        "OPENAI_BASE_URL": "openai_base_url",
+        "OPENAI_MODEL": "openai_model",
+        "ROSETTA_LANGUAGES": "languages",
+        "LOGIN_URL": "login_url",
+    }
+
+    def __init__(self, config: RosettaConfig | None = None) -> None:
+        self._config = config or get_settings()
+
+    def __getattr__(self, name: str) -> Any:
+        attr = self._ALIASES.get(name, name)
+        return getattr(self._config, attr)
+
+
+class TabIndexCounter:
+
+    def __init__(self, start: int = 0) -> None:
+        self.value: int = start
+
+    def next(self) -> int:
+        self.value += 1
+        return self.value
+
+
+def format_message(message: str) -> Markup:
+    if not message:
+        return Markup("")
+
+    escaped = escape(message).replace("\n", "<br>\n")
+
+    return Markup(
+        RX.sub(
+            r"<code>\1</code>",
+            str(escaped),
+        )
+    )
+
+
+def lines_count(message: str) -> int:
+    if not message:
+        return 1
+
+    return int(1 + sum(len(line) / 50 for line in message.splitlines()))
+
+
+def mult(a: int | str, b: int | str) -> int:
+    return int(a) * int(b)
+
+
+def minus(a: int | str, b: int | str) -> int:
+    try:
+        return int(a) - int(b)
+    except (TypeError, ValueError):
+        return 0
+
+
+def gt(a: int | str, b: int | str) -> bool:
+    try:
+        return int(a) > int(b)
+    except (TypeError, ValueError):
+        return False
+
+
+def is_fuzzy(message: object) -> bool:
+    return bool(message and hasattr(message, "flags") and "fuzzy" in message.flags)
+
+
+def linebreaksbr(value: object) -> Markup:
+    text = str(value)
+    return Markup(text.replace("\n", "<br>\n"))
+
+
+def linebreaks(value: object) -> Markup:
+    text = str(value)
+
+    return Markup(
+        "".join(f"<p>{paragraph}</p>" for paragraph in text.splitlines() if paragraph)
+    )
+
+
+def tojson(value: object) -> Markup:
+
+    def default(obj: object) -> object:
+
+        if isinstance(obj, Undefined):
+            return None
+
+        if isinstance(obj, RosettaSettingsView):
+            return {key: getattr(obj, key) for key in obj._ALIASES}
+
+        return str(obj)
+
+    return Markup(
+        json.dumps(
+            value,
+            ensure_ascii=False,
+            default=default,
+        )
+    )
+
+
+def register_jinja_filters(
+    env: Environment,
+) -> Environment:
+    env.filters["can_translate"] = can_translate
+    env.filters["format_message"] = format_message
+    env.filters["lines_count"] = lines_count
+    env.filters["mult"] = mult
+    env.filters["minus"] = minus
+    env.filters["gt"] = gt
+    env.filters["is_fuzzy"] = is_fuzzy
+    env.filters["linebreaksbr"] = linebreaksbr
+    env.filters["linebreaks"] = linebreaks
+    env.filters["tojson"] = tojson
+    env.filters["increment"] = lambda counter: counter.next()
+    env.filters["add"] = lambda a, b: int(a) + int(b)
+    env.filters["length"] = len
+    env.filters["title"] = lambda value: str(value).title()
+    return env
+
+
+@lru_cache
+def get_jinja_environment() -> Environment:
+
+    templates_dir = Path(__file__).parent / "templates"
+
+    env = Environment(
+        loader=FileSystemLoader(str(templates_dir)),
+        autoescape=select_autoescape(["html", "xml"]),
+    )
+
+    register_jinja_filters(env)
+
+    return env
+
+
+def render_template(
+    template_name: str,
+    context: dict[str, Any],
+    *,
+    url_for: Any,
+    static: Any,
+    request: Any,
+) -> str:
+
+    settings = get_settings()
+
+    languages: tuple[tuple[str, str], ...] = settings.languages or ()
+
+    default_language = languages[0][0] if languages else "en"
+
+    language = request.cookies.get("rosetta_language") or default_language
+    env = get_jinja_environment()
+    template = env.get_template(template_name)
+    render_context = {
+        **context,
+        "url": url_for,
+        "static": static,
+        "request": request,
+        "_": gettext_lazy(language),
+        "current_language": language,
+        "rosetta_languages": languages,
+    }
+    return template.render(render_context)