Qubx 0.4.3__tar.gz → 0.5.1__tar.gz

{qubx-0.4.3 → qubx-0.5.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: Qubx
-Version: 0.4.3
+Version: 0.5.1
 Summary: Qubx - quantitative trading framework
 Home-page: https://github.com/dmarienko/Qubx
 Author: Dmitry Marienko
@@ -13,7 +13,10 @@ Classifier: Programming Language :: Python :: 3.12
 Requires-Dist: ccxt (>=4.2.68,<5.0.0)
 Requires-Dist: croniter (>=2.0.5,<3.0.0)
 Requires-Dist: cython (==3.0.8)
+Requires-Dist: dash (>=2.18.2,<3.0.0)
+Requires-Dist: dash-bootstrap-components (>=1.6.0,<2.0.0)
 Requires-Dist: importlib-metadata
+Requires-Dist: jupyter-console (>=6.6.3,<7.0.0)
 Requires-Dist: loguru (>=0.7.2,<0.8.0)
 Requires-Dist: matplotlib (>=3.8.4,<4.0.0)
 Requires-Dist: msgspec (>=0.18.6,<0.19.0)
@@ -28,14 +31,15 @@ Requires-Dist: psycopg-pool (>=3.2.2,<4.0.0)
 Requires-Dist: pyarrow (>=15.0.0,<16.0.0)
 Requires-Dist: pydantic (>=2.9.2,<3.0.0)
 Requires-Dist: pymongo (>=4.6.1,<5.0.0)
-Requires-Dist: pytest[lazyfixture] (>=7.2.0,<8.0.0)
 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: scikit-learn (>=1.4.2,<2.0.0)
 Requires-Dist: scipy (>=1.12.0,<2.0.0)
 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: tqdm
 Project-URL: Repository, https://github.com/dmarienko/Qubx
 Description-Content-Type: text/markdown
@@ -70,3 +74,28 @@ base_currency = USDT
 > python ..\src\qubx\utils\runner.py configs\zero_test.yaml -a configs\.env -j 
 ```
 
+## Running tests
+
+We use `pytest` for running tests. For running unit tests execute
+```
+just test
+```
+
+We also have several integration tests (marked with `@pytest.mark.integration`), which mainly make sure that the exchange connectors function properly. We test them on the corresponding testnets, so you will need to generate api credentials for the exchange testnets that you want to verify.
+
+Once you have the testnet credentials store them in an `.env.integration` file in the root of the Qubx directory
+```
+# BINANCE SPOT test credentials
+BINANCE_SPOT_API_KEY=...
+BINANCE_SPOT_SECRET=...
+
+# BINANCE FUTURES test credentials
+BINANCE_FUTURES_API_KEY=...
+BINANCE_FUTURES_SECRET=...
+```
+
+To run the tests simply call
+```
+just test-integration
+```
+

{qubx-0.4.3 → qubx-0.5.1}/README.md

@@ -27,3 +27,28 @@ base_currency = USDT
 ```
 > python ..\src\qubx\utils\runner.py configs\zero_test.yaml -a configs\.env -j 
 ```
+
+## Running tests
+
+We use `pytest` for running tests. For running unit tests execute
+```
+just test
+```
+
+We also have several integration tests (marked with `@pytest.mark.integration`), which mainly make sure that the exchange connectors function properly. We test them on the corresponding testnets, so you will need to generate api credentials for the exchange testnets that you want to verify.
+
+Once you have the testnet credentials store them in an `.env.integration` file in the root of the Qubx directory
+```
+# BINANCE SPOT test credentials
+BINANCE_SPOT_API_KEY=...
+BINANCE_SPOT_SECRET=...
+
+# BINANCE FUTURES test credentials
+BINANCE_FUTURES_API_KEY=...
+BINANCE_FUTURES_SECRET=...
+```
+
+To run the tests simply call
+```
+just test-integration
+```

{qubx-0.4.3 → qubx-0.5.1}/pyproject.toml

@@ -1,12 +1,13 @@
 [tool.poetry]
 name = "Qubx"
-version = "0.4.3"
+version = "0.5.1"
 description = "Qubx - quantitative trading framework"
-authors = ["Dmitry Marienko <dmitry@gmail.com>", "Yuriy Arabskyy <yuriy.arabskyy@gmail.com>"]
-readme = "README.md"
-packages = [
-    { include = "qubx", from = "src" },
+authors = [
+    "Dmitry Marienko <dmitry@gmail.com>",
+    "Yuriy Arabskyy <yuriy.arabskyy@gmail.com>",
 ]
+readme = "README.md"
+packages = [{ include = "qubx", from = "src" }]
 repository = "https://github.com/dmarienko/Qubx"
 include = [
     # Compiled extensions must be included in the wheel distributions
@@ -16,7 +17,6 @@ include = [
 
 [tool.poetry.dependencies]
 python = ">=3.10,<4.0"
-pytest = {extras = ["lazyfixture"], version = "^7.2.0"}
 numpy = "^1.26.3"
 ntplib = "^0.4.0"
 loguru = "^0.7.2"
@@ -43,34 +43,56 @@ psycopg-binary = "^3.1.19"
 psycopg-pool = "^3.2.2"
 sortedcontainers = "^2.4.0"
 msgspec = "^0.18.6"
+pyyaml = "^6.0.2"
+dash = "^2.18.2"
+dash-bootstrap-components = "^1.6.0"
+tabulate = "^0.9.0"
+jupyter-console = "^6.6.3"
 
 [tool.poetry.group.dev.dependencies]
 pre-commit = "^2.20.0"
-pytest = "^7.1.3"
 rust-just = "^1.36.0"
 twine = "^5.1.1"
 
 #[project.optional-dependencies]
 #numba = "^0.57.1"
 ipykernel = "^6.29.4"
+iprogress = "^0.4"
+click = "^8.1.7"
+ipywidgets = "^8.1.5"
 
 [build-system]
-requires = ["poetry-core", "setuptools", "numpy>=1.26.3", "cython==3.0.8", "toml>=0.10.2"]
+requires = [
+    "poetry-core",
+    "setuptools",
+    "numpy>=1.26.3",
+    "cython==3.0.8",
+    "toml>=0.10.2",
+]
 build-backend = "poetry.core.masonry.api"
 
 [tool.poetry.build]
 script = "build.py"
 generate-setup-file = false
 
-[tool.poetry.scripts]
-qubx = 'qubx.utils.runner:run'
-
 [tool.poetry.group.test.dependencies]
-pytest = "^7.1.3"
+pytest = { extras = ["lazyfixture"], version = "^8.2.0" }
+pytest-asyncio = "^0.24.0"
 pytest-mock = "*"
 
 [tool.pytest.ini_options]
+asyncio_mode = "auto"
+asyncio_default_fixture_loop_scope = "function"
 pythonpath = ["src"]
-filterwarnings = [
-    "ignore:.*Jupyter is migrating.*:DeprecationWarning",
-]
+markers = ["integration: mark a test as an integration test"]
+addopts = "--disable-warnings -s"
+filterwarnings = ["ignore:.*Jupyter is migrating.*:DeprecationWarning"]
+
+[tool.ruff]
+line-length = 120
+
+[tool.ruff.lint.extend-per-file-ignores]
+"*.ipynb" = ["F405", "F401", "E701", "E402", "F403", "E401", "E702"]
+
+[tool.poetry.scripts]
+qubx = "qubx.utils.runner:main"

{qubx-0.4.3 → qubx-0.5.1}/src/qubx/__init__.py

@@ -1,10 +1,13 @@
+import os
+import sys
 from typing import Callable
-from qubx.utils import set_mpl_theme, runtime_env
-from qubx.utils.misc import install_pyx_recompiler_for_dev
 
+import stackprinter
 from loguru import logger
-import os, sys, stackprinter
+
 from qubx.core.lookups import FeesLookup, GlobalLookup, InstrumentsLookup
+from qubx.utils import runtime_env, set_mpl_theme
+from qubx.utils.misc import install_pyx_recompiler_for_dev
 
 # - TODO: import some main methods from packages
 
@@ -15,7 +18,10 @@ def formatter(record):
     if record["level"].name in {"WARNING", "SNAKY"}:
         fmt = "<cyan>{name}</cyan>:<cyan>{function}</cyan>:<cyan>{line}</cyan> - %s" % fmt
 
-    prefix = "<green>{time:YYYY-MM-DD HH:mm:ss.SSS}</green> [ <level>%s</level> ] " % record["level"].icon
+    prefix = (
+        "<green>{time:YYYY-MM-DD HH:mm:ss.SSS}</green> [ <level>%s</level> ] <cyan>({module})</cyan> "
+        % record["level"].icon
+    )
 
     if record["exception"] is not None:
         # stackprinter.set_excepthook(style='darkbg2')
@@ -29,7 +35,6 @@ def formatter(record):
 
 
 class QubxLogConfig:
-
     @staticmethod
     def get_log_level():
         return os.getenv("QUBX_LOG_LEVEL", "DEBUG")
@@ -64,8 +69,8 @@ lookup = GlobalLookup(InstrumentsLookup(), FeesLookup())
 
 # registering magic for jupyter notebook
 if runtime_env() in ["notebook", "shell"]:
-    from IPython.core.magic import Magics, magics_class, line_magic, line_cell_magic
     from IPython.core.getipython import get_ipython
+    from IPython.core.magic import Magics, line_cell_magic, line_magic, magics_class
 
     @magics_class
     class QubxMagics(Magics):
@@ -107,14 +112,15 @@ if runtime_env() in ["notebook", "shell"]:
             if line:
                 if "dark" in line.lower():
                     set_mpl_theme("dark")
+                    # - temporary workaround for vscode - dark theme not applying to ipywidgets in notebook
+                    # - see https://github.com/microsoft/vscode-jupyter/issues/7161
+                    if runtime_env() == "notebook":
+                        _vscode_clr_trick = """from IPython.display import display, HTML; display(HTML("<style> .cell-output-ipywidget-background { background-color: transparent !important; } :root { --jp-widgets-color: var(--vscode-editor-foreground); --jp-widgets-font-size: var(--vscode-editor-font-size); } </style>"))"""
+                        exec(_vscode_clr_trick, self.shell.user_ns)
 
                 elif "light" in line.lower():
                     set_mpl_theme("light")
 
-            # install additional plotly helpers
-            # from qube.charting.plot_helpers import install_plotly_helpers
-            # install_plotly_helpers()
-
         def _get_manager(self):
             if self.__manager is None:
                 import multiprocessing as m
@@ -133,7 +139,8 @@ if runtime_env() in ["notebook", "shell"]:
 
             """
             import multiprocessing as m
-            import time, re
+            import re
+            import time
 
             # create ext args
             name = None
@@ -148,7 +155,7 @@ if runtime_env() in ["notebook", "shell"]:
                         return
 
                 ipy = get_ipython()
-                for a in [x for x in re.split("[\ ,;]", line.strip()) if x]:
+                for a in [x for x in re.split(r"[\ ,;]", line.strip()) if x]:
                     ipy.push({a: self._get_manager().Value(None, None)})
 
             # code to run

{qubx-0.4.3 → qubx-0.5.1}/src/qubx/_nb_magic.py

@@ -1,4 +1,4 @@
-""""
+""" "
 Here stuff we want to have in every Jupyter notebook after calling %qubx magic
 """
 
@@ -27,66 +27,65 @@ def np_fmt_reset():
 
 
 if runtime_env() in ["notebook", "shell"]:
-
     # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
     # -- all imports below will appear in notebook after calling %%qubx magic ---
     # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 
     # - - - - Common stuff - - - -
+    from datetime import time, timedelta
+
     import numpy as np
     import pandas as pd
-    from datetime import time, timedelta
+
+    # - - - - Charting stuff - - - -
+    from matplotlib import pyplot as plt
     from tqdm.auto import tqdm
 
     # - - - - TA stuff and indicators - - - -
     import qubx.pandaz.ta as pta
     import qubx.ta.indicators as ta
+    from qubx.backtester.optimization import variate
+
+    # - - - - Simulator stuff - - - -
+    from qubx.backtester.simulator import simulate
 
     # - - - - Portfolio analysis - - - -
     from qubx.core.metrics import (
-        tearsheet,
         chart_signals,
-        get_symbol_pnls,
-        get_equity,
-        portfolio_metrics,
-        pnl,
         drop_symbols,
+        get_symbol_pnls,
         pick_symbols,
+        pnl,
+        portfolio_metrics,
+        tearsheet,
     )
+    from qubx.data.helpers import loader
 
     # - - - - Data reading - - - -
     from qubx.data.readers import (
-        CsvStorageDataReader,
-        MultiQdbConnector,
-        QuestDBConnector,
         AsOhlcvSeries,
         AsPandasFrame,
         AsQuotes,
         AsTimestampedRecords,
+        CsvStorageDataReader,
+        MultiQdbConnector,
+        QuestDBConnector,
         RestoreTicksFromOHLC,
     )
-    from qubx.data.helpers import loader
-
-    # - - - - Simulator stuff - - - -
-    from qubx.backtester.simulator import simulate
-    from qubx.backtester.optimization import variate
-
-    # - - - - Charting stuff - - - -
-    from matplotlib import pyplot as plt
-    from qubx.utils.charting.mpl_helpers import fig, subplot, sbp, plot_trends, ohlc_plot
-    from qubx.utils.charting.lookinglass import LookingGlass
 
     # - - - - Utils - - - -
     from qubx.pandaz.utils import (
-        scols,
-        srows,
-        ohlc_resample,
         continuous_periods,
-        generate_equal_date_ranges,
         drop_duplicated_indexes,
+        generate_equal_date_ranges,
+        ohlc_resample,
         retain_columns_and_join,
         rolling_forward_test_split,
+        scols,
+        srows,
     )
+    from qubx.utils.charting.lookinglass import LookingGlass
+    from qubx.utils.charting.mpl_helpers import fig, ohlc_plot, plot_trends, sbp, subplot
 
     # - setup short numpy output format
     np_fmt_short()

qubx-0.5.1/src/qubx/backtester/account.py

@@ -0,0 +1,146 @@
+from qubx import logger
+from qubx.backtester.ome import OrdersManagementEngine
+from qubx.core.account import BasicAccountProcessor
+from qubx.core.basics import (
+    ZERO_COSTS,
+    BatchEvent,
+    CtrlChannel,
+    Instrument,
+    Order,
+    Position,
+    Timestamped,
+    TransactionCostsCalculator,
+    dt_64,
+)
+from qubx.core.interfaces import ITimeProvider
+from qubx.core.series import Bar, OrderBook, Quote, Trade
+
+
+class SimulatedAccountProcessor(BasicAccountProcessor):
+    ome: dict[Instrument, OrdersManagementEngine]
+    order_to_instrument: dict[str, Instrument]
+
+    _channel: CtrlChannel
+    _fill_stop_order_at_price: bool
+    _half_tick_size: dict[Instrument, float]
+
+    def __init__(
+        self,
+        account_id: str,
+        channel: CtrlChannel,
+        base_currency: str,
+        initial_capital: float,
+        time_provider: ITimeProvider,
+        tcc: TransactionCostsCalculator = ZERO_COSTS,
+        accurate_stop_orders_execution: bool = False,
+    ) -> None:
+        super().__init__(
+            account_id=account_id,
+            time_provider=time_provider,
+            base_currency=base_currency,
+            tcc=tcc,
+            initial_capital=initial_capital,
+        )
+        self.ome = {}
+        self.order_to_instrument = {}
+        self._channel = channel
+        self._half_tick_size = {}
+        self._fill_stop_order_at_price = accurate_stop_orders_execution
+        if self._fill_stop_order_at_price:
+            logger.info(f"{self.__class__.__name__} emulates stop orders executions at exact price")
+
+    def get_orders(self, instrument: Instrument | None = None) -> list[Order]:
+        if instrument is not None:
+            ome = self.ome.get(instrument)
+            if ome is None:
+                raise ValueError(f"ExchangeService:get_orders :: No OME configured for '{instrument}'!")
+            return ome.get_open_orders()
+
+        return [o for ome in self.ome.values() for o in ome.get_open_orders()]
+
+    def get_position(self, instrument: Instrument) -> Position:
+        if instrument in self.positions:
+            return self.positions[instrument]
+
+        # - initiolize OME for this instrument
+        self.ome[instrument] = OrdersManagementEngine(
+            instrument=instrument,
+            time_provider=self.time_provider,
+            tcc=self._tcc,  # type: ignore
+            fill_stop_order_at_price=self._fill_stop_order_at_price,
+        )
+
+        # - initiolize empty position
+        position = Position(instrument)  # type: ignore
+        self._half_tick_size[instrument] = instrument.tick_size / 2  # type: ignore
+        self.attach_positions(position)
+        return self.positions[instrument]
+
+    def update_position_price(self, time: dt_64, instrument: Instrument, price: float) -> None:
+        super().update_position_price(time, instrument, price)
+
+        # - first we need to update OME with new quote.
+        # - if update is not a quote we need 'emulate' it.
+        # - actually if SimulatedExchangeService is used in backtesting mode it will recieve only quotes
+        # - case when we need that - SimulatedExchangeService is used for paper trading and data provider configured to listen to OHLC or TAS.
+        # - probably we need to subscribe to quotes in real data provider in any case and then this emulation won't be needed.
+        quote = price if isinstance(price, Quote) else self.emulate_quote_from_data(instrument, time, price)
+        if quote is None:
+            return
+
+        # - process new quote
+        self._process_new_quote(instrument, quote)
+
+    def process_order(self, order: Order, update_locked_value: bool = True) -> None:
+        _new = order.status == "NEW"
+        _open = order.status == "OPEN"
+        _cancel = order.status == "CANCELED"
+        _closed = order.status == "CLOSED"
+        if _new or _open:
+            self.order_to_instrument[order.id] = order.instrument
+        if (_cancel or _closed) and order.id in self.order_to_instrument:
+            self.order_to_instrument.pop(order.id)
+        return super().process_order(order, update_locked_value)
+
+    def emulate_quote_from_data(
+        self, instrument: Instrument, timestamp: dt_64, data: float | Timestamped | BatchEvent
+    ) -> Quote | None:
+        if instrument not in self._half_tick_size:
+            _ = self.get_position(instrument)
+
+        _ts2 = self._half_tick_size[instrument]
+        if isinstance(data, Quote):
+            return data
+
+        elif isinstance(data, Trade):
+            if data.taker:  # type: ignore
+                return Quote(timestamp, data.price - _ts2 * 2, data.price, 0, 0)  # type: ignore
+            else:
+                return Quote(timestamp, data.price, data.price + _ts2 * 2, 0, 0)  # type: ignore
+
+        elif isinstance(data, Bar):
+            return Quote(timestamp, data.close - _ts2, data.close + _ts2, 0, 0)  # type: ignore
+
+        elif isinstance(data, OrderBook):
+            return data.to_quote()
+
+        elif isinstance(data, BatchEvent):
+            return self.emulate_quote_from_data(instrument, timestamp, data.data[-1])
+
+        elif isinstance(data, float):
+            return Quote(timestamp, data - _ts2, data + _ts2, 0, 0)
+
+        else:
+            return None
+
+    def _process_new_quote(self, instrument: Instrument, data: Quote) -> None:
+        ome = self.ome.get(instrument)
+        if ome is None:
+            logger.warning("ExchangeService:update :: No OME configured for '{symbol}' yet !")
+            return
+        for r in ome.update_bbo(data):
+            if r.exec is not None:
+                self.order_to_instrument.pop(r.order.id)
+                # - process methods will be called from stg context
+                self._channel.send((instrument, "order", r.order, False))
+                self._channel.send((instrument, "deals", [r.exec], False))

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

@@ -0,0 +1,87 @@
+from qubx.backtester.ome import OmeReport
+from qubx.core.basics import (
+    CtrlChannel,
+    Instrument,
+    Order,
+)
+from qubx.core.interfaces import IBroker
+
+from .account import SimulatedAccountProcessor
+
+
+class SimulatedBroker(IBroker):
+    channel: CtrlChannel
+
+    _account: SimulatedAccountProcessor
+
+    def __init__(
+        self,
+        channel: CtrlChannel,
+        account: SimulatedAccountProcessor,
+        exchange_id: str = "simulated",
+    ) -> None:
+        self.channel = channel
+        self._account = account
+        self._exchange_id = exchange_id
+
+    @property
+    def is_simulated_trading(self) -> bool:
+        return True
+
+    def send_order(
+        self,
+        instrument: Instrument,
+        order_side: str,
+        order_type: str,
+        amount: float,
+        price: float | None = None,
+        client_id: str | None = None,
+        time_in_force: str = "gtc",
+        **options,
+    ) -> Order:
+        ome = self._account.ome.get(instrument)
+        if ome is None:
+            raise ValueError(f"ExchangeService:send_order :: No OME configured for '{instrument.symbol}'!")
+
+        # - try to place order in OME
+        report = ome.place_order(
+            order_side.upper(),  # type: ignore
+            order_type.upper(),  # type: ignore
+            amount,
+            price,
+            client_id,
+            time_in_force,
+            **options,
+        )
+
+        self._send_exec_report(instrument, report)
+        return report.order
+
+    def cancel_order(self, order_id: str) -> Order | None:
+        instrument = self._account.order_to_instrument.get(order_id)
+        if instrument is None:
+            raise ValueError(f"ExchangeService:cancel_order :: can't find order with id = '{order_id}'!")
+
+        ome = self._account.ome.get(instrument)
+        if ome is None:
+            raise ValueError(f"ExchangeService:send_order :: No OME configured for '{instrument}'!")
+
+        # - cancel order in OME and remove from the map to free memory
+        order_update = ome.cancel_order(order_id)
+        self._send_exec_report(instrument, order_update)
+
+        return order_update.order
+
+    def cancel_orders(self, instrument: Instrument) -> None:
+        raise NotImplementedError("Not implemented yet")
+
+    def update_order(self, order_id: str, price: float | None = None, amount: float | None = None) -> Order:
+        raise NotImplementedError("Not implemented yet")
+
+    def _send_exec_report(self, instrument: Instrument, report: OmeReport):
+        self.channel.send((instrument, "order", report.order, False))
+        if report.exec is not None:
+            self.channel.send((instrument, "deals", [report.exec], False))
+
+    def exchange(self) -> str:
+        return self._exchange_id.upper()