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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: bitvavo-api-upgraded
-Version: 4.4.0
+Version: 4.4.1
 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.4.0 → bitvavo_api_upgraded-4.4.1}/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.4.0"
+version = "4.4.1"
 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.4.0"
+current_version = "4.4.1"
 parse = "(?P<major>\\d+)\\.(?P<minor>\\d+)\\.(?P<patch>\\d+)"
 serialize = ["{major}.{minor}.{patch}"]
 search = "{current_version}"

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

@@ -5,6 +5,10 @@ from __future__ import annotations
 import time
 from typing import Protocol
 
+from structlog.stdlib import get_logger
+
+logger = get_logger()
+
 
 class RateLimitStrategy(Protocol):
     """Protocol for custom rate limit handling strategies."""
@@ -39,10 +43,22 @@ class RateLimitManager:
 
         self._strategy: RateLimitStrategy = strategy or DefaultRateLimitStrategy()
 
+        logger.info(
+            "rate-limit-manager-initialized",
+            default_remaining=default_remaining,
+            buffer=buffer,
+            strategy=type(self._strategy).__name__,
+        )
+
     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.default_remaining, "resetAt": 0}
+            logger.debug(
+                "rate-limit-key-initialized",
+                key_idx=idx,
+                default_remaining=self.default_remaining,
+            )
 
     def has_budget(self, idx: int, weight: int) -> bool:
         """Check if there's enough rate limit budget for a request.
@@ -55,7 +71,18 @@ class RateLimitManager:
             True if request can be made within rate limits
         """
         self.ensure_key(idx)
-        return (self.state[idx]["remaining"] - weight) >= self.buffer
+        has_budget = (self.state[idx]["remaining"] - weight) >= self.buffer
+
+        logger.debug(
+            "rate-limit-budget-check",
+            key_idx=idx,
+            weight=weight,
+            remaining=self.state[idx]["remaining"],
+            buffer=self.buffer,
+            has_budget=has_budget,
+        )
+
+        return has_budget
 
     def record_call(self, idx: int, weight: int) -> None:
         """Record a request by decreasing the remaining budget.
@@ -69,8 +96,17 @@ class RateLimitManager:
             weight: Weight of the request
         """
         self.ensure_key(idx)
+        old_remaining = self.state[idx]["remaining"]
         self.state[idx]["remaining"] = max(0, self.state[idx]["remaining"] - weight)
 
+        logger.debug(
+            "rate-limit-call-recorded",
+            key_idx=idx,
+            weight=weight,
+            old_remaining=old_remaining,
+            new_remaining=self.state[idx]["remaining"],
+        )
+
     def update_from_headers(self, idx: int, headers: dict[str, str]) -> None:
         """Update rate limit state from response headers.
 
@@ -83,11 +119,24 @@ class RateLimitManager:
         remaining = headers.get("bitvavo-ratelimit-remaining")
         reset_at = headers.get("bitvavo-ratelimit-resetat")
 
+        old_state = dict(self.state[idx])
+
         if remaining is not None:
             self.state[idx]["remaining"] = int(remaining)
         if reset_at is not None:
             self.state[idx]["resetAt"] = int(reset_at)
 
+        logger.debug(
+            "rate-limit-updated-from-headers",
+            key_idx=idx,
+            old_remaining=old_state["remaining"],
+            new_remaining=self.state[idx]["remaining"],
+            old_reset_at=old_state["resetAt"],
+            new_reset_at=self.state[idx]["resetAt"],
+            has_remaining_header=remaining is not None,
+            has_reset_header=reset_at is not None,
+        )
+
     def update_from_error(self, idx: int, _err: dict[str, object]) -> None:
         """Update rate limit state from API error response.
 
@@ -96,30 +145,73 @@ class RateLimitManager:
             _err: Error response from API (unused but kept for interface compatibility)
         """
         self.ensure_key(idx)
+        old_remaining = self.state[idx]["remaining"]
+        old_reset_at = self.state[idx]["resetAt"]
+
         self.state[idx]["remaining"] = 0
         self.state[idx]["resetAt"] = int(time.time() * 1000) + 60_000
 
+        logger.warning(
+            "rate-limit-updated-from-error",
+            key_idx=idx,
+            old_remaining=old_remaining,
+            old_reset_at=old_reset_at,
+            new_reset_at=self.state[idx]["resetAt"],
+        )
+
     def sleep_until_reset(self, idx: int) -> None:
         """Sleep until rate limit resets for given key index.
 
         Args:
             idx: API key index
         """
+
         self.ensure_key(idx)
         now = int(time.time() * 1000)
         ms_left = max(0, self.state[idx]["resetAt"] - now)
-        time.sleep(ms_left / 1000 + 1)
+        sleep_seconds = ms_left / 1000 + 1
+
+        logger.info(
+            "rate-limit-exceeded",
+            key_idx=idx,
+            sleep_seconds=sleep_seconds,
+            reset_at=self.state[idx]["resetAt"],
+        )
+        time.sleep(sleep_seconds)
+
+        logger.info(
+            "rate-limit-sleep-completed",
+            key_idx=idx,
+            slept_seconds=sleep_seconds,
+        )
 
     def handle_limit(self, idx: int, weight: int) -> None:
         """Invoke the configured strategy when rate limit is exceeded."""
+        logger.info(
+            "rate-limit-handling-strategy",
+            key_idx=idx,
+            weight=weight,
+            strategy=type(self._strategy).__name__,
+        )
         self._strategy(self, idx, weight)
 
     def reset_key(self, idx: int) -> None:
         """Reset the remaining budget and reset time for a key index."""
         self.ensure_key(idx)
+        old_remaining = self.state[idx]["remaining"]
+        old_reset_at = self.state[idx]["resetAt"]
+
         self.state[idx]["remaining"] = self.default_remaining
         self.state[idx]["resetAt"] = 0
 
+        logger.info(
+            "rate-limit-key-reset",
+            key_idx=idx,
+            old_remaining=old_remaining,
+            old_reset_at=old_reset_at,
+            new_remaining=self.default_remaining,
+        )
+
     def get_remaining(self, idx: int) -> int:
         """Get remaining rate limit for key index.
 
@@ -160,6 +252,7 @@ class RateLimitManager:
             Best key index or None if no keys are suitable
         """
         if not available_keys:
+            logger.debug("rate-limit-no-keys-available", weight=weight)
             return None
 
         suitable_keys = []
@@ -174,12 +267,29 @@ class RateLimitManager:
 
         # Return key with most remaining budget if any have sufficient budget
         if suitable_keys:
-            return max(suitable_keys, key=lambda x: x[1])[0]
+            best_key = max(suitable_keys, key=lambda x: x[1])[0]
+            logger.debug(
+                "rate-limit-best-key-found",
+                key_idx=best_key,
+                weight=weight,
+                remaining=self.state[best_key]["remaining"],
+                suitable_keys_count=len(suitable_keys),
+            )
+            return best_key
 
         # If no keys have budget, return the one that resets earliest
         if fallback_keys:
-            return min(fallback_keys, key=lambda x: x[1])[0]
-
+            fallback_key = min(fallback_keys, key=lambda x: x[1])[0]
+            logger.warning(
+                "rate-limit-using-fallback-key",
+                key_idx=fallback_key,
+                weight=weight,
+                reset_at=self.state[fallback_key]["resetAt"],
+                fallback_keys_count=len(fallback_keys),
+            )
+            return fallback_key
+
+        logger.warning("rate-limit-no-suitable-keys", weight=weight, available_keys=available_keys)
         return None
 
     def get_earliest_reset_time(self, key_indices: list[int]) -> int:
@@ -192,6 +302,7 @@ class RateLimitManager:
             Earliest reset timestamp in milliseconds, or 0 if no keys have reset times
         """
         if not key_indices:
+            logger.debug("rate-limit-no-keys-for-reset-time")
             return 0
 
         reset_times = []
@@ -201,4 +312,13 @@ class RateLimitManager:
             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
+        earliest_reset = min(reset_times) if reset_times else 0
+
+        logger.debug(
+            "rate-limit-earliest-reset-time",
+            key_indices=key_indices,
+            keys_with_reset=len(reset_times),
+            earliest_reset=earliest_reset,
+        )
+
+        return earliest_reset

{bitvavo_api_upgraded-4.4.0 → bitvavo_api_upgraded-4.4.1}/src/bitvavo_client/core/settings.py

@@ -30,7 +30,7 @@ class BitvavoSettings(BaseSettings):
 
     # Client behavior
     default_rate_limit: int = Field(default=1_000, description="Default rate limit for new API keys")
-    rate_limit_buffer: int = Field(default=0, description="Rate limit buffer to avoid hitting limits")
+    rate_limit_buffer: int = Field(default=50, description="Rate limit buffer to avoid hitting limits")
     lag_ms: int = Field(default=0, description="Artificial lag to add to requests in milliseconds")
     debugging: bool = Field(default=False, description="Enable debug logging")
 

{bitvavo_api_upgraded-4.4.0 → bitvavo_api_upgraded-4.4.1}/src/bitvavo_client/facade.py

@@ -38,8 +38,8 @@ class BitvavoClient:
         """
         self.settings = settings or BitvavoSettings()
         self.rate_limiter = RateLimitManager(
-            self.settings.default_rate_limit,
-            self.settings.rate_limit_buffer,
+            default_remaining=self.settings.default_rate_limit,
+            buffer=self.settings.rate_limit_buffer,
         )
         self.http = HTTPClient(self.settings, self.rate_limiter)
 

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

@@ -7,6 +7,7 @@ from typing import TYPE_CHECKING, Any
 
 import httpx
 from returns.result import Failure, Result
+from structlog.stdlib import get_logger
 
 from bitvavo_client.adapters.returns_adapter import (
     BitvavoError,
@@ -19,6 +20,8 @@ if TYPE_CHECKING:  # pragma: no cover
     from bitvavo_client.core.settings import BitvavoSettings
     from bitvavo_client.core.types import AnyDict
 
+logger = get_logger(__name__)
+
 
 class HTTPClient:
     """HTTP client for Bitvavo REST API with rate limiting and authentication."""
@@ -30,11 +33,13 @@ class HTTPClient:
             settings: Bitvavo settings configuration
             rate_limiter: Rate limit manager instance
         """
+
         self.settings: BitvavoSettings = settings
         self.rate_limiter: RateLimitManager = rate_limiter
         self._keys: list[tuple[str, str]] = [(item["key"], item["secret"]) for item in self.settings.api_keys]
         if not self._keys:
             msg = "API keys are required"
+            logger.error("api-keys-required")
             raise ValueError(msg)
 
         for idx in range(len(self._keys)):
@@ -47,6 +52,7 @@ class HTTPClient:
 
         key, secret = self._keys[0]
         self.configure_key(key, secret, 0)
+        logger.info("http-client-initialized", key_count=len(self._keys))
 
     def configure_key(self, key: str, secret: str, index: int) -> None:
         """Configure API key for authenticated requests.
@@ -59,18 +65,23 @@ class HTTPClient:
         self.api_key = key
         self.api_secret = secret
         self.key_index = index
+        key_suffix = key[-4:] if len(key) >= 4 else "short"
+        logger.debug("api-key-configured", index=index, key_suffix=key_suffix)
 
     def select_key(self, index: int) -> None:
         """Select a specific API key by index."""
         if not (0 <= index < len(self._keys)):
             msg = "API key index out of range"
+            logger.error("api-key-index-out-of-range", index=index, available_keys=len(self._keys))
             raise IndexError(msg)
         key, secret = self._keys[index]
         self.configure_key(key, secret, index)
+        logger.debug("api-key-selected", index=index)
 
     def _rotate_key(self) -> bool:
         """Rotate to the next configured API key if available."""
         if len(self._keys) <= 1:
+            logger.debug("key-rotation-skipped", reason="only-one-key")
             return False
 
         next_idx = (self.key_index + 1) % len(self._keys)
@@ -78,12 +89,15 @@ class HTTPClient:
         reset_at = self.rate_limiter.get_reset_at(next_idx)
 
         if now < reset_at:
+            logger.info("rotating-to-key-with-sleep", next_index=next_idx)
             self.rate_limiter.sleep_until_reset(next_idx)
             self.rate_limiter.reset_key(next_idx)
         elif self.rate_limiter.get_remaining(next_idx) <= self.rate_limiter.buffer:
+            logger.debug("rotating-to-key-with-reset", next_index=next_idx, reason="low-remaining-budget")
             self.rate_limiter.reset_key(next_idx)
 
         self.select_key(next_idx)
+        logger.info("key-rotated", from_index=self.key_index, to_index=next_idx)
         return True
 
     def _find_available_key(self, weight: int) -> int | None:
@@ -96,7 +110,12 @@ class HTTPClient:
             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)
+        best_key = self.rate_limiter.find_best_available_key(available_keys, weight)
+        if best_key is not None:
+            logger.debug("available-key-found", key_index=best_key, weight=weight)
+        else:
+            logger.warning("no-available-keys", weight=weight)
+        return best_key
 
     def _handle_rate_limit_exhaustion(self, weight: int) -> None:
         """Handle situation when all API keys are rate limited.
@@ -106,6 +125,7 @@ class HTTPClient:
         Args:
             weight: Weight of the original request
         """
+        logger.warning("all-keys-rate-limited", weight=weight)
         all_keys = list(range(len(self._keys)))
         earliest_reset = self.rate_limiter.get_earliest_reset_time(all_keys)
 
@@ -116,12 +136,16 @@ class HTTPClient:
                 if self.rate_limiter.get_reset_at(idx) == earliest_reset:
                     if now < earliest_reset:
                         # Sleep until this key resets
+                        sleep_ms = earliest_reset - now
+                        logger.info("sleeping-until-key-reset", key_index=idx, sleep_ms=sleep_ms)
                         self.rate_limiter.sleep_until_reset(idx)
                     self.rate_limiter.reset_key(idx)
                     self.select_key(idx)
+                    logger.info("key-reset-after-exhaustion", key_index=idx)
                     return
 
         # Fallback to current key's rate limit strategy
+        logger.debug("fallback-to-current-key", key_index=self.key_index)
         self.rate_limiter.handle_limit(self.key_index, weight)
 
     def request(
@@ -146,17 +170,20 @@ class HTTPClient:
         Raises:
             HTTPError: On transport-level failures
         """
+        logger.debug("making-request", method=method, endpoint=endpoint, weight=weight)
         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:
+            logger.debug("switching-to-best-key", from_index=idx, to_index=best_key)
             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):
+            logger.debug("key-lacks-budget", key_index=idx, weight=weight)
             for _ in range(len(self._keys)):
                 if self.rate_limiter.has_budget(idx, weight):
                     break
@@ -167,6 +194,7 @@ class HTTPClient:
 
             # If still no budget after trying all keys, handle exhaustion smartly
             if not self.rate_limiter.has_budget(idx, weight):
+                logger.warning("no-budget-after-rotation", weight=weight)
                 self._handle_rate_limit_exhaustion(weight)
                 idx = self.key_index  # Update idx after potential key change
 
@@ -175,10 +203,13 @@ class HTTPClient:
 
         # Update rate limit usage for this call
         self.rate_limiter.record_call(idx, weight)
+        logger.debug("weight-recorded", weight=weight, key_index=idx)
 
         try:
             response = self._make_http_request(method, url, headers, body)
+            logger.debug("request-completed", status_code=response.status_code)
         except httpx.HTTPError as exc:
+            logger.error("http-request-failed", error=str(exc))
             return Failure(exc)
 
         self._update_rate_limits(response, idx)
@@ -189,6 +220,7 @@ class HTTPClient:
         """Ensure the initial rate limit state is fetched from the API."""
         if self._rate_limit_initialized:
             return
+        logger.info("initializing-rate-limit-state")
         self._rate_limit_initialized = True
         self._initialize_rate_limit()
 
@@ -196,6 +228,7 @@ class HTTPClient:
         """Fetch initial rate limit and handle potential rate limit errors."""
         endpoint = "/account"
         url = f"{self.settings.rest_url}{endpoint}"
+        logger.debug("fetching-initial-rate-limit")
 
         while True:
             headers = self._create_auth_headers("GET", endpoint, None)
@@ -204,7 +237,8 @@ class HTTPClient:
 
             try:
                 response = self._make_http_request("GET", url, headers, None)
-            except httpx.HTTPError:
+            except httpx.HTTPError as exc:
+                logger.warning("rate-limit-init-failed", error=str(exc))
                 return
 
             self._update_rate_limits(response, self.key_index)
@@ -220,15 +254,19 @@ class HTTPClient:
                     if isinstance(err, dict):
                         err_code = str(err.get("code", ""))
             if response.status_code == httpx.codes.TOO_MANY_REQUESTS and err_code == "101":
+                logger.info("rate-limited-during-init", error_code=err_code)
                 self.rate_limiter.sleep_until_reset(self.key_index)
                 self.rate_limiter.reset_key(self.key_index)
                 continue
 
             if self.rate_limiter.get_remaining(self.key_index) < self.rate_limiter.buffer:
+                remaining = self.rate_limiter.get_remaining(self.key_index)
+                logger.info("low-budget-during-init", remaining=remaining)
                 self.rate_limiter.sleep_until_reset(self.key_index)
                 self.rate_limiter.reset_key(self.key_index)
                 continue
 
+            logger.info("rate-limit-initialization-completed")
             break
 
     def _create_auth_headers(self, method: str, endpoint: str, body: AnyDict | None) -> dict[str, str]:
@@ -264,6 +302,7 @@ class HTTPClient:
                 return httpx.delete(url, headers=headers, timeout=timeout)
             case _:
                 msg = f"Unsupported HTTP method: {method}"
+                logger.error("unsupported-http-method", method=method)
                 raise ValueError(msg)
 
     def _update_rate_limits(self, response: httpx.Response, idx: int) -> None:
@@ -275,10 +314,13 @@ class HTTPClient:
 
         if isinstance(json_data, dict) and "error" in json_data:
             if self._is_rate_limit_error(response, json_data):
+                logger.warning("rate-limit-error-detected", key_index=idx)
                 self.rate_limiter.update_from_error(idx, json_data)
             else:
+                logger.debug("non-rate-limit-error", key_index=idx)
                 self.rate_limiter.update_from_headers(idx, dict(response.headers))
         else:
+            logger.debug("successful-response", key_index=idx)
             self.rate_limiter.update_from_headers(idx, dict(response.headers))
 
     def _is_rate_limit_error(self, response: httpx.Response, json_data: dict[str, Any]) -> bool: