Qubx 0.2.82__cp311-cp311-manylinux_2_35_x86_64.whl → 0.3.0__cp311-cp311-manylinux_2_35_x86_64.whl

qubx/backtester/simulator.py

@@ -124,7 +124,12 @@ class _SimulatedLogFormatter:
         if record["level"].name in {"WARNING", "SNAKY"}:
             fmt = "<cyan>{name}</cyan>:<cyan>{function}</cyan>:<cyan>{line}</cyan> - %s" % fmt
 
-        now = self.time_provider.time().astype("datetime64[us]").item().strftime("%Y-%m-%d %H:%M:%S.%f")[:-3]
+        dt = self.time_provider.time()
+        if isinstance(dt, int):
+            now = pd.Timestamp(dt).strftime("%Y-%m-%d %H:%M:%S.%f")[:-3]
+        else:
+            now = self.time_provider.time().astype("datetime64[us]").item().strftime("%Y-%m-%d %H:%M:%S.%f")[:-3]
+
         # prefix = "<green>{time:YYYY-MM-DD HH:mm:ss.SSS}</green> [ <level>%s</level> ] " % record["level"].icon
         prefix = f"<lc>{now}</lc> [<level>{record['level'].icon}</level>] "
 

qubx/connectors/ccxt/ccxt_connector.py

@@ -0,0 +1,319 @@
+from threading import Thread
+import threading
+from typing import Any, Dict, List, Optional, Callable, Awaitable
+
+import asyncio
+from asyncio.tasks import Task
+from asyncio.events import AbstractEventLoop
+from collections import defaultdict
+
+import ccxt.pro as cxp
+from ccxt.base.exchange import Exchange
+from ccxt import NetworkError, ExchangeClosedByUser, ExchangeError, ExchangeNotAvailable
+
+import re
+import numpy as np
+import pandas as pd
+
+from qubx import logger
+from qubx.core.basics import Instrument, Position, dt_64, Deal, CtrlChannel
+from qubx.core.helpers import BasicScheduler
+from qubx.core.strategy import IBrokerServiceProvider, ITradingServiceProvider
+from qubx.core.series import TimeSeries, Bar, Trade, Quote
+from qubx.utils.ntp import time_now
+from .ccxt_utils import DATA_PROVIDERS_ALIASES, ccxt_convert_trade, ccxt_convert_orderbook
+
+# - register custom wrappers
+from .ccxt_customizations import BinanceQV, BinanceQVUSDM
+
+cxp.binanceqv = BinanceQV  # type: ignore
+cxp.binanceqv_usdm = BinanceQVUSDM  # type: ignore
+cxp.exchanges.append("binanceqv")
+cxp.exchanges.append("binanceqv_usdm")
+
+
+class CCXTExchangesConnector(IBrokerServiceProvider):
+    # TODO: implement multi symbol subscription from one channel
+
+    _exchange: Exchange
+    _subscriptions: Dict[str, List[Instrument]]
+    _scheduler: BasicScheduler | None = None
+
+    _last_quotes: Dict[str, Optional[Quote]]
+    _loop: AbstractEventLoop
+    _thread_event_loop: Thread
+
+    def __init__(
+        self,
+        exchange_id: str,
+        trading_service: ITradingServiceProvider,
+        read_only: bool = False,
+        loop: AbstractEventLoop | None = None,
+        max_ws_retries: int = 10,
+        **exchange_auth,
+    ):
+        super().__init__(exchange_id, trading_service)
+        self.trading_service = trading_service
+        self.read_only = read_only
+        self.max_ws_retries = max_ws_retries
+        exchange_id = exchange_id.lower()
+
+        # - setup communication bus
+        self.set_communication_channel(bus := CtrlChannel("databus", sentinel=(None, None, None)))
+        self.trading_service.set_communication_channel(bus)
+
+        # - init CCXT stuff
+        exch = DATA_PROVIDERS_ALIASES.get(exchange_id, exchange_id)
+        if exch not in cxp.exchanges:
+            raise ValueError(f"Exchange {exchange_id} -> {exch} is not supported by CCXT.pro !")
+
+        # - create new even loop
+        self._loop = asyncio.new_event_loop() if loop is None else loop
+        asyncio.set_event_loop(self._loop)
+
+        # - create exchange's instance
+        self._exchange = getattr(cxp, exch)(exchange_auth | {"asyncio_loop": self._loop})
+        self._last_quotes = defaultdict(lambda: None)
+        self._subscriptions = defaultdict(list)
+
+        logger.info(f"{exchange_id} initialized - current time {self.trading_service.time()}")
+
+    def get_scheduler(self) -> BasicScheduler:
+        # - standard scheduler
+        if self._scheduler is None:
+            self._scheduler = BasicScheduler(self.get_communication_channel(), lambda: self.time().item())
+        return self._scheduler
+
+    def subscribe(
+        self, subscription_type: str, instruments: List[Instrument], timeframe: Optional[str] = None, nback: int = 0
+    ) -> bool:
+        to_process = self._check_existing_subscription(subscription_type.lower(), instruments)
+        if not to_process:
+            logger.info(f"Symbols {to_process} already subscribed on {subscription_type} data")
+            return False
+
+        # - start event loop if not already running
+        if not self._loop.is_running():
+            self._thread_event_loop = Thread(target=self._loop.run_forever, args=(), daemon=True)
+            self._thread_event_loop.start()
+
+        to_process_symbols = [s.symbol for s in to_process]
+
+        # - subscribe to market data updates
+        match sbscr := subscription_type.lower():
+            case "ohlc":
+                if timeframe is None:
+                    raise ValueError("timeframe must not be None for OHLC data subscription")
+
+                # convert to exchange format
+                tframe = self._get_exch_timeframe(timeframe)
+                for s in to_process:
+                    # self._task_a(self._listen_to_ohlcv(self.get_communication_channel(), s, tframe, nback))
+                    asyncio.run_coroutine_threadsafe(
+                        self._listen_to_ohlcv(self.get_communication_channel(), s, tframe, nback), self._loop
+                    )
+                    self._subscriptions[sbscr].append(s)
+                logger.info(f"Subscribed on {sbscr} updates for {len(to_process)} symbols: \n\t\t{to_process_symbols}")
+
+            case "trade":
+                if timeframe is None:
+                    timeframe = "1Min"
+                tframe = self._get_exch_timeframe(timeframe)
+                for s in to_process:
+                    asyncio.run_coroutine_threadsafe(
+                        self._listen_to_trades(self.get_communication_channel(), s, tframe, nback), self._loop
+                    )
+                    self._subscriptions[sbscr].append(s)
+                logger.info(f"Subscribed on {sbscr} updates for {len(to_process)} symbols: \n\t\t{to_process_symbols}")
+
+            case "orderbook":
+                if timeframe is None:
+                    timeframe = "1Min"
+                tframe = self._get_exch_timeframe(timeframe)
+                for s in to_process:
+                    asyncio.run_coroutine_threadsafe(
+                        self._listen_to_orderbook(self.get_communication_channel(), s, timeframe, nback), self._loop
+                    )
+                    self._subscriptions[sbscr].append(s)
+                logger.info(f"Subscribed on {sbscr} updates for {len(to_process)} symbols: \n\t\t{to_process_symbols}")
+
+            case "quote":
+                raise ValueError("TODO")
+
+            case _:
+                raise ValueError("TODO")
+
+        # - subscibe to executions reports
+        if not self.read_only:
+            for s in to_process:
+                asyncio.run_coroutine_threadsafe(
+                    self._listen_to_execution_reports(self.get_communication_channel(), s), self._loop
+                )
+
+        return True
+
+    def has_subscription(self, subscription_type: str, instrument: Instrument) -> bool:
+        sub = subscription_type.lower()
+        return sub in self._subscriptions and instrument in self._subscriptions[sub]
+
+    def _check_existing_subscription(self, subscription_type, instruments: List[Instrument]) -> List[Instrument]:
+        subscribed = self._subscriptions[subscription_type]
+        to_subscribe = []
+        for s in instruments:
+            if s not in subscribed:
+                to_subscribe.append(s)
+        return to_subscribe
+
+    def _time_msec_nbars_back(self, timeframe: str, nbarsback: int) -> int:
+        return (self.time() - nbarsback * pd.Timedelta(timeframe)).asm8.item() // 1000000
+
+    def get_historical_ohlcs(self, symbol: str, timeframe: str, nbarsback: int) -> List[Bar]:
+        assert nbarsback >= 1
+        since = self._time_msec_nbars_back(timeframe, nbarsback)
+
+        # - retrieve OHLC data
+        # - TODO: check if nbarsback > max_limit (1000) we need to do more requests
+        # - TODO: how to get quoted volumes ?
+        async def _get():
+            return await self._exchange.fetch_ohlcv(symbol, self._get_exch_timeframe(timeframe), since=since, limit=nbarsback + 1)  # type: ignore
+
+        fut = asyncio.run_coroutine_threadsafe(_get(), self._loop)
+        res = fut.result(60)
+
+        _arr = []
+        for oh in res:  # type: ignore
+            _arr.append(
+                Bar(oh[0] * 1_000_000, oh[1], oh[2], oh[3], oh[4], oh[6], oh[7])
+                if len(oh) > 6
+                else Bar(oh[0] * 1_000_000, oh[1], oh[2], oh[3], oh[4], oh[5])
+            )
+        return _arr
+
+    async def _listen_to_execution_reports(self, channel: CtrlChannel, symbol: str):
+        async def _watch_executions():
+            exec = await self._exchange.watch_orders(symbol)  # type: ignore
+            _msg = f"\nexecs_{symbol} = [\n"
+            for report in exec:
+                _msg += "\t" + str(report) + ",\n"
+                order, deals = self.trading_service.process_execution_report(symbol, report)
+                # - send update to client
+                channel.send((symbol, "order", order))
+                if deals:
+                    channel.send((symbol, "deals", deals))
+            logger.debug(_msg + "]\n")
+
+        await self._listen_to_stream(_watch_executions, self._exchange, channel, f"{symbol} execution reports")
+
+    async def _listen_to_ohlcv(self, channel: CtrlChannel, instrument: Instrument, timeframe: str, nbarsback: int):
+        symbol = instrument.symbol
+
+        async def watch_ohlcv():
+            ohlcv = await self._exchange.watch_ohlcv(symbol, timeframe)  # type: ignore
+            # - update positions by actual close price
+            last_close = ohlcv[-1][4]
+            # - there is no single method to get OHLC update's event time for every broker
+            # - for instance it's possible to do for Binance but for example Bitmex doesn't provide such info
+            # - so we will use ntp adjusted time here
+            self.trading_service.update_position_price(symbol, self.time(), last_close)
+            for oh in ohlcv:
+                channel.send((symbol, "bar", Bar(oh[0] * 1_000_000, oh[1], oh[2], oh[3], oh[4], oh[6], oh[7])))
+
+        await self._stream_hist_bars(channel, timeframe, instrument.symbol, nbarsback)
+        await self._listen_to_stream(watch_ohlcv, self._exchange, channel, f"{symbol} {timeframe} OHLCV")
+
+    async def _listen_to_trades(self, channel: CtrlChannel, instrument: Instrument, timeframe: str, nbarsback: int):
+        symbol = instrument.symbol
+
+        async def _watch_trades():
+            trades = await self._exchange.watch_trades(symbol)
+            # - update positions by actual close price
+            last_trade = ccxt_convert_trade(trades[-1])
+            self.trading_service.update_position_price(symbol, self.time(), last_trade)
+            for trade in trades:
+                channel.send((symbol, "trade", ccxt_convert_trade(trade)))
+
+        # TODO: stream historical trades for some period
+        await self._stream_hist_bars(channel, timeframe, symbol, nbarsback)
+        await self._listen_to_stream(_watch_trades, self._exchange, channel, f"{symbol} trades")
+
+    async def _listen_to_orderbook(self, channel: CtrlChannel, instrument: Instrument, timeframe: str, nbarsback: int):
+        symbol = instrument.symbol
+
+        async def _watch_orderbook():
+            ccxt_ob = await self._exchange.watch_order_book(symbol)
+            ob = ccxt_convert_orderbook(ccxt_ob, instrument)
+            self.trading_service.update_position_price(symbol, self.time(), ob.to_quote())
+            channel.send((symbol, "orderbook", ob))
+
+        # TODO: stream historical orderbooks for some period
+        await self._stream_hist_bars(channel, timeframe, symbol, nbarsback)
+        await self._listen_to_stream(_watch_orderbook, self._exchange, channel, f"{symbol} orderbook")
+
+    async def _listen_to_stream(
+        self, subscriber: Callable[[], Awaitable[None]], exchange: Exchange, channel: CtrlChannel, name: str
+    ):
+        logger.debug(f"Listening to {name}")
+        n_retry = 0
+        while channel.control.is_set():
+            try:
+                await subscriber()
+                n_retry = 0
+            except (NetworkError, ExchangeError, ExchangeNotAvailable) as e:
+                logger.error(f"Error in {name} : {e}")
+                await asyncio.sleep(1)
+                continue
+            except ExchangeClosedByUser:
+                # - we closed connection so just stop it
+                logger.info(f"{name} listening has been stopped")
+                break
+            except Exception as e:
+                logger.error(f"exception in {name} : {e}")
+                logger.exception(e)
+                n_retry += 1
+                if n_retry >= self.max_ws_retries:
+                    logger.error(f"Max retries reached for {name}. Closing connection.")
+                    await exchange.close()  # type: ignore
+                    break
+                await asyncio.sleep(min(2**n_retry, 60))  # Exponential backoff with a cap at 60 seconds
+
+    async def _stream_hist_bars(self, channel: CtrlChannel, timeframe: str, symbol: str, nbarsback: int) -> None:
+        if nbarsback < 1:
+            return
+        start = self._time_msec_nbars_back(timeframe, nbarsback)
+        ohlcv = await self._exchange.fetch_ohlcv(symbol, timeframe, since=start, limit=nbarsback + 1)  # type: ignore
+        # - just send data as the list
+        channel.send(
+            (
+                symbol,
+                "hist_bars",
+                [Bar(oh[0] * 1_000_000, oh[1], oh[2], oh[3], oh[4], oh[6], oh[7]) for oh in ohlcv],
+            )
+        )
+        logger.info(f"{symbol}: loaded {len(ohlcv)} {timeframe} bars")
+
+    def get_quote(self, symbol: str) -> Optional[Quote]:
+        return self._last_quotes[symbol]
+
+    def _get_exch_timeframe(self, timeframe: str) -> str:
+        if timeframe is not None:
+            _t = re.match(r"(\d+)(\w+)", timeframe)
+            timeframe = f"{_t[1]}{_t[2][0].lower()}" if _t and len(_t.groups()) > 1 else timeframe
+
+        tframe = self._exchange.find_timeframe(timeframe)
+        if tframe is None:
+            raise ValueError(f"timeframe {timeframe} is not supported by {self._exchange.name}")
+
+        return tframe
+
+    def close(self):
+        try:
+            # self._loop.run_until_complete(self._exchange.close())  # type: ignore
+            asyncio.run_coroutine_threadsafe(self._exchange.close(), self._loop)
+        except Exception as e:
+            logger.error(e)
+
+    def time(self) -> dt_64:
+        """
+        Returns current time as dt64
+        """
+        return time_now()

qubx/{impl → connectors/ccxt}/ccxt_customizations.py

@@ -53,7 +53,7 @@ class BinanceQV(cxp.binance):
 
     def handle_ohlcv(self, client: Client, message):
         event = self.safe_string(message, "e")
-        eventMap = {
+        eventMap: dict = {
             "indexPrice_kline": "indexPriceKline",
             "markPrice_kline": "markPriceKline",
         }
@@ -63,11 +63,9 @@ class BinanceQV(cxp.binance):
         if event == "indexPriceKline":
             # indexPriceKline doesn't have the _PERP suffix
             marketId = self.safe_string(message, "ps")
-        lowercaseMarketId = marketId.lower()
         interval = self.safe_string(kline, "i")
         # use a reverse lookup in a static map instead
-        timeframe = self.find_timeframe(interval)
-        messageHash = lowercaseMarketId + "@" + event + "_" + interval
+        unifiedTimeframe = self.find_timeframe(interval)
         parsed = [
             self.safe_integer(kline, "t"),
             self.safe_float(kline, "o"),
@@ -83,14 +81,16 @@ class BinanceQV(cxp.binance):
         isSpot = (client.url.find("/stream") > -1) or (client.url.find("/testnet.binance") > -1)
         marketType = "spot" if (isSpot) else "contract"
         symbol = self.safe_symbol(marketId, None, None, marketType)
+        messageHash = "ohlcv::" + symbol + "::" + unifiedTimeframe
         self.ohlcvs[symbol] = self.safe_value(self.ohlcvs, symbol, {})
-        stored = self.safe_value(self.ohlcvs[symbol], timeframe)
+        stored = self.safe_value(self.ohlcvs[symbol], unifiedTimeframe)
         if stored is None:
-            limit = self.safe_integer(self.options, "OHLCVLimit", 2)
+            limit = self.safe_integer(self.options, "OHLCVLimit", 1000)
             stored = ArrayCacheByTimestamp(limit)
-            # self.ohlcvs[symbol][timeframe] = stored
+            self.ohlcvs[symbol][unifiedTimeframe] = stored
         stored.append(parsed)
-        client.resolve(stored, messageHash)
+        resolveData = [symbol, unifiedTimeframe, stored]
+        client.resolve(resolveData, messageHash)
 
     def handle_trade(self, client: Client, message):
         """
@@ -109,9 +109,7 @@ class BinanceQV(cxp.binance):
         marketId = self.safe_string(message, "s")
         market = self.safe_market(marketId, None, None, marketType)
         symbol = market["symbol"]
-        lowerCaseId = self.safe_string_lower(message, "s")
-        event = self.safe_string(message, "e")
-        messageHash = lowerCaseId + "@" + event
+        messageHash = "trade::" + symbol
         executionType = self.safe_string(message, "X")
         if executionType == "INSURANCE_FUND":
             return

qubx/connectors/ccxt/ccxt_exceptions.py

@@ -0,0 +1,5 @@
+from qubx.core.exceptions import BaseError
+
+
+class CcxtOrderBookParsingError(BaseError):
+    pass

qubx/{impl → connectors/ccxt}/ccxt_trading.py

@@ -5,8 +5,6 @@ import stackprinter
 import traceback
 
 import ccxt
-import ccxt.pro as cxp
-from ccxt.base.decimal_to_precision import ROUND_UP
 from ccxt.base.exchange import Exchange, ExchangeError
 
 import numpy as np
@@ -17,7 +15,7 @@ from qubx.core.account import AccountProcessor
 from qubx.core.basics import Instrument, Position, Order, TransactionCostsCalculator, dt_64, Deal, CtrlChannel
 from qubx.core.strategy import IBrokerServiceProvider, ITradingServiceProvider
 from qubx.core.series import TimeSeries, Bar, Trade, Quote
-from qubx.impl.ccxt_utils import (
+from qubx.connectors.ccxt.ccxt_utils import (
     EXCHANGE_ALIASES,
     ccxt_convert_order_info,
     ccxt_convert_deal_info,

qubx/{impl → connectors/ccxt}/ccxt_utils.py

@@ -1,9 +1,13 @@
-from typing import Any, Dict, List, Optional, Tuple
 import pandas as pd
+import numpy as np
+
+from typing import Any, Dict, List, Optional, Tuple
 
 from qubx import logger
-from qubx.core.basics import Order, Deal, Position
-from qubx.core.series import TimeSeries, Bar, Trade, Quote
+from qubx.core.basics import Order, Deal, Position, Instrument
+from qubx.core.series import TimeSeries, Bar, Trade, Quote, OrderBook, time_as_nsec
+from qubx.utils.orderbook import build_orderbook_snapshots
+from .ccxt_exceptions import CcxtOrderBookParsingError
 
 
 EXCHANGE_ALIASES = {"binance.um": "binanceusdm", "binance.cm": "binancecoinm", "kraken.f": "krakenfutures"}
@@ -115,3 +119,57 @@ def ccxt_convert_trade(trade: dict[str, Any]) -> Trade:
     s, info, price, amnt = trade["symbol"], trade["info"], trade["price"], trade["amount"]
     m = info["m"]
     return Trade(t_ns, price, amnt, int(not m), int(trade["id"]))
+
+
+def ccxt_convert_orderbook(
+    ob: dict, instr: Instrument, levels: int = 50, tick_size_pct: float = 0.01, sizes_in_quoted: bool = False
+) -> OrderBook:
+    """
+    Convert a ccxt order book to an OrderBook object with a fixed tick size percentage.
+    Parameters:
+        ob (dict): The order book dictionary from ccxt.
+        instr (Instrument): The instrument object containing market-specific details.
+        levels (int, optional): The number of levels to include in the order book. Default is 50.
+        tick_size_pct (float, optional): The tick size percentage. Default is 0.01%.
+        sizes_in_quoted (bool, optional): Whether the size is in the quoted currency. Default is False.
+    Returns:
+        OrderBook: The converted OrderBook object.
+    """
+    _dt = pd.Timestamp(ob["datetime"]).replace(tzinfo=None).asm8
+    _prev_dt = _dt - pd.Timedelta("1ms").asm8
+
+    updates = [
+        *[(_prev_dt, update[0], update[1], True) for update in ob["bids"]],
+        *[(_prev_dt, update[0], update[1], False) for update in ob["asks"]],
+    ]
+    # add an artificial update to trigger the snapshot building
+    updates.append((_dt, 0, 0, True))
+
+    try:
+        snapshots = build_orderbook_snapshots(
+            updates,
+            levels=levels,
+            tick_size_pct=tick_size_pct,
+            min_tick_size=instr.min_tick,
+            min_size_step=instr.min_size_step,
+            sizes_in_quoted=sizes_in_quoted,
+        )
+    except Exception as e:
+        logger.error(f"Failed to build order book snapshots: {e}", exc_info=True)
+        snapshots = None
+
+    if not snapshots:
+        raise CcxtOrderBookParsingError("Failed to build order book snapshots")
+
+    (dt, _bids, _asks, top_bid, top_ask, tick_size) = snapshots[-1]
+    bids = np.array([s for _, s in _bids[::-1]])
+    asks = np.array([s for _, s in _asks])
+
+    return OrderBook(
+        time=time_as_nsec(dt),
+        top_bid=top_bid,
+        top_ask=top_ask,
+        tick_size=tick_size,
+        bids=bids,
+        asks=asks,
+    )

qubx/core/basics.py

@@ -13,6 +13,7 @@ from qubx.core.utils import prec_ceil, prec_floor
 
 dt_64 = np.datetime64
 td_64 = np.timedelta64
+ns_to_dt_64 = lambda ns: np.datetime64(ns, "ns")
 
 OPTION_FILL_AT_SIGNAL_PRICE = "fill_at_signal_price"
 

qubx/core/context.py

@@ -35,7 +35,7 @@ from qubx.core.strategy import (
     StrategyContext,
     SubscriptionType,
 )
-from qubx.core.series import Trade, Quote, Bar, OHLCV
+from qubx.core.series import Trade, Quote, Bar, OHLCV, OrderBook
 from qubx.data.readers import DataReader
 from qubx.gathering.simplest import SimplePositionGatherer
 from qubx.trackers.sizers import FixedSizer
@@ -221,6 +221,7 @@ class StrategyContextImpl(StrategyContext):
             case "trade" | "trades" | "tas":
                 timeframe = md_config.get("timeframe", "1Sec")
                 self._market_data_subcription_params = {
+                    "timeframe": timeframe,
                     "nback": md_config.get("nback", 1),
                 }
                 self._cache = CachedMarketDataHolder("1Sec")
@@ -354,7 +355,7 @@ class StrategyContextImpl(StrategyContext):
 
             # - if fit was not called - skip on_event call
             if not self.__init_fit_was_called:
-                logger.warning(
+                logger.debug(
                     f"[{self.time()}] {self.strategy.__class__.__name__}::on_event() is SKIPPED for now because on_fit() was not called yet !"
                 )
                 return False
@@ -584,10 +585,19 @@ class StrategyContextImpl(StrategyContext):
             self.__process_and_log_target_positions(target_positions),
         )
 
-        if self._trig_on_trade:
-            event_type = "trade" if not is_batch_event else "batch:trade"
-            return TriggerEvent(self.time(), event_type, self._symb_to_instr.get(symbol), trade)
-        return None
+        event_type = "trade" if not is_batch_event else "batch:trade"
+        return TriggerEvent(self.time(), event_type, self._symb_to_instr.get(symbol), trade)
+
+    def _processing_orderbook(self, symbol: str, orderbook: OrderBook) -> TriggerEvent | None:
+        quote = orderbook.to_quote()
+        self._cache.update_by_quote(symbol, quote)
+        target_positions = self.positions_tracker.update(self, self._symb_to_instr[symbol], quote)
+        self.__process_signals_from_target_positions(target_positions)
+        self.positions_gathering.alter_positions(
+            self,
+            self.__process_and_log_target_positions(target_positions),
+        )
+        return TriggerEvent(self.time(), "orderbook", self._symb_to_instr.get(symbol), orderbook)
 
     def _processing_quote(self, symbol: str, quote: Quote) -> TriggerEvent | None:
         self._cache.update_by_quote(symbol, quote)

qubx/core/helpers.py

@@ -128,7 +128,7 @@ class CachedMarketDataHolder:
             total_vol = trade.size
             bought_vol = total_vol if trade.taker >= 1 else 0.0
             for ser in series.values():
-                if len(ser) > 0 and ser[-1].time > trade.time:
+                if len(ser) > 0 and ser[0].time > trade.time:
                     continue
                 ser.update(trade.time, trade.price, total_vol, bought_vol)
 

qubx/core/series.pxd

@@ -108,6 +108,18 @@ cdef class Quote:
     cpdef double mid_price(Quote self)
 
 
+cdef class OrderBook:
+    cdef public long long time
+    cdef public double top_bid
+    cdef public double top_ask
+    cdef public double tick_size
+    cdef public np.ndarray bids
+    cdef public np.ndarray asks
+
+    cpdef Quote to_quote(OrderBook self)
+    cpdef double mid_price(OrderBook self)
+
+
 cdef class IndicatorOHLC(Indicator):
     pass
 

qubx/core/series.pyi

@@ -1,6 +1,8 @@
-import numpy as np
 from typing import Any, Tuple
 
+import numpy as np
+cimport numpy as np
+
 import pandas as pd
 
 class Bar:
@@ -33,6 +35,19 @@ class Trade:
     trade_id: int
     def __init__(self, time, price, size, taker=-1, trade_id=0): ...
 
+class OrderBook:
+    time: int
+    top_bid: float
+    top_ask: float
+    tick_size: float
+    bids: np.ndarray
+    asks: np.ndarray
+
+    def __init__(self, time, top_bid, top_ask, tick_size, bids, asks): ...
+    def to_quote(self) -> Quote: ...
+    def mid_price(self) -> float: ...
+
+
 class Locator:
     def __getitem__(self, idx): ...
     def find(self, t: str) -> Tuple[np.datetime64, Any]: ...
@@ -94,7 +109,7 @@ class IndicatorOHLC(Indicator):
     series: OHLCV
     def _copy_internal_series(self, start: int, stop: int, *origins): ...
 
-def time_as_nsec(time: Any) -> np.datetime64: ...
+def time_as_nsec(time: Any) -> int: ...
 
 class RollingSum:
     is_init_stage: bool

qubx/core/series.pyx

@@ -687,7 +687,7 @@ cdef class Trade:
         self.trade_id = trade_id
 
     def __repr__(self):
-        return "[%s]\t%.5f (%.1f) %s %s" % ( 
+        return "[%s]\t%.5f (%.2f) %s %s" % ( 
             time_to_str(self.time, 'ns'), self.price, self.size, 
             'take' if self.taker == 1 else 'make' if self.taker == 0 else '???',
             str(self.trade_id) if self.trade_id > 0 else ''
@@ -747,6 +747,27 @@ cdef class Bar:
         return "{o:%f | h:%f | l:%f | c:%f | v:%f}" % (self.open, self.high, self.low, self.close, self.volume)
 
 
+cdef class OrderBook:
+
+    def __init__(self, long long time, top_bid: float, top_ask: float, tick_size: float, bids: np.ndarray, asks: np.ndarray):
+        self.time = time
+        self.top_bid = top_bid
+        self.top_ask = top_ask
+        self.tick_size = tick_size
+        self.bids = bids
+        self.asks = asks
+    
+    def __repr__(self):
+        return f"[{time_to_str(self.time, 'ns')}] {self.top_bid} ({self.bids[0]}) | {self.top_ask} ({self.asks[0]})"
+    
+    cpdef Quote to_quote(self):
+        return Quote(self.time, self.top_bid, self.top_ask, self.bids[0], self.asks[0])
+    
+    cpdef double mid_price(self):
+        return 0.5 * (self.top_ask + self.top_bid)
+
+
+
 cdef class OHLCV(TimeSeries):
 
     def __init__(self, str name, timeframe, max_series_length=INFINITY) -> None: