openbacktesting 0.2.0__py3-none-any.whl

openbacktesting/simulation/optimization.py

@@ -0,0 +1,326 @@
+"""Native parameter search and parallel optimization orchestration."""
+
+from __future__ import annotations
+
+import warnings
+from collections.abc import Callable, Sequence
+from contextlib import contextmanager
+from copy import copy
+from functools import lru_cache
+from itertools import product, repeat
+from multiprocessing.pool import ThreadPool
+
+import numpy as np
+import pandas as pd
+from numpy.random import default_rng
+
+from openbacktesting.helpers import patch
+from openbacktesting.indicators.runtime import (
+    DEFAULT_CACHE_BYTES,
+    IndicatorCache,
+    optimization_scope,
+)
+from openbacktesting.portfolio.stats import dummy_stats
+from openbacktesting.simulation.parallel import SharedMemoryManager, _batch
+from openbacktesting.strategy.inputs import InputError, _definitions, request_for, resolve_native
+from openbacktesting.util import _tqdm
+
+
+@contextmanager
+def _joined_pool(pool):
+    """ThreadPool.__exit__ does not wait for in-flight threads; join them before releasing market data and caches."""
+    active = pool
+    try:
+        with pool as active:
+            yield active
+    finally:
+        if isinstance(active, ThreadPool):
+            active.join()
+
+
+def _optimize(
+    self,
+    _mp_task,
+    *,
+    maximize: str | Callable[[pd.Series], float] = "SQN",
+    method: str = "grid",
+    max_tries: float | None = None,
+    constraint: Callable[[dict], bool] | None = None,
+    return_heatmap: bool = False,
+    return_optimization: bool = False,
+    random_state: int | None = None,
+    **kwargs,
+) -> pd.Series | tuple[pd.Series, pd.Series] | tuple[pd.Series, pd.Series, dict]:
+    if not kwargs:
+        raise ValueError("Need some strategy parameters to optimize")
+
+    declarations = _definitions(self._strategy)
+    if not declarations:
+        self._strategy._check_reserved_params(kwargs)
+    if declarations and method in ("sambo", "skopt"):
+        raise InputError("UnsupportedOptimizationInput", None, "Declared strategies initially support only grid")
+
+    maximize_key = None
+    if isinstance(maximize, str):
+        maximize_key = str(maximize)
+        if maximize not in dummy_stats().index:
+            raise ValueError(
+                "`maximize`, if str, must match a key in pd.Series result of backtest.run()"
+            )
+
+        def maximize(stats: pd.Series, _key=maximize):
+            return stats[_key]
+
+    elif not callable(maximize):
+        raise TypeError(
+            "`maximize` must be str (a field of backtest.run() result "
+            "Series) or a function that accepts result Series "
+            "and returns a number; the higher the better"
+        )
+    assert callable(maximize), maximize
+
+    have_constraint = bool(constraint)
+    if constraint is None:
+
+        def constraint(_):
+            return True
+
+    elif not callable(constraint):
+        raise TypeError(
+            "`constraint` must be a function that accepts a dict "
+            "of strategy parameters and returns a bool whether "
+            "the combination of parameters is admissible or not"
+        )
+    assert callable(constraint), constraint
+
+    if method == "skopt":
+        method = "sambo"
+        warnings.warn(
+            '`Backtest.optimize(method="skopt")` is deprecated. Use `method="sambo"`.',
+            DeprecationWarning,
+            stacklevel=2,
+        )
+    if return_optimization and method != "sambo":
+        raise ValueError("return_optimization=True only valid if method='sambo'")
+
+    def _tuple(x):
+        return x if isinstance(x, Sequence) and not isinstance(x, str) else (x,)
+
+    for k, v in kwargs.items():
+        if len(_tuple(v)) == 0:
+            raise ValueError(
+                f"Optimization variable '{k}' is passed no optimization values: {k}={v}"
+            )
+
+    if declarations:
+        # Validate all values before constraint evaluation and random sampling so invalid candidates cannot be hidden.
+        kwargs = {
+            name: [
+                resolve_native(self._strategy, {name: value}).overrides()[name]
+                for value in _tuple(values)
+            ]
+            for name, values in kwargs.items()
+        }
+
+    class AttrDict(dict):
+        def __getattr__(self, item):
+            return self[item]
+
+    def _grid_size():
+        size = int(np.prod([len(_tuple(v)) for v in kwargs.values()]))
+        if size < 10_000 and have_constraint:
+            size = sum(
+                1
+                for p in product(*(zip(repeat(k), _tuple(v)) for k, v in kwargs.items()))
+                if constraint(AttrDict(p))
+            )
+        return size
+
+    def _optimize_grid() -> pd.Series | tuple[pd.Series, pd.Series]:
+        rand = default_rng(random_state).random
+        grid_frac = (
+            1
+            if max_tries is None
+            else max_tries
+            if 0 < max_tries <= 1
+            else max_tries / _grid_size()
+        )
+        param_combos = [
+            dict(params)  # back to dict so it pickles
+            for params in (
+                AttrDict(params)
+                for params in product(*(zip(repeat(k), _tuple(v)) for k, v in kwargs.items()))
+            )
+            if constraint(params) and rand() <= grid_frac
+        ]
+        if not param_combos:
+            raise ValueError("No admissible parameter combinations to test")
+
+        if len(param_combos) > 300:
+            warnings.warn(
+                f"Searching for best of {len(param_combos)} configurations.", stacklevel=2
+            )
+
+        heatmap = pd.Series(
+            np.nan,
+            name=maximize_key,
+            index=pd.MultiIndex.from_tuples(
+                [p.values() for p in param_combos], names=next(iter(param_combos)).keys()
+            ),
+        )
+
+        batches = list(_batch(param_combos))
+        if declarations:
+            batches = [
+                [request_for(self._strategy, params) for params in batch] for batch in batches
+            ]
+
+        from openbacktesting import Pool
+
+        with (
+            optimization_scope(
+                getattr(self, "_indicator_cache_bytes", DEFAULT_CACHE_BYTES)
+            ) as token,
+            SharedMemoryManager() as smm,
+            _joined_pool(Pool()) as pool,
+        ):
+            with patch(self, "_data", None):
+                bt = copy(self)  # bt._data will be reassigned in _mp_task worker
+            bt._portfolio_enabled = maximize_key is None
+            bt._results = None
+            bt._log_collector = None
+            bt._indicator_cache_token = token
+            data_shm = smm.df2shm(self._data)
+            results = _tqdm(
+                pool.imap(
+                    _mp_task,
+                    ((bt, data_shm, params_batch) for params_batch in batches),
+                ),
+                total=len(param_combos),
+                desc="Backtest.optimize",
+            )
+            for param_batch, result in zip(_batch(param_combos), results):
+                for params, stats in zip(param_batch, result):
+                    if stats is not None:
+                        heatmap[tuple(params.values())] = maximize(stats)
+
+        if pd.isnull(heatmap).all():
+            # No trade was made in any of the runs. Just make a random
+            # run so we get some, if empty, results
+            stats = self.run(**param_combos[0])
+        else:
+            best_params = heatmap.idxmax(skipna=True)
+            stats = self.run(**dict(zip(heatmap.index.names, best_params)))
+
+        if return_heatmap:
+            return stats, heatmap
+        return stats
+
+    def _optimize_sambo() -> (
+        pd.Series | tuple[pd.Series, pd.Series] | tuple[pd.Series, pd.Series, dict]
+    ):
+        try:
+            import sambo
+        except ImportError:
+            raise ImportError(
+                "Need package 'sambo' for method='sambo'. pip install sambo"
+            ) from None
+
+        nonlocal max_tries
+        max_tries = (
+            200
+            if max_tries is None
+            else max(1, int(max_tries * _grid_size()))
+            if 0 < max_tries <= 1
+            else max_tries
+        )
+
+        dimensions = []
+        for values in kwargs.values():
+            values = np.asarray(values)
+            if values.dtype.kind in "mM":  # timedelta, datetime64
+                # these dtypes are unsupported in SAMBO, so convert to raw int
+                # TODO: save dtype and convert back later
+                values = values.astype(np.int64)
+
+            if values.dtype.kind in "iumM":
+                dimensions.append((values.min(), values.max() + 1))
+            elif values.dtype.kind == "f":
+                dimensions.append((values.min(), values.max()))
+            else:
+                dimensions.append(values.tolist())
+
+        # Avoid recomputing re-evaluations
+        @lru_cache
+        def memoized_run(tup):
+            nonlocal maximize, self
+            with (
+                patch(self, "_plotting_enabled", False),
+                patch(self, "_logs_enabled", False),
+                patch(self, "_portfolio_enabled", maximize_key is None),
+            ):
+                stats = self.run(**dict(tup))
+            return -maximize(stats)
+
+        progress = iter(
+            _tqdm(
+                repeat(None),
+                total=max_tries,
+                leave=False,
+                desc=self.optimize.__qualname__,
+                mininterval=2,
+            )
+        )
+        _names = tuple(kwargs.keys())
+
+        def objective_function(x):
+            nonlocal progress, memoized_run, constraint, _names
+            next(progress)
+            value = memoized_run(tuple(zip(_names, x)))
+            return 0 if np.isnan(value) else value
+
+        def cons(x):
+            nonlocal constraint, _names
+            return constraint(AttrDict(zip(_names, x)))
+
+        res = sambo.minimize(
+            fun=objective_function,
+            bounds=dimensions,
+            constraints=cons,
+            max_iter=max_tries,
+            method="sceua",
+            rng=random_state,
+        )
+
+        stats = self.run(**dict(zip(kwargs.keys(), res.x)))
+        output = [stats]
+
+        if return_heatmap:
+            heatmap = pd.Series(dict(zip(map(tuple, res.xv), -res.funv)), name=maximize_key)
+            heatmap.index.names = kwargs.keys()
+            heatmap.sort_index(inplace=True)
+            output.append(heatmap)
+
+        if return_optimization:
+            output.append(res)
+
+        return stats if len(output) == 1 else tuple(output)
+
+    if method == "grid":
+        output = _optimize_grid()
+    elif method in ("sambo", "skopt"):
+        with patch(
+            self,
+            "_indicator_cache",
+            IndicatorCache(getattr(self, "_indicator_cache_bytes", DEFAULT_CACHE_BYTES)),
+        ):
+            output = _optimize_sambo()
+    else:
+        raise ValueError(f"Method should be 'grid' or 'sambo', not {method!r}")
+    return output
+
+
+from openbacktesting.helpers import _set_legacy_module
+
+_set_legacy_module(_joined_pool, "openbacktesting.optimization")
+_set_legacy_module(_optimize, "openbacktesting.optimization")

openbacktesting/simulation/parallel.py

@@ -0,0 +1,145 @@
+"""Native parallel batches and shared-memory lifecycle."""
+
+from __future__ import annotations
+
+import os
+import sys
+import warnings
+from itertools import chain
+from multiprocessing import resource_tracker as _mprt
+from multiprocessing import shared_memory as _mpshm
+from threading import Lock
+
+import numpy as np
+import pandas as pd
+
+from openbacktesting.helpers import _set_legacy_module, patch
+
+if sys.version_info >= (3, 13):
+    SharedMemory = _mpshm.SharedMemory
+else:
+
+    class SharedMemory(_mpshm.SharedMemory):
+        # From https://github.com/python/cpython/issues/82300#issuecomment-2169035092
+        __lock = Lock()
+
+        def __init__(self, *args, track: bool = True, **kwargs):
+            self._track = track
+            if track:
+                return super().__init__(*args, **kwargs)  # noqa: PLE0101 — preserve the shared-memory initialization retry return
+            with self.__lock, patch(_mprt, "register", lambda *a, **kw: None):
+                super().__init__(*args, **kwargs)
+
+        def unlink(self):
+            if _mpshm._USE_POSIX and self._name:
+                _mpshm._posixshmem.shm_unlink(self._name)
+                if self._track:
+                    _mprt.unregister(self._name, "shared_memory")
+
+
+def _batch(seq):
+    # XXX: Replace with itertools.batched
+    n = np.clip(int(len(seq) // (os.cpu_count() or 1)), 1, 300)
+    for i in range(0, len(seq), n):
+        yield seq[i : i + n]
+
+
+class SharedMemoryManager:
+    """
+    A simple shared memory contextmanager based on
+    https://docs.python.org/3/library/multiprocessing.shared_memory.html#multiprocessing.shared_memory.SharedMemory
+    """
+
+    def __init__(self, create=False) -> None:
+        self._shms: list[SharedMemory] = []
+        self.__create = create
+
+    def SharedMemory(self, *, name=None, create=False, size=0, track=True):
+        shm = SharedMemory(name=name, create=create, size=size, track=track)
+        shm._create = create
+        # Essential to keep refs on Windows
+        # https://stackoverflow.com/questions/74193377/filenotfounderror-when-passing-a-shared-memory-to-a-new-process#comment130999060_74194875
+        self._shms.append(shm)
+        return shm
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *args, **kwargs):
+        failures = []
+        for shm in self._shms:
+            try:
+                shm.close()
+                if shm._create:
+                    shm.unlink()
+            except Exception as error:  # noqa: BLE001 — release each segment, then re-raise the first error
+                failures.append(error)
+                warnings.warn(
+                    f"Failed to unlink shared memory {shm.name!r}",
+                    category=ResourceWarning,
+                    stacklevel=2,
+                )
+        if failures:
+            raise failures[0]
+
+    def arr2shm(self, vals):
+        """Array to shared memory. Returns (shm_name, shape, dtype) used for restore."""
+        assert vals.ndim == 1, (vals.ndim, vals.shape, vals)
+        # Not `vals.nbytes`; lazy indexes (e.g. RangeIndex) report their own,
+        # constant size rather than that of the array they materialize into
+        shm = self.SharedMemory(size=vals.size * vals.dtype.base.itemsize, create=True)
+        buf = np.ndarray(vals.shape, dtype=vals.dtype.base, buffer=shm.buf)
+        if isinstance(vals.dtype, pd.DatetimeTZDtype):
+            # Preserve absolute instants at their original precision in both index and columns; do not lose offsets for repeated DST hours.
+            buf.view("i8")[:] = vals.array.asi8
+        else:
+            buf[:] = vals
+        return shm.name, vals.shape, vals.dtype
+
+    def df2shm(self, df):
+        return tuple(
+            (
+                (column, *self.arr2shm(values))
+                for column, values in chain([(self._DF_INDEX_COL, df.index)], df.items())
+            )
+        )
+
+    @staticmethod
+    def shm2s(shm, shape, dtype) -> pd.Series:
+        arr = np.ndarray(shape, dtype=dtype.base, buffer=shm.buf)
+        arr.setflags(write=False)
+        if isinstance(dtype, pd.DatetimeTZDtype):
+            arr = pd.DatetimeIndex(arr).tz_localize("UTC").tz_convert(dtype.tz)
+        return pd.Series(arr, dtype=dtype, copy=False)
+
+    _DF_INDEX_COL = "__bt_index"
+
+    @staticmethod
+    def shm2df(data_shm):
+        shm = []
+        try:
+            for _, name, _, _ in data_shm:
+                shm.append(SharedMemory(name=name, create=False, track=False))
+            df = pd.DataFrame(
+                {
+                    col: SharedMemoryManager.shm2s(handle, shape, dtype)
+                    for handle, (col, _, shape, dtype) in zip(shm, data_shm)
+                },
+                copy=False,
+            )
+            df.set_index(SharedMemoryManager._DF_INDEX_COL, drop=True, inplace=True)
+            # Result statistics retain the market-data index; it must survive independently after the mapping closes.
+            df.index = df.index.copy(deep=True)
+            df.index.name = None
+            return df, shm
+        except BaseException:
+            for handle in shm:
+                handle.close()
+            raise
+
+
+_set_legacy_module(_batch, "openbacktesting._util")
+_set_legacy_module(SharedMemoryManager, "openbacktesting._util")
+
+if sys.version_info < (3, 13):
+    _set_legacy_module(SharedMemory, "openbacktesting._util")

openbacktesting/simulation/variants.py

@@ -0,0 +1,107 @@
+"""Existing implementations moved from lib: FractionalBacktest, MultiBacktest."""
+
+from __future__ import annotations
+
+from itertools import chain, count
+
+import pandas as pd
+
+from openbacktesting.helpers import _set_legacy_module
+from openbacktesting.simulation.core import Backtest
+from openbacktesting.simulation.parallel import SharedMemoryManager, _batch
+from openbacktesting.util import _tqdm
+
+
+class FractionalBacktest(Backtest):
+    """Removed price-scaling entry point; use Backtest and InstrumentSpec."""
+
+    def __init__(self, *args, **kwargs):
+        raise TypeError(
+            "FractionalBacktest has been removed; use Backtest(instrument=InstrumentSpec(quantity_step=...)) and qty"
+        )
+
+
+class MultiBacktest:
+    """Run one strategy on multiple datasets and aggregate statistics for each dataset.
+
+
+    Multi-dataset `openbacktesting.engine.Backtest` wrapper.
+
+    Run supplied `openbacktesting.engine.Strategy` on several instruments,
+    in parallel.  Used for comparing strategy runs across many instruments
+    or classes of instruments. Example:
+
+        from openbacktesting.test import EURUSD, BTCUSD, SmaCross
+        btm = MultiBacktest([EURUSD, BTCUSD], SmaCross)
+        stats_per_ticker: pd.DataFrame = btm.run(fast=10, slow=20)
+        heatmap_per_ticker: pd.DataFrame = btm.optimize(...)
+    """
+
+    def __init__(self, df_list, strategy_cls, **kwargs):
+        self._dfs = df_list
+        self._strategy = strategy_cls
+        self._bt_kwargs = kwargs
+
+    def run(self, **kwargs):
+        """Backtest each dataset and return statistics in dataset columns.
+
+
+        Wraps `openbacktesting.engine.Backtest.run`. Returns `pd.DataFrame` with
+        currency indexes in columns.
+        """
+        from openbacktesting import Pool
+
+        with Pool() as pool, SharedMemoryManager() as smm:
+            shm = [smm.df2shm(df) for df in self._dfs]
+            results = _tqdm(
+                pool.imap(
+                    self._mp_task_run,
+                    (
+                        (df_batch, self._strategy, self._bt_kwargs, kwargs)
+                        for df_batch in _batch(shm)
+                    ),
+                ),
+                total=len(shm),
+                desc=self.run.__qualname__,
+                mininterval=2,
+            )
+            df = pd.DataFrame(list(chain(*results))).transpose()
+        return df
+
+    @staticmethod
+    def _mp_task_run(args):
+        data_shm, strategy, bt_kwargs, run_kwargs = args
+        dfs, shms = zip(*(SharedMemoryManager.shm2df(i) for i in data_shm))
+        try:
+            return [
+                stats.filter(regex="^[^_]")
+                for stats in (Backtest(df, strategy, **bt_kwargs).run(**run_kwargs) for df in dfs)
+            ]
+        finally:
+            for shmem in chain(*shms):
+                shmem.close()
+
+    def optimize(self, **kwargs) -> pd.DataFrame:
+        """Optimize parameters separately for each dataset and aggregate parameter scores.
+
+
+        Wraps `openbacktesting.engine.Backtest.optimize`, but returns `pd.DataFrame` with
+        currency indexes in columns.
+
+            heatmap: pd.DataFrame = btm.optimize(...)
+            mean_scores = heatmap.mean(axis=1)
+        """
+        heatmaps = []
+        # Simple loop since bt.optimize already does its own multiprocessing
+        for df in _tqdm(self._dfs, desc=self.__class__.__name__, mininterval=2):
+            bt = Backtest(df, self._strategy, **self._bt_kwargs)
+            _best_stats, heatmap = bt.optimize(  # type: ignore
+                return_heatmap=True, return_optimization=False, **kwargs
+            )
+            heatmaps.append(heatmap)
+        heatmap = pd.DataFrame(dict(zip(count(), heatmaps)))
+        return heatmap
+
+
+_set_legacy_module(FractionalBacktest, "openbacktesting.lib")
+_set_legacy_module(MultiBacktest, "openbacktesting.lib")

openbacktesting/strategy/__init__.py

@@ -0,0 +1,19 @@
+"""Compatibility exports for the old strategy path; implemented in strategy.base."""
+
+from typing import TYPE_CHECKING
+
+from openbacktesting.strategy.bar_state import BarState as BarState
+
+if TYPE_CHECKING:
+    from openbacktesting.strategy.base import Strategy as Strategy
+
+__all__ = ["BarState", "Strategy"]
+
+
+def __getattr__(name):
+    if name == "Strategy":
+        from openbacktesting.strategy.base import Strategy
+
+        globals()[name] = Strategy
+        return Strategy
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")

openbacktesting/strategy/bar_state.py

@@ -0,0 +1,14 @@
+"""Immutable Bar state for fixed historical input."""
+
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True, slots=True)
+class BarState:
+    """First/last snapshot at the current execution position; saved values do not change with the run cursor.
+
+    is_first means input bar 0; is_last means the final input bar, not the end of the run.
+    """
+
+    is_first: bool
+    is_last: bool