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

{bitvavo_api_upgraded-4.1.2.dist-info → bitvavo_api_upgraded-4.2.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: bitvavo-api-upgraded
-Version: 4.1.2
+Version: 4.2.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.1.2.dist-info → bitvavo_api_upgraded-4.2.1.dist-info}/RECORD

@@ -9,7 +9,7 @@ bitvavo_client/__init__.py,sha256=YXTBdP6fBREV34VeTqS_gkjfzIoHv5uSYhbqSUEeAVU,20
 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=09IjdeTU9GZlszFBmiM6RynE50NwIICyy-8oM6HtX-k,3229
+bitvavo_client/auth/rate_limit.py,sha256=EfZtt4nxzu8D3Ea2ElYadrAvEYEt_Wlm60P8u-zVMvs,4391
 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
@@ -22,17 +22,18 @@ bitvavo_client/core/validation_helpers.py,sha256=2KeviuRXFiq4pgttHjC9q8gcrYmtLos
 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/common.py,sha256=fc4gNNZ2zGMJJwkbHexNz6qMDLjl6dalQFGDXWmBo2E,2413
-bitvavo_client/endpoints/private.py,sha256=dVpDegr_o7-Lsq4HXgPGLas2DcVB8CndfXy7GqHK8AQ,48101
-bitvavo_client/endpoints/public.py,sha256=gDMv1_4RxDCPgY8_VJIQu_9T9PTgS-xIHpWuT0CYLfI,29591
-bitvavo_client/facade.py,sha256=LZELLda4x--6AUAgrloTgWIWTmt_iVMMcSkEp8xf2P4,2644
+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/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=fJX-OfLIox-UOvwuUztPcu95whXAmkfFdo8cQoYdfK0,5614
+bitvavo_client/transport/http.py,sha256=H5N-ZQbKwtKsGNadi6YB1gTCViZSns2TMLCGY0LiKgQ,6144
 bitvavo_client/ws/__init__.py,sha256=Q4SVEq3EihXLVUKpguMdxrhfNAoU8cncpMFbU6kIX_0,44
-bitvavo_api_upgraded-4.1.2.dist-info/WHEEL,sha256=Jb20R3Ili4n9P1fcwuLup21eQ5r9WXhs4_qy7VTrgPI,79
-bitvavo_api_upgraded-4.1.2.dist-info/METADATA,sha256=ToW1wOCtabb5dLJDkQSHPDbVFuAM36jb3f14RQb00a4,35937
-bitvavo_api_upgraded-4.1.2.dist-info/RECORD,,
+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_client/auth/rate_limit.py

@@ -3,6 +3,20 @@
 from __future__ import annotations
 
 import time
+from typing import Protocol
+
+
+class RateLimitStrategy(Protocol):
+    """Protocol for custom rate limit handling strategies."""
+
+    def __call__(self, manager: RateLimitManager, idx: int, weight: int) -> None: ...
+
+
+class DefaultRateLimitStrategy(RateLimitStrategy):
+    """Default RateLimitStrategy implementation that sleeps until the key's rate limit resets."""
+
+    def __call__(self, manager: RateLimitManager, idx: int, _: int) -> None:
+        manager.sleep_until_reset(idx)
 
 
 class RateLimitManager:
@@ -12,16 +26,20 @@ class RateLimitManager:
     for keyless requests.
     """
 
-    def __init__(self, default_remaining: int, buffer: int) -> None:
+    def __init__(self, default_remaining: int, buffer: int, strategy: RateLimitStrategy | None = None) -> None:
         """Initialize rate limit manager.
 
         Args:
             default_remaining: Default rate limit amount
             buffer: Buffer to keep before hitting limit
+            strategy: Optional strategy callback when rate limit exceeded
         """
+        self.default_remaining: int = default_remaining
         self.state: dict[int, dict[str, int]] = {-1: {"remaining": default_remaining, "resetAt": 0}}
         self.buffer: int = buffer
 
+        self._strategy: RateLimitStrategy = strategy or DefaultRateLimitStrategy()
+
     def ensure_key(self, idx: int) -> None:
         """Ensure a key index exists in the state."""
         if idx not in self.state:
@@ -79,6 +97,16 @@ class RateLimitManager:
         ms_left = max(0, self.state[idx]["resetAt"] - now)
         time.sleep(ms_left / 1000 + 1)
 
+    def handle_limit(self, idx: int, weight: int) -> None:
+        """Invoke the configured strategy when rate limit is exceeded."""
+        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)
+        self.state[idx]["remaining"] = self.default_remaining
+        self.state[idx]["resetAt"] = 0
+
     def get_remaining(self, idx: int) -> int:
         """Get remaining rate limit for key index.
 

bitvavo_client/endpoints/base.py

@@ -0,0 +1,305 @@
+"""Shared endpoint utilities for model resolution and DataFrame handling."""
+
+from __future__ import annotations
+
+import contextlib
+from typing import TYPE_CHECKING, Any, TypeVar
+
+from returns.result import Failure, Result, Success
+
+from bitvavo_client.adapters.returns_adapter import BitvavoError
+from bitvavo_client.core.model_preferences import ModelPreference
+
+if TYPE_CHECKING:
+    from collections.abc import Mapping
+
+T = TypeVar("T")
+
+
+# DataFrames preference to library mapping
+_DATAFRAME_LIBRARY_MAP = {
+    ModelPreference.POLARS: ("polars", "pl.DataFrame"),
+    ModelPreference.PANDAS: ("pandas", "pd.DataFrame"),
+    ModelPreference.PYARROW: ("pyarrow", "pa.Table"),
+    ModelPreference.DASK: ("dask", "dd.DataFrame"),
+    ModelPreference.MODIN: ("modin", "mpd.DataFrame"),
+    ModelPreference.CUDF: ("cudf", "cudf.DataFrame"),
+    ModelPreference.IBIS: ("ibis", "ibis.Table"),
+}
+
+
+def _extract_dataframe_data(data: Any, *, items_key: str | None = None) -> list[dict] | dict:
+    """Extract the meaningful data for DataFrame creation from API responses."""
+    if items_key and isinstance(data, dict) and items_key in data:
+        items = data[items_key]
+        if not isinstance(items, list):
+            msg = f"Expected {items_key} to be a list, got {type(items)}"
+            raise ValueError(msg)
+        return items
+    if isinstance(data, list):
+        return data
+    if isinstance(data, dict):
+        return [data]
+    msg = f"Unexpected data type for DataFrame creation: {type(data)}"
+    raise ValueError(msg)
+
+
+def _get_dataframe_constructor(preference: ModelPreference) -> tuple[Any, str]:  # noqa: PLR0911 (Too many return statements)
+    """Get the appropriate dataframe constructor and library name based on preference."""
+    if preference not in _DATAFRAME_LIBRARY_MAP:
+        msg = f"Unsupported dataframe preference: {preference}"
+        raise ValueError(msg)
+
+    library_name, _ = _DATAFRAME_LIBRARY_MAP[preference]
+
+    try:
+        if preference == ModelPreference.POLARS:
+            import polars as pl  # noqa: PLC0415
+
+            return pl.DataFrame, library_name
+        if preference == ModelPreference.PANDAS:
+            import pandas as pd  # noqa: PLC0415
+
+            return pd.DataFrame, library_name
+        if preference == ModelPreference.PYARROW:
+            import pyarrow as pa  # noqa: PLC0415
+
+            return pa.Table.from_pylist, library_name
+        if preference == ModelPreference.DASK:
+            import dask.dataframe as dd  # noqa: PLC0415
+            import pandas as pd  # noqa: PLC0415
+
+            return lambda data, **_: dd.from_pandas(pd.DataFrame(data), npartitions=1), library_name
+        if preference == ModelPreference.MODIN:
+            import modin.pandas as mpd  # noqa: PLC0415
+
+            return mpd.DataFrame, library_name
+        if preference == ModelPreference.CUDF:
+            import cudf  # noqa: PLC0415
+
+            return cudf.DataFrame, library_name
+        import ibis  # noqa: PLC0415
+
+        return lambda data, **_: ibis.memtable(data), library_name
+    except ImportError as e:  # pragma: no cover - import failure is environment dependent
+        msg = f"{library_name} is not installed. Install with appropriate package manager."
+        raise ImportError(msg) from e
+
+
+def _create_dataframe_with_constructor(  # noqa: C901 (is too complex)
+    constructor: Any, library_name: str, df_data: list | dict, empty_schema: dict | None
+) -> Any:
+    """Create DataFrame with data using the appropriate constructor."""
+
+    # Helper function to check if data is array-like and schema exists
+    def _is_array_data_with_schema() -> bool:
+        return bool(empty_schema and isinstance(df_data, list) and df_data and isinstance(df_data[0], (list, tuple)))
+
+    if library_name == "polars":
+        # Handle special case for array data (like candles) with schema
+        if _is_array_data_with_schema() and empty_schema:
+            # Transform array data into named columns based on schema
+            column_names = list(empty_schema.keys())
+            if len(df_data[0]) == len(column_names):  # type: ignore[index]
+                # Create DataFrame with explicit column names
+                import polars as pl  # noqa: PLC0415
+
+                df = pl.DataFrame(df_data, schema=column_names, orient="row")
+                df = _apply_polars_schema(df, empty_schema)
+                return df
+
+        df = constructor(df_data, strict=False)
+        if empty_schema:
+            df = _apply_polars_schema(df, empty_schema)
+        return df
+
+    if library_name in ("pandas", "modin", "cudf"):
+        # Handle special case for array data (like candles) with schema
+        if _is_array_data_with_schema() and empty_schema:
+            # Transform array data into named columns based on schema
+            column_names = list(empty_schema.keys())
+            if len(df_data[0]) == len(column_names):  # type: ignore[index]
+                # Create DataFrame with explicit column names
+                df = constructor(df_data, columns=column_names)
+                if empty_schema:
+                    df = _apply_pandas_like_schema(df, empty_schema)
+                return df
+
+        df = constructor(df_data)
+        if empty_schema:
+            df = _apply_pandas_like_schema(df, empty_schema)
+        return df
+
+    if library_name in ("pyarrow", "dask"):
+        return constructor(df_data)
+
+    return constructor(df_data)
+
+
+def _create_empty_dataframe(constructor: Any, library_name: str, empty_schema: dict | None) -> Any:
+    """Create empty DataFrame using the appropriate constructor."""
+    if empty_schema is None:
+        empty_schema = {"id": str} if library_name != "polars" else {"id": "pl.String"}
+
+    if library_name == "polars":
+        import polars as pl  # noqa: PLC0415
+
+        schema = {k: pl.String if v == "pl.String" else v for k, v in empty_schema.items()}
+        return constructor([], schema=schema)
+    if library_name in ("pandas", "modin", "cudf", "dask") or library_name == "pyarrow":
+        return constructor([])
+    return constructor([dict.fromkeys(empty_schema.keys())])
+
+
+def _apply_polars_schema(df: Any, schema: dict) -> Any:
+    """Apply schema to polars DataFrame."""
+    import polars as pl  # noqa: PLC0415
+
+    for col, expected_dtype in schema.items():
+        if col in df.columns:
+            with contextlib.suppress(Exception):
+                df = df.with_columns(pl.col(col).cast(expected_dtype))
+    return df
+
+
+def _apply_pandas_like_schema(df: Any, schema: dict) -> Any:
+    """Apply schema to pandas-like DataFrame."""
+    pandas_schema = {}
+    for col, dtype in schema.items():
+        if col in df.columns:
+            if "String" in str(dtype) or "Utf8" in str(dtype):
+                pandas_schema[col] = "string"
+            elif "Int" in str(dtype):
+                pandas_schema[col] = "int64"
+            elif "Float" in str(dtype):
+                pandas_schema[col] = "float64"
+
+    if pandas_schema and hasattr(df, "astype"):
+        with contextlib.suppress(Exception):
+            df = df.astype(pandas_schema)
+    return df
+
+
+def _create_dataframe_from_data(
+    data: Any, preference: ModelPreference, *, items_key: str | None = None, empty_schema: dict[str, Any] | None = None
+) -> Result[Any, BitvavoError]:
+    """Create a DataFrame from API response data using the specified preference."""
+    try:
+        df_data = _extract_dataframe_data(data, items_key=items_key)
+        constructor, library_name = _get_dataframe_constructor(preference)
+
+        if df_data:
+            df = _create_dataframe_with_constructor(constructor, library_name, df_data, empty_schema)
+            return Success(df)  # type: ignore[return-value]
+
+        df = _create_empty_dataframe(constructor, library_name, empty_schema)
+        return Success(df)  # type: ignore[return-value]
+
+    except (ValueError, TypeError, ImportError) as exc:
+        error = BitvavoError(
+            http_status=500,
+            error_code=-1,
+            reason="DataFrame creation failed",
+            message=f"Failed to create DataFrame from API response: {exc}",
+            raw={"data_type": type(data).__name__, "data_sample": str(data)[:200]},
+        )
+        return Failure(error)
+
+
+class BaseAPI:
+    """Base class for API endpoint handlers providing model conversion utilities."""
+
+    _endpoint_models: Mapping[str, Any] = {}
+    _default_schemas: Mapping[str, object] = {}
+
+    def __init__(
+        self,
+        http_client: Any,
+        *,
+        preferred_model: ModelPreference | str | None = None,
+        default_schema: Mapping[str, object] | None = None,
+    ) -> None:
+        self.http = http_client
+
+        if preferred_model is None:
+            self.preferred_model = None
+        elif isinstance(preferred_model, ModelPreference):
+            self.preferred_model = preferred_model
+        elif isinstance(preferred_model, str):
+            try:
+                self.preferred_model = ModelPreference(preferred_model)
+            except ValueError:
+                self.preferred_model = preferred_model
+        else:
+            self.preferred_model = preferred_model
+
+        self.default_schema = default_schema
+
+    def _get_effective_model(
+        self,
+        endpoint_type: str,
+        model: type[T] | Any | None,
+        schema: Mapping[str, object] | None,
+    ) -> tuple[type[T] | Any | None, Mapping[str, object] | None]:
+        if model is not None:
+            return model, schema
+
+        if self.preferred_model is None or self.preferred_model == ModelPreference.RAW:
+            return Any, schema
+
+        if isinstance(self.preferred_model, ModelPreference) and self.preferred_model in _DATAFRAME_LIBRARY_MAP:
+            effective_schema = schema or self.default_schema or self._default_schemas.get(endpoint_type)
+            if effective_schema is not None and not isinstance(effective_schema, dict):
+                effective_schema = dict(effective_schema)
+            return self.preferred_model, effective_schema
+
+        if self.preferred_model == ModelPreference.PYDANTIC:
+            model_cls = self._endpoint_models.get(endpoint_type, dict)
+            return model_cls, schema
+
+        return None, schema
+
+    def _convert_raw_result(
+        self,
+        raw_result: Result[Any, BitvavoError | Any],
+        endpoint_type: str,
+        model: type[T] | Any | None,
+        schema: Mapping[str, object] | None,
+        *,
+        items_key: str | None = None,
+    ) -> Result[Any, BitvavoError | Any]:
+        if isinstance(raw_result, Failure):
+            return raw_result
+
+        effective_model, effective_schema = self._get_effective_model(endpoint_type, model, schema)
+
+        if effective_model is Any or effective_model is None:
+            return raw_result
+
+        raw_data = raw_result.unwrap()
+
+        if isinstance(effective_model, ModelPreference) and effective_model in _DATAFRAME_LIBRARY_MAP:
+            return _create_dataframe_from_data(
+                raw_data,
+                effective_model,
+                items_key=items_key,
+                empty_schema=effective_schema,  # type: ignore[arg-type]
+            )
+
+        try:
+            if hasattr(effective_model, "model_validate"):
+                parsed = effective_model.model_validate(raw_data)  # type: ignore[misc]
+            elif effective_schema is None:
+                parsed = effective_model(raw_data)  # type: ignore[misc]
+            else:
+                parsed = effective_model(raw_data, schema=effective_schema)  # type: ignore[misc]
+            return Success(parsed)
+        except (ValueError, TypeError, AttributeError) as exc:
+            error = BitvavoError(
+                http_status=500,
+                error_code=-1,
+                reason="Model conversion failed",
+                message=str(exc),
+                raw=raw_data if isinstance(raw_data, dict) else {"raw": raw_data},
+            )
+            return Failure(error)

bitvavo_client/endpoints/private.py

@@ -2,8 +2,7 @@
 
 from __future__ import annotations
 
-import contextlib
-from typing import TYPE_CHECKING, Any, TypeVar
+from typing import TYPE_CHECKING, Any, ClassVar, TypeVar
 
 import httpx
 from returns.result import Failure, Result, Success
@@ -11,6 +10,11 @@ from returns.result import Failure, Result, Success
 from bitvavo_client.adapters.returns_adapter import BitvavoError
 from bitvavo_client.core import private_models
 from bitvavo_client.core.model_preferences import ModelPreference
+from bitvavo_client.endpoints.base import (
+    _DATAFRAME_LIBRARY_MAP,
+    BaseAPI,
+    _create_dataframe_from_data,
+)
 from bitvavo_client.endpoints.common import create_postfix, default
 from bitvavo_client.schemas.private_schemas import DEFAULT_SCHEMAS
 
@@ -21,209 +25,26 @@ if TYPE_CHECKING:  # pragma: no cover
 T = TypeVar("T")
 
 
-def _extract_dataframe_data(data: Any, *, items_key: str | None = None) -> list[dict] | dict:
-    """Extract the meaningful data for DataFrame creation from API responses.
-
-    Args:
-        data: Raw API response data
-        items_key: Key to extract from nested response (e.g., 'items' for paginated responses)
-
-    Returns:
-        List of dicts or single dict suitable for DataFrame creation
-
-    Raises:
-        ValueError: If data format is unexpected
-    """
-    if items_key and isinstance(data, dict) and items_key in data:
-        # Extract nested items (e.g., transaction_history['items'])
-        items = data[items_key]
-        if not isinstance(items, list):
-            msg = f"Expected {items_key} to be a list, got {type(items)}"
-            raise ValueError(msg)
-        return items
-    if isinstance(data, list):
-        # Direct list response (e.g., balance, trades)
-        return data
-    if isinstance(data, dict):
-        # Single dict response - wrap in list for DataFrame
-        return [data]
-
-    msg = f"Unexpected data type for DataFrame creation: {type(data)}"
-    raise ValueError(msg)
-
-
-# DataFrames preference to library mapping
-_DATAFRAME_LIBRARY_MAP = {
-    ModelPreference.POLARS: ("polars", "pl.DataFrame"),
-    ModelPreference.PANDAS: ("pandas", "pd.DataFrame"),
-    ModelPreference.PYARROW: ("pyarrow", "pa.Table"),
-    ModelPreference.DASK: ("dask", "dd.DataFrame"),
-    ModelPreference.MODIN: ("modin", "mpd.DataFrame"),
-    ModelPreference.CUDF: ("cudf", "cudf.DataFrame"),
-    ModelPreference.IBIS: ("ibis", "ibis.Table"),
-}
-
-
-def _get_dataframe_constructor(preference: ModelPreference) -> tuple[Any, str]:
-    """Get the appropriate dataframe constructor and library name based on preference.
-
-    Args:
-        preference: ModelPreference enum value
-
-    Returns:
-        Tuple of (constructor_class, library_name)
-
-    Raises:
-        ImportError: If required library is not available
-        ValueError: If preference is not a supported dataframe type
-    """
-    if preference not in _DATAFRAME_LIBRARY_MAP:
-        msg = f"Unsupported dataframe preference: {preference}"
-        raise ValueError(msg)
-
-    library_name, _ = _DATAFRAME_LIBRARY_MAP[preference]
-
-    try:
-        if preference == ModelPreference.POLARS:
-            import polars as pl  # noqa: PLC0415
-
-            return pl.DataFrame, library_name
-        if preference == ModelPreference.PANDAS:
-            import pandas as pd  # noqa: PLC0415
-
-            return pd.DataFrame, library_name
-        if preference == ModelPreference.PYARROW:
-            import pyarrow as pa  # noqa: PLC0415
-
-            return pa.Table.from_pylist, library_name
-        if preference == ModelPreference.DASK:
-            import dask.dataframe as dd  # noqa: PLC0415
-            import pandas as pd  # noqa: PLC0415
-
-            return lambda data, **kwargs: dd.from_pandas(pd.DataFrame(data), npartitions=1), library_name
-        if preference == ModelPreference.MODIN:
-            import modin.pandas as mpd  # noqa: PLC0415
-
-            return mpd.DataFrame, library_name
-        if preference == ModelPreference.CUDF:
-            import cudf  # noqa: PLC0415
-
-            return cudf.DataFrame, library_name
-        # ModelPreference.IBIS
-        import ibis  # noqa: PLC0415
-
-        return lambda data, **kwargs: ibis.memtable(data), library_name
-    except ImportError as e:
-        msg = f"{library_name} is not installed. Install with appropriate package manager."
-        raise ImportError(msg) from e
-
-
-def _create_dataframe_from_data(
-    data: Any, preference: ModelPreference, *, items_key: str | None = None, empty_schema: dict[str, Any] | None = None
-) -> Result[Any, BitvavoError]:
-    """Create a DataFrame from API response data using the specified preference.
-
-    Args:
-        data: Raw API response data
-        preference: ModelPreference enum value indicating which library to use
-        items_key: Key to extract from nested response (optional)
-        empty_schema: Schema to use for empty DataFrames and type casting
-
-    Returns:
-        Result containing DataFrame or error
-    """
-    try:
-        df_data = _extract_dataframe_data(data, items_key=items_key)
-        constructor, library_name = _get_dataframe_constructor(preference)
-
-        if df_data:
-            # Create DataFrame using appropriate constructor
-            df = _create_dataframe_with_constructor(constructor, library_name, df_data, empty_schema)
-            return Success(df)  # type: ignore[return-value]
-
-        # Create empty DataFrame
-        df = _create_empty_dataframe(constructor, library_name, empty_schema)
-        return Success(df)  # type: ignore[return-value]
-
-    except (ValueError, TypeError, ImportError) as exc:
-        error = BitvavoError(
-            http_status=500,
-            error_code=-1,
-            reason="DataFrame creation failed",
-            message=f"Failed to create DataFrame from API response: {exc}",
-            raw={"data_type": type(data).__name__, "data_sample": str(data)[:200]},
-        )
-        return Failure(error)
-
-
-def _create_dataframe_with_constructor(
-    constructor: Any, library_name: str, df_data: list | dict, empty_schema: dict | None
-) -> Any:
-    """Create DataFrame with data using the appropriate constructor."""
-    if library_name == "polars":
-        df = constructor(df_data, strict=False)
-        if empty_schema:
-            df = _apply_polars_schema(df, empty_schema)
-        return df
-    if library_name in ("pandas", "modin", "cudf"):
-        df = constructor(df_data)
-        if empty_schema:
-            df = _apply_pandas_like_schema(df, empty_schema)
-        return df
-    if library_name == "pyarrow" or library_name == "dask":
-        return constructor(df_data)
-    # ibis
-    return constructor(df_data)
-
-
-def _create_empty_dataframe(constructor: Any, library_name: str, empty_schema: dict | None) -> Any:
-    """Create empty DataFrame using the appropriate constructor."""
-    if empty_schema is None:
-        empty_schema = {"id": str} if library_name != "polars" else {"id": "pl.String"}
-
-    if library_name == "polars":
-        import polars as pl  # noqa: PLC0415
-
-        schema = {k: pl.String if v == "pl.String" else v for k, v in empty_schema.items()}
-        return constructor([], schema=schema)
-    if library_name in ("pandas", "modin", "cudf", "dask") or library_name == "pyarrow":
-        return constructor([])
-    # ibis
-    return constructor([dict.fromkeys(empty_schema.keys())])
-
-
-def _apply_polars_schema(df: Any, schema: dict) -> Any:
-    """Apply schema to polars DataFrame."""
-    import polars as pl  # noqa: PLC0415
-
-    for col, expected_dtype in schema.items():
-        if col in df.columns:
-            with contextlib.suppress(Exception):
-                df = df.with_columns(pl.col(col).cast(expected_dtype))
-    return df
-
-
-def _apply_pandas_like_schema(df: Any, schema: dict) -> Any:
-    """Apply schema to pandas-like DataFrame."""
-    pandas_schema = {}
-    for col, dtype in schema.items():
-        if col in df.columns:
-            if "String" in str(dtype) or "Utf8" in str(dtype):
-                pandas_schema[col] = "string"
-            elif "Int" in str(dtype):
-                pandas_schema[col] = "int64"
-            elif "Float" in str(dtype):
-                pandas_schema[col] = "float64"
-
-    if pandas_schema and hasattr(df, "astype"):
-        with contextlib.suppress(Exception):
-            df = df.astype(pandas_schema)
-    return df
-
-
-class PrivateAPI:
+class PrivateAPI(BaseAPI):
     """Handles all private Bitvavo API endpoints requiring authentication."""
 
+    _endpoint_models: ClassVar[dict[str, Any]] = {
+        "account": private_models.Account,
+        "balance": private_models.Balances,
+        "orders": private_models.Orders,
+        "order": private_models.Order,
+        "trade_history": private_models.Trades,
+        "transaction_history": private_models.TransactionHistory,
+        "fees": private_models.Fees,
+        "deposit_history": private_models.DepositHistories,
+        "deposit": private_models.Deposit,
+        "withdrawals": private_models.Withdrawals,
+        "withdraw": private_models.WithdrawResponse,
+        "cancel_order": private_models.CancelOrderResponse,
+    }
+
+    _default_schemas = DEFAULT_SCHEMAS
+
     def __init__(
         self,
         http_client: HTTPClient,
@@ -231,166 +52,8 @@ class PrivateAPI:
         preferred_model: ModelPreference | str | None = None,
         default_schema: dict | None = None,
     ) -> None:
-        """Initialize private API handler.
-
-        Args:
-            http_client: HTTP client for making requests
-            preferred_model: Preferred model format for responses
-            default_schema: Default schema for DataFrame conversion
-        """
-        self.http: HTTPClient = http_client
-
-        # Handle preferred_model parameter - try to convert strings to ModelPreference,
-        # but allow arbitrary strings to pass through for custom handling
-        if preferred_model is None:
-            self.preferred_model = None
-        elif isinstance(preferred_model, ModelPreference):
-            self.preferred_model = preferred_model
-        elif isinstance(preferred_model, str):
-            try:
-                self.preferred_model = ModelPreference(preferred_model)
-            except ValueError:
-                # If string doesn't match a valid ModelPreference, store as-is
-                self.preferred_model = preferred_model
-        else:
-            self.preferred_model = preferred_model
-
-        self.default_schema = default_schema
-
-    def _get_effective_model(
-        self,
-        endpoint_type: str,
-        model: type[T] | Any | None,
-        schema: dict | None,
-    ) -> tuple[type[T] | Any | None, dict | None]:
-        """Get the effective model and schema to use for a request.
-
-        Args:
-            endpoint_type: Type of endpoint (e.g., 'account', 'balance', 'orders')
-            model: Model explicitly passed to method (overrides preference)
-            schema: Schema explicitly passed to method
-
-        Returns:
-            Tuple of (effective_model, effective_schema)
-
-        Raises:
-            ValueError: If endpoint_type is not recognized
-        """
-        # If model is explicitly provided, use it
-        if model is not None:
-            return model, schema
-
-        # If no preferred model is set, return None (raw response)
-        if self.preferred_model is None:
-            return None, schema
-
-        # Apply preference based on enum value
-        if self.preferred_model == ModelPreference.RAW:
-            return Any, schema
-
-        # Handle all DataFrame preferences
-        if self.preferred_model in _DATAFRAME_LIBRARY_MAP:
-            # Validate endpoint type
-            if endpoint_type not in list(DEFAULT_SCHEMAS.keys()):
-                msg = f"Invalid endpoint_type '{endpoint_type}'. Valid types: {sorted(DEFAULT_SCHEMAS)}"
-                raise ValueError(msg)
-            # Use the provided schema, fallback to instance default, then to endpoint-specific default
-            effective_schema = schema or self.default_schema or DEFAULT_SCHEMAS.get(endpoint_type)
-            # Convert to dict if it's a Mapping but not already a dict
-            if effective_schema is not None and not isinstance(effective_schema, dict):
-                effective_schema = dict(effective_schema)
-            # Return the preference itself, not a specific DataFrame class
-            return self.preferred_model, effective_schema
-
-        if self.preferred_model == ModelPreference.PYDANTIC:
-            # Map endpoint types to appropriate Pydantic models
-            endpoint_model_map = {
-                "account": private_models.Account,
-                "balance": private_models.Balances,
-                "orders": private_models.Orders,
-                "order": private_models.Order,
-                "trade_history": private_models.Trades,
-                "transaction_history": private_models.TransactionHistory,
-                "fees": private_models.Fees,
-                "deposit_history": private_models.DepositHistories,
-                "deposit": private_models.Deposit,
-                "withdrawals": private_models.Withdrawals,
-                "withdraw": private_models.WithdrawResponse,
-                "cancel_order": private_models.CancelOrderResponse,
-            }
-            if endpoint_type not in endpoint_model_map:
-                msg = f"No Pydantic model defined for endpoint_type '{endpoint_type}'. Add it to endpoint_model_map."
-                raise ValueError(msg)
-            return endpoint_model_map[endpoint_type], schema
-
-        # Default case (AUTO or unknown)
-        return None, schema
-
-    def _convert_raw_result(
-        self,
-        raw_result: Result[Any, BitvavoError | httpx.HTTPError],
-        endpoint_type: str,
-        model: type[T] | Any | None,
-        schema: dict | None,
-        *,
-        items_key: str | None = None,
-    ) -> Result[Any, BitvavoError | httpx.HTTPError]:
-        """Convert raw API result to the desired model format.
-
-        Args:
-            raw_result: Raw result from HTTP client
-            endpoint_type: Type of endpoint (e.g., 'account', 'balance', 'orders')
-            model: Model explicitly passed to method (overrides preference)
-            schema: Schema explicitly passed to method
-            items_key: Key to extract from nested response for DataFrames
-
-        Returns:
-            Result with converted data or original error
-        """
-        # If the raw result is an error, return it as-is
-        if isinstance(raw_result, Failure):
-            return raw_result
-
-        # Get the effective model and schema to use
-        effective_model, effective_schema = self._get_effective_model(endpoint_type, model, schema)
-
-        # If no conversion needed (raw data requested), return as-is
-        if effective_model is Any or effective_model is None:
-            return raw_result
-
-        # Extract the raw data
-        raw_data = raw_result.unwrap()
-
-        # Handle DataFrames specially
-        if effective_model in _DATAFRAME_LIBRARY_MAP and isinstance(effective_model, ModelPreference):
-            return _create_dataframe_from_data(
-                raw_data, effective_model, items_key=items_key, empty_schema=effective_schema
-            )
-
-        # Handle other model types using the same logic as PublicAPI
-        try:
-            # Handle different model types
-            if hasattr(effective_model, "model_validate"):
-                # Pydantic model
-                parsed = effective_model.model_validate(raw_data)  # type: ignore[misc]
-            elif effective_schema is None:
-                # Simple constructor call - this handles dict and other simple types
-                parsed = effective_model(raw_data)  # type: ignore[misc]
-            else:
-                # Other models with schema
-                parsed = effective_model(raw_data, schema=effective_schema)  # type: ignore[misc]
-
-            return Success(parsed)
-        except (ValueError, TypeError, AttributeError) as exc:
-            # If conversion fails, return a structured error
-            error = BitvavoError(
-                http_status=500,
-                error_code=-1,
-                reason="Model conversion failed",
-                message=str(exc),
-                raw=raw_data if isinstance(raw_data, dict) else {"raw": raw_data},
-            )
-            return Failure(error)
+        """Initialize private API handler."""
+        super().__init__(http_client, preferred_model=preferred_model, default_schema=default_schema)
 
     def account(
         self,
@@ -1225,8 +888,8 @@ class PrivateAPI:
         Returns:
             Result containing withdrawal result or error
         """
-        effective_model, effective_schema = self._get_effective_model("withdraw", model, schema)
         body = {"symbol": symbol, "amount": amount, "address": address}
         if options:
             body.update(options)
-        return self.http.request("POST", "/withdrawal", body=body, weight=1)
+        raw_result = self.http.request("POST", "/withdrawal", body=body, weight=1)
+        return self._convert_raw_result(raw_result, "withdraw", model, schema)

bitvavo_client/endpoints/public.py

@@ -2,13 +2,10 @@
 
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Any, Literal, TypeVar
+from typing import TYPE_CHECKING, Any, ClassVar, Literal, TypeVar
 
-from returns.result import Failure, Success
-
-from bitvavo_client.adapters.returns_adapter import BitvavoError
 from bitvavo_client.core import public_models
-from bitvavo_client.core.model_preferences import ModelPreference
+from bitvavo_client.endpoints.base import BaseAPI
 from bitvavo_client.endpoints.common import create_postfix
 from bitvavo_client.schemas.public_schemas import DEFAULT_SCHEMAS
 
@@ -24,32 +21,39 @@ MAX_TIMESTAMP_VALUE = 8640000000000000  # Maximum allowed timestamp value
 MAX_BOOK_DEPTH = 1000  # Maximum depth for order book
 MAX_BOOK_REPORT_DEPTH = 1000  # Maximum depth for order book report
 
-# DataFrames preference to library mapping
-_DATAFRAME_LIBRARY_MAP = {
-    ModelPreference.POLARS: ("polars", "pl.DataFrame"),
-    ModelPreference.PANDAS: ("pandas", "pd.DataFrame"),
-    ModelPreference.PYARROW: ("pyarrow", "pa.Table"),
-    ModelPreference.DASK: ("dask", "dd.DataFrame"),
-    ModelPreference.MODIN: ("modin", "mpd.DataFrame"),
-    ModelPreference.CUDF: ("cudf", "cudf.DataFrame"),
-    ModelPreference.IBIS: ("ibis", "ibis.Table"),
-}
-
 if TYPE_CHECKING:  # pragma: no cover
     from collections.abc import Mapping
 
     import httpx
     from returns.result import Result
 
+    from bitvavo_client.adapters.returns_adapter import BitvavoError
+    from bitvavo_client.core.model_preferences import ModelPreference
     from bitvavo_client.core.types import AnyDict
     from bitvavo_client.transport.http import HTTPClient
 
 T = TypeVar("T")
 
 
-class PublicAPI:
+class PublicAPI(BaseAPI):
     """Handles all public Bitvavo API endpoints."""
 
+    _endpoint_models: ClassVar[dict[str, type[Any]]] = {
+        "time": public_models.ServerTime,
+        "markets": public_models.Markets,
+        "assets": public_models.Assets,
+        "book": public_models.OrderBook,
+        "trades": public_models.Trades,
+        "candles": public_models.Candles,
+        "ticker_price": public_models.TickerPrices,
+        "ticker_book": public_models.TickerBooks,
+        "ticker_24h": public_models.Ticker24hs,
+        "report_book": public_models.OrderBookReport,
+        "report_trades": public_models.TradesReport,
+    }
+
+    _default_schemas = DEFAULT_SCHEMAS
+
     def __init__(
         self,
         http_client: HTTPClient,
@@ -57,209 +61,8 @@ class PublicAPI:
         preferred_model: ModelPreference | str | None = None,
         default_schema: Mapping[str, object] | None = None,
     ) -> None:
-        """Initialize public API handler.
-
-        Args:
-            http_client: HTTP client for making requests
-            preferred_model: Preferred model format for responses
-            default_schema: Default schema for DataFrame conversion
-        """
-        self.http: HTTPClient = http_client
-
-        # Handle preferred_model parameter - try to convert strings to ModelPreference,
-        # but allow arbitrary strings to pass through for custom handling
-        if preferred_model is None:
-            self.preferred_model = None
-        elif isinstance(preferred_model, ModelPreference):
-            self.preferred_model = preferred_model
-        elif isinstance(preferred_model, str):
-            try:
-                self.preferred_model = ModelPreference(preferred_model)
-            except ValueError:
-                # If string doesn't match a valid ModelPreference, store as-is
-                self.preferred_model = preferred_model
-        else:
-            self.preferred_model = preferred_model
-
-        # If using DATAFRAME preference without a default schema, we could provide sensible defaults
-        # But keep it explicit for now - users can import and use schemas as needed
-        self.default_schema = default_schema
-
-    def _get_effective_model(
-        self,
-        endpoint_type: str,
-        model: type[T] | Any | None,
-        schema: Mapping[str, object] | None,
-    ) -> tuple[type[T] | Any | None, Mapping[str, object] | None]:
-        """Get the effective model and schema to use for a request.
-
-        Args:
-            endpoint_type: Type of endpoint (e.g., 'time', 'markets', 'assets')
-            model: Model explicitly passed to method (overrides preference)
-            schema: Schema explicitly passed to method
-
-        Returns:
-            Tuple of (effective_model, effective_schema)
-        """
-        # If model is explicitly provided, use it
-        if model is not None:
-            return model, schema
-
-        # If no preferred model is set, return Any (raw response)
-        if self.preferred_model is None:
-            return Any, schema
-
-        # Apply preference based on enum value
-        if self.preferred_model == ModelPreference.RAW:
-            return Any, schema
-
-        # Handle all DataFrame preferences
-        if self.preferred_model in _DATAFRAME_LIBRARY_MAP:
-            # Use the provided schema, fallback to instance default, then to endpoint-specific default
-            effective_schema = schema or self.default_schema or DEFAULT_SCHEMAS.get(endpoint_type)
-            # Return the preference itself, not a specific DataFrame class
-            return self.preferred_model, effective_schema
-
-        if self.preferred_model == ModelPreference.PYDANTIC:
-            # Map endpoint types to appropriate Pydantic models
-            endpoint_model_map = {
-                "time": public_models.ServerTime,
-                "markets": public_models.Markets,
-                "assets": public_models.Assets,
-                "book": public_models.OrderBook,
-                "trades": public_models.Trades,
-                "candles": public_models.Candles,
-                "ticker_price": public_models.TickerPrices,
-                "ticker_book": public_models.TickerBooks,
-                "ticker_24h": public_models.Ticker24hs,
-                "report_book": public_models.OrderBookReport,
-                "report_trades": public_models.TradesReport,
-            }
-            return endpoint_model_map.get(endpoint_type, dict), schema
-
-        # Default case (AUTO or unknown)
-        return None, schema
-
-    def _convert_raw_result(
-        self,
-        raw_result: Result[Any, BitvavoError | httpx.HTTPError],
-        endpoint_type: str,
-        model: type[T] | Any | None,
-        schema: Mapping[str, object] | None,
-    ) -> Result[Any, BitvavoError | httpx.HTTPError]:
-        """Convert raw API result to the desired model format.
-
-        Args:
-            raw_result: Raw result from HTTP client
-            endpoint_type: Type of endpoint (e.g., 'time', 'markets', 'assets')
-            model: Model explicitly passed to method (overrides preference)
-            schema: Schema explicitly passed to method
-
-        Returns:
-            Result with converted data or original error
-        """
-        # If the raw result is an error, return it as-is
-        if isinstance(raw_result, Failure):
-            return raw_result
-
-        # Get the effective model and schema to use
-        effective_model, effective_schema = self._get_effective_model(endpoint_type, model, schema)
-
-        # If no conversion needed (raw data requested), return as-is
-        if effective_model is Any or effective_model is None or effective_model == ModelPreference.RAW:
-            return raw_result
-
-        # Extract the raw data
-        raw_data = raw_result.unwrap()
-
-        # Perform conversion
-        try:
-            # Handle DataFrame preferences specially
-            if isinstance(effective_model, ModelPreference) and effective_model in _DATAFRAME_LIBRARY_MAP:
-                parsed = self._create_dataframe(raw_data, effective_model, effective_schema)
-            elif hasattr(effective_model, "model_validate"):
-                # Pydantic model
-                parsed = effective_model.model_validate(raw_data)  # type: ignore[misc]
-            else:
-                # Simple constructor call - this handles dict and other simple types
-                parsed = effective_model(raw_data)  # type: ignore[misc]
-
-            return Success(parsed)
-        except (ValueError, TypeError, AttributeError) as exc:
-            # If conversion fails, return a structured error
-            error = BitvavoError(
-                http_status=500,
-                error_code=-1,
-                reason="Model conversion failed",
-                message=str(exc),
-                raw=raw_data if isinstance(raw_data, dict) else {"raw": raw_data},
-            )
-            return Failure(error)
-
-    def _create_dataframe(
-        self,
-        data: Any,
-        preference: ModelPreference,
-        schema: Mapping[str, object] | None,
-    ) -> Any:
-        """Create a DataFrame from raw data using the specified preference.
-
-        Args:
-            data: Raw data to convert
-            preference: DataFrame preference (POLARS, PANDAS, etc.)
-            schema: Schema for DataFrame conversion
-
-        Returns:
-            DataFrame instance
-
-        Raises:
-            ImportError: If the required DataFrame library is not available
-            ValueError: If DataFrame creation fails
-        """
-        if preference == ModelPreference.POLARS:
-            import polars as pl
-
-            return self._create_polars_dataframe(data, schema, pl)
-
-        if preference == ModelPreference.PANDAS:
-            import pandas as pd
-
-            return pd.DataFrame(data)
-
-        if preference == ModelPreference.PYARROW:
-            import pyarrow as pa
-
-            return pa.Table.from_pylist(data if isinstance(data, list) else [data])
-
-        # For other DataFrame types, try basic conversion
-        msg = f"DataFrame preference {preference} not yet fully implemented"
-        raise NotImplementedError(msg)
-
-    def _create_polars_dataframe(
-        self,
-        data: Any,
-        schema: Mapping[str, object] | None,
-        pl: Any,  # polars module
-    ) -> Any:
-        """Create a Polars DataFrame with proper schema handling.
-
-        Args:
-            data: Raw data to convert
-            schema: Schema for DataFrame conversion
-            pl: Polars module
-
-        Returns:
-            Polars DataFrame
-        """
-        if schema is None:
-            return pl.DataFrame(data)
-
-        # For Polars, we need to handle the schema with strict=False for compatibility
-        try:
-            return pl.DataFrame(data, schema=schema, strict=False)
-        except Exception:
-            # Fallback to basic DataFrame creation if schema fails
-            return pl.DataFrame(data)
+        """Initialize public API handler."""
+        super().__init__(http_client, preferred_model=preferred_model, default_schema=default_schema)
 
     def time(
         self,

bitvavo_client/facade.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import time
 from typing import TYPE_CHECKING, TypeVar
 
 from bitvavo_client.auth.rate_limit import RateLimitManager
@@ -50,17 +51,67 @@ class BitvavoClient:
         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:
-            # Single API key configuration
-            self.http.configure_key(self.settings.api_key, self.settings.api_secret, 0)
-            self.rate_limiter.ensure_key(0)
-        elif self.settings.api_keys:
-            # Multiple API keys - configure the first one by default
-            if self.settings.api_keys:
-                first_key = self.settings.api_keys[0]
-                self.http.configure_key(first_key["key"], first_key["secret"], 0)
-                self.rate_limiter.ensure_key(0)
+            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_client/transport/http.py

@@ -15,6 +15,8 @@ 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
@@ -35,6 +37,7 @@ class HTTPClient:
         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.
@@ -48,6 +51,10 @@ 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 request(
         self,
         method: str,
@@ -72,7 +79,11 @@ class HTTPClient:
         """
         # Check rate limits
         if not self.rate_limiter.has_budget(self.key_index, weight):
-            self.rate_limiter.sleep_until_reset(self.key_index)
+            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)