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

edsl/jobs/buckets/TokenBucket.py

@@ -1,55 +1,10 @@
 from typing import Union, List, Any, Optional
 import asyncio
 import time
-from threading import RLock
-from edsl.jobs.decorators import synchronized_class
 
-from typing import Union, List, Any, Optional
-import asyncio
-import time
-from threading import RLock
-from edsl.jobs.decorators import synchronized_class
 
-
-@synchronized_class
 class TokenBucket:
-    """This is a token bucket used to respect rate limits to services.
-    It can operate either locally or remotely via a REST API based on initialization parameters.
-    """
-
-    def __new__(
-        cls,
-        *,
-        bucket_name: str,
-        bucket_type: str,
-        capacity: Union[int, float],
-        refill_rate: Union[int, float],
-        remote_url: Optional[str] = None,
-    ):
-        """Factory method to create either a local or remote token bucket.
-
-        Args:
-            bucket_name: Name of the bucket
-            bucket_type: Type of the bucket
-            capacity: Maximum number of tokens
-            refill_rate: Rate at which tokens are refilled
-            remote_url: If provided, creates a remote token bucket client
-        """
-        if remote_url is not None:
-            # Import here to avoid circular imports
-            from edsl.jobs.buckets.TokenBucketClient import TokenBucketClient
-
-            return TokenBucketClient(
-                bucket_name=bucket_name,
-                bucket_type=bucket_type,
-                capacity=capacity,
-                refill_rate=refill_rate,
-                api_base_url=remote_url,
-            )
-
-        # Create a local token bucket
-        instance = super(TokenBucket, cls).__new__(cls)
-        return instance
+    """This is a token bucket used to respect rate limits to services."""
 
     def __init__(
         self,
@@ -58,17 +13,11 @@ class TokenBucket:
         bucket_type: str,
         capacity: Union[int, float],
         refill_rate: Union[int, float],
-        remote_url: Optional[str] = None,
     ):
-        # Skip initialization if this is a remote bucket
-        if remote_url is not None:
-            return
-
         self.bucket_name = bucket_name
         self.bucket_type = bucket_type
-        self.capacity = capacity
+        self.capacity = capacity  # Maximum number of tokens
         self.added_tokens = 0
-        self._lock = RLock()
 
         self.target_rate = (
             capacity * 60
@@ -276,6 +225,25 @@ class TokenBucket:
 
         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