Qubx 0.5.7__cp312-cp312-manylinux_2_39_x86_64.whl

qubx/__init__.py

@@ -0,0 +1,207 @@
+import os
+import sys
+from typing import Callable
+
+import stackprinter
+from loguru import logger
+
+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
+
+
+def formatter(record):
+    end = record["extra"].get("end", "\n")
+    fmt = "<lvl>{message}</lvl>%s" % end
+    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> ] <cyan>({module})</cyan> "
+        % record["level"].icon
+    )
+
+    if record["exception"] is not None:
+        # stackprinter.set_excepthook(style='darkbg2')
+        record["extra"]["stack"] = stackprinter.format(record["exception"], style="darkbg3")
+        fmt += "\n{extra[stack]}\n"
+
+    if record["level"].name in {"TEXT"}:
+        prefix = ""
+
+    return prefix + fmt
+
+
+class QubxLogConfig:
+    @staticmethod
+    def get_log_level():
+        return os.getenv("QUBX_LOG_LEVEL", "WARNING")
+
+    @staticmethod
+    def set_log_level(level: str):
+        os.environ["QUBX_LOG_LEVEL"] = level
+        QubxLogConfig.setup_logger(level)
+
+    @staticmethod
+    def setup_logger(level: str | None = None, custom_formatter: Callable | None = None):
+        global logger
+        config = {
+            "handlers": [
+                {"sink": sys.stdout, "format": "{time} - {message}"},
+            ],
+            "extra": {"user": "someone"},
+        }
+        logger.configure(**config)
+        logger.remove(None)
+        level = level or QubxLogConfig.get_log_level()
+        logger.add(sys.stdout, format=custom_formatter or formatter, colorize=True, level=level, enqueue=True)
+        logger = logger.opt(colors=True)
+
+
+QubxLogConfig.setup_logger()
+
+
+# - global lookup helper
+lookup = GlobalLookup(InstrumentsLookup(), FeesLookup())
+
+
+# registering magic for jupyter notebook
+if runtime_env() in ["notebook", "shell"]:
+    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):
+        # process data manager
+        __manager = None
+
+        @line_magic
+        def qubx(self, line: str):
+            self.qubx_setup("dark" + " " + line)
+
+        @line_magic
+        def qubxd(self, line: str):
+            self.qubx_setup("dark" + " " + line)
+
+        @line_magic
+        def qubxl(self, line: str):
+            self.qubx_setup("light" + " " + line)
+
+        @line_magic
+        def qubx_setup(self, line: str):
+            """
+            QUBX framework initialization
+            """
+            import os
+
+            args = [x.strip() for x in line.split(" ")]
+
+            # setup cython dev hooks - only if 'dev' is passed as argument
+            if line and "dev" in args:
+                install_pyx_recompiler_for_dev()
+
+            tpl_path = os.path.join(os.path.dirname(__file__), "_nb_magic.py")
+            with open(tpl_path, "r", encoding="utf8") as myfile:
+                s = myfile.read()
+
+            exec(s, self.shell.user_ns)
+
+            # setup more funcy mpl theme instead of ugly default
+            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); } .widget-hprogress, .jupyter-widget-hprogress { height: 16px; align-self: center; kj} table.dataframe, .dataframe td, .dataframe tr { border: 1px solid #55554a85; border-collapse: collapse; color: #859548d9 !important; } .dataframe th { border: 1px solid #55554a85; border-collapse: collapse; background-color: #010101 !important; color: #177 !important; } </style>"))"""
+                        exec(_vscode_clr_trick, self.shell.user_ns)
+
+                elif "light" in line.lower():
+                    set_mpl_theme("light")
+
+        def _get_manager(self):
+            if self.__manager is None:
+                import multiprocessing as m
+
+                self.__manager = m.Manager()
+            return self.__manager
+
+        @line_cell_magic
+        def proc(self, line, cell=None):
+            """
+            Run cell in separate process
+
+            >>> %%proc x, y as MyProc1
+            >>> x.set('Hello')
+            >>> y.set([1,2,3,4])
+
+            """
+            import multiprocessing as m
+            import re
+            import time
+
+            # create ext args
+            name = None
+            if line:
+                # check if custom process name was provided
+                if " as " in line:
+                    line, name = line.split("as")
+                    if not name.isspace():
+                        name = name.strip()
+                    else:
+                        print('>>> Process name must be specified afer "as" keyword !')
+                        return
+
+                ipy = get_ipython()
+                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
+            lines = "\n".join(["    %s" % x for x in cell.split("\n")])
+
+            def fn():
+                result = get_ipython().run_cell(lines)
+
+                # send errors to parent
+                if result.error_before_exec:
+                    raise result.error_before_exec
+
+                if result.error_in_exec:
+                    raise result.error_in_exec
+
+            t_start = str(time.time()).replace(".", "_")
+            f_id = f"proc_{t_start}" if name is None else name
+            if self._is_task_name_already_used(f_id):
+                f_id = f"{f_id}_{t_start}"
+
+            task = m.Process(target=fn, name=f_id)
+            task.start()
+            print(" -> Task %s is started" % f_id)
+
+        def _is_task_name_already_used(self, name):
+            import multiprocessing as m
+
+            for p in m.active_children():
+                if p.name == name:
+                    return True
+            return False
+
+        @line_magic
+        def list_proc(self, line):
+            import multiprocessing as m
+
+            for p in m.active_children():
+                print(p.name)
+
+        @line_magic
+        def kill_proc(self, line):
+            import multiprocessing as m
+
+            for p in m.active_children():
+                if line and p.name.startswith(line):
+                    p.terminate()
+
+    # - registering magic here
+    get_ipython().register_magics(QubxMagics)  # type: ignore

qubx/_nb_magic.py

@@ -0,0 +1,100 @@
+""" "
+Here stuff we want to have in every Jupyter notebook after calling %qubx magic
+"""
+
+import qubx
+from qubx.utils import runtime_env
+from qubx.utils.misc import add_project_to_system_path, logo
+
+
+def np_fmt_short():
+    # default np output is 75 columns so extend it a bit and suppress scientific fmt for small floats
+    np.set_printoptions(linewidth=240, suppress=True)
+
+
+def np_fmt_reset():
+    # reset default np printing options
+    np.set_printoptions(
+        edgeitems=3,
+        infstr="inf",
+        linewidth=75,
+        nanstr="nan",
+        precision=8,
+        suppress=False,
+        threshold=1000,
+        formatter=None,
+    )
+
+
+if runtime_env() in ["notebook", "shell"]:
+    # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+    # -- all imports below will appear in notebook after calling %%qubx magic ---
+    # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+
+    # - - - - Common stuff - - - -
+    from datetime import time, timedelta  # noqa: F401
+
+    import numpy as np  # noqa: F401
+    import pandas as pd  # noqa: F401
+
+    # - - - - Charting stuff - - - -
+    from matplotlib import pyplot as plt  # noqa: F401
+    from tqdm.auto import tqdm  # noqa: F401
+
+    # - - - - TA stuff and indicators - - - -
+    import qubx.pandaz.ta as pta  # noqa: F401
+    import qubx.ta.indicators as ta  # noqa: F401
+    from qubx.backtester.optimization import variate  # noqa: F401
+
+    # - - - - Simulator stuff - - - -
+    from qubx.backtester.simulator import simulate  # noqa: F401
+
+    # - - - - Portfolio analysis - - - -
+    from qubx.core.metrics import (  # noqa: F401
+        chart_signals,
+        drop_symbols,
+        get_symbol_pnls,
+        pick_symbols,
+        pnl,
+        portfolio_metrics,
+        tearsheet,
+    )
+    from qubx.data.helpers import loader  # noqa: F401
+
+    # - - - - Data reading - - - -
+    from qubx.data.readers import (  # noqa: F401
+        AsOhlcvSeries,
+        AsPandasFrame,
+        AsQuotes,
+        AsTimestampedRecords,
+        CsvStorageDataReader,
+        MultiQdbConnector,
+        QuestDBConnector,
+        RestoreTicksFromOHLC,
+    )
+
+    # - - - - Utils - - - -
+    from qubx.pandaz.utils import (  # noqa: F401
+        continuous_periods,
+        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  # noqa: F401
+    from qubx.utils.charting.mpl_helpers import fig, ohlc_plot, plot_trends, sbp, subplot  # noqa: F401
+    from qubx.utils.misc import this_project_root  # noqa: F401
+
+    # - setup short numpy output format
+    np_fmt_short()
+
+    # - add project home to system path
+    add_project_to_system_path()
+
+    # show logo first time
+    if not hasattr(qubx.QubxMagics, "__already_initialized__"):
+        setattr(qubx.QubxMagics, "__already_initialized__", True)
+        logo()

qubx/backtester/__init__.py

@@ -0,0 +1,5 @@
+__all__ = ["BacktestsResultsManager", "variate", "simulate"]
+
+from .management import BacktestsResultsManager
+from .optimization import variate
+from .simulator import simulate

qubx/backtester/account.py

@@ -0,0 +1,145 @@
+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,
+    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"[<y>{self.__class__.__name__}</y>] :: emulates stop orders executions at exact price")
+
+    def get_orders(self, instrument: Instrument | None = None) -> dict[str, 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 {o.id: o for o in ome.get_open_orders()}
+
+        return {o.id: 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
+    ) -> Quote | None:
+        if instrument not in self._half_tick_size:
+            _ = self.get_position(instrument)
+
+        if isinstance(data, Quote):
+            return data
+
+        elif isinstance(data, Trade):
+            _ts2 = self._half_tick_size[instrument]
+            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):
+            _ts2 = self._half_tick_size[instrument]
+            return Quote(timestamp, data.close - _ts2, data.close + _ts2, 0, 0)  # type: ignore
+
+        elif isinstance(data, OrderBook):
+            return data.to_quote()
+
+        elif isinstance(data, float):
+            _ts2 = self._half_tick_size[instrument]
+            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/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()