Qubx 0.4.2__tar.gz → 0.5.0__tar.gz

{qubx-0.4.2 → qubx-0.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: Qubx
-Version: 0.4.2
+Version: 0.5.0
 Summary: Qubx - quantitative trading framework
 Home-page: https://github.com/dmarienko/Qubx
 Author: Dmitry Marienko
@@ -13,6 +13,8 @@ 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: loguru (>=0.7.2,<0.8.0)
 Requires-Dist: matplotlib (>=3.8.4,<4.0.0)
@@ -28,9 +30,9 @@ 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)
@@ -70,3 +72,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.2 → qubx-0.5.0}/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.2 → qubx-0.5.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "Qubx"
-version = "0.4.2"
+version = "0.5.0"
 description = "Qubx - quantitative trading framework"
 authors = ["Dmitry Marienko <dmitry@gmail.com>", "Yuriy Arabskyy <yuriy.arabskyy@gmail.com>"]
 readme = "README.md"
@@ -16,7 +16,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,16 +42,21 @@ 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"
 
 [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"]
@@ -62,15 +66,25 @@ build-backend = "poetry.core.masonry.api"
 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"]
+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"]

{qubx-0.4.2 → qubx-0.5.0}/src/qubx/__init__.py

@@ -15,7 +15,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 +32,6 @@ def formatter(record):
 
 
 class QubxLogConfig:
-
     @staticmethod
     def get_log_level():
         return os.getenv("QUBX_LOG_LEVEL", "DEBUG")
@@ -107,14 +109,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

{qubx-0.4.2 → qubx-0.5.0}/src/qubx/_nb_magic.py

@@ -1,4 +1,4 @@
-""""
+""" "
 Here stuff we want to have in every Jupyter notebook after calling %qubx magic
 """
 
@@ -27,7 +27,6 @@ def np_fmt_reset():
 
 
 if runtime_env() in ["notebook", "shell"]:
-
     # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
     # -- all imports below will appear in notebook after calling %%qubx magic ---
     # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

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

@@ -0,0 +1,134 @@
+from qubx import logger
+from qubx.backtester.ome import OrdersManagementEngine
+from qubx.core.account import BasicAccountProcessor
+from qubx.core.basics import (
+    ZERO_COSTS,
+    CtrlChannel,
+    Instrument,
+    Order,
+    Position,
+    TransactionCostsCalculator,
+    dt_64,
+)
+from qubx.core.interfaces import ITimeProvider
+from qubx.core.series import Bar, 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 | Trade | Bar
+    ) -> 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, 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.0/src/qubx/backtester/broker.py

@@ -0,0 +1,82 @@
+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,
+    ) -> None:
+        self.channel = channel
+        self._account = account
+
+    @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))