Qubx 0.6.29__cp312-cp312-manylinux_2_39_x86_64.whl → 0.6.31__cp312-cp312-manylinux_2_39_x86_64.whl

qubx/backtester/ome.py

@@ -105,11 +105,13 @@ class OrdersManagementEngine:
         if mdata.time < self._last_data_update_time_ns:
             return _exec_report
         self._last_data_update_time_ns = mdata.time
+        _mkt_state = "UNKNOWN"
 
         # - new quote
         if isinstance(mdata, Quote):
             _b, _a = mdata.bid, mdata.ask
             _bs, _as = _b, _a
+            _mkt_state = "Q: " + str(mdata)
 
             # - update BBO by new quote
             self.__prev_bbo = self.bbo
@@ -122,16 +124,19 @@ class OrdersManagementEngine:
             _b = max_buy_price - self._tick_size
             _a = min_sell_price + self._tick_size
             _bs, _as = _a, _b
+            _mkt_state = "TA: " + str(mdata)
 
         # - single trade
         elif isinstance(mdata, Trade):
             _b, _a = mdata.price - self._tick_size, mdata.price + self._tick_size
             _bs, _as = _b, _a
+            _mkt_state = "T: " + str(mdata)
 
         # - order book
         elif isinstance(mdata, OrderBook):
             _b, _a = mdata.top_bid, mdata.top_ask
             _bs, _as = _b, _a
+            _mkt_state = "OB: " + str(mdata)
 
         else:
             raise SimulationError(f"Invalid market data type: {type(mdata)} for update OME({self.instrument.symbol})")
@@ -142,7 +147,7 @@ class OrdersManagementEngine:
             for level in _asks_to_execute:
                 for order_id in self.asks[level]:
                     order = self.active_orders.pop(order_id)
-                    _exec_report.append(self._execute_order(timestamp, order.price, order, False))
+                    _exec_report.append(self._execute_order(timestamp, order.price, order, False, _mkt_state))
                 self.asks.pop(level)
 
         # - when new quote ask is lower than the highest bid order execute all affected orders
@@ -151,7 +156,7 @@ class OrdersManagementEngine:
             for level in _bids_to_execute:
                 for order_id in self.bids[level]:
                     order = self.active_orders.pop(order_id)
-                    _exec_report.append(self._execute_order(timestamp, order.price, order, False))
+                    _exec_report.append(self._execute_order(timestamp, order.price, order, False, _mkt_state))
                 self.bids.pop(level)
 
         # - processing stop orders
@@ -162,12 +167,12 @@ class OrdersManagementEngine:
             if so.side == "BUY" and _as >= so.price:
                 _exec_price = _as if not _emulate_price_exec else so.price
                 self.stop_orders.pop(soid)
-                _exec_report.append(self._execute_order(timestamp, _exec_price, so, True))
+                _exec_report.append(self._execute_order(timestamp, _exec_price, so, True, _mkt_state))
 
             elif so.side == "SELL" and _bs <= so.price:
                 _exec_price = _bs if not _emulate_price_exec else so.price
                 self.stop_orders.pop(soid)
-                _exec_report.append(self._execute_order(timestamp, _exec_price, so, True))
+                _exec_report.append(self._execute_order(timestamp, _exec_price, so, True, _mkt_state))
 
         self._last_update_time = timestamp
         return _exec_report
@@ -268,7 +273,7 @@ class OrdersManagementEngine:
 
         # - if order must be "executed" immediately
         if _exec_price is not None:
-            return self._execute_order(timestamp, _exec_price, order, True)
+            return self._execute_order(timestamp, _exec_price, order, True, "BBO: " + str(self.bbo))
 
         # - processing limit orders
         if _need_update_book:
@@ -284,10 +289,12 @@ class OrdersManagementEngine:
         return SimulatedExecutionReport(self.instrument, timestamp, order, None)
 
     def _execute_order(
-        self, timestamp: dt_64, exec_price: float, order: Order, taker: bool
+        self, timestamp: dt_64, exec_price: float, order: Order, taker: bool, market_state: str
     ) -> SimulatedExecutionReport:
         order.status = "CLOSED"
-        self._dbg(f"<red>{order.id}</red> {order.type} {order.side} {order.quantity} executed at {exec_price}")
+        self._dbg(
+            f"<red>{order.id}</red> {order.type} {order.side} {order.quantity} executed at {exec_price} ::: {market_state}"
+        )
         return SimulatedExecutionReport(
             self.instrument,
             timestamp,

qubx/connectors/ccxt/data.py

@@ -616,9 +616,10 @@ class CcxtDataProvider(IDataProvider):
             for exch_symbol, ccxt_ticker in ccxt_tickers.items():  # type: ignore
                 instrument = ccxt_find_instrument(exch_symbol, self._exchange, _symbol_to_instrument)
                 quote = ccxt_convert_ticker(ccxt_ticker)
-                self._health_monitor.record_data_arrival(sub_type, dt_64(quote.time, "ns"))
-                self._last_quotes[instrument] = quote
-                channel.send((instrument, sub_type, quote, False))
+                if self._last_quotes[instrument] is None or quote.time > self._last_quotes[instrument].time:
+                    self._health_monitor.record_data_arrival(sub_type, dt_64(quote.time, "ns"))
+                    self._last_quotes[instrument] = quote
+                    channel.send((instrument, sub_type, quote, False))
 
         async def un_watch_quote(instruments: list[Instrument]):
             symbols = [_instr_to_ccxt_symbol[i] for i in instruments]

qubx/connectors/ccxt/exchanges/__init__.py

@@ -8,6 +8,8 @@ import ccxt.pro as cxp
 
 from .binance.broker import BinanceCcxtBroker
 from .binance.exchange import BINANCE_UM_MM, BinancePortfolioMargin, BinanceQV, BinanceQVUSDM
+from .bitfinex.bitfinex import BitfinexF
+from .bitfinex.bitfinex_account import BitfinexAccountProcessor
 from .kraken.kraken import CustomKrakenFutures
 
 EXCHANGE_ALIASES = {
@@ -17,7 +19,7 @@ EXCHANGE_ALIASES = {
     "binance.pm": "binancepm",
     "kraken.f": "custom_krakenfutures",
     "binance.um.mm": "binance_um_mm",
-    "bitfinex.f": "bitfinex",
+    "bitfinex.f": "bitfinex_f",
 }
 
 CUSTOM_BROKERS = {
@@ -27,11 +29,16 @@ CUSTOM_BROKERS = {
     "binance.pm": partial(BinanceCcxtBroker, enable_create_order_ws=False, enable_cancel_order_ws=False),
 }
 
+CUSTOM_ACCOUNTS = {
+    "bitfinex.f": BitfinexAccountProcessor,
+}
+
 cxp.binanceqv = BinanceQV  # type: ignore
 cxp.binanceqv_usdm = BinanceQVUSDM  # type: ignore
 cxp.binancepm = BinancePortfolioMargin  # type: ignore
 cxp.binance_um_mm = BINANCE_UM_MM  # type: ignore
 cxp.custom_krakenfutures = CustomKrakenFutures  # type: ignore
+cxp.bitfinex_f = BitfinexF  # type: ignore
 
 cxp.exchanges.append("binanceqv")
 cxp.exchanges.append("binanceqv_usdm")
@@ -39,3 +46,4 @@ cxp.exchanges.append("binancepm")
 cxp.exchanges.append("binancepm_usdm")
 cxp.exchanges.append("binance_um_mm")
 cxp.exchanges.append("custom_krakenfutures")
+cxp.exchanges.append("bitfinex_f")

qubx/connectors/ccxt/exchanges/binance/exchange.py

@@ -202,7 +202,12 @@ class BinanceQV(cxp.binance):
         executionType = self.safe_string(message, "X")
         if executionType == "INSURANCE_FUND":
             return
+
+        # - fix 2025-04-16: filter out trades with zero price
         trade = self.parse_ws_trade(message, market)
+        if trade["price"] == 0.0:
+            return
+
         tradesArray = self.safe_value(self.trades, symbol)
         if tradesArray is None:
             limit = self.safe_integer(self.options, "tradesLimit", 1000)

qubx/connectors/ccxt/exchanges/bitfinex/bitfinex.py

@@ -8,16 +8,19 @@ from ccxt.base.precise import Precise
 from ccxt.base.types import (
     Any,
     Balances,
+    Int,
+    Market,
     Num,
     Order,
     OrderSide,
     OrderType,
+    Str,
     Strings,
     Tickers,
 )
 
 
-class MyBitfinex(cxp.bitfinex):
+class BitfinexF(cxp.bitfinex):
     """
     Extended binance exchange to provide quote asset volumes support
     """
@@ -41,3 +44,126 @@ class MyBitfinex(cxp.bitfinex):
     def un_watch_bids_asks(self, symbol: str, params: dict = {}):
         if hasattr(self, "un_watch_order_book"):
             return self.un_watch_order_book(symbol, params)
+
+    async def fetch_balance(self, params={}) -> Balances:
+        params["type"] = "margin"
+        return await super().fetch_balance(params)
+
+    async def create_order(
+        self, symbol: str, type: OrderType, side: OrderSide, amount: float, price: Num = None, params={}
+    ):
+        params.pop("type", None)
+        if "timeInForce" in params and params["timeInForce"] == "GTX":
+            # GTX is not supported by bitfinex, so we need to convert it to PO
+            params["timeInForce"] = "PO"
+            params["postOnly"] = True
+        response = await super().create_order(symbol, type, side, amount, price, params)
+        return response
+
+    async def watch_orders(self, symbol: Str = None, since: Int = None, limit: Int = None, params={}) -> List[Order]:
+        response = await super().watch_orders(symbol, since, limit, params)
+        print(response)
+        return response
+
+    def parse_ws_order_status(self, status):
+        print(status)
+        statuses: dict = {
+            "ACTIVE": "open",
+            "CANCELED": "canceled",
+            "EXECUTED": "closed",
+            "PARTIALLY": "open",
+            "POSTONLY": "canceled",  # this status means that a postonly order got canceled on submission
+        }
+        return self.safe_string(statuses, status, status)
+
+    def parse_order_status(self, status: Str):
+        if status is None:
+            return status
+        parts = status.split(" ")
+        state = self.safe_string(parts, 0)
+        statuses: dict = {
+            "ACTIVE": "open",
+            "PARTIALLY": "open",
+            "EXECUTED": "closed",
+            "CANCELED": "canceled",
+            "INSUFFICIENT": "canceled",
+            "POSTONLY CANCELED": "canceled",
+            "POSTONLY": "canceled",
+            "RSN_DUST": "rejected",
+            "RSN_PAUSE": "rejected",
+            "IOC CANCELED": "canceled",
+            "FILLORKILL CANCELED": "canceled",
+        }
+        return self.safe_string(statuses, state, status)
+
+    def parse_position(self, position: dict, market: Market = None):
+        #
+        #    [
+        #        "tBTCUSD",                    # SYMBOL
+        #        "ACTIVE",                     # STATUS
+        #        0.0195,                       # AMOUNT
+        #        8565.0267019,                 # BASE_PRICE
+        #        0,                            # MARGIN_FUNDING
+        #        0,                            # MARGIN_FUNDING_TYPE
+        #        -0.33455568705000516,         # PL
+        #        -0.0003117550117425625,       # PL_PERC
+        #        7045.876419249083,            # PRICE_LIQ
+        #        3.0673001895895604,           # LEVERAGE
+        #        null,                         # _PLACEHOLDER
+        #        142355652,                    # POSITION_ID
+        #        1574002216000,                # MTS_CREATE
+        #        1574002216000,                # MTS_UPDATE
+        #        null,                         # _PLACEHOLDER
+        #        0,                            # TYPE
+        #        null,                         # _PLACEHOLDER
+        #        0,                            # COLLATERAL
+        #        0,                            # COLLATERAL_MIN
+        #        # META
+        #        {
+        #            "reason": "TRADE",
+        #            "order_id": 34271018124,
+        #            "liq_stage": null,
+        #            "trade_price": "8565.0267019",
+        #            "trade_amount": "0.0195",
+        #            "order_id_oppo": 34277498022
+        #        }
+        #    ]
+        #
+        positionList = self.safe_list(position, "result")
+        marketId = self.safe_string(positionList, 0)
+        amount = self.safe_string(positionList, 2)
+        timestamp = self.safe_integer(positionList, 12)
+        meta = self.safe_string(positionList, 19)
+        tradePrice = self.safe_string(meta, "trade_price")
+        tradeAmount = self.safe_string(meta, "trade_amount")
+        return self.safe_position(
+            {
+                "info": positionList,
+                "id": self.safe_string(positionList, 11),
+                "symbol": self.safe_symbol(marketId, market),
+                "notional": None,
+                "marginMode": "isolated",  # derivatives use isolated, margin uses cross, https://support.bitfinex.com/hc/en-us/articles/360035475374-Derivatives-Trading-on-Bitfinex
+                "liquidationPrice": self.safe_number(positionList, 8),
+                "entryPrice": self.safe_number(positionList, 3),
+                "unrealizedPnl": self.safe_number(positionList, 6),
+                "percentage": self.safe_number(positionList, 7),
+                "contracts": self.parse_number(amount),
+                "contractSize": None,
+                "markPrice": None,
+                "lastPrice": None,
+                "side": "long" if Precise.string_gt(amount, "0") else "short",
+                "hedged": None,
+                "timestamp": timestamp,
+                "datetime": self.iso8601(timestamp),
+                "lastUpdateTimestamp": self.safe_integer(positionList, 13),
+                "maintenanceMargin": self.safe_number(positionList, 18),
+                "maintenanceMarginPercentage": None,
+                "collateral": self.safe_number(positionList, 17),
+                "initialMargin": self.parse_number(Precise.string_mul(tradeAmount, tradePrice)),
+                "initialMarginPercentage": None,
+                "leverage": self.safe_number(positionList, 9),
+                "marginRatio": None,
+                "stopLossPrice": None,
+                "takeProfitPrice": None,
+            }
+        )

qubx/connectors/ccxt/exchanges/bitfinex/bitfinex_account.py

@@ -0,0 +1,45 @@
+import asyncio
+
+from qubx.connectors.ccxt.account import CcxtAccountProcessor
+from qubx.connectors.ccxt.utils import (
+    ccxt_convert_order_info,
+    ccxt_extract_deals_from_exec,
+    ccxt_find_instrument,
+)
+from qubx.core.basics import CtrlChannel
+
+
+class BitfinexAccountProcessor(CcxtAccountProcessor):
+    async def _subscribe_executions(self, name: str, channel: CtrlChannel):
+        _symbol_to_instrument = {}
+
+        async def _watch_orders():
+            orders = await self.exchange.watch_orders()
+            for order in orders:
+                instrument = ccxt_find_instrument(order["symbol"], self.exchange, _symbol_to_instrument)
+                order = ccxt_convert_order_info(instrument, order)
+                channel.send((instrument, "order", order, False))
+
+        async def _watch_my_trades():
+            trades = await self.exchange.watch_my_trades()
+            for trade in trades:  # type: ignore
+                instrument = ccxt_find_instrument(trade["symbol"], self.exchange, _symbol_to_instrument)
+                print(trade)
+                deals = ccxt_extract_deals_from_exec({"trades": [trade]})
+                print(deals)
+                channel.send((instrument, "deals", deals, False))
+
+        await asyncio.gather(
+            self._listen_to_stream(
+                subscriber=_watch_orders,
+                exchange=self.exchange,
+                channel=channel,
+                name=name,
+            ),
+            self._listen_to_stream(
+                subscriber=_watch_my_trades,
+                exchange=self.exchange,
+                channel=channel,
+                name=name,
+            ),
+        )

qubx/connectors/ccxt/factory.py

@@ -7,7 +7,8 @@ from qubx.connectors.ccxt.broker import CcxtBroker
 from qubx.core.basics import CtrlChannel
 from qubx.core.interfaces import IAccountProcessor, IBroker, IDataProvider, ITimeProvider
 
-from .exchanges import CUSTOM_BROKERS, EXCHANGE_ALIASES
+from .account import CcxtAccountProcessor
+from .exchanges import CUSTOM_ACCOUNTS, CUSTOM_BROKERS, EXCHANGE_ALIASES
 
 
 def get_ccxt_exchange(
@@ -69,10 +70,18 @@ def get_ccxt_broker(
     data_provider: IDataProvider,
     **kwargs,
 ) -> IBroker:
-    broker_cls = CUSTOM_BROKERS.get(exchange_name, CcxtBroker)
+    broker_cls = CUSTOM_BROKERS.get(exchange_name.lower(), CcxtBroker)
     return broker_cls(exchange, channel, time_provider, account, data_provider, **kwargs)
 
 
+def get_ccxt_account(
+    exchange_name: str,
+    **kwargs,
+) -> IAccountProcessor:
+    account_cls = CUSTOM_ACCOUNTS.get(exchange_name.lower(), CcxtAccountProcessor)
+    return account_cls(**kwargs)
+
+
 def _get_api_credentials(
     api_key: str | None, secret: str | None, kwargs: dict[str, Any]
 ) -> tuple[str | None, str | None]:

qubx/connectors/ccxt/utils.py

@@ -38,6 +38,9 @@ def ccxt_convert_order_info(instrument: Instrument, raw: dict[str, Any]) -> Orde
     Convert CCXT excution record to Order object
     """
     ri = raw["info"]
+    if isinstance(ri, list):
+        # we don't handle case when order info is a list
+        ri = {}
     amnt = float(ri.get("origQty", raw.get("amount")))
     price = raw["price"]
     status = raw["status"]
@@ -157,7 +160,8 @@ def ccxt_convert_positions(
             quantity=info["contracts"] * (-1 if info["side"] == "short" else 1),
             pos_average_price=info["entryPrice"],
         )
-        pos.update_market_price(pd.Timestamp(info["timestamp"], unit="ms").asm8, info["markPrice"], 1)
+        if info.get("markPrice", None) is not None:
+            pos.update_market_price(pd.Timestamp(info["timestamp"], unit="ms").asm8, info["markPrice"], 1)
         positions.append(pos)
     return positions
 

qubx/core/context.py

@@ -430,8 +430,8 @@ class StrategyContext(IStrategyContext):
     def close_positions(self, market_type: MarketType | None = None) -> None:
         return self._trading_manager.close_positions(market_type)
 
-    def cancel_order(self, order_id: str) -> None:
-        return self._trading_manager.cancel_order(order_id)
+    def cancel_order(self, order_id: str, exchange: str | None = None) -> None:
+        return self._trading_manager.cancel_order(order_id, exchange)
 
     def cancel_orders(self, instrument: Instrument):
         return self._trading_manager.cancel_orders(instrument)

qubx/core/helpers.py

@@ -202,6 +202,8 @@ class CachedMarketDataHolder:
         series = self._ohlcvs.get(instrument)
         if series:
             for ser in series.values():
+                if len(ser) > 0 and ser[0].time > quote.time:
+                    continue
                 ser.update(quote.time, quote.mid_price(), 0)
 
     @SW.watch("CachedMarketDataHolder")

qubx/core/mixins/trading.py

@@ -180,7 +180,9 @@ class TradingManager(ITradingManager):
     def _adjust_size(self, instrument: Instrument, amount: float) -> float:
         size_adj = instrument.round_size_down(abs(amount))
         if size_adj < instrument.min_size:
-            raise ValueError(f"Attempt to trade size {abs(amount)} less than minimal allowed {instrument.min_size} !")
+            raise ValueError(
+                f"[{instrument.symbol}] Attempt to trade size {abs(amount)} less than minimal allowed {instrument.min_size} !"
+            )
         return size_adj
 
     def _adjust_price(self, instrument: Instrument, price: float | None, amount: float) -> float | None:

qubx/data/tardis.py

@@ -529,6 +529,7 @@ class TardisMachineReader(DataReader):
             raise ValueError(f"Invalid data_id format: {data_id}. Expected format: 'exchange:symbol'")
 
         exchange = TARDIS_EXCHANGE_MAPPERS.get(exchange.lower(), exchange)
+        symbol = self._map_symbol(symbol, exchange)
 
         start_date, end_date = handle_start_stop(start, stop)
         if not start_date:
@@ -607,6 +608,7 @@ class TardisMachineReader(DataReader):
                             try:
                                 chunk = chunk_queue.get()
                                 if chunk is None:  # End of chunks
+                                    logger.info(f"End of chunks for {data_id}")
                                     break
 
                                 # Process and yield the chunk
@@ -877,3 +879,10 @@ class TardisMachineReader(DataReader):
     def _stream_data(self, url: str, line_queue: Queue, stop_event: threading.Event):
         """Submit the streaming coroutine to the asyncio loop"""
         return self._async_loop.submit(self._fetch_stream(url, line_queue, stop_event))
+
+    def _map_symbol(self, symbol: str, exchange: str) -> str:
+        """Map symbol to Tardis Machine API format"""
+        if exchange.lower() == "bitfinex-derivatives":
+            return f"{symbol[:3]}F0:USTF0"
+        else:
+            return symbol

qubx/utils/runner/runner.py

@@ -21,9 +21,8 @@ from qubx.backtester.utils import (
     SimulationSetup,
     recognize_simulation_data_config,
 )
-from qubx.connectors.ccxt.account import CcxtAccountProcessor
 from qubx.connectors.ccxt.data import CcxtDataProvider
-from qubx.connectors.ccxt.factory import get_ccxt_broker, get_ccxt_exchange
+from qubx.connectors.ccxt.factory import get_ccxt_account, get_ccxt_broker, get_ccxt_exchange
 from qubx.connectors.tardis.data import TardisDataProvider
 from qubx.core.account import CompositeAccountProcessor
 from qubx.core.basics import (
@@ -464,40 +463,43 @@ def _create_account_processor(
     restored_state: RestoredState | None = None,
     read_only: bool = False,
 ) -> IAccountProcessor:
-    if paper:
-        settings = account_manager.get_exchange_settings(exchange_name)
-
-        # - TODO: here we can create  different types of simulated exchanges based on it's name etc
-        simulated_exchange = get_simulated_exchange(exchange_name, time_provider, tcc)
-
-        return SimulatedAccountProcessor(
-            account_id=exchange_name,
-            exchange=simulated_exchange,
-            channel=channel,
-            base_currency=settings.base_currency,
-            initial_capital=settings.initial_capital,
-            restored_state=restored_state,
-        )
-
-    creds = account_manager.get_exchange_credentials(exchange_name)
-    connector = exchange_config.connector
     if exchange_config.account is not None:
         connector = exchange_config.account.connector
+    elif paper:
+        connector = "paper"
+    else:
+        connector = exchange_config.connector
 
     match connector.lower():
         case "ccxt":
+            creds = account_manager.get_exchange_credentials(exchange_name)
             exchange = get_ccxt_exchange(
                 exchange_name, use_testnet=creds.testnet, api_key=creds.api_key, secret=creds.secret
             )
-            return CcxtAccountProcessor(
+            return get_ccxt_account(
                 exchange_name,
-                exchange,
-                channel,
-                time_provider,
+                account_id=exchange_name,
+                exchange=exchange,
+                channel=channel,
+                time_provider=time_provider,
                 base_currency=creds.base_currency,
                 tcc=tcc,
                 read_only=read_only,
             )
+        case "paper":
+            settings = account_manager.get_exchange_settings(exchange_name)
+
+            # - TODO: here we can create  different types of simulated exchanges based on it's name etc
+            simulated_exchange = get_simulated_exchange(exchange_name, time_provider, tcc)
+
+            return SimulatedAccountProcessor(
+                account_id=exchange_name,
+                exchange=simulated_exchange,
+                channel=channel,
+                base_currency=settings.base_currency,
+                initial_capital=settings.initial_capital,
+                restored_state=restored_state,
+            )
         case _:
             raise ValueError(f"Connector {exchange_config.connector} is not supported yet !")
 
@@ -512,19 +514,19 @@ def _create_broker(
     account_manager: AccountConfigurationManager,
     paper: bool,
 ) -> IBroker:
-    if paper:
-        assert isinstance(account, SimulatedAccountProcessor)
-        return SimulatedBroker(channel=channel, account=account, simulated_exchange=account._exchange)
-
-    creds = account_manager.get_exchange_credentials(exchange_name)
-    connector = exchange_config.connector
-    params = exchange_config.params
     if exchange_config.broker is not None:
         connector = exchange_config.broker.connector
         params = exchange_config.broker.params
+    elif paper:
+        connector = "paper"
+        params = {}
+    else:
+        connector = exchange_config.connector
+        params = exchange_config.params
 
     match connector.lower():
         case "ccxt":
+            creds = account_manager.get_exchange_credentials(exchange_name)
             _enable_mm = params.pop("enable_mm", False)
             exchange = get_ccxt_exchange(
                 exchange_name,
@@ -536,6 +538,9 @@ def _create_broker(
             return get_ccxt_broker(
                 exchange_name, exchange, channel, time_provider, account, data_provider, **exchange_config.params
             )
+        case "paper":
+            assert isinstance(account, SimulatedAccountProcessor)
+            return SimulatedBroker(channel=channel, account=account, simulated_exchange=account._exchange)
         case _:
             raise ValueError(f"Connector {exchange_config.connector} is not supported yet !")
 

{qubx-0.6.29.dist-info → qubx-0.6.31.dist-info}/METADATA

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

{qubx-0.6.29.dist-info → qubx-0.6.31.dist-info}/RECORD

@@ -5,7 +5,7 @@ qubx/backtester/account.py,sha256=0yvE06icSeK2ymovvaKkuftY8Ou3Z7Y2JrDa6VtkINw,30
 qubx/backtester/broker.py,sha256=JMasxycLqCT99NxN50uyQ1uxtpHYL0wpp4sJ3hB6v2M,2688
 qubx/backtester/data.py,sha256=De2ioNv3Zh-cCGakzK0igb2caDcqbibZ_tsYmF7sTTQ,6601
 qubx/backtester/management.py,sha256=HuyzFsBPgR7j-ei78Ngcx34CeSn65c9atmaii1aTsYg,14900
-qubx/backtester/ome.py,sha256=Uus6xdcWwhb_G0a6hJSLuRTgMcbFA_zJxYkH6kF22Gw,15268
+qubx/backtester/ome.py,sha256=Uf3wqyVjUEpm1jrDQ4PE77E3R3B7wJJy1vaOOmvQqWg,15610
 qubx/backtester/optimization.py,sha256=HHUIYA6Y66rcOXoePWFOuOVX9iaHGKV0bGt_4d5e6FM,7619
 qubx/backtester/runner.py,sha256=zF56lXVRYJCBiwdqnylob-yf48r_aVK9gHpf8aT49cQ,20471
 qubx/backtester/simulated_data.py,sha256=niujaMRj__jf4IyzCZrSBR5ZoH1VUbvsZHSewHftdmI,17240
@@ -20,26 +20,27 @@ qubx/cli/release.py,sha256=JYdNt_ZM9jarmYiRDtKqbRqqllzm2Qwi6VggokB2j8A,28167
 qubx/connectors/ccxt/__init__.py,sha256=HEQ7lM9HS8sED_zfsAHrhFT7F9E7NFGAecwZwNr-TDE,65
 qubx/connectors/ccxt/account.py,sha256=HILqsSPfor58NrlP0qYwO5lkNZzUBG-SR5Hy1OSa7_M,24308
 qubx/connectors/ccxt/broker.py,sha256=UMAytmDCwELUv4-R4WmrEQdPnZjjF89XlgJst15WVSs,15305
-qubx/connectors/ccxt/data.py,sha256=-5ysiERXC6Ip5Hp9N6Lq4bTQVyMZvFFMMPcS6RfwmYk,30051
+qubx/connectors/ccxt/data.py,sha256=COVUh37ZdCUjiDB0a38Cj9SNSV8P95mqG2B3Gc_fQ2U,30172
 qubx/connectors/ccxt/exceptions.py,sha256=OfZc7iMdEG8uLorcZta2NuEuJrSIqi0FG7IICmwF54M,262
-qubx/connectors/ccxt/exchanges/__init__.py,sha256=2Po4YfvLOcpXHCS9Q2SSy3TMUejkcd9RhQ-oyGaxcEc,1504
+qubx/connectors/ccxt/exchanges/__init__.py,sha256=wtRH7g2PWyX-AT_LkM29UHpq021L5dFi2SVvdbUpLCk,1756
 qubx/connectors/ccxt/exchanges/binance/broker.py,sha256=BB2V82zaOm1EjP3GrsOqQQMeGpml6-w23iv7goKrjyU,2111
-qubx/connectors/ccxt/exchanges/binance/exchange.py,sha256=7r4Y1-4NOMjnhz_Sdg6mjazUHtJPc1jOIPT_d8sxuBs,24444
-qubx/connectors/ccxt/exchanges/bitfinex/bitfinex.py,sha256=C0ZtM2MmLI_LJyUFSbww9qon7od57iAKoJJZ_3KUgNM,1150
+qubx/connectors/ccxt/exchanges/binance/exchange.py,sha256=ywmf373kVkXXw0h1PTqi7dg_3-sb7ZYKC8Y3qTmDtsY,24561
+qubx/connectors/ccxt/exchanges/bitfinex/bitfinex.py,sha256=14Mh0H05tMAAcf6ass55YqGckEOUIPp6o750DPxAuV8,6825
+qubx/connectors/ccxt/exchanges/bitfinex/bitfinex_account.py,sha256=TgRK5i99Fil5XgB9Hxfw53-Ngx-3L2M_xiyje2jwuDY,1661
 qubx/connectors/ccxt/exchanges/kraken/kraken.py,sha256=RFrnvr1L1NZYoKYWR5_L8vVkpMXtY7UDkWRnHeoasDU,351
-qubx/connectors/ccxt/factory.py,sha256=mfWjIJhoTAREkL--WiCGpD7ptDC7mHRc19s0hI2ShKM,2957
+qubx/connectors/ccxt/factory.py,sha256=T0cMSH5m6-T2LXrbZHM9uCSOYOfZf-bh1fAOXAoFhF4,3226
 qubx/connectors/ccxt/reader.py,sha256=qaZIaOZkRf3Rz31ZrEqqAv4kATk5zDlSq-LK1jziBs8,8314
-qubx/connectors/ccxt/utils.py,sha256=hNy7jmNau6SKgztVCV-HNTRRphfVREmPCvpxKkKwPzY,11575
+qubx/connectors/ccxt/utils.py,sha256=hin4NgFJCH8fwQMZsjnMCwtP4KiITm5xgkiBnWgzMkI,11733
 qubx/connectors/tardis/data.py,sha256=VJJXSe6xb4jsa88VVj1lwI7VkEYknIXuM4End3t852M,30752
 qubx/connectors/tardis/utils.py,sha256=epThu9DwqbDb7BgScH6fHa_FVpKUaItOqp3JwtKGc5g,9092
 qubx/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 qubx/core/account.py,sha256=4_XskMLR9Uh-rpJBDYMrceYiGMvAZw56k1ve-unIW8w,19417
 qubx/core/basics.py,sha256=PaprFa6sscrYPZfxImWOPLfVoVlu3PtcXTWbz0ZMtEk,28864
-qubx/core/context.py,sha256=-kzDxzsZtu2kO1eBxi5iVUoSmWB3tIZOp4JTCiEZZE0,22277
+qubx/core/context.py,sha256=R6otCA09Eqb4d0xA-HOGDAv4NjpLwJc3RzLs4QHXzg4,22316
 qubx/core/deque.py,sha256=3PsmJ5LF76JpsK4Wp5LLogyE15rKn6EDCkNOOWT6EOk,6203
 qubx/core/errors.py,sha256=kWCK6o0-mm87VUhhlGKqwTpvdDXAza7YRRjeyz-vwfI,609
 qubx/core/exceptions.py,sha256=11wQC3nnNLsl80zBqbE6xiKCqm31kctqo6W_gdnZkg8,581
-qubx/core/helpers.py,sha256=9nl9L_ZzT1HsMC9VthMqXfmuRS_37crB-9bVfIRHeOs,19631
+qubx/core/helpers.py,sha256=qzRsttt4sMYMarDWMzWvc3b2W-Qp9qAQwFiQBljAsA0,19722
 qubx/core/initializer.py,sha256=PUiD_cIjvGpuPjYyRpUjpwm3xNQ2Kipa8bAhbtxCQRo,3935
 qubx/core/interfaces.py,sha256=VKIgEhRaDj9EMf1UUcMlai2BLrw0UNPU1-2akU5q0Ng,57955
 qubx/core/loggers.py,sha256=eYhJANHYwz1heeFMa5V7jYCL196wkTSvj6c-8lkPj1Y,19567
@@ -49,13 +50,13 @@ qubx/core/mixins/__init__.py,sha256=AMCLvfNuIb1kkQl3bhCj9jIOEl2eKcVPJeyLgrkB-rk,
 qubx/core/mixins/market.py,sha256=lBappEimPhIuI0vmUvwVlIztkYjlEjJBpP-AdpfudII,3948
 qubx/core/mixins/processing.py,sha256=dqehukrfqcLy5BeILKnkpHCvva4SbLKj1ZbQdnByu1k,24552
 qubx/core/mixins/subscription.py,sha256=V_g9wCPQ8S5SHkU-qOZ84cV5nReAUrV7DoSNAGG0LPY,10372
-qubx/core/mixins/trading.py,sha256=6XK712ZHECZnI-lleJfQ8taXfaBagPQBVqNoBxAkEyM,7204
+qubx/core/mixins/trading.py,sha256=idfRPaqrvkfMxzu9mXr9i_xfqLee-ZAOrERxkxv6Ruo,7256
 qubx/core/mixins/universe.py,sha256=L3s2Jw46_J1iDh4622Gk_LvCjol4W7mflBwEHrLfZEw,9899
-qubx/core/series.cpython-312-x86_64-linux-gnu.so,sha256=fsbUVYNqAS42tjo3ZbPvyXTUO9hw1d-9nZcIXepfd4U,978280
+qubx/core/series.cpython-312-x86_64-linux-gnu.so,sha256=3j9cBsksD9HcJZ6NNNCaqgIFvM8q3HPDLMpT1lbCkeA,978280
 qubx/core/series.pxd,sha256=jBdMwgO8J4Zrue0e_xQ5RlqTXqihpzQNu6V3ckZvvpY,3978
 qubx/core/series.pyi,sha256=RaHm_oHHiWiNUMJqVfx5FXAXniGLsHxUFOUpacn7GC0,4604
 qubx/core/series.pyx,sha256=7cM3zZThW59waHiYcZmMxvYj-HYD7Ej_l7nKA4emPjE,46477
-qubx/core/utils.cpython-312-x86_64-linux-gnu.so,sha256=0AJgqHjRH-SBlVonHtpvhHITa0qCj-AxpT6ZHZOSHrA,86568
+qubx/core/utils.cpython-312-x86_64-linux-gnu.so,sha256=icPDYxV83A3kNlrgxzCnhzxtMhGqh07sfSTgsmIbdTg,86568
 qubx/core/utils.pyi,sha256=a-wS13V2p_dM1CnGq40JVulmiAhixTwVwt0ah5By0Hc,348
 qubx/core/utils.pyx,sha256=k5QHfEFvqhqWfCob89ANiJDKNG8gGbOh-O4CVoneZ8M,1696
 qubx/data/__init__.py,sha256=ELZykvpPGWc5rX7QoNyNQwMLgdKMG8MACOByA4pM5hA,549
@@ -64,7 +65,7 @@ qubx/data/helpers.py,sha256=VcXBl1kfWzAOqrjadKrP9WemGjJIB0q3xascbesErh4,16268
 qubx/data/hft.py,sha256=Y1QVg3eXDt9ZtdnrNk7xreblEa0Mc4Jrprt0dVaoOn0,32797
 qubx/data/readers.py,sha256=Y6bU4jyeRGB9mPdQwi9dD0PTuiQH-OVAY9N-6cM3HVo,62527
 qubx/data/registry.py,sha256=45mjy5maBSO6cf-0zfIRRDs8b0VDW7wHSPn43aRjv-o,3883
-qubx/data/tardis.py,sha256=aQeNKUu2jKQpTSRyzCtTqDhxWW8hUp2If7Yr5mMaaYA,33360
+qubx/data/tardis.py,sha256=VMw13tIIlrGZwermKvdFRSNtLUiJDGOKW4l6WuAMQSA,33747
 qubx/emitters/__init__.py,sha256=tpJ9OoW-gycTBXGJ0647tT8-dVBmq23T2wMX_kmk3nM,565
 qubx/emitters/base.py,sha256=z0CiEnIGkizd-4Btvq9Auxg3BpnkKN6M8-ksAH2enQc,7745
 qubx/emitters/composite.py,sha256=8DsPIUtaJ95Oww9QTVVB6LR7Wcb6TJ-c1jIHMGuttz4,2784
@@ -116,7 +117,7 @@ qubx/restorers/signal.py,sha256=DBLqA7vDhoMTAzUC4N9UerrO0GbjeHdTeMoCz7U7iI8,6621
 qubx/restorers/state.py,sha256=duXyEHQhS1zdNdo3VKscMhieZ5sYNlfE4S_pPXQ1Tuw,4109
 qubx/restorers/utils.py,sha256=We2gfqwQKWziUYhuUnjb-xo-5tSlbuHWpPQn0CEMTn0,1155
 qubx/ta/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-qubx/ta/indicators.cpython-312-x86_64-linux-gnu.so,sha256=Mss8usOoL6hmmXTTcoOH5yIUN0bRcFOEgWYsIueYlRo,654440
+qubx/ta/indicators.cpython-312-x86_64-linux-gnu.so,sha256=OYg0HP0g9sc1OFuUCw16x6L8j7xd6TFa809WGe7ni2E,654440
 qubx/ta/indicators.pxd,sha256=Goo0_N0Xnju8XGo3Xs-3pyg2qr_0Nh5C-_26DK8U_IE,4224
 qubx/ta/indicators.pyi,sha256=19W0uERft49In5bf9jkJHkzJYEyE9gzudN7_DJ5Vdv8,1963
 qubx/ta/indicators.pyx,sha256=Xgpew46ZxSXsdfSEWYn3A0Q35MLsopB9n7iyCsXTufs,25969
@@ -150,11 +151,11 @@ qubx/utils/runner/_jupyter_runner.pyt,sha256=41dLQeI2EL4wJjBDht2qKbgISgS5DtmJ6Xt
 qubx/utils/runner/accounts.py,sha256=mpiv6oxr5z97zWt7STYyARMhWQIpc_XFKungb_pX38U,3270
 qubx/utils/runner/configs.py,sha256=4lonQgksh4wDygsN67lIidVRIUksskWuhL25A2IZwho,3694
 qubx/utils/runner/factory.py,sha256=vQ2dBTbrQE9YH__-TvuFzGF-E1li-vt_qQum9GHa11g,11666
-qubx/utils/runner/runner.py,sha256=iJsxTU9ne43Seh5rMfZLrXnV-RtA4BwzZYsjHeXajLs,29067
+qubx/utils/runner/runner.py,sha256=X6KxzcrnBFhS9nyyid7M9dYGiZ_2f1_b_j5Ksa3DRn8,29314
 qubx/utils/time.py,sha256=J0ZFGjzFL5T6GA8RPAel8hKG0sg2LZXeQ5YfDCfcMHA,10055
 qubx/utils/version.py,sha256=e52fIHyxzCiIuH7svCF6pkHuDlqL64rklqz-2XjWons,5309
-qubx-0.6.29.dist-info/LICENSE,sha256=qwMHOSJ2TD0nx6VUJvFhu1ynJdBfNozRMt6tnSul-Ts,35140
-qubx-0.6.29.dist-info/METADATA,sha256=a7FpGiZmBlGzYdt3GrAuWr6skM_ow-yWuAkZHmCiBTM,4444
-qubx-0.6.29.dist-info/WHEEL,sha256=XjdW4AGUgFDhpG9b3b2KPhtR_JLZvHyfemLgJJwcqOI,110
-qubx-0.6.29.dist-info/entry_points.txt,sha256=VqilDTe8mVuV9SbR-yVlZJBTjbkHIL2JBgXfQw076HY,47
-qubx-0.6.29.dist-info/RECORD,,
+qubx-0.6.31.dist-info/LICENSE,sha256=qwMHOSJ2TD0nx6VUJvFhu1ynJdBfNozRMt6tnSul-Ts,35140
+qubx-0.6.31.dist-info/METADATA,sha256=xcwgxs5jjEL4HrPbEUjdKq9uUbwjfFS2YNeMWm2J3Z4,4444
+qubx-0.6.31.dist-info/WHEEL,sha256=XjdW4AGUgFDhpG9b3b2KPhtR_JLZvHyfemLgJJwcqOI,110
+qubx-0.6.31.dist-info/entry_points.txt,sha256=VqilDTe8mVuV9SbR-yVlZJBTjbkHIL2JBgXfQw076HY,47
+qubx-0.6.31.dist-info/RECORD,,