scitex 2.0.0__py2.py3-none-any.whl

scitex/ai/genai/provider_factory.py

@@ -0,0 +1,370 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Time-stamp: "2024-11-15 12:00:00"
+# Author: Yusuke Watanabe (ywatanabe@alumni.u-tokyo.ac.jp)
+
+"""
+Factory for creating AI provider instances.
+
+This module provides a factory pattern for instantiating different AI providers
+with consistent configuration.
+"""
+
+from enum import Enum
+from typing import Any, Dict, Optional, Type, Union
+import os
+
+from .base_provider import BaseProvider, Provider
+from .provider_base import ProviderConfig
+
+
+class ProviderRegistry:
+    """Registry for managing AI providers and their aliases."""
+
+    def __init__(self):
+        """Initialize the registry with provider storage and aliases."""
+        self._providers: Dict[Provider, Type[BaseProvider]] = {}
+        self._aliases: Dict[str, Provider] = {
+            # OpenAI aliases
+            "openai": Provider.OPENAI,
+            "gpt": Provider.OPENAI,
+            "gpt-3": Provider.OPENAI,
+            "gpt-3.5": Provider.OPENAI,
+            "gpt-4": Provider.OPENAI,
+            "gpt-4o": Provider.OPENAI,
+            "o1": Provider.OPENAI,
+            # Anthropic aliases
+            "anthropic": Provider.ANTHROPIC,
+            "claude": Provider.ANTHROPIC,
+            "claude-2": Provider.ANTHROPIC,
+            "claude-3": Provider.ANTHROPIC,
+            "claude-3-opus": Provider.ANTHROPIC,
+            "claude-3-sonnet": Provider.ANTHROPIC,
+            "claude-3-haiku": Provider.ANTHROPIC,
+            # Google aliases
+            "google": Provider.GOOGLE,
+            "gemini": Provider.GOOGLE,
+            "bard": Provider.GOOGLE,
+            "bison": Provider.GOOGLE,
+            "palm": Provider.GOOGLE,
+            # Groq aliases
+            "groq": Provider.GROQ,
+            "mixtral": Provider.GROQ,
+            "llama": Provider.GROQ,
+            "llama2": Provider.GROQ,
+            "llama3": Provider.GROQ,
+            # Perplexity aliases
+            "perplexity": Provider.PERPLEXITY,
+            "pplx": Provider.PERPLEXITY,
+            # DeepSeek aliases
+            "deepseek": Provider.DEEPSEEK,
+            "deepseek-coder": Provider.DEEPSEEK,
+            "deepseek-chat": Provider.DEEPSEEK,
+        }
+
+    def register(self, provider: Provider, provider_class: Type[BaseProvider]) -> None:
+        """
+        Register a provider implementation.
+
+        Parameters
+        ----------
+        provider : Provider
+            Provider enum value
+        provider_class : Type[BaseProvider]
+            Provider implementation class
+        """
+        self._providers[provider] = provider_class
+
+    def get(self, provider: Provider) -> Type[BaseProvider]:
+        """
+        Get a registered provider class.
+
+        Parameters
+        ----------
+        provider : Provider
+            Provider enum value
+
+        Returns
+        -------
+        Type[BaseProvider]
+            Provider implementation class
+
+        Raises
+        ------
+        ValueError
+            If provider is not registered
+        """
+        if provider not in self._providers:
+            raise ValueError(f"Provider {provider} is not registered")
+        return self._providers[provider]
+
+    def resolve_provider(self, provider_or_model: str) -> Provider:
+        """
+        Resolve a provider from a string or model name.
+
+        Parameters
+        ----------
+        provider_or_model : str
+            Provider name, alias, or model name
+
+        Returns
+        -------
+        Provider
+            Resolved provider enum value
+
+        Raises
+        ------
+        ValueError
+            If provider cannot be resolved
+        """
+        provider_lower = provider_or_model.lower()
+
+        # Direct provider name match
+        for p in Provider:
+            if p.value == provider_lower:
+                return p
+
+        # Alias match
+        if provider_lower in self._aliases:
+            return self._aliases[provider_lower]
+
+        # Try to infer from model name patterns
+        model_patterns = {
+            Provider.OPENAI: [
+                "gpt-",
+                "o1-",
+                "text-davinci",
+                "text-curie",
+                "text-babbage",
+                "text-ada",
+            ],
+            Provider.ANTHROPIC: ["claude-"],
+            Provider.GOOGLE: ["gemini-", "palm-", "bison"],
+            Provider.GROQ: ["mixtral-", "llama-"],
+            Provider.PERPLEXITY: ["pplx-", "perplexity-"],
+            Provider.DEEPSEEK: ["deepseek-"],
+        }
+
+        for provider, patterns in model_patterns.items():
+            if any(provider_lower.startswith(pattern) for pattern in patterns):
+                return provider
+
+        raise ValueError(f"Cannot resolve provider from: {provider_or_model}")
+
+    def list_providers(self) -> list[Provider]:
+        """
+        List registered providers.
+
+        Returns
+        -------
+        list[Provider]
+            List of registered provider enums
+        """
+        return list(self._providers.keys())
+
+
+# Global registry instance
+_registry = ProviderRegistry()
+
+# Auto-register providers when they're imported
+_auto_register_called = False
+
+
+def _auto_register():
+    """Auto-register available provider implementations."""
+    global _auto_register_called
+    if _auto_register_called:
+        return
+    _auto_register_called = True
+
+    # Try to import and register providers
+    try:
+        # Import providers here to trigger their registration
+        # Each provider module should register itself when imported
+        from . import mock_provider  # For testing
+        from . import anthropic_provider
+        from . import openai_provider
+        from . import google_provider
+        from . import groq_provider
+        from . import perplexity_provider
+        from . import deepseek_provider
+        from . import llama_provider
+    except ImportError as e:
+        # Log import errors but continue
+        import warnings
+
+        warnings.warn(f"Failed to import some providers: {e}")
+
+
+class ModelRegistry:
+    """Registry for model information."""
+
+    @staticmethod
+    def get_models_for_provider(provider: str) -> list[str]:
+        """Get available models for a provider."""
+        # This would be implemented with actual model data
+        return []
+
+
+# Module-level convenience functions
+def register_provider(name: str, provider_class: Type[BaseProvider]) -> None:
+    """
+    Register a provider implementation.
+
+    Parameters
+    ----------
+    name : str
+        Provider name
+    provider_class : Type[BaseProvider]
+        Provider implementation class
+    """
+    provider = _registry.resolve_provider(name)
+    _registry.register(provider, provider_class)
+
+
+def create_provider(
+    provider: str,
+    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: Any,
+) -> BaseProvider:
+    """
+    Create a provider instance.
+
+    Parameters
+    ----------
+    provider : str
+        Provider name, alias, or model name
+    api_key : Optional[str]
+        API key for authentication
+    model : str
+        Model name to use
+    system_prompt : Optional[str]
+        System prompt to prepend to messages
+    stream : bool
+        Whether to stream responses
+    seed : Optional[int]
+        Random seed for reproducibility
+    max_tokens : Optional[int]
+        Maximum tokens in response
+    temperature : float
+        Sampling temperature
+    n_draft : int
+        Number of drafts to generate
+    **kwargs : Any
+        Additional provider-specific parameters
+
+    Returns
+    -------
+    BaseProvider
+        Provider instance
+    """
+    # Auto-register providers
+    _auto_register()
+
+    # Resolve provider
+    provider_enum = _registry.resolve_provider(provider)
+
+    # Get provider class
+    provider_class = _registry.get(provider_enum)
+
+    # Create configuration
+    config = ProviderConfig(
+        api_key=api_key,
+        model=model,
+        system_prompt=system_prompt,
+        stream=stream,
+        seed=seed,
+        max_tokens=max_tokens,
+        temperature=temperature,
+        n_draft=n_draft,
+        kwargs=kwargs,
+    )
+
+    # Instantiate provider
+    return provider_class(config)
+
+
+def GenAI(
+    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,
+    provider: Optional[str] = None,
+    **kwargs: Any,
+) -> BaseProvider:
+    """
+    Create an AI provider instance (backward compatibility).
+
+    This function maintains backward compatibility with the old API.
+    If provider is not specified, it infers from the model name.
+
+    Parameters
+    ----------
+    api_key : Optional[str]
+        API key for authentication
+    model : str
+        Model name to use
+    system_prompt : Optional[str]
+        System prompt to prepend to messages
+    stream : bool
+        Whether to stream responses
+    seed : Optional[int]
+        Random seed for reproducibility
+    max_tokens : Optional[int]
+        Maximum tokens in response
+    temperature : float
+        Sampling temperature
+    n_draft : int
+        Number of drafts to generate
+    provider : Optional[str]
+        Provider name (if not specified, inferred from model)
+    **kwargs : Any
+        Additional provider-specific parameters
+
+    Returns
+    -------
+    BaseProvider
+        Provider instance
+    """
+    # If provider is explicitly specified, use it
+    if provider:
+        return create_provider(
+            provider=provider,
+            api_key=api_key,
+            model=model,
+            system_prompt=system_prompt,
+            stream=stream,
+            seed=seed,
+            max_tokens=max_tokens,
+            temperature=temperature,
+            n_draft=n_draft,
+            **kwargs,
+        )
+
+    # Otherwise, try to infer from model name
+    return create_provider(
+        provider=model,  # Let resolve_provider handle it
+        api_key=api_key,
+        model=model,
+        system_prompt=system_prompt,
+        stream=stream,
+        seed=seed,
+        max_tokens=max_tokens,
+        temperature=temperature,
+        n_draft=n_draft,
+        **kwargs,
+    )
+
+
+## EOF

scitex/ai/genai/response_handler.py

@@ -0,0 +1,235 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Time-stamp: "2025-05-31 10:20:00"
+# Author: ywatanabe
+# File: ./src/scitex/ai/genai/response_handler.py
+
+"""
+Handles response processing for AI providers.
+
+This module provides response handling functionality including:
+- Static response processing
+- Stream response handling
+- Output formatting
+- Error response generation
+"""
+
+import sys
+from typing import Generator, List, Union, Optional, Any
+
+from .format_output_func import format_output_func
+
+
+class ResponseHandler:
+    """Handles processing of AI provider responses.
+
+    Example
+    -------
+    >>> handler = ResponseHandler()
+    >>> # Process static response
+    >>> result = handler.process_static("Hello, world!")
+    >>> print(result)
+    Hello, world!
+
+    >>> # Process stream
+    >>> stream = ["Hello", ", ", "world!"]
+    >>> for chunk in handler.process_stream(stream):
+    ...     print(chunk, end="")
+    Hello, world!
+    """
+
+    def __init__(self):
+        """Initialize response handler."""
+        self._accumulated_response = []
+
+    def process_static(self, response: str, format_output: bool = False) -> str:
+        """Process a static (non-streaming) response.
+
+        Parameters
+        ----------
+        response : str
+            The response text to process
+        format_output : bool
+            Whether to apply output formatting
+
+        Returns
+        -------
+        str
+            Processed response text
+        """
+        if format_output:
+            response = self.format_output(response)
+        return response
+
+    def process_stream(
+        self, stream: Generator[str, None, None], format_output: bool = False
+    ) -> Generator[str, None, None]:
+        """Process a streaming response.
+
+        Parameters
+        ----------
+        stream : Generator[str, None, None]
+            The stream of response chunks
+        format_output : bool
+            Whether to apply output formatting to final result
+
+        Yields
+        ------
+        str
+            Response chunks as they arrive
+        """
+        self._accumulated_response = []
+
+        for chunk in stream:
+            if chunk:
+                self._accumulated_response.append(chunk)
+                yield chunk
+
+        # Apply formatting to accumulated response if requested
+        if format_output and self._accumulated_response:
+            full_response = "".join(self._accumulated_response)
+            formatted = self.format_output(full_response)
+
+            # If formatting changed the response, yield the difference
+            if formatted != full_response:
+                # This is tricky - we've already yielded the unformatted chunks
+                # In practice, formatting is usually applied after streaming
+                pass
+
+    def format_output(self, text: str) -> str:
+        """Apply output formatting to text.
+
+        Parameters
+        ----------
+        text : str
+            Text to format
+
+        Returns
+        -------
+        str
+            Formatted text
+        """
+        return format_output_func(text)
+
+    def yield_stream_with_print(self, stream: Generator[str, None, None]) -> str:
+        """Yield stream chunks while printing to stdout.
+
+        Parameters
+        ----------
+        stream : Generator[str, None, None]
+            The stream to process
+
+        Returns
+        -------
+        str
+            Complete accumulated response
+        """
+        accumulated = []
+
+        for chunk in stream:
+            if chunk:
+                sys.stdout.write(chunk)
+                sys.stdout.flush()
+                accumulated.append(chunk)
+
+        return "".join(accumulated)
+
+    def create_error_response(
+        self, error_messages: List[str], as_stream: bool = False
+    ) -> Union[str, Generator[str, None, None]]:
+        """Create an error response.
+
+        Parameters
+        ----------
+        error_messages : List[str]
+            List of error messages
+        as_stream : bool
+            Whether to return as stream
+
+        Returns
+        -------
+        Union[str, Generator[str, None, None]]
+            Error response as string or stream
+        """
+        error_text = "".join(error_messages)
+
+        if not as_stream:
+            return error_text
+
+        return self._text_to_stream(error_text)
+
+    def _text_to_stream(self, text: str) -> Generator[str, None, None]:
+        """Convert text to a stream generator.
+
+        Parameters
+        ----------
+        text : str
+            Text to convert
+
+        Yields
+        ------
+        str
+            Text as stream chunks
+        """
+        # Yield text in reasonable chunks
+        chunk_size = 50
+        for i in range(0, len(text), chunk_size):
+            yield text[i : i + chunk_size]
+
+    def extract_content_from_response(self, response: Any) -> str:
+        """Extract text content from various response formats.
+
+        Parameters
+        ----------
+        response : Any
+            Response object from provider
+
+        Returns
+        -------
+        str
+            Extracted text content
+        """
+        # Handle string responses
+        if isinstance(response, str):
+            return response
+
+        # Handle dict responses
+        if isinstance(response, dict):
+            if "content" in response:
+                return str(response["content"])
+            if "text" in response:
+                return str(response["text"])
+            if "message" in response:
+                return str(response["message"])
+
+        # Handle object responses with attributes
+        if hasattr(response, "content"):
+            return str(response.content)
+        if hasattr(response, "text"):
+            return str(response.text)
+        if hasattr(response, "message"):
+            return str(response.message)
+
+        # Fallback to string conversion
+        return str(response)
+
+    def reset(self) -> None:
+        """Reset the handler state."""
+        self._accumulated_response = []
+
+    def get_accumulated_response(self) -> str:
+        """Get the accumulated response from streaming.
+
+        Returns
+        -------
+        str
+            Accumulated response text
+        """
+        return "".join(self._accumulated_response)
+
+    def __repr__(self) -> str:
+        """String representation of ResponseHandler."""
+        return f"ResponseHandler(accumulated_chunks={len(self._accumulated_response)})"
+
+
+# EOF

scitex/ai/layer/_Pass.py

@@ -0,0 +1,21 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Time-stamp: "2024-11-20 00:29:47 (ywatanabe)"
+# File: ./scitex_repo/src/scitex/ai/layer/_Pass.py
+
+THIS_FILE = "/home/ywatanabe/proj/scitex_repo/src/scitex/ai/layer/_Pass.py"
+
+import torch.nn as nn
+
+
+class Pass(nn.Module):
+    def __init__(
+        self,
+    ):
+        super().__init__()
+
+    def forward(self, x):
+        return x
+
+
+# EOF

scitex/ai/layer/__init__.py

@@ -0,0 +1,10 @@
+#!/usr/bin/env python3
+"""Scitex layer module."""
+
+from ._Pass import Pass
+from ._switch import switch
+
+__all__ = [
+    "Pass",
+    "switch",
+]

scitex/ai/layer/_switch.py

@@ -0,0 +1,8 @@
+from ._Pass import Pass
+
+
+def switch(layer, is_used):
+    if is_used:
+        return layer
+    else:
+        return Pass()

scitex/ai/loss/_L1L2Losses.py

@@ -0,0 +1,34 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Time-stamp: "2024-11-07 18:53:03 (ywatanabe)"
+# File: ./scitex_repo/src/scitex/ai/loss/_L1L2Losses.py
+
+import torch
+
+
+def l1(model, lambda_l1=0.01):
+    lambda_l1 = torch.tensor(lambda_l1)
+    l1 = torch.tensor(0.0).cuda()
+    for param in model.parameters():  # fixme; is this OK?
+        l1 += torch.abs(param).sum()
+    return l1
+
+
+def l2(model, lambda_l2=0.01):
+    lambda_l2 = torch.tensor(lambda_l2)
+    l2 = torch.tensor(0.0).cuda()
+    for param in model.parameters():  # fixme; is this OK?
+        l2 += torch.norm(param).sum()
+    return l2
+
+
+def elastic(model, alpha=1.0, l1_ratio=0.5):
+    assert 0 <= l1_ratio <= 1
+
+    L1 = l1(model)
+    L2 = l2(model)
+
+    return alpha * (l1_ratio * L1 + (1 - l1_ratio) * L2)
+
+
+# EOF

scitex/ai/loss/__init__.py

@@ -0,0 +1,12 @@
+#!/usr/bin/env python3
+"""Scitex loss module."""
+
+from ._L1L2Losses import elastic, l1, l2
+from .multi_task_loss import MultiTaskLoss
+
+__all__ = [
+    "elastic",
+    "l1",
+    "l2",
+    "MultiTaskLoss",
+]