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

scitex/ai/genai/provider_base.py

@@ -1,302 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-# Time-stamp: "2024-11-15 12:00:00"
-# Author: Yusuke Watanabe (ywatanabe@alumni.u-tokyo.ac.jp)
-
-"""
-Provider base implementation using composition pattern.
-
-This module provides the concrete base class that combines all components
-to implement the provider interface.
-"""
-
-import warnings
-from dataclasses import dataclass
-from typing import Any, Dict, Iterator, List, Optional, Union
-
-from .auth_manager import AuthManager
-from .base_provider import BaseProvider
-from .chat_history import ChatHistory
-from .cost_tracker import CostTracker, TokenUsage
-from .image_processor import ImageProcessor
-from .model_registry import ModelInfo, ModelRegistry
-from .response_handler import ResponseHandler
-
-
-@dataclass
-class ProviderConfig:
-    """Configuration for provider initialization."""
-
-    api_key: Optional[str] = None
-    model: str = "gpt-3.5-turbo"
-    system_prompt: Optional[str] = None
-    stream: bool = False
-    seed: Optional[int] = None
-    max_tokens: Optional[int] = None
-    temperature: float = 0.0
-    n_draft: int = 1
-    kwargs: Optional[Dict[str, Any]] = None
-
-
-class ProviderBase(BaseProvider):
-    """
-    Base implementation using composition pattern.
-
-    This class combines all components to provide a complete implementation
-    of the provider interface. Concrete providers should inherit from this
-    class and implement provider-specific methods.
-    """
-
-    def __init__(
-        self,
-        provider_name: str,
-        config: ProviderConfig,
-        auth_manager: Optional[AuthManager] = None,
-        model_registry: Optional[ModelRegistry] = None,
-        chat_history: Optional[ChatHistory] = None,
-        cost_tracker: Optional[CostTracker] = None,
-        response_handler: Optional[ResponseHandler] = None,
-        image_processor: Optional[ImageProcessor] = None,
-    ):
-        """Initialize provider with components."""
-        self.provider_name = provider_name
-        self.config = config
-
-        # Initialize components
-        self.auth_manager = auth_manager or AuthManager()
-        self.model_registry = model_registry or ModelRegistry()
-        self.chat_history = chat_history or ChatHistory()
-        self.cost_tracker = cost_tracker or CostTracker()
-        self.response_handler = response_handler or ResponseHandler()
-        self.image_processor = image_processor or ImageProcessor()
-
-        # Get and validate API key
-        self.api_key = self.auth_manager.get_api_key(provider_name, config.api_key)
-
-        # Initialize provider-specific attributes
-        self.model = config.model
-        self.system_prompt = config.system_prompt
-        self.stream = config.stream
-        self.seed = config.seed
-        self.max_tokens = config.max_tokens
-        self.temperature = config.temperature
-        self.n_draft = config.n_draft
-        self.kwargs = config.kwargs or {}
-
-        # Get model info
-        self.model_info = self._get_model_info()
-
-    def _get_model_info(self) -> ModelInfo:
-        """Get model information from registry."""
-        model_info = self.model_registry.get_model_info(self.model)
-        if not model_info:
-            # Create default model info if not found
-            model_info = ModelInfo(
-                name=self.model,
-                provider=self.provider_name,
-                max_tokens=4096,  # Default
-                supports_images=False,
-                supports_streaming=True,
-            )
-            warnings.warn(
-                f"Model {self.model} not found in registry. Using defaults.",
-                UserWarning,
-            )
-        return model_info
-
-    def call(
-        self,
-        messages: Union[str, List[Dict[str, Any]]],
-        **kwargs: Any,
-    ) -> Union[str, Iterator[str]]:
-        """
-        Main method to interact with the AI provider.
-
-        Parameters
-        ----------
-        messages : Union[str, List[Dict[str, Any]]]
-            Input messages or prompt
-        **kwargs : Any
-            Additional parameters for the API call
-
-        Returns
-        -------
-        Union[str, Iterator[str]]
-            Response text or streaming iterator
-        """
-        # Merge kwargs with instance kwargs
-        call_kwargs = {**self.kwargs, **kwargs}
-
-        # Process messages
-        processed_messages = self._process_messages(messages)
-
-        # Add system prompt if provided
-        if self.system_prompt:
-            processed_messages = self._add_system_prompt(processed_messages)
-
-        # Process images if present
-        processed_messages = self._process_images_in_messages(processed_messages)
-
-        # Store messages in history
-        for msg in processed_messages:
-            if msg["role"] != "system":
-                self.chat_history.add_message(msg["role"], msg["content"])
-
-        # Ensure alternating messages
-        self.chat_history.ensure_alternating()
-
-        # Make API call (to be implemented by concrete providers)
-        response = self._make_api_call(processed_messages, **call_kwargs)
-
-        # Handle response based on stream mode
-        if self.stream:
-            return self._handle_streaming_response(response)
-        else:
-            return self._handle_static_response(response)
-
-    def _process_messages(
-        self, messages: Union[str, List[Dict[str, Any]]]
-    ) -> List[Dict[str, Any]]:
-        """Process input messages into standard format."""
-        if isinstance(messages, str):
-            return [{"role": "user", "content": messages}]
-        return messages
-
-    def _add_system_prompt(
-        self, messages: List[Dict[str, Any]]
-    ) -> List[Dict[str, Any]]:
-        """Add system prompt to messages."""
-        if messages and messages[0]["role"] == "system":
-            # Replace existing system prompt
-            messages[0]["content"] = self.system_prompt
-        else:
-            # Insert system prompt at beginning
-            messages.insert(0, {"role": "system", "content": self.system_prompt})
-        return messages
-
-    def _process_images_in_messages(
-        self, messages: List[Dict[str, Any]]
-    ) -> List[Dict[str, Any]]:
-        """Process images in messages if model supports it."""
-        if not self.model_info.supports_images:
-            return messages
-
-        processed_messages = []
-        for msg in messages:
-            if isinstance(msg.get("content"), list):
-                # Process multimodal content
-                processed_content = []
-                for item in msg["content"]:
-                    if item.get("type") == "image" and "path" in item:
-                        # Process image file
-                        image_data = self.image_processor.process_image(
-                            item["path"], max_size=item.get("max_size", 2048)
-                        )
-                        processed_content.append(
-                            {
-                                "type": "image",
-                                "data": image_data["data"],
-                                "mime_type": image_data["mime_type"],
-                            }
-                        )
-                    else:
-                        processed_content.append(item)
-
-                processed_messages.append(
-                    {
-                        "role": msg["role"],
-                        "content": processed_content,
-                    }
-                )
-            else:
-                processed_messages.append(msg)
-
-        return processed_messages
-
-    def _handle_static_response(self, response: Any) -> str:
-        """Handle static response from API."""
-        result = self.response_handler.handle_static_response(
-            response, self.provider_name
-        )
-
-        # Track usage
-        if result.usage:
-            self.cost_tracker.track_usage(
-                self.model,
-                TokenUsage(
-                    input_tokens=result.usage.input_tokens,
-                    output_tokens=result.usage.output_tokens,
-                ),
-            )
-
-        # Add to history
-        self.chat_history.add_message("assistant", result.content)
-
-        return result.content
-
-    def _handle_streaming_response(self, response: Any) -> Iterator[str]:
-        """Handle streaming response from API."""
-        full_content = []
-        total_usage = TokenUsage()
-
-        for chunk in self.response_handler.handle_streaming_response(
-            response, self.provider_name
-        ):
-            if chunk.content:
-                full_content.append(chunk.content)
-                yield chunk.content
-
-            if chunk.usage:
-                total_usage.input_tokens += chunk.usage.input_tokens
-                total_usage.output_tokens += chunk.usage.output_tokens
-
-        # Track total usage
-        if total_usage.input_tokens > 0 or total_usage.output_tokens > 0:
-            self.cost_tracker.track_usage(self.model, total_usage)
-
-        # Add complete response to history
-        complete_content = "".join(full_content)
-        if complete_content:
-            self.chat_history.add_message("assistant", complete_content)
-
-    def _make_api_call(self, messages: List[Dict[str, Any]], **kwargs: Any) -> Any:
-        """
-        Make API call to the provider.
-
-        This method must be implemented by concrete providers.
-        """
-        raise NotImplementedError(
-            f"{self.__class__.__name__} must implement _make_api_call"
-        )
-
-    def get_usage_stats(self) -> Dict[str, Any]:
-        """Get usage statistics."""
-        return self.cost_tracker.get_usage_stats()
-
-    def reset_usage_stats(self) -> None:
-        """Reset usage statistics."""
-        self.cost_tracker.reset()
-
-    def clear_history(self) -> None:
-        """Clear chat history."""
-        self.chat_history.clear()
-
-    def get_history(self) -> List[Dict[str, str]]:
-        """Get chat history."""
-        return self.chat_history.get_messages()
-
-    def set_system_prompt(self, prompt: str) -> None:
-        """Update system prompt."""
-        self.system_prompt = prompt
-
-    def __repr__(self) -> str:
-        """String representation."""
-        return (
-            f"{self.__class__.__name__}("
-            f"provider={self.provider_name}, "
-            f"model={self.model}, "
-            f"stream={self.stream})"
-        )
-
-
-## EOF

scitex/ai/genai/provider_factory.py

@@ -1,370 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-# Time-stamp: "2024-11-15 12:00:00"
-# Author: Yusuke Watanabe (ywatanabe@alumni.u-tokyo.ac.jp)
-
-"""
-Factory for creating AI provider instances.
-
-This module provides a factory pattern for instantiating different AI providers
-with consistent configuration.
-"""
-
-from enum import Enum
-from typing import Any, Dict, Optional, Type, Union
-import os
-
-from .base_provider import BaseProvider, Provider
-from .provider_base import ProviderConfig
-
-
-class ProviderRegistry:
-    """Registry for managing AI providers and their aliases."""
-
-    def __init__(self):
-        """Initialize the registry with provider storage and aliases."""
-        self._providers: Dict[Provider, Type[BaseProvider]] = {}
-        self._aliases: Dict[str, Provider] = {
-            # OpenAI aliases
-            "openai": Provider.OPENAI,
-            "gpt": Provider.OPENAI,
-            "gpt-3": Provider.OPENAI,
-            "gpt-3.5": Provider.OPENAI,
-            "gpt-4": Provider.OPENAI,
-            "gpt-4o": Provider.OPENAI,
-            "o1": Provider.OPENAI,
-            # Anthropic aliases
-            "anthropic": Provider.ANTHROPIC,
-            "claude": Provider.ANTHROPIC,
-            "claude-2": Provider.ANTHROPIC,
-            "claude-3": Provider.ANTHROPIC,
-            "claude-3-opus": Provider.ANTHROPIC,
-            "claude-3-sonnet": Provider.ANTHROPIC,
-            "claude-3-haiku": Provider.ANTHROPIC,
-            # Google aliases
-            "google": Provider.GOOGLE,
-            "gemini": Provider.GOOGLE,
-            "bard": Provider.GOOGLE,
-            "bison": Provider.GOOGLE,
-            "palm": Provider.GOOGLE,
-            # Groq aliases
-            "groq": Provider.GROQ,
-            "mixtral": Provider.GROQ,
-            "llama": Provider.GROQ,
-            "llama2": Provider.GROQ,
-            "llama3": Provider.GROQ,
-            # Perplexity aliases
-            "perplexity": Provider.PERPLEXITY,
-            "pplx": Provider.PERPLEXITY,
-            # DeepSeek aliases
-            "deepseek": Provider.DEEPSEEK,
-            "deepseek-coder": Provider.DEEPSEEK,
-            "deepseek-chat": Provider.DEEPSEEK,
-        }
-
-    def register(self, provider: Provider, provider_class: Type[BaseProvider]) -> None:
-        """
-        Register a provider implementation.
-
-        Parameters
-        ----------
-        provider : Provider
-            Provider enum value
-        provider_class : Type[BaseProvider]
-            Provider implementation class
-        """
-        self._providers[provider] = provider_class
-
-    def get(self, provider: Provider) -> Type[BaseProvider]:
-        """
-        Get a registered provider class.
-
-        Parameters
-        ----------
-        provider : Provider
-            Provider enum value
-
-        Returns
-        -------
-        Type[BaseProvider]
-            Provider implementation class
-
-        Raises
-        ------
-        ValueError
-            If provider is not registered
-        """
-        if provider not in self._providers:
-            raise ValueError(f"Provider {provider} is not registered")
-        return self._providers[provider]
-
-    def resolve_provider(self, provider_or_model: str) -> Provider:
-        """
-        Resolve a provider from a string or model name.
-
-        Parameters
-        ----------
-        provider_or_model : str
-            Provider name, alias, or model name
-
-        Returns
-        -------
-        Provider
-            Resolved provider enum value
-
-        Raises
-        ------
-        ValueError
-            If provider cannot be resolved
-        """
-        provider_lower = provider_or_model.lower()
-
-        # Direct provider name match
-        for p in Provider:
-            if p.value == provider_lower:
-                return p
-
-        # Alias match
-        if provider_lower in self._aliases:
-            return self._aliases[provider_lower]
-
-        # Try to infer from model name patterns
-        model_patterns = {
-            Provider.OPENAI: [
-                "gpt-",
-                "o1-",
-                "text-davinci",
-                "text-curie",
-                "text-babbage",
-                "text-ada",
-            ],
-            Provider.ANTHROPIC: ["claude-"],
-            Provider.GOOGLE: ["gemini-", "palm-", "bison"],
-            Provider.GROQ: ["mixtral-", "llama-"],
-            Provider.PERPLEXITY: ["pplx-", "perplexity-"],
-            Provider.DEEPSEEK: ["deepseek-"],
-        }
-
-        for provider, patterns in model_patterns.items():
-            if any(provider_lower.startswith(pattern) for pattern in patterns):
-                return provider
-
-        raise ValueError(f"Cannot resolve provider from: {provider_or_model}")
-
-    def list_providers(self) -> list[Provider]:
-        """
-        List registered providers.
-
-        Returns
-        -------
-        list[Provider]
-            List of registered provider enums
-        """
-        return list(self._providers.keys())
-
-
-# Global registry instance
-_registry = ProviderRegistry()
-
-# Auto-register providers when they're imported
-_auto_register_called = False
-
-
-def _auto_register():
-    """Auto-register available provider implementations."""
-    global _auto_register_called
-    if _auto_register_called:
-        return
-    _auto_register_called = True
-
-    # Try to import and register providers
-    try:
-        # Import providers here to trigger their registration
-        # Each provider module should register itself when imported
-        from . import mock_provider  # For testing
-        from . import anthropic_provider
-        from . import openai_provider
-        from . import google_provider
-        from . import groq_provider
-        from . import perplexity_provider
-        from . import deepseek_provider
-        from . import llama_provider
-    except ImportError as e:
-        # Log import errors but continue
-        import warnings
-
-        warnings.warn(f"Failed to import some providers: {e}")
-
-
-class ModelRegistry:
-    """Registry for model information."""
-
-    @staticmethod
-    def get_models_for_provider(provider: str) -> list[str]:
-        """Get available models for a provider."""
-        # This would be implemented with actual model data
-        return []
-
-
-# Module-level convenience functions
-def register_provider(name: str, provider_class: Type[BaseProvider]) -> None:
-    """
-    Register a provider implementation.
-
-    Parameters
-    ----------
-    name : str
-        Provider name
-    provider_class : Type[BaseProvider]
-        Provider implementation class
-    """
-    provider = _registry.resolve_provider(name)
-    _registry.register(provider, provider_class)
-
-
-def create_provider(
-    provider: str,
-    api_key: Optional[str] = None,
-    model: str = "gpt-3.5-turbo",
-    system_prompt: Optional[str] = None,
-    stream: bool = False,
-    seed: Optional[int] = None,
-    max_tokens: Optional[int] = None,
-    temperature: float = 0.0,
-    n_draft: int = 1,
-    **kwargs: Any,
-) -> BaseProvider:
-    """
-    Create a provider instance.
-
-    Parameters
-    ----------
-    provider : str
-        Provider name, alias, or model name
-    api_key : Optional[str]
-        API key for authentication
-    model : str
-        Model name to use
-    system_prompt : Optional[str]
-        System prompt to prepend to messages
-    stream : bool
-        Whether to stream responses
-    seed : Optional[int]
-        Random seed for reproducibility
-    max_tokens : Optional[int]
-        Maximum tokens in response
-    temperature : float
-        Sampling temperature
-    n_draft : int
-        Number of drafts to generate
-    **kwargs : Any
-        Additional provider-specific parameters
-
-    Returns
-    -------
-    BaseProvider
-        Provider instance
-    """
-    # Auto-register providers
-    _auto_register()
-
-    # Resolve provider
-    provider_enum = _registry.resolve_provider(provider)
-
-    # Get provider class
-    provider_class = _registry.get(provider_enum)
-
-    # Create configuration
-    config = ProviderConfig(
-        api_key=api_key,
-        model=model,
-        system_prompt=system_prompt,
-        stream=stream,
-        seed=seed,
-        max_tokens=max_tokens,
-        temperature=temperature,
-        n_draft=n_draft,
-        kwargs=kwargs,
-    )
-
-    # Instantiate provider
-    return provider_class(config)
-
-
-def GenAI(
-    api_key: Optional[str] = None,
-    model: str = "gpt-3.5-turbo",
-    system_prompt: Optional[str] = None,
-    stream: bool = False,
-    seed: Optional[int] = None,
-    max_tokens: Optional[int] = None,
-    temperature: float = 0.0,
-    n_draft: int = 1,
-    provider: Optional[str] = None,
-    **kwargs: Any,
-) -> BaseProvider:
-    """
-    Create an AI provider instance (backward compatibility).
-
-    This function maintains backward compatibility with the old API.
-    If provider is not specified, it infers from the model name.
-
-    Parameters
-    ----------
-    api_key : Optional[str]
-        API key for authentication
-    model : str
-        Model name to use
-    system_prompt : Optional[str]
-        System prompt to prepend to messages
-    stream : bool
-        Whether to stream responses
-    seed : Optional[int]
-        Random seed for reproducibility
-    max_tokens : Optional[int]
-        Maximum tokens in response
-    temperature : float
-        Sampling temperature
-    n_draft : int
-        Number of drafts to generate
-    provider : Optional[str]
-        Provider name (if not specified, inferred from model)
-    **kwargs : Any
-        Additional provider-specific parameters
-
-    Returns
-    -------
-    BaseProvider
-        Provider instance
-    """
-    # If provider is explicitly specified, use it
-    if provider:
-        return create_provider(
-            provider=provider,
-            api_key=api_key,
-            model=model,
-            system_prompt=system_prompt,
-            stream=stream,
-            seed=seed,
-            max_tokens=max_tokens,
-            temperature=temperature,
-            n_draft=n_draft,
-            **kwargs,
-        )
-
-    # Otherwise, try to infer from model name
-    return create_provider(
-        provider=model,  # Let resolve_provider handle it
-        api_key=api_key,
-        model=model,
-        system_prompt=system_prompt,
-        stream=stream,
-        seed=seed,
-        max_tokens=max_tokens,
-        temperature=temperature,
-        n_draft=n_draft,
-        **kwargs,
-    )
-
-
-## EOF