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

truthound_dashboard/translate/providers/openai.py

@@ -0,0 +1,187 @@
+"""OpenAI provider for translation.
+
+This module implements the OpenAI translation provider using
+GPT-4 and GPT-3.5 models.
+"""
+
+from __future__ import annotations
+
+import asyncio
+
+import httpx
+
+from truthound_dashboard.translate.exceptions import TranslationAPIError
+from truthound_dashboard.translate.providers.base import (
+    AIProvider,
+    ProviderConfig,
+    TranslationRequest,
+    TranslationResponse,
+)
+
+
+class OpenAIProvider(AIProvider):
+    """OpenAI translation provider.
+
+    Uses OpenAI's GPT models for translation.
+
+    Environment:
+        OPENAI_API_KEY: API key for authentication
+
+    Example:
+        provider = OpenAIProvider()
+        response = await provider.translate(
+            TranslationRequest(text="Hello", source_lang="en", target_lang="ja")
+        )
+    """
+
+    name = "openai"
+    display_name = "OpenAI"
+    env_var = "OPENAI_API_KEY"
+    default_model = "gpt-4o-mini"
+    supported_models = [
+        "gpt-4o",
+        "gpt-4o-mini",
+        "gpt-4-turbo",
+        "gpt-4",
+        "gpt-3.5-turbo",
+    ]
+
+    DEFAULT_BASE_URL = "https://api.openai.com/v1"
+
+    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,
+        max_retries: int = 5,
+        base_delay: float = 25.0,
+    ) -> TranslationResponse:
+        """Translate text using OpenAI API.
+
+        Args:
+            request: Translation request
+            max_retries: Maximum number of retries for rate limit errors
+            base_delay: Base delay in seconds for rate limit retries
+
+        Returns:
+            Translation response with translated text
+
+        Raises:
+            TranslationAPIError: If API call fails
+        """
+        prompt = self.get_translation_prompt(request)
+        last_error = None
+
+        for attempt in range(max_retries + 1):
+            async with httpx.AsyncClient(timeout=self.config.timeout) as client:
+                try:
+                    response = await client.post(
+                        f"{self.base_url}/chat/completions",
+                        headers={
+                            "Authorization": f"Bearer {self.config.api_key}",
+                            "Content-Type": "application/json",
+                        },
+                        json={
+                            "model": self.model,
+                            "messages": [
+                                {
+                                    "role": "system",
+                                    "content": (
+                                        "You are a professional translator. "
+                                        "Translate the given text accurately and naturally. "
+                                        "Only output the translated text, nothing else."
+                                    ),
+                                },
+                                {"role": "user", "content": prompt},
+                            ],
+                            "temperature": 0.3,
+                            "max_tokens": 4096,
+                        },
+                    )
+
+                    # Handle rate limit with retry
+                    if response.status_code == 429:
+                        if attempt < max_retries:
+                            # Exponential backoff with jitter
+                            delay = base_delay * (1.5**attempt)
+                            await asyncio.sleep(delay)
+                            continue
+                        else:
+                            raise TranslationAPIError(
+                                provider_name=self.name,
+                                message=f"Rate limit exceeded after {max_retries} retries",
+                                status_code=response.status_code,
+                                response_body=response.text,
+                            )
+
+                    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["choices"][0]["message"]["content"].strip()
+
+                    usage = None
+                    if "usage" in data:
+                        usage = {
+                            "prompt_tokens": data["usage"].get("prompt_tokens", 0),
+                            "completion_tokens": data["usage"].get("completion_tokens", 0),
+                            "total_tokens": data["usage"].get("total_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:
+                    last_error = TranslationAPIError(
+                        provider_name=self.name,
+                        message=f"Request timed out after {self.config.timeout}s",
+                    )
+                    if attempt < max_retries:
+                        await asyncio.sleep(base_delay)
+                        continue
+                    raise last_error from e
+                except httpx.RequestError as e:
+                    raise TranslationAPIError(
+                        provider_name=self.name,
+                        message=f"Request failed: {e}",
+                    ) from e
+
+        # Should not reach here, but just in case
+        if last_error:
+            raise last_error
+        raise TranslationAPIError(
+            provider_name=self.name,
+            message="Translation failed after all retries",
+        )
+
+    async def is_available(self) -> bool:
+        """Check if OpenAI API is available.
+
+        Returns:
+            True if API key is set and valid
+        """
+        if not self.config.api_key:
+            return False
+
+        try:
+            async with httpx.AsyncClient(timeout=10.0) as client:
+                response = await client.get(
+                    f"{self.base_url}/models",
+                    headers={"Authorization": f"Bearer {self.config.api_key}"},
+                )
+                return response.status_code == 200
+        except Exception:
+            return False

truthound_dashboard/translate/providers/registry.py

@@ -0,0 +1,217 @@
+"""Provider registry for managing AI translation providers.
+
+This module provides a central registry for AI providers, enabling
+dynamic provider discovery and auto-detection based on environment.
+"""
+
+from __future__ import annotations
+
+import os
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from truthound_dashboard.translate.providers.base import AIProvider, ProviderConfig
+
+
+class ProviderRegistry:
+    """Registry for AI translation providers.
+
+    This class manages provider registration and lookup, supporting
+    both explicit selection and auto-detection.
+
+    Example:
+        registry = ProviderRegistry()
+        registry.register("openai", OpenAIProvider)
+
+        # Get specific provider
+        provider = registry.get("openai")
+
+        # Auto-detect based on environment
+        provider = registry.detect()
+    """
+
+    _providers: dict[str, type["AIProvider"]] = {}
+    _instances: dict[str, "AIProvider"] = {}
+
+    @classmethod
+    def register(cls, name: str, provider_class: type["AIProvider"]) -> None:
+        """Register a provider class.
+
+        Args:
+            name: Provider name (e.g., 'openai', 'anthropic')
+            provider_class: Provider class to register
+        """
+        cls._providers[name.lower()] = provider_class
+
+    @classmethod
+    def get(
+        cls,
+        name: str,
+        config: "ProviderConfig | None" = None,
+    ) -> "AIProvider":
+        """Get a provider instance by name.
+
+        Args:
+            name: Provider name
+            config: Optional configuration override
+
+        Returns:
+            Provider instance
+
+        Raises:
+            ProviderNotFoundError: If provider is not registered
+        """
+        from truthound_dashboard.translate.exceptions import ProviderNotFoundError
+
+        name_lower = name.lower()
+        if name_lower not in cls._providers:
+            raise ProviderNotFoundError(name, list(cls._providers.keys()))
+
+        # Create new instance with config
+        provider_class = cls._providers[name_lower]
+        return provider_class(config)
+
+    @classmethod
+    def detect(cls, config: "ProviderConfig | None" = None) -> "AIProvider":
+        """Auto-detect and return an available provider.
+
+        Detection priority:
+        1. Anthropic (ANTHROPIC_API_KEY)
+        2. OpenAI (OPENAI_API_KEY)
+        3. Mistral (MISTRAL_API_KEY)
+        4. Ollama (if running locally)
+
+        Args:
+            config: Optional configuration override
+
+        Returns:
+            First available provider instance
+
+        Raises:
+            ProviderNotFoundError: If no provider is available
+        """
+        from truthound_dashboard.translate.exceptions import ProviderNotFoundError
+
+        # Priority order for detection
+        detection_order = [
+            ("anthropic", "ANTHROPIC_API_KEY"),
+            ("openai", "OPENAI_API_KEY"),
+            ("mistral", "MISTRAL_API_KEY"),
+            ("ollama", None),  # Ollama doesn't need API key
+        ]
+
+        for provider_name, env_var in detection_order:
+            if provider_name not in cls._providers:
+                continue
+
+            # Check if API key is available (or not needed)
+            if env_var is None or os.getenv(env_var):
+                try:
+                    provider = cls.get(provider_name, config)
+                    return provider
+                except Exception:
+                    continue
+
+        raise ProviderNotFoundError(
+            "auto",
+            list(cls._providers.keys()),
+        )
+
+    @classmethod
+    def list_available(cls) -> list[dict[str, str]]:
+        """List all registered providers with their status.
+
+        Returns:
+            List of dicts with provider info and availability status
+        """
+        result = []
+        for name, provider_class in cls._providers.items():
+            env_var = provider_class.env_var
+            has_key = (
+                env_var is None  # Doesn't need key
+                or bool(os.getenv(env_var))
+            )
+            result.append({
+                "name": name,
+                "display_name": provider_class.display_name or name.title(),
+                "env_var": env_var or "N/A",
+                "available": has_key,
+                "default_model": provider_class.default_model,
+            })
+        return result
+
+    @classmethod
+    def clear(cls) -> None:
+        """Clear all registered providers. Mainly for testing."""
+        cls._providers.clear()
+        cls._instances.clear()
+
+
+def register_provider(name: str, provider_class: type["AIProvider"]) -> None:
+    """Register a provider class with the global registry.
+
+    Args:
+        name: Provider name
+        provider_class: Provider class to register
+    """
+    ProviderRegistry.register(name, provider_class)
+
+
+def get_provider(
+    name: str,
+    config: "ProviderConfig | None" = None,
+) -> "AIProvider":
+    """Get a provider instance by name.
+
+    Args:
+        name: Provider name (e.g., 'openai', 'anthropic')
+        config: Optional configuration override
+
+    Returns:
+        Provider instance
+
+    Raises:
+        ProviderNotFoundError: If provider not found
+    """
+    return ProviderRegistry.get(name, config)
+
+
+def detect_provider(config: "ProviderConfig | None" = None) -> "AIProvider":
+    """Auto-detect and return an available provider.
+
+    Args:
+        config: Optional configuration override
+
+    Returns:
+        First available provider
+
+    Raises:
+        ProviderNotFoundError: If no provider available
+    """
+    return ProviderRegistry.detect(config)
+
+
+def list_available_providers() -> list[dict[str, str]]:
+    """List all registered providers with availability status.
+
+    Returns:
+        List of provider info dicts
+    """
+    return ProviderRegistry.list_available()
+
+
+# Auto-register built-in providers on module import
+def _register_builtin_providers() -> None:
+    """Register all built-in providers."""
+    from truthound_dashboard.translate.providers.openai import OpenAIProvider
+    from truthound_dashboard.translate.providers.anthropic import AnthropicProvider
+    from truthound_dashboard.translate.providers.ollama import OllamaProvider
+    from truthound_dashboard.translate.providers.mistral import MistralProvider
+
+    register_provider("openai", OpenAIProvider)
+    register_provider("anthropic", AnthropicProvider)
+    register_provider("ollama", OllamaProvider)
+    register_provider("mistral", MistralProvider)
+
+
+_register_builtin_providers()