edsl 0.1.39__py3-none-any.whl → 0.1.39.dev1__py3-none-any.whl

edsl/inference_services/InferenceServicesCollection.py

@@ -1,138 +1,97 @@
-from functools import lru_cache
-from collections import defaultdict
-from typing import Optional, Protocol, Dict, List, Tuple, TYPE_CHECKING, Literal
-
 from edsl.inference_services.InferenceServiceABC import InferenceServiceABC
-from edsl.inference_services.AvailableModelFetcher import AvailableModelFetcher
-from edsl.exceptions.inference_services import InferenceServiceError
-
-if TYPE_CHECKING:
-    from edsl.language_models.LanguageModel import LanguageModel
-    from edsl.inference_services.InferenceServiceABC import InferenceServiceABC
-
-
-class ModelCreator(Protocol):
-    def create_model(self, model_name: str) -> "LanguageModel":
-        ...
-
-
-from edsl.enums import InferenceServiceLiteral
-
-
-class ModelResolver:
-    def __init__(
-        self,
-        services: List[InferenceServiceLiteral],
-        models_to_services: Dict[InferenceServiceLiteral, InferenceServiceABC],
-        availability_fetcher: "AvailableModelFetcher",
-    ):
-        """
-        Class for determining which service to use for a given model.
-        """
-        self.services = services
-        self._models_to_services = models_to_services
-        self.availability_fetcher = availability_fetcher
-        self._service_names_to_classes = {
-            service._inference_service_: service for service in services
-        }
-
-    def resolve_model(
-        self, model_name: str, service_name: Optional[InferenceServiceLiteral] = None
-    ) -> InferenceServiceABC:
-        """Returns an InferenceServiceABC object for the given model name.
-
-        :param model_name: The name of the model to resolve. E.g., 'gpt-4o'
-        :param service_name: The name of the service to use. E.g., 'openai'
-        :return: An InferenceServiceABC object
-
-        """
-        if model_name == "test":
-            from edsl.inference_services.TestService import TestService
-
-            return TestService()
-
-        if service_name is not None:
-            service: InferenceServiceABC = self._service_names_to_classes.get(
-                service_name
-            )
-            if not service:
-                raise InferenceServiceError(f"Service {service_name} not found")
-            return service
-
-        if model_name in self._models_to_services:  # maybe we've seen it before!
-            return self._models_to_services[model_name]
-
-        for service in self.services:
-            (
-                available_models,
-                service_name,
-            ) = self.availability_fetcher.get_available_models_by_service(service)
-            if model_name in available_models:
-                self._models_to_services[model_name] = service
-                return service
-
-        raise InferenceServiceError(
-            f"""Model {model_name} not found in any services. 
-                                    If you know the service that has this model, use the service_name parameter directly.
-                                    E.g., Model("gpt-4o", service_name="openai")
-                                    """
-        )
+import warnings
 
 
 class InferenceServicesCollection:
-    added_models = defaultdict(list)  # Moved back to class level
+    added_models = {}
 
-    def __init__(self, services: Optional[List[InferenceServiceABC]] = None):
+    def __init__(self, services: list[InferenceServiceABC] = None):
         self.services = services or []
-        self._models_to_services: Dict[str, InferenceServiceABC] = {}
-
-        self.availability_fetcher = AvailableModelFetcher(
-            self.services, self.added_models
-        )
-        self.resolver = ModelResolver(
-            self.services, self._models_to_services, self.availability_fetcher
-        )
 
     @classmethod
-    def add_model(cls, service_name: str, model_name: str) -> None:
+    def add_model(cls, service_name, model_name):
         if service_name not in cls.added_models:
-            cls.added_models[service_name].append(model_name)
-
-    def service_names_to_classes(self) -> Dict[str, InferenceServiceABC]:
-        return {service._inference_service_: service for service in self.services}
-
-    def available(
-        self,
-        service: Optional[str] = None,
-    ) -> List[Tuple[str, str, int]]:
-        return self.availability_fetcher.available(service)
+            cls.added_models[service_name] = []
+        cls.added_models[service_name].append(model_name)
+
+    @staticmethod
+    def _get_service_available(service, warn: bool = False) -> list[str]:
+        try:
+            service_models = service.available()
+        except Exception:
+            if warn:
+                warnings.warn(
+                    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.
+                    Relying on Coop.""",
+                    UserWarning,
+                )
+
+            # Use the list of models on Coop as a fallback
+            try:
+                from edsl import Coop
+
+                c = Coop()
+                models_from_coop = c.fetch_models()
+                service_models = models_from_coop.get(service._inference_service_, [])
+
+                # cache results
+                service._models_list_cache = service_models
+
+            # Finally, use the available models cache from the Python file
+            except Exception:
+                if warn:
+                    warnings.warn(
+                        f"""Error getting models for {service._inference_service_}. 
+                        Relying on EDSL cache.""",
+                        UserWarning,
+                    )
+
+                from edsl.inference_services.models_available_cache import (
+                    models_available,
+                )
+
+                service_models = models_available.get(service._inference_service_, [])
+
+                # cache results
+                service._models_list_cache = service_models
+
+        return service_models
+
+    def available(self):
+        total_models = []
+        for service in self.services:
+            service_models = self._get_service_available(service)
+            for model in service_models:
+                total_models.append([model, service._inference_service_, -1])
 
-    def reset_cache(self) -> None:
-        self.availability_fetcher.reset_cache()
+            for model in self.added_models.get(service._inference_service_, []):
+                total_models.append([model, service._inference_service_, -1])
 
-    @property
-    def num_cache_entries(self) -> int:
-        return self.availability_fetcher.num_cache_entries
+        sorted_models = sorted(total_models)
+        for i, model in enumerate(sorted_models):
+            model[2] = i
+            model = tuple(model)
+        return sorted_models
 
-    def register(self, service: InferenceServiceABC) -> None:
+    def register(self, service):
         self.services.append(service)
 
-    def create_model_factory(
-        self, model_name: str, service_name: Optional[InferenceServiceLiteral] = None
-    ) -> "LanguageModel":
-
-        if service_name is None:  # we try to find the right service
-            service = self.resolver.resolve_model(model_name, service_name)
-        else:  # if they passed a service, we'll use that
-            service = self.service_names_to_classes().get(service_name)
+    def create_model_factory(self, model_name: str, service_name=None, index=None):
+        from edsl.inference_services.TestService import TestService
 
-        if not service:  # but if we can't find it, we'll raise an error
-            raise InferenceServiceError(f"Service {service_name} not found")
-
-        return service.create_model(model_name)
+        if model_name == "test":
+            return TestService.create_model(model_name)
 
+        if service_name:
+            for service in self.services:
+                if service_name == service._inference_service_:
+                    return service.create_model(model_name)
 
-if __name__ == "__main__":
-    import doctest
+        for service in self.services:
+            if model_name in self._get_service_available(service):
+                if service_name is None or service_name == service._inference_service_:
+                    return service.create_model(model_name)
 
-    doctest.testmod()
+        raise Exception(f"Model {model_name} not found in any of the services")

edsl/inference_services/MistralAIService.py

@@ -85,6 +85,9 @@ class MistralAIService(InferenceServiceABC):
                 "top_p": 0.9,
             }
 
+            _tpm = cls.get_tpm(cls)
+            _rpm = cls.get_rpm(cls)
+
             def sync_client(self):
                 return cls.sync_client()
 

edsl/inference_services/OpenAIService.py

@@ -1,19 +1,16 @@
 from __future__ import annotations
-from typing import Any, List, Optional, Dict, NewType
+from typing import Any, List, Optional
 import os
 
-
 import openai
 
 from edsl.inference_services.InferenceServiceABC import InferenceServiceABC
-from edsl.language_models.LanguageModel import LanguageModel
+from edsl.language_models 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."""
@@ -25,43 +22,35 @@ class OpenAIService(InferenceServiceABC):
     _sync_client_ = openai.OpenAI
     _async_client_ = openai.AsyncOpenAI
 
-    _sync_client_instances: Dict[APIToken, openai.OpenAI] = {}
-    _async_client_instances: Dict[APIToken, openai.AsyncOpenAI] = {}
+    _sync_client_instance = None
+    _async_client_instance = None
 
     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 = {}
+        # 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, api_key):
-        if api_key not in cls._sync_client_instances:
-            client = cls._sync_client_(
-                api_key=api_key,
-                base_url=cls._base_url_,
+    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_), base_url=cls._base_url_
             )
-            cls._sync_client_instances[api_key] = client
-        client = cls._sync_client_instances[api_key]
-        return client
+        return cls._sync_client_instance
 
     @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_,
+    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_), base_url=cls._base_url_
             )
-            cls._async_client_instances[api_key] = client
-        client = cls._async_client_instances[api_key]
-        return client
+        return cls._async_client_instance
 
     model_exclude_list = [
         "whisper-1",
@@ -83,24 +72,20 @@ class OpenAIService(InferenceServiceABC):
     _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()
+    def get_model_list(cls):
+        raw_list = cls.sync_client().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_)
+    def available(cls) -> List[str]:
         if not cls._models_list_cache:
             try:
                 cls._models_list_cache = [
                     m.id
-                    for m in cls.get_model_list(api_key=api_token)
+                    for m in cls.get_model_list()
                     if m.id not in cls.model_exclude_list
                 ]
             except Exception as e:
@@ -122,6 +107,9 @@ class OpenAIService(InferenceServiceABC):
             input_token_name = cls.input_token_name
             output_token_name = cls.output_token_name
 
+            _rpm = cls.get_rpm(cls)
+            _tpm = cls.get_tpm(cls)
+
             _inference_service_ = cls._inference_service_
             _model_ = model_name
             _parameters_ = {
@@ -135,10 +123,10 @@ class OpenAIService(InferenceServiceABC):
             }
 
             def sync_client(self):
-                return cls.sync_client(api_key=self.api_token)
+                return cls.sync_client()
 
             def async_client(self):
-                return cls.async_client(api_key=self.api_token)
+                return cls.async_client()
 
             @classmethod
             def available(cls) -> list[str]:
@@ -187,16 +175,16 @@ class OpenAIService(InferenceServiceABC):
             ) -> 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}]
-                    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}"
-                                },
-                            }
-                        )
+                    content.append(
+                        {
+                            "type": "image_url",
+                            "image_url": {
+                                "url": f"data:image/jpeg;base64,{encoded_image}"
+                            },
+                        }
+                    )
                 else:
                     content = user_prompt
                 client = self.async_client()

edsl/inference_services/PerplexityService.py

@@ -51,6 +51,9 @@ class PerplexityService(OpenAIService):
             input_token_name = cls.input_token_name
             output_token_name = cls.output_token_name
 
+            _rpm = cls.get_rpm(cls)
+            _tpm = cls.get_tpm(cls)
+
             _inference_service_ = cls._inference_service_
             _model_ = model_name
 

edsl/inference_services/TestService.py

@@ -2,7 +2,7 @@ from typing import Any, List, Optional
 import os
 import asyncio
 from edsl.inference_services.InferenceServiceABC import InferenceServiceABC
-from edsl.language_models.LanguageModel import LanguageModel
+from edsl.language_models import LanguageModel
 from edsl.inference_services.rate_limits_cache import rate_limits
 from edsl.utilities.utilities import fix_partial_correct_response
 
@@ -51,7 +51,6 @@ class TestService(InferenceServiceABC):
             @property
             def _canned_response(self):
                 if hasattr(self, "canned_response"):
-
                     return self.canned_response
                 else:
                     return "Hello, world"
@@ -64,15 +63,7 @@ class TestService(InferenceServiceABC):
                 files_list: Optional[List["File"]] = None,
             ) -> dict[str, Any]:
                 await asyncio.sleep(0.1)
-
-                if hasattr(self, "throw_exception") and self.throw_exception:
-                    if hasattr(self, "exception_probability"):
-                        p = self.exception_probability
-                    else:
-                        p = 1
-
-                    if random.random() < p:
-                        raise Exception("This is a test error")
+                # return {"message": """{"answer": "Hello, world"}"""}
 
                 if hasattr(self, "func"):
                     return {
@@ -82,6 +73,14 @@ class TestService(InferenceServiceABC):
                         "usage": {"prompt_tokens": 1, "completion_tokens": 1},
                     }
 
+                if hasattr(self, "throw_exception") and self.throw_exception:
+                    if hasattr(self, "exception_probability"):
+                        p = self.exception_probability
+                    else:
+                        p = 1
+
+                    if random.random() < p:
+                        raise Exception("This is a test error")
                 return {
                     "message": [{"text": f"{self._canned_response}"}],
                     "usage": {"prompt_tokens": 1, "completion_tokens": 1},

edsl/inference_services/TogetherAIService.py

@@ -143,17 +143,15 @@ class TogetherAIService(OpenAIService):
     _async_client_ = openai.AsyncOpenAI
 
     @classmethod
-    def get_model_list(cls, api_token=None):
+    def get_model_list(cls):
         # Togheter.ai has a different response in model list then openai
         # and the OpenAI class returns an error when calling .models.list()
         import requests
         import os
 
         url = "https://api.together.xyz/v1/models?filter=serverless"
-        if api_token is None:
-            api_token = os.getenv(cls._env_key_name_)
-
-        headers = {"accept": "application/json", "authorization": f"Bearer {api_token}"}
+        token = os.getenv(cls._env_key_name_)
+        headers = {"accept": "application/json", "authorization": f"Bearer {token}"}
 
         response = requests.get(url, headers=headers)
         return response.json()

edsl/jobs/Answers.py

@@ -1,6 +1,7 @@
 """This module contains the Answers class, which is a helper class to hold the answers to a survey."""
 
 from collections import UserDict
+from rich.table import Table
 from edsl.data_transfer_models import EDSLResultObjectInput
 
 
@@ -21,7 +22,7 @@ class Answers(UserDict):
         if comment:
             self[question.question_name + "_comment"] = comment
 
-    def replace_missing_answers_with_none(self, survey: "Survey") -> None:
+    def replace_missing_answers_with_none(self, survey) -> None:
         """Replace missing answers with None. Answers can be missing if the agent skips a question."""
         for question_name in survey.question_names:
             if question_name not in self:
@@ -36,6 +37,18 @@ class Answers(UserDict):
         """Return an Answers object from a dictionary."""
         return cls(d)
 
+    def rich_print(self):
+        """Display an object as a table."""
+        table = Table(title="Answers")
+        table.add_column("Attribute", style="bold")
+        table.add_column("Value")
+
+        to_display = self
+        for attr_name, attr_value in to_display.items():
+            table.add_row(attr_name, repr(attr_value))
+
+        return table
+
 
 if __name__ == "__main__":
     import doctest