Qubx 1.1.1.dev3__tar.gz → 1.1.2__tar.gz

{qubx-1.1.1.dev3 → qubx-1.1.2}/PKG-INFO

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

{qubx-1.1.1.dev3 → qubx-1.1.2}/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/src/qubx/_version.py

@@ -0,0 +1,24 @@
+# file generated by vcs-versioning
+# don't change, don't track in version control
+from __future__ import annotations
+
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
+
+version: str
+__version__: str
+__version_tuple__: tuple[int | str, ...]
+version_tuple: tuple[int | str, ...]
+commit_id: str | None
+__commit_id__: str | None
+
+__version__ = version = '1.1.2'
+__version_tuple__ = version_tuple = (1, 1, 2)
+
+__commit_id__ = commit_id = None

{qubx-1.1.1.dev3 → qubx-1.1.2}/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.1.dev3 → qubx-1.1.2}/src/qubx/backtester/management.py

@@ -573,7 +573,7 @@ class BacktestStorage:
         if self._is_cloud:
             self._setup_cloud_duckdb()
 
-    def get_log(self, backtest_id: str, config_name: str | None = None) -> str | None:
+    def get_log(self, backtest_id: str, config_name: str | None = None, max_lines: int = 1000) -> tuple[str, bool] | None:
         """
         Read the log file for a backtest run.
 
@@ -581,14 +581,29 @@ class BacktestStorage:
             backtest_id: Relative path within base_path.
             config_name: Config name (used for log filename).
                         If None, searches for any .log file.
+            max_lines: Maximum number of lines to return (from the end). 0 = unlimited.
 
         Returns:
-            Log file content as string, or None if not found.
+            (log_content, truncated) tuple, or None if not found.
         """
         run_dir = f"{self.base_path}{backtest_id.strip('/')}/"
 
         if config_name:
             log_path = f"{run_dir}{config_name}.log"
+        elif self._is_cloud:
+            try:
+                from pyarrow.fs import FileSelector, FileType
+
+                from qubx.utils.s3 import strip_scheme
+
+                client = S3Client(storage_options=self._storage_options)
+                entries = client.fs.get_file_info(FileSelector(strip_scheme(run_dir)))
+                log_files = [e.path for e in entries if e.type == FileType.File and e.path.endswith(".log")]
+                if not log_files:
+                    return None
+                log_path = f"s3://{log_files[0]}"
+            except Exception:
+                return None
         else:
             try:
                 files_df = self._conn.execute(f"SELECT file FROM glob('{run_dir}*.log')").df()
@@ -598,20 +613,30 @@ class BacktestStorage:
             except Exception:
                 return None
 
+        def _tail(content: str) -> tuple[str, bool]:
+            if not max_lines:
+                return content, False
+            lines = content.splitlines()
+            if len(lines) <= max_lines:
+                return content, False
+            return "\n".join(lines[-max_lines:]), True
+
         if self._is_cloud:
             try:
                 from qubx.utils.s3 import strip_scheme
 
                 client = S3Client(storage_options=self._storage_options)
                 with client.fs.open_input_stream(strip_scheme(log_path)) as f:
-                    return f.read().decode("utf-8")
+                    return _tail(f.read().decode("utf-8"))
             except Exception:
                 return None
         else:
             from pathlib import Path
 
             p = Path(log_path)
-            return p.read_text(encoding="utf-8", errors="replace") if p.is_file() else None
+            if not p.is_file():
+                return None
+            return _tail(p.read_text(encoding="utf-8", errors="replace"))
 
     def export_backtests_to_markdown(self, backtest_id: str, path: str, tags: tuple[str] | None = None):
         if tsr := self.load(backtest_id):

{qubx-1.1.1.dev3 → qubx-1.1.2}/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
@@ -131,6 +131,11 @@ class SimulationRunner:
         self._create_backtest_context()
         self._handle_ctx_subscriptions()
 
+    @property
+    def data_time_range(self) -> tuple[int, int] | None:
+        """Time range (ns) of historical data actually processed: (first, last), or None if no data arrived."""
+        return self._simulated_data_source.data_time_range
+
     def run(self, silent: bool = False, catch_keyboard_interrupt: bool = True, close_data_readers: bool = False):
         """
         Run the backtest from start to stop.
@@ -437,7 +442,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 +616,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.1.dev3 → qubx-1.1.2}/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
@@ -846,9 +846,17 @@ class SimulatedDataIterator(Iterator):
         self._slicer = None
         self._slicing_iterator = None
         self._current_time = None
+        self._first_data_time: int | None = None
         self._start = None
         self._stop = None
 
+    @property
+    def data_time_range(self) -> tuple[int, int] | None:
+        """Time range (ns) of historical data actually processed: (first, last), or None if no data arrived."""
+        if self._first_data_time is not None and self._current_time is not None:
+            return (self._first_data_time, self._current_time)
+        return None
+
     @property
     def emulation_time_indent_seconds(self) -> float:
         """
@@ -876,7 +884,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 +1007,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,16 +1109,17 @@ 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._first_data_time = None
         self._slicer = IteratedDataStreamsSlicer()
         return self
 
     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():
@@ -1137,6 +1146,8 @@ class SimulatedDataIterator(Iterator):
                 if t < self._current_time:
                     is_historical = True
                 else:
+                    if self._first_data_time is None:
+                        self._first_data_time = t
                     self._current_time = t
 
                 return instr, data_type, v, is_historical
@@ -1160,7 +1171,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.1.dev3 → qubx-1.1.2}/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.1.dev3 → qubx-1.1.2}/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,
     )