bitvavo-api-upgraded 4.2.1__tar.gz → 4.3.0__tar.gz

{bitvavo_api_upgraded-4.2.1 → bitvavo_api_upgraded-4.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: bitvavo-api-upgraded
-Version: 4.2.1
+Version: 4.3.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>
@@ -214,7 +214,6 @@ BITVAVO_API_SECRET=your-api-secret-here
 # BITVAVO_API_KEYS='[{"key": "key1", "secret": "secret1"}, {"key": "key2", "secret": "secret2"}]'
 
 # Client behavior
-BITVAVO_PREFER_KEYLESS=true          # Use keyless for public endpoints
 BITVAVO_DEFAULT_RATE_LIMIT=1000      # Rate limit per key
 BITVAVO_RATE_LIMIT_BUFFER=50         # Buffer to avoid hitting limits
 BITVAVO_DEBUGGING=false              # Enable debug logging
@@ -238,7 +237,6 @@ client = BitvavoClient()
 settings = BitvavoSettings(
     api_key="your-key",
     api_secret="your-secret",
-    prefer_keyless=True,
     debugging=True
 )
 client = BitvavoClient(settings)
@@ -279,7 +277,7 @@ bitvavo = Bitvavo({
 })
 
 # Option 4: Keyless (public endpoints only)
-bitvavo = Bitvavo({'PREFER_KEYLESS': True})
+bitvavo = Bitvavo({})
 ```
 
 ## Data Format Flexibility
@@ -400,7 +398,7 @@ trades = bitvavo.getTrades('BTC-EUR', {})  # Automatic failover if rate limit re
 from bitvavo_api_upgraded import Bitvavo
 
 # No API keys needed for public data
-bitvavo = Bitvavo({'PREFER_KEYLESS': True})
+bitvavo = Bitvavo({})
 
 # These work without authentication and don't count against your rate limits
 markets = bitvavo.markets({})
@@ -416,13 +414,12 @@ candles = bitvavo.candles('BTC-EUR', '1h', {})
 ### Hybrid Configuration
 
 ```python
-# Combine keyless preference with API keys for optimal performance
+# Combine keyless access with API keys for optimal performance
 bitvavo = Bitvavo({
     'APIKEYS': [
         {'key': 'key1', 'secret': 'secret1'},
         {'key': 'key2', 'secret': 'secret2'}
-    ],
-    'PREFER_KEYLESS': True  # Use keyless for public endpoints, API keys for private
+    ]
 })
 
 # Public calls use keyless (no rate limit impact)
@@ -470,7 +467,7 @@ candles_result = client.public.candles('BTC-EUR', '1h')
 ```python
 from bitvavo_api_upgraded import Bitvavo
 
-bitvavo = Bitvavo({'PREFER_KEYLESS': True})  # For public endpoints
+bitvavo = Bitvavo({})  # For public endpoints
 
 # Get server time
 time_resp = bitvavo.time()
@@ -705,7 +702,7 @@ for i in range(2000):  # Would exceed single key limit
     markets = bitvavo_multi.markets({})  # Automatically switches keys
 
 # Keyless calls don't count against authenticated rate limits
-bitvavo_keyless = Bitvavo({'PREFER_KEYLESS': True})
+bitvavo_keyless = Bitvavo({})
 markets = bitvavo_keyless.markets({})  # Uses public rate limit pool
 ```
 
@@ -886,7 +883,7 @@ result = client.private.balance()
    bitvavo = Bitvavo({'APIKEYS': [{'key': 'k1', 'secret': 's1'}, {'key': 'k2', 'secret': 's2'}]})
 
    # Keyless for public endpoints
-   bitvavo = Bitvavo({'PREFER_KEYLESS': True})
+   bitvavo = Bitvavo({})
 
    # DataFrame support
    markets_df = bitvavo.markets({}, output_format='pandas')

{bitvavo_api_upgraded-4.2.1 → bitvavo_api_upgraded-4.3.0}/README.md

@@ -150,7 +150,6 @@ BITVAVO_API_SECRET=your-api-secret-here
 # BITVAVO_API_KEYS='[{"key": "key1", "secret": "secret1"}, {"key": "key2", "secret": "secret2"}]'
 
 # Client behavior
-BITVAVO_PREFER_KEYLESS=true          # Use keyless for public endpoints
 BITVAVO_DEFAULT_RATE_LIMIT=1000      # Rate limit per key
 BITVAVO_RATE_LIMIT_BUFFER=50         # Buffer to avoid hitting limits
 BITVAVO_DEBUGGING=false              # Enable debug logging
@@ -174,7 +173,6 @@ client = BitvavoClient()
 settings = BitvavoSettings(
     api_key="your-key",
     api_secret="your-secret",
-    prefer_keyless=True,
     debugging=True
 )
 client = BitvavoClient(settings)
@@ -215,7 +213,7 @@ bitvavo = Bitvavo({
 })
 
 # Option 4: Keyless (public endpoints only)
-bitvavo = Bitvavo({'PREFER_KEYLESS': True})
+bitvavo = Bitvavo({})
 ```
 
 ## Data Format Flexibility
@@ -336,7 +334,7 @@ trades = bitvavo.getTrades('BTC-EUR', {})  # Automatic failover if rate limit re
 from bitvavo_api_upgraded import Bitvavo
 
 # No API keys needed for public data
-bitvavo = Bitvavo({'PREFER_KEYLESS': True})
+bitvavo = Bitvavo({})
 
 # These work without authentication and don't count against your rate limits
 markets = bitvavo.markets({})
@@ -352,13 +350,12 @@ candles = bitvavo.candles('BTC-EUR', '1h', {})
 ### Hybrid Configuration
 
 ```python
-# Combine keyless preference with API keys for optimal performance
+# Combine keyless access with API keys for optimal performance
 bitvavo = Bitvavo({
     'APIKEYS': [
         {'key': 'key1', 'secret': 'secret1'},
         {'key': 'key2', 'secret': 'secret2'}
-    ],
-    'PREFER_KEYLESS': True  # Use keyless for public endpoints, API keys for private
+    ]
 })
 
 # Public calls use keyless (no rate limit impact)
@@ -406,7 +403,7 @@ candles_result = client.public.candles('BTC-EUR', '1h')
 ```python
 from bitvavo_api_upgraded import Bitvavo
 
-bitvavo = Bitvavo({'PREFER_KEYLESS': True})  # For public endpoints
+bitvavo = Bitvavo({})  # For public endpoints
 
 # Get server time
 time_resp = bitvavo.time()
@@ -641,7 +638,7 @@ for i in range(2000):  # Would exceed single key limit
     markets = bitvavo_multi.markets({})  # Automatically switches keys
 
 # Keyless calls don't count against authenticated rate limits
-bitvavo_keyless = Bitvavo({'PREFER_KEYLESS': True})
+bitvavo_keyless = Bitvavo({})
 markets = bitvavo_keyless.markets({})  # Uses public rate limit pool
 ```
 
@@ -822,7 +819,7 @@ result = client.private.balance()
    bitvavo = Bitvavo({'APIKEYS': [{'key': 'k1', 'secret': 's1'}, {'key': 'k2', 'secret': 's2'}]})
 
    # Keyless for public endpoints
-   bitvavo = Bitvavo({'PREFER_KEYLESS': True})
+   bitvavo = Bitvavo({})
 
    # DataFrame support
    markets_df = bitvavo.markets({}, output_format='pandas')

{bitvavo_api_upgraded-4.2.1 → bitvavo_api_upgraded-4.3.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.2.1"
+version = "4.3.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.2.1"
+current_version = "4.3.0"
 parse = "(?P<major>\\d+)\\.(?P<minor>\\d+)\\.(?P<patch>\\d+)"
 serialize = ["{major}.{minor}.{patch}"]
 search = "{current_version}"

{bitvavo_api_upgraded-4.2.1 → bitvavo_api_upgraded-4.3.0}/src/bitvavo_api_upgraded/bitvavo.py

@@ -167,7 +167,7 @@ class Bitvavo:
     )
     time_dict = bitvavo.time()
 
-    # Multiple API keys with keyless preference
+    # Multiple API keys
     bitvavo = Bitvavo(
         {
             "APIKEYS": [
@@ -175,7 +175,6 @@ class Bitvavo:
                 {"key": "$YOUR_API_KEY_2", "secret": "$YOUR_API_SECRET_2"},
                 {"key": "$YOUR_API_KEY_3", "secret": "$YOUR_API_SECRET_3"},
             ],
-            "PREFER_KEYLESS": True,  # Use keyless requests first, then API keys
             "RESTURL": "https://api.bitvavo.com/v2",
             "WSURL": "wss://ws.bitvavo.com/v2/",
             "ACCESSWINDOW": 10000,
@@ -187,7 +186,6 @@ class Bitvavo:
     # Keyless only (no API keys)
     bitvavo = Bitvavo(
         {
-            "PREFER_KEYLESS": True,
             "RESTURL": "https://api.bitvavo.com/v2",
             "WSURL": "wss://ws.bitvavo.com/v2/",
             "ACCESSWINDOW": 10000,
@@ -235,11 +233,14 @@ class Bitvavo:
                 else:
                     self.api_keys = []
 
-        # Current API key index and keyless preference - options take precedence
+        if not self.api_keys:
+            msg = "API keys are required"
+            raise ValueError(msg)
+
+        # Current API key index - options take precedence
         self.current_api_key_index: int = 0
-        self.prefer_keyless: bool = bool(_options.get("PREFER_KEYLESS", bitvavo_upgraded_settings.PREFER_KEYLESS))
 
-        # Rate limiting per API key (keyless has index -1)
+        # Rate limiting per API key
         self.rate_limits: dict[int, dict[str, int | ms]] = {}
         # Get default rate limit from options or settings
         default_rate_limit_option = _options.get("DEFAULT_RATE_LIMIT", bitvavo_upgraded_settings.DEFAULT_RATE_LIMIT)
@@ -249,7 +250,6 @@ class Bitvavo:
             else bitvavo_upgraded_settings.DEFAULT_RATE_LIMIT
         )
 
-        self.rate_limits[-1] = {"remaining": default_rate_limit, "resetAt": ms(0)}  # keyless
         for i in range(len(self.api_keys)):
             self.rate_limits[i] = {"remaining": default_rate_limit, "resetAt": ms(0)}
 
@@ -265,36 +265,21 @@ class Bitvavo:
         self.debugging: bool = bool(_options.get("DEBUGGING", bitvavo_settings.DEBUGGING))
 
     def get_best_api_key_config(self, rateLimitingWeight: int = 1) -> tuple[str, str, int]:
-        """
-        Get the best API key configuration to use for a request.
+        """Get the best API key configuration to use for a request."""
 
-        Returns:
-            tuple: (api_key, api_secret, key_index) where key_index is -1 for keyless
-        """
-        # If prefer keyless and keyless has enough rate limit, use keyless
-        if self.prefer_keyless and self._has_rate_limit_available(-1, rateLimitingWeight):
-            return "", "", -1
-
-        # Try to find an API key with enough rate limit
         for i in range(len(self.api_keys)):
             if self._has_rate_limit_available(i, rateLimitingWeight):
                 return self.api_keys[i]["key"], self.api_keys[i]["secret"], i
 
-        # If keyless is available, use it as fallback
-        if self._has_rate_limit_available(-1, rateLimitingWeight):
-            return "", "", -1
-
-        # No keys available, use current key and let rate limiting handle the wait
-        if self.api_keys:
-            return (
-                self.api_keys[self.current_api_key_index]["key"],
-                self.api_keys[self.current_api_key_index]["secret"],
-                self.current_api_key_index,
-            )
-        return "", "", -1
+        # No keys have available budget, use current key and let rate limiting handle the wait
+        return (
+            self.api_keys[self.current_api_key_index]["key"],
+            self.api_keys[self.current_api_key_index]["secret"],
+            self.current_api_key_index,
+        )
 
     def _has_rate_limit_available(self, key_index: int, weight: int) -> bool:
-        """Check if a specific API key (or keyless) has enough rate limit."""
+        """Check if a specific API key has enough rate limit."""
         if key_index not in self.rate_limits:
             return False
         remaining = self.rate_limits[key_index]["remaining"]
@@ -320,7 +305,7 @@ class Bitvavo:
                 self.rate_limits[key_index]["resetAt"] = ms(time_ms() + 60000)
 
             timeToWait = time_to_wait(ms(self.rate_limits[key_index]["resetAt"]))
-            key_name = f"API_KEY_{key_index}" if key_index >= 0 else "KEYLESS"
+            key_name = f"API_KEY_{key_index}"
             logger.warning(
                 "api-key-banned",
                 info={
@@ -530,7 +515,7 @@ class Bitvavo:
         list[list[str]]
         ```
         """
-        # Get the best API key configuration (keyless preferred, then available keys)
+        # Get the best API key configuration
         api_key, api_secret, key_index = self.get_best_api_key_config(rateLimitingWeight)
 
         # Check if we need to wait for rate limit
@@ -538,38 +523,25 @@ class Bitvavo:
             self._sleep_for_key(key_index)
 
         # Update current API key for legacy compatibility
-        if api_key:
-            self._current_api_key = api_key
-            self._current_api_secret = api_secret
-            self.current_api_key_index = key_index
-        else:
-            # Using keyless
-            self._current_api_key = ""
-            self._current_api_secret = ""
+        self._current_api_key = api_key
+        self._current_api_secret = api_secret
+        self.current_api_key_index = key_index
 
         if self.debugging:
             logger.debug(
                 "api-request",
-                info={
-                    "url": url,
-                    "with_api_key": bool(api_key != ""),
-                    "public_or_private": "public",
-                    "key_index": key_index,
-                },
+                info={"url": url, "key_index": key_index},
             )
 
-        if api_key:
-            now = time_ms() + bitvavo_upgraded_settings.LAG
-            sig = create_signature(now, "GET", url.replace(self.base, ""), None, api_secret)
-            headers = {
-                "bitvavo-access-key": api_key,
-                "bitvavo-access-signature": sig,
-                "bitvavo-access-timestamp": str(now),
-                "bitvavo-access-window": str(self.ACCESSWINDOW),
-            }
-            r = get(url, headers=headers, timeout=(self.ACCESSWINDOW / 1000))
-        else:
-            r = get(url, timeout=(self.ACCESSWINDOW / 1000))
+        now = time_ms() + bitvavo_upgraded_settings.LAG
+        sig = create_signature(now, "GET", url.replace(self.base, ""), None, api_secret)
+        headers = {
+            "bitvavo-access-key": api_key,
+            "bitvavo-access-signature": sig,
+            "bitvavo-access-timestamp": str(now),
+            "bitvavo-access-window": str(self.ACCESSWINDOW),
+        }
+        r = get(url, headers=headers, timeout=(self.ACCESSWINDOW / 1000))
 
         # Update rate limit for the specific key used
         if "error" in r.json():
@@ -2371,7 +2343,7 @@ class Bitvavo:
                 # Update rate limit tracking indices (shift them down)
                 new_rate_limits = {}
                 for key_idx, limits in self.rate_limits.items():
-                    if key_idx == -1 or key_idx < i:  # keyless
+                    if key_idx < i:
                         new_rate_limits[key_idx] = limits
                     elif key_idx > i:
                         new_rate_limits[key_idx - 1] = limits
@@ -2389,19 +2361,10 @@ class Bitvavo:
         """Get the current status of all API keys including rate limits.
 
         Returns:
-            dict: Status information for keyless and all API keys
+            dict: Status information for all API keys
         """
         status = {}
 
-        # Keyless status
-        keyless_limits = self.rate_limits.get(-1, {"remaining": 0, "resetAt": ms(0)})
-        status["keyless"] = {
-            "remaining": int(keyless_limits["remaining"]),
-            "resetAt": int(keyless_limits["resetAt"]),
-            "available": self._has_rate_limit_available(-1, 1),
-        }
-
-        # API key status
         for i, key_data in enumerate(self.api_keys):
             key_limits = self.rate_limits.get(i, {"remaining": 0, "resetAt": ms(0)})
             KEY_LENGTH = 12
@@ -2419,15 +2382,6 @@ class Bitvavo:
 
         return status
 
-    def set_keyless_preference(self, prefer_keyless: bool) -> None:  # noqa: FBT001 (Boolean-typed positional argument in function definition)
-        """Set whether to prefer keyless requests.
-
-        Args:
-            prefer_keyless: If True, use keyless requests first when available
-        """
-        self.prefer_keyless = prefer_keyless
-        logger.info("keyless-preference-changed", prefer_keyless=prefer_keyless)
-
     def get_current_config(self) -> dict[str, str | bool | int]:
         """Get the current configuration.
 
@@ -2437,7 +2391,6 @@ class Bitvavo:
         KEY_LENGTH = 12
         return {
             "api_key_count": len(self.api_keys),
-            "prefer_keyless": self.prefer_keyless,
             "current_api_key_index": self.current_api_key_index,
             "current_api_key": self._current_api_key[:8] + "..." + self._current_api_key[-4:]
             if len(self._current_api_key) > KEY_LENGTH

{bitvavo_api_upgraded-4.2.1 → bitvavo_api_upgraded-4.3.0}/src/bitvavo_api_upgraded/settings.py

@@ -28,7 +28,6 @@ class BitvavoApiUpgradedSettings(BaseSettings):
     RATE_LIMITING_BUFFER: int = Field(default=25)
 
     # Multi-API key settings
-    PREFER_KEYLESS: bool = Field(default=True, description="Prefer keyless requests over API key requests")
     DEFAULT_RATE_LIMIT: int = Field(default=1000, description="Default rate limit for new API keys")
 
     SSL_CERT_FILE: str | None = Field(
@@ -101,9 +100,6 @@ class BitvavoSettings(BaseSettings):
     RESTURL: str = Field(default="https://api.bitvavo.com/v2")
     WSURL: str = Field(default="wss://ws.bitvavo.com/v2/")
 
-    # Multi-key specific settings
-    PREFER_KEYLESS: bool = Field(default=True)
-
     # Configuration for Pydantic Settings
     model_config = SettingsConfigDict(
         env_file=Path.cwd() / ".env",

{bitvavo_api_upgraded-4.2.1 → bitvavo_api_upgraded-4.3.0}/src/bitvavo_client/auth/rate_limit.py

@@ -58,6 +58,20 @@ class RateLimitManager:
         self.ensure_key(idx)
         return (self.state[idx]["remaining"] - weight) >= self.buffer
 
+    def record_call(self, idx: int, weight: int) -> None:
+        """Record a request by decreasing the remaining budget.
+
+        This should be called whenever an API request is made to ensure
+        the local rate limit state reflects all outgoing calls, even when
+        the response doesn't include rate limit headers.
+
+        Args:
+            idx: API key index (-1 for keyless)
+            weight: Weight of the request
+        """
+        self.ensure_key(idx)
+        self.state[idx]["remaining"] = max(0, self.state[idx]["remaining"] - weight)
+
     def update_from_headers(self, idx: int, headers: dict[str, str]) -> None:
         """Update rate limit state from response headers.
 

{bitvavo_api_upgraded-4.2.1 → bitvavo_api_upgraded-4.3.0}/src/bitvavo_client/core/settings.py

@@ -29,7 +29,6 @@ class BitvavoSettings(BaseSettings):
     access_window_ms: int = Field(default=10_000, description="API access window in milliseconds")
 
     # Client behavior
-    prefer_keyless: bool = Field(default=True, description="Prefer keyless requests when possible")
     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")
     lag_ms: int = Field(default=0, description="Artificial lag to add to requests in milliseconds")
@@ -41,7 +40,8 @@ class BitvavoSettings(BaseSettings):
 
     # Multiple API keys support
     api_keys: list[dict[str, str]] = Field(
-        default_factory=list, description="List of API key/secret pairs for multi-key support"
+        default_factory=list,
+        description="List of API key/secret pairs for multi-key support",
     )
 
     @model_validator(mode="after")

{bitvavo_api_upgraded-4.2.1 → bitvavo_api_upgraded-4.3.0}/src/bitvavo_client/endpoints/base.py

@@ -13,6 +13,8 @@ from bitvavo_client.core.model_preferences import ModelPreference
 if TYPE_CHECKING:
     from collections.abc import Mapping
 
+    from bitvavo_client.transport.http import HTTPClient
+
 T = TypeVar("T")
 
 
@@ -214,7 +216,7 @@ class BaseAPI:
 
     def __init__(
         self,
-        http_client: Any,
+        http_client: HTTPClient,
         *,
         preferred_model: ModelPreference | str | None = None,
         default_schema: Mapping[str, object] | None = None,

bitvavo_api_upgraded-4.3.0/src/bitvavo_client/facade.py

@@ -0,0 +1,56 @@
+"""Main facade for the Bitvavo client."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from bitvavo_client.auth.rate_limit import RateLimitManager
+from bitvavo_client.core.settings import BitvavoSettings
+from bitvavo_client.endpoints.private import PrivateAPI
+from bitvavo_client.endpoints.public import PublicAPI
+from bitvavo_client.transport.http import HTTPClient
+
+if TYPE_CHECKING:  # pragma: no cover
+    from bitvavo_client.core.model_preferences import ModelPreference
+
+
+class BitvavoClient:
+    """
+    Main Bitvavo API client facade providing backward-compatible interface.
+
+    TODO(NostraDavid): add mechanisms to get a ton of data efficiently, which then uses the public and private APIs.
+    Otherwise, users can just grab the data themselves via the public and private API endpoints.
+    """
+
+    def __init__(
+        self,
+        settings: BitvavoSettings | None = None,
+        *,
+        preferred_model: ModelPreference | str | None = None,
+        default_schema: dict | None = None,
+    ) -> None:
+        """Initialize Bitvavo client.
+
+        Args:
+            settings: Optional settings override. If None, uses defaults.
+            preferred_model: Preferred model format for responses
+            default_schema: Default schema for DataFrame conversion
+        """
+        self.settings = settings or BitvavoSettings()
+        self.rate_limiter = RateLimitManager(
+            self.settings.default_rate_limit,
+            self.settings.rate_limit_buffer,
+        )
+        self.http = HTTPClient(self.settings, self.rate_limiter)
+
+        # Initialize API endpoint handlers with preferred model settings
+        self.public = PublicAPI(
+            self.http,
+            preferred_model=preferred_model,
+            default_schema=default_schema,
+        )
+        self.private = PrivateAPI(
+            self.http,
+            preferred_model=preferred_model,
+            default_schema=default_schema,
+        )

bitvavo_api_upgraded-4.3.0/src/bitvavo_client/transport/http.py

@@ -0,0 +1,250 @@
+"""HTTP client for Bitvavo API."""
+
+from __future__ import annotations
+
+import time
+from typing import TYPE_CHECKING, Any
+
+import httpx
+from returns.result import Failure, Result
+
+from bitvavo_client.adapters.returns_adapter import (
+    BitvavoError,
+    decode_response_result,
+)
+from bitvavo_client.auth.signing import create_signature
+
+if TYPE_CHECKING:  # pragma: no cover
+    from bitvavo_client.auth.rate_limit import RateLimitManager
+    from bitvavo_client.core.settings import BitvavoSettings
+    from bitvavo_client.core.types import AnyDict
+
+
+class HTTPClient:
+    """HTTP client for Bitvavo REST API with rate limiting and authentication."""
+
+    def __init__(self, settings: BitvavoSettings, rate_limiter: RateLimitManager) -> None:
+        """Initialize HTTP client.
+
+        Args:
+            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"
+            raise ValueError(msg)
+
+        for idx in range(len(self._keys)):
+            self.rate_limiter.ensure_key(idx)
+
+        self.key_index: int = 0
+        self.api_key: str = ""
+        self.api_secret: str = ""
+        self._rate_limit_initialized: bool = False
+
+        key, secret = self._keys[0]
+        self.configure_key(key, secret, 0)
+
+    def configure_key(self, key: str, secret: str, index: int) -> None:
+        """Configure API key for authenticated requests.
+
+        Args:
+            key: API key
+            secret: API secret
+            index: Key index for rate limiting
+        """
+        self.api_key = key
+        self.api_secret = secret
+        self.key_index = index
+
+    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"
+            raise IndexError(msg)
+        key, secret = self._keys[index]
+        self.configure_key(key, secret, index)
+
+    def _rotate_key(self) -> bool:
+        """Rotate to the next configured API key if available."""
+        if len(self._keys) <= 1:
+            return False
+
+        next_idx = (self.key_index + 1) % len(self._keys)
+        now = int(time.time() * 1000)
+        reset_at = self.rate_limiter.get_reset_at(next_idx)
+
+        if now < reset_at:
+            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:
+            self.rate_limiter.reset_key(next_idx)
+
+        self.select_key(next_idx)
+        return True
+
+    def request(
+        self,
+        method: str,
+        endpoint: str,
+        *,
+        body: AnyDict | None = None,
+        weight: int = 1,
+    ) -> Result[Any, BitvavoError | httpx.HTTPError]:
+        """Make HTTP request and return raw JSON data as a Result.
+
+        Args:
+            method: HTTP method (GET, POST, PUT, DELETE)
+            endpoint: API endpoint path
+            body: Request body for POST/PUT requests
+            weight: Rate limit weight of the request
+
+        Returns:
+            Result containing raw JSON response or error
+
+        Raises:
+            HTTPError: On transport-level failures
+        """
+        idx = self.key_index
+        self._ensure_rate_limit_initialized()
+
+        if not self.rate_limiter.has_budget(idx, weight):
+            for _ in range(len(self._keys)):
+                if self.rate_limiter.has_budget(idx, weight):
+                    break
+                rotated = self._rotate_key()
+                idx = self.key_index
+                if not rotated:
+                    break
+            if not self.rate_limiter.has_budget(idx, weight):
+                self.rate_limiter.handle_limit(idx, weight)
+
+        url = f"{self.settings.rest_url}{endpoint}"
+        headers = self._create_auth_headers(method, endpoint, body)
+
+        # Update rate limit usage for this call
+        self.rate_limiter.record_call(idx, weight)
+
+        try:
+            response = self._make_http_request(method, url, headers, body)
+        except httpx.HTTPError as exc:
+            return Failure(exc)
+
+        self._update_rate_limits(response, idx)
+        # Always return raw data - let the caller handle model conversion
+        return decode_response_result(response, model=Any)
+
+    def _ensure_rate_limit_initialized(self) -> None:
+        """Ensure the initial rate limit state is fetched from the API."""
+        if self._rate_limit_initialized:
+            return
+        self._rate_limit_initialized = True
+        self._initialize_rate_limit()
+
+    def _initialize_rate_limit(self) -> None:
+        """Fetch initial rate limit and handle potential rate limit errors."""
+        endpoint = "/account"
+        url = f"{self.settings.rest_url}{endpoint}"
+
+        while True:
+            headers = self._create_auth_headers("GET", endpoint, None)
+            # Record the weight for this check (weight 1)
+            self.rate_limiter.record_call(self.key_index, 1)
+
+            try:
+                response = self._make_http_request("GET", url, headers, None)
+            except httpx.HTTPError:
+                return
+
+            self._update_rate_limits(response, self.key_index)
+
+            err_code = ""
+            if response.status_code == httpx.codes.TOO_MANY_REQUESTS:
+                try:
+                    data = response.json()
+                except ValueError:
+                    data = {}
+                if isinstance(data, dict):
+                    err = data.get("error")
+                    if isinstance(err, dict):
+                        err_code = str(err.get("code", ""))
+            if response.status_code == httpx.codes.TOO_MANY_REQUESTS and err_code == "101":
+                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:
+                self.rate_limiter.sleep_until_reset(self.key_index)
+                self.rate_limiter.reset_key(self.key_index)
+                continue
+
+            break
+
+    def _create_auth_headers(self, method: str, endpoint: str, body: AnyDict | None) -> dict[str, str]:
+        """Create authentication headers if API key is configured."""
+        timestamp = int(time.time() * 1000) + self.settings.lag_ms
+        signature = create_signature(timestamp, method, endpoint, body, self.api_secret)
+
+        return {
+            "bitvavo-access-key": self.api_key,
+            "bitvavo-access-signature": signature,
+            "bitvavo-access-timestamp": str(timestamp),
+            "bitvavo-access-window": str(self.settings.access_window_ms),
+        }
+
+    def _make_http_request(
+        self,
+        method: str,
+        url: str,
+        headers: dict[str, str],
+        body: AnyDict | None,
+    ) -> httpx.Response:
+        """Make the actual HTTP request."""
+        timeout = self.settings.access_window_ms / 1000
+
+        match method:
+            case "GET":
+                return httpx.get(url, headers=headers, timeout=timeout)
+            case "POST":
+                return httpx.post(url, headers=headers, json=body, timeout=timeout)
+            case "PUT":
+                return httpx.put(url, headers=headers, json=body, timeout=timeout)
+            case "DELETE":
+                return httpx.delete(url, headers=headers, timeout=timeout)
+            case _:
+                msg = f"Unsupported HTTP method: {method}"
+                raise ValueError(msg)
+
+    def _update_rate_limits(self, response: httpx.Response, idx: int) -> None:
+        """Update rate limits based on response."""
+        try:
+            json_data = response.json()
+        except ValueError:
+            json_data = {}
+
+        if isinstance(json_data, dict) and "error" in json_data:
+            if self._is_rate_limit_error(response, json_data):
+                self.rate_limiter.update_from_error(idx, json_data)
+            else:
+                self.rate_limiter.update_from_headers(idx, dict(response.headers))
+        else:
+            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:
+        """Check if response indicates a rate limit error."""
+        status = getattr(response, "status_code", None)
+        if status == httpx.codes.TOO_MANY_REQUESTS:
+            return True
+
+        err = json_data.get("error")
+        if isinstance(err, dict):
+            code = str(err.get("code", "")).lower()
+            message = str(err.get("message", "")).lower()
+        else:
+            code = ""
+            message = str(err).lower()
+
+        return any(k in code or k in message for k in ("rate", "limit", "too_many"))

bitvavo_api_upgraded-4.2.1/src/bitvavo_client/facade.py

@@ -1,117 +0,0 @@
-"""Main facade for the Bitvavo client."""
-
-from __future__ import annotations
-
-import time
-from typing import TYPE_CHECKING, TypeVar
-
-from bitvavo_client.auth.rate_limit import RateLimitManager
-from bitvavo_client.core.settings import BitvavoSettings
-from bitvavo_client.endpoints.private import PrivateAPI
-from bitvavo_client.endpoints.public import PublicAPI
-from bitvavo_client.transport.http import HTTPClient
-
-if TYPE_CHECKING:  # pragma: no cover
-    from bitvavo_client.core.model_preferences import ModelPreference
-
-T = TypeVar("T")
-
-
-class BitvavoClient:
-    """
-    Main Bitvavo API client facade providing backward-compatible interface.
-
-    TODO(NostraDavid): add mechanisms to get a ton of data efficiently, which then uses the public and private APIs.
-    Otherwise, users can just grab the data themselves via the public and private API endpoints.
-    """
-
-    def __init__(
-        self,
-        settings: BitvavoSettings | None = None,
-        *,
-        preferred_model: ModelPreference | str | None = None,
-        default_schema: dict | None = None,
-    ) -> None:
-        """Initialize Bitvavo client.
-
-        Args:
-            settings: Optional settings override. If None, uses defaults.
-            preferred_model: Preferred model format for responses
-            default_schema: Default schema for DataFrame conversion
-        """
-        self.settings = settings or BitvavoSettings()
-        self.rate_limiter = RateLimitManager(
-            self.settings.default_rate_limit,
-            self.settings.rate_limit_buffer,
-        )
-        self.http = HTTPClient(self.settings, self.rate_limiter)
-
-        # Initialize API endpoint handlers with preferred model settings
-        self.public = PublicAPI(self.http, preferred_model=preferred_model, default_schema=default_schema)
-        self.private = PrivateAPI(self.http, preferred_model=preferred_model, default_schema=default_schema)
-
-        # Configure API keys if available
-        self._api_keys: list[tuple[str, str]] = []
-        self._current_key: int = -1
-        self._configure_api_keys()
-
-    def _configure_api_keys(self) -> None:
-        """Configure API keys for authentication."""
-        # Collect keys from settings
-        if self.settings.api_key and self.settings.api_secret:
-            self._api_keys.append((self.settings.api_key, self.settings.api_secret))
-        if self.settings.api_keys:
-            self._api_keys.extend((item["key"], item["secret"]) for item in self.settings.api_keys)
-
-        if not self._api_keys:
-            return
-
-        for idx, (_key, _secret) in enumerate(self._api_keys):
-            self.rate_limiter.ensure_key(idx)
-
-        if self._api_keys:
-            self.http.set_key_rotation_callback(self.rotate_key)
-
-    def rotate_key(self) -> bool:
-        """Rotate to the next configured API key if available."""
-        if not self._api_keys:
-            return False
-
-        now = int(time.time() * 1000)
-
-        if self._current_key == -1:
-            idx = 0
-            if now < self.rate_limiter.get_reset_at(idx):
-                self.rate_limiter.sleep_until_reset(idx)
-            self.rate_limiter.reset_key(idx)
-            self._current_key = idx
-            key, secret = self._api_keys[idx]
-            self.http.configure_key(key, secret, idx)
-            return True
-
-        if self._current_key < len(self._api_keys) - 1:
-            idx = self._current_key + 1
-            if now < self.rate_limiter.get_reset_at(idx):
-                self.rate_limiter.sleep_until_reset(idx)
-            self.rate_limiter.reset_key(idx)
-            self._current_key = idx
-            key, secret = self._api_keys[idx]
-            self.http.configure_key(key, secret, idx)
-            return True
-
-        reset_at = self.rate_limiter.get_reset_at(-1)
-        if now < reset_at:
-            self.rate_limiter.sleep_until_reset(-1)
-        self.rate_limiter.reset_key(-1)
-        self._current_key = -1
-        self.http.configure_key("", "", -1)
-        return True
-
-    def select_key(self, index: int) -> None:
-        """Select a specific API key by index."""
-        if not (0 <= index < len(self._api_keys)):
-            msg = "API key index out of range"
-            raise IndexError(msg)
-        self._current_key = index
-        key, secret = self._api_keys[index]
-        self.http.configure_key(key, secret, index)

bitvavo_api_upgraded-4.2.1/src/bitvavo_client/transport/http.py

@@ -1,170 +0,0 @@
-"""HTTP client for Bitvavo API."""
-
-from __future__ import annotations
-
-import time
-from typing import TYPE_CHECKING, Any
-
-import httpx
-from returns.result import Failure, Result
-
-from bitvavo_client.adapters.returns_adapter import (
-    BitvavoError,
-    decode_response_result,
-)
-from bitvavo_client.auth.signing import create_signature
-
-if TYPE_CHECKING:  # pragma: no cover
-    from collections.abc import Callable
-
-    from bitvavo_client.auth.rate_limit import RateLimitManager
-    from bitvavo_client.core.settings import BitvavoSettings
-    from bitvavo_client.core.types import AnyDict
-
-
-class HTTPClient:
-    """HTTP client for Bitvavo REST API with rate limiting and authentication."""
-
-    def __init__(self, settings: BitvavoSettings, rate_limiter: RateLimitManager) -> None:
-        """Initialize HTTP client.
-
-        Args:
-            settings: Bitvavo settings configuration
-            rate_limiter: Rate limit manager instance
-        """
-        self.settings: BitvavoSettings = settings
-        self.rate_limiter: RateLimitManager = rate_limiter
-        self.key_index: int = -1
-        self.api_key: str = ""
-        self.api_secret: str = ""
-        self.key_rotation_callback: Callable[[], bool] | None = None
-
-    def configure_key(self, key: str, secret: str, index: int) -> None:
-        """Configure API key for authenticated requests.
-
-        Args:
-            key: API key
-            secret: API secret
-            index: Key index for rate limiting
-        """
-        self.api_key = key
-        self.api_secret = secret
-        self.key_index = index
-
-    def set_key_rotation_callback(self, callback: Callable[[], bool]) -> None:
-        """Set callback to rotate API keys when rate limit exceeded."""
-        self.key_rotation_callback = callback
-
-    def request(
-        self,
-        method: str,
-        endpoint: str,
-        *,
-        body: AnyDict | None = None,
-        weight: int = 1,
-    ) -> Result[Any, BitvavoError | httpx.HTTPError]:
-        """Make HTTP request and return raw JSON data as a Result.
-
-        Args:
-            method: HTTP method (GET, POST, PUT, DELETE)
-            endpoint: API endpoint path
-            body: Request body for POST/PUT requests
-            weight: Rate limit weight of the request
-
-        Returns:
-            Result containing raw JSON response or error
-
-        Raises:
-            HTTPError: On transport-level failures
-        """
-        # Check rate limits
-        if not self.rate_limiter.has_budget(self.key_index, weight):
-            rotated = False
-            if self.key_rotation_callback:
-                rotated = self.key_rotation_callback()
-            if not rotated or not self.rate_limiter.has_budget(self.key_index, weight):
-                self.rate_limiter.handle_limit(self.key_index, weight)
-
-        url = f"{self.settings.rest_url}{endpoint}"
-        headers = self._create_auth_headers(method, endpoint, body)
-
-        try:
-            response = self._make_http_request(method, url, headers, body)
-        except httpx.HTTPError as exc:
-            return Failure(exc)
-
-        self._update_rate_limits(response)
-        # Always return raw data - let the caller handle model conversion
-        return decode_response_result(response, model=Any)
-
-    def _create_auth_headers(self, method: str, endpoint: str, body: AnyDict | None) -> dict[str, str]:
-        """Create authentication headers if API key is configured."""
-        headers: dict[str, str] = {}
-
-        if self.api_key:
-            timestamp = int(time.time() * 1000) + self.settings.lag_ms
-            signature = create_signature(timestamp, method, endpoint, body, self.api_secret)
-
-            headers.update(
-                {
-                    "bitvavo-access-key": self.api_key,
-                    "bitvavo-access-signature": signature,
-                    "bitvavo-access-timestamp": str(timestamp),
-                    "bitvavo-access-window": str(self.settings.access_window_ms),
-                },
-            )
-        return headers
-
-    def _make_http_request(
-        self,
-        method: str,
-        url: str,
-        headers: dict[str, str],
-        body: AnyDict | None,
-    ) -> httpx.Response:
-        """Make the actual HTTP request."""
-        timeout = self.settings.access_window_ms / 1000
-
-        match method:
-            case "GET":
-                return httpx.get(url, headers=headers, timeout=timeout)
-            case "POST":
-                return httpx.post(url, headers=headers, json=body, timeout=timeout)
-            case "PUT":
-                return httpx.put(url, headers=headers, json=body, timeout=timeout)
-            case "DELETE":
-                return httpx.delete(url, headers=headers, timeout=timeout)
-            case _:
-                msg = f"Unsupported HTTP method: {method}"
-                raise ValueError(msg)
-
-    def _update_rate_limits(self, response: httpx.Response) -> None:
-        """Update rate limits based on response."""
-        try:
-            json_data = response.json()
-        except ValueError:
-            json_data = {}
-
-        if isinstance(json_data, dict) and "error" in json_data:
-            if self._is_rate_limit_error(response, json_data):
-                self.rate_limiter.update_from_error(self.key_index, json_data)
-            else:
-                self.rate_limiter.update_from_headers(self.key_index, dict(response.headers))
-        else:
-            self.rate_limiter.update_from_headers(self.key_index, dict(response.headers))
-
-    def _is_rate_limit_error(self, response: httpx.Response, json_data: dict[str, Any]) -> bool:
-        """Check if response indicates a rate limit error."""
-        status = getattr(response, "status_code", None)
-        if status == httpx.codes.TOO_MANY_REQUESTS:
-            return True
-
-        err = json_data.get("error")
-        if isinstance(err, dict):
-            code = str(err.get("code", "")).lower()
-            message = str(err.get("message", "")).lower()
-        else:
-            code = ""
-            message = str(err).lower()
-
-        return any(k in code or k in message for k in ("rate", "limit", "too_many"))