Qubx 0.6.65__cp312-cp312-manylinux_2_39_x86_64.whl → 0.6.66__cp312-cp312-manylinux_2_39_x86_64.whl

qubx/backtester/broker.py

@@ -1,3 +1,4 @@
+from qubx import logger
 from qubx.backtester.ome import SimulatedExecutionReport
 from qubx.backtester.simulated_exchange import ISimulatedExchange
 from qubx.core.basics import (
@@ -5,6 +6,7 @@ from qubx.core.basics import (
     Instrument,
     Order,
 )
+from qubx.core.exceptions import OrderNotFound
 from qubx.core.interfaces import IBroker
 
 from .account import SimulatedAccountProcessor
@@ -63,8 +65,13 @@ class SimulatedBroker(IBroker):
         self.send_order(instrument, order_side, order_type, amount, price, client_id, time_in_force, **optional)
 
     def cancel_order(self, order_id: str) -> Order | None:
-        self._send_execution_report(order_update := self._exchange.cancel_order(order_id))
-        return order_update.order if order_update is not None else None
+        try:
+            self._send_execution_report(order_update := self._exchange.cancel_order(order_id))
+            return order_update.order if order_update is not None else None
+        except OrderNotFound:
+            # Order was already cancelled or doesn't exist
+            logger.debug(f"Order {order_id} not found")
+            return None
 
     def cancel_orders(self, instrument: Instrument) -> None:
         raise NotImplementedError("Not implemented yet")

qubx/backtester/runner.py

@@ -5,7 +5,9 @@ import pandas as pd
 from tqdm.auto import tqdm
 
 from qubx import logger
+from qubx.backtester.sentinels import NoDataContinue
 from qubx.backtester.simulated_data import IterableSimulationData
+from qubx.backtester.utils import SimulationDataConfig, TimeGuardedWrapper
 from qubx.core.account import CompositeAccountProcessor
 from qubx.core.basics import SW, DataType, Instrument, TransactionCostsCalculator
 from qubx.core.context import StrategyContext
@@ -22,8 +24,10 @@ from qubx.core.interfaces import (
 )
 from qubx.core.loggers import StrategyLogging
 from qubx.core.lookups import lookup
+from qubx.data.helpers import CachedPrefetchReader
 from qubx.loggers.inmemory import InMemoryLogsWriter
 from qubx.pandaz.utils import _frame_to_str
+from qubx.utils.time import now_ns
 
 from .account import SimulatedAccountProcessor
 from .broker import SimulatedBroker
@@ -80,6 +84,7 @@ class SimulationRunner:
         emitter: IMetricEmitter | None = None,
         strategy_state: StrategyState | None = None,
         initializer: BasicStrategyInitializer | None = None,
+        warmup_mode: bool = False,
     ):
         """
         Initialize the BacktestContextRunner with a strategy context.
@@ -102,8 +107,10 @@ class SimulationRunner:
         self.emitter = emitter
         self.strategy_state = strategy_state if strategy_state is not None else StrategyState()
         self.initializer = initializer
+        self.warmup_mode = warmup_mode
         self._pregenerated_signals = dict()
         self._to_process = {}
+        self._aux_data_reader = None
 
         # - get strategy parameters BEFORE simulation start
         #   potentially strategy may change it's parameters during simulation
@@ -126,6 +133,8 @@ class SimulationRunner:
         """
         logger.debug(f"[<y>SimulationRunner</y>] :: Running simulation from {self.start} to {self.stop}")
 
+        self._prefetch_aux_data()
+
         # Start the context
         self.ctx.start()
 
@@ -164,6 +173,8 @@ class SimulationRunner:
             logger.error("Simulated trading interrupted by user!")
             if not catch_keyboard_interrupt:
                 raise
+        except Exception as e:
+            raise e
         finally:
             # Stop the context
             self.ctx.stop()
@@ -196,7 +207,7 @@ class SimulationRunner:
             for i in self._data_providers[0].get_subscribed_instruments():
                 # - we can process series with variable id's if we can find some similar instrument
                 if s == i.symbol or s == str(i) or s == f"{i.exchange}:{i.symbol}" or str(s) == str(i):
-                    _start, _end = pd.Timestamp(start), pd.Timestamp(end)
+                    _start, _end = np.datetime64(start), np.datetime64(end)
                     _start_idx, _end_idx = v.index.get_indexer([_start, _end], method="ffill")
                     sel = v.iloc[max(_start_idx, 0) : _end_idx + 1]
 
@@ -268,21 +279,34 @@ class SimulationRunner:
         start, stop = pd.Timestamp(start), pd.Timestamp(stop)
         total_duration = stop - start
         update_delta = total_duration / 100
-        prev_dt = pd.Timestamp(start)
+        prev_dt = np.datetime64(start)
 
         # - date iteration
         qiter = self._data_source.create_iterable(start, stop)
+
         if silent:
             for instrument, data_type, event, is_hist in qiter:
-                if not _run(instrument, data_type, event, is_hist):
+                # Handle NoDataContinue sentinel
+                if isinstance(event, NoDataContinue):
+                    if not self._handle_no_data_scenario(stop):
+                        break
+                    continue
+
+                if not self._process_event(instrument, data_type, event, is_hist, _run, stop):
                     break
         else:
             _p = 0
             with tqdm(total=100, desc="Simulating", unit="%", leave=False) as pbar:
                 for instrument, data_type, event, is_hist in qiter:
-                    if not _run(instrument, data_type, event, is_hist):
+                    # Handle NoDataContinue sentinel
+                    if isinstance(event, NoDataContinue):
+                        if not self._handle_no_data_scenario(stop):
+                            break
+                        continue
+
+                    if not self._process_event(instrument, data_type, event, is_hist, _run, stop):
                         break
-                    dt = pd.Timestamp(event.time)
+                    dt = np.datetime64(event.time, "ns")
                     # update only if date has changed
                     if dt - prev_dt > update_delta:
                         _p += 1
@@ -294,6 +318,43 @@ class SimulationRunner:
 
         logger.info(f"{self.__class__.__name__} ::: Simulation finished at {stop} :::")
 
+    def _process_event(self, instrument, data_type, event, is_hist, _run, stop_time):
+        """Process a single simulation event with proper time advancement and scheduler checks."""
+        # During warmup, clamp future timestamps to current time
+        if self.warmup_mode and hasattr(event, "time"):
+            current_real_time = now_ns()
+            if event.time > current_real_time:
+                event.time = current_real_time
+
+        if not _run(instrument, data_type, event, is_hist):
+            return False
+        return True
+
+    def _handle_no_data_scenario(self, stop_time):
+        """Handle scenario when no data is available but scheduler might have events."""
+        # Check if we have pending scheduled events
+        if hasattr(self.scheduler, "_next_nearest_time"):
+            next_scheduled_time = self.scheduler._next_nearest_time
+            current_time = self.time_provider.time()
+
+            # Convert to int64 for numerical comparisons (avoid type issues)
+            next_time_ns = next_scheduled_time.astype("int64")
+            current_time_ns = current_time.astype("int64")
+            stop_time_ns = stop_time.value  # Already int64
+
+            # Check if we've reached the stop time
+            if current_time_ns >= stop_time_ns:
+                return False  # Stop simulation
+
+            # If there's a scheduled event before stop time, advance to it
+            if next_time_ns < np.iinfo(np.int64).max and next_time_ns < stop_time_ns:
+                # Use the original datetime64 object for set_time (not the int64 conversion)
+                self.time_provider.set_time(next_scheduled_time)
+                self.scheduler.check_and_run_tasks()
+                return True  # Continue simulation
+
+        return False  # No scheduled events, stop simulation
+
     def print_latency_report(self) -> None:
         _l_r = SW.latency_report()
         if _l_r is not None:
@@ -311,11 +372,6 @@ class SimulationRunner:
             f"for {self.setup.capital} {self.setup.base_currency}..."
         )
 
-        data_source = IterableSimulationData(
-            self.data_config.data_providers,
-            open_close_time_indent_secs=self.data_config.adjusted_open_close_time_indent_secs,
-        )
-
         channel = SimulatedCtrlChannel("databus", sentinel=(None, None, None, None))
         simulated_clock = SimulatedTimeProvider(np.datetime64(self.start, "ns"))
 
@@ -325,6 +381,11 @@ class SimulationRunner:
 
         scheduler = SimulatedScheduler(channel, lambda: simulated_clock.time().item())
 
+        data_source = IterableSimulationData(
+            self.data_config.data_providers,
+            open_close_time_indent_secs=self.data_config.adjusted_open_close_time_indent_secs,
+        )
+
         brokers = []
         for exchange in self.setup.exchanges:
             _exchange_account = account.get_account_processor(exchange)
@@ -349,7 +410,7 @@ class SimulationRunner:
             )
 
         # - get aux data provider
-        _aux_data = self.data_config.get_timeguarded_aux_reader(simulated_clock)
+        self._aux_data_reader = self.data_config.get_timeguarded_aux_reader(simulated_clock)
 
         # - it will store simulation results into memory
         logs_writer = InMemoryLogsWriter(self.account_id, self.setup.name, "0")
@@ -401,7 +462,7 @@ class SimulationRunner:
             time_provider=simulated_clock,
             instruments=self.setup.instruments,
             logging=StrategyLogging(logs_writer, portfolio_log_freq=self.portfolio_log_freq),
-            aux_data_provider=_aux_data,
+            aux_data_provider=self._aux_data_reader,
             emitter=self.emitter,
             strategy_state=self.strategy_state,
             initializer=self.initializer,
@@ -487,3 +548,42 @@ class SimulationRunner:
             time_provider=time_provider,
             account_processors=_account_processors,
         )
+
+    def _prefetch_aux_data(self):
+        # Perform prefetch of aux data if enabled
+        if self._aux_data_reader is None:
+            return
+
+        aux_reader = self._aux_data_reader
+        if isinstance(aux_reader, TimeGuardedWrapper) and isinstance(aux_reader._reader, CachedPrefetchReader):
+            aux_reader = aux_reader._reader
+        elif isinstance(aux_reader, CachedPrefetchReader):
+            aux_reader = aux_reader
+        else:
+            return
+
+        if self.data_config.prefetch_config and self.data_config.prefetch_config.enabled:
+            # Prepare prefetch arguments
+            prefetch_args = self.data_config.prefetch_config.args.copy()
+
+            # Add exchange info if available from instruments
+            if self.setup.instruments and "exchange" not in prefetch_args:
+                # Get exchange from first instrument
+                first_exchange = self.setup.instruments[0].exchange
+                if first_exchange:
+                    prefetch_args["exchange"] = first_exchange
+
+            logger.info(
+                f"Prefetching aux data: {self.data_config.prefetch_config.aux_data_names} for period {self.start} to {self.stop}"
+            )
+
+            try:
+                # Perform the prefetch
+                aux_reader.prefetch_aux_data(
+                    self.data_config.prefetch_config.aux_data_names,
+                    start=str(self.start),
+                    stop=str(self.stop),
+                    **prefetch_args,
+                )
+            except Exception as e:
+                logger.warning(f"Prefetch failed: {e}")

qubx/backtester/sentinels.py

@@ -0,0 +1,23 @@
+from __future__ import annotations
+
+from typing import Optional
+
+
+class NoDataContinue:
+    """Sentinel indicating no data streams available but simulation should continue.
+    
+    This is used when all instruments are unsubscribed but there may still be
+    scheduled events to process before the simulation stop time.
+    """
+    
+    def __init__(self, next_scheduled_time: Optional[int] = None):
+        """Initialize the sentinel.
+        
+        Args:
+            next_scheduled_time: The next scheduled event time in nanoseconds,
+                                or None if no scheduled events exist.
+        """
+        self.next_scheduled_time = next_scheduled_time
+    
+    def __repr__(self) -> str:
+        return f"NoDataContinue(next_scheduled_time={self.next_scheduled_time})"

qubx/backtester/simulated_data.py

@@ -3,6 +3,7 @@ from typing import Any, Iterator
 import pandas as pd
 
 from qubx import logger
+from qubx.backtester.sentinels import NoDataContinue
 from qubx.core.basics import DataType, Instrument, MarketType, Timestamped
 from qubx.core.exceptions import SimulationError
 from qubx.data.composite import IteratedDataStreamsSlicer
@@ -447,6 +448,17 @@ class IterableSimulationData(Iterator):
         try:
             while data := next(self._slicing_iterator):  # type: ignore
                 k, t, v = data
+
+                # Check if we've reached or exceeded the stop time
+                # It's commented out because we expect data readers to stop on their own
+                # if self._stop is not None and t > self._stop.value:
+                #     raise StopIteration
+                
+                # Handle NoDataContinue sentinel
+                if isinstance(v, NoDataContinue):
+                    # Return the sentinel as the event - the runner will detect it with isinstance
+                    return None, "", v, False
+
                 instr, fetcher, subt = self._instruments[k]
                 data_type = fetcher._producing_data_type
                 _is_historical = False

qubx/backtester/simulated_exchange.py

@@ -11,6 +11,7 @@ from qubx.core.basics import (
     TransactionCostsCalculator,
     dt_64,
 )
+from qubx.core.exceptions import OrderNotFound
 from qubx.core.series import Bar, OrderBook, Quote, Trade, TradeArray
 
 
@@ -155,8 +156,7 @@ class BasicSimulatedExchange(ISimulatedExchange):
                     if order.id == order_id:
                         return self._process_ome_response(o.cancel_order(order_id))
 
-            logger.warning(f"[<y>{self.__class__.__name__}</y>] :: cancel_order :: can't find order '{order_id}'!")
-            return None
+            raise OrderNotFound(f"Order '{order_id}' not found")
 
         ome = self._ome.get(instrument)
         if ome is None:
@@ -165,7 +165,10 @@ class BasicSimulatedExchange(ISimulatedExchange):
             )
 
         # - cancel order in OME and remove from the map to free memory
-        return self._process_ome_response(ome.cancel_order(order_id))
+        result = self._process_ome_response(ome.cancel_order(order_id))
+        if result is None:
+            raise OrderNotFound(f"Order '{order_id}' not found")
+        return result
 
     def _process_ome_response(self, report: SimulatedExecutionReport | None) -> SimulatedExecutionReport | None:
         if report is not None:

qubx/backtester/simulator.py

@@ -11,7 +11,8 @@ from qubx.core.metrics import TradingSessionResult
 from qubx.data.readers import DataReader
 from qubx.emitters.inmemory import InMemoryMetricEmitter
 from qubx.utils.misc import ProgressParallel, Stopwatch, get_current_user
-from qubx.utils.time import handle_start_stop
+from qubx.utils.runner.configs import PrefetchConfig
+from qubx.utils.time import handle_start_stop, to_utc_naive
 
 from .runner import SimulationRunner
 from .utils import (
@@ -32,10 +33,10 @@ def simulate(
     strategies: StrategiesDecls_t,
     data: DataDecls_t,
     capital: float | dict[str, float],
-    instruments: list[str] | list[Instrument] | dict[ExchangeName_t, list[SymbolOrInstrument_t]],
-    commissions: str | dict[str, str | None] | None,
     start: str | pd.Timestamp,
     stop: str | pd.Timestamp | None = None,
+    instruments: list[str] | list[Instrument] | dict[ExchangeName_t, list[SymbolOrInstrument_t]] | None = None,
+    commissions: str | dict[str, str | None] | None = None,
     exchange: ExchangeName_t | list[ExchangeName_t] | None = None,
     base_currency: str = "USDT",
     n_jobs: int = 1,
@@ -52,6 +53,7 @@ def simulate(
     enable_inmemory_emitter: bool = False,
     emitter_stats_interval: str = "1h",
     run_separate_instruments: bool = False,
+    prefetch_config: PrefetchConfig | None = None,
 ) -> list[TradingSessionResult]:
     """
     Backtest utility for trading strategies or signals using historical data.
@@ -80,6 +82,7 @@ def simulate(
         - enable_inmemory_emitter (bool): If True, attaches an in-memory metric emitter and returns its dataframe in TradingSessionResult.emitter_data.
         - emitter_stats_interval (str): Interval for emitting stats in the in-memory emitter (default: "1h").
         - run_separate_instruments (bool): If True, creates separate simulation setups for each instrument, default is False.
+        - prefetch_config (dict[str, Any] | None): Configuration for prefetching auxiliary data, default is None.
 
     Returns:
         - list[TradingSessionResult]: A list of TradingSessionResult objects containing the results of each simulation setup.
@@ -91,6 +94,9 @@ def simulate(
     # - we need to reset stopwatch
     Stopwatch().reset()
 
+    if instruments is None:
+        instruments = []
+
     # - process instruments:
     _instruments, _exchanges = find_instruments_and_exchanges(instruments, exchange)
 
@@ -103,7 +109,9 @@ def simulate(
         raise SimulationError(_msg)
 
     # - recognize provided data
-    data_setup = recognize_simulation_data_config(data, _instruments, open_close_time_indent_secs, aux_data)
+    data_setup = recognize_simulation_data_config(
+        data, _instruments, open_close_time_indent_secs, aux_data, prefetch_config
+    )
 
     # - recognize setup: it can be either a strategy or set of signals
     simulation_setups = recognize_simulation_configuration(
@@ -133,7 +141,7 @@ def simulate(
     # - preprocess start and stop and convert to datetime if necessary
     if stop is None:
         # - check stop time : here we try to backtest till now (may be we need to get max available time from data reader ?)
-        stop = pd.Timestamp.now(tz="UTC").astimezone(None)
+        stop = to_utc_naive(pd.Timestamp.now(tz="UTC"))
 
     _start, _stop = handle_start_stop(start, stop, convert=pd.Timestamp)
     assert isinstance(_start, pd.Timestamp) and isinstance(_stop, pd.Timestamp), "Invalid start and stop times"
@@ -229,7 +237,7 @@ def _adjust_start_date_for_min_instrument_onboard(setup: SimulationSetup, start:
     Adjust the start date for the simulation to the onboard date of the instrument with the minimum onboard date.
     """
     onboard_dates = [
-        pd.Timestamp(instrument.onboard_date).replace(tzinfo=None)
+        to_utc_naive(pd.Timestamp(instrument.onboard_date))
         for instrument in setup.instruments
         if instrument.onboard_date is not None
     ]

qubx/backtester/utils.py

@@ -24,9 +24,10 @@ from qubx.core.lookups import lookup
 from qubx.core.series import OHLCV, Bar, Quote, Trade
 from qubx.core.utils import time_delta_to_str
 from qubx.data import TardisMachineReader
-from qubx.data.helpers import InMemoryCachedReader, TimeGuardedWrapper
+from qubx.data.helpers import CachedPrefetchReader, TimeGuardedWrapper
 from qubx.data.hft import HftDataReader
 from qubx.data.readers import AsDict, DataReader, InMemoryDataFrameReader
+from qubx.utils.runner.configs import PrefetchConfig
 from qubx.utils.time import infer_series_frequency, timedelta_to_crontab
 
 SymbolOrInstrument_t: TypeAlias = str | Instrument
@@ -108,14 +109,31 @@ class SimulationDataConfig:
     default_warmups: dict[str, str]                        # default warmups periods
     open_close_time_indent_secs: int                       # open/close ticks shift in seconds
     adjusted_open_close_time_indent_secs: int              # adjusted open/close ticks shift in seconds
-    aux_data_provider: InMemoryCachedReader | None = None  # auxiliary data provider
+    aux_data_provider: DataReader | None = None  # auxiliary data provider
+    prefetch_config: PrefetchConfig | None = None         # prefetch configuration
 
     def get_timeguarded_aux_reader(self, time_provider: ITimeProvider) -> TimeGuardedWrapper | None:
         _aux = None
         if self.aux_data_provider is not None:
-            if not isinstance(self.aux_data_provider, InMemoryCachedReader):
-                logger.warning("Aux data provider should be an instance of InMemoryCachedReader ! Otherwise it can lead to unnecessary effects !")
-            _aux = TimeGuardedWrapper(self.aux_data_provider, time_guard=time_provider)
+            aux_reader = self.aux_data_provider
+            
+            # Wrap with CachedPrefetchReader if not already wrapped
+            if not isinstance(aux_reader, CachedPrefetchReader):
+                prefetch_period = "1w"
+                cache_size_mb = 100
+                
+                # Get prefetch configuration if available
+                if self.prefetch_config:
+                    prefetch_period = self.prefetch_config.prefetch_period
+                    cache_size_mb = self.prefetch_config.cache_size_mb
+                
+                aux_reader = CachedPrefetchReader(
+                    aux_reader, 
+                    prefetch_period=prefetch_period,
+                    cache_size_mb=cache_size_mb
+                )
+            
+            _aux = TimeGuardedWrapper(aux_reader, time_guard=time_provider)
         return _aux
 # fmt: on
 
@@ -777,6 +795,7 @@ def recognize_simulation_data_config(
     instruments: list[Instrument],
     open_close_time_indent_secs: int = 1,
     aux_data: DataReader | None = None,
+    prefetch_config: PrefetchConfig | None = None,
 ) -> SimulationDataConfig:
     """
     Recognizes and configures simulation data based on the provided declarations.
@@ -920,5 +939,6 @@ def recognize_simulation_data_config(
 
     # - just pass it to config, TODO: we need to think how to handle auxiliary data provider better
     _setup_defaults.aux_data_provider = aux_data  # type: ignore
+    _setup_defaults.prefetch_config = prefetch_config
 
     return _setup_defaults

qubx/connectors/ccxt/data.py

@@ -444,7 +444,7 @@ class CcxtDataProvider(IDataProvider):
                 logger.info(f"<yellow>{self._exchange_id}</yellow> {name} listening has been stopped")
                 break
             except (NetworkError, ExchangeError, ExchangeNotAvailable) as e:
-                logger.error(f"<yellow>{self._exchange_id}</yellow> Error in {name} : {e}")
+                logger.error(f"<yellow>{self._exchange_id}</yellow> {e.__class__.__name__} :: Error in {name} : {e}")
                 await asyncio.sleep(1)
                 continue
             except Exception as e:

qubx/connectors/ccxt/reader.py

@@ -10,7 +10,7 @@ from qubx.core.basics import DataType, Instrument
 from qubx.data.readers import DataReader, DataTransformer
 from qubx.data.registry import reader
 from qubx.utils.misc import AsyncThreadLoop
-from qubx.utils.time import handle_start_stop
+from qubx.utils.time import handle_start_stop, now_utc
 
 from .factory import get_ccxt_exchange
 from .utils import ccxt_find_instrument, instrument_to_ccxt_symbol
@@ -123,7 +123,7 @@ class CcxtDataReader(DataReader):
         if dtype != "ohlc":
             return None, None
 
-        end_time = pd.Timestamp.now()
+        end_time = now_utc()
         start_time = end_time - self._max_history
         return start_time.to_datetime64(), end_time.to_datetime64()
 
@@ -153,14 +153,14 @@ class CcxtDataReader(DataReader):
         self, start: str | None, stop: str | None, timeframe: pd.Timedelta
     ) -> tuple[pd.Timestamp, pd.Timestamp]:
         if not stop:
-            stop = pd.Timestamp.now().isoformat()
+            stop = now_utc().isoformat()
         _start, _stop = handle_start_stop(start, stop, convert=lambda x: pd.Timestamp(x))
         assert isinstance(_stop, pd.Timestamp)
         if not _start:
             _start = _stop - timeframe * self._max_bars
         assert isinstance(_start, pd.Timestamp)
 
-        if _start < (_max_time := pd.Timestamp.now() - self._max_history):
+        if _start < (_max_time := now_utc() - self._max_history):
             _start = _max_time
 
         return _start, _stop

qubx/connectors/ccxt/utils.py

@@ -3,7 +3,6 @@ from typing import Any, Dict, List
 
 import numpy as np
 import pandas as pd
-from numba import njit
 
 import ccxt.pro as cxp
 from ccxt import BadSymbol
@@ -24,6 +23,7 @@ from qubx.utils.marketdata.ccxt import (
     ccxt_symbol_to_instrument,
 )
 from qubx.utils.orderbook import accumulate_orderbook_levels
+from qubx.utils.time import to_utc_naive
 
 from .exceptions import (
     CcxtLiquidationParsingError,
@@ -244,7 +244,7 @@ def ccxt_convert_orderbook(
 
 def ccxt_convert_liquidation(liq: dict[str, Any]) -> Liquidation:
     try:
-        _dt = pd.Timestamp(liq["datetime"]).replace(tzinfo=None).asm8
+        _dt = to_utc_naive(pd.Timestamp(liq["datetime"])).asm8
         return Liquidation(
             time=_dt,
             price=liq["price"],
@@ -265,7 +265,7 @@ def ccxt_convert_ticker(ticker: dict[str, Any]) -> Quote:
         Quote: The converted Quote object.
     """
     return Quote(
-        time=pd.Timestamp(ticker["datetime"]).replace(tzinfo=None).asm8,
+        time=to_utc_naive(pd.Timestamp(ticker["datetime"])).asm8,
         bid=ticker["bid"],
         ask=ticker["ask"],
         bid_size=ticker["bidVolume"],

qubx/core/basics.py

@@ -48,22 +48,18 @@ class FundingRate:
 class FundingPayment:
     """
     Represents a funding payment for a perpetual swap position.
-    
+
     Based on QuestDB schema: timestamp, symbol, funding_rate, funding_interval_hours
     """
+
     time: dt_64
-    symbol: str
     funding_rate: float
     funding_interval_hours: int
-    
+
     def __post_init__(self):
-        # Validation logic
-        if not self.symbol or self.symbol.strip() == '':
-            raise ValueError("Symbol cannot be empty")
-        
         if abs(self.funding_rate) > 1.0:
             raise ValueError(f"Invalid funding rate: {self.funding_rate} (must be between -1.0 and 1.0)")
-        
+
         if self.funding_interval_hours <= 0:
             raise ValueError(f"Invalid funding interval: {self.funding_interval_hours} (must be positive)")
 
@@ -575,7 +571,7 @@ class Position:
     # funding payment tracking
     cumulative_funding: float = 0.0  # cumulative funding paid (negative) or received (positive)
     funding_payments: list[FundingPayment]  # history of funding payments
-    last_funding_time: dt_64 = np.datetime64('NaT')  # last funding payment time
+    last_funding_time: dt_64 = np.datetime64("NaT")  # last funding payment time
 
     # - helpers for position processing
     _qty_multiplier: float = 1.0
@@ -616,7 +612,7 @@ class Position:
         self.maint_margin = 0.0
         self.cumulative_funding = 0.0
         self.funding_payments = []
-        self.last_funding_time = np.datetime64('NaT')  # type: ignore
+        self.last_funding_time = np.datetime64("NaT")  # type: ignore
         self.__pos_incr_qty = 0
         self._qty_multiplier = self.instrument.contract_size
 
@@ -634,8 +630,8 @@ class Position:
         self.last_update_conversion_rate = pos.last_update_conversion_rate
         self.maint_margin = pos.maint_margin
         self.cumulative_funding = pos.cumulative_funding
-        self.funding_payments = pos.funding_payments.copy() if hasattr(pos, 'funding_payments') else []
-        self.last_funding_time = pos.last_funding_time if hasattr(pos, 'last_funding_time') else np.datetime64('NaT')
+        self.funding_payments = pos.funding_payments.copy() if hasattr(pos, "funding_payments") else []
+        self.last_funding_time = pos.last_funding_time if hasattr(pos, "last_funding_time") else np.datetime64("NaT")
         self.__pos_incr_qty = pos.__pos_incr_qty
 
     @property
@@ -770,48 +766,47 @@ class Position:
     def apply_funding_payment(self, funding_payment: FundingPayment, mark_price: float) -> float:
         """
         Apply a funding payment to this position.
-        
+
         For perpetual swaps:
         - Positive funding rate: longs pay shorts
         - Negative funding rate: shorts pay longs
-        
+
         Args:
             funding_payment: The funding payment event
             mark_price: The mark price at the time of funding
-            
+
         Returns:
             The funding amount (negative if paying, positive if receiving)
         """
         if abs(self.quantity) < self.instrument.min_size:
             return 0.0
-            
+
         # Calculate funding amount
         # Funding = Position Size * Mark Price * Funding Rate
         funding_amount = self.quantity * mark_price * funding_payment.funding_rate
-        
+
         # For long positions with positive funding rate, amount is negative (paying)
         # For short positions with positive funding rate, amount is positive (receiving)
         funding_amount = -funding_amount
-        
+
         # Update position state
         self.cumulative_funding += funding_amount
         self.r_pnl += funding_amount  # Funding affects realized PnL
-        self.pnl += funding_amount    # And total PnL
-        
+        self.pnl += funding_amount  # And total PnL
+
         # Track funding payment history (limit to last 100)
         self.funding_payments.append(funding_payment)
         if len(self.funding_payments) > 100:
             self.funding_payments = self.funding_payments[-100:]
-            
+
         self.last_funding_time = funding_payment.time
-        
+
         return funding_amount
 
     def get_funding_pnl(self) -> float:
         """Get cumulative funding PnL for this position."""
         return self.cumulative_funding
 
-
     def is_open(self) -> bool:
         return abs(self.quantity) > self.instrument.min_size