scitex 2.0.0__py2.py3-none-any.whl

scitex/ai/genai/groq.py

@@ -0,0 +1,104 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Time-stamp: "2024-11-28 02:47:54 (ywatanabe)"
+# File: ./scitex_repo/src/scitex/ai/_gen_ai/_Groq.py
+
+THIS_FILE = "/home/ywatanabe/proj/scitex_repo/src/scitex/ai/_gen_ai/_Groq.py"
+
+"""
+Functionality:
+    - Implements GLOQ AI interface
+    - Handles both streaming and static text generation
+Input:
+    - User prompts and chat history
+    - Model configurations and API credentials
+Output:
+    - Generated text responses
+    - Token usage statistics
+Prerequisites:
+    - GLOQ API key (GLOQ_API_KEY environment variable)
+    - gloq package
+"""
+
+"""Imports"""
+import os
+import sys
+import warnings
+from typing import Any, Dict, Generator, List, Optional, Union
+
+from groq import Groq as _Groq
+import matplotlib.pyplot as plt
+
+from .base_genai import BaseGenAI
+
+"""Functions & Classes"""
+
+
+class Groq(BaseGenAI):
+    def __init__(
+        self,
+        system_setting: str = "",
+        api_key: Optional[str] = os.getenv("GROQ_API_KEY"),
+        model: str = "llama3-8b-8192",
+        stream: bool = False,
+        seed: Optional[int] = None,
+        n_keep: int = 1,
+        temperature: float = 0.5,
+        chat_history: Optional[List[Dict[str, str]]] = None,
+        max_tokens: int = 8000,
+    ) -> None:
+        warnings.warn(
+            "Groq class is deprecated. Use GenAI(provider='groq') instead. "
+            "Example: from scitex.ai.genai import GenAI; ai = GenAI(provider='groq', model='llama3-8b-8192')",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        max_tokens = min(max_tokens, 8000)
+        if not api_key:
+            raise ValueError("GROQ_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="Groq",
+            chat_history=chat_history,
+            max_tokens=max_tokens,
+        )
+
+    def _init_client(self) -> Any:
+        return _Groq(api_key=self.api_key)
+
+    def _api_call_static(self) -> str:
+        output = self.client.chat.completions.create(
+            model=self.model,
+            messages=self.history,
+            temperature=self.temperature,
+            max_tokens=self.max_tokens,
+            stream=False,
+        )
+        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,
+            temperature=self.temperature,
+            max_tokens=self.max_tokens,
+            stream=True,
+        )
+
+        for chunk in stream:
+            if chunk.choices[0].delta.content:
+                yield chunk.choices[0].delta.content
+
+
+# EOF

scitex/ai/genai/groq_provider.py

@@ -0,0 +1,248 @@
+#!/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/groq_provider.py
+
+"""
+Groq provider implementation for GenAI.
+
+Provides access to Groq's API with models like Llama, Mixtral, etc.
+"""
+
+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 GroqProvider(BaseProvider):
+    """
+    Groq provider implementation.
+
+    Supports Llama 3, Mixtral, and other models available through Groq.
+    """
+
+    SUPPORTED_MODELS = [
+        "llama3-8b-8192",
+        "llama3-70b-8192",
+        "llama2-70b-4096",
+        "mixtral-8x7b-32768",
+        "gemma-7b-it",
+    ]
+
+    DEFAULT_MODEL = "llama3-8b-8192"
+
+    def __init__(self, config):
+        """Initialize Groq provider."""
+        self.config = config
+        self.api_key = config.api_key or os.getenv("GROQ_API_KEY")
+        self.model = config.model or self.DEFAULT_MODEL
+        self.kwargs = config.kwargs or {}
+
+        if not self.api_key:
+            raise ValueError("GROQ_API_KEY not provided and not found in environment")
+
+        # Import Groq client
+        try:
+            from groq import Groq as GroqClient
+
+            self.client = GroqClient(api_key=self.api_key)
+        except ImportError:
+            raise ImportError(
+                "Groq package not installed. Install with: pip install groq"
+            )
+
+    def complete(self, messages: List[Dict[str, Any]], **kwargs) -> CompletionResponse:
+        """
+        Generate completion using Groq 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 Groq (same as OpenAI format)
+        formatted_messages = self.format_messages(messages)
+
+        # Prepare API parameters
+        api_params = {
+            "model": self.model,
+            "messages": formatted_messages,
+            "stream": False,
+        }
+
+        # Add optional parameters
+        for param in ["temperature", "max_tokens", "top_p", "stop", "seed"]:
+            if param in kwargs:
+                api_params[param] = kwargs[param]
+
+        # Groq has a max token limit of 8000
+        if "max_tokens" in api_params:
+            api_params["max_tokens"] = min(api_params["max_tokens"], 8000)
+
+        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"Groq API error: {str(e)}")
+            raise
+
+    def format_messages(self, messages: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
+        """
+        Format messages for Groq API.
+
+        Groq 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 Groq
+        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"]:
+            if param in kwargs:
+                api_params[param] = kwargs[param]
+
+        # Groq has a max token limit of 8000
+        if "max_tokens" in api_params:
+            api_params["max_tokens"] = min(api_params["max_tokens"], 8000)
+
+        try:
+            # Make streaming API call
+            stream = self.client.chat.completions.create(**api_params)
+
+            # Track content
+            full_content = ""
+
+            for chunk in stream:
+                if chunk.choices[0].delta.content:
+                    content = chunk.choices[0].delta.content
+                    full_content += content
+                    yield content
+
+            # Estimate tokens for streaming (Groq doesn't provide usage in stream)
+            input_tokens = self.count_tokens(str(formatted_messages))
+            output_tokens = self.count_tokens(full_content)
+
+            # Return final response
+            return CompletionResponse(
+                content=full_content,
+                input_tokens=input_tokens,
+                output_tokens=output_tokens,
+                finish_reason="stop",
+            )
+
+        except Exception as e:
+            logger.error(f"Groq 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)
+        """
+        # Groq doesn't provide a token counter, so estimate
+        # Llama tokenization is roughly similar to GPT
+        return len(text.split()) * 4 // 3
+
+    @property
+    def supports_images(self) -> bool:
+        """Check if this provider/model supports image inputs."""
+        # Groq doesn't currently 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."""
+        context_lengths = {
+            "llama3-8b-8192": 8192,
+            "llama3-70b-8192": 8192,
+            "llama2-70b-4096": 4096,
+            "mixtral-8x7b-32768": 32768,
+            "gemma-7b-it": 8192,
+        }
+        return context_lengths.get(self.model, 8192)
+
+
+# Auto-register when module is imported
+register_provider(Provider.GROQ.value, GroqProvider)

scitex/ai/genai/image_processor.py

@@ -0,0 +1,250 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Time-stamp: "2025-05-31 10:25:00"
+# Author: ywatanabe
+# File: ./src/scitex/ai/genai/image_processor.py
+
+"""
+Handles image processing for multimodal AI inputs.
+
+This module provides image processing functionality including:
+- Image resizing to fit token limits
+- Base64 encoding for API transmission
+- Multiple format support (file path, bytes, PIL Image)
+- Format validation
+"""
+
+import base64
+import io
+from typing import Union, Tuple, Optional
+from PIL import Image
+
+
+class ImageProcessor:
+    """Processes images for multimodal AI inputs.
+
+    Example
+    -------
+    >>> processor = ImageProcessor()
+    >>> # Process image from file
+    >>> base64_str = processor.process_image("path/to/image.jpg", max_size=512)
+    >>> print(base64_str[:50])
+    /9j/4AAQSkZJRgABAQEASABIAAD/2wBDAAgGBgcGBQgHBw...
+
+    >>> # Process PIL Image
+    >>> from PIL import Image
+    >>> img = Image.new('RGB', (100, 100), color='red')
+    >>> base64_str = processor.process_image(img)
+    """
+
+    def __init__(self):
+        """Initialize image processor."""
+        self.supported_formats = {".jpg", ".jpeg", ".png", ".gif", ".bmp", ".webp"}
+
+    def process_image(
+        self, image: Union[str, bytes, Image.Image], max_size: int = 512
+    ) -> str:
+        """Process an image for API transmission.
+
+        Parameters
+        ----------
+        image : Union[str, bytes, Image.Image]
+            Image as file path, bytes, or PIL Image
+        max_size : int
+            Maximum dimension (width or height) in pixels
+
+        Returns
+        -------
+        str
+            Base64 encoded image string
+        """
+        # Convert to PIL Image
+        pil_image = self._to_pil_image(image)
+
+        # Resize if needed
+        if max(pil_image.size) > max_size:
+            pil_image = self.resize_image(pil_image, max_size)
+
+        # Convert to base64
+        return self.to_base64(pil_image)
+
+    def _to_pil_image(self, image: Union[str, bytes, Image.Image]) -> Image.Image:
+        """Convert various image formats to PIL Image.
+
+        Parameters
+        ----------
+        image : Union[str, bytes, Image.Image]
+            Input image in various formats
+
+        Returns
+        -------
+        Image.Image
+            PIL Image object
+        """
+        if isinstance(image, Image.Image):
+            return image
+
+        if isinstance(image, str):
+            # Check if it's a base64 string
+            if image.startswith("data:image"):
+                # Extract base64 data from data URL
+                base64_data = image.split(",")[1]
+                image_bytes = base64.b64decode(base64_data)
+                return Image.open(io.BytesIO(image_bytes))
+            else:
+                # Assume it's a file path
+                try:
+                    return Image.open(image)
+                except Exception as e:
+                    # Maybe it's already base64 encoded
+                    try:
+                        image_bytes = base64.b64decode(image)
+                        return Image.open(io.BytesIO(image_bytes))
+                    except:
+                        raise ValueError(f"Could not load image from string: {e}")
+
+        if isinstance(image, bytes):
+            return Image.open(io.BytesIO(image))
+
+        raise ValueError(f"Unsupported image type: {type(image)}")
+
+    def resize_image(self, image: Image.Image, max_size: int) -> Image.Image:
+        """Resize image to fit within max_size while maintaining aspect ratio.
+
+        Parameters
+        ----------
+        image : Image.Image
+            PIL Image to resize
+        max_size : int
+            Maximum dimension in pixels
+
+        Returns
+        -------
+        Image.Image
+            Resized PIL Image
+        """
+        # Calculate new dimensions
+        width, height = image.size
+        aspect_ratio = width / height
+
+        if width > height:
+            new_width = max_size
+            new_height = int(max_size / aspect_ratio)
+        else:
+            new_height = max_size
+            new_width = int(max_size * aspect_ratio)
+
+        # Use high-quality resampling
+        return image.resize((new_width, new_height), Image.Resampling.LANCZOS)
+
+    def to_base64(self, image: Image.Image, format: str = "JPEG") -> str:
+        """Convert PIL Image to base64 string.
+
+        Parameters
+        ----------
+        image : Image.Image
+            PIL Image to encode
+        format : str
+            Output format (JPEG, PNG, etc.)
+
+        Returns
+        -------
+        str
+            Base64 encoded image string
+        """
+        # Convert RGBA to RGB if saving as JPEG
+        if format.upper() == "JPEG" and image.mode in ("RGBA", "LA", "P"):
+            # Create a white background
+            background = Image.new("RGB", image.size, (255, 255, 255))
+            if image.mode == "P":
+                image = image.convert("RGBA")
+            background.paste(
+                image, mask=image.split()[-1] if image.mode == "RGBA" else None
+            )
+            image = background
+
+        # Save to bytes buffer
+        buffer = io.BytesIO()
+        image.save(
+            buffer, format=format, quality=95 if format.upper() == "JPEG" else None
+        )
+
+        # Encode to base64
+        return base64.b64encode(buffer.getvalue()).decode("utf-8")
+
+    def get_image_info(self, image: Union[str, bytes, Image.Image]) -> dict:
+        """Get information about an image.
+
+        Parameters
+        ----------
+        image : Union[str, bytes, Image.Image]
+            Image to analyze
+
+        Returns
+        -------
+        dict
+            Image information including size, mode, format
+        """
+        pil_image = self._to_pil_image(image)
+
+        return {
+            "width": pil_image.width,
+            "height": pil_image.height,
+            "mode": pil_image.mode,
+            "format": pil_image.format,
+            "size_mb": self._estimate_size_mb(pil_image),
+        }
+
+    def _estimate_size_mb(self, image: Image.Image) -> float:
+        """Estimate image size in megabytes.
+
+        Parameters
+        ----------
+        image : Image.Image
+            PIL Image
+
+        Returns
+        -------
+        float
+            Estimated size in MB
+        """
+        # Rough estimate based on dimensions and mode
+        bytes_per_pixel = len(image.mode)  # Rough estimate
+        total_bytes = image.width * image.height * bytes_per_pixel
+        return total_bytes / (1024 * 1024)
+
+    def validate_image(self, image_path: str) -> bool:
+        """Validate if a file is a supported image format.
+
+        Parameters
+        ----------
+        image_path : str
+            Path to image file
+
+        Returns
+        -------
+        bool
+            True if valid image format
+        """
+        if not isinstance(image_path, str):
+            return False
+
+        # Check file extension
+        ext = image_path.lower().split(".")[-1]
+        if f".{ext}" not in self.supported_formats:
+            return False
+
+        # Try to open the image
+        try:
+            img = Image.open(image_path)
+            img.verify()
+            return True
+        except:
+            return False
+
+    def __repr__(self) -> str:
+        """String representation of ImageProcessor."""
+        return f"ImageProcessor(supported_formats={self.supported_formats})"
+
+
+# EOF