scitex 2.0.0__py2.py3-none-any.whl

scitex/ai/genai/model_registry.py

@@ -0,0 +1,304 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Time-stamp: "2025-05-31 10:05:00"
+# Author: ywatanabe
+# File: ./src/scitex/ai/genai/model_registry.py
+
+"""
+Central registry for AI model information.
+
+This module maintains a registry of available models across providers,
+including their capabilities, costs, and constraints.
+"""
+
+from typing import Dict, List, Optional, NamedTuple, Union, Any
+import pandas as pd
+from dataclasses import dataclass
+
+try:
+    from .params import MODELS
+except ImportError:
+    # For testing, use a default empty dataframe
+    MODELS = pd.DataFrame()
+
+
+@dataclass
+class ModelInfo:
+    """Information about a specific model.
+
+    Attributes
+    ----------
+    name : str
+        Model identifier
+    provider : str
+        Provider name
+    max_tokens : int
+        Maximum token limit
+    supports_images : bool
+        Whether model supports image inputs
+    supports_streaming : bool
+        Whether model supports streaming responses
+    cost_per_1k_input : float
+        Cost per 1000 input tokens
+    cost_per_1k_output : float
+        Cost per 1000 output tokens
+    """
+
+    name: str
+    provider: str
+    max_tokens: int
+    supports_images: bool = False
+    supports_streaming: bool = True
+    cost_per_1k_input: float = 0.0
+    cost_per_1k_output: float = 0.0
+
+
+class ModelRegistry:
+    """Central registry for model information.
+
+    Example
+    -------
+    >>> registry = ModelRegistry()
+    >>> models = registry.get_models_for_provider("OpenAI")
+    >>> print(models)
+    ['gpt-3.5-turbo', 'gpt-4', ...]
+
+    >>> info = registry.get_model_info("gpt-4")
+    >>> print(info.max_tokens)
+    8192
+    """
+
+    def __init__(self):
+        """Initialize the model registry."""
+        self._models_df = MODELS
+        self._model_cache: Dict[str, ModelInfo] = {}
+        self._build_cache()
+
+    def _build_cache(self) -> None:
+        """Build the internal model cache from the dataframe."""
+        if self._models_df.empty:
+            return
+
+        for _, row in self._models_df.iterrows():
+            # Handle different column names from fixtures
+            cost_input = row.get(
+                "cost_1k_input_tokens", row.get("cost_per_1k_input", 0.0)
+            )
+            cost_output = row.get(
+                "cost_1k_output_tokens", row.get("cost_per_1k_output", 0.0)
+            )
+
+            info = ModelInfo(
+                name=row["name"],
+                provider=row["provider"],
+                max_tokens=row.get("max_tokens", 4096),
+                supports_images=row.get("supports_images", False),
+                supports_streaming=row.get("supports_streaming", True),
+                cost_per_1k_input=cost_input,
+                cost_per_1k_output=cost_output,
+            )
+            self._model_cache[row["name"]] = info
+
+    def get_models_for_provider(self, provider: str) -> List[str]:
+        """Get all available models for a specific provider.
+
+        Parameters
+        ----------
+        provider : str
+            The provider name
+
+        Returns
+        -------
+        List[str]
+            List of model names
+        """
+        if self._models_df.empty:
+            return []
+        mask = self._models_df["provider"].str.lower() == provider.lower()
+        return self._models_df[mask]["name"].tolist()
+
+    def verify_model(self, provider: str, model: str) -> bool:
+        """Verify if a model is available for a provider.
+
+        Parameters
+        ----------
+        provider : str
+            The provider name
+        model : str
+            The model name
+
+        Returns
+        -------
+        bool
+            True if model is available
+
+        Raises
+        ------
+        ValueError
+            If model is not available for the provider
+        """
+        if model not in self._model_cache:
+            raise ValueError(f"Model '{model}' not available for provider '{provider}'")
+        if self._model_cache[model].provider.lower() != provider.lower():
+            raise ValueError(f"Model '{model}' not available for provider '{provider}'")
+        return True
+
+    def get_model_info(self, provider: str, model: str) -> Dict[str, Any]:
+        """Get detailed information about a model.
+
+        Parameters
+        ----------
+        provider : str
+            The provider name
+        model : str
+            The model name
+
+        Returns
+        -------
+        Dict[str, any]
+            Model information dictionary
+
+        Raises
+        ------
+        ValueError
+            If model not found
+        """
+        if model not in self._model_cache:
+            raise ValueError(f"Model {model} not found")
+
+        info = self._model_cache[model]
+        if info.provider.lower() != provider.lower():
+            raise ValueError(f"Model {model} not found for provider {provider}")
+
+        # Return info as dictionary (matching test expectations)
+        return {
+            "name": info.name,
+            "provider": info.provider.lower(),
+            "max_tokens": info.max_tokens,
+            "supports_images": info.supports_images,
+            "supports_streaming": info.supports_streaming,
+            "cost_per_1k_input_tokens": info.cost_per_1k_input,
+            "cost_per_1k_output_tokens": info.cost_per_1k_output,
+        }
+
+    def list_all_models(self) -> Dict[str, List[str]]:
+        """List all available models grouped by provider.
+
+        Returns
+        -------
+        Dict[str, List[str]]
+            Dictionary mapping providers to their model lists
+        """
+        result = {}
+        for provider in self._models_df["provider"].unique():
+            result[provider] = self.get_models_for_provider(provider)
+        return result
+
+    def get_provider_for_model(self, model: str) -> Optional[str]:
+        """Get the provider for a specific model.
+
+        Parameters
+        ----------
+        model : str
+            The model name
+
+        Returns
+        -------
+        Optional[str]
+            Provider name if model found, None otherwise
+        """
+        info = self._model_cache.get(model)
+        return info.provider if info else None
+
+    def list_models(self, provider: Optional[str] = None) -> List[str]:
+        """List available models.
+
+        Parameters
+        ----------
+        provider : Optional[str]
+            If specified, only return models for this provider
+
+        Returns
+        -------
+        List[str]
+            List of model names
+        """
+        if provider:
+            return self.get_models_for_provider(provider.lower())
+        else:
+            return list(self._model_cache.keys())
+
+    def list_providers(self) -> List[str]:
+        """List available providers.
+
+        Returns
+        -------
+        List[str]
+            List of unique provider names
+        """
+        if self._models_df.empty:
+            return []
+        return sorted(self._models_df["provider"].str.lower().unique().tolist())
+
+    def get_default_model(self, provider: str) -> str:
+        """Get default model for a provider.
+
+        Parameters
+        ----------
+        provider : str
+            The provider name
+
+        Returns
+        -------
+        str
+            Default model name
+
+        Raises
+        ------
+        ValueError
+            If no models available for provider
+        """
+        models = self.get_models_for_provider(provider.lower())
+        if not models:
+            raise ValueError(f"No models available for provider {provider}")
+        return models[0]
+
+    def supports_images(self, provider: str, model: str) -> bool:
+        """Check if model supports images.
+
+        Parameters
+        ----------
+        provider : str
+            The provider name
+        model : str
+            The model name
+
+        Returns
+        -------
+        bool
+            True if model supports images
+        """
+        info = self._model_cache.get(model)
+        if not info or info.provider.lower() != provider.lower():
+            return False
+        return info.supports_images
+
+    def print_models(self, provider: Optional[str] = None) -> None:
+        """Print available models in a formatted way.
+
+        Parameters
+        ----------
+        provider : Optional[str]
+            If specified, only show models for this provider
+        """
+        if provider:
+            models = self.get_models_for_provider(provider.lower())
+            for model in models:
+                info = self._model_cache[model]
+                print(f"- {info.provider.lower()} - {model}")
+        else:
+            for model, info in self._model_cache.items():
+                print(f"- {info.provider.lower()} - {model}")
+
+
+# EOF

scitex/ai/genai/openai.py

@@ -0,0 +1,230 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Timestamp: "2025-01-22 01:21:11 (ywatanabe)"
+# File: _OpenAI.py
+
+THIS_FILE = "/home/ywatanabe/proj/scitex_repo/src/scitex/ai/_gen_ai/_OpenAI.py"
+
+
+"""Imports"""
+import os
+from openai import OpenAI as _OpenAI
+from .base_genai import BaseGenAI
+
+"""Functions & Classes"""
+
+
+class OpenAI(BaseGenAI):
+    def __init__(
+        self,
+        system_setting="",
+        model="",
+        api_key=os.getenv("OPENAI_API_KEY"),
+        stream=False,
+        seed=None,
+        n_keep=1,
+        temperature=1.0,
+        chat_history=None,
+        max_tokens=None,
+    ):
+        self.passed_model = model
+
+        # import scitex
+        # scitex.str.print_debug()
+        # scitex.gen.printc(model)
+
+        if model.startswith("o"):
+            for reasoning_effort in ["low", "midium", "high"]:
+                model = model.replace(f"-{reasoning_effort}", "")
+
+        # Set max_tokens based on model
+        if max_tokens is None:
+            if "gpt-4-turbo" in model:
+                max_tokens = 128_000
+            elif "gpt-4" in model:
+                max_tokens = 8_192
+            elif "gpt-3.5-turbo-16k" in model:
+                max_tokens = 16_384
+            elif "gpt-3.5" in model:
+                max_tokens = 4_096
+            else:
+                max_tokens = 4_096
+
+        super().__init__(
+            system_setting=system_setting,
+            model=model,
+            api_key=api_key,
+            stream=stream,
+            n_keep=n_keep,
+            temperature=temperature,
+            provider="OpenAI",
+            chat_history=chat_history,
+            max_tokens=max_tokens,
+        )
+
+    def _init_client(
+        self,
+    ):
+        client = _OpenAI(api_key=self.api_key)
+        return client
+
+    def _api_call_static(self):
+        kwargs = dict(
+            model=self.passed_model,
+            messages=self.history,
+            seed=self.seed,
+            stream=False,
+            temperature=self.temperature,
+            max_tokens=self.max_tokens,
+        )
+
+        # # o models adjustment
+        # import scitex
+        # scitex.str.print_debug()
+        # scitex.gen.printc(kwargs.get("model"))
+
+        if kwargs.get("model").startswith("o"):
+            kwargs.pop("max_tokens")
+            for reasoning_effort in ["low", "midium", "high"]:
+                if reasoning_effort in kwargs["model"]:
+                    kwargs["reasoning_effort"] = reasoning_effort
+                    kwargs["model"] = kwargs["model"].replace(
+                        f"-{reasoning_effort}", ""
+                    )
+        # import scitex
+        # scitex.str.print_debug()
+        # scitex.gen.printc(kwargs.get("model"))
+        # scitex.gen.printc(kwargs.get("reasoning_effort"))
+        # scitex.str.print_debug()
+
+        output = self.client.chat.completions.create(**kwargs)
+        self.input_tokens += output.usage.prompt_tokens
+        self.output_tokens += output.usage.completion_tokens
+
+        out_text = output.choices[0].message.content
+
+        return out_text
+
+    def _api_call_stream(self):
+        kwargs = dict(
+            model=self.model,
+            messages=self.history,
+            max_tokens=self.max_tokens,
+            n=1,
+            stream=self.stream,
+            seed=self.seed,
+            temperature=self.temperature,
+            stream_options={"include_usage": True},
+        )
+
+        if kwargs.get("model").startswith("o"):
+            for reasoning_effort in ["low", "midium", "high"]:
+                kwargs["reasoning_effort"] = reasoning_effort
+                kwargs["model"] = kwargs["model"].replace(f"-{reasoning_effort}", "")
+            full_response = self._api_call_static()
+            for char in full_response:
+                yield char
+            return
+
+        stream = self.client.chat.completions.create(**kwargs)
+        buffer = ""
+
+        for chunk in stream:
+            if chunk:
+                try:
+                    self.input_tokens += chunk.usage.prompt_tokens
+                except:
+                    pass
+                try:
+                    self.output_tokens += chunk.usage.completion_tokens
+                except:
+                    pass
+
+                try:
+                    current_text = chunk.choices[0].delta.content
+                    if current_text:
+                        buffer += current_text
+                        # Yield complete sentences or words
+                        if any(char in ".!?\n " for char in current_text):
+                            yield buffer
+                            buffer = ""
+                except Exception as e:
+                    pass
+
+        # Yield any remaining text
+        if buffer:
+            yield buffer
+
+    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_url",
+                                "image_url": {
+                                    "url": f"data:image/jpeg;base64,{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 main() -> None:
+    import scitex
+
+    ai = scitex.ai.GenAI(
+        model="o1-low",
+        api_key=os.getenv("OPENAI_API_KEY"),
+    )
+
+    print(ai("hi, could you tell me what is in the pic?"))
+
+    # 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
+
+
+# def main():
+#     model = "o1-mini"
+#     # model = "o1-preview"
+#     # model = "gpt-4o"
+#     stream = True
+#     max_tokens = 4906
+#     m = scitex.ai.GenAI(model, stream=stream, max_tokens=max_tokens)
+#     m("hi")
+
+if __name__ == "__main__":
+    import sys
+
+    import matplotlib.pyplot as plt
+    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
+"""
+python -m scitex.ai._gen_ai._OpenAI
+"""
+
+# EOF