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

scitex/ai/genai/__init__.py

@@ -1,277 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-# Time-stamp: "2024-11-25 12:00:00"
-# Author: Yusuke Watanabe (ywatanabe@alumni.u-tokyo.ac.jp)
-# scitex/src/scitex/ai/genai/__init__.py
-
-"""
-GenAI module for unified access to multiple AI providers.
-
-This module provides a consistent interface for interacting with various
-AI providers (OpenAI, Anthropic, Google, etc.) with built-in cost tracking,
-chat history management, and error handling.
-"""
-
-from typing import List, Dict, Any, Optional, Union
-import logging
-
-from .provider_factory import Provider, create_provider, GenAI as GenAIFactory
-from .auth_manager import AuthManager
-from .chat_history import ChatHistory
-from .cost_tracker import CostTracker
-from .response_handler import ResponseHandler
-from .base_provider import BaseProvider, CompletionResponse
-
-# Import legacy providers for backward compatibility
-from .anthropic import Anthropic
-from .openai import OpenAI
-from .google import Google
-from .groq import Groq
-from .deepseek import DeepSeek
-from .llama import Llama
-from .perplexity import Perplexity
-from .genai_factory import genai_factory
-
-logger = logging.getLogger(__name__)
-
-
-class GenAI:
-    """
-    Unified interface for multiple AI providers.
-
-    This class provides a consistent API for interacting with various AI providers
-    while handling authentication, chat history, cost tracking, and response processing.
-
-    Args:
-        provider: Provider name (e.g., 'openai', 'anthropic', 'google')
-        api_key: Optional API key (if not provided, will use environment variable)
-        model: Model name (if not provided, will use provider's default)
-        system_prompt: Optional system prompt to prepend to conversations
-        **kwargs: Additional provider-specific configuration
-
-    Example:
-        >>> from scitex.ai.genai import GenAI
-        >>>
-        >>> # Basic usage
-        >>> ai = GenAI(provider="openai")
-        >>> response = ai.complete("What is the capital of France?")
-        >>> print(response)
-        "The capital of France is Paris."
-        >>>
-        >>> # With specific model and system prompt
-        >>> ai = GenAI(
-        ...     provider="anthropic",
-        ...     model="claude-3-opus-20240229",
-        ...     system_prompt="You are a helpful geography expert."
-        ... )
-        >>> response = ai.complete("Tell me about Paris.")
-        >>>
-        >>> # Check costs
-        >>> print(ai.get_cost_summary())
-        "Total cost: $0.015 | Requests: 2 | Tokens: 1,234"
-    """
-
-    def __init__(
-        self,
-        provider: Union[str, Provider],
-        api_key: Optional[str] = None,
-        model: Optional[str] = None,
-        system_prompt: Optional[str] = None,
-        **kwargs
-    ):
-        """Initialize GenAI with specified provider."""
-        # Store provider name
-        if isinstance(provider, str):
-            self.provider_name = provider.lower()
-        else:
-            self.provider_name = provider.value
-
-        # Initialize components
-        self.auth_manager = AuthManager(api_key, self.provider_name)
-        self.chat_history = ChatHistory(n_keep=-1)  # Keep all messages by default
-        self.response_handler = ResponseHandler()
-
-        # Get API key from auth manager if not provided
-        if api_key is None:
-            api_key = self.auth_manager.api_key
-
-        # Create provider instance
-        self.provider = create_provider(
-            provider=self.provider_name, api_key=api_key, model=model, **kwargs
-        )
-
-        # Initialize cost tracker with provider and model
-        # Note: provider instance may have a model attribute set during initialization
-        actual_model = getattr(self.provider, "model", None) or model or "unknown"
-        self.cost_tracker = CostTracker(provider=self.provider_name, model=actual_model)
-
-        # Add system prompt if provided
-        if system_prompt:
-            self.chat_history.add_message("system", system_prompt)
-
-        logger.info(f"Initialized GenAI with provider: {self.provider_name}")
-
-    def complete(
-        self, prompt: str, images: Optional[List[str]] = None, **kwargs
-    ) -> str:
-        """
-        Generate a completion for the given prompt.
-
-        Args:
-            prompt: The input prompt
-            images: Optional list of image URLs or base64 strings
-            **kwargs: Additional provider-specific parameters
-
-        Returns:
-            The generated response text
-
-        Raises:
-            ValueError: If the provider doesn't support images but images are provided
-            Exception: Provider-specific exceptions
-        """
-        # Add user message to history
-        self.chat_history.add_message("user", prompt, images)
-
-        # Get messages for API call
-        messages = [msg.to_dict() for msg in self.chat_history.get_messages()]
-
-        # Call provider
-        try:
-            response: CompletionResponse = self.provider.complete(
-                messages=messages, **kwargs
-            )
-        except Exception as e:
-            logger.error(f"Provider {self.provider_name} failed: {str(e)}")
-            raise
-
-        # Process response - CompletionResponse has a content attribute
-        content = response.content
-
-        # Add assistant message to history
-        self.chat_history.add_message("assistant", content)
-
-        # Track costs - CompletionResponse has input_tokens and output_tokens
-        self.cost_tracker.update(
-            input_tokens=response.input_tokens, output_tokens=response.output_tokens
-        )
-
-        return content
-
-    def complete_async(self, prompt: str, images: Optional[List[str]] = None, **kwargs):
-        """
-        Async version of complete method.
-
-        Args:
-            prompt: The input prompt
-            images: Optional list of image URLs or base64 strings
-            **kwargs: Additional provider-specific parameters
-
-        Returns:
-            Awaitable that resolves to the generated response text
-        """
-        raise NotImplementedError("Async completion not yet implemented")
-
-    def stream(self, prompt: str, images: Optional[List[str]] = None, **kwargs):
-        """
-        Stream completions for the given prompt.
-
-        Args:
-            prompt: The input prompt
-            images: Optional list of image URLs or base64 strings
-            **kwargs: Additional provider-specific parameters
-
-        Yields:
-            Chunks of the generated response
-        """
-        raise NotImplementedError("Streaming not yet implemented")
-
-    def clear_history(self):
-        """Clear the chat history."""
-        self.chat_history.clear()
-        logger.info("Chat history cleared")
-
-    def get_history(self) -> List[Dict[str, str]]:
-        """Get the current chat history."""
-        return self.chat_history.messages
-
-    def get_cost_summary(self) -> str:
-        """Get a summary of costs incurred."""
-        return self.cost_tracker.get_summary()
-
-    def get_detailed_costs(self) -> Dict[str, Any]:
-        """Get detailed cost breakdown."""
-        return {
-            "total_cost": self.cost_tracker.total_cost,
-            "total_prompt_tokens": self.cost_tracker.total_prompt_tokens,
-            "total_completion_tokens": self.cost_tracker.total_completion_tokens,
-            "request_count": self.cost_tracker.request_count,
-            "cost_by_model": self.cost_tracker.cost_by_model,
-        }
-
-    def reset_costs(self):
-        """Reset cost tracking."""
-        self.cost_tracker.reset()
-        logger.info("Cost tracking reset")
-
-    def __repr__(self) -> str:
-        """String representation of GenAI instance."""
-        return (
-            f"GenAI(provider='{self.provider_name}', "
-            f"model='{self.provider.model}', "
-            f"requests={self.cost_tracker.request_count})"
-        )
-
-
-# Convenience function for one-off completions
-def complete(
-    prompt: str,
-    provider: Union[str, Provider] = "openai",
-    model: Optional[str] = None,
-    api_key: Optional[str] = None,
-    **kwargs
-) -> str:
-    """
-    Convenience function for one-off completions without managing state.
-
-    Args:
-        prompt: The input prompt
-        provider: Provider name or enum
-        model: Optional model name
-        api_key: Optional API key
-        **kwargs: Additional parameters
-
-    Returns:
-        The generated response text
-
-    Example:
-        >>> from scitex.ai.genai import complete
-        >>> response = complete("What is 2+2?", provider="anthropic")
-        >>> print(response)
-        "2 + 2 = 4"
-    """
-    genai = GenAI(provider=provider, model=model, api_key=api_key)
-    return genai.complete(prompt, **kwargs)
-
-
-# Export public API
-__all__ = [
-    # New API
-    "GenAI",
-    "GenAIFactory",
-    "complete",
-    "Provider",
-    "create_provider",
-    "AuthManager",
-    "ChatHistory",
-    "CostTracker",
-    "ResponseHandler",
-    # Legacy API for backward compatibility
-    "genai_factory",
-    "Anthropic",
-    "OpenAI",
-    "Google",
-    "Groq",
-    "DeepSeek",
-    "Llama",
-    "Perplexity",
-]

scitex/ai/genai/anthropic_provider.py

@@ -1,320 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-# Time-stamp: "2024-11-25 12:00:00"
-# Author: Yusuke Watanabe (ywatanabe@alumni.u-tokyo.ac.jp)
-# scitex/src/scitex/ai/genai/anthropic_provider.py
-
-"""
-Anthropic provider implementation for GenAI.
-"""
-
-from typing import List, Dict, Any, Optional, Generator
-import logging
-
-from .base_provider import BaseProvider, CompletionResponse
-
-logger = logging.getLogger(__name__)
-
-
-class AnthropicProvider(BaseProvider):
-    """
-    Anthropic provider implementation.
-
-    Supports Claude 3 models (Opus, Sonnet, Haiku).
-    """
-
-    SUPPORTED_MODELS = [
-        "claude-3-opus-20240229",
-        "claude-3-sonnet-20240229",
-        "claude-3-haiku-20240307",
-        "claude-2.1",
-        "claude-2.0",
-        "claude-instant-1.2",
-    ]
-
-    DEFAULT_MODEL = "claude-3-sonnet-20240229"
-
-    def __init__(self, config):
-        """Initialize Anthropic provider."""
-        self.config = config
-        self.api_key = config.api_key
-        self.model = config.model or self.DEFAULT_MODEL
-        self.kwargs = config.kwargs or {}
-
-        # Import Anthropic client
-        try:
-            from anthropic import Anthropic as AnthropicClient
-
-            self.client = AnthropicClient(api_key=api_key)
-        except ImportError:
-            raise ImportError(
-                "Anthropic package not installed. Install with: pip install anthropic"
-            )
-
-    def complete(self, messages: List[Dict[str, Any]], **kwargs) -> CompletionResponse:
-        """
-        Generate completion using Anthropic API.
-
-        Args:
-            messages: List of message dictionaries
-            **kwargs: Additional parameters (max_tokens, temperature, etc.)
-
-        Returns:
-            CompletionResponse with generated text and usage info
-        """
-        # Validate messages
-        if not self.validate_messages(messages):
-            raise ValueError("Invalid message format")
-
-        # Format messages for Anthropic
-        formatted_messages = self.format_messages(messages)
-
-        # Extract system message if present
-        system_message = None
-        user_messages = []
-
-        for msg in formatted_messages:
-            if msg["role"] == "system":
-                system_message = msg["content"]
-            else:
-                user_messages.append(msg)
-
-        # Prepare API parameters
-        api_params = {
-            "model": self.model,
-            "messages": user_messages,
-            "max_tokens": kwargs.get("max_tokens", 4096),
-        }
-
-        # Add system message if present
-        if system_message:
-            api_params["system"] = system_message
-
-        # Add optional parameters
-        for param in ["temperature", "top_p", "top_k", "stop_sequences"]:
-            if param in kwargs:
-                api_params[param] = kwargs[param]
-
-        try:
-            # Make API call
-            response = self.client.messages.create(**api_params)
-
-            # Extract content
-            content = response.content[0].text if response.content else ""
-
-            # Extract usage
-            usage = {
-                "prompt_tokens": response.usage.input_tokens,
-                "completion_tokens": response.usage.output_tokens,
-                "total_tokens": response.usage.input_tokens
-                + response.usage.output_tokens,
-            }
-
-            return CompletionResponse(content=content, usage=usage)
-
-        except Exception as e:
-            logger.error(f"Anthropic API error: {str(e)}")
-            raise
-
-    def format_messages(self, messages: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
-        """
-        Format messages for Anthropic API.
-
-        Anthropic expects messages in the format::
-
-            [
-                {"role": "user", "content": "..."},
-                {"role": "assistant", "content": "..."}
-            ]
-
-        System messages are passed separately.
-
-        For images, the content should be a list::
-
-            {
-                "role": "user",
-                "content": [
-                    {"type": "text", "text": "What's in this image?"},
-                    {"type": "image", "source": {"type": "base64", "media_type": "image/jpeg", "data": "..."}}
-                ]
-            }
-        """
-        formatted_messages = []
-
-        for msg in messages:
-            role = msg["role"]
-            content = msg["content"]
-            images = msg.get("images", [])
-
-            if images and self.model.startswith("claude-3"):
-                # Format with images (only Claude 3 supports images)
-                content_parts = [{"type": "text", "text": content}]
-
-                for img in images:
-                    if img.startswith("data:"):
-                        # Extract base64 data
-                        header, data = img.split(",", 1)
-                        media_type = header.split(":")[1].split(";")[0]
-
-                        content_parts.append(
-                            {
-                                "type": "image",
-                                "source": {
-                                    "type": "base64",
-                                    "media_type": media_type,
-                                    "data": data,
-                                },
-                            }
-                        )
-                    else:
-                        # URL images not directly supported, would need to download first
-                        logger.warning("URL images not directly supported by Anthropic")
-
-                formatted_messages.append({"role": role, "content": content_parts})
-            else:
-                # Regular text message
-                formatted_messages.append({"role": role, "content": content})
-
-        return formatted_messages
-
-    def validate_messages(self, messages: List[Dict[str, Any]]) -> bool:
-        """Validate message format."""
-        if not messages:
-            return False
-
-        for msg in messages:
-            if not isinstance(msg, dict):
-                return False
-            if "role" not in msg or "content" not in msg:
-                return False
-            if msg["role"] not in ["system", "user", "assistant"]:
-                return False
-
-        return True
-
-    def stream(
-        self, messages: List[Dict[str, Any]], **kwargs
-    ) -> Generator[str, None, CompletionResponse]:
-        """Generate a streaming completion.
-
-        Args:
-            messages: List of messages in standard format
-            **kwargs: Additional parameters
-
-        Yields:
-            Text chunks during streaming
-
-        Returns:
-            Final CompletionResponse when complete
-        """
-        # Validate messages
-        if not self.validate_messages(messages):
-            raise ValueError("Invalid message format")
-
-        # Format messages for Anthropic
-        formatted_messages = self.format_messages(messages)
-
-        # Extract system message if present
-        system_message = None
-        user_messages = []
-
-        for msg in formatted_messages:
-            if msg["role"] == "system":
-                system_message = msg["content"]
-            else:
-                user_messages.append(msg)
-
-        # Prepare API parameters
-        api_params = {
-            "model": self.model,
-            "messages": user_messages,
-            "max_tokens": kwargs.get("max_tokens", 4096),
-            "stream": True,
-        }
-
-        # Add system message if present
-        if system_message:
-            api_params["system"] = system_message
-
-        # Add optional parameters
-        for param in ["temperature", "top_p", "top_k", "stop_sequences"]:
-            if param in kwargs:
-                api_params[param] = kwargs[param]
-
-        try:
-            # Make streaming API call
-            full_content = ""
-            prompt_tokens = 0
-            completion_tokens = 0
-
-            with self.client.messages.stream(**api_params) as stream:
-                for text in stream.text_stream:
-                    full_content += text
-                    yield text
-
-                # Get final message with usage info
-                message = stream.get_final_message()
-                if hasattr(message, "usage"):
-                    prompt_tokens = message.usage.input_tokens
-                    completion_tokens = message.usage.output_tokens
-
-            # Return final response
-            return CompletionResponse(
-                content=full_content,
-                usage={
-                    "prompt_tokens": prompt_tokens,
-                    "completion_tokens": completion_tokens,
-                    "total_tokens": prompt_tokens + completion_tokens,
-                },
-            )
-
-        except Exception as e:
-            logger.error(f"Anthropic streaming error: {str(e)}")
-            raise
-
-    def count_tokens(self, text: str) -> int:
-        """Count tokens in the given text.
-
-        Args:
-            text: Text to count tokens for
-
-        Returns:
-            Number of tokens
-        """
-        try:
-            # Anthropic uses its own tokenizer
-            return self.client.count_tokens(text)
-        except Exception:
-            # Fallback: rough estimate (Claude tends to use fewer tokens than GPT)
-            return len(text.split()) * 3 // 4
-
-    @property
-    def supports_images(self) -> bool:
-        """Check if this provider/model supports image inputs."""
-        # Only Claude 3 models support images
-        return self.model.startswith("claude-3")
-
-    @property
-    def supports_streaming(self) -> bool:
-        """Check if this provider/model supports streaming."""
-        return True  # All Anthropic models support streaming
-
-    @property
-    def max_context_length(self) -> int:
-        """Get maximum context length for this model."""
-        context_lengths = {
-            "claude-3-opus-20240229": 200000,
-            "claude-3-sonnet-20240229": 200000,
-            "claude-3-haiku-20240307": 200000,
-            "claude-2.1": 200000,
-            "claude-2.0": 100000,
-            "claude-instant-1.2": 100000,
-        }
-        return context_lengths.get(self.model, 100000)
-
-
-# Auto-register when module is imported
-from .base_provider import Provider
-from .provider_factory import register_provider
-
-register_provider(Provider.ANTHROPIC.value, AnthropicProvider)

scitex/ai/genai/anthropic_refactored.py

@@ -1,109 +0,0 @@
-#!/usr/bin/env python3
-"""Refactored Anthropic provider using component architecture."""
-
-from typing import List, Dict, Any, Generator
-import anthropic
-
-from .provider_base import ProviderBase, ProviderConfig
-
-
-class AnthropicProvider(ProviderBase):
-    """Anthropic (Claude) provider implementation."""
-
-    def _init_client(self) -> anthropic.Anthropic:
-        """Initialize Anthropic client."""
-        client_config = self.auth.get_client_config()
-        return anthropic.Anthropic(**client_config)
-
-    def _api_call(self, messages: List[Dict[str, Any]]) -> Any:
-        """Make a non-streaming API call to Anthropic."""
-        # Extract system prompt if present
-        system_prompt = None
-        filtered_messages = []
-
-        for msg in messages:
-            if msg["role"] == "system":
-                system_prompt = msg["content"]
-            else:
-                filtered_messages.append(msg)
-
-        # Make API call
-        response = self.client.messages.create(
-            model=self.config.model,
-            messages=filtered_messages,
-            max_tokens=self.config.max_tokens,
-            temperature=self.config.temperature,
-            system=system_prompt or self.config.system_prompt,
-            stream=False,
-        )
-
-        return response
-
-    def _api_stream(self, messages: List[Dict[str, Any]]) -> Generator[Any, None, None]:
-        """Make a streaming API call to Anthropic."""
-        # Extract system prompt
-        system_prompt = None
-        filtered_messages = []
-
-        for msg in messages:
-            if msg["role"] == "system":
-                system_prompt = msg["content"]
-            else:
-                filtered_messages.append(msg)
-
-        # Make streaming API call
-        stream = self.client.messages.create(
-            model=self.config.model,
-            messages=filtered_messages,
-            max_tokens=self.config.max_tokens,
-            temperature=self.config.temperature,
-            system=system_prompt or self.config.system_prompt,
-            stream=True,
-        )
-
-        for chunk in stream:
-            yield chunk
-
-    def _extract_token_counts(self, response: Any) -> tuple[int, int]:
-        """Extract token counts from Anthropic response."""
-        input_tokens = getattr(response.usage, "input_tokens", 0)
-        output_tokens = getattr(response.usage, "output_tokens", 0)
-        return input_tokens, output_tokens
-
-    def count_tokens(self, text: str) -> int:
-        """Count tokens using Anthropic's tokenizer."""
-        # Anthropic doesn't provide a public tokenizer
-        # Use approximation for now
-        # Claude's tokenization is roughly 1 token per 3.5 characters
-        return len(text) // 3
-
-
-# Example usage:
-if __name__ == "__main__":
-    # Create configuration
-    config = ProviderConfig(
-        provider="anthropic",
-        model="claude-3-opus-20240229",
-        system_prompt="You are a helpful assistant.",
-        temperature=0.7,
-        max_tokens=1024,
-    )
-
-    # Create provider instance
-    claude = AnthropicProvider(config)
-
-    # Use it
-    messages = [{"role": "user", "content": "Hello, how are you?"}]
-
-    # Non-streaming
-    response = claude.complete(messages)
-    print(response.content)
-    print(f"Tokens: {response.input_tokens} in, {response.output_tokens} out")
-
-    # Streaming
-    print("\nStreaming response:")
-    for chunk in claude.stream(messages):
-        print(chunk, end="", flush=True)
-
-    # Get cost summary
-    print("\n\n" + claude.get_cost_summary())