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

edsl/inference_services/GoogleService.py

@@ -64,7 +64,7 @@ class GoogleService(InferenceServiceABC):
                         "stopSequences": self.stopSequences,
                     },
                 }
-                # print(combined_prompt)
+                print(combined_prompt)
                 async with aiohttp.ClientSession() as session:
                     async with session.post(
                         url, headers=headers, data=json.dumps(data)

edsl/inference_services/InferenceServiceABC.py

@@ -1,27 +1,14 @@
 from abc import abstractmethod, ABC
-import os
+from typing import Any
 import re
 from edsl.config import CONFIG
 
 
 class InferenceServiceABC(ABC):
-    """
-    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},
-    }
+    """Abstract class for inference services."""
 
+    # 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."
@@ -31,47 +18,29 @@ class InferenceServiceABC(ABC):
                 f"Class {cls.__name__} must have a 'model_exclude_list' attribute."
             )
 
-    @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_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))
 
     def get_rpm(cls):
-        """
-        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")
+        key = f"EDSL_SERVICE_RPM_{cls._inference_service_.upper()}"
+        if key not in CONFIG:
+            key = "EDSL_SERVICE_RPM_BASELINE"
+        return int(CONFIG.get(key))
 
     @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):
-        """
-        Converts a string to a valid class name.
+        """Convert a string to a valid class name.
 
         >>> InferenceServiceABC.to_class_name("hello world")
         'HelloWorld'

edsl/inference_services/OpenAIService.py

@@ -187,15 +187,12 @@ 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": messages,
+                    "messages": [
+                        {"role": "system", "content": system_prompt},
+                        {"role": "user", "content": content},
+                    ],
                     "temperature": self.temperature,
                     "max_tokens": self.max_tokens,
                     "top_p": self.top_p,

edsl/inference_services/TestService.py

@@ -7,25 +7,14 @@ from edsl.inference_services.rate_limits_cache import rate_limits
 from edsl.utilities.utilities import fix_partial_correct_response
 
 from edsl.enums import InferenceServiceType
-import random
 
 
 class TestService(InferenceServiceABC):
     """OpenAI service class."""
 
-    _inference_service_ = "test"
-    _env_key_name_ = None
-    _base_url_ = None
-
-    _sync_client_ = None
-    _async_client_ = None
-
-    _sync_client_instance = None
-    _async_client_instance = None
-
     key_sequence = None
-    usage_sequence = None
     model_exclude_list = []
+    _inference_service_ = "test"
     input_token_name = "prompt_tokens"
     output_token_name = "completion_tokens"
 
@@ -56,25 +45,27 @@ class TestService(InferenceServiceABC):
                     return "Hello, world"
 
             async def async_execute_model_call(
-                self,
-                user_prompt: str,
-                system_prompt: str,
-                encoded_image=None,
+                self, user_prompt: str, system_prompt: str
             ) -> dict[str, Any]:
                 await asyncio.sleep(0.1)
                 # return {"message": """{"answer": "Hello, world"}"""}
-
                 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")
+                    raise Exception("This is a test error")
                 return {
                     "message": [{"text": f"{self._canned_response}"}],
                     "usage": {"prompt_tokens": 1, "completion_tokens": 1},
                 }
 
         return TestServiceLanguageModel
+
+    # _inference_service_ = "openai"
+    # _env_key_name_ = "OPENAI_API_KEY"
+    # _base_url_ = None
+
+    # _sync_client_ = openai.OpenAI
+    # _async_client_ = openai.AsyncOpenAI
+
+    # _sync_client_instance = None
+    # _async_client_instance = None
+
+    # key_sequence = ["choices", 0, "message", "content"]

edsl/inference_services/registry.py

@@ -12,7 +12,6 @@ from edsl.inference_services.AzureAI import AzureAIService
 from edsl.inference_services.OllamaService import OllamaService
 from edsl.inference_services.TestService import TestService
 from edsl.inference_services.MistralAIService import MistralAIService
-from edsl.inference_services.TogetherAIService import TogetherAIService
 
 default = InferenceServicesCollection(
     [
@@ -26,6 +25,5 @@ default = InferenceServicesCollection(
         OllamaService,
         TestService,
         MistralAIService,
-        TogetherAIService,
     ]
 )

edsl/jobs/Jobs.py

@@ -460,12 +460,6 @@ class Jobs(Base):
                 if warn:
                     warnings.warn(message)
 
-        if self.scenarios.has_jinja_braces:
-            warnings.warn(
-                "The scenarios have Jinja braces ({{ and }}). Converting to '<<' and '>>'. If you want a different conversion, use the convert_jinja_braces method first to modify the scenario."
-            )
-            self.scenarios = self.scenarios.convert_jinja_braces()
-
     @property
     def skip_retry(self):
         if not hasattr(self, "_skip_retry"):
@@ -492,7 +486,6 @@ class Jobs(Base):
         remote_inference_description: Optional[str] = None,
         skip_retry: bool = False,
         raise_validation_errors: bool = False,
-        disable_remote_inference: bool = False,
     ) -> Results:
         """
         Runs the Job: conducts Interviews and returns their results.
@@ -515,17 +508,14 @@ class Jobs(Base):
 
         self.verbose = verbose
 
-        remote_cache = False
-        remote_inference = False
-
-        if not disable_remote_inference:
-            try:
-                coop = Coop()
-                user_edsl_settings = Coop().edsl_settings
-                remote_cache = user_edsl_settings.get("remote_caching", False)
-                remote_inference = user_edsl_settings.get("remote_inference", False)
-            except Exception:
-                pass
+        try:
+            coop = Coop()
+            user_edsl_settings = coop.edsl_settings
+            remote_cache = user_edsl_settings["remote_caching"]
+            remote_inference = user_edsl_settings["remote_inference"]
+        except Exception:
+            remote_cache = False
+            remote_inference = False
 
         if remote_inference:
             import time

edsl/jobs/buckets/BucketCollection.py

@@ -13,8 +13,6 @@ class BucketCollection(UserDict):
     def __init__(self, infinity_buckets=False):
         super().__init__()
         self.infinity_buckets = infinity_buckets
-        self.models_to_services = {}
-        self.services_to_buckets = {}
 
     def __repr__(self):
         return f"BucketCollection({self.data})"
@@ -23,7 +21,6 @@ class BucketCollection(UserDict):
         """Adds a model to the bucket collection.
 
         This will create the token and request buckets for the model."""
-
         # compute the TPS and RPS from the model
         if not self.infinity_buckets:
             TPS = model.TPM / 60.0
@@ -32,28 +29,22 @@ class BucketCollection(UserDict):
             TPS = float("inf")
             RPS = float("inf")
 
-        if model.model not in self.models_to_services:
-            service = model._inference_service_
-            if service not in self.services_to_buckets:
-                requests_bucket = TokenBucket(
-                    bucket_name=service,
-                    bucket_type="requests",
-                    capacity=RPS,
-                    refill_rate=RPS,
-                )
-                tokens_bucket = TokenBucket(
-                    bucket_name=service,
-                    bucket_type="tokens",
-                    capacity=TPS,
-                    refill_rate=TPS,
-                )
-                self.services_to_buckets[service] = ModelBuckets(
-                    requests_bucket, tokens_bucket
-                )
-            self.models_to_services[model.model] = service
-            self[model] = self.services_to_buckets[service]
+        # create the buckets
+        requests_bucket = TokenBucket(
+            bucket_name=model.model,
+            bucket_type="requests",
+            capacity=RPS,
+            refill_rate=RPS,
+        )
+        tokens_bucket = TokenBucket(
+            bucket_name=model.model, bucket_type="tokens", capacity=TPS, refill_rate=TPS
+        )
+        model_buckets = ModelBuckets(requests_bucket, tokens_bucket)
+        if model in self:
+            # it if already exists, combine the buckets
+            self[model] += model_buckets
         else:
-            self[model] = self.services_to_buckets[self.models_to_services[model.model]]
+            self[model] = model_buckets
 
     def visualize(self) -> dict:
         """Visualize the token and request buckets for each model."""

edsl/jobs/buckets/TokenBucket.py

@@ -1,4 +1,4 @@
-from typing import Union, List, Any, Optional
+from typing import Union, List, Any
 import asyncio
 import time
 
@@ -17,12 +17,6 @@ class TokenBucket:
         self.bucket_name = bucket_name
         self.bucket_type = bucket_type
         self.capacity = capacity  # Maximum number of tokens
-        self.added_tokens = 0
-
-        self.target_rate = (
-            capacity * 60
-        )  # set this here because it can change with turbo mode
-
         self._old_capacity = capacity
         self.tokens = capacity  # Current number of available tokens
         self.refill_rate = refill_rate  # Rate at which tokens are refilled
@@ -31,12 +25,6 @@ class TokenBucket:
         self.log: List[Any] = []
         self.turbo_mode = False
 
-        self.creation_time = time.monotonic()
-
-        self.num_requests = 0
-        self.num_released = 0
-        self.tokens_returned = 0
-
     def turbo_mode_on(self):
         """Set the refill rate to infinity."""
         if self.turbo_mode:
@@ -81,7 +69,6 @@ class TokenBucket:
         >>> bucket.tokens
         10
         """
-        self.tokens_returned += tokens
         self.tokens = min(self.capacity, self.tokens + tokens)
         self.log.append((time.monotonic(), self.tokens))
 
@@ -146,12 +133,15 @@ class TokenBucket:
         >>> bucket.capacity
         12.100000000000001
         """
-        self.num_requests += amount
         if amount >= self.capacity:
             if not cheat_bucket_capacity:
                 msg = f"Requested amount exceeds bucket capacity. Bucket capacity: {self.capacity}, requested amount: {amount}. As the bucket never overflows, the requested amount will never be available."
                 raise ValueError(msg)
             else:
+                # self.tokens = 0  # clear the bucket but let it go through
+                # print(
+                #    f"""The requested amount, {amount}, exceeds the current bucket capacity of {self.capacity}.Increasing bucket capacity to {amount} * 1.10 accommodate the requested amount."""
+                # )
                 self.capacity = amount * 1.10
                 self._old_capacity = self.capacity
 
@@ -163,10 +153,14 @@ class TokenBucket:
                 break
 
             wait_time = self.wait_time(amount)
+            # print(f"Waiting for {wait_time:.4f} seconds")
             if wait_time > 0:
+                # print(f"Waiting for {wait_time:.4f} seconds")
                 await asyncio.sleep(wait_time)
 
-        self.num_released += amount
+        # total_elapsed = time.monotonic() - start_time
+        # print(f"Total time to acquire tokens: {total_elapsed:.4f} seconds")
+
         now = time.monotonic()
         self.log.append((now, self.tokens))
         return None
@@ -193,54 +187,6 @@ class TokenBucket:
         plt.tight_layout()
         plt.show()
 
-    def get_throughput(self, time_window: Optional[float] = None) -> float:
-        """
-        Calculate the empirical bucket throughput in tokens per minute for the specified time window.
-
-        :param time_window: The time window in seconds to calculate the throughput for.
-        :return: The throughput in tokens per minute.
-
-        >>> bucket = TokenBucket(bucket_name="test", bucket_type="test", capacity=100, refill_rate=10)
-        >>> asyncio.run(bucket.get_tokens(50))
-        >>> time.sleep(1)  # Wait for 1 second
-        >>> asyncio.run(bucket.get_tokens(30))
-        >>> throughput = bucket.get_throughput(1)
-        >>> 4750 < throughput < 4850
-        True
-        """
-        now = time.monotonic()
-
-        if time_window is None:
-            start_time = self.creation_time
-        else:
-            start_time = now - time_window
-
-        if start_time < self.creation_time:
-            start_time = self.creation_time
-
-        elapsed_time = now - start_time
-
-        return (self.num_released / elapsed_time) * 60
-
-        # # Filter log entries within the time window
-        # relevant_log = [(t, tokens) for t, tokens in self.log if t >= start_time]
-
-        # if len(relevant_log) < 2:
-        #     return 0  # Not enough data points to calculate throughput
-
-        # # Calculate total tokens used
-        # initial_tokens = relevant_log[0][1]
-        # final_tokens = relevant_log[-1][1]
-        # tokens_used = self.num_released - (final_tokens - initial_tokens)
-
-        # # Calculate actual time elapsed
-        # actual_time_elapsed = relevant_log[-1][0] - relevant_log[0][0]
-
-        # # Calculate throughput in tokens per minute
-        # throughput = (tokens_used / actual_time_elapsed) * 60
-
-        # return throughput
-
 
 if __name__ == "__main__":
     import doctest