Qubx 1.1.2.dev6__tar.gz → 1.1.2.dev8__tar.gz

{qubx-1.1.2.dev6 → qubx-1.1.2.dev8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: Qubx
-Version: 1.1.2.dev6
+Version: 1.1.2.dev8
 Summary: Qubx - Quantitative Trading Framework
 Project-URL: homepage, https://xlydian.com
 Project-URL: repository, https://github.com/xLydianSoftware/Qubx

{qubx-1.1.2.dev6 → qubx-1.1.2.dev8}/src/qubx/__init__.py

@@ -47,6 +47,16 @@ def format_platform_identity(record) -> str:
     return ""
 
 
+def format_phase(record) -> str:
+    """Return a colored phase tag from record extras."""
+    phase = record["extra"].get("phase")
+    if phase == "warmup":
+        return "<yellow>[WARMUP]</yellow> "
+    elif phase == "live":
+        return "<green>[LIVE]</green> "
+    return ""
+
+
 def formatter(record):
     end = record["extra"].get("end", "\n")
     fmt = "<lvl>{message}</lvl>%s" % end
@@ -54,9 +64,10 @@ def formatter(record):
         fmt = "<cyan>{name}</cyan>:<cyan>{function}</cyan>:<cyan>{line}</cyan> - %s" % fmt
 
     identity = format_platform_identity(record)
+    phase = format_phase(record)
     prefix = (
-        "<green>{time:YYYY-MM-DD HH:mm:ss.SSS}</green> [ <level>%s</level> ] %s<cyan>({module})</cyan> "
-        % (record["level"].icon, identity)
+        "<green>{time:YYYY-MM-DD HH:mm:ss.SSS}</green> [ <level>%s</level> ] %s%s<cyan>({module})</cyan> "
+        % (record["level"].icon, identity, phase)
     )
 
     if record["exception"] is not None:
@@ -158,17 +169,36 @@ class QubxLogConfig:
         )
         logger = logger.opt(colors=colorize)
 
+    _bot_id: str | None = None
+    _instance_id: str | None = None
+    _phase: str | None = None
+
     @staticmethod
-    def bind_platform_identity(bot_id: str | None = None, instance_id: str | None = None):
-        """Bind platform identity fields (bot_id, instance_id) to all log messages globally."""
+    def _update_patcher():
+        """Reconfigure loguru with a single patcher that applies all bound fields."""
         def patcher(record):
-            if bot_id:
-                record["extra"]["bot_id"] = bot_id
-            if instance_id:
-                record["extra"]["instance_id"] = instance_id
+            if QubxLogConfig._bot_id:
+                record["extra"]["bot_id"] = QubxLogConfig._bot_id
+            if QubxLogConfig._instance_id:
+                record["extra"]["instance_id"] = QubxLogConfig._instance_id
+            if QubxLogConfig._phase:
+                record["extra"]["phase"] = QubxLogConfig._phase
 
         logger.configure(patcher=patcher)
 
+    @staticmethod
+    def bind_platform_identity(bot_id: str | None = None, instance_id: str | None = None):
+        """Bind platform identity fields (bot_id, instance_id) to all log messages globally."""
+        QubxLogConfig._bot_id = bot_id
+        QubxLogConfig._instance_id = instance_id
+        QubxLogConfig._update_patcher()
+
+    @staticmethod
+    def bind_phase(phase: str | None):
+        """Bind phase (warmup/live) to all log messages globally."""
+        QubxLogConfig._phase = phase
+        QubxLogConfig._update_patcher()
+
 
 QubxLogConfig.setup_logger()
 

{qubx-1.1.2.dev6 → qubx-1.1.2.dev8}/src/qubx/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '1.1.2.dev6'
-__version_tuple__ = version_tuple = (1, 1, 2, 'dev6')
+__version__ = version = '1.1.2.dev8'
+__version_tuple__ = version_tuple = (1, 1, 2, 'dev8')
 
 __commit_id__ = commit_id = None

{qubx-1.1.2.dev6 → qubx-1.1.2.dev8}/src/qubx/backtester/data.py

@@ -1,8 +1,6 @@
 from collections import defaultdict
 from typing import TypeVar
 
-import pandas as pd
-
 from qubx import logger
 from qubx.backtester.simulated_data import SimulatedDataIterator
 from qubx.core.basics import (
@@ -12,6 +10,7 @@ from qubx.core.basics import (
 )
 from qubx.core.interfaces import IDataProvider
 from qubx.core.series import Bar, Quote
+from qubx.utils.time import to_timedelta, to_timestamp
 
 from .account import SimulatedAccountProcessor
 from .utils import SimulatedTimeProvider
@@ -144,8 +143,8 @@ class SimulatedDataProvider(IDataProvider):
             self._data_source.set_warmup_period(si[0], warm_period)
 
     def get_ohlc(self, instrument: Instrument, timeframe: str, nbarsback: int) -> list[Bar]:
-        start = pd.Timestamp(self.time_provider.time())
-        end = start - nbarsback * pd.Timedelta(timeframe)
+        start = to_timestamp(self.time_provider.time())
+        end = start - nbarsback * to_timedelta(timeframe)
         return self._data_source.get_ohlc(instrument, timeframe, start, end)
 
     def get_quote(self, instrument: Instrument) -> Quote | None:

{qubx-1.1.2.dev6 → qubx-1.1.2.dev8}/src/qubx/backtester/runner.py

@@ -34,7 +34,7 @@ from qubx.health import DummyHealthMonitor
 from qubx.loggers.inmemory import InMemoryLogsWriter
 from qubx.pandaz.utils import _frame_to_str
 from qubx.utils.runner.configs import PrefetchConfig
-from qubx.utils.time import now_ns
+from qubx.utils.time import now_ns, to_timedelta
 
 from .account import SimulatedAccountProcessor
 from .broker import SimulatedBroker
@@ -437,7 +437,7 @@ class SimulationRunner:
         # - TimeGuard is applied by callers that need it (aux/strategy-facing access).
         # - Main simulation data (DataPump) must NOT be time-guarded: DataPump provides
         #   its own explicit [start, end] window and needs to read the full range upfront.
-        _prefetch_period = str(min(self.stop - self.start, pd.Timedelta(prefetch_cfg.prefetch_period)))
+        _prefetch_period = str(min(self.stop - self.start, to_timedelta(prefetch_cfg.prefetch_period)))
         return CachedStorage(
             storage, prefetch_period=_prefetch_period, cache_factory=lambda: MemoryCache(prefetch_cfg.cache_size_mb)
         )
@@ -611,10 +611,8 @@ class SimulationRunner:
 
         _account_processors = {}
         for exchange in self.setup.exchanges:
-            _initial_capital = self.setup.capital
-            if isinstance(_initial_capital, dict):
-                _initial_capital = _initial_capital[exchange]
-            assert isinstance(_initial_capital, (float, int))
+            assert isinstance(self.setup.capital, dict)
+            _initial_capital = self.setup.capital[exchange]
             _account_processors[exchange] = SimulatedAccountProcessor(
                 account_id=self.account_id,
                 exchange=_exchange_to_simulated_exchange[exchange],

{qubx-1.1.2.dev6 → qubx-1.1.2.dev8}/src/qubx/backtester/simulated_data.py

@@ -16,7 +16,7 @@ from qubx.data.containers import IRawContainer, RawData, RawMultiData
 from qubx.data.storage import IDataTransformer, IReader, IStorage, Transformable
 from qubx.data.storages.utils import find_column_index_in_list
 from qubx.data.transformers import TypedRecords
-from qubx.utils.time import convert_times_to_ns, infer_series_frequency
+from qubx.utils.time import convert_times_to_ns, infer_series_frequency, to_timedelta, to_timestamp
 
 
 class EmulatedUpdatesFromOHLC(IDataTransformer):
@@ -26,7 +26,7 @@ class EmulatedUpdatesFromOHLC(IDataTransformer):
 
     @staticmethod
     def timedelta_to_numpy(x: str) -> int:
-        return pd.Timedelta(x).to_numpy().item()
+        return to_timedelta(x).to_numpy().item()
 
     D1, H1 = timedelta_to_numpy("1D"), timedelta_to_numpy("1h")
     MS1 = 1_000_000
@@ -329,9 +329,9 @@ class RawSymbolBuffer:
         if isinstance(value, pd.Timestamp):
             return value.value
         if isinstance(value, np.datetime64):
-            return pd.Timestamp(value).value
+            return to_timestamp(value).value
         # - fallback: try to convert via pd.Timestamp
-        return pd.Timestamp(value).value
+        return to_timestamp(value).value
 
     def activate(self):
         self._active = True
@@ -367,10 +367,10 @@ class RawSymbolBuffer:
         # - dedup: filter out rows already in buffer using native pyarrow comparison
         if self._watermark > 0:
             if pa.types.is_timestamp(time_col.type):
-                wm_scalar = pa.scalar(pd.Timestamp(self._watermark, unit="ns"), type=time_col.type)
+                wm_scalar = pa.scalar(to_timestamp(self._watermark, unit="ns"), type=time_col.type)
             elif pa.types.is_date(time_col.type):
                 # - date32 stores days since epoch; watermark is ns, convert to datetime.date
-                wm_scalar = pa.scalar(pd.Timestamp(self._watermark, unit="ns").date(), type=time_col.type)
+                wm_scalar = pa.scalar(to_timestamp(self._watermark, unit="ns").date(), type=time_col.type)
             else:
                 wm_scalar = pa.scalar(self._watermark, type=time_col.type)
             mask = pa.compute.greater(time_col, wm_scalar)
@@ -398,7 +398,7 @@ class RawSymbolBuffer:
         return len(self._batches)
 
     def __repr__(self) -> str:
-        _wm = pd.Timestamp(self._watermark, unit="ns") if self._watermark else "N/A"
+        _wm = to_timestamp(self._watermark, unit="ns") if self._watermark else "N/A"
         return f"RawSymbolBuffer({self._symbol}, chunks={len(self)}, wm={_wm}, active={self._active})"
 
 
@@ -644,13 +644,13 @@ class DataPump:
         Starts backend reader, creates MemReaders for all symbols.
         Returns dict suitable for slicer.put().
         """
-        self._end = pd.Timestamp(end)
+        self._end = to_timestamp(end)
         symbols = self._active_symbols()
         if not symbols:
             return {}
 
         # - all symbols need warmup on first read
-        read_start = pd.Timestamp(start)
+        read_start = to_timestamp(start)
         if self._warmup_period:
             read_start = read_start - self._warmup_period
             self._warmed.update(symbols)
@@ -686,7 +686,7 @@ class DataPump:
             dict of NEW MemReaders only (for slicer.put())
         """
         if end is not None:
-            self._end = pd.Timestamp(end)
+            self._end = to_timestamp(end)
 
         symbols = self._active_symbols()
         if not symbols:
@@ -695,7 +695,7 @@ class DataPump:
 
         # - determine start time: extend into past if new symbols need warmup
         new_symbols = [s for s in symbols if s not in self._warmed]
-        read_start = pd.Timestamp(current_time)
+        read_start = to_timestamp(current_time)
 
         if new_symbols and self._warmup_period:
             read_start = read_start - self._warmup_period
@@ -876,7 +876,7 @@ class SimulatedDataIterator(Iterator):
     def set_warmup_period(self, subscription: str, warmup_period: str | None = None):
         if warmup_period:
             access_key, _, _ = self._parse_subscription_spec(subscription)
-            self._warmups[access_key] = pd.Timedelta(warmup_period)
+            self._warmups[access_key] = to_timedelta(warmup_period)
 
     def _parse_subscription_spec(self, subscription: str) -> tuple[str, str, dict[str, object]]:
         _subtype, _params = DataType.from_str(subscription)
@@ -999,7 +999,7 @@ class SimulatedDataIterator(Iterator):
 
             # - if simulation is running, restart read to include new symbols
             if self.is_running and new_instruments:
-                new_mem_readers = pump.restart_read(pd.Timestamp(self._current_time, unit="ns"), self._stop)  # type: ignore
+                new_mem_readers = pump.restart_read(to_timestamp(self._current_time, unit="ns"), self._stop)  # type: ignore
                 if new_mem_readers and self._slicer is not None:
                     self._slicer.put(new_mem_readers)
 
@@ -1101,8 +1101,8 @@ class SimulatedDataIterator(Iterator):
         return self._current_time is not None
 
     def create_iterable(self, start: str | pd.Timestamp, stop: str | pd.Timestamp) -> Iterator:
-        self._start = pd.Timestamp(start)
-        self._stop = pd.Timestamp(stop)
+        self._start = to_timestamp(start)
+        self._stop = to_timestamp(stop)
         self._current_time = None
         self._slicer = IteratedDataStreamsSlicer()
         return self
@@ -1110,7 +1110,7 @@ class SimulatedDataIterator(Iterator):
     def __iter__(self) -> Iterator:
         assert self._start is not None and self._stop is not None
         assert self._slicer is not None
-        self._current_time = int(pd.Timestamp(self._start).timestamp() * 1e9)
+        self._current_time = int(to_timestamp(self._start).timestamp() * 1e9)
 
         # - initial read for all pumps
         for pump in self._pumps.values():
@@ -1160,7 +1160,7 @@ class SimulatedDataIterator(Iterator):
         assert isinstance(t_records, Transformable)
 
         return self._process_bar_records(
-            t_records.transform(TypedRecords()), time_as_nsec(start), pd.Timedelta(timeframe).asm8.item()
+            t_records.transform(TypedRecords()), time_as_nsec(start), to_timedelta(timeframe).asm8.item()
         )
 
     def _process_bar_records(self, records: list[Bar], cut_time_ns: int, timeframe_ns: int) -> list[Bar]:

{qubx-1.1.2.dev6 → qubx-1.1.2.dev8}/src/qubx/backtester/utils.py

@@ -25,6 +25,7 @@ from qubx.core.utils import time_delta_to_str
 from qubx.data.storage import IStorage
 from qubx.utils.misc import safe_dtype_timeframe
 from qubx.utils.runner.configs import PrefetchConfig
+from qubx.utils.time import to_timedelta
 
 SymbolOrInstrument_t: TypeAlias = str | Instrument
 ExchangeName_t: TypeAlias = str
@@ -45,7 +46,7 @@ StrategiesDecls_t: TypeAlias = (
 
 
 def _timedelta_to_numpy(x: str | int) -> int:
-    return pd.Timedelta(x).to_numpy().item()
+    return to_timedelta(x).to_numpy().item()
 
 
 DEFAULT_DAILY_SESSION = (_timedelta_to_numpy("00:00:00.100"), _timedelta_to_numpy("23:59:59.900"))
@@ -98,6 +99,13 @@ class SimulationSetup:
     accurate_stop_orders_execution: bool = False
     enable_funding: bool = False
 
+    def __post_init__(self) -> None:
+        # Normalize capital to a per-exchange dict: split evenly when a single float is given
+        if isinstance(self.capital, (int, float)):
+            n = len(self.exchanges)
+            per_exchange = float(self.capital) / n if n > 0 else float(self.capital)
+            self.capital = {exchange: per_exchange for exchange in self.exchanges}
+
     def __str__(self) -> str:
         return f"{self.name} {self.setup_type} capital {self.capital} {self.base_currency} for [{','.join(map(lambda x: x.symbol, self.instruments))}] @ {self.exchanges}[{self.commissions}]"
 
@@ -133,10 +141,11 @@ class SimulatedLogFormatter:
         else:
             now = self.time_provider.time().astype("datetime64[us]").item().strftime("%Y-%m-%d %H:%M:%S.%f")[:-3]
 
-        from qubx import format_platform_identity
+        from qubx import format_phase, format_platform_identity
 
         identity = format_platform_identity(record)
-        prefix = f"<lc>{now}</lc> [<level>{record['level'].icon}</level>] {identity}<cyan>({{module}})</cyan> "
+        phase = format_phase(record)
+        prefix = f"<lc>{now}</lc> [<level>{record['level'].icon}</level>] {identity}{phase}<cyan>({{module}})</cyan> "
 
         if record["exception"] is not None:
             record["extra"]["stack"] = stackprinter.format(record["exception"], style="darkbg3")
@@ -521,15 +530,15 @@ def _adjust_open_close_time_indent_secs(timeframe: pd.Timedelta | None, original
         return original_indent_secs
 
     # - if it triggers at daily+ bar let's assume this bar is 'closed' 5 min before exact closing time
-    if timeframe >= pd.Timedelta("1d"):
+    if timeframe >= to_timedelta("1d"):
         return max(original_indent_secs, 5 * 60)
 
     # - if it triggers at 1Min+ bar let's assume this bar is 'closed' 5 sec before exact closing time
-    if timeframe >= pd.Timedelta("1min"):
+    if timeframe >= to_timedelta("1min"):
         return max(original_indent_secs, 5)
 
     # - for all sub-minute timeframes just use 1 sec shift
-    if timeframe > pd.Timedelta("1s"):
+    if timeframe > to_timedelta("1s"):
         return max(original_indent_secs, 1)
 
     # - for rest just keep original indent
@@ -538,9 +547,9 @@ def _adjust_open_close_time_indent_secs(timeframe: pd.Timedelta | None, original
 
 def _get_default_warmup_period(base_subscription: str, in_timeframe: pd.Timedelta | None) -> pd.Timedelta:
     if in_timeframe is None or base_subscription in [DataType.QUOTE, DataType.TRADE, DataType.ORDERBOOK]:
-        return pd.Timedelta("1Min")
+        return to_timedelta("1Min")
 
-    if in_timeframe < pd.Timedelta("1h"):
+    if in_timeframe < to_timedelta("1h"):
         return 5 * in_timeframe
 
     return 2 * in_timeframe

{qubx-1.1.2.dev6 → qubx-1.1.2.dev8}/src/qubx/cli/commands.py

@@ -230,15 +230,6 @@ def run(
 @click.option(
     "--report", "-r", default=None, type=str, help="Output directory for simulation reports.", show_default=True
 )
-@click.option(
-    "--log",
-    "-L",
-    "log_to_file",
-    is_flag=True,
-    default=False,
-    help="Write simulation logs to a file in the output directory.",
-    show_default=True,
-)
 @click.option(
     "--name",
     "-n",
@@ -261,7 +252,6 @@ def simulate(
     end: str | None,
     output: str | None,
     report: str | None,
-    log_to_file: bool,
     name: str | None,
     log_file: str | None,
 ):
@@ -276,7 +266,7 @@ def simulate(
     logo()
     logger.info(f"Process PID: <g>{os.getpid()}</g>")
     simulate_strategy(
-        config_file, output, start, end, report, log_to_file, name=name, log_file=log_file,
+        config_file, output, start, end, report, name=name, log_file=log_file,
     )
 
 

{qubx-1.1.2.dev6 → qubx-1.1.2.dev8}/src/qubx/connectors/ccxt/account.py

@@ -7,7 +7,6 @@ from typing import TYPE_CHECKING, Awaitable, Callable
 
 import ccxt.pro as cxp
 import numpy as np
-import pandas as pd
 from ccxt import ExchangeClosedByUser, ExchangeError, ExchangeNotAvailable, NetworkError
 
 from qubx import logger
@@ -29,6 +28,7 @@ from qubx.core.helpers import extract_price
 from qubx.core.interfaces import IHealthMonitor, ISubscriptionManager
 from qubx.utils.marketdata.ccxt import ccxt_symbol_to_instrument
 from qubx.utils.misc import AsyncThreadLoop
+from qubx.utils.time import to_timedelta
 
 from .exceptions import CcxtSymbolNotRecognized
 from .exchange_manager import ExchangeManager
@@ -252,11 +252,11 @@ class CcxtAccountProcessor(BasicAccountProcessor):
         interval: str,
         backoff: str | None = None,
     ):
-        sleep_time = pd.Timedelta(interval).total_seconds()
+        sleep_time = to_timedelta(interval).total_seconds()
         retries = 0
 
         if backoff is not None:
-            sleep_time = pd.Timedelta(backoff).total_seconds()
+            sleep_time = to_timedelta(backoff).total_seconds()
             await asyncio.sleep(sleep_time)
 
         while self.channel.control.is_set():
@@ -308,7 +308,7 @@ class CcxtAccountProcessor(BasicAccountProcessor):
     async def _update_subscriptions(self) -> None:
         """Subscribe to required instruments"""
         assert self._subscription_manager is not None
-        await asyncio.sleep(pd.Timedelta(self.subscription_interval).total_seconds())
+        await asyncio.sleep(to_timedelta(self.subscription_interval).total_seconds())
 
         # if required instruments have changed, subscribe to them
         if not self._latest_instruments.issuperset(self._required_instruments):
@@ -380,7 +380,7 @@ class CcxtAccountProcessor(BasicAccountProcessor):
             current_pos.set_external_maint_margin(new_pos.maint_margin)
 
     def _get_start_time_in_ms(self, days_before: int) -> int:
-        return (self.time_provider.time() - days_before * pd.Timedelta("1d")).asm8.item() // 1000000  # type: ignore
+        return (self.time_provider.time() - days_before * to_timedelta("1d")).asm8.item() // 1000000  # type: ignore
 
     def _is_our_order(self, order: Order) -> bool:
         if order.client_id is None:
@@ -408,7 +408,7 @@ class CcxtAccountProcessor(BasicAccountProcessor):
         _fetch_instruments: list[Instrument] = []
         for instr in instruments:
             _dt, _ = self._instrument_to_last_price.get(instr, (None, None))
-            if _dt is None or pd.Timedelta(_current_time - _dt) > pd.Timedelta(self.balance_interval):  # type: ignore
+            if _dt is None or to_timedelta(_current_time - _dt) > to_timedelta(self.balance_interval):  # type: ignore
                 _fetch_instruments.append(instr)
 
         _symbol_to_instrument = {instr.symbol: instr for instr in instruments}

{qubx-1.1.2.dev6 → qubx-1.1.2.dev8}/src/qubx/connectors/ccxt/broker.py

@@ -3,7 +3,6 @@ import traceback
 from typing import TYPE_CHECKING, Any
 
 import ccxt
-import pandas as pd
 from ccxt.base.errors import ExchangeError
 
 from qubx import logger
@@ -24,6 +23,7 @@ from qubx.core.interfaces import (
     ITimeProvider,
 )
 from qubx.utils.misc import AsyncThreadLoop
+from qubx.utils.time import to_timedelta
 
 from .exchange_manager import ExchangeManager
 from .utils import ccxt_convert_order_info, instrument_to_ccxt_symbol
@@ -545,7 +545,7 @@ class CcxtBroker(IBroker):
 
             # Common retry logic for all retryable errors
             current_time = self.time_provider.time()
-            elapsed_seconds = pd.Timedelta(current_time - start_time).total_seconds()
+            elapsed_seconds = to_timedelta(current_time - start_time).total_seconds()
             retries += 1
 
             if elapsed_seconds >= timeout_delta or retries >= self.max_cancel_retries:

{qubx-1.1.2.dev6 → qubx-1.1.2.dev8}/src/qubx/connectors/ccxt/data.py

@@ -2,8 +2,6 @@ import asyncio
 from collections import defaultdict
 from typing import TYPE_CHECKING, Dict, List, Optional, Set, Tuple
 
-import pandas as pd
-
 # CCXT exceptions are now handled in ConnectionManager
 from qubx import logger
 from qubx.connectors.ccxt.utils import ccxt_convert_timeframe_to_exchange_format
@@ -12,6 +10,7 @@ from qubx.core.basics import CtrlChannel, DataType, Instrument, ITimeProvider
 from qubx.core.interfaces import IDataProvider, IHealthMonitor
 from qubx.core.series import Bar, Quote
 from qubx.utils.misc import AsyncThreadLoop
+from qubx.utils.time import to_timedelta, to_timestamp
 
 from .connection_manager import ConnectionManager
 from .exchange_manager import ExchangeManager
@@ -319,8 +318,8 @@ class CcxtDataProvider(IDataProvider):
         return _key is None or _key == ""
 
     def _time_msec_nbars_back(self, timeframe: str, nbarsback: int = 1) -> int:
-        now = pd.Timestamp(self.time_provider.time())
-        delta = pd.to_timedelta(timeframe) * nbarsback
+        now = to_timestamp(self.time_provider.time())
+        delta = to_timedelta(timeframe) * nbarsback
         return int((now - delta).value // 1_000_000)
 
     def _get_exch_timeframe(self, timeframe: str) -> str:

{qubx-1.1.2.dev6 → qubx-1.1.2.dev8}/src/qubx/connectors/ccxt/exchanges/binance/exchange.py

@@ -16,7 +16,7 @@ from ccxt.base.types import (
     Strings,
 )
 
-from qubx.utils.time import now_utc
+from qubx.utils.time import now_utc, to_timedelta
 
 from ..base import CcxtFuturePatchMixin
 
@@ -418,7 +418,7 @@ class BinanceQVUSDM(cxp.binanceusdm, BinanceQV):
         super().__init__(*args, **kwargs)
         self._funding_intervals = {}
         self._funding_intervals_updated_at = None
-        self._funding_interval_cache_ttl = cast(pd.Timedelta, pd.Timedelta(minutes=10))
+        self._funding_interval_cache_ttl = to_timedelta(minutes=10)
 
     def describe(self):
         """

{qubx-1.1.2.dev6 → qubx-1.1.2.dev8}/src/qubx/connectors/ccxt/handlers/ohlc.py

@@ -7,13 +7,13 @@ Handles subscription and warmup for OHLC (candlestick) data.
 import asyncio
 from typing import Set
 
-import pandas as pd
 from ccxt import BadSymbol
 
 from qubx import logger
 from qubx.core.basics import CtrlChannel, DataType, Instrument
 from qubx.core.exceptions import NotSupported
 from qubx.core.series import Bar, Quote
+from qubx.utils.time import to_timedelta
 
 from ..subscription_config import SubscriptionConfiguration
 from ..utils import ccxt_find_instrument, create_market_type_batched_subscriber, instrument_to_ccxt_symbol
@@ -89,9 +89,9 @@ class OhlcDataHandler(BaseDataTypeHandler):
             warmup_period: Period to warm up (e.g., "30d", "1000h")
             timeframe: Timeframe for OHLC data (e.g., "1m", "5m", "1h")
         """
-        nbarsback = pd.Timedelta(warmup_period) // pd.Timedelta(timeframe)
+        nbarsback = to_timedelta(warmup_period) // to_timedelta(timeframe)
         exch_timeframe = self._data_provider._get_exch_timeframe(timeframe)
-        _tf_msec = pd.to_timedelta(timeframe).value // 1_000_000
+        _tf_msec = to_timedelta(timeframe).value // 1_000_000
 
         for instrument in instruments:
             start_since = self._data_provider._time_msec_nbars_back(timeframe, nbarsback)
@@ -149,7 +149,7 @@ class OhlcDataHandler(BaseDataTypeHandler):
         exch_timeframe = self._data_provider._get_exch_timeframe(timeframe)
 
         loaded_bars = {}
-        _tf_msec = pd.to_timedelta(timeframe).value // 1_000_000  # convert to msec
+        _tf_msec = to_timedelta(timeframe).value // 1_000_000  # convert to msec
 
         # - retrieve OHLC data from exchange by chunks as some providers limit number of bars per request
         # Loop until we have enough bars or exchange stops returning data.

{qubx-1.1.2.dev6 → qubx-1.1.2.dev8}/src/qubx/connectors/ccxt/utils.py

@@ -26,7 +26,7 @@ from qubx.utils.marketdata.ccxt import (
     ccxt_symbol_to_instrument,
 )
 from qubx.utils.orderbook import accumulate_orderbook_levels
-from qubx.utils.time import now_utc
+from qubx.utils.time import now_utc, to_timestamp
 
 from .exceptions import (
     CcxtLiquidationParsingError,
@@ -103,7 +103,7 @@ def ccxt_convert_deal_info(raw: Dict[str, Any]) -> Deal:
     return Deal(
         id=raw["id"],
         order_id=raw["order"],
-        time=pd.Timestamp(raw["timestamp"], unit="ms"),  # type: ignore
+        time=to_timestamp(raw["timestamp"], unit="ms"),
         amount=float(raw["amount"]) * (-1 if raw["side"] == "sell" else +1),
         price=float(raw["price"]),
         aggressive=raw["takerOrMaker"] == "taker",

{qubx-1.1.2.dev6 → qubx-1.1.2.dev8}/src/qubx/connectors/tardis/data.py

@@ -15,6 +15,7 @@ from qubx.core.interfaces import IDataProvider, IHealthMonitor
 from qubx.core.series import Bar, Quote, Trade
 from qubx.health import DummyHealthMonitor
 from qubx.utils.misc import AsyncThreadLoop, synchronized
+from qubx.utils.time import to_timedelta
 
 from .utils import (
     tardis_convert_orderbook,
@@ -244,7 +245,7 @@ class TardisDataProvider(IDataProvider):
 
         # Calculate start time based on timeframe and nbarsback
         end_time = self.time_provider.time()
-        start_time = end_time - pd.Timedelta(timeframe) * nbarsback
+        start_time = end_time - to_timedelta(timeframe) * nbarsback
 
         # Format dates for Tardis API
         start_str = pd.Timestamp(start_time).strftime("%Y-%m-%d")
@@ -521,7 +522,7 @@ class TardisDataProvider(IDataProvider):
         """Fetch historical OHLC data for warmup."""
         # Calculate start and end time
         end_time = self.time_provider.time()
-        start_time = end_time - pd.Timedelta(period)
+        start_time = end_time - to_timedelta(period)
 
         # Format dates for Tardis API
         start_str = pd.Timestamp(start_time).strftime("%Y-%m-%d")
@@ -578,7 +579,7 @@ class TardisDataProvider(IDataProvider):
         """Fetch historical trade data for warmup."""
         # Calculate start and end time
         end_time = self.time_provider.time()
-        start_time = end_time - pd.Timedelta(period)
+        start_time = end_time - to_timedelta(period)
 
         # Format dates for Tardis API
         start_str = pd.Timestamp(start_time).strftime("%Y-%m-%d")
@@ -632,7 +633,7 @@ class TardisDataProvider(IDataProvider):
         """Fetch historical orderbook data for warmup."""
         # Calculate start and end time
         end_time = self.time_provider.time()
-        start_time = end_time - pd.Timedelta(period)
+        start_time = end_time - to_timedelta(period)
 
         # Format dates for Tardis API
         start_str = pd.Timestamp(start_time).strftime("%Y-%m-%d")
@@ -724,7 +725,7 @@ class TardisDataProvider(IDataProvider):
 
         # Otherwise, try to parse the timeframe
         try:
-            pd_timedelta = pd.Timedelta(timeframe)
+            pd_timedelta = to_timedelta(timeframe)
             return f"{int(pd_timedelta.total_seconds() * 1000)}ms"
         except:
             # Fallback to default 1m if parsing fails