Qubx 0.6.54__cp312-cp312-manylinux_2_39_x86_64.whl → 0.6.56__cp312-cp312-manylinux_2_39_x86_64.whl

qubx/backtester/runner.py

@@ -439,7 +439,7 @@ class SimulationRunner:
         if isinstance(commissions, (str, type(None))):
             commissions = {e: commissions for e in exchanges}
         for exchange in exchanges:
-            _exchange_to_tcc[exchange] = lookup.fees.find(exchange.lower(), commissions.get(exchange))
+            _exchange_to_tcc[exchange] = lookup.find_fees(exchange.lower(), commissions.get(exchange))
         return _exchange_to_tcc
 
     def _construct_account_processor(

qubx/core/basics.py

@@ -1,3 +1,4 @@
+import re
 from dataclasses import dataclass, field
 from datetime import datetime
 from enum import StrEnum
@@ -176,6 +177,14 @@ class MarketType(StrEnum):
 
 @dataclass
 class Instrument:
+    """
+    Instrument class.
+
+     - 2025-06-11: Important change for FUTURE type: now instrument's symbol contains delivery date in format YYYYMMDD.
+        So now for let's say september's BTCUSDT future, symbol would be BTCUSD.20250914
+        and full id is `BINANCE.UM:FUTURE:BTCUSD.20250914`
+    """
+
     symbol: str
     asset_type: AssetType
     market_type: MarketType
@@ -192,8 +201,10 @@ class Instrument:
     maint_margin: float = 0.0  # maintenance margin
     liquidation_fee: float = 0.0  # liquidation fee
     contract_size: float = 1.0  # contract size
-    onboard_date: datetime | None = None
-    delivery_date: datetime | None = None
+    onboard_date: datetime | None = None  # date when instrument was listed on the exchange
+    delivery_date: datetime | None = None  # date when instrument is delivered
+    delist_date: datetime | None = None  # date when instrument is delisted
+    inverse: bool = False  # if true, then the future is inverse
 
     @property
     def price_precision(self):
@@ -437,9 +448,6 @@ class AssetBalance:
         return self
 
 
-MARKET_TYPE = Literal["SPOT", "MARGIN", "SWAP", "FUTURES", "OPTION"]
-
-
 class Position:
     instrument: Instrument  # instrument for this position
     quantity: float = 0.0  # quantity positive for long and negative for short
@@ -878,3 +886,101 @@ class RestoredState:
     balances: dict[str, AssetBalance]
     instrument_to_target_positions: dict[Instrument, list[TargetPosition]]
     positions: dict[Instrument, Position]
+
+
+class InstrumentsLookup:
+    def get_lookup(self) -> dict[str, Instrument]: ...
+
+    def find(
+        self,
+        exchange: str,
+        base: str,
+        quote: str,
+        settle: str | None = None,
+        market_type: MarketType | None = None,
+    ) -> Instrument | None:
+        for i in self.get_lookup().values():
+            if (
+                i.exchange == exchange
+                and ((i.base == base and i.quote == quote) or (i.base == quote and i.quote == base))
+                and (market_type is None or i.market_type == market_type)
+            ):
+                if settle is not None and i.settle is not None:
+                    if i.settle == settle:
+                        return i
+                else:
+                    return i
+        return None
+
+    def find_symbol(self, exchange: str, symbol: str, market_type: MarketType | None = None) -> Instrument | None:
+        for i in self.get_lookup().values():
+            if (
+                (i.exchange == exchange)
+                and (i.symbol == symbol)
+                and (market_type is None or i.market_type == market_type)
+            ):
+                return i
+
+        return None
+
+    def find_instruments(
+        self,
+        exchange: str,
+        quote: str | None = None,
+        market_type: MarketType | None = None,
+        as_of: str | pd.Timestamp | None = None,
+    ) -> list[Instrument]:
+        """
+        Find instruments by exchange, quote, market type and as of date.
+        If as_of is not None, then only instruments that are not delisted after as_of date will be returned.
+        - exchange: str - exchange name
+        - quote: str | None - quote currency
+        - market_type: MarketType | None - market type
+        - as_of is a string in format YYYY-MM-DD or pd.Timestamp or None
+        """
+        _limit_time = pd.Timestamp(as_of) if as_of else None
+        return [
+            i
+            for i in self.get_lookup().values()
+            if i.exchange == exchange
+            and (quote is None or i.quote == quote)
+            and (market_type is None or i.market_type == market_type)
+            and (
+                _limit_time is None
+                or (i.delist_date is None)
+                or (pd.Timestamp(i.delist_date).tz_localize(None) >= _limit_time)
+            )
+        ]
+
+    def find_aux_instrument_for(
+        self, instrument: Instrument, base_currency: str, market_type: MarketType | None = None
+    ) -> Instrument | None:
+        """
+        Tries to find aux instrument (for conversions to funded currency)
+        for example:
+            ETHBTC -> BTCUSDT for base_currency USDT
+            EURGBP -> GBPUSD for base_currency USD
+            ...
+        """
+        if market_type is None:
+            market_type = instrument.market_type
+        base_currency = base_currency.upper()
+        if instrument.quote != base_currency:
+            return self.find(instrument.exchange, instrument.quote, base_currency, market_type=market_type)
+        return None
+
+    def __getitem__(self, spath: str) -> list[Instrument]:
+        """
+        Helper method for finding instruments by pattern.
+        It's convenient to use in research mode.
+        """
+        res = []
+        c = re.compile(spath)
+        for k, v in self.get_lookup().items():
+            if re.match(c, k):
+                res.append(v)
+        return res
+
+
+class FeesLookup:
+    def find_fees(self, exchange: str, spec: str | None) -> TransactionCostsCalculator: ...

qubx/core/helpers.py

@@ -6,15 +6,15 @@ import time
 from collections import defaultdict, deque
 from inspect import isbuiltin, isclass, isfunction, ismethod, ismethoddescriptor
 from threading import Thread
-from typing import Any, Callable, Dict, List
+from typing import Any, Callable
 
 import numpy as np
 import pandas as pd
 from croniter import croniter
 
 from qubx import logger
-from qubx.core.basics import SW, CtrlChannel, DataType, Instrument, Timestamped
-from qubx.core.series import OHLCV, Bar, OrderBook, Quote, Trade
+from qubx.core.basics import SW, CtrlChannel, DataType, Instrument, Timestamped, dt_64
+from qubx.core.series import OHLCV, Bar, OrderBook, Quote, Trade, time_as_nsec
 from qubx.utils.time import convert_seconds_to_str, convert_tf_str_td64, interval_to_cron
 
 
@@ -26,9 +26,9 @@ class CachedMarketDataHolder:
     default_timeframe: np.timedelta64
     _last_bar: dict[Instrument, Bar | None]
     _ohlcvs: dict[Instrument, dict[np.timedelta64, OHLCV]]
-    _updates: dict[Instrument, Any]
+    _updates: dict[Instrument, Bar | Quote | Trade]
 
-    _instr_to_sub_to_buffer: Dict[Instrument, Dict[str, deque]]
+    _instr_to_sub_to_buffer: dict[Instrument, dict[str, deque]]
 
     def __init__(self, default_timeframe: str | None = None, max_buffer_size: int = 10_000) -> None:
         self._ohlcvs = dict()
@@ -93,7 +93,7 @@ class CachedMarketDataHolder:
 
         return self._ohlcvs[instrument][tf]
 
-    def get_data(self, instrument: Instrument, event_type: str) -> List[Any]:
+    def get_data(self, instrument: Instrument, event_type: str) -> list[Any]:
         return list(self._instr_to_sub_to_buffer[instrument][event_type])
 
     def update(
@@ -126,7 +126,7 @@ class CachedMarketDataHolder:
                 pass
 
     @SW.watch("CachedMarketDataHolder")
-    def update_by_bars(self, instrument: Instrument, timeframe: str | np.timedelta64, bars: List[Bar]) -> OHLCV:
+    def update_by_bars(self, instrument: Instrument, timeframe: str | np.timedelta64, bars: list[Bar]) -> OHLCV:
         """
         Update or create OHLCV series with the provided historical bars.
 
@@ -203,6 +203,17 @@ class CachedMarketDataHolder:
                     continue
                 ser.update(trade.time, trade.price, total_vol, bought_vol)
 
+    def finalize_all_ohlc(self, time: dt_64):
+        """
+        Finalize all OHLCV series at the given time.
+        FIXME: (2025-06-17) This is part of urgent live fix and must be removed in future !!!.
+        """
+        for instrument in self._ohlcvs.keys():
+            # - use most recent update
+            if (_u := self._updates.get(instrument)) is not None:
+                _px = extract_price(_u)
+                self.update_by_bar(instrument, Bar(time_as_nsec(time), _px, _px, _px, _px, 0, 0))
+
 
 SPEC_REGEX = re.compile(
     r"((?P<type>[A-Za-z]+)(\.?(?P<timeframe>[0-9A-Za-z]+))?\ *:)?"