edsl 0.1.14__py3-none-any.whl → 0.1.40__py3-none-any.whl

edsl/inference_services/MistralAIService.py

@@ -0,0 +1,120 @@
+import os
+from typing import Any, List, Optional
+from edsl.inference_services.InferenceServiceABC import InferenceServiceABC
+from edsl.language_models.LanguageModel import LanguageModel
+import asyncio
+from mistralai import Mistral
+
+from edsl.exceptions.language_models import LanguageModelBadResponseError
+
+
+class MistralAIService(InferenceServiceABC):
+    """Mistral AI service class."""
+
+    key_sequence = ["choices", 0, "message", "content"]
+    usage_sequence = ["usage"]
+
+    _inference_service_ = "mistral"
+    _env_key_name_ = "MISTRAL_API_KEY"  # Environment variable for Mistral API key
+    input_token_name = "prompt_tokens"
+    output_token_name = "completion_tokens"
+
+    _sync_client_instance = None
+    _async_client_instance = None
+
+    _sync_client = Mistral
+    _async_client = Mistral
+
+    _models_list_cache: List[str] = []
+    model_exclude_list = []
+
+    def __init_subclass__(cls, **kwargs):
+        super().__init_subclass__(**kwargs)
+        # so subclasses have to create their own instances of the clients
+        cls._sync_client_instance = None
+        cls._async_client_instance = None
+
+    @classmethod
+    def sync_client(cls):
+        if cls._sync_client_instance is None:
+            cls._sync_client_instance = cls._sync_client(
+                api_key=os.getenv(cls._env_key_name_)
+            )
+        return cls._sync_client_instance
+
+    @classmethod
+    def async_client(cls):
+        if cls._async_client_instance is None:
+            cls._async_client_instance = cls._async_client(
+                api_key=os.getenv(cls._env_key_name_)
+            )
+        return cls._async_client_instance
+
+    @classmethod
+    def available(cls) -> list[str]:
+        if not cls._models_list_cache:
+            cls._models_list_cache = [
+                m.id for m in cls.sync_client().models.list().data
+            ]
+
+        return cls._models_list_cache
+
+    @classmethod
+    def create_model(
+        cls, model_name: str = "mistral", model_class_name=None
+    ) -> LanguageModel:
+        if model_class_name is None:
+            model_class_name = cls.to_class_name(model_name)
+
+        class LLM(LanguageModel):
+            """
+            Child class of LanguageModel for interacting with Mistral models.
+            """
+
+            key_sequence = cls.key_sequence
+            usage_sequence = cls.usage_sequence
+
+            input_token_name = cls.input_token_name
+            output_token_name = cls.output_token_name
+
+            _inference_service_ = cls._inference_service_
+            _model_ = model_name
+            _parameters_ = {
+                "temperature": 0.5,
+                "max_tokens": 512,
+                "top_p": 0.9,
+            }
+
+            def sync_client(self):
+                return cls.sync_client()
+
+            def async_client(self):
+                return cls.async_client()
+
+            async def async_execute_model_call(
+                self,
+                user_prompt: str,
+                system_prompt: str = "",
+                files_list: Optional[List["FileStore"]] = None,
+            ) -> dict[str, Any]:
+                """Calls the Mistral API and returns the API response."""
+                s = self.async_client()
+
+                try:
+                    res = await s.chat.complete_async(
+                        model=model_name,
+                        messages=[
+                            {
+                                "content": user_prompt,
+                                "role": "user",
+                            },
+                        ],
+                    )
+                except Exception as e:
+                    raise LanguageModelBadResponseError(f"Error with Mistral API: {e}")
+
+                return res.model_dump()
+
+        LLM.__name__ = model_class_name
+
+        return LLM

edsl/inference_services/OllamaService.py

@@ -0,0 +1,18 @@
+import aiohttp
+import json
+import requests
+from typing import Any, List
+
+# from edsl.inference_services.InferenceServiceABC import InferenceServiceABC
+from edsl.language_models import LanguageModel
+
+from edsl.inference_services.OpenAIService import OpenAIService
+
+
+class OllamaService(OpenAIService):
+    """DeepInfra service class."""
+
+    _inference_service_ = "ollama"
+    _env_key_name_ = "DEEP_INFRA_API_KEY"
+    _base_url_ = "http://localhost:11434/v1"
+    _models_list_cache: List[str] = []

edsl/inference_services/OpenAIService.py

@@ -0,0 +1,236 @@
+from __future__ import annotations
+from typing import Any, List, Optional, Dict, NewType
+import os
+
+
+import openai
+
+from edsl.inference_services.InferenceServiceABC import InferenceServiceABC
+from edsl.language_models.LanguageModel import LanguageModel
+from edsl.inference_services.rate_limits_cache import rate_limits
+from edsl.utilities.utilities import fix_partial_correct_response
+
+from edsl.config import CONFIG
+
+APIToken = NewType("APIToken", str)
+
+
+class OpenAIService(InferenceServiceABC):
+    """OpenAI service class."""
+
+    _inference_service_ = "openai"
+    _env_key_name_ = "OPENAI_API_KEY"
+    _base_url_ = None
+
+    _sync_client_ = openai.OpenAI
+    _async_client_ = openai.AsyncOpenAI
+
+    _sync_client_instances: Dict[APIToken, openai.OpenAI] = {}
+    _async_client_instances: Dict[APIToken, openai.AsyncOpenAI] = {}
+
+    key_sequence = ["choices", 0, "message", "content"]
+    usage_sequence = ["usage"]
+    input_token_name = "prompt_tokens"
+    output_token_name = "completion_tokens"
+
+    available_models_url = "https://platform.openai.com/docs/models/gp"
+
+    def __init_subclass__(cls, **kwargs):
+        super().__init_subclass__(**kwargs)
+        # so subclasses that use the OpenAI api key have to create their own instances of the clients
+        cls._sync_client_instances = {}
+        cls._async_client_instances = {}
+
+    @classmethod
+    def sync_client(cls, api_key):
+        if api_key not in cls._sync_client_instances:
+            client = cls._sync_client_(
+                api_key=api_key,
+                base_url=cls._base_url_,
+            )
+            cls._sync_client_instances[api_key] = client
+        client = cls._sync_client_instances[api_key]
+        return client
+
+    @classmethod
+    def async_client(cls, api_key):
+        if api_key not in cls._async_client_instances:
+            client = cls._async_client_(
+                api_key=api_key,
+                base_url=cls._base_url_,
+            )
+            cls._async_client_instances[api_key] = client
+        client = cls._async_client_instances[api_key]
+        return client
+
+    model_exclude_list = [
+        "whisper-1",
+        "davinci-002",
+        "dall-e-2",
+        "tts-1-hd-1106",
+        "tts-1-hd",
+        "dall-e-3",
+        "tts-1",
+        "babbage-002",
+        "tts-1-1106",
+        "text-embedding-3-large",
+        "text-embedding-3-small",
+        "text-embedding-ada-002",
+        "ft:davinci-002:mit-horton-lab::8OfuHgoo",
+        "gpt-3.5-turbo-instruct-0914",
+        "gpt-3.5-turbo-instruct",
+    ]
+    _models_list_cache: List[str] = []
+
+    @classmethod
+    def get_model_list(cls, api_key=None):
+        if api_key is None:
+            api_key = os.getenv(cls._env_key_name_)
+        raw_list = cls.sync_client(api_key).models.list()
+        if hasattr(raw_list, "data"):
+            return raw_list.data
+        else:
+            return raw_list
+
+    @classmethod
+    def available(cls, api_token=None) -> List[str]:
+        if api_token is None:
+            api_token = os.getenv(cls._env_key_name_)
+        if not cls._models_list_cache:
+            try:
+                cls._models_list_cache = [
+                    m.id
+                    for m in cls.get_model_list(api_key=api_token)
+                    if m.id not in cls.model_exclude_list
+                ]
+            except Exception as e:
+                raise
+        return cls._models_list_cache
+
+    @classmethod
+    def create_model(cls, model_name, model_class_name=None) -> LanguageModel:
+        if model_class_name is None:
+            model_class_name = cls.to_class_name(model_name)
+
+        class LLM(LanguageModel):
+            """
+            Child class of LanguageModel for interacting with OpenAI models
+            """
+
+            key_sequence = cls.key_sequence
+            usage_sequence = cls.usage_sequence
+            input_token_name = cls.input_token_name
+            output_token_name = cls.output_token_name
+
+            _inference_service_ = cls._inference_service_
+            _model_ = model_name
+            _parameters_ = {
+                "temperature": 0.5,
+                "max_tokens": 1000,
+                "top_p": 1,
+                "frequency_penalty": 0,
+                "presence_penalty": 0,
+                "logprobs": False,
+                "top_logprobs": 3,
+            }
+
+            def sync_client(self):
+                return cls.sync_client(api_key=self.api_token)
+
+            def async_client(self):
+                return cls.async_client(api_key=self.api_token)
+
+            @classmethod
+            def available(cls) -> list[str]:
+                return cls.sync_client().models.list()
+
+            def get_headers(self) -> dict[str, Any]:
+                client = self.sync_client()
+                response = client.chat.completions.with_raw_response.create(
+                    messages=[
+                        {
+                            "role": "user",
+                            "content": "Say this is a test",
+                        }
+                    ],
+                    model=self.model,
+                )
+                return dict(response.headers)
+
+            def get_rate_limits(self) -> dict[str, Any]:
+                try:
+                    if "openai" in rate_limits:
+                        headers = rate_limits["openai"]
+
+                    else:
+                        headers = self.get_headers()
+
+                except Exception as e:
+                    return {
+                        "rpm": 10_000,
+                        "tpm": 2_000_000,
+                    }
+                else:
+                    return {
+                        "rpm": int(headers["x-ratelimit-limit-requests"]),
+                        "tpm": int(headers["x-ratelimit-limit-tokens"]),
+                    }
+
+            async def async_execute_model_call(
+                self,
+                user_prompt: str,
+                system_prompt: str = "",
+                files_list: Optional[List["Files"]] = None,
+                invigilator: Optional[
+                    "InvigilatorAI"
+                ] = None,  # TBD - can eventually be used for function-calling
+            ) -> dict[str, Any]:
+                """Calls the OpenAI API and returns the API response."""
+                if files_list:
+                    content = [{"type": "text", "text": user_prompt}]
+                    for file_entry in files_list:
+                        content.append(
+                            {
+                                "type": "image_url",
+                                "image_url": {
+                                    "url": f"data:{file_entry.mime_type};base64,{file_entry.base64_string}"
+                                },
+                            }
+                        )
+                else:
+                    content = user_prompt
+                client = self.async_client()
+
+                messages = [
+                    {"role": "system", "content": system_prompt},
+                    {"role": "user", "content": content},
+                ]
+                if (
+                    system_prompt == "" and self.omit_system_prompt_if_empty
+                ) or "o1" in self.model:
+                    messages = messages[1:]
+
+                params = {
+                    "model": self.model,
+                    "messages": messages,
+                    "temperature": self.temperature,
+                    "max_tokens": self.max_tokens,
+                    "top_p": self.top_p,
+                    "frequency_penalty": self.frequency_penalty,
+                    "presence_penalty": self.presence_penalty,
+                    "logprobs": self.logprobs,
+                    "top_logprobs": self.top_logprobs if self.logprobs else None,
+                }
+                if "o1" in self.model:
+                    params.pop("max_tokens")
+                    params["max_completion_tokens"] = self.max_tokens
+                    params["temperature"] = 1
+                try:
+                    response = await client.chat.completions.create(**params)
+                except Exception as e:
+                    print(e)
+                return response.model_dump()
+
+        LLM.__name__ = "LanguageModel"
+
+        return LLM

edsl/inference_services/PerplexityService.py

@@ -0,0 +1,160 @@
+import aiohttp
+import json
+import requests
+from typing import Any, List, Optional
+from edsl.inference_services.rate_limits_cache import rate_limits
+
+# from edsl.inference_services.InferenceServiceABC import InferenceServiceABC
+from edsl.language_models import LanguageModel
+
+from edsl.inference_services.OpenAIService import OpenAIService
+
+
+class PerplexityService(OpenAIService):
+    """Perplexity service class."""
+
+    _inference_service_ = "perplexity"
+    _env_key_name_ = "PERPLEXITY_API_KEY"
+    _base_url_ = "https://api.perplexity.ai"
+    _models_list_cache: List[str] = []
+    # default perplexity parameters
+    _parameters_ = {
+        "temperature": 0.5,
+        "max_tokens": 1000,
+        "top_p": 1,
+        "logprobs": False,
+        "top_logprobs": 3,
+    }
+
+    @classmethod
+    def available(cls) -> List[str]:
+        return [
+            "llama-3.1-sonar-huge-128k-online",
+            "llama-3.1-sonar-large-128k-online",
+            "llama-3.1-sonar-small-128k-online",
+        ]
+
+    @classmethod
+    def create_model(
+        cls, model_name="llama-3.1-sonar-large-128k-online", model_class_name=None
+    ) -> LanguageModel:
+        if model_class_name is None:
+            model_class_name = cls.to_class_name(model_name)
+
+        class LLM(LanguageModel):
+            """
+            Child class of LanguageModel for interacting with Perplexity models
+            """
+
+            key_sequence = cls.key_sequence
+            usage_sequence = cls.usage_sequence
+            input_token_name = cls.input_token_name
+            output_token_name = cls.output_token_name
+
+            _inference_service_ = cls._inference_service_
+            _model_ = model_name
+
+            _parameters_ = {
+                "temperature": 0.5,
+                "max_tokens": 1000,
+                "top_p": 1,
+                "frequency_penalty": 1,
+                "presence_penalty": 0,
+                # "logprobs": False, # Enable this returns 'Neither or both of logprobs and top_logprobs must be set.
+                # "top_logprobs": 3,
+            }
+
+            def sync_client(self):
+                return cls.sync_client()
+
+            def async_client(self):
+                return cls.async_client()
+
+            @classmethod
+            def available(cls) -> list[str]:
+                return cls.sync_client().models.list()
+
+            def get_headers(self) -> dict[str, Any]:
+                client = self.sync_client()
+                response = client.chat.completions.with_raw_response.create(
+                    messages=[
+                        {
+                            "role": "user",
+                            "content": "Say this is a test",
+                        }
+                    ],
+                    model=self.model,
+                )
+                return dict(response.headers)
+
+            def get_rate_limits(self) -> dict[str, Any]:
+                try:
+                    if "openai" in rate_limits:
+                        headers = rate_limits["openai"]
+
+                    else:
+                        headers = self.get_headers()
+
+                except Exception as e:
+                    return {
+                        "rpm": 10_000,
+                        "tpm": 2_000_000,
+                    }
+                else:
+                    return {
+                        "rpm": int(headers["x-ratelimit-limit-requests"]),
+                        "tpm": int(headers["x-ratelimit-limit-tokens"]),
+                    }
+
+            async def async_execute_model_call(
+                self,
+                user_prompt: str,
+                system_prompt: str = "",
+                files_list: Optional[List["Files"]] = None,
+                invigilator: Optional[
+                    "InvigilatorAI"
+                ] = None,  # TBD - can eventually be used for function-calling
+            ) -> dict[str, Any]:
+                """Calls the OpenAI API and returns the API response."""
+                if files_list:
+                    encoded_image = files_list[0].base64_string
+                    content = [{"type": "text", "text": user_prompt}]
+                    content.append(
+                        {
+                            "type": "image_url",
+                            "image_url": {
+                                "url": f"data:image/jpeg;base64,{encoded_image}"
+                            },
+                        }
+                    )
+                else:
+                    content = user_prompt
+                client = self.async_client()
+
+                messages = [
+                    {"role": "system", "content": system_prompt},
+                    {"role": "user", "content": content},
+                ]
+                if system_prompt == "" and self.omit_system_prompt_if_empty:
+                    messages = messages[1:]
+
+                params = {
+                    "model": self.model,
+                    "messages": messages,
+                    "temperature": self.temperature,
+                    "max_tokens": self.max_tokens,
+                    "top_p": self.top_p,
+                    "frequency_penalty": self.frequency_penalty,
+                    "presence_penalty": self.presence_penalty,
+                    # "logprobs": self.logprobs,
+                    # "top_logprobs": self.top_logprobs if self.logprobs else None,
+                }
+                try:
+                    response = await client.chat.completions.create(**params)
+                except Exception as e:
+                    print(e, flush=True)
+                return response.model_dump()
+
+        LLM.__name__ = "LanguageModel"
+
+        return LLM

edsl/inference_services/ServiceAvailability.py

@@ -0,0 +1,135 @@
+from enum import Enum
+from typing import List, Optional, TYPE_CHECKING
+from functools import partial
+import warnings
+
+from edsl.inference_services.data_structures import AvailableModels, ModelNamesList
+
+if TYPE_CHECKING:
+    from edsl.inference_services.InferenceServiceABC import InferenceServiceABC
+
+
+class ModelSource(Enum):
+    LOCAL = "local"
+    COOP = "coop"
+    CACHE = "cache"
+
+
+class ServiceAvailability:
+    """This class is responsible for fetching the available models from different sources."""
+
+    _coop_model_list = None
+
+    def __init__(self, source_order: Optional[List[ModelSource]] = None):
+        """
+        Initialize with custom source order.
+        Default order is LOCAL -> COOP -> CACHE
+        """
+        self.source_order = source_order or [
+            ModelSource.LOCAL,
+            ModelSource.COOP,
+            ModelSource.CACHE,
+        ]
+
+        # Map sources to their fetch functions
+        self._source_fetchers = {
+            ModelSource.LOCAL: self._fetch_from_local_service,
+            ModelSource.COOP: self._fetch_from_coop,
+            ModelSource.CACHE: self._fetch_from_cache,
+        }
+
+    @classmethod
+    def models_from_coop(cls) -> AvailableModels:
+        if not cls._coop_model_list:
+            from edsl.coop.coop import Coop
+
+            c = Coop()
+            coop_model_list = c.fetch_models()
+            cls._coop_model_list = coop_model_list
+        return cls._coop_model_list
+
+    def get_service_available(
+        self, service: "InferenceServiceABC", warn: bool = False
+    ) -> ModelNamesList:
+        """
+        Try to fetch available models from sources in specified order.
+        Returns first successful result.
+        """
+        last_error = None
+
+        for source in self.source_order:
+            try:
+                fetch_func = partial(self._source_fetchers[source], service)
+                result = fetch_func()
+
+                # Cache successful result
+                service._models_list_cache = result
+                return result
+
+            except Exception as e:
+                last_error = e
+                if warn:
+                    self._warn_source_failed(service, source)
+                continue
+
+        # If we get here, all sources failed
+        raise RuntimeError(
+            f"All sources failed to fetch models. Last error: {last_error}"
+        )
+
+    @staticmethod
+    def _fetch_from_local_service(service: "InferenceServiceABC") -> ModelNamesList:
+        """Attempt to fetch models directly from the service."""
+        return service.available()
+
+    @classmethod
+    def _fetch_from_coop(cls, service: "InferenceServiceABC") -> ModelNamesList:
+        """Fetch models from Coop."""
+        models_from_coop = cls.models_from_coop()
+        return models_from_coop.get(service._inference_service_, [])
+
+    @staticmethod
+    def _fetch_from_cache(service: "InferenceServiceABC") -> ModelNamesList:
+        """Fetch models from local cache."""
+        from edsl.inference_services.models_available_cache import models_available
+
+        return models_available.get(service._inference_service_, [])
+
+    def _warn_source_failed(self, service: "InferenceServiceABC", source: ModelSource):
+        """Display appropriate warning message based on failed source."""
+        messages = {
+            ModelSource.LOCAL: f"""Error getting models for {service._inference_service_}. 
+                Check that you have properly stored your Expected Parrot API key and activated remote inference, 
+                or stored your own API keys for the language models that you want to use.
+                See https://docs.expectedparrot.com/en/latest/api_keys.html for instructions on storing API keys.
+                Trying next source.""",
+            ModelSource.COOP: f"Error getting models from Coop for {service._inference_service_}. Trying next source.",
+            ModelSource.CACHE: f"Error getting models from cache for {service._inference_service_}.",
+        }
+        warnings.warn(messages[source], UserWarning)
+
+
+if __name__ == "__main__":
+    # sa = ServiceAvailability()
+    # models_from_coop = sa.models_from_coop()
+    # print(models_from_coop)
+    from edsl.inference_services.OpenAIService import OpenAIService
+
+    openai_models = ServiceAvailability._fetch_from_local_service(OpenAIService())
+    print(openai_models)
+
+# Example usage:
+"""
+# Default order (LOCAL -> COOP -> CACHE)
+availability = ServiceAvailability()
+
+# Custom order (COOP -> LOCAL -> CACHE)
+availability_coop_first = ServiceAvailability([
+    ModelSource.COOP,
+    ModelSource.LOCAL,
+    ModelSource.CACHE
+])
+
+# Get available models using custom order
+models = availability_coop_first.get_service_available(service, warn=True)
+"""