scitex 2.0.0__py2.py3-none-any.whl

scitex/ai/genai/perplexity.py

@@ -0,0 +1,202 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Time-stamp: "2024-11-11 04:11:10 (ywatanabe)"
+# File: ./scitex_repo/src/scitex/ai/_gen_ai/_Perplexity.py
+
+"""
+Functionality:
+    - Implements Perplexity AI interface using OpenAI-compatible API
+    - Provides access to Llama and Mixtral models
+Input:
+    - User prompts and chat history
+    - Model configurations and API credentials
+Output:
+    - Generated text responses from Perplexity models
+    - Token usage statistics
+Prerequisites:
+    - Perplexity API key
+    - openai package
+
+DEPRECATED: This module is deprecated. Please use perplexity_provider.py instead.
+The new provider-based architecture offers better modularity and maintainability.
+"""
+
+"""Imports"""
+import os
+import sys
+from pprint import pprint
+from typing import Dict, Generator, List, Optional
+import warnings
+
+import matplotlib.pyplot as plt
+from openai import OpenAI
+
+from .base_genai import BaseGenAI
+
+warnings.warn(
+    "perplexity.py is deprecated. Please use perplexity_provider.py instead. "
+    "See PROVIDER_MIGRATION_GUIDE.md for migration instructions.",
+    DeprecationWarning,
+    stacklevel=2,
+)
+
+"""Functions & Classes"""
+
+
+class Perplexity(BaseGenAI):
+    def __init__(
+        self,
+        system_setting: str = "",
+        model: str = "",
+        api_key: str = "",
+        stream: bool = False,
+        seed: Optional[int] = None,
+        n_keep: int = 1,
+        temperature: float = 1.0,
+        chat_history: Optional[List[Dict[str, str]]] = None,
+        max_tokens: Optional[int] = None,  # Added parameter
+    ) -> None:
+        # Set max_tokens based on model if not provided
+        if max_tokens is None:
+            max_tokens = 128_000 if "128k" in model else 32_000
+
+        super().__init__(
+            system_setting=system_setting,
+            model=model,
+            api_key=api_key,
+            stream=stream,
+            n_keep=n_keep,
+            temperature=temperature,
+            provider="Perplexity",
+            chat_history=chat_history,
+            max_tokens=max_tokens,
+        )
+
+    def _init_client(self) -> OpenAI:
+        return OpenAI(api_key=self.api_key, base_url="https://api.perplexity.ai")
+        # return OpenAI(
+        #     api_key=self.api_key, base_url="https://api.perplexity.ai/chat/completions"
+        # )
+
+    def _api_call_static(self) -> str:
+        output = self.client.chat.completions.create(
+            model=self.model,
+            messages=self.history,
+            max_tokens=self.max_tokens,
+            stream=False,
+            temperature=self.temperature,
+        )
+
+        print(output)
+
+        out_text = output.choices[0].message.content
+        self.input_tokens += output.usage.prompt_tokens
+        self.output_tokens += output.usage.completion_tokens
+
+        return out_text
+
+    def _api_call_stream(self) -> Generator[str, None, None]:
+        stream = self.client.chat.completions.create(
+            model=self.model,
+            messages=self.history,
+            max_tokens=self.max_tokens,
+            n=1,
+            stream=self.stream,
+            temperature=self.temperature,
+        )
+
+        for chunk in stream:
+            if chunk and chunk.choices[0].finish_reason == "stop":
+                print(chunk.choices)
+                try:
+                    self.input_tokens += chunk.usage.prompt_tokens
+                    self.output_tokens += chunk.usage.completion_tokens
+                except AttributeError:
+                    pass
+
+            if chunk.choices:
+                current_text = chunk.choices[0].delta.content
+                if current_text:
+                    yield current_text
+
+    def _get_available_models(self) -> List[str]:
+        return [
+            "llama-3.1-sonar-small-128k-online",
+            "llama-3.1-sonar-large-128k-online",
+            "llama-3.1-sonar-huge-128k-online",
+            "llama-3.1-sonar-small-128k-chat",
+            "llama-3.1-sonar-large-128k-chat",
+            "llama-3-sonar-small-32k-chat",
+            "llama-3-sonar-small-32k-online",
+            "llama-3-sonar-large-32k-chat",
+            "llama-3-sonar-large-32k-online",
+            "llama-3-8b-instruct",
+            "llama-3-70b-instruct",
+            "mixtral-8x7b-instruct",
+        ]
+
+
+def main() -> None:
+    from ._genai_factory import genai_factory as GenAI
+
+    models = [
+        "llama-3.1-sonar-small-128k-online",
+        "llama-3.1-sonar-large-128k-online",
+        "llama-3.1-sonar-huge-128k-online",
+    ]
+    ai = GenAI(model=models[0], api_key=os.getenv("PERPLEXITY_API_KEY"), stream=False)
+    out = ai("tell me about important citations for epilepsy prediction with citations")
+    print(out)
+
+
+def main():
+    import requests
+
+    url = "https://api.perplexity.ai/chat/completions"
+
+    payload = {
+        "model": "llama-3.1-sonar-small-128k-online",
+        "messages": [
+            {"role": "system", "content": "Be precise and concise."},
+            {
+                "role": "user",
+                "content": "tell me useful citations (scientific peer-reviewed papers) for epilepsy seizure prediction.",
+            },
+        ],
+        "max_tokens": 4096,
+        "temperature": 0.2,
+        "top_p": 0.9,
+        "search_domain_filter": ["perplexity.ai"],
+        "return_images": False,
+        "return_related_questions": False,
+        "search_recency_filter": "month",
+        "top_k": 0,
+        "stream": False,
+        "presence_penalty": 0,
+        "frequency_penalty": 1,
+    }
+    api_key = os.getenv("PERPLEXITY_API_KEY")
+    headers = {
+        "Authorization": f"Bearer {api_key}",
+        "Content-Type": "application/json",
+    }
+
+    response = requests.request("POST", url, json=payload, headers=headers)
+
+    pprint(response.json()["citations"])
+    # pprint(response["citations"])
+
+    # print(response.url)
+    # print(response.links)
+    # print(dir(response))
+    # print(response.text["citations"])
+
+
+if __name__ == "__main__":
+    import scitex
+
+    CONFIG, sys.stdout, sys.stderr, plt, CC = scitex.gen.start(sys, plt, verbose=False)
+    main()
+    scitex.gen.close(CONFIG, verbose=False, notify=False)
+
+# EOF

scitex/ai/genai/perplexity_provider.py

@@ -0,0 +1,205 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Time-stamp: "2024-11-13 20:25:55 (ywatanabe)"
+# File: ./scitex_repo/src/scitex/ai/genai/perplexity_provider.py
+
+"""Perplexity AI provider implementation using the new component-based architecture.
+
+This module provides integration with Perplexity's API using an OpenAI-compatible interface.
+Perplexity offers access to various Llama and Mixtral models with online search capabilities.
+"""
+
+import os
+from typing import Dict, List, Iterator, Optional, Any
+import openai
+from openai import OpenAI
+
+from .base_provider import BaseProvider, ProviderConfig
+
+
+class PerplexityProvider(BaseProvider):
+    """Perplexity AI provider implementation."""
+
+    SUPPORTED_MODELS = [
+        "llama-3.1-sonar-small-128k-online",
+        "llama-3.1-sonar-large-128k-online",
+        "llama-3.1-sonar-huge-128k-online",
+        "llama-3.1-sonar-small-128k-chat",
+        "llama-3.1-sonar-large-128k-chat",
+        "llama-3-sonar-small-32k-chat",
+        "llama-3-sonar-small-32k-online",
+        "llama-3-sonar-large-32k-chat",
+        "llama-3-sonar-large-32k-online",
+        "llama-3-8b-instruct",
+        "llama-3-70b-instruct",
+        "mixtral-8x7b-instruct",
+    ]
+
+    DEFAULT_MODEL = "llama-3.1-sonar-small-128k-online"
+
+    def __init__(self, config: ProviderConfig):
+        """Initialize Perplexity provider.
+
+        Args:
+            config: Provider configuration
+        """
+        self.config = config
+        self.api_key = config.api_key or os.getenv("PERPLEXITY_API_KEY")
+
+        if not self.api_key:
+            raise ValueError(
+                "Perplexity API key not provided. Set PERPLEXITY_API_KEY environment variable or pass api_key."
+            )
+
+        # Initialize OpenAI client with Perplexity endpoint
+        self.client = OpenAI(api_key=self.api_key, base_url="https://api.perplexity.ai")
+
+        # Set default max_tokens based on model if not provided
+        if self.config.max_tokens is None:
+            if "128k" in (config.model or self.DEFAULT_MODEL):
+                self.config.max_tokens = 128_000
+            else:
+                self.config.max_tokens = 32_000
+
+    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"]:
+                raise ValueError(f"Invalid role: {msg['role']}")
+
+    def format_messages(self, messages: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
+        """Format messages for Perplexity API.
+
+        Args:
+            messages: List of message dictionaries
+
+        Returns:
+            Formatted messages
+        """
+        formatted = []
+
+        # Add system prompt if configured
+        if self.config.system_prompt:
+            formatted.append({"role": "system", "content": self.config.system_prompt})
+
+        # Add user messages
+        formatted.extend(messages)
+
+        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
+        params = {
+            "model": self.config.model or self.DEFAULT_MODEL,
+            "messages": formatted_messages,
+            "temperature": self.config.temperature,
+            "max_tokens": self.config.max_tokens,
+            "stream": False,
+        }
+        params.update(kwargs)
+
+        try:
+            response = self.client.chat.completions.create(**params)
+
+            return {
+                "content": response.choices[0].message.content,
+                "model": response.model,
+                "usage": {
+                    "prompt_tokens": response.usage.prompt_tokens,
+                    "completion_tokens": response.usage.completion_tokens,
+                    "total_tokens": response.usage.total_tokens,
+                },
+                "finish_reason": response.choices[0].finish_reason,
+            }
+        except Exception as e:
+            raise RuntimeError(f"Perplexity API 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)
+
+        # Merge config parameters with kwargs
+        params = {
+            "model": self.config.model or self.DEFAULT_MODEL,
+            "messages": formatted_messages,
+            "temperature": self.config.temperature,
+            "max_tokens": self.config.max_tokens,
+            "stream": True,
+        }
+        params.update(kwargs)
+
+        try:
+            stream = self.client.chat.completions.create(**params)
+
+            for chunk in stream:
+                if chunk.choices:
+                    content = chunk.choices[0].delta.content
+                    if content:
+                        yield {
+                            "content": content,
+                            "model": (
+                                chunk.model
+                                if hasattr(chunk, "model")
+                                else params["model"]
+                            ),
+                        }
+
+                # Check for usage in final chunk
+                if hasattr(chunk, "usage") and chunk.usage:
+                    yield {
+                        "content": "",
+                        "usage": {
+                            "prompt_tokens": chunk.usage.prompt_tokens,
+                            "completion_tokens": chunk.usage.completion_tokens,
+                            "total_tokens": chunk.usage.total_tokens,
+                        },
+                        "finish_reason": (
+                            chunk.choices[0].finish_reason if chunk.choices else None
+                        ),
+                    }
+                elif chunk.choices and chunk.choices[0].finish_reason == "stop":
+                    # Handle case where usage might be in a stop chunk
+                    yield {
+                        "content": "",
+                        "finish_reason": "stop",
+                    }
+
+        except Exception as e:
+            raise RuntimeError(f"Perplexity API error: {str(e)}")

scitex/ai/genai/provider_base.py

@@ -0,0 +1,302 @@
+#!/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