scitex 2.0.0__py2.py3-none-any.whl → 2.1.0__py2.py3-none-any.whl

scitex/ai/genai/auth_manager.py

@@ -1,200 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-# Time-stamp: "2025-05-31 10:00:00"
-# Author: ywatanabe
-# File: ./src/scitex/ai/genai/auth_manager.py
-
-"""
-Handles API key management and validation for AI providers.
-
-This module provides secure handling of API keys including:
-- Environment variable retrieval
-- Key validation
-- Masked key display for security
-"""
-
-import os
-from typing import Optional, Dict, Any
-
-
-class AuthManager:
-    """Manages API key authentication for AI providers.
-
-    Example
-    -------
-    >>> auth = AuthManager("sk-abc123...", "OpenAI")
-    >>> auth.validate_key()
-    True
-    >>> auth.get_masked_key()
-    'sk-a****3...'
-
-    Parameters
-    ----------
-    api_key : str
-        The API key for authentication
-    provider : str
-        The provider name (e.g., "OpenAI", "Anthropic")
-    """
-
-    # Mapping of providers to environment variable names
-    ENV_VAR_MAPPING: Dict[str, str] = {
-        "OpenAI": "OPENAI_API_KEY",
-        "Anthropic": "ANTHROPIC_API_KEY",
-        "Google": "GOOGLE_API_KEY",
-        "Groq": "GROQ_API_KEY",
-        "DeepSeek": "DEEPSEEK_API_KEY",
-        "Perplexity": "PERPLEXITY_API_KEY",
-        "Llama": "LLAMA_API_KEY",
-    }
-
-    def __init__(self, api_key: Optional[str], provider: str):
-        """Initialize AuthManager with API key and provider.
-
-        Parameters
-        ----------
-        api_key : Optional[str]
-            The API key. If None, will attempt to get from environment
-        provider : str
-            The provider name
-        """
-        # Normalize provider name to lowercase
-        self.provider = provider.lower()
-
-        # Check if provider is known
-        if self.provider not in [p.lower() for p in self.ENV_VAR_MAPPING.keys()]:
-            raise ValueError(f"Unknown provider: {provider}")
-
-        # Store private api key
-        self._api_key = api_key or self.get_key_from_env(provider)
-
-        if not self._api_key:
-            raise ValueError(f"No API key provided for {provider}")
-
-        # Public property for backward compatibility
-        self.api_key = self._api_key
-
-    def validate(self) -> bool:
-        """Validate the API key format.
-
-        Returns
-        -------
-        bool
-            True if key appears valid, False otherwise
-
-        Raises
-        ------
-        ValueError
-            If API key is missing or invalid
-        """
-        if not self._api_key:
-            raise ValueError("No API key configured")
-
-        # Basic validation - ensure key is not empty and has reasonable length
-        if len(self._api_key) < 10:
-            raise ValueError(
-                f"API key for {self.provider} appears to be invalid (too short)"
-            )
-
-        return True
-
-    def get_masked_key(self) -> str:
-        """Get a masked version of the API key for display.
-
-        Returns
-        -------
-        str
-            Masked API key showing only first few and last few characters
-        """
-        if not self._api_key:
-            return "No API key"
-
-        if len(self._api_key) <= 8:
-            return "*****"
-
-        # Match test expectation: show first 3 and last 4 characters with "..." in between
-        return f"{self._api_key[:3]}...{self._api_key[-4:]}"
-
-    def get_client_config(self) -> Dict[str, Any]:
-        """Get client configuration for the provider.
-
-        Returns
-        -------
-        Dict[str, any]
-            Configuration dictionary for the provider client
-        """
-        config = {"api_key": self._api_key}
-
-        # Provider-specific configurations
-        if self.provider == "openai":
-            # Check for optional organization
-            org = os.getenv("OPENAI_ORGANIZATION")
-            if org:
-                config["organization"] = org
-        elif self.provider == "anthropic":
-            config["max_retries"] = 3
-        elif self.provider == "google":
-            # Google only needs API key
-            pass
-
-        return config
-
-    @classmethod
-    def get_key_from_env(cls, provider: str) -> Optional[str]:
-        """Get API key from environment variable.
-
-        Parameters
-        ----------
-        provider : str
-            The provider name
-
-        Returns
-        -------
-        Optional[str]
-            The API key if found in environment, None otherwise
-        """
-        # Find the env var name case-insensitively
-        for p, env_var in cls.ENV_VAR_MAPPING.items():
-            if p.lower() == provider.lower():
-                return os.getenv(env_var)
-
-        # Try generic pattern if not found
-        env_var = f"{provider.upper()}_API_KEY"
-        return os.getenv(env_var)
-
-    def get_api_key(self, provider: str, api_key: Optional[str] = None) -> str:
-        """Get API key for a provider.
-
-        This method is used by provider_base.py for compatibility.
-
-        Parameters
-        ----------
-        provider : str
-            The provider name
-        api_key : Optional[str]
-            Explicit API key, if None will use environment
-
-        Returns
-        -------
-        str
-            The API key
-
-        Raises
-        ------
-        ValueError
-            If no API key is found
-        """
-        if api_key:
-            return api_key
-
-        key = self.get_key_from_env(provider)
-        if not key:
-            raise ValueError(f"No API key provided for {provider}")
-
-        return key
-
-    def __repr__(self) -> str:
-        """String representation of AuthManager."""
-        return f"AuthManager(provider={self.provider}, key={self.get_masked_key()})"
-
-
-# EOF

scitex/ai/genai/base_provider.py

@@ -1,291 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-# Time-stamp: "2025-05-31 10:30:00"
-# Author: ywatanabe
-# File: ./src/scitex/ai/genai/base_provider.py
-
-"""
-Abstract base class for AI provider implementations.
-
-This module defines the interface that all AI providers must implement,
-ensuring consistency across different providers (OpenAI, Anthropic, etc.).
-"""
-
-from abc import ABC, abstractmethod
-from dataclasses import dataclass, field
-from enum import Enum
-from typing import Any, Dict, List, Generator, Optional
-
-
-class Provider(str, Enum):
-    """Supported AI providers."""
-
-    OPENAI = "openai"
-    ANTHROPIC = "anthropic"
-    GOOGLE = "google"
-    GROQ = "groq"
-    DEEPSEEK = "deepseek"
-    LLAMA = "llama"
-    PERPLEXITY = "perplexity"
-    MOCK = "mock"  # For testing
-
-    def __str__(self):
-        return self.value
-
-
-class Role(str, Enum):
-    """Message roles for chat conversations."""
-
-    SYSTEM = "system"
-    USER = "user"
-    ASSISTANT = "assistant"
-
-
-@dataclass
-class ProviderConfig:
-    """Configuration for AI providers."""
-
-    provider: str
-    model: str
-    api_key: Optional[str] = None
-    system_prompt: str = ""
-    temperature: float = 1.0
-    max_tokens: int = 4096
-    stream: bool = False
-    seed: Optional[int] = None
-    n_keep: int = 1
-
-
-@dataclass
-class CompletionResponse:
-    """Standard response format for completions."""
-
-    content: str
-    input_tokens: int
-    output_tokens: int
-    finish_reason: str = "stop"
-    provider_response: Optional[Any] = None
-
-
-class BaseProvider(ABC):
-    """Abstract base class for AI providers.
-
-    All AI provider implementations must inherit from this class
-    and implement the required abstract methods.
-
-    Example
-    -------
-    >>> class MyProvider(BaseProvider):
-    ...     def init_client(self) -> Any:
-    ...         return MyAPIClient(self.api_key)
-    ...
-    ...     def format_history(self, history: List[Dict]) -> List[Dict]:
-    ...         # Provider-specific formatting
-    ...         return history
-    ...
-    ...     def call_static(self, messages: List[Dict], **kwargs) -> Any:
-    ...         # Make API call
-    ...         return self.client.complete(messages)
-    ...
-    ...     def call_stream(self, messages: List[Dict], **kwargs) -> Generator:
-    ...         # Make streaming API call
-    ...         for chunk in self.client.stream(messages):
-    ...             yield chunk
-    """
-
-    @abstractmethod
-    def init_client(self) -> Any:
-        """Initialize the provider-specific client.
-
-        This method should create and configure the API client
-        for the specific provider (e.g., OpenAI client, Anthropic client).
-
-        Returns
-        -------
-        Any
-            The initialized client object
-        """
-        pass
-
-    @abstractmethod
-    def format_history(self, history: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
-        """Format conversation history for the provider's API.
-
-        Different providers may expect different formats for conversation
-        history. This method converts the standard format to the
-        provider-specific format.
-
-        Parameters
-        ----------
-        history : List[Dict[str, Any]]
-            Standard format conversation history
-
-        Returns
-        -------
-        List[Dict[str, Any]]
-            Provider-specific formatted history
-        """
-        pass
-
-    @abstractmethod
-    def call_static(self, messages: List[Dict[str, Any]], **kwargs) -> Any:
-        """Make a static (non-streaming) API call.
-
-        Parameters
-        ----------
-        messages : List[Dict[str, Any]]
-            Formatted conversation messages
-        **kwargs
-            Additional provider-specific parameters
-
-        Returns
-        -------
-        Any
-            Provider-specific response object
-        """
-        pass
-
-    @abstractmethod
-    def call_stream(
-        self, messages: List[Dict[str, Any]], **kwargs
-    ) -> Generator[str, None, None]:
-        """Make a streaming API call.
-
-        Parameters
-        ----------
-        messages : List[Dict[str, Any]]
-            Formatted conversation messages
-        **kwargs
-            Additional provider-specific parameters
-
-        Yields
-        ------
-        str
-            Response text chunks
-        """
-        pass
-
-    @property
-    @abstractmethod
-    def supports_streaming(self) -> bool:
-        """Whether this provider supports streaming responses.
-
-        Returns
-        -------
-        bool
-            True if streaming is supported
-        """
-        pass
-
-    @property
-    @abstractmethod
-    def supports_images(self) -> bool:
-        """Whether this provider supports image inputs.
-
-        Returns
-        -------
-        bool
-            True if images are supported
-        """
-        pass
-
-    @property
-    @abstractmethod
-    def max_context_length(self) -> int:
-        """Maximum context length in tokens.
-
-        Returns
-        -------
-        int
-            Maximum number of tokens
-        """
-        pass
-
-    def get_capabilities(self) -> Dict[str, Any]:
-        """Get provider capabilities summary.
-
-        Returns
-        -------
-        Dict[str, Any]
-            Dictionary of provider capabilities
-        """
-        return {
-            "supports_streaming": self.supports_streaming,
-            "supports_images": self.supports_images,
-            "max_context_length": self.max_context_length,
-        }
-
-    def extract_tokens_from_response(self, response: Any) -> Dict[str, int]:
-        """Extract token usage from provider response.
-
-        Default implementation returns zeros. Providers should override
-        to extract actual token counts from their response format.
-
-        Parameters
-        ----------
-        response : Any
-            Provider-specific response object
-
-        Returns
-        -------
-        Dict[str, int]
-            Dictionary with 'input_tokens' and 'output_tokens'
-        """
-        return {"input_tokens": 0, "output_tokens": 0}
-
-    def handle_rate_limit(self, error: Exception) -> bool:
-        """Handle rate limit errors.
-
-        Default implementation returns False. Providers can override
-        to implement retry logic or other handling.
-
-        Parameters
-        ----------
-        error : Exception
-            The error that occurred
-
-        Returns
-        -------
-        bool
-            True if the error was handled and operation should retry
-        """
-        return False
-
-    def validate_model(self, model: str) -> bool:
-        """Validate if a model is supported.
-
-        Default implementation returns True. Providers should override
-        to validate against their supported models.
-
-        Parameters
-        ----------
-        model : str
-            Model name to validate
-
-        Returns
-        -------
-        bool
-            True if model is supported
-        """
-        return True
-
-    def get_error_message(self, error: Exception) -> str:
-        """Extract user-friendly error message.
-
-        Default implementation returns string representation.
-        Providers can override for better error messages.
-
-        Parameters
-        ----------
-        error : Exception
-            The error that occurred
-
-        Returns
-        -------
-        str
-            User-friendly error message
-        """
-        return str(error)
-
-
-# EOF