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

bitvavo_api_upgraded/bitvavo.py

@@ -2,16 +2,16 @@ from __future__ import annotations
 
 import contextlib
 import datetime as dt
-import hashlib
-import hmac
 import json
+import statistics
 import time
+from concurrent.futures import ThreadPoolExecutor, as_completed
 from pathlib import Path
 from threading import Thread
-from typing import Any, Callable
+from typing import TYPE_CHECKING, Any
 
 import websocket as ws_lib
-from requests import delete, get, post, put
+from httpx import delete, get, post, put
 from structlog.stdlib import get_logger
 from websocket import WebSocketApp  # missing stubs for WebSocketApp
 
@@ -19,88 +19,24 @@ from bitvavo_api_upgraded.dataframe_utils import convert_candles_to_dataframe, c
 from bitvavo_api_upgraded.helper_funcs import configure_loggers, time_ms, time_to_wait
 from bitvavo_api_upgraded.settings import bitvavo_settings, bitvavo_upgraded_settings
 from bitvavo_api_upgraded.type_aliases import OutputFormat, anydict, errordict, intdict, ms, s_f, strdict, strintdict
+from bitvavo_client.auth.signing import create_signature
+from bitvavo_client.endpoints.common import (
+    asks_compare,
+    bids_compare,
+    create_postfix,
+    default,
+    epoch_millis,
+    sort_and_insert,
+)
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
 
 configure_loggers()
 
 logger = get_logger(__name__)
 
 
-def create_signature(timestamp: ms, method: str, url: str, body: anydict | None, api_secret: str) -> str:
-    string = f"{timestamp}{method}/v2{url}"
-    if body is not None and len(body.keys()) > 0:
-        string += json.dumps(body, separators=(",", ":"))
-    signature = hmac.new(api_secret.encode("utf-8"), string.encode("utf-8"), hashlib.sha256).hexdigest()
-    return signature
-
-
-def create_postfix(options: anydict | None) -> str:
-    """Generate a URL postfix, based on the `options` dict.
-
-    ---
-    Args:
-        options (anydict): [description]
-
-    ---
-    Returns:
-        str: [description]
-    """
-    options = _default(options, {})
-    params = [f"{key}={options[key]}" for key in options]
-    postfix = "&".join(params)  # intersperse
-    return f"?{postfix}" if len(options) > 0 else postfix
-
-
-def _default(value: anydict | None, fallback: anydict) -> anydict:
-    """
-    Note that is close, but not actually equal to:
-
-    `return value or fallback`
-
-    I checked this with a temporary hypothesis test.
-
-    This note is all you will get out of me.
-    """
-    return value if value is not None else fallback
-
-
-def _epoch_millis(dt: dt.datetime) -> int:
-    return int(dt.timestamp() * 1000)
-
-
-def asks_compare(a: float, b: float) -> bool:
-    return a < b
-
-
-def bids_compare(a: float, b: float) -> bool:
-    return a > b
-
-
-def sort_and_insert(
-    asks_or_bids: list[list[str]],
-    update: list[list[str]],
-    compareFunc: Callable[[float, float], bool],
-) -> list[list[str]] | errordict:
-    for updateEntry in update:
-        entrySet: bool = False
-        for j in range(len(asks_or_bids)):
-            bookItem = asks_or_bids[j]
-            if compareFunc(float(updateEntry[0]), float(bookItem[0])):
-                asks_or_bids.insert(j, updateEntry)
-                entrySet = True
-                break
-            if float(updateEntry[0]) == float(bookItem[0]):
-                if float(updateEntry[1]) > 0.0:
-                    asks_or_bids[j] = updateEntry
-                    entrySet = True
-                    break
-                asks_or_bids.pop(j)
-                entrySet = True
-                break
-        if not entrySet:
-            asks_or_bids.append(updateEntry)
-    return asks_or_bids
-
-
 def process_local_book(ws: Bitvavo.WebSocketAppFacade, message: anydict) -> None:
     market: str = ""
     if "action" in message:
@@ -412,7 +348,9 @@ class Bitvavo:
         key_name = f"API_KEY_{key_index}" if key_index >= 0 else "KEYLESS"
 
         logger.warning(
-            "rate-limit-reached", key_name=key_name, rateLimitRemaining=self.rate_limits[key_index]["remaining"]
+            "rate-limit-reached",
+            key_name=key_name,
+            rateLimitRemaining=self.rate_limits[key_index]["remaining"],
         )
         logger.info(
             "napping-until-reset",
@@ -423,27 +361,108 @@ class Bitvavo:
         )
         time.sleep(napTime + 1)  # +1 to add a tiny bit of buffer time
 
-    def calc_lag(self) -> ms:
+    def calc_lag(self, samples: int = 5, timeout_seconds: float = 5.0) -> ms:  # noqa: C901
         """
-        Calculate the time difference between the client and server; use this value with BITVAVO_API_UPGRADED_LAG,
-        when you make an api call, to precent 304 errors.
+        Calculate the time difference between the client and server using statistical analysis.
+
+        Uses multiple samples with outlier detection to get a more accurate lag measurement.
+
+        Args:
+            samples: Number of time samples to collect (default: 5)
+            timeout_seconds: Maximum time to spend collecting samples (default: 5.0)
+
+        Returns:
+            Average lag in milliseconds
 
-        Raises KeyError if time() returns an error dict.
+        Raises:
+            ValueError: If unable to collect sufficient valid samples
+            RuntimeError: If all API calls fail
         """
-        lag_list = [
-            self.time()["time"] - time_ms(),
-            self.time()["time"] - time_ms(),
-            self.time()["time"] - time_ms(),
-            self.time()["time"] - time_ms(),
-            self.time()["time"] - time_ms(),
-            self.time()["time"] - time_ms(),
-            self.time()["time"] - time_ms(),
-            self.time()["time"] - time_ms(),
-            self.time()["time"] - time_ms(),
-            self.time()["time"] - time_ms(),
-        ]
+        ARBITRARY = 3
+        if samples < ARBITRARY:
+            msg = f"Need at least {ARBITRARY} samples for statistical analysis"
+            raise ValueError(msg)
+
+        def measure_single_lag() -> ms | None:
+            """Measure lag for a single request with error handling."""
+            try:
+                client_time_before = time_ms()
+                server_response = self.time()
+                client_time_after = time_ms()
+
+                if isinstance(server_response, dict) and "time" in server_response:
+                    # Use midpoint of request duration for better accuracy
+                    client_time_avg = (client_time_before + client_time_after) // 2
+                    server_time = server_response["time"]
+                    if isinstance(server_time, int):
+                        return ms(server_time - client_time_avg)
+                    return None
+            except (ValueError, TypeError, KeyError):
+                return None
+            else:
+                # If error or unexpected response
+                return None
+
+        lag_measurements: list[ms] = []
+
+        # Collect samples concurrently for better performance
+        with ThreadPoolExecutor(max_workers=min(samples, 5)) as executor:
+            try:
+                # Submit all measurement tasks
+                future_to_sample = {executor.submit(measure_single_lag): i for i in range(samples)}
+
+                # Collect results with timeout
+                for future in as_completed(future_to_sample, timeout=timeout_seconds):
+                    lag = future.result()
+                    if lag is not None:
+                        lag_measurements.append(lag)
+
+            except TimeoutError:
+                if self.debugging:
+                    logger.warning(
+                        "lag-calculation-timeout",
+                        collected_samples=len(lag_measurements),
+                        requested_samples=samples,
+                    )
+
+        if len(lag_measurements) < max(2, samples // 2):
+            msg = f"Insufficient valid samples: got {len(lag_measurements)}, need at least {max(2, samples // 2)}"
+            raise RuntimeError(msg)
+
+        # Remove outliers using interquartile range method
+        QUARTILES = 4
+        if len(lag_measurements) >= QUARTILES:
+            try:
+                q1 = statistics.quantiles(lag_measurements, n=QUARTILES)[0]
+                q3 = statistics.quantiles(lag_measurements, n=QUARTILES)[2]
+                iqr = q3 - q1
+                lower_bound = q1 - 1.5 * iqr
+                upper_bound = q3 + 1.5 * iqr
+
+                filtered_measurements = [lag for lag in lag_measurements if lower_bound <= lag <= upper_bound]
+
+                # Use filtered data if we still have enough samples
+                if len(filtered_measurements) >= 2:  # noqa: PLR2004
+                    lag_measurements = filtered_measurements
+
+            except statistics.StatisticsError:
+                # Fall back to original measurements if filtering fails
+                pass
+
+        # Calculate final lag using median for robustness
+        final_lag = ms(statistics.median(lag_measurements))
+
+        if self.debugging:
+            logger.debug(
+                "lag-calculated",
+                samples_collected=len(lag_measurements),
+                lag_ms=final_lag,
+                min_lag=min(lag_measurements),
+                max_lag=max(lag_measurements),
+                std_dev=statistics.stdev(lag_measurements) if len(lag_measurements) > 1 else 0,
+            )
 
-        return ms(sum(lag_list) / len(lag_list))
+        return final_lag
 
     def get_remaining_limit(self) -> int:
         """Get the remaining rate limit
@@ -576,7 +595,6 @@ class Bitvavo:
 
         ---
         Args:
-        # TODO(NostraDavid) fill these in
         ```python
         endpoint: str = "/order"
         postfix: str = ""  # ?key=value&key2=another_value&...
@@ -1045,14 +1063,14 @@ class Bitvavo:
         # timestamp is converted to datetime, numeric columns to float
         ```
         """
-        options = _default(options, {})
+        options = default(options, {})
         options["interval"] = interval
         if limit is not None:
             options["limit"] = limit
         if start is not None:
-            options["start"] = _epoch_millis(start)
+            options["start"] = epoch_millis(start)
         if end is not None:
-            options["end"] = _epoch_millis(end)
+            options["end"] = epoch_millis(end)
         postfix = create_postfix(options)
         result = self.public_request(f"{self.base}/{market}/candles{postfix}")  # type: ignore[return-value]
         return convert_candles_to_dataframe(result, output_format)
@@ -1279,7 +1297,7 @@ class Bitvavo:
         ]
         ```
         """
-        options = _default(options, {})
+        options = default(options, {})
         rateLimitingWeight = 25
         if "market" in options:
             rateLimitingWeight = 1
@@ -1796,7 +1814,7 @@ class Bitvavo:
         ]
         ```
         """  # noqa: E501
-        options = _default(options, {})
+        options = default(options, {})
         options["market"] = market
         postfix = create_postfix(options)
         return self.private_request("/orders", postfix, {}, "GET", 5)  # type: ignore[return-value]
@@ -1894,7 +1912,7 @@ class Bitvavo:
         ]
         ```
         """
-        options = _default(options, {})
+        options = default(options, {})
         rateLimitingWeight = 25
         if "market" in options:
             rateLimitingWeight = 1
@@ -1960,7 +1978,7 @@ class Bitvavo:
         ]
         ```
         """  # noqa: E501
-        options = _default(options, {})
+        options = default(options, {})
         options["market"] = market
         postfix = create_postfix(options)
         result = self.private_request("/trades", postfix, {}, "GET", 5)  # type: ignore[return-value]
@@ -2489,7 +2507,6 @@ class Bitvavo:
                 time.sleep(0.1)
 
         def do_send(self, ws: WebSocketApp, message: str, private: bool = False) -> None:  # noqa: FBT001, FBT002
-            # TODO(NostraDavid): add nap-time to the websocket, or do it here; I don't know yet.
             if private and self.APIKEY == "":
                 logger.error(
                     "no-apikey",
@@ -3961,8 +3978,6 @@ class Bitvavo:
             self.do_send(self.ws, json.dumps(options), True)
 
         def subscription_ticker(self, market: str, callback: Callable[[Any], None]) -> None:
-            # TODO(NostraDavid): one possible improvement here is to turn `market` into a list of markets, so we can sub
-            # to all of them at once. Same goes for other `subscription*()`
             """
             Subscribe to the ticker channel, which means `callback` gets passed the new best bid or ask whenever they
             change (server-side).

bitvavo_api_upgraded/dataframe_utils.py

@@ -165,7 +165,9 @@ def convert_candles_to_dataframe(data: Any, output_format: str | OutputFormat) -
     # Convert list of lists to list of dicts first
     columns = ["timestamp", "open", "high", "low", "close", "volume"]
     dict_data = [
-        dict(zip(columns, candle)) for candle in data if isinstance(candle, list) and len(candle) >= len(columns)
+        dict(zip(columns, candle, strict=True))
+        for candle in data
+        if isinstance(candle, list) and len(candle) >= len(columns)
     ]
 
     if not dict_data:

bitvavo_api_upgraded/settings.py

@@ -105,7 +105,7 @@ class BitvavoSettings(BaseSettings):
     PREFER_KEYLESS: bool = Field(default=True)
 
     # Configuration for Pydantic Settings
-    model_config: SettingsConfigDict = SettingsConfigDict(
+    model_config = SettingsConfigDict(
         env_file=Path.cwd() / ".env",
         env_file_encoding="utf-8",
         env_prefix="BITVAVO_",

bitvavo_api_upgraded/type_aliases.py

@@ -4,7 +4,7 @@ to clearify the intention or semantics/meaning/unit of a variable
 """
 
 import sys
-from typing import Any, Union
+from typing import Any
 
 if sys.version_info >= (3, 11):
     from enum import StrEnum
@@ -26,7 +26,7 @@ anydict = dict[str, Any]
 strdict = dict[str, str]
 intdict = dict[str, int]
 # can't use | here, with __future__. Not sure why.
-strintdict = dict[str, Union[str, int]]
+strintdict = dict[str, str | int]
 errordict = dict[str, Any]  # same type as anydict, but the semantics/meaning is different
 
 # note: You can also use these for type conversion, so instead of int(some_float / 1000), you can just do ms(some_float