truthound-dashboard 1.0.2__py3-none-any.whl → 1.1.0__py3-none-any.whl

truthound_dashboard/translate/config_updater.py

@@ -0,0 +1,327 @@
+"""Intlayer configuration updater.
+
+This module handles updating intlayer.config.ts and related frontend
+configuration files when new languages are added.
+"""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+from pathlib import Path
+
+from truthound_dashboard.translate.exceptions import ConfigUpdateError
+
+
+@dataclass
+class LocaleMapping:
+    """Mapping between language codes and Intlayer locale constants."""
+
+    code: str  # ISO 639-1 code (e.g., 'ja', 'zh')
+    intlayer_const: str  # Intlayer constant (e.g., 'JAPANESE', 'CHINESE')
+    name: str  # English name
+    native_name: str  # Native name
+    flag: str  # Flag emoji
+
+    @classmethod
+    def from_code(cls, code: str) -> "LocaleMapping":
+        """Create a LocaleMapping from a language code.
+
+        Args:
+            code: ISO 639-1 language code
+
+        Returns:
+            LocaleMapping instance
+
+        Raises:
+            ValueError: If language code is not supported
+        """
+        code = code.lower()
+        if code not in LOCALE_MAPPINGS:
+            supported = ", ".join(sorted(LOCALE_MAPPINGS.keys()))
+            raise ValueError(
+                f"Unsupported language code: '{code}'. "
+                f"Supported codes: {supported}"
+            )
+        return LOCALE_MAPPINGS[code]
+
+
+# Mapping of ISO 639-1 codes to Intlayer locale info
+LOCALE_MAPPINGS: dict[str, LocaleMapping] = {
+    "en": LocaleMapping("en", "ENGLISH", "English", "English", "🇺🇸"),
+    "ko": LocaleMapping("ko", "KOREAN", "Korean", "한국어", "🇰🇷"),
+    "ja": LocaleMapping("ja", "JAPANESE", "Japanese", "日本語", "🇯🇵"),
+    "zh": LocaleMapping("zh", "CHINESE", "Chinese", "中文", "🇨🇳"),
+    "de": LocaleMapping("de", "GERMAN", "German", "Deutsch", "🇩🇪"),
+    "fr": LocaleMapping("fr", "FRENCH", "French", "Français", "🇫🇷"),
+    "es": LocaleMapping("es", "SPANISH", "Spanish", "Español", "🇪🇸"),
+    "pt": LocaleMapping("pt", "PORTUGUESE", "Portuguese", "Português", "🇵🇹"),
+    "it": LocaleMapping("it", "ITALIAN", "Italian", "Italiano", "🇮🇹"),
+    "ru": LocaleMapping("ru", "RUSSIAN", "Russian", "Русский", "🇷🇺"),
+    "ar": LocaleMapping("ar", "ARABIC", "Arabic", "العربية", "🇸🇦"),
+    "hi": LocaleMapping("hi", "HINDI", "Hindi", "हिन्दी", "🇮🇳"),
+    "th": LocaleMapping("th", "THAI", "Thai", "ไทย", "🇹🇭"),
+    "vi": LocaleMapping("vi", "VIETNAMESE", "Vietnamese", "Tiếng Việt", "🇻🇳"),
+    "nl": LocaleMapping("nl", "DUTCH", "Dutch", "Nederlands", "🇳🇱"),
+    "pl": LocaleMapping("pl", "POLISH", "Polish", "Polski", "🇵🇱"),
+    "tr": LocaleMapping("tr", "TURKISH", "Turkish", "Türkçe", "🇹🇷"),
+    "sv": LocaleMapping("sv", "SWEDISH", "Swedish", "Svenska", "🇸🇪"),
+    "da": LocaleMapping("da", "DANISH", "Danish", "Dansk", "🇩🇰"),
+    "no": LocaleMapping("no", "NORWEGIAN", "Norwegian", "Norsk", "🇳🇴"),
+    "fi": LocaleMapping("fi", "FINNISH", "Finnish", "Suomi", "🇫🇮"),
+    "cs": LocaleMapping("cs", "CZECH", "Czech", "Čeština", "🇨🇿"),
+    "hu": LocaleMapping("hu", "HUNGARIAN", "Hungarian", "Magyar", "🇭🇺"),
+    "el": LocaleMapping("el", "GREEK", "Greek", "Ελληνικά", "🇬🇷"),
+    "he": LocaleMapping("he", "HEBREW", "Hebrew", "עברית", "🇮🇱"),
+    "id": LocaleMapping("id", "INDONESIAN", "Indonesian", "Bahasa Indonesia", "🇮🇩"),
+    "ms": LocaleMapping("ms", "MALAY", "Malay", "Bahasa Melayu", "🇲🇾"),
+    "uk": LocaleMapping("uk", "UKRAINIAN", "Ukrainian", "Українська", "🇺🇦"),
+    "ro": LocaleMapping("ro", "ROMANIAN", "Romanian", "Română", "🇷🇴"),
+    "bg": LocaleMapping("bg", "BULGARIAN", "Bulgarian", "Български", "🇧🇬"),
+    "hr": LocaleMapping("hr", "CROATIAN", "Croatian", "Hrvatski", "🇭🇷"),
+    "sk": LocaleMapping("sk", "SLOVAK", "Slovak", "Slovenčina", "🇸🇰"),
+    "sl": LocaleMapping("sl", "SLOVENIAN", "Slovenian", "Slovenščina", "🇸🇮"),
+    "et": LocaleMapping("et", "ESTONIAN", "Estonian", "Eesti", "🇪🇪"),
+    "lv": LocaleMapping("lv", "LATVIAN", "Latvian", "Latviešu", "🇱🇻"),
+    "lt": LocaleMapping("lt", "LITHUANIAN", "Lithuanian", "Lietuvių", "🇱🇹"),
+}
+
+
+class IntlayerConfigUpdater:
+    """Updates Intlayer configuration files with new languages.
+
+    This class handles:
+    1. intlayer.config.ts - Add new locales to the locales array
+    2. providers/intlayer/config.ts - Add locale info for UI
+
+    Example:
+        updater = IntlayerConfigUpdater(frontend_dir)
+        updater.add_languages(["ja", "zh", "de"])
+    """
+
+    def __init__(self, frontend_dir: Path | str) -> None:
+        """Initialize the config updater.
+
+        Args:
+            frontend_dir: Path to the frontend directory
+        """
+        self.frontend_dir = Path(frontend_dir)
+        self.intlayer_config = self.frontend_dir / "intlayer.config.ts"
+        self.provider_config = (
+            self.frontend_dir / "src" / "providers" / "intlayer" / "config.ts"
+        )
+
+    def get_current_locales(self) -> list[str]:
+        """Get currently configured locales from intlayer.config.ts.
+
+        Returns:
+            List of language codes currently configured
+        """
+        if not self.intlayer_config.exists():
+            return []
+
+        content = self.intlayer_config.read_text()
+
+        # Parse locales array: [Locales.ENGLISH, Locales.KOREAN]
+        pattern = r"locales:\s*\[([\s\S]*?)\]"
+        match = re.search(pattern, content)
+        if not match:
+            return []
+
+        locales_str = match.group(1)
+        locales = []
+
+        for const_name in re.findall(r"Locales\.(\w+)", locales_str):
+            for code, mapping in LOCALE_MAPPINGS.items():
+                if mapping.intlayer_const == const_name:
+                    locales.append(code)
+                    break
+
+        return locales
+
+    def add_languages(self, language_codes: list[str]) -> list[str]:
+        """Add new languages to the configuration.
+
+        Args:
+            language_codes: List of ISO 639-1 language codes to add
+
+        Returns:
+            List of actually added language codes (excluding already existing)
+
+        Raises:
+            ConfigUpdateError: If configuration update fails
+        """
+        # Validate all language codes first
+        mappings = []
+        for code in language_codes:
+            try:
+                mappings.append(LocaleMapping.from_code(code))
+            except ValueError as e:
+                raise ConfigUpdateError(str(self.intlayer_config), str(e)) from e
+
+        # Get current locales
+        current_locales = self.get_current_locales()
+        new_codes = [m.code for m in mappings if m.code not in current_locales]
+
+        if not new_codes:
+            return []
+
+        # Update intlayer.config.ts
+        self._update_intlayer_config(mappings)
+
+        # Update provider config.ts
+        self._update_provider_config(mappings)
+
+        return new_codes
+
+    def _update_intlayer_config(self, mappings: list[LocaleMapping]) -> None:
+        """Update intlayer.config.ts with new locales.
+
+        Args:
+            mappings: List of LocaleMapping objects to add
+        """
+        if not self.intlayer_config.exists():
+            raise ConfigUpdateError(
+                str(self.intlayer_config),
+                "File does not exist",
+            )
+
+        content = self.intlayer_config.read_text()
+        current_locales = self.get_current_locales()
+
+        # Build new locales array
+        all_locales = current_locales.copy()
+        for mapping in mappings:
+            if mapping.code not in all_locales:
+                all_locales.append(mapping.code)
+
+        # Generate locales string
+        locales_entries = []
+        for code in all_locales:
+            mapping = LOCALE_MAPPINGS[code]
+            locales_entries.append(f"Locales.{mapping.intlayer_const}")
+
+        new_locales_str = ", ".join(locales_entries)
+
+        # Replace locales array
+        pattern = r"(locales:\s*\[)[\s\S]*?(\])"
+        replacement = f"\\g<1>{new_locales_str}\\g<2>"
+        new_content = re.sub(pattern, replacement, content)
+
+        self.intlayer_config.write_text(new_content)
+
+    def _update_provider_config(self, mappings: list[LocaleMapping]) -> None:
+        """Update providers/intlayer/config.ts with new locale info.
+
+        Args:
+            mappings: List of LocaleMapping objects to add
+        """
+        if not self.provider_config.exists():
+            raise ConfigUpdateError(
+                str(self.provider_config),
+                "File does not exist",
+            )
+
+        content = self.provider_config.read_text()
+        current_locales = self.get_current_locales()
+
+        # Update SUPPORTED_LOCALES array
+        all_locales = current_locales.copy()
+        for mapping in mappings:
+            if mapping.code not in all_locales:
+                all_locales.append(mapping.code)
+
+        # Generate SUPPORTED_LOCALES entries
+        locales_entries = []
+        for code in all_locales:
+            mapping = LOCALE_MAPPINGS[code]
+            locales_entries.append(f"Locales.{mapping.intlayer_const}")
+
+        new_supported_str = ", ".join(locales_entries)
+
+        # Replace SUPPORTED_LOCALES
+        pattern = r"(export const SUPPORTED_LOCALES = \[)[\s\S]*?(\] as const)"
+        replacement = f"\\g<1>{new_supported_str}\\g<2>"
+        new_content = re.sub(pattern, replacement, content)
+
+        # Update LOCALE_INFO array
+        locale_info_entries = []
+        for code in all_locales:
+            mapping = LOCALE_MAPPINGS[code]
+            entry = (
+                f"  {{\n"
+                f"    code: Locales.{mapping.intlayer_const},\n"
+                f"    name: '{mapping.name}',\n"
+                f"    nativeName: '{mapping.native_name}',\n"
+                f"    flag: '{mapping.flag}',\n"
+                f"  }}"
+            )
+            locale_info_entries.append(entry)
+
+        new_locale_info_str = ",\n".join(locale_info_entries)
+
+        # Replace LOCALE_INFO array
+        pattern = r"(export const LOCALE_INFO: readonly LocaleInfo\[\] = \[)\n[\s\S]*?(\n\] as const)"
+        replacement = f"\\g<1>\n{new_locale_info_str},\\g<2>"
+        new_content = re.sub(pattern, replacement, new_content)
+
+        # Update getBrowserLocale function
+        self._update_browser_locale_function(new_content, all_locales)
+
+        self.provider_config.write_text(new_content)
+
+    def _update_browser_locale_function(
+        self,
+        content: str,
+        all_locales: list[str],
+    ) -> str:
+        """Update getBrowserLocale function with new language mappings.
+
+        This is a simplified approach - for complex cases, consider
+        using a proper AST parser.
+
+        Args:
+            content: Current file content
+            all_locales: List of all locale codes
+
+        Returns:
+            Updated content
+        """
+        # For now, we keep the basic structure and just ensure
+        # the function exists. Full implementation would require
+        # AST manipulation for clean results.
+        return content
+
+    def validate_config(self) -> bool:
+        """Validate that configuration files exist and are valid.
+
+        Returns:
+            True if all configurations are valid
+        """
+        if not self.intlayer_config.exists():
+            return False
+        if not self.provider_config.exists():
+            return False
+
+        try:
+            self.get_current_locales()
+            return True
+        except Exception:
+            return False
+
+
+def get_supported_languages() -> list[dict[str, str]]:
+    """Get list of all supported languages for translation.
+
+    Returns:
+        List of dicts with language info
+    """
+    return [
+        {
+            "code": mapping.code,
+            "name": mapping.name,
+            "native_name": mapping.native_name,
+            "flag": mapping.flag,
+        }
+        for mapping in LOCALE_MAPPINGS.values()
+    ]

truthound_dashboard/translate/exceptions.py

@@ -0,0 +1,98 @@
+"""Custom exceptions for the translation module."""
+
+from __future__ import annotations
+
+
+class TranslationError(Exception):
+    """Base exception for translation-related errors."""
+
+    pass
+
+
+class ProviderNotFoundError(TranslationError):
+    """Raised when a requested AI provider is not found or not supported."""
+
+    def __init__(self, provider_name: str, available: list[str] | None = None) -> None:
+        self.provider_name = provider_name
+        self.available = available or []
+        message = f"Provider '{provider_name}' not found."
+        if self.available:
+            message += f" Available providers: {', '.join(self.available)}"
+        super().__init__(message)
+
+
+class APIKeyNotFoundError(TranslationError):
+    """Raised when required API key is not set in environment."""
+
+    def __init__(self, provider_name: str, env_var: str) -> None:
+        self.provider_name = provider_name
+        self.env_var = env_var
+        message = (
+            f"API key not found for provider '{provider_name}'. "
+            f"Please set the {env_var} environment variable."
+        )
+        super().__init__(message)
+
+
+class TranslationAPIError(TranslationError):
+    """Raised when AI provider API call fails."""
+
+    def __init__(
+        self,
+        provider_name: str,
+        message: str,
+        status_code: int | None = None,
+        response_body: str | None = None,
+    ) -> None:
+        self.provider_name = provider_name
+        self.status_code = status_code
+        self.response_body = response_body
+        full_message = f"API error from '{provider_name}': {message}"
+        if status_code:
+            full_message += f" (status: {status_code})"
+        super().__init__(full_message)
+
+
+class ContentParseError(TranslationError):
+    """Raised when content file parsing fails."""
+
+    def __init__(self, file_path: str, reason: str) -> None:
+        self.file_path = file_path
+        self.reason = reason
+        message = f"Failed to parse content file '{file_path}': {reason}"
+        super().__init__(message)
+
+
+class ConfigUpdateError(TranslationError):
+    """Raised when intlayer config update fails."""
+
+    def __init__(self, config_path: str, reason: str) -> None:
+        self.config_path = config_path
+        self.reason = reason
+        message = f"Failed to update config '{config_path}': {reason}"
+        super().__init__(message)
+
+
+class NodejsNotFoundError(TranslationError):
+    """Raised when Node.js is not installed or version is too old."""
+
+    def __init__(self, required_version: str = "18.0.0") -> None:
+        self.required_version = required_version
+        message = (
+            f"Node.js {required_version}+ is required for translation. "
+            "Please install from https://nodejs.org/"
+        )
+        super().__init__(message)
+
+
+class OllamaNotRunningError(TranslationError):
+    """Raised when Ollama is not running for local LLM translation."""
+
+    def __init__(self) -> None:
+        message = (
+            "Ollama is not running. Please start Ollama first:\n"
+            "  1. Install: https://ollama.ai/download\n"
+            "  2. Start: ollama serve\n"
+            "  3. Pull a model: ollama pull llama2"
+        )
+        super().__init__(message)

truthound_dashboard/translate/providers/__init__.py

@@ -0,0 +1,49 @@
+"""AI provider abstraction layer for translation.
+
+This module provides a unified interface for multiple AI providers,
+enabling seamless switching between different translation backends.
+
+Example:
+    from truthound_dashboard.translate.providers import get_provider, detect_provider
+
+    # Explicit provider selection
+    provider = get_provider("openai")
+
+    # Auto-detection based on environment
+    provider = detect_provider()
+
+    # Translate text
+    result = await provider.translate(
+        text="Hello, world!",
+        source_lang="en",
+        target_lang="ja",
+    )
+"""
+
+from truthound_dashboard.translate.providers.base import (
+    AIProvider,
+    ProviderConfig,
+    TranslationRequest,
+    TranslationResponse,
+)
+from truthound_dashboard.translate.providers.registry import (
+    ProviderRegistry,
+    get_provider,
+    detect_provider,
+    list_available_providers,
+    register_provider,
+)
+
+__all__ = [
+    # Base classes
+    "AIProvider",
+    "ProviderConfig",
+    "TranslationRequest",
+    "TranslationResponse",
+    # Registry functions
+    "ProviderRegistry",
+    "get_provider",
+    "detect_provider",
+    "list_available_providers",
+    "register_provider",
+]

truthound_dashboard/translate/providers/anthropic.py

@@ -0,0 +1,135 @@
+"""Anthropic provider for translation.
+
+This module implements the Anthropic translation provider using
+Claude models.
+"""
+
+from __future__ import annotations
+
+import httpx
+
+from truthound_dashboard.translate.exceptions import TranslationAPIError
+from truthound_dashboard.translate.providers.base import (
+    AIProvider,
+    ProviderConfig,
+    TranslationRequest,
+    TranslationResponse,
+)
+
+
+class AnthropicProvider(AIProvider):
+    """Anthropic translation provider.
+
+    Uses Anthropic's Claude models for translation.
+
+    Environment:
+        ANTHROPIC_API_KEY: API key for authentication
+
+    Example:
+        provider = AnthropicProvider()
+        response = await provider.translate(
+            TranslationRequest(text="Hello", source_lang="en", target_lang="ja")
+        )
+    """
+
+    name = "anthropic"
+    display_name = "Anthropic"
+    env_var = "ANTHROPIC_API_KEY"
+    default_model = "claude-sonnet-4-20250514"
+    supported_models = [
+        "claude-sonnet-4-20250514",
+        "claude-opus-4-20250514",
+        "claude-3-5-sonnet-20241022",
+        "claude-3-5-haiku-20241022",
+        "claude-3-opus-20240229",
+        "claude-3-sonnet-20240229",
+        "claude-3-haiku-20240307",
+    ]
+
+    DEFAULT_BASE_URL = "https://api.anthropic.com"
+    API_VERSION = "2023-06-01"
+
+    def __init__(self, config: ProviderConfig | None = None) -> None:
+        super().__init__(config)
+        self.base_url = self.config.base_url or self.DEFAULT_BASE_URL
+
+    async def translate(self, request: TranslationRequest) -> TranslationResponse:
+        """Translate text using Anthropic API.
+
+        Args:
+            request: Translation request
+
+        Returns:
+            Translation response with translated text
+
+        Raises:
+            TranslationAPIError: If API call fails
+        """
+        prompt = self.get_translation_prompt(request)
+
+        async with httpx.AsyncClient(timeout=self.config.timeout) as client:
+            try:
+                response = await client.post(
+                    f"{self.base_url}/v1/messages",
+                    headers={
+                        "x-api-key": self.config.api_key,
+                        "anthropic-version": self.API_VERSION,
+                        "Content-Type": "application/json",
+                    },
+                    json={
+                        "model": self.model,
+                        "max_tokens": 4096,
+                        "system": (
+                            "You are a professional translator. "
+                            "Translate the given text accurately and naturally. "
+                            "Only output the translated text, nothing else."
+                        ),
+                        "messages": [{"role": "user", "content": prompt}],
+                    },
+                )
+
+                if response.status_code != 200:
+                    raise TranslationAPIError(
+                        provider_name=self.name,
+                        message=f"API request failed: {response.text}",
+                        status_code=response.status_code,
+                        response_body=response.text,
+                    )
+
+                data = response.json()
+                translated_text = data["content"][0]["text"].strip()
+
+                usage = None
+                if "usage" in data:
+                    usage = {
+                        "input_tokens": data["usage"].get("input_tokens", 0),
+                        "output_tokens": data["usage"].get("output_tokens", 0),
+                    }
+
+                return TranslationResponse(
+                    translated_text=translated_text,
+                    source_lang=request.source_lang,
+                    target_lang=request.target_lang,
+                    model=self.model,
+                    provider=self.name,
+                    usage=usage,
+                )
+
+            except httpx.TimeoutException as e:
+                raise TranslationAPIError(
+                    provider_name=self.name,
+                    message=f"Request timed out after {self.config.timeout}s",
+                ) from e
+            except httpx.RequestError as e:
+                raise TranslationAPIError(
+                    provider_name=self.name,
+                    message=f"Request failed: {e}",
+                ) from e
+
+    async def is_available(self) -> bool:
+        """Check if Anthropic API is available.
+
+        Returns:
+            True if API key is set
+        """
+        return bool(self.config.api_key)