Qubx 0.6.35__tar.gz → 0.6.37__tar.gz

{qubx-0.6.35 → qubx-0.6.37}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: Qubx
-Version: 0.6.35
+Version: 0.6.37
 Summary: Qubx - Quantitative Trading Framework
 Author: Dmitry Marienko
 Author-email: dmitry.marienko@xlydian.com

{qubx-0.6.35 → qubx-0.6.37}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "poetry.core.masonry.api"
 
 [tool.poetry]
 name = "Qubx"
-version = "0.6.35"
+version = "0.6.37"
 description = "Qubx - Quantitative Trading Framework"
 authors = [ "Dmitry Marienko <dmitry.marienko@xlydian.com>", "Yuriy Arabskyy <yuriy.arabskyy@xlydian.com>",]
 readme = "README.md"

{qubx-0.6.35 → qubx-0.6.37}/src/qubx/connectors/ccxt/broker.py

@@ -14,7 +14,7 @@ from qubx.core.basics import (
     Order,
     OrderSide,
 )
-from qubx.core.errors import OrderCancellationError, OrderCreationError, create_error_event
+from qubx.core.errors import ErrorLevel, OrderCancellationError, OrderCreationError, create_error_event
 from qubx.core.exceptions import BadRequest, InvalidOrderParameters
 from qubx.core.interfaces import (
     IAccountProcessor,
@@ -61,6 +61,57 @@ class CcxtBroker(IBroker):
     def is_simulated_trading(self) -> bool:
         return False
 
+    def _post_order_error_to_databus(
+        self,
+        error: Exception,
+        instrument: Instrument,
+        order_side: OrderSide,
+        order_type: str,
+        amount: float,
+        price: float | None,
+        client_id: str | None,
+        time_in_force: str,
+        **options,
+    ):
+        level = ErrorLevel.LOW
+        match error:
+            case ccxt.InsufficientFunds():
+                level = ErrorLevel.HIGH
+                logger.error(
+                    f"(::create_order) INSUFFICIENT FUNDS for {order_side} {amount} {order_type} for {instrument.symbol} : {error}"
+                )
+            case ccxt.OrderNotFillable():
+                level = ErrorLevel.LOW
+                logger.error(
+                    f"(::create_order) ORDER NOT FILLEABLE for {order_side} {amount} {order_type} for [{instrument.symbol}] : {error}"
+                )
+            case ccxt.InvalidOrder():
+                level = ErrorLevel.LOW
+                logger.error(
+                    f"(::create_order) INVALID ORDER for {order_side} {amount} {order_type} for {instrument.symbol} : {error}"
+                )
+            case ccxt.BadRequest():
+                level = ErrorLevel.LOW
+                logger.error(
+                    f"(::create_order) BAD REQUEST for {order_side} {amount} {order_type} for {instrument.symbol} : {error}"
+                )
+            case _:
+                level = ErrorLevel.MEDIUM
+                logger.error(f"(::create_order) Unexpected error: {error}")
+
+        error_event = OrderCreationError(
+            timestamp=self.time_provider.time(),
+            message=f"Error message: {str(error)}",
+            level=level,
+            instrument=instrument,
+            amount=amount,
+            price=price,
+            order_type=order_type,
+            side=order_side,
+            error=error,
+        )
+        self.channel.send(create_error_event(error_event))
+
     def send_order_async(
         self,
         instrument: Instrument,
@@ -93,33 +144,20 @@ class CcxtBroker(IBroker):
                 )
 
                 if error:
-                    # Create and send an error event through the channel
-                    error_event = OrderCreationError(
-                        timestamp=self.time_provider.time(),
-                        message=str(error),
-                        instrument=instrument,
-                        amount=amount,
-                        price=price,
-                        order_type=order_type,
-                        side=order_side,
+                    self._post_order_error_to_databus(
+                        error, instrument, order_side, order_type, amount, price, client_id, time_in_force, **options
                     )
-                    self.channel.send(create_error_event(error_event))
-                    return None
+                    order = None
+
                 return order
+
             except Exception as err:
                 # Catch any unexpected errors and send them through the channel as well
-                logger.error(f"Unexpected error in async order creation: {err}")
+                logger.error(f"{self.__class__.__name__} :: Unexpected error in async order creation: {err}")
                 logger.error(traceback.format_exc())
-                error_event = OrderCreationError(
-                    timestamp=self.time_provider.time(),
-                    message=f"Unexpected error: {str(err)}",
-                    instrument=instrument,
-                    amount=amount,
-                    price=price,
-                    order_type=order_type,
-                    side=order_side,
+                self._post_order_error_to_databus(
+                    err, instrument, order_side, order_type, amount, price, client_id, time_in_force, **options
                 )
-                self.channel.send(create_error_event(error_event))
                 return None
 
         # Submit the task to the async loop
@@ -135,7 +173,7 @@ class CcxtBroker(IBroker):
         client_id: str | None = None,
         time_in_force: str = "gtc",
         **options,
-    ) -> Order:
+    ) -> Order | None:
         """
         Submit an order and wait for the result. Exceptions will be raised on errors.
 
@@ -169,14 +207,16 @@ class CcxtBroker(IBroker):
 
             # If there was no error but also no order, something went wrong
             if not order and not self.enable_create_order_ws:
-                raise ExchangeError("Order creation failed with no specific error")
+                raise ExchangeError(f"{self.__class__.__name__} :: Order creation failed with no specific error")
 
             return order
 
         except Exception as err:
             # This will catch any errors from future.result() or if we explicitly raise an error
-            logger.error(f"Error in send_order: {err}")
-            raise
+            self._post_order_error_to_databus(
+                err, instrument, order_side, order_type, amount, price, client_id, time_in_force, **options
+            )
+            return None
 
     def cancel_order(self, order_id: str) -> Order | None:
         orders = self.account.get_orders()
@@ -231,25 +271,7 @@ class CcxtBroker(IBroker):
             logger.info(f"New order {order}")
             return order, None
 
-        except ccxt.OrderNotFillable as exc:
-            logger.error(
-                f"(::_create_order) [{instrument.symbol}] ORDER NOT FILLEABLE for {order_side} {amount} {order_type} : {exc}"
-            )
-            return None, exc
-        except ccxt.InvalidOrder as exc:
-            logger.error(
-                f"(::_create_order) INVALID ORDER for {order_side} {amount} {order_type} for {instrument.symbol} : {exc}"
-            )
-            return None, exc
-        except ccxt.BadRequest as exc:
-            logger.error(
-                f"(::_create_order) BAD REQUEST for {order_side} {amount} {order_type} for {instrument.symbol} : {exc}"
-            )
-            return None, exc
         except Exception as err:
-            logger.error(
-                f"(::_create_order) {order_side} {amount} {order_type} for {instrument.symbol} exception : {err}"
-            )
             return None, err
 
     def _prepare_order_payload(
@@ -371,6 +393,8 @@ class CcxtBroker(IBroker):
                             order_id=order_id,
                             message=f"Timeout reached for canceling order {order_id}",
                             instrument=instrument,
+                            level=ErrorLevel.LOW,
+                            error=None,
                         )
                     )
                 )

{qubx-0.6.35 → qubx-0.6.37}/src/qubx/connectors/ccxt/exchanges/__init__.py

@@ -25,7 +25,7 @@ EXCHANGE_ALIASES = {
 
 CUSTOM_BROKERS = {
     "binance": partial(BinanceCcxtBroker, enable_create_order_ws=True, enable_cancel_order_ws=False),
-    "binance.um": partial(BinanceCcxtBroker, enable_create_order_ws=True, enable_cancel_order_ws=False),
+    "binance.um": partial(BinanceCcxtBroker, enable_create_order_ws=True, enable_cancel_order_ws=True),
     "binance.cm": partial(BinanceCcxtBroker, enable_create_order_ws=True, enable_cancel_order_ws=False),
     "binance.pm": partial(BinanceCcxtBroker, enable_create_order_ws=False, enable_cancel_order_ws=False),
     "bitfinex.f": partial(CcxtBroker, enable_create_order_ws=True, enable_cancel_order_ws=True),

{qubx-0.6.35 → qubx-0.6.37}/src/qubx/connectors/ccxt/exchanges/binance/exchange.py

@@ -3,7 +3,7 @@ from typing import Dict, List
 import ccxt.pro as cxp
 from ccxt.async_support.base.ws.cache import ArrayCache, ArrayCacheByTimestamp
 from ccxt.async_support.base.ws.client import Client
-from ccxt.base.errors import ArgumentsRequired, BadRequest, NotSupported
+from ccxt.base.errors import ArgumentsRequired, BadRequest, InsufficientFunds, NotSupported
 from ccxt.base.precise import Precise
 from ccxt.base.types import (
     Any,
@@ -34,7 +34,12 @@ class BinanceQV(cxp.binance):
                         "name": "aggTrade",
                     },
                     "localOrderBookLimit": 10_000,  # set a large limit to avoid cutting off the orderbook
-                }
+                },
+                "exceptions": {
+                    "exact": {
+                        "-2019": InsufficientFunds,  # ccxt doesn't have this code for some weird reason !!
+                    },
+                },
             },
         )
 

{qubx-0.6.35 → qubx-0.6.37}/src/qubx/connectors/ccxt/exchanges/bitfinex/bitfinex.py

@@ -78,6 +78,10 @@ class BitfinexF(cxp.bitfinex):
             # GTX is not supported by bitfinex, so we need to convert it to PO
             params["timeInForce"] = "PO"
             params["postOnly"] = True
+
+        if "lev" not in params:
+            params["lev"] = 2
+
         response = await super().create_order(symbol, type, side, amount, price, params)
         return response
 
@@ -90,6 +94,9 @@ class BitfinexF(cxp.bitfinex):
             params["timeInForce"] = "PO"
             params["postOnly"] = True
 
+        if "lev" not in params:
+            params["lev"] = 2
+
         await self.load_markets()
         market = self.market(symbol)
         request = self.create_order_request(symbol, type, side, amount, price, params)
@@ -98,14 +105,22 @@ class BitfinexF(cxp.bitfinex):
         #     request["cid"] = request["newClientOrderId"]
         #     del request["newClientOrderId"]
 
-        await self.bfx.wss.inputs.submit_order(
-            type=request["type"],
-            symbol=request["symbol"],
-            amount=float(request["amount"]),
-            price=float(request["price"]),
-            flags=request["flags"],
-            # cid=int(request["cid"]),
-        )
+        _params = {
+            "type": request["type"],
+            "symbol": request["symbol"],
+            "amount": float(request["amount"]),
+            "lev": request["lev"],
+        }
+
+        if "price" in request:
+            _params["price"] = float(request["price"])
+        else:
+            _params["price"] = None
+
+        if "flags" in request:
+            _params["flags"] = request["flags"]
+
+        await self.bfx.wss.inputs.submit_order(**_params)
         return self.safe_order({"info": {}}, market)  # type: ignore
 
     async def cancel_order_ws(self, id: str, symbol: Str = None, params={}) -> Order | None:

{qubx-0.6.35 → qubx-0.6.37}/src/qubx/connectors/ccxt/utils.py

@@ -54,7 +54,7 @@ def ccxt_convert_order_info(instrument: Instrument, raw: dict[str, Any]) -> Orde
         type=_type,
         instrument=instrument,
         time=pd.Timestamp(raw["timestamp"], unit="ms"),  # type: ignore
-        quantity=amnt,
+        quantity=abs(amnt) * (-1 if side == "SELL" else 1),
         price=float(price) if price is not None else 0.0,
         side=side,
         status=status.upper(),
@@ -157,7 +157,7 @@ def ccxt_convert_positions(
         )
         pos = Position(
             instrument=instr,
-            quantity=info["contracts"] * (-1 if info["side"] == "short" else 1),
+            quantity=abs(info["contracts"]) * (-1 if info["side"] == "short" else 1),
             pos_average_price=info["entryPrice"],
         )
         if info.get("markPrice", None) is not None:

{qubx-0.6.35 → qubx-0.6.37}/src/qubx/connectors/tardis/data.py

@@ -454,7 +454,7 @@ class TardisDataProvider(IDataProvider):
 
         # Record data arrival for health monitoring
         tardis_type = data["type"]
-        tardis_name = data["name"]
+        tardis_name = data["name"] if "name" in data else ""
         qubx_type = self._map_tardis_type_to_data_type(tardis_type)
         if qubx_type:
             self._health_monitor.record_data_arrival(qubx_type, dt_64(msg_time, "ns"))

{qubx-0.6.35 → qubx-0.6.37}/src/qubx/core/context.py

@@ -16,6 +16,7 @@ from qubx.core.basics import (
     Timestamped,
     dt_64,
 )
+from qubx.core.errors import BaseErrorEvent, ErrorLevel
 from qubx.core.exceptions import StrategyExceededMaxNumberOfRuntimeFailuresError
 from qubx.core.helpers import (
     BasicScheduler,
@@ -286,7 +287,7 @@ class StrategyContext(IStrategyContext):
 
         # - invoke strategy's stop code
         try:
-            if not self._strategy_state.is_warmup_in_progress:
+            if not self.is_warmup_in_progress:
                 self.strategy.on_stop(self)
         except Exception as strat_error:
             logger.error(
@@ -327,7 +328,7 @@ class StrategyContext(IStrategyContext):
         return self._data_providers[0].is_simulation
 
     @property
-    def is_simulated_trading(self) -> bool:
+    def is_paper_trading(self) -> bool:
         return self._brokers[0].is_simulated_trading
 
     # IAccountViewer delegation
@@ -536,6 +537,16 @@ class StrategyContext(IStrategyContext):
                 if _should_record:
                     self._health_monitor.record_start_processing(d_type, dt_64(data.time, "ns"))
 
+                # - notify error if error level is medium or higher
+                if (
+                    self._lifecycle_notifier
+                    and isinstance(data, BaseErrorEvent)
+                    and data.level.value >= ErrorLevel.MEDIUM.value
+                ):
+                    self._lifecycle_notifier.notify_error(
+                        self._strategy_name, data.error or Exception("Unknown error"), {"message": str(data)}
+                    )
+
                 if self.process_data(instrument, d_type, data, hist):
                     channel.stop()
                     break

qubx-0.6.37/src/qubx/core/errors.py

@@ -0,0 +1,51 @@
+"""
+Error types that are sent through the event channel.
+"""
+
+from dataclasses import dataclass
+from enum import Enum
+
+from qubx.core.basics import Instrument, dt_64
+
+
+class ErrorLevel(Enum):
+    LOW = 1  # continue trading
+    MEDIUM = 2  # send notifications and continue trading
+    HIGH = 3  # send notification and cancel orders and close positions
+    CRITICAL = 4  # send notification and shutdown strategy
+
+
+@dataclass
+class BaseErrorEvent:
+    timestamp: dt_64
+    message: str
+    level: ErrorLevel
+    error: Exception | None
+
+    def __str__(self):
+        return f"[{self.level}] : {self.timestamp} : {self.message} / {self.error}"
+
+
+def create_error_event(error: BaseErrorEvent) -> tuple[None, str, BaseErrorEvent, bool]:
+    return None, "error", error, False
+
+
+@dataclass
+class OrderCreationError(BaseErrorEvent):
+    instrument: Instrument
+    amount: float
+    price: float | None
+    order_type: str
+    side: str
+
+    def __str__(self):
+        return f"[{self.level}] : {self.timestamp} : {self.message} / {self.error} ||| Order creation error for {self.order_type} {self.side} {self.instrument} {self.amount}"
+
+
+@dataclass
+class OrderCancellationError(BaseErrorEvent):
+    instrument: Instrument
+    order_id: str
+
+    def __str__(self):
+        return f"[{self.level}] : {self.timestamp} : {self.message} / {self.error} ||| Order cancellation error for {self.order_id} {self.instrument}"

{qubx-0.6.35 → qubx-0.6.37}/src/qubx/core/interfaces.py

@@ -1068,7 +1068,6 @@ class IStrategyContext(
     IProcessingManager,
     IAccountViewer,
     IWarmupStateSaver,
-    StrategyState,
 ):
     strategy: "IStrategy"
     initializer: "IStrategyInitializer"
@@ -1086,17 +1085,27 @@ class IStrategyContext(
         """Stop the strategy context."""
         pass
 
+    @property
+    def state(self) -> StrategyState:
+        """Get the strategy state."""
+        return StrategyState(**self._strategy_state.__dict__)
+
     def is_running(self) -> bool:
         """Check if the strategy context is running."""
         return False
 
+    @property
+    def is_warmup_in_progress(self) -> bool:
+        """Check if the warmup is in progress."""
+        return self._strategy_state.is_warmup_in_progress
+
     @property
     def is_simulation(self) -> bool:
         """Check if the strategy context is running in simulation mode."""
         return False
 
     @property
-    def is_simulated_trading(self) -> bool:
+    def is_paper_trading(self) -> bool:
         """Check if the strategy context is running in simulated trading mode."""
         return False
 

{qubx-0.6.35 → qubx-0.6.37}/src/qubx/core/metrics.py

@@ -717,7 +717,7 @@ class TradingSessionResult:
             "name": self.name,
             "start": pd.Timestamp(self.start).isoformat(),
             "stop": pd.Timestamp(self.stop).isoformat(),
-            "exchange": self.exchanges,
+            "exchanges": self.exchanges,
             "capital": self.capital,
             "base_currency": self.base_currency,
             "commissions": self.commissions,
@@ -824,6 +824,12 @@ class TradingSessionResult:
             info = self.info()
             if description:
                 info["description"] = description
+            # - set name if not specified
+            if info.get("name") is None:
+                info["name"] = name
+
+            # - add numpy array representer
+            yaml.SafeDumper.add_representer(np.ndarray, lambda dumper, data: dumper.represent_list(data.tolist()))
             yaml.safe_dump(info, f, sort_keys=False, indent=4)
 
         # - save logs
@@ -855,15 +861,31 @@ class TradingSessionResult:
 
         with zipfile.ZipFile(path, "r") as zip_ref:
             info = yaml.safe_load(zip_ref.read("info.yml"))
-            portfolio = pd.read_csv(zip_ref.open("portfolio.csv"), index_col=["timestamp"], parse_dates=["timestamp"])
-            executions = pd.read_csv(zip_ref.open("executions.csv"), index_col=["timestamp"], parse_dates=["timestamp"])
-            signals = pd.read_csv(zip_ref.open("signals.csv"), index_col=["timestamp"], parse_dates=["timestamp"])
+            try:
+                portfolio = pd.read_csv(
+                    zip_ref.open("portfolio.csv"), index_col=["timestamp"], parse_dates=["timestamp"]
+                )
+            except:
+                portfolio = pd.DataFrame()
+            try:
+                executions = pd.read_csv(
+                    zip_ref.open("executions.csv"), index_col=["timestamp"], parse_dates=["timestamp"]
+                )
+            except:
+                executions = pd.DataFrame()
+            try:
+                signals = pd.read_csv(zip_ref.open("signals.csv"), index_col=["timestamp"], parse_dates=["timestamp"])
+            except:
+                signals = pd.DataFrame()
 
         # load result
         _qbx_version = info.pop("qubx_version")
         _decr = info.pop("description", None)
         _perf = info.pop("performance", None)
         info["instruments"] = info.pop("symbols")
+        # - fix for old versions
+        _exch = info.pop("exchange")
+        info["exchanges"] = _exch if isinstance(_exch, list) else [_exch]
         tsr = TradingSessionResult(**info, portfolio_log=portfolio, executions_log=executions, signals_log=signals)
         tsr.qubx_version = _qbx_version
         tsr._metrics = _perf

{qubx-0.6.35 → qubx-0.6.37}/src/qubx/data/hft.py

@@ -1,9 +1,9 @@
 import queue
-from collections import defaultdict, deque
+from collections import defaultdict
 from multiprocessing import Event, Process, Queue
 from pathlib import Path
 from threading import Thread
-from typing import Any, Iterable, Optional, TypeAlias, TypeVar, Union
+from typing import Any, Iterable, Optional, TypeAlias, TypeVar
 
 import numpy as np
 import pandas as pd
@@ -148,7 +148,7 @@ class HftChunkPrefetcher:
                     enable_trade="trade" in queues,
                     enable_orderbook="orderbook" in queues,
                 )
-                ctx = reader._get_or_create_context(data_id, start, stop)
+                ctx = reader._get_or_create_context(data_id, start.floor("d"), stop)
                 instrument = reader._data_id_to_instrument[data_id]
 
                 # Initialize buffers only for enabled data types
@@ -205,9 +205,11 @@ class HftChunkPrefetcher:
                     ]
                 )
                 reader._create_buffer_if_needed("quotes", instrument, (quote_chunksize,), quote_dtype)
+                start_time_ns = start.value
+                stop_time_ns = stop.value
 
                 while not stop_event.is_set():
-                    reader._next_batch(
+                    stop_reached = reader._next_batch(
                         ctx=ctx,
                         instrument=instrument,
                         chunksize=chunk_args["chunksize"],
@@ -216,6 +218,8 @@ class HftChunkPrefetcher:
                         orderbook_period=orderbook_period,
                         tick_size_pct=chunk_args["tick_size_pct"],
                         depth=chunk_args["depth"],
+                        start_time=start_time_ns,
+                        stop_time=stop_time_ns,
                     )
 
                     # Get records for enabled data types
@@ -270,6 +274,9 @@ class HftChunkPrefetcher:
                     for data_type in queues:
                         reader._mark_processed(data_type, instrument)
 
+                    if stop_reached:
+                        break
+
             except Exception as e:
                 error_queue.put(e)
                 for queue in queues.values():
@@ -450,7 +457,9 @@ class HftDataReader(DataReader):
         ):
             raise ValueError(f"Data type {data_type} is not enabled")
 
-        _start, _stop = handle_start_stop(start, stop, lambda x: pd.Timestamp(x).floor("d"))
+        # - handle start and stop
+        _start_raw, _stop = handle_start_stop(start, stop, lambda x: pd.Timestamp(x))
+        _start = _start_raw.floor("d")  # we must to start from day's start
         assert isinstance(_start, pd.Timestamp) and isinstance(_stop, pd.Timestamp)
 
         # Check if we need to recreate the prefetcher
@@ -489,7 +498,7 @@ class HftDataReader(DataReader):
                 "orderbook_interval": self.orderbook_interval,
                 "trade_capacity": self.trade_capacity,
             }
-            prefetcher.start(self.path, data_id, _start, _stop, chunk_args)
+            prefetcher.start(self.path, data_id, _start_raw, _stop, chunk_args)
             logger.debug(f"Started prefetcher for {data_id}")
             self._prefetchers[data_id] = prefetcher
             self._prefetcher_ranges[data_id] = (_start, _stop)
@@ -620,7 +629,9 @@ class HftDataReader(DataReader):
         orderbook_period: int,
         tick_size_pct: float,
         depth: int,
-    ) -> None:
+        start_time: int,
+        stop_time: int,
+    ) -> bool:
         match data_type:
             case "quote":
                 if self._instrument_to_quote_index[instrument] > 0 or not self.enable_quote:
@@ -636,8 +647,11 @@ class HftDataReader(DataReader):
             quote_index,
             trade_index,
             orderbook_index,
+            stop_reached,
         ) = _simulate_hft(
             ctx=ctx,
+            start_time=start_time,
+            stop_time=stop_time,
             ob_timestamp=self._instrument_to_name_to_buffer["ob_timestamp"][instrument],
             bid_price_buffer=self._instrument_to_name_to_buffer["bid_price"][instrument],
             ask_price_buffer=self._instrument_to_name_to_buffer["ask_price"][instrument],
@@ -660,6 +674,8 @@ class HftDataReader(DataReader):
         self._instrument_to_trade_index[instrument] = trade_index if self.enable_trade else 0
         self._instrument_to_orderbook_index[instrument] = orderbook_index if self.enable_orderbook else 0
 
+        return stop_reached
+
     def _create_backtest_assets(self, files: list[str], instrument: Instrument) -> list[BacktestAsset]:
         mid_price = _get_initial_mid_price(files)
         roi_lb, roi_ub = mid_price / 4, mid_price * 4
@@ -760,6 +776,8 @@ def _simulate_hft(
     trade_buffer: np.ndarray,
     quote_buffer: np.ndarray,
     batch_size: int,
+    start_time: int,
+    stop_time: int,
     interval: int = 1_000_000_000,
     orderbook_period: int = 1,
     tick_size_pct: float = 0.0,
@@ -767,12 +785,17 @@ def _simulate_hft(
     enable_quote: bool = True,
     enable_trade: bool = True,
     enable_orderbook: bool = True,
-) -> tuple[int, int, int]:
+) -> tuple[int, int, int, bool]:
     orderbook_index = 0
     quote_index = 0
     trade_index = 0
+    stop_reached = False
 
     while ctx.elapse(interval) == 0 and orderbook_index < batch_size:
+        # - skip if we are before the start time
+        if ctx.current_timestamp < start_time:
+            continue
+
         depth = ctx.depth(0)
 
         # record quote
@@ -824,4 +847,9 @@ def _simulate_hft(
         ctx.clear_last_trades(0)
         quote_index += 1
 
-    return quote_index, trade_index, orderbook_index
+        # - stop if we reached the stop time
+        if ctx.current_timestamp >= stop_time:
+            stop_reached = True
+            break
+
+    return quote_index, trade_index, orderbook_index, stop_reached