edsl 0.1.33.dev2__py3-none-any.whl → 0.1.34__py3-none-any.whl

edsl/config.py

@@ -1,73 +1,65 @@
 """This module provides a Config class that loads environment variables from a .env file and sets them as class attributes."""
 
 import os
+from dotenv import load_dotenv, find_dotenv
 from edsl.exceptions import (
     InvalidEnvironmentVariableError,
     MissingEnvironmentVariableError,
 )
-from dotenv import load_dotenv, find_dotenv
 
 # valid values for EDSL_RUN_MODE
-EDSL_RUN_MODES = ["development", "development-testrun", "production"]
+EDSL_RUN_MODES = [
+    "development",
+    "development-testrun",
+    "production",
+]
 
 # `default` is used to impute values only in "production" mode
 # `info` gives a brief description of the env var
 CONFIG_MAP = {
     "EDSL_RUN_MODE": {
         "default": "production",
-        "info": "This env var determines the run mode of the application.",
-    },
-    "EDSL_DATABASE_PATH": {
-        "default": f"sqlite:///{os.path.join(os.getcwd(), '.edsl_cache/data.db')}",
-        "info": "This env var determines the path to the cache file.",
-    },
-    "EDSL_LOGGING_PATH": {
-        "default": f"{os.path.join(os.getcwd(), 'interview.log')}",
-        "info": "This env var determines the path to the log file.",
+        "info": "This config var determines the run mode of the application.",
     },
     "EDSL_API_TIMEOUT": {
         "default": "60",
-        "info": "This env var determines the maximum number of seconds to wait for an API call to return.",
+        "info": "This config var determines the maximum number of seconds to wait for an API call to return.",
     },
     "EDSL_BACKOFF_START_SEC": {
         "default": "1",
-        "info": "This env var determines the number of seconds to wait before retrying a failed API call.",
+        "info": "This config var determines the number of seconds to wait before retrying a failed API call.",
     },
-    "EDSL_MAX_BACKOFF_SEC": {
+    "EDSL_BACKOFF_MAX_SEC": {
         "default": "60",
-        "info": "This env var determines the maximum number of seconds to wait before retrying a failed API call.",
+        "info": "This config var determines the maximum number of seconds to wait before retrying a failed API call.",
     },
-    "EDSL_MAX_ATTEMPTS": {
-        "default": "5",
-        "info": "This env var determines the maximum number of times to retry a failed API call.",
+    "EDSL_DATABASE_PATH": {
+        "default": f"sqlite:///{os.path.join(os.getcwd(), '.edsl_cache/data.db')}",
+        "info": "This config var determines the path to the cache file.",
     },
     "EDSL_DEFAULT_MODEL": {
         "default": "gpt-4o",
-        "info": "This env var holds the default model name.",
+        "info": "This config var holds the default model that will be used if a model is not explicitly passed.",
     },
-    "EDSL_SERVICE_TPM_BASELINE": {
-        "default": "2000000",
-        "info": "This env var holds the maximum number of tokens per minute for all models. Model-specific values such as EDSL_SERVICE_TPM_OPENAI will override this.",
+    "EDSL_FETCH_TOKEN_PRICES": {
+        "default": "True",
+        "info": "This config var determines whether to fetch prices for tokens used in remote inference",
+    },
+    "EDSL_MAX_ATTEMPTS": {
+        "default": "5",
+        "info": "This config var determines the maximum number of times to retry a failed API call.",
     },
     "EDSL_SERVICE_RPM_BASELINE": {
         "default": "100",
-        "info": "This env var holds the maximum number of requests per minute for OpenAI. Model-specific values such as EDSL_SERVICE_RPM_OPENAI will override this.",
+        "info": "This config var holds the maximum number of requests per minute. Model-specific values provided in env vars such as EDSL_SERVICE_RPM_OPENAI will override this. value for the corresponding model",
     },
-    "EDSL_SERVICE_TPM_OPENAI": {
+    "EDSL_SERVICE_TPM_BASELINE": {
         "default": "2000000",
-        "info": "This env var holds the maximum number of tokens per minute for OpenAI.",
-    },
-    "EDSL_SERVICE_RPM_OPENAI": {
-        "default": "100",
-        "info": "This env var holds the maximum number of requests per minute for OpenAI.",
-    },
-    "EDSL_FETCH_TOKEN_PRICES": {
-        "default": "True",
-        "info": "Whether to fetch the prices for tokens",
+        "info": "This config var holds the maximum number of tokens per minute for all models. Model-specific values provided in env vars such as EDSL_SERVICE_TPM_OPENAI will override this value for the corresponding model.",
     },
     "EXPECTED_PARROT_URL": {
         "default": "https://www.expectedparrot.com",
-        "info": "This env var holds the URL of the Expected Parrot API.",
+        "info": "This config var holds the URL of the Expected Parrot API.",
     },
 }
 

edsl/coop/coop.py

@@ -59,8 +59,16 @@ class Coop:
         Send a request to the server and return the response.
         """
         url = f"{self.url}/{uri}"
+        method = method.upper()
+        if payload is None:
+            timeout = 20
+        elif (
+            method.upper() == "POST"
+            and "json_string" in payload
+            and payload.get("json_string") is not None
+        ):
+            timeout = max(20, (len(payload.get("json_string", "")) // (1024 * 1024)))
         try:
-            method = method.upper()
             if method in ["GET", "DELETE"]:
                 response = requests.request(
                     method, url, params=params, headers=self.headers, timeout=timeout
@@ -77,7 +85,7 @@ class Coop:
             else:
                 raise Exception(f"Invalid {method=}.")
         except requests.ConnectionError:
-            raise requests.ConnectionError("Could not connect to the server.")
+            raise requests.ConnectionError(f"Could not connect to the server at {url}.")
 
         return response
 
@@ -87,6 +95,7 @@ class Coop:
         """
         if response.status_code >= 400:
             message = response.json().get("detail")
+            # print(response.text)
             if "Authorization" in message:
                 print(message)
                 message = "Please provide an Expected Parrot API key."
@@ -794,8 +803,9 @@ def main():
     ##############
     job = Jobs.example()
     coop.remote_inference_cost(job)
-    results = coop.remote_inference_create(job)
-    coop.remote_inference_get(results.get("uuid"))
+    job_coop_object = coop.remote_inference_create(job)
+    job_coop_results = coop.remote_inference_get(job_coop_object.get("uuid"))
+    coop.get(uuid=job_coop_results.get("results_uuid"))
 
     ##############
     # E. Errors

edsl/data_transfer_models.py

@@ -1,4 +1,6 @@
 from typing import NamedTuple, Dict, List, Optional, Any
+from dataclasses import dataclass, fields
+import reprlib
 
 
 class ModelInputs(NamedTuple):
@@ -45,76 +47,27 @@ class EDSLResultObjectInput(NamedTuple):
     cost: Optional[float] = None
 
 
-# from collections import UserDict
-
-
-# class AgentResponseDict(UserDict):
-#     """A dictionary to store the response of the agent to a question."""
-
-#     def __init__(
-#         self,
-#         *,
-#         question_name,
-#         answer,
-#         prompts,
-#         generated_tokens: str,
-#         usage=None,
-#         comment=None,
-#         cached_response=None,
-#         raw_model_response=None,
-#         simple_model_raw_response=None,
-#         cache_used=None,
-#         cache_key=None,
-#     ):
-#         """Initialize the AgentResponseDict object."""
-#         usage = usage or {"prompt_tokens": 0, "completion_tokens": 0}
-#         if generated_tokens is None:
-#             raise ValueError("generated_tokens must be provided")
-#         self.data = {
-#             "answer": answer,
-#             "comment": comment,
-#             "question_name": question_name,
-#             "prompts": prompts,
-#             "usage": usage,
-#             "cached_response": cached_response,
-#             "raw_model_response": raw_model_response,
-#             "simple_model_raw_response": simple_model_raw_response,
-#             "cache_used": cache_used,
-#             "cache_key": cache_key,
-#             "generated_tokens": generated_tokens,
-#         }
-
-#     @property
-#     def data(self):
-#         return self._data
-
-#     @data.setter
-#     def data(self, value):
-#         self._data = value
-
-#     def __getitem__(self, key):
-#         return self.data.get(key, None)
-
-#     def __setitem__(self, key, value):
-#         self.data[key] = value
-
-#     def __delitem__(self, key):
-#         del self.data[key]
-
-#     def __iter__(self):
-#         return iter(self.data)
-
-#     def __len__(self):
-#         return len(self.data)
-
-#     def keys(self):
-#         return self.data.keys()
-
-#     def values(self):
-#         return self.data.values()
-
-#     def items(self):
-#         return self.data.items()
-
-#     def is_this_same_model(self):
-#         return True
+@dataclass
+class ImageInfo:
+    file_path: str
+    file_name: str
+    image_format: str
+    file_size: int
+    encoded_image: str
+
+    def __repr__(self):
+        reprlib_instance = reprlib.Repr()
+        reprlib_instance.maxstring = 30  # Limit the string length for the encoded image
+
+        # Get all fields except encoded_image
+        field_reprs = [
+            f"{f.name}={getattr(self, f.name)!r}"
+            for f in fields(self)
+            if f.name != "encoded_image"
+        ]
+
+        # Add the reprlib-restricted encoded_image field
+        field_reprs.append(f"encoded_image={reprlib_instance.repr(self.encoded_image)}")
+
+        # Join everything to create the repr
+        return f"{self.__class__.__name__}({', '.join(field_reprs)})"

edsl/enums.py

@@ -63,6 +63,7 @@ class InferenceServiceType(EnumWithChecks):
     AZURE = "azure"
     OLLAMA = "ollama"
     MISTRAL = "mistral"
+    TOGETHER = "together"
 
 
 service_to_api_keyname = {
@@ -76,6 +77,7 @@ service_to_api_keyname = {
     InferenceServiceType.GROQ.value: "GROQ_API_KEY",
     InferenceServiceType.BEDROCK.value: ["AWS_ACCESS_KEY_ID", "AWS_SECRET_ACCESS_KEY"],
     InferenceServiceType.MISTRAL.value: "MISTRAL_API_KEY",
+    InferenceServiceType.TOGETHER.value: "TOGETHER_API_KEY",
 }
 
 

edsl/inference_services/AnthropicService.py

@@ -1,5 +1,5 @@
 import os
-from typing import Any
+from typing import Any, Optional, List
 import re
 from anthropic import AsyncAnthropic
 from edsl.inference_services.InferenceServiceABC import InferenceServiceABC
@@ -60,7 +60,10 @@ class AnthropicService(InferenceServiceABC):
             _rpm = cls.get_rpm(cls)
 
             async def async_execute_model_call(
-                self, user_prompt: str, system_prompt: str = ""
+                self,
+                user_prompt: str,
+                system_prompt: str = "",
+                files_list: Optional[List["Files"]] = None,
             ) -> dict[str, Any]:
                 """Calls the OpenAI API and returns the API response."""
 

edsl/inference_services/AwsBedrock.py

@@ -1,5 +1,5 @@
 import os
-from typing import Any
+from typing import Any, List, Optional
 import re
 import boto3
 from botocore.exceptions import ClientError
@@ -69,7 +69,10 @@ class AwsBedrockService(InferenceServiceABC):
             _tpm = cls.get_tpm(cls)
 
             async def async_execute_model_call(
-                self, user_prompt: str, system_prompt: str = ""
+                self,
+                user_prompt: str,
+                system_prompt: str = "",
+                files_list: Optional[List["FileStore"]] = None,
             ) -> dict[str, Any]:
                 """Calls the AWS Bedrock API and returns the API response."""
 

edsl/inference_services/AzureAI.py

@@ -1,5 +1,5 @@
 import os
-from typing import Any
+from typing import Any, Optional, List
 import re
 from openai import AsyncAzureOpenAI
 from edsl.inference_services.InferenceServiceABC import InferenceServiceABC
@@ -122,7 +122,10 @@ class AzureAIService(InferenceServiceABC):
             _tpm = cls.get_tpm(cls)
 
             async def async_execute_model_call(
-                self, user_prompt: str, system_prompt: str = ""
+                self,
+                user_prompt: str,
+                system_prompt: str = "",
+                files_list: Optional[List["FileStore"]] = None,
             ) -> dict[str, Any]:
                 """Calls the Azure OpenAI API and returns the API response."""
 

edsl/inference_services/GoogleService.py

@@ -1,25 +1,54 @@
 import os
-import aiohttp
-import json
-from typing import Any
+from typing import Any, Dict, List, Optional
+import google
+import google.generativeai as genai
+from google.generativeai.types import GenerationConfig
+from google.api_core.exceptions import InvalidArgument
+
 from edsl.exceptions import MissingAPIKeyError
 from edsl.language_models.LanguageModel import LanguageModel
-
 from edsl.inference_services.InferenceServiceABC import InferenceServiceABC
 
+safety_settings = [
+    {
+        "category": "HARM_CATEGORY_HARASSMENT",
+        "threshold": "BLOCK_NONE",
+    },
+    {
+        "category": "HARM_CATEGORY_HATE_SPEECH",
+        "threshold": "BLOCK_NONE",
+    },
+    {
+        "category": "HARM_CATEGORY_SEXUALLY_EXPLICIT",
+        "threshold": "BLOCK_NONE",
+    },
+    {
+        "category": "HARM_CATEGORY_DANGEROUS_CONTENT",
+        "threshold": "BLOCK_NONE",
+    },
+]
+
 
 class GoogleService(InferenceServiceABC):
     _inference_service_ = "google"
     key_sequence = ["candidates", 0, "content", "parts", 0, "text"]
-    usage_sequence = ["usageMetadata"]
-    input_token_name = "promptTokenCount"
-    output_token_name = "candidatesTokenCount"
+    usage_sequence = ["usage_metadata"]
+    input_token_name = "prompt_token_count"
+    output_token_name = "candidates_token_count"
 
     model_exclude_list = []
 
+    # @classmethod
+    # def available(cls) -> List[str]:
+    #     return ["gemini-pro", "gemini-1.5-pro", "gemini-1.5-flash", "gemini-1.0-pro"]
+
     @classmethod
-    def available(cls):
-        return ["gemini-pro", "gemini-1.5-pro", "gemini-1.5-flash", "gemini-1.0-pro"]
+    def available(cls) -> List[str]:
+        model_list = []
+        for m in genai.list_models():
+            if "generateContent" in m.supported_generation_methods:
+                model_list.append(m.name.split("/")[-1])
+        return model_list
 
     @classmethod
     def create_model(
@@ -47,33 +76,79 @@ class GoogleService(InferenceServiceABC):
                 "stopSequences": [],
             }
 
+            api_token = None
+            model = None
+
+            @classmethod
+            def initialize(cls):
+                if cls.api_token is None:
+                    cls.api_token = os.getenv("GOOGLE_API_KEY")
+                    if not cls.api_token:
+                        raise MissingAPIKeyError(
+                            "GOOGLE_API_KEY environment variable is not set"
+                        )
+                    genai.configure(api_key=cls.api_token)
+                    cls.generative_model = genai.GenerativeModel(
+                        cls._model_, safety_settings=safety_settings
+                    )
+
+            def __init__(self, *args, **kwargs):
+                super().__init__(*args, **kwargs)
+                self.initialize()
+
+            def get_generation_config(self) -> GenerationConfig:
+                return GenerationConfig(
+                    temperature=self.temperature,
+                    top_p=self.topP,
+                    top_k=self.topK,
+                    max_output_tokens=self.maxOutputTokens,
+                    stop_sequences=self.stopSequences,
+                )
+
             async def async_execute_model_call(
-                self, user_prompt: str, system_prompt: str = ""
-            ) -> dict[str, Any]:
-                # self.api_token = os.getenv("GOOGLE_API_KEY")
-                combined_prompt = user_prompt + system_prompt
-                url = f"https://generativelanguage.googleapis.com/v1beta/models/{model_name}:generateContent?key={self.api_token}"
-                headers = {"Content-Type": "application/json"}
-                data = {
-                    "contents": [{"parts": [{"text": combined_prompt}]}],
-                    "generationConfig": {
-                        "temperature": self.temperature,
-                        "topK": self.topK,
-                        "topP": self.topP,
-                        "maxOutputTokens": self.maxOutputTokens,
-                        "stopSequences": self.stopSequences,
-                    },
-                }
-                print(combined_prompt)
-                async with aiohttp.ClientSession() as session:
-                    async with session.post(
-                        url, headers=headers, data=json.dumps(data)
-                    ) as response:
-                        raw_response_text = await response.text()
-                        return json.loads(raw_response_text)
+                self,
+                user_prompt: str,
+                system_prompt: str = "",
+                files_list: Optional["Files"] = None,
+            ) -> Dict[str, Any]:
+                generation_config = self.get_generation_config()
 
-        LLM.__name__ = model_name
+                if files_list is None:
+                    files_list = []
+
+                if (
+                    system_prompt is not None
+                    and system_prompt != ""
+                    and self._model_ != "gemini-pro"
+                ):
+                    try:
+                        self.generative_model = genai.GenerativeModel(
+                            self._model_,
+                            safety_settings=safety_settings,
+                            system_instruction=system_prompt,
+                        )
+                    except InvalidArgument as e:
+                        print(
+                            f"This model, {self._model_}, does not support system_instruction"
+                        )
+                        print("Will add system_prompt to user_prompt")
+                        user_prompt = f"{system_prompt}\n{user_prompt}"
 
+                combined_prompt = [user_prompt]
+                for file in files_list:
+                    if "google" not in file.external_locations:
+                        _ = file.upload_google()
+                    gen_ai_file = google.generativeai.types.file_types.File(
+                        file.external_locations["google"]
+                    )
+                    combined_prompt.append(gen_ai_file)
+
+                response = await self.generative_model.generate_content_async(
+                    combined_prompt, generation_config=generation_config
+                )
+                return response.to_dict()
+
+        LLM.__name__ = model_name
         return LLM
 
 

edsl/inference_services/InferenceServiceABC.py

@@ -1,14 +1,27 @@
 from abc import abstractmethod, ABC
-from typing import Any
+import os
 import re
 from edsl.config import CONFIG
 
 
 class InferenceServiceABC(ABC):
-    """Abstract class for inference services."""
+    """
+    Abstract class for inference services.
+    Anthropic: https://docs.anthropic.com/en/api/rate-limits
+    """
+
+    default_levels = {
+        "google": {"tpm": 2_000_000, "rpm": 15},
+        "openai": {"tpm": 2_000_000, "rpm": 10_000},
+        "anthropic": {"tpm": 2_000_000, "rpm": 500},
+    }
 
-    # check if child class has cls attribute "key_sequence"
     def __init_subclass__(cls):
+        """
+        Check that the subclass has the required attributes.
+        - `key_sequence` attribute determines...
+        - `model_exclude_list` attribute determines...
+        """
         if not hasattr(cls, "key_sequence"):
             raise NotImplementedError(
                 f"Class {cls.__name__} must have a 'key_sequence' attribute."
@@ -18,29 +31,47 @@ class InferenceServiceABC(ABC):
                 f"Class {cls.__name__} must have a 'model_exclude_list' attribute."
             )
 
-    def get_tpm(cls):
-        key = f"EDSL_SERVICE_TPM_{cls._inference_service_.upper()}"
-        if key not in CONFIG:
-            key = "EDSL_SERVICE_TPM_BASELINE"
-        return int(CONFIG.get(key))
+    @classmethod
+    def _get_limt(cls, limit_type: str) -> int:
+        key = f"EDSL_SERVICE_{limit_type.upper()}_{cls._inference_service_.upper()}"
+        if key in os.environ:
+            return int(os.getenv(key))
+
+        if cls._inference_service_ in cls.default_levels:
+            return int(cls.default_levels[cls._inference_service_][limit_type])
+
+        return int(CONFIG.get(f"EDSL_SERVICE_{limit_type.upper()}_BASELINE"))
+
+    def get_tpm(cls) -> int:
+        """
+        Returns the TPM for the service. If the service is not defined in the environment variables, it will return the baseline TPM.
+        """
+        return cls._get_limt(limit_type="tpm")
 
     def get_rpm(cls):
-        key = f"EDSL_SERVICE_RPM_{cls._inference_service_.upper()}"
-        if key not in CONFIG:
-            key = "EDSL_SERVICE_RPM_BASELINE"
-        return int(CONFIG.get(key))
+        """
+        Returns the RPM for the service. If the service is not defined in the environment variables, it will return the baseline RPM.
+        """
+        return cls._get_limt(limit_type="rpm")
 
     @abstractmethod
     def available() -> list[str]:
+        """
+        Returns a list of available models for the service.
+        """
         pass
 
     @abstractmethod
     def create_model():
+        """
+        Returns a LanguageModel object.
+        """
         pass
 
     @staticmethod
     def to_class_name(s):
-        """Convert a string to a valid class name.
+        """
+        Converts a string to a valid class name.
 
         >>> InferenceServiceABC.to_class_name("hello world")
         'HelloWorld'

edsl/inference_services/MistralAIService.py

@@ -1,5 +1,5 @@
 import os
-from typing import Any, List
+from typing import Any, List, Optional
 from edsl.inference_services.InferenceServiceABC import InferenceServiceABC
 from edsl.language_models.LanguageModel import LanguageModel
 import asyncio
@@ -95,7 +95,10 @@ class MistralAIService(InferenceServiceABC):
                 return cls.async_client()
 
             async def async_execute_model_call(
-                self, user_prompt: str, system_prompt: str = ""
+                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()

edsl/inference_services/OpenAIService.py

@@ -168,13 +168,14 @@ class OpenAIService(InferenceServiceABC):
                 self,
                 user_prompt: str,
                 system_prompt: str = "",
-                encoded_image=None,
+                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 encoded_image:
+                if files_list:
+                    encoded_image = files_list[0].base64_string
                     content = [{"type": "text", "text": user_prompt}]
                     content.append(
                         {
@@ -187,12 +188,15 @@ class OpenAIService(InferenceServiceABC):
                 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": [
-                        {"role": "system", "content": system_prompt},
-                        {"role": "user", "content": content},
-                    ],
+                    "messages": messages,
                     "temperature": self.temperature,
                     "max_tokens": self.max_tokens,
                     "top_p": self.top_p,