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

scitex/ai/genai/groq_provider.py

@@ -1,248 +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/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

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

scitex/ai/genai/llama_provider.py

@@ -1,214 +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/llama_provider.py
-
-"""Llama provider implementation using the new component-based architecture.
-
-This module provides integration with local Llama models through the official Llama library.
-It supports loading and running Llama models locally with full control over model parameters.
-"""
-
-import os
-from typing import Dict, List, Iterator, Optional, Any
-
-try:
-    from llama import Llama as _Llama
-    from llama import Dialog
-except ImportError:
-    _Llama = None
-    Dialog = None
-    print(
-        "Warning: llama package not installed. "
-        "Install with the official Meta Llama repository instructions."
-    )
-
-from .base_provider import BaseProvider, ProviderConfig
-
-
-class LlamaProvider(BaseProvider):
-    """Llama provider implementation for local model inference."""
-
-    SUPPORTED_MODELS = [
-        "Meta-Llama-3-8B",
-        "Meta-Llama-3-70B",
-        "Meta-Llama-3.1-8B",
-        "Meta-Llama-3.1-70B",
-        "Meta-Llama-3.1-405B",
-        "Llama-2-7b",
-        "Llama-2-13b",
-        "Llama-2-70b",
-    ]
-
-    DEFAULT_MODEL = "Meta-Llama-3-8B"
-
-    def __init__(self, config: ProviderConfig):
-        """Initialize Llama provider.
-
-        Args:
-            config: Provider configuration
-        """
-        self.config = config
-        self.model_name = config.model or self.DEFAULT_MODEL
-
-        # Llama-specific configuration
-        self.ckpt_dir = getattr(config, "ckpt_dir", None) or f"{self.model_name}/"
-        self.tokenizer_path = (
-            getattr(config, "tokenizer_path", None)
-            or f"{self.model_name}/tokenizer.model"
-        )
-        self.max_seq_len = getattr(config, "max_seq_len", 32_768)
-        self.max_batch_size = getattr(config, "max_batch_size", 4)
-        self.max_gen_len = config.max_tokens
-
-        # Configure environment variables for distributed inference
-        self._setup_environment()
-
-        # Initialize the Llama model
-        if _Llama is None:
-            raise ImportError(
-                "Llama package is not installed. Please install it from the official Meta repository."
-            )
-
-        try:
-            self.generator = _Llama.build(
-                ckpt_dir=self.ckpt_dir,
-                tokenizer_path=self.tokenizer_path,
-                max_seq_len=self.max_seq_len,
-                max_batch_size=self.max_batch_size,
-            )
-        except Exception as e:
-            raise RuntimeError(f"Failed to load Llama model: {str(e)}")
-
-    def _setup_environment(self):
-        """Set up environment variables for distributed inference."""
-        env_vars = {
-            "MASTER_ADDR": os.getenv("MASTER_ADDR", "localhost"),
-            "MASTER_PORT": os.getenv("MASTER_PORT", "12355"),
-            "WORLD_SIZE": os.getenv("WORLD_SIZE", "1"),
-            "RANK": os.getenv("RANK", "0"),
-        }
-
-        for key, value in env_vars.items():
-            os.environ[key] = value
-
-    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 Llama API.
-
-        Args:
-            messages: List of message dictionaries
-
-        Returns:
-            Formatted messages for Llama
-        """
-        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)
-
-        # Convert to Llama Dialog format
-        dialogs: List[Dialog] = [formatted_messages]
-
-        # Merge config parameters with kwargs
-        params = {
-            "max_gen_len": self.max_gen_len,
-            "temperature": self.config.temperature or 1.0,
-            "top_p": kwargs.get("top_p", 0.9),
-        }
-
-        try:
-            results = self.generator.chat_completion(dialogs, **params)
-
-            result = results[0]
-            content = result["generation"]["content"]
-
-            # Estimate token counts (Llama doesn't provide exact counts)
-            prompt_tokens = len(
-                " ".join(msg["content"] for msg in formatted_messages).split()
-            )
-            completion_tokens = len(content.split())
-
-            return {
-                "content": content,
-                "model": self.model_name,
-                "usage": {
-                    "prompt_tokens": prompt_tokens,
-                    "completion_tokens": completion_tokens,
-                    "total_tokens": prompt_tokens + completion_tokens,
-                },
-                "finish_reason": "stop",
-            }
-        except Exception as e:
-            raise RuntimeError(f"Llama inference error: {str(e)}")
-
-    def stream(
-        self, messages: List[Dict[str, Any]], **kwargs
-    ) -> Iterator[Dict[str, Any]]:
-        """Stream a completion.
-
-        Note: Llama doesn't have native streaming support, so this simulates streaming
-        by yielding characters one at a time.
-
-        Args:
-            messages: List of message dictionaries
-            **kwargs: Additional parameters for the API
-
-        Yields:
-            Chunks of the completion
-        """
-        # Get the full response
-        response = self.complete(messages, **kwargs)
-        content = response["content"]
-
-        # Simulate streaming by yielding characters
-        for i, char in enumerate(content):
-            yield {
-                "content": char,
-                "model": self.model_name,
-            }
-
-        # Yield final chunk with usage info
-        yield {
-            "content": "",
-            "usage": response["usage"],
-            "finish_reason": "stop",
-        }