openbacktesting 0.2.0__py3-none-any.whl

openbacktesting/data/core.py

@@ -0,0 +1,218 @@
+"""Native market-data views, indicator arrays, and warmup helpers."""
+
+from __future__ import annotations
+
+import warnings
+from numbers import Number
+from typing import cast
+
+import numpy as np
+import pandas as pd
+
+from openbacktesting.helpers import _set_legacy_module
+
+
+def _data_period(index) -> pd.Timedelta | Number:
+    """Return data index period as pd.Timedelta"""
+    values = pd.Series(index[-100:])
+    return values.diff().dropna().median()
+
+
+def _strategy_indicators(strategy):
+    return {
+        attr: indicator
+        for attr, indicator in strategy.__dict__.items()
+        if isinstance(indicator, _Indicator)
+    }.items()
+
+
+def _indicator_warmup_nbars(strategy):
+    """Indicator-readiness diagnostic for the legacy entry point; no longer controls next scheduling or return baselines."""
+    if strategy is None:
+        return 0
+    if hasattr(strategy, "_indicator_cursor"):
+        return max((indicator.first_ready() for indicator in strategy._indicators), default=0)
+    nbars = max(
+        (
+            np.isnan(indicator.astype(float)).argmin(axis=-1).max()
+            for _, indicator in _strategy_indicators(strategy)
+            if indicator._opts.get("warmup", True)
+        ),
+        default=0,
+    )
+    return nbars
+
+
+class _Array(np.ndarray):
+    """
+    ndarray extended to supply .name and other arbitrary properties
+    in ._opts dict.
+    """
+
+    def __new__(cls, array, *, name=None, **kwargs):
+        obj = np.asarray(array).view(cls)
+        obj.name = name or array.name
+        obj._opts = kwargs
+        return obj
+
+    def __array_finalize__(self, obj):
+        if obj is not None:
+            self.name = getattr(obj, "name", "")
+            self._opts = getattr(obj, "_opts", {})
+
+    # Make sure properties name and _opts are carried over
+    # when (un-)pickling.
+    def __reduce__(self):
+        value = super().__reduce__()
+        return value[:2] + (value[2] + (self.__dict__,),)
+
+    def __setstate__(self, state):
+        self.__dict__.update(state[-1])
+        super().__setstate__(state[:-1])
+
+    def __bool__(self):
+        try:
+            return bool(self[-1])
+        except IndexError:
+            return super().__bool__()
+
+    def __float__(self):
+        try:
+            return float(self[-1])
+        except IndexError:
+            return super().__float__()
+
+    def to_series(self):
+        warnings.warn("`.to_series()` is deprecated. For pd.Series conversion, use accessor `.s`")
+        return self.s
+
+    @property
+    def s(self) -> pd.Series:
+        values = np.atleast_2d(self)
+        index = self._opts["index"][: values.shape[1]]
+        return pd.Series(values[0], index=index, name=self.name)
+
+    @property
+    def df(self) -> pd.DataFrame:
+        values = np.atleast_2d(np.asarray(self))
+        index = self._opts["index"][: values.shape[1]]
+        df = pd.DataFrame(values.T, index=index, columns=[self.name] * len(values))
+        return df
+
+
+class _Indicator(_Array):
+    pass
+
+
+class _Data:
+    """
+    A data array accessor. Provides access to OHLCV "columns"
+    as a standard `pd.DataFrame` would, except it's not a DataFrame
+    and the returned "series" are _not_ `pd.Series` but `np.ndarray`
+    for performance reasons.
+    """
+
+    def __init__(self, df: pd.DataFrame):
+        self.__df = df
+        self.__len = len(df)  # Current length
+        self.__pip: float | None = None
+        self.__cache: dict[str, _Array] = {}
+        self.__arrays: dict[str, _Array] = {}
+        self._update()
+
+    def __getitem__(self, item):
+        return self.__get_array(item)
+
+    def __getattr__(self, item):
+        try:
+            return self.__get_array(item)
+        except KeyError:
+            raise AttributeError(f"Column '{item}' not in data") from None
+
+    def _set_length(self, length):
+        self.__len = length
+        self.__cache.clear()
+
+    def _update(self):
+        index = self.__df.index.copy()
+        self.__arrays = {col: _Array(arr, index=index) for col, arr in self.__df.items()}
+        # Leave index as Series because pd.Timestamp nicer API to work with
+        self.__arrays["__index"] = index
+
+    def __repr__(self):
+        i = min(self.__len, len(self.__df)) - 1
+        index = self.__arrays["__index"][i]
+        items = ", ".join(f"{k}={v}" for k, v in self.__df.iloc[i].items())
+        return f"<Data i={i} ({index}) {items}>"
+
+    def __len__(self):
+        return self.__len
+
+    @property
+    def df(self) -> pd.DataFrame:
+        return self.__df.iloc[: self.__len] if self.__len < len(self.__df) else self.__df
+
+    def _full_frame(self) -> pd.DataFrame:
+        """Used for internal provenance capture without changing the visible length of public data."""
+        return self.__df
+
+    @property
+    def pip(self) -> float:
+        if self.__pip is None:
+            self.__pip = float(
+                10
+                ** -np.median(
+                    [len(s.partition(".")[-1]) for s in self.__arrays["Close"].astype(str)]
+                )
+            )
+        return self.__pip
+
+    def __get_array(self, key) -> _Array:
+        arr = self.__cache.get(key)
+        if arr is None:
+            arr = self.__cache[key] = cast(_Array, self.__arrays[key][: self.__len])
+        return arr
+
+    def _current_value(self, key: str):
+        # Known fast path to avoid needless __get_array reslicing
+        assert self.__len >= 0, self
+        return self.__arrays[key][self.__len - 1]
+
+    @property
+    def Open(self) -> _Array:
+        return self.__get_array("Open")
+
+    @property
+    def High(self) -> _Array:
+        return self.__get_array("High")
+
+    @property
+    def Low(self) -> _Array:
+        return self.__get_array("Low")
+
+    @property
+    def Close(self) -> _Array:
+        return self.__get_array("Close")
+
+    @property
+    def Volume(self) -> _Array:
+        return self.__get_array("Volume")
+
+    @property
+    def index(self) -> pd.DatetimeIndex:
+        return self.__get_array("__index")
+
+    # Make pickling in Backtest.optimize() work with our catch-all __getattr__
+    def __getstate__(self):
+        return self.__dict__
+
+    def __setstate__(self, state):
+        self.__dict__ = state
+
+
+_set_legacy_module(_data_period, "openbacktesting._util")
+_set_legacy_module(_strategy_indicators, "openbacktesting._util")
+_set_legacy_module(_indicator_warmup_nbars, "openbacktesting._util")
+_set_legacy_module(_Array, "openbacktesting._util")
+_set_legacy_module(_Indicator, "openbacktesting._util")
+_set_legacy_module(_Data, "openbacktesting._util")

openbacktesting/data/generators.py

@@ -0,0 +1,54 @@
+"""Existing implementation moved from lib: random_ohlc_data."""
+
+from __future__ import annotations
+
+from collections.abc import Generator
+
+import pandas as pd
+
+from openbacktesting.helpers import _set_legacy_module
+
+
+def random_ohlc_data(
+    example_data: pd.DataFrame, *, frac=1.0, random_state: int | None = None
+) -> Generator[pd.DataFrame, None, None]:
+    """Iteratively generate random samples preserving basic market-data structure; these are not real-market forecasts.
+
+
+    OHLC data generator. The generated OHLC data has basic
+    [descriptive statistics](https://en.wikipedia.org/wiki/Descriptive_statistics)
+    similar to the provided `example_data`.
+
+    `frac` is a fraction of data to sample (with replacement). Values greater
+    than 1 result in oversampling.
+
+    Such random data can be effectively used for stress testing trading
+    strategy robustness, Monte Carlo simulations, significance testing, etc.
+
+    >>> from openbacktesting.test import EURUSD
+    >>> ohlc_generator = random_ohlc_data(EURUSD)
+    >>> next(ohlc_generator)  # returns new random data
+    ...
+    >>> next(ohlc_generator)  # returns new random data
+    ...
+    """
+
+    def shuffle(x):
+        return x.sample(frac=frac, replace=frac > 1, random_state=random_state)
+
+    if len(example_data.columns.intersection({"Open", "High", "Low", "Close"})) != 4:
+        raise ValueError(
+            "`data` must be a pandas.DataFrame with columns 'Open', 'High', 'Low', 'Close'"
+        )
+    while True:
+        df = shuffle(example_data)
+        df.index = example_data.index
+        padding = df.Close - df.Open.shift(-1)
+        gaps = shuffle(example_data.Open.shift(-1) - example_data.Close)
+        deltas = (padding + gaps).shift(1).fillna(0).cumsum()
+        for key in ("Open", "High", "Low", "Close"):
+            df[key] += deltas
+        yield df
+
+
+_set_legacy_module(random_ohlc_data, "openbacktesting.lib")

openbacktesting/data/strategy_data.py

@@ -0,0 +1,103 @@
+"""Per-run market-data snapshot and stable series; does not register indicators."""
+
+import numpy as np
+import pandas as pd
+
+from openbacktesting.data.core import _Data
+from openbacktesting.indicators.types import (
+    IndicatorCursor,
+    IndicatorError,
+    IndicatorHandle,
+    immutable,
+)
+
+PRICE_COLUMNS = {"open": "Open", "high": "High", "low": "Low", "close": "Close", "volume": "Volume"}
+DERIVED = ("hl2", "hlc3", "hlcc4")
+DATA_NAMES = frozenset((*PRICE_COLUMNS, *DERIVED, "data_index", "df", "pip"))
+
+
+class StrategyData:
+    def __init__(self, data: _Data, cursor: IndicatorCursor):
+        self._data = data
+        self._cursor = cursor
+        self._baseline: pd.DataFrame | None = None
+        self._values: dict[str, np.ndarray] = {}
+        self._handles: dict[str, IndicatorHandle] = {}
+
+    def validate(self):
+        """Check only at the initialization boundary; do not scan all data on each bar."""
+        if self._baseline is None or self._cursor.phase != "init":
+            return
+        frame = self._data._full_frame()
+        columns = frame.columns[frame.columns.isin(PRICE_COLUMNS.values())]
+        current = frame.loc[:, columns]
+        if (
+            not current.equals(self._baseline)
+            or not current.index.identical(self._baseline.index)
+            or not current.columns.identical(self._baseline.columns)
+        ):
+            raise IndicatorError(
+                "data-source-mutated",
+                "strategy.data",
+                "OHLCV or index changed; finish market-data preprocessing before first reading a market-data series",
+            )
+
+    def _capture(self):
+        frame = self._data._full_frame()
+        if not frame.index.is_unique:
+            raise IndicatorError("invalid-data-source", "strategy.data", "Market-data index must be unique")
+        columns = frame.columns[frame.columns.isin(PRICE_COLUMNS.values())]
+        if len(columns) != 5 or set(columns) != set(PRICE_COLUMNS.values()):
+            raise IndicatorError("invalid-data-source", "strategy.data", "Unique OHLCV columns are required")
+        baseline = frame.loc[:, columns].copy(deep=True)
+        values = {}
+        for name, column in PRICE_COLUMNS.items():
+            series = baseline[column]
+            if pd.api.types.is_bool_dtype(series.dtype) or not (
+                pd.api.types.is_integer_dtype(series.dtype)
+                or pd.api.types.is_float_dtype(series.dtype)
+            ):
+                raise IndicatorError(
+                    "invalid-data-source", "strategy.data", f"{column} must be a real-valued market-data column"
+                )
+            values[name] = immutable(series.to_numpy(dtype=np.float64, na_value=np.nan))
+        self._baseline = baseline
+        self._values = values
+
+    def _derive(self, name):
+        high, low, close = (self._values[key] for key in ("high", "low", "close"))
+        valid = np.isfinite(high) & np.isfinite(low)
+        with np.errstate(over="ignore", invalid="ignore"):
+            if name == "hl2":
+                values = (high + low) / 2
+            else:
+                valid &= np.isfinite(close)
+                if name == "hlc3":
+                    values = ((high + low) + close) / 3
+                else:
+                    values = ((high + low) + (close + close)) / 4
+        return np.where(valid & np.isfinite(values), values, np.nan)
+
+    def get(self, name: str) -> IndicatorHandle:
+        self.validate()
+        if self._baseline is None:
+            self._capture()
+        if name not in self._handles:
+            values = self._values[name] if name in PRICE_COLUMNS else self._derive(name)
+            self._handles[name] = IndicatorHandle(
+                values,
+                name=PRICE_COLUMNS.get(name, name),
+                index=self._baseline.index,
+                cursor=self._cursor,
+                metadata={"kind": "data-source", "field": name, "version": "1"},
+            )
+        return self._handles[name]
+
+    def __setstate__(self, state):
+        self.__dict__.update(state)
+        self._values = {name: immutable(value) for name, value in self._values.items()}
+
+
+from openbacktesting.helpers import _set_legacy_module
+
+_set_legacy_module(StrategyData, "openbacktesting.strategy_data")

openbacktesting/data/timeframe.py

@@ -0,0 +1,69 @@
+"""Chart timeframe units and immutable values; no market-data inference or resampling."""
+
+from dataclasses import dataclass
+from enum import StrEnum
+
+
+class TimeframeUnit(StrEnum):
+    """Time-bar units; calendar units are not implicitly converted to fixed seconds."""
+
+    SECOND = "second"
+    MINUTE = "minute"
+    DAY = "day"
+    WEEK = "week"
+    MONTH = "month"
+
+
+def _positive_integer(value: int) -> int:
+    if type(value) is not int:
+        raise TypeError("Timeframe multiplier must be an integer; bool and floats are not accepted")
+    if value <= 0:
+        raise ValueError("Timeframe multiplier must be a positive integer")
+    return value
+
+
+@dataclass(frozen=True)
+class Timeframe:
+    """Timeframe value; the host validates data-source support, and not all combinations are guaranteed to have market data."""
+
+    unit: TimeframeUnit
+    multiplier: int
+
+    def __post_init__(self):
+        if not isinstance(self.unit, TimeframeUnit):
+            raise TypeError("unit must be a TimeframeUnit")
+        _positive_integer(self.multiplier)
+
+    @classmethod
+    def seconds(cls, value: int) -> "Timeframe":
+        """Create a seconds timeframe."""
+        return cls(TimeframeUnit.SECOND, value)
+
+    @classmethod
+    def minutes(cls, value: int) -> "Timeframe":
+        """Create a minutes timeframe."""
+        return cls(TimeframeUnit.MINUTE, value)
+
+    @classmethod
+    def hours(cls, value: int) -> "Timeframe":
+        """Normalize hours to minutes; 24 hours is not a daily timeframe."""
+        return cls.minutes(_positive_integer(value) * 60)
+
+    @classmethod
+    def days(cls, value: int) -> "Timeframe":
+        """Create a calendar-day timeframe."""
+        return cls(TimeframeUnit.DAY, value)
+
+    @classmethod
+    def weeks(cls, value: int) -> "Timeframe":
+        """Create a calendar-week timeframe."""
+        return cls(TimeframeUnit.WEEK, value)
+
+    @classmethod
+    def months(cls, value: int) -> "Timeframe":
+        """Create a calendar-month timeframe."""
+        return cls(TimeframeUnit.MONTH, value)
+
+    def snapshot(self) -> dict:
+        """Return independent plain unit/multiplier values."""
+        return {"unit": self.unit.value, "multiplier": self.multiplier}

openbacktesting/engine.py

@@ -0,0 +1,34 @@
+"""Compatibility entry point for old native-kernel paths; definitions reside in the corresponding responsibility modules."""
+
+from openbacktesting.broker.core import (
+    Order,
+    Position,
+    Trade,
+    __pdoc__,  # noqa: F401 — preserve compatibility exports at the original path
+    _Broker,  # noqa: F401 — preserve compatibility exports at the original path
+    _OutOfMoneyError,  # noqa: F401 — preserve compatibility exports at the original path
+)
+from openbacktesting.data.core import (
+    _Data,  # noqa: F401 — preserve compatibility exports at the original path
+    _Indicator,  # noqa: F401 — preserve compatibility exports at the original path
+    _indicator_warmup_nbars,  # noqa: F401 — preserve compatibility exports at the original path
+    _strategy_indicators,  # noqa: F401 — preserve compatibility exports at the original path
+)
+from openbacktesting.helpers import (
+    _as_str,  # noqa: F401 — preserve compatibility exports at the original path
+    patch,  # noqa: F401 — preserve compatibility exports at the original path
+    try_,  # noqa: F401 — preserve compatibility exports at the original path
+)
+from openbacktesting.portfolio.stats import (
+    compute_stats,  # noqa: F401 — preserve compatibility exports at the original path
+    dummy_stats,  # noqa: F401 — preserve compatibility exports at the original path
+)
+from openbacktesting.simulation.core import Backtest
+from openbacktesting.simulation.parallel import (
+    SharedMemoryManager,  # noqa: F401 — preserve compatibility exports at the original path
+    _batch,  # noqa: F401 — preserve compatibility exports at the original path
+)
+from openbacktesting.strategy.base import Strategy
+from openbacktesting.util import _tqdm  # noqa: F401 — preserve compatibility exports at the original path
+
+__all__ = ["Strategy", "Position", "Order", "Trade", "Backtest"]  # noqa: RUF022 — preserve the original public export order

openbacktesting/helpers.py

@@ -0,0 +1,77 @@
+"""Stateless helpers and compatibility with old object paths."""
+
+from __future__ import annotations
+
+from collections.abc import Sequence
+from contextlib import contextmanager
+from numbers import Number
+from types import FunctionType
+
+import pandas as pd
+
+
+def _set_legacy_module(obj, module):
+    """Preserve old qualified names used by pickle when moving definitions; do not create replacement classes."""
+    original = obj.__module__
+    obj.__module__ = module
+    if isinstance(obj, type):
+        for member in vars(obj).values():
+            if isinstance(member, type) and member.__module__ == original:
+                _set_legacy_module(member, module)
+            if isinstance(member, (staticmethod, classmethod)):
+                functions = (member.__func__,)
+            elif isinstance(member, property):
+                functions = (member.fget, member.fset, member.fdel)
+            else:
+                functions = (member, getattr(member, "func", None))
+            for function in functions:
+                if isinstance(function, FunctionType) and function.__module__ == original:
+                    function.__module__ = module
+
+
+def try_(lazy_func, default=None, exception=Exception):
+    try:
+        return lazy_func()
+    except exception:
+        return default
+
+
+@contextmanager
+def patch(obj, attr, newvalue):
+    had_attr = hasattr(obj, attr)
+    orig_value = getattr(obj, attr, None)
+    setattr(obj, attr, newvalue)
+    try:
+        yield
+    finally:
+        if had_attr:
+            setattr(obj, attr, orig_value)
+        else:
+            delattr(obj, attr)
+
+
+def _as_str(value) -> str:
+    if isinstance(value, (Number, str)):
+        return str(value)
+    if isinstance(value, pd.DataFrame):
+        return "df"
+    name = str(getattr(value, "name", "") or "")
+    if name in ("Open", "High", "Low", "Close", "Volume"):
+        return name[:1]
+    if callable(value):
+        name = getattr(value, "__name__", value.__class__.__name__).replace("<lambda>", "λ")
+    if len(name) > 10:
+        name = name[:9] + "…"
+    return name
+
+
+def _as_list(value) -> list:
+    if isinstance(value, Sequence) and not isinstance(value, str):
+        return list(value)
+    return [value]
+
+
+_set_legacy_module(try_, "openbacktesting._util")
+_set_legacy_module(patch, "openbacktesting._util")
+_set_legacy_module(_as_str, "openbacktesting._util")
+_set_legacy_module(_as_list, "openbacktesting._util")

openbacktesting/indicator_api.py

@@ -0,0 +1,10 @@
+"""Compatibility exports for old type paths; implemented in the indicators subpackage."""
+
+from .indicators.api import (
+    IndicatorNamespace,
+    IndicatorResult,
+    Inputs,
+    Source,
+)
+
+__all__ = ["IndicatorNamespace", "IndicatorResult", "Inputs", "Source"]

openbacktesting/indicator_methods.py

@@ -0,0 +1,123 @@
+"""Compatibility exports for old type paths; implemented in the indicators subpackage."""
+
+from .indicators.methods import (
+    AberrationResult,
+    AccbandsResult,
+    AdxResult,
+    AdxrResult,
+    AmatResult,
+    AobvResult,
+    AroonResult,
+    BbandsResult,
+    BrarResult,
+    CdlZResult,
+    CeResult,
+    CkspResult,
+    CprResult,
+    DmResult,
+    DonchianResult,
+    DrawdownResult,
+    EriResult,
+    FisherResult,
+    HaResult,
+    HiloResult,
+    HtPhasorResult,
+    HtSineResult,
+    HwcResult,
+    IchimokuResult,
+    KcResult,
+    KdjResult,
+    KstResult,
+    KvoResult,
+    MacdextResult,
+    MacdfixResult,
+    MacdResult,
+    MamaResult,
+    MmarResult,
+    MswResult,
+    PpoResult,
+    PsarResult,
+    PvoResult,
+    QqeResult,
+    RainbowResult,
+    RvgiResult,
+    SmiResult,
+    SqueezeProResult,
+    SqueezeResult,
+    StcResult,
+    StochfResult,
+    StochResult,
+    StochrsiResult,
+    SupertrendResult,
+    TdSeqResult,
+    TechnicalAnalysis,
+    ThermoResult,
+    TrixhResult,
+    TrixResult,
+    TsignalsResult,
+    TsiResult,
+    VortexResult,
+    VwmacdResult,
+    XsignalsResult,
+)
+
+__all__ = [
+    "AberrationResult",
+    "AccbandsResult",
+    "AdxResult",
+    "AdxrResult",
+    "AmatResult",
+    "AobvResult",
+    "AroonResult",
+    "BbandsResult",
+    "BrarResult",
+    "CdlZResult",
+    "CeResult",
+    "CkspResult",
+    "CprResult",
+    "DmResult",
+    "DonchianResult",
+    "DrawdownResult",
+    "EriResult",
+    "FisherResult",
+    "HaResult",
+    "HiloResult",
+    "HtPhasorResult",
+    "HtSineResult",
+    "HwcResult",
+    "IchimokuResult",
+    "KcResult",
+    "KdjResult",
+    "KstResult",
+    "KvoResult",
+    "MacdResult",
+    "MacdextResult",
+    "MacdfixResult",
+    "MamaResult",
+    "MmarResult",
+    "MswResult",
+    "PpoResult",
+    "PsarResult",
+    "PvoResult",
+    "QqeResult",
+    "RainbowResult",
+    "RvgiResult",
+    "SmiResult",
+    "SqueezeProResult",
+    "SqueezeResult",
+    "StcResult",
+    "StochResult",
+    "StochfResult",
+    "StochrsiResult",
+    "SupertrendResult",
+    "TdSeqResult",
+    "TechnicalAnalysis",
+    "ThermoResult",
+    "TrixResult",
+    "TrixhResult",
+    "TsiResult",
+    "TsignalsResult",
+    "VortexResult",
+    "VwmacdResult",
+    "XsignalsResult",
+]