scitex 2.0.0__py2.py3-none-any.whl

scitex/ai/genai/anthropic.py

@@ -0,0 +1,177 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Timestamp: "2025-02-26 09:02:48 (ywatanabe)"
+# File: ./src/scitex/ai/_gen_ai/_Anthropic.py
+
+THIS_FILE = "/home/ywatanabe/proj/scitex_repo/src/scitex/ai/_gen_ai/_Anthropic.py"
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Time-stamp: "2025-02-26 09:02:48 (ywatanabe)"
+# File: ./scitex_repo/src/scitex/ai/_gen_ai/_Anthropic.py
+
+THIS_FILE = "/home/ywatanabe/proj/scitex_repo/src/scitex/ai/_gen_ai/_Anthropic.py"
+
+"""
+Functionality:
+    - Implements Anthropic AI (Claude) interface
+    - Handles both streaming and static text generation
+Input:
+    - User prompts and chat history
+    - Model configurations and API credentials
+Output:
+    - Generated text responses from Claude models
+    - Token usage statistics
+Prerequisites:
+    - Anthropic API key (ANTHROPIC_API_KEY environment variable)
+    - anthropic package
+"""
+
+"""Imports"""
+import os
+import sys
+from typing import Any, Dict, Generator, List, Optional, Union
+
+import anthropic
+import matplotlib.pyplot as plt
+
+from .base_genai import BaseGenAI
+import re
+
+
+"""Functions & Classes"""
+
+
+class Anthropic(BaseGenAI):
+    def __init__(
+        self,
+        system_setting: str = "",
+        api_key: Optional[str] = os.getenv("ANTHROPIC_API_KEY"),
+        model: str = "claude-3-opus-20240229",
+        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: int = 100_000,
+    ) -> None:
+
+        if model == "claude-3-7-sonnet-2025-0219":
+            max_tokens = 128_000
+
+        api_key = api_key or os.getenv("ANTHROPIC_API_KEY")
+
+        if not api_key:
+            raise ValueError("ANTHROPIC_API_KEY environment variable not set")
+
+        super().__init__(
+            system_setting=system_setting,
+            model=model,
+            api_key=api_key,
+            stream=stream,
+            n_keep=n_keep,
+            temperature=temperature,
+            provider="Anthropic",
+            chat_history=chat_history,
+            max_tokens=max_tokens,
+        )
+
+    def _init_client(self) -> anthropic.Anthropic:
+        return anthropic.Anthropic(api_key=self.api_key)
+
+    def _api_format_history(self, history):
+        formatted_history = []
+        for msg in history:
+            if isinstance(msg["content"], list):
+                content = []
+                for item in msg["content"]:
+                    if item["type"] == "text":
+                        content.append({"type": "text", "text": item["text"]})
+                    elif item["type"] == "_image":
+                        content.append(
+                            {
+                                "type": "image",
+                                "source": {
+                                    "type": "base64",
+                                    "media_type": "image/jpeg",
+                                    "data": item["_image"],
+                                },
+                            }
+                        )
+                formatted_msg = {"role": msg["role"], "content": content}
+            else:
+                formatted_msg = {
+                    "role": msg["role"],
+                    "content": msg["content"],
+                }
+            formatted_history.append(formatted_msg)
+        return formatted_history
+
+    def _api_call_static(self) -> str:
+        output = self.client.messages.create(
+            model=self.model,
+            max_tokens=self.max_tokens,
+            messages=self.history,
+            temperature=self.temperature,
+        )
+        out_text = output.content[0].text
+
+        self.input_tokens += output.usage.input_tokens
+        self.output_tokens += output.usage.output_tokens
+
+        return out_text
+
+    def _api_call_stream(self) -> Generator[str, None, None]:
+        with self.client.messages.stream(
+            model=self.model,
+            max_tokens=self.max_tokens,
+            messages=self.history,
+            temperature=self.temperature,
+        ) as stream:
+            for chunk in stream:
+                try:
+                    self.input_tokens += chunk.message.usage.input_tokens
+                    self.output_tokens += chunk.message.usage.output_tokens
+                except AttributeError:
+                    pass
+
+                if chunk.type == "content_block_delta":
+                    yield chunk.delta.text
+
+
+def main() -> None:
+    import scitex
+
+    ai = scitex.ai.GenAI(
+        model="claude-3-5-sonnet-20241022",
+        api_key=os.getenv("ANTHROPIC_API_KEY"),
+        n_keep=10,
+    )
+    print(ai("hi"))
+    print(ai("My name is Yusuke"))
+    print(ai("do you remember my name?"))
+
+    print(
+        ai(
+            "hi, could you tell me what is in the pic?",
+            images=[
+                "/home/ywatanabe/Downloads/2560px-Gfp-wisconsin-madison-the-nature-boardwalk.jpg"
+            ],
+        )
+    )
+    pass
+
+
+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)
+
+
+"""
+python src/scitex/ai/_gen_ai/_Anthropic.py
+python -m src.scitex.ai._gen_ai._Anthropic
+"""
+
+# EOF

scitex/ai/genai/anthropic_provider.py

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

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