bitvavo-api-upgraded 4.1.0__py3-none-any.whl → 4.1.1__py3-none-any.whl

bitvavo_client/facade.py

@@ -0,0 +1,66 @@
+"""Main facade for the Bitvavo client."""
+
+from __future__ import annotations
+
+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._configure_api_keys()
+
+    def _configure_api_keys(self) -> None:
+        """Configure API keys for authentication."""
+        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)

bitvavo_client/schemas/__init__.py

@@ -0,0 +1,50 @@
+"""Schema definitions for bitvavo_client."""
+
+from bitvavo_client.schemas import private_schemas, public_schemas
+from bitvavo_client.schemas.private_schemas import (
+    BALANCE_SCHEMA,
+    DEPOSIT_HISTORY_SCHEMA,
+    DEPOSIT_SCHEMA,
+    FEES_SCHEMA,
+    ORDER_SCHEMA,
+    ORDERS_SCHEMA,
+    WITHDRAWAL_SCHEMA,
+    WITHDRAWALS_SCHEMA,
+)
+from bitvavo_client.schemas.public_schemas import (
+    ASSETS_SCHEMA,
+    BOOK_SCHEMA,
+    CANDLES_SCHEMA,
+    COMBINED_DEFAULT_SCHEMA,
+    DEFAULT_SCHEMAS,
+    MARKETS_SCHEMA,
+    TICKER_24H_SCHEMA,
+    TICKER_BOOK_SCHEMA,
+    TICKER_PRICE_SCHEMA,
+    TIME_SCHEMA,
+    TRADES_SCHEMA,
+)
+
+__all__ = [
+    "ASSETS_SCHEMA",
+    "BALANCE_SCHEMA",
+    "BOOK_SCHEMA",
+    "CANDLES_SCHEMA",
+    "COMBINED_DEFAULT_SCHEMA",
+    "DEFAULT_SCHEMAS",
+    "DEPOSIT_HISTORY_SCHEMA",
+    "DEPOSIT_SCHEMA",
+    "FEES_SCHEMA",
+    "MARKETS_SCHEMA",
+    "ORDERS_SCHEMA",
+    "ORDER_SCHEMA",
+    "TICKER_24H_SCHEMA",
+    "TICKER_BOOK_SCHEMA",
+    "TICKER_PRICE_SCHEMA",
+    "TIME_SCHEMA",
+    "TRADES_SCHEMA",
+    "WITHDRAWALS_SCHEMA",
+    "WITHDRAWAL_SCHEMA",
+    "private_schemas",
+    "public_schemas",
+]

bitvavo_client/schemas/private_schemas.py

@@ -0,0 +1,191 @@
+"""Polars DataFrame schemas for private API endpoints."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+import polars as pl
+
+if TYPE_CHECKING:  # pragma: no cover
+    from collections.abc import Mapping
+
+
+# Balance endpoint schema
+BALANCE_SCHEMA: dict[str, type[pl.Categorical | pl.Float64]] = {
+    "symbol": pl.Categorical,
+    "available": pl.Float64,
+    "inOrder": pl.Float64,
+}
+
+# Order endpoint schema (for individual orders)
+ORDER_SCHEMA: dict[str, type[pl.String | pl.Int64 | pl.Boolean | pl.Categorical | pl.Float64] | pl.List] = {
+    "orderId": pl.String,
+    "market": pl.Categorical,
+    "created": pl.Int64,
+    "updated": pl.Int64,
+    "status": pl.Categorical,
+    "side": pl.Categorical,
+    "orderType": pl.Categorical,
+    "clientOrderId": pl.String,
+    "selfTradePrevention": pl.Categorical,
+    "visible": pl.Boolean,
+    "onHold": pl.Float64,
+    "onHoldCurrency": pl.Categorical,
+    "fills": pl.List(
+        pl.Struct(
+            {
+                "id": pl.String,
+                "timestamp": pl.Int64,
+                "amount": pl.Float64,
+                "price": pl.Float64,
+                "taker": pl.Boolean,
+                "fee": pl.String,
+                "feeCurrency": pl.Categorical,
+                "settled": pl.Boolean,
+            }
+        )
+    ),
+    "feePaid": pl.Float64,
+    "feeCurrency": pl.Categorical,
+    "operatorId": pl.Int64,
+    "price": pl.Float64,
+    "timeInForce": pl.Categorical,
+    "postOnly": pl.Boolean,
+    "amount": pl.Float64,
+    "amountRemaining": pl.Float64,
+    "filledAmount": pl.Float64,
+    "filledAmountQuote": pl.Float64,
+    "createdNs": pl.Int64,
+    "updatedNs": pl.Int64,
+}
+
+# Orders endpoint schema (for lists of orders)
+ORDERS_SCHEMA = ORDER_SCHEMA.copy()
+
+# Cancel order response schema
+CANCEL_ORDER_SCHEMA: dict[str, type[pl.String | pl.Int64]] = {
+    "orderId": pl.String,
+    "clientOrderId": pl.String,
+    "operatorId": pl.Int64,
+}
+
+# Trade endpoint schema (for private trades)
+TRADE_SCHEMA: dict[str, type[pl.String | pl.Int64 | pl.Categorical | pl.Boolean]] = {
+    "id": pl.String,
+    "timestamp": pl.Int64,
+    "amount": pl.String,
+    "price": pl.String,
+    "side": pl.Categorical,
+    "market": pl.Categorical,
+    "fee": pl.String,
+    "feeCurrency": pl.Categorical,
+    "settled": pl.Boolean,
+}
+
+# Trades endpoint schema (for lists of trades)
+TRADES_SCHEMA = TRADE_SCHEMA.copy()
+
+# Fees endpoint schema
+FEES_SCHEMA: dict[str, type[pl.Int32 | pl.String]] = {
+    "tier": pl.Int32,
+    "volume": pl.String,
+    "maker": pl.String,
+    "taker": pl.String,
+}
+
+# Deposit endpoint schema
+DEPOSIT_SCHEMA: dict[str, type[pl.String | pl.Int64 | pl.Categorical]] = {
+    "timestamp": pl.Int64,
+    "symbol": pl.Categorical,
+    "amount": pl.String,
+    "fee": pl.String,
+    "status": pl.Categorical,
+    "address": pl.String,
+    "paymentId": pl.String,
+    "txId": pl.String,
+}
+
+# Deposits endpoint schema (for lists of deposits)
+DEPOSIT_HISTORY_SCHEMA = DEPOSIT_SCHEMA.copy()
+
+# Withdrawal endpoint schema (for withdrawal history)
+WITHDRAWAL_SCHEMA: dict[str, type[pl.String | pl.Int64 | pl.Categorical]] = {
+    "timestamp": pl.Int64,
+    "symbol": pl.Categorical,
+    "amount": pl.String,
+    "fee": pl.String,
+    "status": pl.Categorical,
+    "address": pl.String,
+    "txId": pl.String,
+}
+
+# Withdraw response schema (for withdraw operation response)
+WITHDRAW_RESPONSE_SCHEMA: dict[str, type[pl.String | pl.Boolean | pl.Categorical]] = {
+    "success": pl.Boolean,
+    "symbol": pl.Categorical,
+    "amount": pl.String,
+}
+
+# Withdrawals endpoint schema (for lists of withdrawals)
+WITHDRAWALS_SCHEMA = WITHDRAWAL_SCHEMA.copy()
+
+# Deposit data endpoint schema (for deposit information)
+DEPOSIT_DATA_SCHEMA: dict[str, type[pl.String]] = {
+    "address": pl.String,
+    "paymentid": pl.String,
+    "iban": pl.String,
+    "bic": pl.String,
+    "description": pl.String,
+}
+
+# Transaction history item schema (minimal - only core fields that are always present)
+TRANSACTION_HISTORY_ITEM_SCHEMA: dict[str, type[pl.String | pl.Categorical]] = {
+    "transactionId": pl.String,
+    "executedAt": pl.String,
+    "type": pl.Categorical,
+    # Optional fields that may or may not be present depending on transaction type:
+    # priceCurrency, priceAmount, sentCurrency, sentAmount,
+    # receivedCurrency, receivedAmount, feesCurrency, feesAmount, address
+}
+
+# Alternative comprehensive schema for cases where all fields are known to be present
+TRANSACTION_HISTORY_ITEM_FULL_SCHEMA: dict[str, type[pl.String | pl.Categorical]] = {
+    "transactionId": pl.String,
+    "executedAt": pl.String,
+    "type": pl.Categorical,
+    "priceCurrency": pl.Categorical,
+    "priceAmount": pl.String,
+    "sentCurrency": pl.Categorical,
+    "sentAmount": pl.String,
+    "receivedCurrency": pl.Categorical,
+    "receivedAmount": pl.String,
+    "feesCurrency": pl.Categorical,
+    "feesAmount": pl.String,
+    "address": pl.String,
+}
+
+# Transaction history response schema (for DataFrame containing transaction items)
+# Since transaction_history now returns tuple(items_df, metadata_dict),
+# the DataFrame contains transaction items, not pagination metadata
+TRANSACTION_HISTORY_SCHEMA = TRANSACTION_HISTORY_ITEM_SCHEMA.copy()
+
+# Default schemas mapping for each private endpoint
+# note that it doesn't always make sense for certain schemas to exist.
+DEFAULT_SCHEMAS: dict[str, Mapping[str, object]] = {
+    "account": {},  # placeholder - method will return Failure for DataFrame requests
+    "balance": BALANCE_SCHEMA,
+    "order": ORDER_SCHEMA,
+    "orders": ORDERS_SCHEMA,
+    "cancel_order": CANCEL_ORDER_SCHEMA,
+    "trade_history": TRADES_SCHEMA,
+    "transaction_history": TRANSACTION_HISTORY_SCHEMA,
+    "fees": FEES_SCHEMA,
+    "deposit": {},  # placeholder - method will return Failure for DataFrame requests
+    "deposit_history": DEPOSIT_HISTORY_SCHEMA,
+    "withdraw": WITHDRAW_RESPONSE_SCHEMA,
+    "withdrawal": WITHDRAWAL_SCHEMA,
+    "withdrawals": WITHDRAWALS_SCHEMA,
+}
+
+# Combined default schema for when you want all endpoints to use DataFrames
+COMBINED_DEFAULT_SCHEMA: dict[str, Mapping[str, object]] = DEFAULT_SCHEMAS.copy()

bitvavo_client/schemas/public_schemas.py

@@ -0,0 +1,149 @@
+"""Polars DataFrame schemas for public API endpoints."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+import polars as pl
+
+if TYPE_CHECKING:  # pragma: no cover
+    from collections.abc import Mapping
+
+# Time endpoint schema
+TIME_SCHEMA: dict[str, type[pl.Int64]] = {
+    "time": pl.Int64,
+    "timeNs": pl.Int64,
+}
+
+# Markets endpoint schema
+MARKETS_SCHEMA: dict[str, type[pl.Categorical | pl.Int8 | pl.Float64] | pl.List] = {
+    "market": pl.Categorical,
+    "status": pl.Categorical,
+    "base": pl.Categorical,
+    "quote": pl.Categorical,
+    "pricePrecision": pl.Int8,
+    "minOrderInBaseAsset": pl.Float64,
+    "minOrderInQuoteAsset": pl.Float64,
+    "maxOrderInBaseAsset": pl.Float64,
+    "maxOrderInQuoteAsset": pl.Float64,
+    "quantityDecimals": pl.Int8,
+    "notionalDecimals": pl.Int8,
+    "tickSize": pl.Float64,
+    "maxOpenOrders": pl.Int8,
+    "feeCategory": pl.Categorical,
+    "orderTypes": pl.List(pl.String),
+}
+
+# Assets endpoint schema
+ASSETS_SCHEMA: dict[str, type[pl.Categorical | pl.String | pl.Int8 | pl.Int16 | pl.Float64] | pl.List] = {
+    "symbol": pl.Categorical,
+    "name": pl.String,
+    "decimals": pl.Int8,
+    "depositFee": pl.Int8,
+    "depositConfirmations": pl.Int16,
+    "depositStatus": pl.Categorical,
+    "withdrawalFee": pl.Float64,
+    "withdrawalMinAmount": pl.Float64,
+    "withdrawalStatus": pl.Categorical,
+    "networks": pl.List(pl.Categorical),
+    "message": pl.String,
+}
+
+# Order book endpoint schema
+BOOK_SCHEMA: dict[str, type[pl.Categorical | pl.Int32 | pl.Int64] | pl.List] = {
+    "market": pl.Categorical,
+    "nonce": pl.Int32,
+    "bids": pl.List(pl.String),
+    "asks": pl.List(pl.String),
+    "timestamp": pl.Int64,
+}
+# Public trades endpoint schema
+TRADES_SCHEMA: dict[str, type[pl.String | pl.Int64 | pl.Float64 | pl.Categorical]] = {
+    "id": pl.String,
+    "timestamp": pl.Int64,
+    "amount": pl.Float64,
+    "price": pl.Float64,
+    "side": pl.Categorical,
+}
+
+# Candles endpoint schema
+CANDLES_SCHEMA: dict[str, type[pl.Int64 | pl.Float64]] = {
+    "timestamp": pl.Int64,
+    "open": pl.Float64,
+    "high": pl.Float64,
+    "low": pl.Float64,
+    "close": pl.Float64,
+    "volume": pl.Float64,
+}
+
+# Ticker price endpoint schema
+TICKER_PRICE_SCHEMA: dict[str, type[pl.Categorical | pl.Float64]] = {
+    "market": pl.Categorical,
+    "price": pl.Float64,
+}
+
+# Ticker book endpoint schema
+TICKER_BOOK_SCHEMA: dict[str, type[pl.Categorical | pl.Float64]] = {
+    "market": pl.Categorical,
+    "bid": pl.Float64,
+    "bidSize": pl.Float64,
+    "ask": pl.Float64,
+    "askSize": pl.Float64,
+}
+
+# Ticker 24h endpoint schema
+TICKER_24H_SCHEMA: dict[str, type[pl.Categorical | pl.Int64 | pl.Float64]] = {
+    "market": pl.Categorical,
+    "startTimestamp": pl.Int64,
+    "timestamp": pl.Int64,
+    "open": pl.Float64,
+    "openTimestamp": pl.Int64,
+    "high": pl.Float64,
+    "low": pl.Float64,
+    "last": pl.Float64,
+    "closeTimestamp": pl.Int64,
+    "bid": pl.Float64,
+    "bidSize": pl.Float64,
+    "ask": pl.Float64,
+    "askSize": pl.Float64,
+    "volume": pl.Float64,
+    "volumeQuote": pl.Float64,
+}
+
+# Order book report endpoint schema (MiCA-compliant)
+# Note: This uses the API field names (camelCase) since DataFrames are created
+# directly from the raw API response, not from Pydantic model instances
+# Note: bids and asks are complex nested structures that may need flattening for DataFrame use
+REPORT_BOOK_SCHEMA: dict[str, type | object] = {
+    "submissionTimestamp": pl.String,  # ISO 8601 timestamp
+    "assetCode": pl.Categorical,
+    "assetName": pl.String,
+    "priceCurrency": pl.Categorical,
+    "priceNotation": pl.Categorical,  # Always "MONE"
+    "quantityCurrency": pl.Categorical,
+    "quantityNotation": pl.Categorical,  # Always "CRYP"
+    "venue": pl.Categorical,  # Always "VAVO"
+    "tradingSystem": pl.Categorical,  # Always "VAVO"
+    "publicationTimestamp": pl.String,  # ISO 8601 timestamp
+    # Note: Nested structures for bids/asks - Polars will handle these as struct arrays
+    "bids": pl.Object,  # Complex nested structure
+    "asks": pl.Object,  # Complex nested structure
+}
+
+# Default schemas mapping for each endpoint
+DEFAULT_SCHEMAS: dict[str, Mapping[str, object]] = {
+    "time": TIME_SCHEMA,
+    "markets": MARKETS_SCHEMA,
+    "assets": ASSETS_SCHEMA,
+    "book": BOOK_SCHEMA,
+    "trades": TRADES_SCHEMA,
+    "candles": CANDLES_SCHEMA,
+    "ticker_price": TICKER_PRICE_SCHEMA,
+    "ticker_book": TICKER_BOOK_SCHEMA,
+    "ticker_24h": TICKER_24H_SCHEMA,
+    "report_book": REPORT_BOOK_SCHEMA,
+}
+
+# Combined default schema for when you want all endpoints to use DataFrames
+COMBINED_DEFAULT_SCHEMA: dict[str, Mapping[str, object]] = DEFAULT_SCHEMAS.copy()
+COMBINED_DEFAULT_SCHEMA = DEFAULT_SCHEMAS.copy()

bitvavo_client/transport/__init__.py

@@ -0,0 +1 @@
+"""Transport modules for bitvavo_client."""

bitvavo_client/transport/http.py

@@ -0,0 +1,159 @@
+"""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.key_index: int = -1
+        self.api_key: str = ""
+        self.api_secret: str = ""
+
+    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 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):
+            self.rate_limiter.sleep_until_reset(self.key_index)
+
+        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"))

bitvavo_client/ws/__init__.py

@@ -0,0 +1 @@
+"""WebSocket modules for bitvavo_client."""

bitvavo_api_upgraded-4.1.0.dist-info/RECORD

@@ -1,10 +0,0 @@
-bitvavo_api_upgraded/__init__.py,sha256=J_HdGBmZOfb1eOydaxsPmXfOIZ58hVa1qAfE6QErUHs,301
-bitvavo_api_upgraded/bitvavo.py,sha256=_3FRVVPg7_1HrALyGPjcuokCsHF5oz6itN_GKx7yTMo,166155
-bitvavo_api_upgraded/dataframe_utils.py,sha256=UvcDM0HeE-thUvsm9EjCmddmGBzZ9Puu40UVa0fR_p8,5821
-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/type_aliases.py,sha256=SbPBcuKWJZPZ8DSDK-Uycu5O-TUO6ejVaTt_7oyGyIU,1979
-bitvavo_api_upgraded-4.1.0.dist-info/WHEEL,sha256=Jb20R3Ili4n9P1fcwuLup21eQ5r9WXhs4_qy7VTrgPI,79
-bitvavo_api_upgraded-4.1.0.dist-info/METADATA,sha256=Go7SrHcYNBc3aZKxf09IBC8nudujCyN_Ze7tZST3mZI,35857
-bitvavo_api_upgraded-4.1.0.dist-info/RECORD,,