openbacktesting 0.2.0__py3-none-any.whl

openbacktesting/indicator_types.py

@@ -0,0 +1,19 @@
+"""Compatibility exports for old type paths; implemented in the indicators subpackage."""
+
+from .indicators.types import (
+    IndicatorCursor,
+    IndicatorError,
+    IndicatorHandle,
+    IndicatorSpec,
+    Parameter,
+    immutable,
+)
+
+__all__ = [
+    "IndicatorCursor",
+    "IndicatorError",
+    "IndicatorHandle",
+    "IndicatorSpec",
+    "Parameter",
+    "immutable",
+]

openbacktesting/indicators/__init__.py

@@ -0,0 +1,7 @@
+"""Public entry points for built-in indicators; computation implementations are maintained by category."""
+
+from .runtime import DEFAULT_CACHE_BYTES as DEFAULT_CACHE_BYTES
+from .runtime import IndicatorCache as IndicatorCache
+from .runtime import catalog as catalog
+from .runtime import compute as compute
+from .runtime import describe as describe

openbacktesting/indicators/api.py

@@ -0,0 +1,97 @@
+"""Lightweight adapter for method-style indicator entry points; strategies still handle computation and registration."""
+
+from collections.abc import Callable, Mapping, Sequence
+
+from .predicates import CrossPredicates
+from .types import IndicatorError, IndicatorHandle
+
+Source = str | IndicatorHandle
+Inputs = Mapping[str, Source]
+
+
+class IndicatorResult:
+    """Read-only attribute container for multiple outputs; channel views are created only during initialization."""
+
+    __slots__ = ("_channels", "_handle")
+
+    def __init__(self, handle: IndicatorHandle):
+        self._handle = handle
+        self._channels = {name: handle[name] for name in handle.name}
+
+    def __getitem__(self, name: str) -> IndicatorHandle:
+        return self._channels[name]
+
+    @property
+    def ready(self):
+        """Minimum-history mask shared by all outputs."""
+        return self._handle.ready
+
+    @property
+    def valid(self):
+        """Underlying validity masks for each channel; check the selected channel before trading."""
+        return self._handle.valid
+
+    @property
+    def metadata(self):
+        """Return an independent copy of the underlying handle's provenance metadata."""
+        return self._handle.metadata
+
+    @property
+    def df(self):
+        """Return a pandas DataFrame copy of the currently visible prefix of all channels."""
+        return self._handle.df
+
+
+class IndicatorNamespace(CrossPredicates):
+    """Bind a registration callback to one strategy, avoiding an indicator-layer dependency on strategy implementations."""
+
+    def __init__(self, register: Callable[..., IndicatorHandle]):
+        self._register = register
+
+    def _call(
+        self,
+        indicator: str,
+        primary: str,
+        source: Source | None,
+        inputs: Inputs | None,
+        backend: str | None,
+        required_outputs: Sequence[str] | None,
+        parameters: dict,
+    ) -> IndicatorHandle:
+        if source is not None:
+            if inputs is not None:
+                raise IndicatorError(
+                    "invalid-parameter", indicator, "source and inputs cannot both be specified"
+                )
+            if not isinstance(source, (str, IndicatorHandle)):
+                raise IndicatorError(
+                    "missing-input", indicator, "source must be a column name or single-channel handle; select a channel from multi-output handles first"
+                )
+            inputs = {primary: source}
+        return self._register(
+            indicator,
+            inputs=inputs,
+            backend=backend,
+            required_outputs=required_outputs,
+            **parameters,
+        )
+
+    def _call_inputs(
+        self,
+        indicator: str,
+        sources: dict[str, Source | None],
+        inputs: Inputs | None,
+        backend: str | None,
+        required_outputs: Sequence[str] | None,
+        parameters: dict,
+    ) -> IndicatorHandle:
+        bound = {name: source for name, source in sources.items() if source is not None}
+        if bound and inputs is not None:
+            raise IndicatorError("invalid-parameter", indicator, "Named inputs and inputs cannot both be specified")
+        return self._register(
+            indicator,
+            inputs=bound if bound else inputs,
+            backend=backend,
+            required_outputs=required_outputs,
+            **parameters,
+        )

openbacktesting/indicators/calculus.py

@@ -0,0 +1,75 @@
+"""Shared finite-history mathematics for local indicators, independent of registration, caches, and strategies."""
+
+import numpy as np
+import pandas as pd
+
+from .types import IndicatorError
+
+
+def clean(source):
+    return source.astype(float).where(np.isfinite(source))
+
+
+def segments(valid):
+    """Return contiguous valid segments; recursive state must be rebuilt after missing data."""
+    edges = np.diff(np.r_[False, valid, False].astype(np.int8))
+    return zip(np.flatnonzero(edges == 1), np.flatnonzero(edges == -1))
+
+
+def average(source, length, *, alpha=None, seeded=True):
+    """Recursive average seeded by an SMA or the first value; warm up again after missing data."""
+    source = clean(source)
+    out = np.full(len(source), np.nan)
+    alpha = 2 / (length + 1) if alpha is None else alpha
+    for start, end in segments(source.notna().to_numpy()):
+        part = source.iloc[start:end].to_numpy(copy=True)
+        skip = length - 1 if seeded else 0
+        if len(part) <= skip:
+            continue
+        if seeded:
+            part[skip] = part[:length].mean()
+        out[start + skip : end] = pd.Series(part[skip:]).ewm(alpha=alpha, adjust=False).mean()
+    return pd.Series(out, index=source.index)
+
+
+def ratio(numerator, denominator):
+    return numerator / denominator.where(denominator != 0)
+
+
+def atr(high, low, close, length):
+    previous = clean(close).shift(1)
+    ranges = np.maximum.reduce(
+        [(clean(high) - clean(low)).to_numpy(), (high - previous).abs(), (low - previous).abs()]
+    )
+    return average(pd.Series(ranges, index=close.index), length, alpha=1 / length)
+
+
+def strength(delta, length):
+    gains = average(delta.clip(lower=0), length, alpha=1 / length)
+    losses = average(-delta.clip(upper=0), length, alpha=1 / length)
+    total = gains + losses
+    return ratio(100 * gains, total).mask(total == 0, 50.0)
+
+
+def condition(source, indicator):
+    source = clean(source)
+    if not source.dropna().isin([0, 1]).all():
+        raise IndicatorError("invalid-input", indicator, "Condition inputs allow only 0, 1, or missing values")
+    return source
+
+
+def pattern_result(calculate, indicator, inputs, minimum, **options):
+    """Call native patterns on valid OHLC segments, preserving integer scores and validity masks separately."""
+    frame = pd.DataFrame(inputs)
+    values = np.zeros(len(frame), dtype=np.int16)
+    valid = np.zeros(len(frame), dtype=bool)
+    for start, end in segments(np.isfinite(frame.to_numpy()).all(axis=1)):
+        if end - start < minimum:
+            continue
+        part = frame.iloc[start:end]
+        result = calculate(**{key: part[key] for key in inputs}, **options)
+        values[start:end] = result.to_numpy(dtype=np.int16)
+        valid[start + minimum - 1 : end] = True
+    result = pd.Series(values, index=frame.index, name=indicator)
+    result.attrs["indicator_valid"] = valid
+    return result

openbacktesting/indicators/candles/cdl_doji.py

@@ -0,0 +1,17 @@
+"""Doji: Threshold based on mean historical range; explicit local implementation avoids implicit TA-Lib and full-sample epsilon."""
+
+import numpy as np
+
+from ..calculus import clean
+
+
+def compute(*, open_, high, low, close, length, factor):
+    width = clean(high) - clean(low)
+    body = (clean(close) - clean(open_)).abs()
+    threshold = width.rolling(length).mean().shift(1) * factor / 100
+    history = np.isfinite(np.column_stack([open_, high, low, close])).all(axis=1)
+    valid = body.notna() & threshold.notna()
+    valid &= clean(close).where(history).rolling(length + 1).count() == length + 1
+    result = ((body <= threshold).astype(np.int16) * 100).rename("cdl_doji")
+    result.attrs["indicator_valid"] = valid.to_numpy()
+    return result

openbacktesting/indicators/candles/cdl_engulfing.py

@@ -0,0 +1,14 @@
+"""cdl_engulfing: Fixed native pattern with a separate validity mask."""
+
+from pandas_ta_classic.candles.cdl_engulfing import cdl_engulfing as _calculate
+
+from ..calculus import pattern_result
+
+
+def compute(*, open_, high, low, close, talib):
+    return pattern_result(
+        _calculate,
+        "cdl_engulfing",
+        {"open_": open_, "high": high, "low": low, "close": close},
+        3,
+    )

openbacktesting/indicators/candles/cdl_eveningstar.py

@@ -0,0 +1,15 @@
+"""cdl_eveningstar: Fixed native pattern with a separate validity mask."""
+
+from pandas_ta_classic.candles.cdl_eveningstar import cdl_eveningstar as _calculate
+
+from ..calculus import pattern_result
+
+
+def compute(*, open_, high, low, close, penetration, talib):
+    return pattern_result(
+        _calculate,
+        "cdl_eveningstar",
+        {"open_": open_, "high": high, "low": low, "close": close},
+        13,
+        penetration=penetration,
+    )

openbacktesting/indicators/candles/cdl_hammer.py

@@ -0,0 +1,14 @@
+"""cdl_hammer: Fixed native pattern with a separate validity mask."""
+
+from pandas_ta_classic.candles.cdl_hammer import cdl_hammer as _calculate
+
+from ..calculus import pattern_result
+
+
+def compute(*, open_, high, low, close, talib):
+    return pattern_result(
+        _calculate,
+        "cdl_hammer",
+        {"open_": open_, "high": high, "low": low, "close": close},
+        12,
+    )

openbacktesting/indicators/candles/cdl_harami.py

@@ -0,0 +1,14 @@
+"""cdl_harami: Fixed native pattern with a separate validity mask."""
+
+from pandas_ta_classic.candles.cdl_harami import cdl_harami as _calculate
+
+from ..calculus import pattern_result
+
+
+def compute(*, open_, high, low, close, talib):
+    return pattern_result(
+        _calculate,
+        "cdl_harami",
+        {"open_": open_, "high": high, "low": low, "close": close},
+        12,
+    )

openbacktesting/indicators/candles/cdl_inside.py

@@ -0,0 +1,14 @@
+"""cdl_inside: Fixed native pattern with a separate validity mask."""
+
+from pandas_ta_classic.candles.cdl_inside import cdl_inside as _calculate
+
+from ..calculus import pattern_result
+
+
+def compute(*, open_, high, low, close, talib):
+    return pattern_result(
+        _calculate,
+        "cdl_inside",
+        {"open_": open_, "high": high, "low": low, "close": close},
+        2,
+    )

openbacktesting/indicators/candles/cdl_marubozu.py

@@ -0,0 +1,14 @@
+"""cdl_marubozu: Fixed native pattern with a separate validity mask."""
+
+from pandas_ta_classic.candles.cdl_marubozu import cdl_marubozu as _calculate
+
+from ..calculus import pattern_result
+
+
+def compute(*, open_, high, low, close, talib):
+    return pattern_result(
+        _calculate,
+        "cdl_marubozu",
+        {"open_": open_, "high": high, "low": low, "close": close},
+        11,
+    )

openbacktesting/indicators/candles/cdl_morningstar.py

@@ -0,0 +1,15 @@
+"""cdl_morningstar: Fixed native pattern with a separate validity mask."""
+
+from pandas_ta_classic.candles.cdl_morningstar import cdl_morningstar as _calculate
+
+from ..calculus import pattern_result
+
+
+def compute(*, open_, high, low, close, penetration, talib):
+    return pattern_result(
+        _calculate,
+        "cdl_morningstar",
+        {"open_": open_, "high": high, "low": low, "close": close},
+        13,
+        penetration=penetration,
+    )

openbacktesting/indicators/candles/cdl_shootingstar.py

@@ -0,0 +1,14 @@
+"""cdl_shootingstar: Fixed native pattern with a separate validity mask."""
+
+from pandas_ta_classic.candles.cdl_shootingstar import cdl_shootingstar as _calculate
+
+from ..calculus import pattern_result
+
+
+def compute(*, open_, high, low, close, talib):
+    return pattern_result(
+        _calculate,
+        "cdl_shootingstar",
+        {"open_": open_, "high": high, "low": low, "close": close},
+        12,
+    )

openbacktesting/indicators/candles/cdl_z.py

@@ -0,0 +1,28 @@
+"""ta.cdl_z: Computation wrapper for the pinned dependency with canonical outputs."""
+
+from pandas_ta_classic.candles.cdl_z import cdl_z as _calculate
+
+from ..common import named_frame
+
+
+def compute(*, open_, high, low, close, length, ddof, full, talib):
+    result = _calculate(
+        open_=open_,
+        high=high,
+        low=low,
+        close=close,
+        length=length,
+        ddof=ddof,
+        full=full,
+        talib=talib,
+    )
+    return named_frame(
+        result,
+        "ta.cdl_z",
+        {
+            f"open_Z_{length}_{ddof or 1}": "open",
+            f"high_Z_{length}_{ddof or 1}": "high",
+            f"low_Z_{length}_{ddof or 1}": "low",
+            f"close_Z_{length}_{ddof or 1}": "close",
+        },
+    )

openbacktesting/indicators/candles/ha.py

@@ -0,0 +1,19 @@
+"""ta.ha: Computation wrapper for the pinned dependency with canonical outputs."""
+
+from pandas_ta_classic.candles.ha import ha as _calculate
+
+from ..common import named_frame
+
+
+def compute(*, open_, high, low, close, talib):
+    result = _calculate(open_=open_, high=high, low=low, close=close, talib=talib)
+    return named_frame(
+        result,
+        "ta.ha",
+        {
+            "HA_open": "open",
+            "HA_high": "high",
+            "HA_low": "low",
+            "HA_close": "close",
+        },
+    )