Qubx 0.6.64__tar.gz → 0.7.25__tar.gz

{qubx-0.6.64 → qubx-0.7.25}/PKG-INFO

@@ -1,7 +1,8 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.4
 Name: Qubx
-Version: 0.6.64
+Version: 0.7.25
 Summary: Qubx - Quantitative Trading Framework
+License-File: LICENSE
 Author: Dmitry Marienko
 Author-email: dmitry.marienko@xlydian.com
 Requires-Python: >=3.10,<4.0
@@ -10,6 +11,7 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Requires-Dist: aiohttp (>=3.10.11,<3.11.0)
 Requires-Dist: ccxt (>=4.2.68,<5.0.0)
 Requires-Dist: croniter (>=2.0.5,<3.0.0)
@@ -19,6 +21,7 @@ Requires-Dist: dash-bootstrap-components (>=1.6.0,<2.0.0)
 Requires-Dist: gitpython (>=3.1.44,<4.0.0)
 Requires-Dist: importlib-metadata
 Requires-Dist: ipywidgets (>=8.1.5,<9.0.0)
+Requires-Dist: jinja2 (>=3.1.0,<4.0.0)
 Requires-Dist: jupyter (>=1.1.1,<2.0.0)
 Requires-Dist: jupyter-console (>=6.6.3,<7.0.0)
 Requires-Dist: loguru (>=0.7.2,<0.8.0)
@@ -40,6 +43,7 @@ Requires-Dist: python-binance (>=1.0.19,<2.0.0)
 Requires-Dist: python-dotenv (>=1.0.0,<2.0.0)
 Requires-Dist: pyyaml (>=6.0.2,<7.0.0)
 Requires-Dist: qubx-bitfinex-api (>=3.0.7,<4.0.0)
+Requires-Dist: qubx-lighter-api (>=0.1.4,<0.2.0)
 Requires-Dist: questdb (>=2.0.3,<3.0.0)
 Requires-Dist: redis (>=5.2.1,<6.0.0)
 Requires-Dist: rich (>=13.9.4,<14.0.0)
@@ -49,9 +53,12 @@ Requires-Dist: sortedcontainers (>=2.4.0,<3.0.0)
 Requires-Dist: stackprinter (>=0.2.10,<0.3.0)
 Requires-Dist: statsmodels (>=0.14.2,<0.15.0)
 Requires-Dist: tabulate (>=0.9.0,<0.10.0)
-Requires-Dist: textual (>=0.88.0,<0.89.0)
+Requires-Dist: textual-autocomplete (>=4.0.0,<5.0.0)
+Requires-Dist: textual-serve (>=1.0.0,<2.0.0)
+Requires-Dist: textual[syntax] (>=6.0.0,<7.0.0)
 Requires-Dist: toml (>=0.10.2,<0.11.0)
 Requires-Dist: tqdm
+Requires-Dist: uvloop (>=0.22.1,<0.23.0)
 Requires-Dist: websockets (==15.0.1)
 Project-URL: Repository, https://github.com/xLydianSoftware/Qubx
 Description-Content-Type: text/markdown
@@ -69,6 +76,49 @@ Description-Content-Type: text/markdown
 
 Qubx is a next-generation quantitative trading framework designed for efficient backtesting and live trading. Built with Python, it offers a robust environment for developing, testing, and deploying trading strategies.
 
+## Quick Start
+
+### 1. Install Dependencies
+```bash
+poetry install
+```
+
+### 2. Create a Strategy
+```bash
+# Create a simple strategy template (default)
+poetry run qubx init
+
+# Or specify a name and symbols
+poetry run qubx init --name my_strategy --symbols BTCUSDT,ETHUSDT
+```
+
+### 3. Run Your Strategy
+```bash
+cd my_strategy
+
+# Run in paper trading mode
+poetry run qubx run config.yml --paper
+
+# Or run in Jupyter mode for interactive development
+./jpaper.sh
+```
+
+### Available Templates
+```bash
+# List available strategy templates
+poetry run qubx init --list-templates
+
+# Create strategy with full project structure and MACD example
+poetry run qubx init --template project --name my_project
+```
+
+### Strategy Development Workflow
+1. **Initialize**: `poetry run qubx init` - Create strategy from template
+2. **Develop**: Edit `strategy.py` to implement your trading logic
+3. **Test**: `poetry run qubx run config.yml --paper` - Run in paper mode
+4. **Debug**: `./jpaper.sh` - Use Jupyter for interactive development
+5. **Deploy**: Configure for live trading when ready
+
 ## Features
 
 - 🚀 High-performance backtesting engine
@@ -119,11 +169,13 @@ qubx --help  # Show all available commands
 
 Available commands:
 
-- `qubx deploy` - Deploy a strategy from a zip file
-- `qubx ls` - List all strategies in a directory
-- `qubx release` - Package a strategy into a zip file
+- `qubx init` - Create a new strategy from template
 - `qubx run` - Start a strategy with given configuration
 - `qubx simulate` - Run strategy simulation
+- `qubx ls` - List all strategies in a directory
+- `qubx release` - Package a strategy into a zip file
+- `qubx deploy` - Deploy a strategy from a zip file
+- `qubx browse` - Browse backtest results using interactive TUI
 
 ## Development
 

{qubx-0.6.64 → qubx-0.7.25}/README.md

@@ -11,6 +11,49 @@
 
 Qubx is a next-generation quantitative trading framework designed for efficient backtesting and live trading. Built with Python, it offers a robust environment for developing, testing, and deploying trading strategies.
 
+## Quick Start
+
+### 1. Install Dependencies
+```bash
+poetry install
+```
+
+### 2. Create a Strategy
+```bash
+# Create a simple strategy template (default)
+poetry run qubx init
+
+# Or specify a name and symbols
+poetry run qubx init --name my_strategy --symbols BTCUSDT,ETHUSDT
+```
+
+### 3. Run Your Strategy
+```bash
+cd my_strategy
+
+# Run in paper trading mode
+poetry run qubx run config.yml --paper
+
+# Or run in Jupyter mode for interactive development
+./jpaper.sh
+```
+
+### Available Templates
+```bash
+# List available strategy templates
+poetry run qubx init --list-templates
+
+# Create strategy with full project structure and MACD example
+poetry run qubx init --template project --name my_project
+```
+
+### Strategy Development Workflow
+1. **Initialize**: `poetry run qubx init` - Create strategy from template
+2. **Develop**: Edit `strategy.py` to implement your trading logic
+3. **Test**: `poetry run qubx run config.yml --paper` - Run in paper mode
+4. **Debug**: `./jpaper.sh` - Use Jupyter for interactive development
+5. **Deploy**: Configure for live trading when ready
+
 ## Features
 
 - 🚀 High-performance backtesting engine
@@ -61,11 +104,13 @@ qubx --help  # Show all available commands
 
 Available commands:
 
-- `qubx deploy` - Deploy a strategy from a zip file
-- `qubx ls` - List all strategies in a directory
-- `qubx release` - Package a strategy into a zip file
+- `qubx init` - Create a new strategy from template
 - `qubx run` - Start a strategy with given configuration
 - `qubx simulate` - Run strategy simulation
+- `qubx ls` - List all strategies in a directory
+- `qubx release` - Package a strategy into a zip file
+- `qubx deploy` - Deploy a strategy from a zip file
+- `qubx browse` - Browse backtest results using interactive TUI
 
 ## Development
 

{qubx-0.6.64 → qubx-0.7.25}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "poetry.core.masonry.api"
 
 [tool.poetry]
 name = "Qubx"
-version = "0.6.64"
+version = "0.7.25"
 description = "Qubx - Quantitative Trading Framework"
 authors = [ "Dmitry Marienko <dmitry.marienko@xlydian.com>", "Yuriy Arabskyy <yuriy.arabskyy@xlydian.com>",]
 readme = "README.md"
@@ -74,8 +74,12 @@ orjson = "^3.10.15"
 aiohttp = "~3.10.11"
 websockets = "15.0.1"
 qubx-bitfinex-api = "^3.0.7"
-textual = "^0.88.0"
+textual-autocomplete = "^4.0.0"
+textual-serve = "^1.0.0"
 rich = "^13.9.4"
+jinja2 = "^3.1.0"
+qubx-lighter-api = "^0.1.4"
+uvloop = "^0.22.1"
 
 [tool.ruff.lint]
 extend-select = [ "I",]
@@ -87,7 +91,11 @@ asyncio_default_fixture_loop_scope = "function"
 pythonpath = [ "src",]
 markers = [ "integration: mark test as requiring external services like Redis", "e2e: mark test as requiring external exchange connections and API credentials",]
 addopts = "--disable-warnings"
-filterwarnings = [ "ignore:.*Jupyter is migrating.*:DeprecationWarning",]
+filterwarnings = [ "ignore:.*Jupyter is migrating.*:DeprecationWarning", "ignore:coroutine.*AsyncMockMixin._execute_mock_call.*was never awaited:RuntimeWarning",]
+
+[tool.poetry.dependencies.textual]
+extras = [ "syntax",]
+version = "^6.0.0"
 
 [tool.ruff.lint.extend-per-file-ignores]
 "*.ipynb" = [ "F405", "F401", "E701", "E402", "F403", "E401", "E702", "I001",]
@@ -119,6 +127,7 @@ pytest-mock = "^3.12.0"
 pytest-lazy-fixture = "^0.6.3"
 pytest-cov = "^4.1.0"
 mongomock = "^4.3.0"
+pytest-textual-snapshot = "^1.1.0"
 
 [tool.poetry.group.k8.dependencies]
 prometheus-client = "^0.21.1"

{qubx-0.6.64 → qubx-0.7.25}/src/qubx/__init__.py

@@ -186,7 +186,7 @@ if runtime_env() in ["notebook", "shell"]:
                         return
 
                 ipy = get_ipython()
-                for a in [x for x in re.split(r"[\ ,;]", line.strip()) if x]:
+                for a in [x for x in re.split(r"[\s,;]", line.strip()) if x]:
                     ipy.push({a: self._get_manager().Value(None, None)})
 
             # code to run

{qubx-0.6.64 → qubx-0.7.25}/src/qubx/backtester/account.py

@@ -8,6 +8,7 @@ from qubx.core.basics import (
     Timestamped,
     dt_64,
 )
+from qubx.core.interfaces import IHealthMonitor
 from qubx.core.series import OrderBook, Quote, Trade, TradeArray
 from qubx.restorers import RestoredState
 
@@ -21,7 +22,9 @@ class SimulatedAccountProcessor(BasicAccountProcessor):
         account_id: str,
         exchange: ISimulatedExchange,
         channel: CtrlChannel,
+        health_monitor: IHealthMonitor,
         base_currency: str,
+        exchange_name: str,
         initial_capital: float,
         restored_state: RestoredState | None = None,
     ) -> None:
@@ -29,6 +32,8 @@ class SimulatedAccountProcessor(BasicAccountProcessor):
             account_id=account_id,
             time_provider=exchange.get_time_provider(),
             base_currency=base_currency,
+            health_monitor=health_monitor,
+            exchange=exchange_name,
             tcc=exchange.get_transaction_costs_calculator(),
             initial_capital=initial_capital,
         )
@@ -37,12 +42,14 @@ class SimulatedAccountProcessor(BasicAccountProcessor):
         self._channel = channel
 
         if restored_state is not None:
-            self._balances.update(restored_state.balances)
+            # Convert list of AssetBalance to dict for internal storage
+            for balance in restored_state.balances:
+                self._balances[balance.currency] = balance
             for instrument, position in restored_state.positions.items():
                 _pos = self.get_position(instrument)
                 _pos.reset_by_position(position)
 
-    def get_orders(self, instrument: Instrument | None = None) -> dict[str, Order]:
+    def get_orders(self, instrument: Instrument | None = None, exchange: str | None = None) -> dict[str, Order]:
         return self._exchange.get_open_orders(instrument)
 
     def get_position(self, instrument: Instrument) -> Position:

qubx-0.7.25/src/qubx/backtester/broker.py

@@ -0,0 +1,128 @@
+from qubx import logger
+from qubx.backtester.ome import SimulatedExecutionReport
+from qubx.backtester.simulated_exchange import ISimulatedExchange
+from qubx.core.basics import (
+    CtrlChannel,
+    Instrument,
+    Order,
+    OrderRequest,
+)
+from qubx.core.exceptions import BadRequest, OrderNotFound
+from qubx.core.interfaces import IBroker
+
+from .account import SimulatedAccountProcessor
+
+
+class SimulatedBroker(IBroker):
+    channel: CtrlChannel
+
+    _account: SimulatedAccountProcessor
+    _exchange: ISimulatedExchange
+
+    def __init__(
+        self,
+        channel: CtrlChannel,
+        account: SimulatedAccountProcessor,
+        simulated_exchange: ISimulatedExchange,
+    ) -> None:
+        self.channel = channel
+        self._account = account
+        self._exchange = simulated_exchange
+
+    @property
+    def is_simulated_trading(self) -> bool:
+        return True
+
+    def send_order(self, request: OrderRequest) -> Order:
+        """Submit order synchronously in simulation."""
+        instrument = request.instrument
+        order_side = request.side
+        order_type = request.order_type
+        amount = request.quantity
+        price = request.price
+        client_id = request.client_id
+        time_in_force = request.time_in_force
+        options = request.options
+
+        self._send_execution_report(
+            report := self._exchange.place_order(
+                instrument, order_side, order_type, amount, price, client_id, time_in_force, **options
+            )
+        )
+        return report.order
+
+    def send_order_async(self, request: OrderRequest) -> None:
+        """Submit order asynchronously (same as sync in simulation)."""
+        self.send_order(request)
+
+    def cancel_order(self, order_id: str) -> bool:
+        """Cancel an order synchronously and return success status."""
+        try:
+            self._send_execution_report(order_update := self._exchange.cancel_order(order_id))
+            return order_update is not None
+        except OrderNotFound:
+            # Order was already cancelled or doesn't exist
+            logger.debug(f"Order {order_id} not found")
+            return False
+
+    def cancel_order_async(self, order_id: str) -> None:
+        """Cancel an order asynchronously (fire-and-forget)."""
+        # For simulation, async is same as sync since it's fast
+        self.cancel_order(order_id)
+
+    def cancel_orders(self, instrument: Instrument) -> None:
+        raise NotImplementedError("Not implemented yet")
+
+    def update_order(self, order_id: str, price: float, amount: float) -> Order:
+        """Update an existing limit order using cancel+recreate strategy.
+
+        Args:
+            order_id: The ID of the order to update
+            price: New price for the order
+            amount: New amount for the order
+
+        Returns:
+            Order: The updated (newly created) order object
+
+        Raises:
+            OrderNotFound: If the order is not found
+            BadRequest: If the order is not a limit order
+        """
+        # Get the existing order from account
+        active_orders = self._account.get_orders()
+        existing_order = active_orders.get(order_id)
+        if not existing_order:
+            raise OrderNotFound(f"Order {order_id} not found")
+
+        # Validate that it's a limit order
+        if existing_order.type != "LIMIT":
+            raise BadRequest(
+                f"Order {order_id} is not a limit order (type: {existing_order.type}). Only limit orders can be updated."
+            )
+
+        self.cancel_order(order_id)
+
+        request = OrderRequest(
+            instrument=existing_order.instrument,
+            quantity=abs(amount),
+            price=price,
+            order_type="LIMIT",
+            side=existing_order.side,
+            time_in_force=existing_order.time_in_force or "gtc",
+            options={},
+        )
+
+        updated_order = self.send_order(request)
+
+        return updated_order
+
+    def _send_execution_report(self, report: SimulatedExecutionReport | None):
+        if report is None:
+            return
+
+        self.channel.send((report.instrument, "order", report.order, False))
+        if report.exec is not None:
+            self.channel.send((report.instrument, "deals", [report.exec], False))
+
+    def exchange(self) -> str:
+        return self._exchange.exchange_id

{qubx-0.6.64 → qubx-0.7.25}/src/qubx/backtester/data.py

@@ -1,4 +1,5 @@
 from collections import defaultdict
+from typing import TypeVar
 
 import pandas as pd
 
@@ -19,6 +20,17 @@ from qubx.utils.time import infer_series_frequency
 from .account import SimulatedAccountProcessor
 from .utils import SimulatedTimeProvider
 
+T = TypeVar("T")
+
+
+def _get_first_existing(data: dict, keys: list, default: T = None) -> T:
+    data_get = data.get  # Cache method lookup
+    sentinel = object()
+    for key in keys:
+        if (value := data_get(key, sentinel)) is not sentinel and value is not None:
+            return value
+    return default
+
 
 class SimulatedDataProvider(IDataProvider):
     time_provider: SimulatedTimeProvider
@@ -62,16 +74,35 @@ class SimulatedDataProvider(IDataProvider):
     def is_simulation(self) -> bool:
         return True
 
+    def is_connected(self) -> bool:
+        """
+        Check if the data provider is currently connected to the exchange.
+
+        For simulated data provider, always returns True since data is loaded from files.
+
+        Returns:
+            bool: Always True for simulated data
+        """
+        return True
+
     def subscribe(self, subscription_type: str, instruments: set[Instrument], reset: bool) -> None:
         _new_instr = [i for i in instruments if not self.has_subscription(i, subscription_type)]
+
         self._data_source.add_instruments_for_subscription(subscription_type, list(instruments))
 
         # - provide historical data and last quote for subscribed instruments
         for i in _new_instr:
-            # Check if the instrument was actually subscribed (not filtered out)
+            # - check if the instrument was actually subscribed (not filtered out)
             if not self.has_subscription(i, subscription_type):
                 continue
-                
+
+            # - notify simulating exchange that instrument is subscribed
+            self._account._exchange.on_subscribe(i)
+
+            # - we need to clear last quote as it can be staled
+            self._last_quotes.pop(i, None)
+
+            # - try to peek most recent market data
             h_data = self._data_source.peek_historical_data(i, subscription_type)
             if h_data:
                 # _s_type = DataType.from_str(subscription_type)[0]
@@ -91,9 +122,16 @@ class SimulatedDataProvider(IDataProvider):
     def unsubscribe(self, subscription_type: str, instruments: set[Instrument] | Instrument | None = None) -> None:
         # logger.debug(f" | unsubscribe: {subscription_type} -> {instruments}")
         if instruments is not None:
-            self._data_source.remove_instruments_from_subscription(
-                subscription_type, [instruments] if isinstance(instruments, Instrument) else list(instruments)
-            )
+            _instruments = [instruments] if isinstance(instruments, Instrument) else list(instruments)
+            self._data_source.remove_instruments_from_subscription(subscription_type, _instruments)
+
+            # - Clear last quotes for unsubscribed instruments
+            for instr in _instruments:
+                # - clear last quote
+                self._last_quotes.pop(instr, None)
+
+                # - Notify simulating exchange that instrument is unsubscribed
+                self._account._exchange.on_unsubscribe(instr)
 
     def has_subscription(self, instrument: Instrument, subscription_type: str) -> bool:
         return self._data_source.has_subscription(instrument, subscription_type)
@@ -157,15 +195,30 @@ class SimulatedDataProvider(IDataProvider):
             if _b_ts_0 <= cut_time_ns and cut_time_ns < _b_ts_1:
                 break
 
+            # Handle None values in OHLC data
+            open_price = r.data["open"]
+            high_price = r.data["high"]
+            low_price = r.data["low"]
+            close_price = r.data["close"]
+
+            # Skip this record if any OHLC value is None
+            if open_price is None or high_price is None or low_price is None or close_price is None:
+                continue
+
             bars.append(
                 Bar(
                     _b_ts_0,
-                    r.data["open"],
-                    r.data["high"],
-                    r.data["low"],
-                    r.data["close"],
-                    r.data.get("volume", 0),
-                    r.data.get("bought_volume", 0),
+                    open_price,
+                    high_price,
+                    low_price,
+                    close_price,
+                    volume=r.data.get("volume", 0) or 0,  # Handle None volume
+                    bought_volume=_get_first_existing(r.data, ["taker_buy_volume", "bought_volume"], 0),
+                    volume_quote=_get_first_existing(r.data, ["quote_volume", "volume_quote"], 0),
+                    bought_volume_quote=_get_first_existing(
+                        r.data, ["taker_buy_quote_volume", "bought_volume_quote"], 0
+                    ),
+                    trade_count=_get_first_existing(r.data, ["count", "trade_count"], 0),
                 )
             )
 

{qubx-0.6.64 → qubx-0.7.25}/src/qubx/backtester/management.py

@@ -1,11 +1,13 @@
 import re
 import zipfile
 from collections import defaultdict
+from os.path import expanduser
 from pathlib import Path
 
 import numpy as np
 import pandas as pd
 import yaml
+from tqdm.auto import tqdm
 
 from qubx.core.metrics import TradingSessionResult
 from qubx.utils.misc import blue, cyan, green, magenta, red, yellow
@@ -38,7 +40,7 @@ class BacktestsResultsManager:
     """
 
     def __init__(self, path: str):
-        self.path = path
+        self.path = expanduser(path)
         self.reload()
 
     def reload(self) -> "BacktestsResultsManager":
@@ -326,10 +328,11 @@ class BacktestsResultsManager:
                 if not as_table:
                     print(_s)
 
+                dd_column = "max_dd_pct" if "max_dd_pct" in metrics else "mdd_pct"
                 if with_metrics:
                     _m_repr = (
                         pd.DataFrame.from_dict(metrics, orient="index")
-                        .T[["gain", "cagr", "sharpe", "qr", "max_dd_pct", "mdd_usd", "fees", "execs"]]
+                        .T[["gain", "cagr", "sharpe", "qr", dd_column, "mdd_usd", "fees", "execs"]]
                         .astype(float)
                     )
                     _m_repr = _m_repr.round(3).to_string(index=False)
@@ -344,7 +347,7 @@ class BacktestsResultsManager:
                     metrics = {
                         m: round(v, 3)
                         for m, v in metrics.items()
-                        if m in ["gain", "cagr", "sharpe", "qr", "max_dd_pct", "mdd_usd", "fees", "execs"]
+                        if m in ["gain", "cagr", "sharpe", "qr", dd_column, "mdd_usd", "fees", "execs"]
                     }
                     _t_rep.append(
                         {"Index": info.get("idx", ""), "Strategy": name}
@@ -379,7 +382,7 @@ class BacktestsResultsManager:
                     _mtrx[_nm] = v.get("performance", {})
 
                 _m_repr = pd.DataFrame.from_dict(_mtrx, orient="index")[
-                    ["gain", "cagr", "sharpe", "qr", "max_dd_pct", "mdd_usd", "fees", "execs"]
+                    ["gain", "cagr", "sharpe", "qr", "mdd_pct", "mdd_usd", "fees", "execs"]
                 ].astype(float)
                 _m_repr = _m_repr.round(3)
                 _m_repr = _m_repr.sort_values(by=sort_by, ascending=ascending) if sort_by else _m_repr
@@ -420,8 +423,10 @@ class BacktestsResultsManager:
         Returns:
             plotly.graph_objects.Figure: The plot of the variation.
         """
-        import plotly.express as px
         from itertools import cycle
+
+        import plotly.express as px
+
         from qubx.utils.misc import string_shortener
 
         _vars = self.variations.get(variation_idx)
@@ -507,3 +512,11 @@ class BacktestsResultsManager:
             )
         )
         return figure
+
+    def export_backtests_to_markdown(self, path: str, tags: tuple[str] | None = None):
+        """
+        Export backtests to markdown format
+        """
+        for n, v in tqdm(self.results.items()):
+            r = TradingSessionResult.from_file(v.get("path"))
+            r.to_markdown(path, list(tags) if tags else None)

{qubx-0.6.64 → qubx-0.7.25}/src/qubx/backtester/ome.py

@@ -79,8 +79,11 @@ class OrdersManagementEngine:
         self.active_orders = dict()
         self.stop_orders = dict()
         self.bbo = None
-        self.__order_id = 100000
-        self.__trade_id = 100000
+        # - 2025-12-09: OME always started with fixed order_id / trade_id
+        #   executions stopped to be accounted in portfolio when OME re-created
+        _start_id = int(time_provider.time().view("i8")) + 1000
+        self.__order_id = _start_id
+        self.__trade_id = _start_id
         self._fill_stops_at_price = fill_stop_order_at_price
         self._tick_size = instrument.tick_size
         self._last_update_time = np.datetime64(0, "ns")