Qubx 0.5.3__tar.gz → 0.5.5__tar.gz

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

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

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

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

{qubx-0.5.3 → qubx-0.5.5}/src/qubx/backtester/management.py

@@ -90,8 +90,12 @@ class BacktestsResultsManager:
             stop = pd.Timestamp(info.get("stop", "")).round("1s")
             dscr = info.get("description", "")
             _s = f"{yellow(str(info.get('idx')))} - {red(name)} ::: {magenta(pd.Timestamp(info.get('creation_time', '')).round('1s'))} by {cyan(info.get('author', ''))}"
+
             if dscr:
-                _s += f"\n\t{magenta(dscr)}"
+                dscr = dscr.split("\n")
+                for _d in dscr:
+                    _s += f"\n\t{magenta('# ' + _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', '')})"
@@ -117,3 +121,21 @@ class BacktestsResultsManager:
                 for i in _m_repr:
                     print("\t " + cyan(i))
             print()
+
+    def delete(self, name: str | int):
+        print(red(f" -> Danger zone - you are about to delete {name} ..."))
+        for info in self.results.values():
+            match name:
+                case int():
+                    if info.get("idx", -1) == name:
+                        Path(info["path"]).unlink()
+                        print(f" -> Deleted {red(name)} ...")
+                        self.reload()
+                        return
+                case str():
+                    if info.get("name", "") == name:
+                        Path(info["path"]).unlink()
+                        print(f" -> Deleted {red(name)} ...")
+                        self.reload()
+                        return
+        print(f" -> No results found for {red(name)} !")

{qubx-0.5.3 → qubx-0.5.5}/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.5}/src/qubx/core/interfaces.py

@@ -1003,6 +1003,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 +1023,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):

{qubx-0.5.3 → qubx-0.5.5}/src/qubx/core/metrics.py

@@ -609,6 +609,7 @@ class TradingSessionResult:
     creation_time: pd.Timestamp | None = None        # when result was created
     author: str | None = None                        # who created the result
     qubx_version: str | None = None                  # Qubx version used to create the result
+    _metrics: dict[str, float] | None = None         # performance metrics
     # fmt: on
 
     def __init__(
@@ -649,6 +650,39 @@ class TradingSessionResult:
         self.creation_time = pd.Timestamp(creation_time) if creation_time else pd.Timestamp.now()
         self.author = author
         self.qubx_version = version()
+        self._metrics = None
+
+    def performance(self) -> dict[str, float]:
+        """
+        Calculate performance metrics for the trading session
+        """
+        if not self._metrics:
+            # - caluclate short statistics
+            self._metrics = portfolio_metrics(
+                self.portfolio_log,
+                self.executions_log,
+                self.capital,
+                performance_statistics_period=DAILY_365,
+                account_transactions=True,
+                commission_factor=1,
+            )
+            # - convert timestamps to isoformat
+            for k, v in self._metrics.items():
+                match v:
+                    case pd.Timestamp():
+                        self._metrics[k] = v.isoformat()
+                    case np.float64():
+                        self._metrics[k] = float(v)
+            # fmt: off
+            for k in [
+                "equity", "drawdown_usd", "drawdown_pct",
+                "compound_returns", "returns_daily", "returns", "monthly_returns",
+                "rolling_sharpe", "long_value", "short_value",
+            ]:
+                self._metrics.pop(k, None)
+            # fmt: on
+
+        return self._metrics
 
     @property
     def symbols(self) -> list[str]:
@@ -690,6 +724,7 @@ class TradingSessionResult:
             "author": self.author,
             "qubx_version": self.qubx_version,
             "symbols": self.symbols,
+            "performance": dict(self.performance()),
         }
 
     def to_html(self, compound=True) -> HTML:
@@ -743,8 +778,42 @@ class TradingSessionResult:
         """
         return HTML(_tmpl)
 
-    def to_file(self, name: str, description: str | None = None, compound=True, archive=True):
-        name = (name + self.creation_time.strftime("%Y%m%d%H%M%S")) if self.creation_time else name
+    def to_file(
+        self,
+        name: str,
+        description: str | None = None,
+        compound=True,
+        archive=True,
+        suffix: str | None = None,
+        attachments: list[str] | None = None,
+    ):
+        """
+        Save the trading session results to files.
+
+        Args:
+            name (str): Base name/path for saving the files
+            description (str | None, optional): Description to include in info file. Defaults to None.
+            compound (bool, optional): Whether to use compound returns in report. Defaults to True.
+            archive (bool, optional): Whether to zip the output files. Defaults to True.
+            suffix (str | None, optional): Optional suffix to append to filename. Defaults to None.
+            attachments (list[str] | None, optional): Additional files to include. Defaults to None.
+
+        The following files are saved:
+            - info.yml: Contains strategy configuration and metadata
+            - portfolio.csv: Portfolio state log
+            - executions.csv: Trade execution log
+            - signals.csv: Strategy signals log
+            - report.html: HTML performance report
+            - Any provided attachment files
+
+        If archive=True, all files are zipped into a single archive and the directory is removed.
+        """
+        import shutil
+
+        if suffix is not None:
+            name = f"{name}{suffix}"
+        else:
+            name = (name + self.creation_time.strftime("%Y%m%d%H%M%S")) if self.creation_time else name
         p = Path(makedirs(name))
         with open(p / "info.yml", "w") as f:
             info = self.info()
@@ -761,9 +830,13 @@ class TradingSessionResult:
         with open(p / "report.html", "w") as f:
             f.write(self.to_html(compound=compound).data)
 
-        if archive:
-            import shutil
+        # - save attachments
+        if attachments:
+            for a in attachments:
+                if (af := Path(a)).is_file():
+                    shutil.copy(af, p / af.name)
 
+        if archive:
             shutil.make_archive(name, "zip", p)  # type: ignore
             shutil.rmtree(p)  # type: ignore
 
@@ -784,9 +857,11 @@ class TradingSessionResult:
         # load result
         _qbx_version = info.pop("qubx_version")
         _decr = info.pop("description", None)
+        _perf = info.pop("performance", None)
         info["instruments"] = info.pop("symbols")
         tsr = TradingSessionResult(**info, portfolio_log=portfolio, executions_log=executions, signals_log=signals)
         tsr.qubx_version = _qbx_version
+        tsr._metrics = _perf
         return tsr
 
     def __repr__(self) -> str:
@@ -796,10 +871,13 @@ class TradingSessionResult:
  :   QUBX: {self.qubx_version}
  :   Capital: {self.capital} {self.base_currency} ({self.commissions} @ {self.exchange})
  :   Instruments: [{",".join(self.symbols)}]
- :   Generated: {len(self.signals_log)} signals, {len(self.executions_log)} executions
- :   Strategy: {self.config(False)}
  :   Created: {self.creation_time} by {self.author} 
-        """
+ :   Strategy: {self.config(False)}
+ :   Generated: {len(self.signals_log)} signals, {len(self.executions_log)} executions
+"""
+        _perf = pd.DataFrame.from_dict(self.performance(), orient="index").T.to_string(index=None)
+        for _i, s in enumerate(_perf.split("\n")):
+            r += f"       : {s}\n" if _i > 0 else f"  `----: {s}\n"
         return r
 
 

{qubx-0.5.3 → qubx-0.5.5}/src/qubx/trackers/sizers.py

@@ -173,3 +173,57 @@ class LongShortRatioPortfolioSizer(IPositionSizer):
             t_pos.append(TargetPosition.create(ctx, signal, _p * _p_q))
 
         return t_pos
+
+
+class FixedRiskSizerWithConstantCapital(IPositionSizer):
+    def __init__(
+        self,
+        capital: float,
+        max_cap_in_risk: float,
+        max_allowed_position=np.inf,
+        divide_by_symbols: bool = True,
+    ):
+        """
+        Create fixed risk sizer calculator instance.
+        :param max_cap_in_risk: maximal risked capital (in percentage)
+        :param max_allowed_position: limitation for max position size in quoted currency (i.e. max 5000 in USDT)
+        :param reinvest_profit: if true use profit to reinvest
+        """
+        self.capital = capital
+        assert self.capital > 0, f" >> {self.__class__.__name__}: Capital must be positive, got {self.capital}"
+        self.max_cap_in_risk = max_cap_in_risk / 100
+        self.max_allowed_position_quoted = max_allowed_position
+        self.divide_by_symbols = divide_by_symbols
+
+    def calculate_target_positions(self, ctx: IStrategyContext, signals: List[Signal]) -> List[TargetPosition]:
+        t_pos = []
+        for signal in signals:
+            target_position_size = 0
+            if signal.signal != 0:
+                if signal.stop and signal.stop > 0:
+                    # - get signal entry price
+                    if (_entry := self.get_signal_entry_price(ctx, signal)) is None:
+                        continue
+
+                    # - just use same fixed capital
+                    _cap = self.capital / (len(ctx.instruments) if self.divide_by_symbols else 1)
+
+                    # fmt: off
+                    _direction = np.sign(signal.signal)
+                    target_position_size = (  
+                        _direction * min(
+                            (_cap * self.max_cap_in_risk) / abs(signal.stop / _entry - 1), 
+                            self.max_allowed_position_quoted
+                        ) / _entry
+                    )  
+                    # fmt: on
+
+                else:
+                    logger.warning(
+                        f" >>> {self.__class__.__name__}: stop is not specified for {str(signal)} - can't calculate position !"
+                    )
+                    continue
+
+            t_pos.append(TargetPosition.create(ctx, signal, target_position_size))
+
+        return t_pos

{qubx-0.5.3 → qubx-0.5.5}/src/qubx/utils/runner/configs.py

@@ -55,6 +55,8 @@ class StrategySimulationConfig(BaseModel):
     parameters: dict = Field(default_factory=dict)
     data: dict = Field(default_factory=dict)
     simulation: dict = Field(default_factory=dict)
+    description: str | list[str] | None = None
+    variate: dict = Field(default_factory=dict)
 
 
 def load_simulation_config_from_yaml(path: Path | str) -> StrategySimulationConfig:

{qubx-0.5.3 → qubx-0.5.5}/src/qubx/utils/runner/runner.py

@@ -4,8 +4,11 @@ import time
 from functools import reduce
 from pathlib import Path
 
+import pandas as pd
+
 from qubx import formatter, logger, lookup
 from qubx.backtester.account import SimulatedAccountProcessor
+from qubx.backtester.optimization import variate
 from qubx.backtester.simulator import SimulatedBroker, simulate
 from qubx.connectors.ccxt.account import CcxtAccountProcessor
 from qubx.connectors.ccxt.broker import CcxtBroker
@@ -18,7 +21,7 @@ from qubx.core.helpers import BasicScheduler
 from qubx.core.interfaces import IAccountProcessor, IBroker, IDataProvider, IStrategyContext
 from qubx.core.loggers import StrategyLogging
 from qubx.data import DataReader
-from qubx.utils.misc import class_import, makedirs
+from qubx.utils.misc import blue, class_import, cyan, green, magenta, makedirs, red, yellow
 from qubx.utils.runner.configs import ExchangeConfig, load_simulation_config_from_yaml, load_strategy_config_from_yaml
 
 from .accounts import AccountConfigurationManager
@@ -379,6 +382,8 @@ def simulate_strategy(
 
     cfg = load_simulation_config_from_yaml(config_file)
     stg = cfg.strategy
+    simulation_name = config_file.stem
+    _v_id = pd.Timestamp("now").strftime("%Y%m%d%H%M%S")
 
     match stg:
         case list():
@@ -388,8 +393,24 @@ def simulate_strategy(
         case _:
             raise SimulationConfigError(f"Invalid strategy type: {stg}")
 
-    strategy = stg_cls(**cfg.parameters)
-    exp_name = config_file.stem
+    # - create simulation setup
+    if cfg.variate:
+        # - get conditions for variations if exists
+        cond = cfg.variate.pop("with", None)
+        conditions = []
+        dict2lambda = lambda a, d: eval(f"lambda {a}: {d}")  # noqa: E731
+        if cond:
+            for a, c in cond.items():
+                conditions.append(dict2lambda(a, c))
+
+        experiments = variate(stg_cls, **(cfg.parameters | cfg.variate), conditions=conditions)
+        experiments = {f"{simulation_name}.{_v_id}.[{k}]": v for k, v in experiments.items()}
+        print(f"Variation is enabled. There are {len(experiments)} simualtions to run.")
+        _n_jobs = -1
+    else:
+        strategy = stg_cls(**cfg.parameters)
+        experiments = {simulation_name: strategy}
+        _n_jobs = 1
 
     data_i = {}
 
@@ -409,13 +430,30 @@ def simulate_strategy(
         sim_params["stop"] = stop
         logger.info(f"Stop date set to {stop}")
 
-    test_res = simulate({exp_name: strategy}, data=data_i, **sim_params)
-    logger.info(f"<g>Simulation Results:</g>\n{str(test_res[0])}")
+    # - run simulation
+    print(f" > Run simulation for [{red(simulation_name)}] ::: {sim_params['start']} - {sim_params['stop']}")
+    sim_params["n_jobs"] = sim_params.get("n_jobs", _n_jobs)
+    test_res = simulate(experiments, data=data_i, **sim_params)
 
     _where_to_save = save_path if save_path is not None else Path("results/")
-    s_path = Path(makedirs(str(_where_to_save))) / exp_name
-
-    logger.info(f"Saving results to <g>{s_path}</g> ...")
-    test_res[0].to_file(str(s_path))
+    s_path = Path(makedirs(str(_where_to_save))) / simulation_name
+
+    # logger.info(f"Saving simulation results to <g>{s_path}</g> ...")
+    if cfg.description is not None:
+        _descr = cfg.description
+        if isinstance(cfg.description, list):
+            _descr = "\n".join(cfg.description)
+        else:
+            _descr = str(cfg.description)
+
+    if len(test_res) > 1:
+        # - TODO: think how to deal with variations !
+        s_path = s_path / f"variations.{_v_id}"
+        print(f" > Saving variations results to <g>{s_path}</g> ...")
+        for k, t in enumerate(test_res):
+            t.to_file(str(s_path), description=_descr, suffix=f".{k}", attachments=[str(config_file)])
+    else:
+        print(f" > Saving simulation results to <g>{s_path}</g> ...")
+        test_res[0].to_file(str(s_path), description=_descr, attachments=[str(config_file)])
 
     return test_res