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

scitex/ai/genai/deepseek_provider.py

@@ -1,251 +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/deepseek_provider.py
-
-"""
-DeepSeek provider implementation for GenAI.
-
-Provides access to DeepSeek's API for code generation and chat.
-Uses OpenAI-compatible API endpoint.
-"""
-
-from typing import List, Dict, Any, Optional, Generator
-import logging
-import os
-
-from .base_provider import BaseProvider, CompletionResponse, Provider
-from .provider_factory import register_provider
-
-logger = logging.getLogger(__name__)
-
-
-class DeepSeekProvider(BaseProvider):
-    """
-    DeepSeek provider implementation.
-
-    Supports DeepSeek Chat and DeepSeek Coder models.
-    """
-
-    SUPPORTED_MODELS = [
-        "deepseek-chat",
-        "deepseek-coder",
-    ]
-
-    DEFAULT_MODEL = "deepseek-chat"
-
-    def __init__(self, config):
-        """Initialize DeepSeek provider."""
-        self.config = config
-        self.api_key = config.api_key or os.getenv("DEEPSEEK_API_KEY")
-        self.model = config.model or self.DEFAULT_MODEL
-        self.kwargs = config.kwargs or {}
-
-        if not self.api_key:
-            raise ValueError(
-                "DEEPSEEK_API_KEY not provided and not found in environment"
-            )
-
-        # Import OpenAI client (DeepSeek uses OpenAI-compatible API)
-        try:
-            from openai import OpenAI as OpenAIClient
-
-            # DeepSeek uses a custom base URL
-            self.client = OpenAIClient(
-                api_key=self.api_key, base_url="https://api.deepseek.com/beta"
-            )
-        except ImportError:
-            raise ImportError(
-                "OpenAI package not installed. Install with: pip install openai"
-            )
-
-    def complete(self, messages: List[Dict[str, Any]], **kwargs) -> CompletionResponse:
-        """
-        Generate completion using DeepSeek API.
-
-        Args:
-            messages: List of message dictionaries
-            **kwargs: Additional parameters (temperature, max_tokens, 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 DeepSeek (same as OpenAI format)
-        formatted_messages = self.format_messages(messages)
-
-        # Prepare API parameters
-        api_params = {
-            "model": self.model,
-            "messages": formatted_messages,
-        }
-
-        # Add optional parameters
-        for param in ["temperature", "max_tokens", "top_p", "stop", "seed", "n"]:
-            if param in kwargs:
-                api_params[param] = kwargs[param]
-
-        try:
-            # Make API call
-            response = self.client.chat.completions.create(**api_params)
-
-            # Extract content and usage
-            content = response.choices[0].message.content
-            usage = response.usage
-
-            return CompletionResponse(
-                content=content,
-                input_tokens=usage.prompt_tokens,
-                output_tokens=usage.completion_tokens,
-                finish_reason=response.choices[0].finish_reason,
-                provider_response=response,
-            )
-
-        except Exception as e:
-            logger.error(f"DeepSeek API error: {str(e)}")
-            raise
-
-    def format_messages(self, messages: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
-        """
-        Format messages for DeepSeek API.
-
-        DeepSeek uses the same message format as OpenAI.
-        """
-        formatted_messages = []
-
-        for msg in messages:
-            formatted_msg = {"role": msg["role"], "content": msg["content"]}
-            formatted_messages.append(formatted_msg)
-
-        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 DeepSeek
-        formatted_messages = self.format_messages(messages)
-
-        # Prepare API parameters
-        api_params = {
-            "model": self.model,
-            "messages": formatted_messages,
-            "stream": True,
-        }
-
-        # Add optional parameters
-        for param in ["temperature", "max_tokens", "top_p", "stop", "seed", "n"]:
-            if param in kwargs:
-                api_params[param] = kwargs[param]
-
-        try:
-            # Make streaming API call
-            stream = self.client.chat.completions.create(**api_params)
-
-            # Track content and usage
-            full_content = ""
-            prompt_tokens = 0
-            completion_tokens = 0
-
-            for chunk in stream:
-                if chunk.choices[0].delta.content:
-                    content = chunk.choices[0].delta.content
-                    full_content += content
-                    yield content
-
-                # Try to get usage info from chunks (if available)
-                if hasattr(chunk, "usage") and chunk.usage:
-                    if hasattr(chunk.usage, "prompt_tokens"):
-                        prompt_tokens = chunk.usage.prompt_tokens
-                    if hasattr(chunk.usage, "completion_tokens"):
-                        completion_tokens = chunk.usage.completion_tokens
-
-            # If no usage info from stream, estimate
-            if prompt_tokens == 0:
-                prompt_tokens = self.count_tokens(str(formatted_messages))
-            if completion_tokens == 0:
-                completion_tokens = self.count_tokens(full_content)
-
-            # Return final response
-            return CompletionResponse(
-                content=full_content,
-                input_tokens=prompt_tokens,
-                output_tokens=completion_tokens,
-                finish_reason="stop",
-            )
-
-        except Exception as e:
-            logger.error(f"DeepSeek 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 (estimated)
-        """
-        # DeepSeek uses similar tokenization to GPT models
-        # Rough estimate: 1 token ≈ 4 characters or 0.75 words
-        return len(text.split()) * 4 // 3
-
-    @property
-    def supports_images(self) -> bool:
-        """Check if this provider/model supports image inputs."""
-        # DeepSeek currently doesn't support multimodal inputs
-        return False
-
-    @property
-    def supports_streaming(self) -> bool:
-        """Check if this provider/model supports streaming."""
-        return True
-
-    @property
-    def max_context_length(self) -> int:
-        """Get maximum context length for this model."""
-        # DeepSeek models typically support 4K-16K context
-        context_lengths = {
-            "deepseek-chat": 4096,
-            "deepseek-coder": 16384,
-        }
-        return context_lengths.get(self.model, 4096)
-
-
-# Auto-register when module is imported
-register_provider(Provider.DEEPSEEK.value, DeepSeekProvider)

scitex/ai/genai/google_provider.py

@@ -1,228 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-# Time-stamp: "2024-11-13 20:25:55 (ywatanabe)"
-# File: ./scitex_repo/src/scitex/ai/genai/google_provider.py
-
-"""Google Generative AI (Gemini) provider implementation using the new component-based architecture.
-
-This module provides integration with Google's Gemini models through the google.generativeai API.
-"""
-
-import os
-from typing import Dict, List, Iterator, Optional, Any
-
-try:
-    from google import genai
-except ImportError:
-    raise ImportError(
-        "google-generativeai package is required for Google provider. "
-        "Install with: pip install google-generativeai"
-    )
-
-from .base_provider import BaseProvider, ProviderConfig
-
-
-class GoogleProvider(BaseProvider):
-    """Google Generative AI (Gemini) provider implementation."""
-
-    SUPPORTED_MODELS = [
-        "gemini-1.5-pro-latest",
-        "gemini-1.5-flash-latest",
-        "gemini-2.0-flash-exp",
-        "gemini-2.0-flash",
-        "gemini-2.0-flash-thinking-exp-01-21",
-        "gemini-2.0-pro-exp-02-05",
-        "gemini-2.0-flash-lite-preview-02-05",
-    ]
-
-    DEFAULT_MODEL = "gemini-1.5-pro-latest"
-
-    def __init__(self, config: ProviderConfig):
-        """Initialize Google provider.
-
-        Args:
-            config: Provider configuration
-        """
-        self.config = config
-        self.api_key = config.api_key or os.getenv("GOOGLE_API_KEY")
-
-        if not self.api_key:
-            raise ValueError(
-                "Google API key not provided. Set GOOGLE_API_KEY environment variable or pass api_key."
-            )
-
-        # Initialize Google Generative AI client
-        self.client = genai.Client(api_key=self.api_key)
-
-        # Set default max_tokens if not provided
-        if self.config.max_tokens is None:
-            self.config.max_tokens = 32_768
-
-    def validate_messages(self, messages: List[Dict[str, Any]]) -> None:
-        """Validate message format.
-
-        Args:
-            messages: List of message dictionaries
-
-        Raises:
-            ValueError: If messages are invalid
-        """
-        if not messages:
-            raise ValueError("Messages cannot be empty")
-
-        for msg in messages:
-            if "role" not in msg:
-                raise ValueError(f"Missing role in message: {msg}")
-            if "content" not in msg:
-                raise ValueError(f"Missing content in message: {msg}")
-            if msg["role"] not in ["system", "user", "assistant", "model"]:
-                raise ValueError(f"Invalid role: {msg['role']}")
-
-    def format_messages(self, messages: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
-        """Format messages for Google Generative AI API.
-
-        Google expects a specific format with 'parts' and 'model' role instead of 'assistant'.
-
-        Args:
-            messages: List of message dictionaries
-
-        Returns:
-            Formatted messages for Google API
-        """
-        formatted = []
-
-        # Add system prompt if configured
-        if self.config.system_prompt:
-            formatted.append(
-                {"role": "user", "parts": [{"text": self.config.system_prompt}]}
-            )
-            formatted.append(
-                {
-                    "role": "model",
-                    "parts": [
-                        {"text": "I understand. I will follow these instructions."}
-                    ],
-                }
-            )
-
-        # Format user messages
-        for msg in messages:
-            role = msg["role"]
-            # Convert assistant to model for Google API
-            if role == "assistant":
-                role = "model"
-            elif role == "system":
-                # System messages are handled as user messages in Google API
-                role = "user"
-
-            # Check if already formatted with parts
-            if isinstance(msg.get("parts"), list):
-                formatted.append({"role": role, "parts": msg["parts"]})
-            else:
-                formatted.append({"role": role, "parts": [{"text": msg["content"]}]})
-
-        return formatted
-
-    def complete(self, messages: List[Dict[str, Any]], **kwargs) -> Dict[str, Any]:
-        """Generate a completion.
-
-        Args:
-            messages: List of message dictionaries
-            **kwargs: Additional parameters for the API
-
-        Returns:
-            Completion response dictionary
-        """
-        self.validate_messages(messages)
-        formatted_messages = self.format_messages(messages)
-
-        # Merge config parameters with kwargs
-        model = self.config.model or self.DEFAULT_MODEL
-
-        try:
-            response = self.client.models.generate_content(
-                model=model,
-                contents=formatted_messages,
-                # Google API doesn't support all OpenAI parameters directly
-                # Temperature and other settings would need to be set via generation_config
-            )
-
-            # Extract token usage if available
-            usage = {}
-            if hasattr(response, "usage_metadata"):
-                usage = {
-                    "prompt_tokens": response.usage_metadata.prompt_token_count,
-                    "completion_tokens": response.usage_metadata.candidates_token_count,
-                    "total_tokens": (
-                        response.usage_metadata.prompt_token_count
-                        + response.usage_metadata.candidates_token_count
-                    ),
-                }
-
-            return {
-                "content": response.text,
-                "model": model,
-                "usage": usage,
-                "finish_reason": "stop",
-            }
-        except Exception as e:
-            raise RuntimeError(f"Google Generative AI error: {str(e)}")
-
-    def stream(
-        self, messages: List[Dict[str, Any]], **kwargs
-    ) -> Iterator[Dict[str, Any]]:
-        """Stream a completion.
-
-        Args:
-            messages: List of message dictionaries
-            **kwargs: Additional parameters for the API
-
-        Yields:
-            Chunks of the completion
-        """
-        self.validate_messages(messages)
-        formatted_messages = self.format_messages(messages)
-
-        model = self.config.model or self.DEFAULT_MODEL
-
-        try:
-            stream = self.client.models.generate_content_stream(
-                model=model,
-                contents=formatted_messages,
-            )
-
-            total_prompt_tokens = 0
-            total_completion_tokens = 0
-
-            for chunk in stream:
-                if chunk and hasattr(chunk, "text") and chunk.text:
-                    # Track token usage if available
-                    if hasattr(chunk, "usage_metadata"):
-                        if hasattr(chunk.usage_metadata, "prompt_token_count"):
-                            total_prompt_tokens += (
-                                chunk.usage_metadata.prompt_token_count
-                            )
-                        if hasattr(chunk.usage_metadata, "candidates_token_count"):
-                            total_completion_tokens += (
-                                chunk.usage_metadata.candidates_token_count
-                            )
-
-                    yield {
-                        "content": chunk.text,
-                        "model": model,
-                    }
-
-            # Yield final chunk with usage info if we collected any
-            if total_prompt_tokens > 0 or total_completion_tokens > 0:
-                yield {
-                    "content": "",
-                    "usage": {
-                        "prompt_tokens": total_prompt_tokens,
-                        "completion_tokens": total_completion_tokens,
-                        "total_tokens": total_prompt_tokens + total_completion_tokens,
-                    },
-                    "finish_reason": "stop",
-                }
-
-        except Exception as e:
-            raise RuntimeError(f"Google Generative AI error: {str(e)}")