bitvavo-api-upgraded 4.3.1__tar.gz → 4.4.0__tar.gz

{bitvavo_api_upgraded-4.3.1 → bitvavo_api_upgraded-4.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: bitvavo-api-upgraded
-Version: 4.3.1
+Version: 4.4.0
 Summary: A unit-tested fork of the Bitvavo API
 Author: Bitvavo BV (original code), NostraDavid
 Author-email: NostraDavid <55331731+NostraDavid@users.noreply.github.com>

{bitvavo_api_upgraded-4.3.1 → bitvavo_api_upgraded-4.4.0}/pyproject.toml

@@ -6,7 +6,7 @@ build-backend = "uv_build"
 # https://setuptools.pypa.io/en/latest/userguide/pyproject_config.html
 [project]
 name = "bitvavo-api-upgraded"
-version = "4.3.1"
+version = "4.4.0"
 description = "A unit-tested fork of the Bitvavo API"
 readme = "README.md"
 requires-python = ">=3.10"
@@ -108,7 +108,7 @@ dev-dependencies = [
 ]
 
 [tool.bumpversion]
-current_version = "4.3.1"
+current_version = "4.4.0"
 parse = "(?P<major>\\d+)\\.(?P<minor>\\d+)\\.(?P<patch>\\d+)"
 serialize = ["{major}.{minor}.{patch}"]
 search = "{current_version}"

{bitvavo_api_upgraded-4.3.1 → bitvavo_api_upgraded-4.4.0}/src/bitvavo_client/auth/rate_limit.py

@@ -20,10 +20,9 @@ class DefaultRateLimitStrategy(RateLimitStrategy):
 
 
 class RateLimitManager:
-    """Manages rate limiting for multiple API keys and keyless requests.
+    """Manages rate limiting for multiple API keys.
 
-    Each API key index has its own rate limit state. Index -1 is reserved
-    for keyless requests.
+    Each API key index has its own rate limit state.
     """
 
     def __init__(self, default_remaining: int, buffer: int, strategy: RateLimitStrategy | None = None) -> None:
@@ -35,7 +34,7 @@ class RateLimitManager:
             strategy: Optional strategy callback when rate limit exceeded
         """
         self.default_remaining: int = default_remaining
-        self.state: dict[int, dict[str, int]] = {-1: {"remaining": default_remaining, "resetAt": 0}}
+        self.state: dict[int, dict[str, int]] = {}
         self.buffer: int = buffer
 
         self._strategy: RateLimitStrategy = strategy or DefaultRateLimitStrategy()
@@ -43,13 +42,13 @@ class RateLimitManager:
     def ensure_key(self, idx: int) -> None:
         """Ensure a key index exists in the state."""
         if idx not in self.state:
-            self.state[idx] = {"remaining": self.state[-1]["remaining"], "resetAt": 0}
+            self.state[idx] = {"remaining": self.default_remaining, "resetAt": 0}
 
     def has_budget(self, idx: int, weight: int) -> bool:
         """Check if there's enough rate limit budget for a request.
 
         Args:
-            idx: API key index (-1 for keyless)
+            idx: API key index
             weight: Weight of the request
 
         Returns:
@@ -66,7 +65,7 @@ class RateLimitManager:
         the response doesn't include rate limit headers.
 
         Args:
-            idx: API key index (-1 for keyless)
+            idx: API key index
             weight: Weight of the request
         """
         self.ensure_key(idx)
@@ -144,3 +143,62 @@ class RateLimitManager:
         """
         self.ensure_key(idx)
         return self.state[idx]["resetAt"]
+
+    def find_best_available_key(self, available_keys: list[int], weight: int) -> int | None:
+        """Find the best API key for a request with given weight.
+
+        Prioritizes keys by:
+        1. Keys with sufficient budget (remaining - weight >= buffer)
+        2. Keys with the most remaining budget
+        3. Keys with the earliest reset time (if all are rate limited)
+
+        Args:
+            available_keys: List of available key indices
+            weight: Weight of the request
+
+        Returns:
+            Best key index or None if no keys are suitable
+        """
+        if not available_keys:
+            return None
+
+        suitable_keys = []
+        fallback_keys = []
+
+        for idx in available_keys:
+            self.ensure_key(idx)
+            if self.has_budget(idx, weight):
+                suitable_keys.append((idx, self.state[idx]["remaining"]))
+            else:
+                fallback_keys.append((idx, self.state[idx]["resetAt"]))
+
+        # Return key with most remaining budget if any have sufficient budget
+        if suitable_keys:
+            return max(suitable_keys, key=lambda x: x[1])[0]
+
+        # If no keys have budget, return the one that resets earliest
+        if fallback_keys:
+            return min(fallback_keys, key=lambda x: x[1])[0]
+
+        return None
+
+    def get_earliest_reset_time(self, key_indices: list[int]) -> int:
+        """Get the earliest reset time among the given keys.
+
+        Args:
+            key_indices: List of key indices to check
+
+        Returns:
+            Earliest reset timestamp in milliseconds, or 0 if no keys have reset times
+        """
+        if not key_indices:
+            return 0
+
+        reset_times = []
+        for idx in key_indices:
+            self.ensure_key(idx)
+            reset_at = self.state[idx]["resetAt"]
+            if reset_at > 0:  # Only consider keys that actually have a reset time
+                reset_times.append(reset_at)
+
+        return min(reset_times) if reset_times else 0

{bitvavo_api_upgraded-4.3.1 → bitvavo_api_upgraded-4.4.0}/src/bitvavo_client/transport/http.py

@@ -86,6 +86,44 @@ class HTTPClient:
         self.select_key(next_idx)
         return True
 
+    def _find_available_key(self, weight: int) -> int | None:
+        """Find the best available API key for a request with given weight.
+
+        Args:
+            weight: Weight of the request
+
+        Returns:
+            Best key index or None if all keys are rate limited
+        """
+        available_keys = list(range(len(self._keys)))
+        return self.rate_limiter.find_best_available_key(available_keys, weight)
+
+    def _handle_rate_limit_exhaustion(self, weight: int) -> None:
+        """Handle situation when all API keys are rate limited.
+
+        Sleeps until the earliest key reset time and then resets that key.
+
+        Args:
+            weight: Weight of the original request
+        """
+        all_keys = list(range(len(self._keys)))
+        earliest_reset = self.rate_limiter.get_earliest_reset_time(all_keys)
+
+        if earliest_reset > 0:
+            # Find which key has the earliest reset time
+            now = int(time.time() * 1000)
+            for idx in all_keys:
+                if self.rate_limiter.get_reset_at(idx) == earliest_reset:
+                    if now < earliest_reset:
+                        # Sleep until this key resets
+                        self.rate_limiter.sleep_until_reset(idx)
+                    self.rate_limiter.reset_key(idx)
+                    self.select_key(idx)
+                    return
+
+        # Fallback to current key's rate limit strategy
+        self.rate_limiter.handle_limit(self.key_index, weight)
+
     def request(
         self,
         method: str,
@@ -111,6 +149,13 @@ class HTTPClient:
         idx = self.key_index
         self._ensure_rate_limit_initialized()
 
+        # Try to find the best available key for this request
+        best_key = self._find_available_key(weight)
+        if best_key is not None and best_key != idx:
+            self.select_key(best_key)
+            idx = best_key
+
+        # If current key doesn't have budget, try rotation
         if not self.rate_limiter.has_budget(idx, weight):
             for _ in range(len(self._keys)):
                 if self.rate_limiter.has_budget(idx, weight):
@@ -119,8 +164,11 @@ class HTTPClient:
                 idx = self.key_index
                 if not rotated:
                     break
+
+            # If still no budget after trying all keys, handle exhaustion smartly
             if not self.rate_limiter.has_budget(idx, weight):
-                self.rate_limiter.handle_limit(idx, weight)
+                self._handle_rate_limit_exhaustion(weight)
+                idx = self.key_index  # Update idx after potential key change
 
         url = f"{self.settings.rest_url}{endpoint}"
         headers = self._create_auth_headers(method, endpoint, body)