bitvavo-api-upgraded 4.2.1__py3-none-any.whl → 4.3.0__py3-none-any.whl

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/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.dist-info → bitvavo_api_upgraded-4.3.0.dist-info}/METADATA

@@ -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.dist-info → bitvavo_api_upgraded-4.3.0.dist-info}/RECORD

@@ -1,39 +1,39 @@
 bitvavo_api_upgraded/__init__.py,sha256=J_HdGBmZOfb1eOydaxsPmXfOIZ58hVa1qAfE6QErUHs,301
-bitvavo_api_upgraded/bitvavo.py,sha256=_3FRVVPg7_1HrALyGPjcuokCsHF5oz6itN_GKx7yTMo,166155
+bitvavo_api_upgraded/bitvavo.py,sha256=30AQBXNDVEKbmcDdEKknavb9M4JgD8_2WryKS19H49Q,163867
 bitvavo_api_upgraded/dataframe_utils.py,sha256=nGNHVhaCtnmwRYcZXoy4d5LREHeTDYxPmrixB08NcF4,5811
 bitvavo_api_upgraded/helper_funcs.py,sha256=4oBdQ1xB-C2XkQTmN-refzIzWfO-IUowDSWhOSFdCRU,3212
 bitvavo_api_upgraded/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-bitvavo_api_upgraded/settings.py,sha256=I1fogU6_kb1hOe_0YDzOgDhzKfnnYFoIR2OXbwtyD4E,5291
+bitvavo_api_upgraded/settings.py,sha256=JTGcRxg2q0jm-3E5ApHlGA_leNid2lOp_sSH1bo8tOk,5101
 bitvavo_api_upgraded/type_aliases.py,sha256=SbPBcuKWJZPZ8DSDK-Uycu5O-TUO6ejVaTt_7oyGyIU,1979
 bitvavo_client/__init__.py,sha256=YXTBdP6fBREV34VeTqS_gkjfzIoHv5uSYhbqSUEeAVU,207
 bitvavo_client/adapters/__init__.py,sha256=9YVjMhNiAN6K1x7N0UvAXMQwuhOFy4W6Edrba1hW8KI,64
 bitvavo_client/adapters/returns_adapter.py,sha256=3HSAPw6HB9GCS8AbKmeidURpZXnvMZqkvalOu6JhBv0,14195
 bitvavo_client/auth/__init__.py,sha256=bjWu5WCKNNnNoLcVU290tKBml9M5afmcxaU_KrkisSQ,39
-bitvavo_client/auth/rate_limit.py,sha256=EfZtt4nxzu8D3Ea2ElYadrAvEYEt_Wlm60P8u-zVMvs,4391
+bitvavo_client/auth/rate_limit.py,sha256=wv1UI733CVo8y5tI89CaUvomNpXLjbjSUh5vr9vn0ls,4949
 bitvavo_client/auth/signing.py,sha256=DJrI1R1SLKjl276opj9hN4RrKIgsMhxsSEDA8b7T04I,1037
 bitvavo_client/core/__init__.py,sha256=WqjaU9Ut5JdZwn4tsR1vDdrSfMjEJred3im6fvWpalc,39
 bitvavo_client/core/errors.py,sha256=jWHHQKqkkhpHS9TeKlccl7wuyuRrq0H_PGZ0bl6sbW4,460
 bitvavo_client/core/model_preferences.py,sha256=uPXjAD3B4UaBwzmhSN7k59oG71RGmV05y6-FGDKM184,1134
 bitvavo_client/core/private_models.py,sha256=lttKQJQ6sVVwgFJ7WsnXim185KZUfjjuuQzsciPuEL8,33232
 bitvavo_client/core/public_models.py,sha256=st1m1yOxutPhVQteJoRS72mzlQNeL7ynYjG1hqYg27w,37492
-bitvavo_client/core/settings.py,sha256=H721f_EpMFrvk77SQLC3IOHN-UJecSX6uGlgV527PdA,2237
+bitvavo_client/core/settings.py,sha256=jUu_8FQERkJneFHEOW6aHNeYX8DRRcBn_PXIkIipVtQ,2146
 bitvavo_client/core/types.py,sha256=wxqGlbBf6UFMMnRak4H8b7rNymQQuFqKFR8mkSsRig8,429
 bitvavo_client/core/validation_helpers.py,sha256=2KeviuRXFiq4pgttHjC9q8gcrYmtLosSUrlvgnygMQY,3346
 bitvavo_client/df/__init__.py,sha256=1ui3dsRhDvy0NOoOi4zj5gR48u828Au9K_qtH9S1hIo,44
 bitvavo_client/df/convert.py,sha256=bf46QYmyB8o4KFdwUOfaxLV3_Qp29gq0L6hk3Qj-0pI,2522
 bitvavo_client/endpoints/__init__.py,sha256=X1e_Hn6xN7FBBLgKOpjdfIbKiXSp8f4gYSn8wRcn4ro,43
-bitvavo_client/endpoints/base.py,sha256=EyhxXJ2YVuXJeaIwgvF7VAzY-qVZ9maA282Xj0lSyIc,11977
+bitvavo_client/endpoints/base.py,sha256=gZwUHG1XapoVvE9F7yqU8NLt2-QETwUsGSwcHkwOJ80,12042
 bitvavo_client/endpoints/common.py,sha256=fc4gNNZ2zGMJJwkbHexNz6qMDLjl6dalQFGDXWmBo2E,2413
 bitvavo_client/endpoints/private.py,sha256=yChMe-HL2wFm6GBYoghURjdLzSxCPTYlEIOjysCrn3E,34589
 bitvavo_client/endpoints/public.py,sha256=EY7y3vuuo3li1BiPCM2KfSNnoa91X426DPtp8BvHiS8,21944
-bitvavo_client/facade.py,sha256=y08585HMAhYGRI51dUbBezsTFOoZFKgpMZ4GA39r1ew,4368
+bitvavo_client/facade.py,sha256=KZ8_yw9Ygtb8hK4_VIIwlrXGXIp43OJ4c-XncoYoaxE,1969
 bitvavo_client/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 bitvavo_client/schemas/__init__.py,sha256=udqMyAFElrcBbNJIhoarQuTI-CF425JvPFqgLVjILU8,1126
 bitvavo_client/schemas/private_schemas.py,sha256=cG-cV5HKO8ZvWp3hjUPBFMT6Th0UBumMViI8gAZTyik,6143
 bitvavo_client/schemas/public_schemas.py,sha256=zfV6C_PQvNLLYEWS72ZD77Nm3XtRrEghKRhaFpgWHnI,4746
 bitvavo_client/transport/__init__.py,sha256=H7txnyuz6v84_GzdBiqpsehVQitEymgUTA5AJPeUEvg,44
-bitvavo_client/transport/http.py,sha256=H5N-ZQbKwtKsGNadi6YB1gTCViZSns2TMLCGY0LiKgQ,6144
+bitvavo_client/transport/http.py,sha256=hGablbfalBKAaJW9oQvz69oXpietBk7oGtCDZp1sQdc,9113
 bitvavo_client/ws/__init__.py,sha256=Q4SVEq3EihXLVUKpguMdxrhfNAoU8cncpMFbU6kIX_0,44
-bitvavo_api_upgraded-4.2.1.dist-info/WHEEL,sha256=Jb20R3Ili4n9P1fcwuLup21eQ5r9WXhs4_qy7VTrgPI,79
-bitvavo_api_upgraded-4.2.1.dist-info/METADATA,sha256=qil3_u24JDZf1uKRE22_kX87viD56lXcSZw4R6o8EdU,35937
-bitvavo_api_upgraded-4.2.1.dist-info/RECORD,,
+bitvavo_api_upgraded-4.3.0.dist-info/WHEEL,sha256=F3mArEuDT3LDFEqo9fCiUx6ISLN64aIhcGSiIwtu4r8,79
+bitvavo_api_upgraded-4.3.0.dist-info/METADATA,sha256=wzxm4ozq23mZI_CMvOsJUVTl0MrD1lCBx4-b0m7jQ8Q,35640
+bitvavo_api_upgraded-4.3.0.dist-info/RECORD,,

{bitvavo_api_upgraded-4.2.1.dist-info → bitvavo_api_upgraded-4.3.0.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: uv 0.8.15
+Generator: uv 0.8.16
 Root-Is-Purelib: true
 Tag: py3-none-any

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_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_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_client/facade.py

@@ -2,8 +2,7 @@
 
 from __future__ import annotations
 
-import time
-from typing import TYPE_CHECKING, TypeVar
+from typing import TYPE_CHECKING
 
 from bitvavo_client.auth.rate_limit import RateLimitManager
 from bitvavo_client.core.settings import BitvavoSettings
@@ -14,8 +13,6 @@ 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:
     """
@@ -47,71 +44,13 @@ class BitvavoClient:
         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)
+        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_client/transport/http.py

@@ -15,8 +15,6 @@ from bitvavo_client.adapters.returns_adapter import (
 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
@@ -34,10 +32,21 @@ class HTTPClient:
         """
         self.settings: BitvavoSettings = settings
         self.rate_limiter: RateLimitManager = rate_limiter
-        self.key_index: int = -1
+        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.key_rotation_callback: Callable[[], bool] | None = None
+        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.
@@ -51,9 +60,31 @@ class HTTPClient:
         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 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,
@@ -77,43 +108,92 @@ class HTTPClient:
         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)
+        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)
+        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."""
-        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
+        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,
@@ -138,7 +218,7 @@ class HTTPClient:
                 msg = f"Unsupported HTTP method: {method}"
                 raise ValueError(msg)
 
-    def _update_rate_limits(self, response: httpx.Response) -> None:
+    def _update_rate_limits(self, response: httpx.Response, idx: int) -> None:
         """Update rate limits based on response."""
         try:
             json_data = response.json()
@@ -147,11 +227,11 @@ class HTTPClient:
 
         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)
+                self.rate_limiter.update_from_error(idx, json_data)
             else:
-                self.rate_limiter.update_from_headers(self.key_index, dict(response.headers))
+                self.rate_limiter.update_from_headers(idx, dict(response.headers))
         else:
-            self.rate_limiter.update_from_headers(self.key_index, dict(response.headers))
+            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."""