Qubx 0.5.3__tar.gz → 0.5.6__tar.gz

{qubx-0.5.3 → qubx-0.5.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: Qubx
-Version: 0.5.3
+Version: 0.5.6
 Summary: Qubx - quantitative trading framework
 Home-page: https://github.com/dmarienko/Qubx
 Author: Dmitry Marienko

{qubx-0.5.3 → qubx-0.5.6}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "Qubx"
-version = "0.5.3"
+version = "0.5.6"
 description = "Qubx - quantitative trading framework"
 authors = [
     "Dmitry Marienko <dmitry@gmail.com>",

{qubx-0.5.3 → qubx-0.5.6}/src/qubx/backtester/account.py

@@ -48,14 +48,15 @@ class SimulatedAccountProcessor(BasicAccountProcessor):
         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) -> list[Order]:
+    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 ome.get_open_orders()
 
-        return [o for ome in self.ome.values() for o in ome.get_open_orders()]
+            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:

qubx-0.5.6/src/qubx/backtester/management.py

@@ -0,0 +1,237 @@
+import re
+import zipfile
+from collections import defaultdict
+from pathlib import Path
+
+import pandas as pd
+import yaml
+
+from qubx.core.metrics import TradingSessionResult, _pfl_metrics_prepare
+from qubx.utils.misc import blue, cyan, green, magenta, red, yellow
+
+
+class BacktestsResultsManager:
+    """
+    Manager class for handling backtesting results.
+
+    This class provides functionality to load, list and manage backtesting results stored in zip files.
+    Each result contains trading session information and metrics that can be loaded and analyzed.
+
+    Parameters
+    ----------
+    path : str
+        Path to directory containing backtesting result zip files
+
+    Methods
+    -------
+    reload()
+        Reloads all backtesting results from the specified path
+    list(regex="", with_metrics=False)
+        Lists all backtesting results, optionally filtered by regex and including metrics
+    load(name)
+        Loads a specific backtesting result by name
+    """
+
+    def __init__(self, path: str):
+        self.path = path
+        self.reload()
+
+    def reload(self) -> "BacktestsResultsManager":
+        self.results = {}
+        names = defaultdict(lambda: 0)
+        for p in Path(self.path).glob("**/*.zip"):
+            with zipfile.ZipFile(p, "r") as zip_ref:
+                try:
+                    info = yaml.safe_load(zip_ref.read("info.yml"))
+                    info["path"] = str(p)
+                    n = info.get("name", "")
+                    _new_name = n if names[n] == 0 else f"{n}.{names[n]}"
+                    names[n] += 1
+                    info["name"] = _new_name
+                    self.results[_new_name] = info
+                except Exception:
+                    pass
+
+        # - reindex
+        _idx = 1
+        for n in sorted(self.results.keys()):
+            self.results[n]["idx"] = _idx
+            _idx += 1
+
+        return self
+
+    def __getitem__(
+        self, name: str | int | list[int] | list[str] | slice
+    ) -> TradingSessionResult | list[TradingSessionResult]:
+        return self.load(name)
+
+    def load(
+        self, name: str | int | list[int] | list[str] | slice
+    ) -> TradingSessionResult | list[TradingSessionResult]:
+        match name:
+            case list():
+                return [self.load(i) for i in name]
+            case slice():
+                return [self.load(i) for i in range(name.start, name.stop, name.step if name.step else 1)]
+
+        for info in self.results.values():
+            match name:
+                case int():
+                    if info.get("idx", -1) == name:
+                        return TradingSessionResult.from_file(info["path"])
+                case str():
+                    if info.get("name", "") == name:
+                        return TradingSessionResult.from_file(info["path"])
+        raise ValueError(f"No result found for {name}")
+
+    def delete(self, name: str | int | list[int] | list[str] | slice):
+        def _del_idx(idx):
+            for info in self.results.values():
+                if info.get("idx", -1) == idx:
+                    Path(info["path"]).unlink()
+                    return info.get("name", idx)
+            return None
+
+        match name:
+            case str():
+                nms = [_del_idx(i) for i in self._find_indices(name)]
+                self.reload()
+                print(f" -> Deleted {red(', '.join(nms))} ...")
+                return
+
+            case list():
+                nms = [_del_idx(i) for i in name]
+                self.reload()
+                print(f" -> Deleted {red(', '.join(nms))} ...")
+                return
+
+            case slice():
+                nms = [_del_idx(i) for i in range(name.start, name.stop, name.step if name.step else 1)]
+                self.reload()
+                print(f" -> Deleted {red(', '.join(nms))} ...")
+                return
+
+        for info in self.results.values():
+            match name:
+                case int():
+                    if info.get("idx", -1) == name:
+                        Path(info["path"]).unlink()
+                        print(f" -> Deleted {red(info.get('name', name))} ...")
+                        self.reload()
+                        return
+                case str():
+                    if info.get("name", "") == name:
+                        Path(info["path"]).unlink()
+                        print(f" -> Deleted {red(info.get('name', name))} ...")
+                        self.reload()
+                        return
+        print(f" -> No results found for {red(name)} !")
+
+    def _find_indices(self, regex: str):
+        for n in sorted(self.results.keys()):
+            info = self.results[n]
+            s_cls = info.get("strategy_class", "").split(".")[-1]
+
+            try:
+                if not re.match(regex, n, re.IGNORECASE):
+                    if not re.match(regex, s_cls, re.IGNORECASE):
+                        continue
+            except Exception:
+                if regex.lower() != n.lower() and regex.lower() != s_cls.lower():
+                    continue
+
+            yield info.get("idx", -1)
+
+    def list(self, regex: str = "", with_metrics=True, params=False, as_table=False):
+        """List backtesting results with optional filtering and formatting.
+
+        Args:
+            - regex (str, optional): Regular expression pattern to filter results by strategy name or class. Defaults to "".
+            - with_metrics (bool, optional): Whether to include performance metrics in output. Defaults to True.
+            - params (bool, optional): Whether to display strategy parameters. Defaults to False.
+            - as_table (bool, optional): Return results as a pandas DataFrame instead of printing. Defaults to False.
+
+        Returns:
+            - Optional[pd.DataFrame]: If as_table=True, returns a DataFrame containing the results sorted by creation time.
+            - Otherwise prints formatted results to console.
+        """
+        _t_rep = []
+        for n in sorted(self.results.keys()):
+            info = self.results[n]
+            s_cls = info.get("strategy_class", "").split(".")[-1]
+
+            if regex:
+                if not re.match(regex, n, re.IGNORECASE):
+                    if not re.match(regex, s_cls, re.IGNORECASE):
+                        continue
+
+            name = info.get("name", "")
+            smbs = ", ".join(info.get("symbols", list()))
+            start = pd.Timestamp(info.get("start", "")).round("1s")
+            stop = pd.Timestamp(info.get("stop", "")).round("1s")
+            dscr = info.get("description", "")
+            created = pd.Timestamp(info.get("creation_time", "")).round("1s")
+            metrics = info.get("performance", {})
+            author = info.get("author", "")
+            _s = f"{yellow(str(info.get('idx')))} - {red(name)} ::: {magenta(created)} by {cyan(author)}"
+
+            _one_line_dscr = ""
+            if dscr:
+                dscr = dscr.split("\n")
+                for _d in dscr:
+                    _s += f"\n\t{magenta('# ' + _d)}"
+                    _one_line_dscr += " " + _d
+
+            _s += f"\n\tstrategy: {green(s_cls)}"
+            _s += f"\n\tinterval: {blue(start)} - {blue(stop)}"
+            _s += f"\n\tcapital: {blue(info.get('capital', ''))} {info.get('base_currency', '')} ({info.get('commissions', '')})"
+            _s += f"\n\tinstruments: {blue(smbs)}"
+            if params:
+                formats = ["{" + f":<{i}" + "}" for i in [50]]
+                _p = pd.DataFrame.from_dict(info.get("parameters", {}), orient="index")
+                for i in _p.to_string(
+                    max_colwidth=30,
+                    header=False,
+                    formatters=[(lambda x: cyan(fmt.format(str(x)))) for fmt in formats],
+                    justify="left",
+                ).split("\n"):
+                    _s += f"\n\t  |  {yellow(i)}"
+
+            if not as_table:
+                print(_s)
+
+            if with_metrics:
+                _m_repr = (
+                    pd.DataFrame.from_dict(metrics, orient="index")
+                    .T[["gain", "cagr", "sharpe", "qr", "max_dd_pct", "mdd_usd", "fees", "execs"]]
+                    .astype(float)
+                )
+                _m_repr = _m_repr.round(3).to_string(index=False)
+                _h, _v = _m_repr.split("\n")
+                if not as_table:
+                    print("\t " + red(_h))
+                    print("\t " + cyan(_v))
+
+            if not as_table:
+                print()
+            else:
+                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"]
+                }
+                _t_rep.append(
+                    {"Index": info.get("idx", ""), "Strategy": name}
+                    | metrics
+                    | {
+                        "start": start,
+                        "stop": stop,
+                        "Created": created,
+                        "Author": author,
+                        "Description": _one_line_dscr,
+                    },
+                )
+
+        if as_table:
+            _df = pd.DataFrame.from_records(_t_rep, index="Index")
+            return _df.sort_values(by="Created", ascending=False)

{qubx-0.5.3 → qubx-0.5.6}/src/qubx/backtester/simulator.py

@@ -57,6 +57,7 @@ def simulate(
     open_close_time_indent_secs=1,
     debug: Literal["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"] | None = "WARNING",
     show_latency_report: bool = False,
+    parallel_backend: Literal["loky", "multiprocessing"] = "multiprocessing",
 ) -> list[TradingSessionResult]:
     """
     Backtest utility for trading strategies or signals using historical data.
@@ -149,6 +150,7 @@ def simulate(
         n_jobs=n_jobs,
         silent=silent,
         show_latency_report=show_latency_report,
+        parallel_backend=parallel_backend,
     )
 
 
@@ -160,6 +162,7 @@ def _run_setups(
     n_jobs: int = -1,
     silent: bool = False,
     show_latency_report: bool = False,
+    parallel_backend: Literal["loky", "multiprocessing"] = "multiprocessing",
 ) -> list[TradingSessionResult]:
     # loggers don't work well with joblib and multiprocessing in general because they contain
     # open file handlers that cannot be pickled. I found a solution which requires the usage of enqueue=True
@@ -170,7 +173,7 @@ def _run_setups(
     n_jobs = 1 if _main_loop_silent else n_jobs
 
     reports = ProgressParallel(
-        n_jobs=n_jobs, total=len(strategies_setups), silent=_main_loop_silent, backend="multiprocessing"
+        n_jobs=n_jobs, total=len(strategies_setups), silent=_main_loop_silent, backend=parallel_backend
     )(
         delayed(_run_setup)(id, f"Simulated-{id}", setup, data_setup, start, stop, silent, show_latency_report)
         for id, setup in enumerate(strategies_setups)

{qubx-0.5.3 → qubx-0.5.6}/src/qubx/core/context.py

@@ -34,6 +34,7 @@ from qubx.core.interfaces import (
     ITradingManager,
     IUniverseManager,
     PositionsTracker,
+    RemovalPolicy,
 )
 from qubx.core.loggers import StrategyLogging
 from qubx.data.readers import DataReader
@@ -144,6 +145,7 @@ class StrategyContext(IStrategyContext):
             account=self.account,
             position_tracker=__position_tracker,
             position_gathering=__position_gathering,
+            universe_manager=self._universe_manager,
             cache=self._cache,
             scheduler=self._scheduler,
             is_simulation=self._data_provider.is_simulation,
@@ -325,8 +327,10 @@ class StrategyContext(IStrategyContext):
         return self._trading_manager.cancel_orders(instrument)
 
     # IUniverseManager delegation
-    def set_universe(self, instruments: list[Instrument], skip_callback: bool = False):
-        return self._universe_manager.set_universe(instruments, skip_callback)
+    def set_universe(
+        self, instruments: list[Instrument], skip_callback: bool = False, if_has_position_then: RemovalPolicy = "close"
+    ):
+        return self._universe_manager.set_universe(instruments, skip_callback, if_has_position_then)
 
     def add_instruments(self, instruments: list[Instrument]):
         return self._universe_manager.add_instruments(instruments)

{qubx-0.5.3 → qubx-0.5.6}/src/qubx/core/helpers.py

@@ -14,7 +14,7 @@ from croniter import croniter
 from qubx import logger
 from qubx.core.basics import SW, CtrlChannel, DataType, Instrument, Timestamped
 from qubx.core.series import OHLCV, Bar, OrderBook, Quote, Trade
-from qubx.utils.time import convert_seconds_to_str, convert_tf_str_td64
+from qubx.utils.time import convert_seconds_to_str, convert_tf_str_td64, interval_to_cron
 
 
 class CachedMarketDataHolder:
@@ -204,7 +204,7 @@ def _make_shift(_b, _w, _d, _h, _m, _s):
 
     # return AS_TD(f'{_b*4}W') + AS_TD(f'{_w}W') + AS_TD(f'{_d}D') + AS_TD(f'{_h}h') + AS_TD(f'{_m}Min') + AS_TD(f'{_s}Sec')
     for t in [
-        AS_TD(f"{_b*4}W"),
+        AS_TD(f"{_b * 4}W"),
         AS_TD(f"{_w}W"),
         AS_TD(f"{_d}D"),
         AS_TD(f"{_h}h"),
@@ -218,12 +218,12 @@ def _make_shift(_b, _w, _d, _h, _m, _s):
     return P, N
 
 
-def _parse_schedule_spec(schedule: str) -> Dict[str, str]:
+def _parse_schedule_spec(schedule: str) -> dict[str, str]:
     m = SPEC_REGEX.match(schedule)
     return {k: v for k, v in m.groupdict().items() if v} if m else {}
 
 
-def process_schedule_spec(spec_str: str | None) -> Dict[str, Any]:
+def process_schedule_spec(spec_str: str | None) -> dict[str, Any]:
     AS_INT = lambda d, k: int(d.get(k, 0))  # noqa: E731
     S = lambda s: [x for x in re.split(r"[, ]", s) if x]  # noqa: E731
     config = {}
@@ -246,10 +246,16 @@ def process_schedule_spec(spec_str: str | None) -> Dict[str, Any]:
 
     match _T:
         case "cron":
-            if not _S or croniter.is_valid(_S):
-                config = dict(type="cron", schedule=_S, spec=_S)
-            else:
-                raise ValueError(f"Wrong specification for cron type: {_S}")
+            if not _S:
+                raise ValueError(f"Empty specification for cron: {spec_str}")
+
+            if not croniter.is_valid(_S):
+                _S = interval_to_cron(_S)
+
+                if not croniter.is_valid(_S):
+                    raise ValueError(f"Wrong specification for cron: {spec_str}")
+
+            config = dict(type="cron", schedule=_S, spec=_S)
 
         case "time":
             for t in _t:
@@ -265,13 +271,20 @@ def process_schedule_spec(spec_str: str | None) -> Dict[str, Any]:
                     if croniter.is_valid(_S):
                         config = dict(type="cron", schedule=_S, spec=_S)
                     else:
-                        if _has_intervals:
-                            _F = (
-                                convert_seconds_to_str(int(_s_pos.as_unit("s").to_timedelta64().item().total_seconds()))
-                                if not _F
-                                else _F
-                            )
-                            config = dict(type="bar", schedule=None, timeframe=_F, delay=_s_neg, spec=_S)
+                        # - try convert to cron
+                        _S = interval_to_cron(_S)
+                        if croniter.is_valid(_S):
+                            config = dict(type="cron", schedule=_S, spec=_S)
+                        else:
+                            if _has_intervals:
+                                _F = (
+                                    convert_seconds_to_str(
+                                        int(_s_pos.as_unit("s").to_timedelta64().item().total_seconds())
+                                    )
+                                    if not _F
+                                    else _F
+                                )
+                                config = dict(type="bar", schedule=None, timeframe=_F, delay=_s_neg, spec=_S)
         case _:
             config = dict(type=_T, schedule=None, timeframe=_F, delay=_shift, spec=_S)
 
@@ -348,6 +361,7 @@ class BasicScheduler:
             # - update next nearest time
             self._next_times[event] = next_time
             self._next_nearest_time = np.datetime64(int(min(self._next_times.values()) * 1000000000), "ns")
+            # logger.debug(f" >>> ({event}) task is scheduled at {self._next_nearest_time}")
 
             return True
         logger.debug(f"({event}) task is not scheduled")

{qubx-0.5.3 → qubx-0.5.6}/src/qubx/core/interfaces.py

@@ -10,7 +10,7 @@ This module includes:
 """
 
 import traceback
-from typing import Any, Dict, List, Set, Tuple
+from typing import Any, Dict, List, Literal, Set, Tuple
 
 import numpy as np
 import pandas as pd
@@ -36,6 +36,8 @@ from qubx.core.basics import (
 from qubx.core.helpers import set_parameters_to_object
 from qubx.core.series import OHLCV, Bar, Quote
 
+RemovalPolicy = Literal["close", "wait_for_close", "wait_for_change"]
+
 
 class IAccountViewer:
     account_id: str
@@ -568,11 +570,18 @@ class ITradingManager:
 class IUniverseManager:
     """Manages universe updates."""
 
-    def set_universe(self, instruments: list[Instrument], skip_callback: bool = False):
+    def set_universe(
+        self, instruments: list[Instrument], skip_callback: bool = False, if_has_position_then: RemovalPolicy = "close"
+    ):
         """Set the trading universe.
 
         Args:
             instruments: List of instruments in the universe
+            skip_callback: Skip callback to the strategy
+            if_has_position_then: What to do if the instrument has a position
+                - “close” (default) - close position immediatelly and remove (unsubscribe) instrument from strategy
+                - “wait_for_close” - keep instrument and it’s position until it’s closed from strategy (or risk management), then remove instrument from strategy
+                - “wait_for_change” - keep instrument and position until strategy would try to change it - then close position and remove instrument
         """
         ...
 
@@ -584,11 +593,15 @@ class IUniverseManager:
         """
         ...
 
-    def remove_instruments(self, instruments: list[Instrument]):
+    def remove_instruments(self, instruments: list[Instrument], if_has_position_then: RemovalPolicy = "close"):
         """Remove instruments from the trading universe.
 
         Args:
             instruments: List of instruments to remove
+            if_has_position_then: What to do if the instrument has a position
+                - “close” (default) - close position immediatelly and remove (unsubscribe) instrument from strategy
+                - “wait_for_close” - keep instrument and it’s position until it’s closed from strategy (or risk management), then remove instrument from strategy
+                - “wait_for_change” - keep instrument and position until strategy would try to change it - then close position and remove instrument
         """
         ...
 
@@ -599,6 +612,19 @@ class IUniverseManager:
         """
         ...
 
+    def on_alter_position(self, instrument: Instrument) -> None:
+        """
+        Called when the position of an instrument changes.
+        It can be used for postponed unsubscribed events
+        """
+        ...
+
+    def is_trading_allowed(self, instrument: Instrument) -> bool:
+        """
+        Check if trading is allowed for an instrument because of the instrument's trading policy.
+        """
+        ...
+
 
 class ISubscriptionManager:
     """Manages subscriptions."""
@@ -1003,6 +1029,18 @@ class PositionsTracker:
         ...
 
 
+def _unpickle_instance(chain: tuple[type], state: dict):
+    """
+    chain is a tuple of the *original* classes, e.g. (A, B, C).
+    Reconstruct a new ephemeral class that inherits from them.
+    """
+    name = "_".join(cls.__name__ for cls in chain)
+    # Reverse the chain to respect the typical left-to-right MRO
+    inst = type(name, chain[::-1], {"__module__": "__main__"})()
+    inst.__dict__.update(state)
+    return inst
+
+
 class Mixable(type):
     """
     It's possible to create composite strategies dynamically by adding mixins with functionality.
@@ -1011,8 +1049,28 @@ class Mixable(type):
     NewStrategy(....) can be used in simulation or live trading.
     """
 
-    def __add__(cls: type, other_cls: type):
-        return type(cls)(f"{cls.__name__}_{other_cls.__name__}", (other_cls, cls), {"__module__": cls.__module__})
+    def __add__(cls, other_cls):
+        # If we already have a _composition, combine them;
+        # else treat cls itself as the start of the chain
+        cls_chain = getattr(cls, "__composition__", (cls,))
+        other_chain = getattr(other_cls, "__composition__", (other_cls,))
+
+        # Combine them into one chain. You can define your own order rules:
+        new_chain = cls_chain + other_chain
+
+        # Create ephemeral class
+        name = "_".join(c.__name__ for c in new_chain)
+
+        def __reduce__(self):
+            # Just return the chain of *original real classes*
+            return _unpickle_instance, (new_chain, self.__dict__)
+
+        new_cls = type(
+            name,
+            new_chain[::-1],
+            {"__module__": cls.__module__, "__composition__": new_chain, "__reduce__": __reduce__},
+        )
+        return new_cls
 
 
 class IStrategy(metaclass=Mixable):