openbacktesting 0.2.0__py3-none-any.whl

openbacktesting/indicators/trend/cpr.py

@@ -0,0 +1,57 @@
+"""ta.cpr: Computation wrapper for the pinned dependency with canonical outputs."""
+
+from pandas_ta_classic.trend.cpr import cpr as _calculate
+
+from ..common import named_frame
+
+
+def compute(
+    *,
+    open_,
+    high,
+    low,
+    close,
+    volume,
+    method,
+    timeframe,
+    interval,
+    levels,
+    width_analysis,
+    price_position,
+    virgin_cpr,
+    lookahead,
+    talib,
+):
+    result = _calculate(
+        open_=open_,
+        high=high,
+        low=low,
+        close=close,
+        volume=volume,
+        method=method,
+        timeframe=timeframe,
+        interval=interval,
+        levels=levels,
+        width_analysis=width_analysis,
+        price_position=price_position,
+        virgin_cpr=virgin_cpr,
+        lookahead=lookahead,
+        talib=talib,
+    )
+    return named_frame(
+        result,
+        "ta.cpr",
+        {
+            "CPR_TC": "top",
+            "CPR_PIVOT": "pivot",
+            "CPR_BC": "bottom",
+            "CPR_R1": "r1",
+            "CPR_R2": "r2",
+            "CPR_S1": "s1",
+            "CPR_S2": "s2",
+            "CPR_WIDTH": "width",
+            "CPR_WIDTH_PCT": "width_percent",
+            "CPR_WIDTH_CLASS": "width_class",
+            "CPR_POSITION": "position",
+        },
+    )

openbacktesting/indicators/trend/decay.py

@@ -0,0 +1,10 @@
+"""ta.decay: Computation wrapper for the pinned dependency with canonical outputs."""
+
+from pandas_ta_classic.trend.decay import decay as _calculate
+
+from ..common import named_series
+
+
+def compute(*, close, length, mode, kind, talib):
+    result = _calculate(close=close, length=length, mode=mode, kind=kind, talib=talib)
+    return named_series(result, "ta.decay", "decay")

openbacktesting/indicators/trend/decreasing.py

@@ -0,0 +1,18 @@
+"""ta.decreasing: Computation wrapper for the pinned dependency with canonical outputs."""
+
+from pandas_ta_classic.trend.decreasing import decreasing as _calculate
+
+from ..common import named_series
+
+
+def compute(*, close, length, strict, asint, percent, drift, talib):
+    result = _calculate(
+        close=close,
+        length=length,
+        strict=strict,
+        asint=asint,
+        percent=percent,
+        drift=drift,
+        talib=talib,
+    )
+    return named_series(result, "ta.decreasing", "decreasing")

openbacktesting/indicators/trend/dpo.py

@@ -0,0 +1,12 @@
+"""ta.dpo: Computation wrapper for the pinned dependency with canonical outputs."""
+
+from pandas_ta_classic.trend.dpo import dpo as _calculate
+
+from ..common import named_series
+
+
+def compute(*, close, length, centered, lookahead, talib):
+    result = _calculate(
+        close=close, length=length, centered=centered, lookahead=lookahead, talib=talib
+    )
+    return named_series(result, "ta.dpo", "dpo")

openbacktesting/indicators/trend/dx.py

@@ -0,0 +1,19 @@
+"""ta.dx: Computation wrapper for the pinned dependency with canonical outputs."""
+
+from pandas_ta_classic.trend.dx import dx as _calculate
+
+from ..common import named_series
+
+
+def compute(*, high, low, close, length, scalar, mamode, drift, talib):
+    result = _calculate(
+        high=high,
+        low=low,
+        close=close,
+        length=length,
+        scalar=scalar,
+        mamode=mamode,
+        drift=drift,
+        talib=talib,
+    )
+    return named_series(result, "ta.dx", "dx")

openbacktesting/indicators/trend/edecay.py

@@ -0,0 +1,10 @@
+"""ta.edecay: Computation wrapper for the pinned dependency with canonical outputs."""
+
+from pandas_ta_classic.trend.edecay import edecay as _calculate
+
+from ..common import named_series
+
+
+def compute(*, close, length, talib):
+    result = _calculate(close=close, length=length, talib=talib)
+    return named_series(result, "ta.edecay", "edecay")

openbacktesting/indicators/trend/increasing.py

@@ -0,0 +1,18 @@
+"""ta.increasing: Computation wrapper for the pinned dependency with canonical outputs."""
+
+from pandas_ta_classic.trend.increasing import increasing as _calculate
+
+from ..common import named_series
+
+
+def compute(*, close, length, strict, asint, percent, drift, talib):
+    result = _calculate(
+        close=close,
+        length=length,
+        strict=strict,
+        asint=asint,
+        percent=percent,
+        drift=drift,
+        talib=talib,
+    )
+    return named_series(result, "ta.increasing", "increasing")

openbacktesting/indicators/trend/long_run.py

@@ -0,0 +1,10 @@
+"""ta.long_run: Computation wrapper for the pinned dependency with canonical outputs."""
+
+from pandas_ta_classic.trend.long_run import long_run as _calculate
+
+from ..common import named_series
+
+
+def compute(*, fast, slow, length, talib):
+    result = _calculate(fast=fast, slow=slow, length=length, talib=talib)
+    return named_series(result, "ta.long_run", "long_run")

openbacktesting/indicators/trend/minus_dm.py

@@ -0,0 +1,10 @@
+"""ta.minus_dm: Computation wrapper for the pinned dependency with canonical outputs."""
+
+from pandas_ta_classic.trend.minus_dm import minus_dm as _calculate
+
+from ..common import named_series
+
+
+def compute(*, high, low, length, drift, talib):
+    result = _calculate(high=high, low=low, length=length, drift=drift, talib=talib)
+    return named_series(result, "ta.minus_dm", "minus_dm")

openbacktesting/indicators/trend/pivot_points.py

@@ -0,0 +1,89 @@
+"""Six Pivot formulas with explicit period anchors; consume only completed periods."""
+
+import numpy as np
+import pandas as pd
+
+from ..calculus import condition
+from ..types import IndicatorError
+
+
+def _levels(open_, high, low, close, current_open, method):
+    levels = np.full(11, np.nan)
+    width = high - low
+    pivot = (high + low + close) / 3
+    if method == "woodie":
+        pivot = (high + low + 2 * current_open) / 4
+    if method == "demark":
+        if close == open_:
+            total = high + low + 2 * close
+        elif close > open_:
+            total = 2 * high + low + close
+        else:
+            total = high + 2 * low + close
+        levels[:3] = total / 4, total / 2 - low, total / 2 - high
+        return levels
+    levels[0] = pivot
+    if method == "fibonacci":
+        for i, coefficient in enumerate((0.382, 0.618, 1), 1):
+            levels[2 * i - 1 : 2 * i + 1] = pivot + width * coefficient, pivot - width * coefficient
+    elif method == "camarilla":
+        for i, divisor in enumerate((12, 6, 4, 2), 1):
+            levels[2 * i - 1 : 2 * i + 1] = (
+                close + 1.1 * width / divisor,
+                close - 1.1 * width / divisor,
+            )
+        if low != 0:
+            levels[9] = high / low * close
+            levels[10] = 2 * close - levels[9]
+    else:
+        levels[1:5] = 2 * pivot - low, 2 * pivot - high, pivot + width, pivot - width
+        if method == "classic":
+            levels[5:9] = pivot + 2 * width, pivot - 2 * width, pivot + 3 * width, pivot - 3 * width
+        elif method == "woodie":
+            levels[5:7] = high + 2 * (pivot - low), low - 2 * (high - pivot)
+            levels[7:9] = levels[5] + width, levels[6] - width
+        else:
+            for i in (3, 4, 5):
+                levels[2 * i - 1 : 2 * i + 1] = (
+                    (i - 1) * pivot + high - (i - 1) * low,
+                    (i - 1) * pivot - (i - 1) * high + low,
+                )
+    return levels
+
+
+def compute(*, open_, high, low, close, anchor, method, developing):
+    if developing and method == "woodie":
+        raise IndicatorError("invalid-parameter", "ta.pivot_points", "Woodie does not support developing")
+    anchor = condition(anchor, "ta.pivot_points")
+    if anchor.isna().any():
+        raise IndicatorError("invalid-input", "ta.pivot_points", "Period anchors must not be missing")
+    values = np.column_stack([open_, high, low, close])
+    output = np.full((len(close), 11), np.nan)
+    levels = np.full(11, np.nan)
+    started = False
+    complete = False
+    po = ph = pl = pc = np.nan
+    for i, (o, h, l, c) in enumerate(values):
+        valid = np.isfinite(values[i]).all()
+        if developing:
+            valid = valid and h >= l
+        if anchor.iloc[i] == 1:
+            if started and complete and (method != "woodie" or np.isfinite(o)):
+                levels = _levels(po, ph, pl, pc, o, method)
+            else:
+                levels = np.full(11, np.nan)
+            started, complete = True, valid
+            po, ph, pl, pc = o, h, l, c
+        elif started:
+            complete &= valid
+            ph, pl, pc = max(ph, h), min(pl, l), c
+        if developing:
+            levels = (
+                _levels(po, ph, pl, pc, o, method) if started and complete else np.full(11, np.nan)
+            )
+        output[i] = levels
+    return pd.DataFrame(
+        output,
+        index=close.index,
+        columns=["p", "r1", "s1", "r2", "s2", "r3", "s3", "r4", "s4", "r5", "s5"],
+    )

openbacktesting/indicators/trend/pivothigh.py

@@ -0,0 +1,23 @@
+"""ta.pivothigh: Fixed causal sequence contract."""
+
+import numpy as np
+import pandas as pd
+
+from ..calculus import clean
+
+
+def compute(*, high, left, right):
+    source = clean(high)
+    candidate = source.shift(right)
+    lhs = source.shift(right + 1).rolling(left).max()
+    rhs = source.rolling(right).max()
+    event = (candidate >= lhs) & (candidate > rhs)
+    positions = pd.Series(np.arange(len(source), dtype=float), index=source.index)
+    return pd.DataFrame(
+        {
+            "value": candidate.where(event),
+            "pivot_bar": (positions - right).where(event),
+            "confirmed_at": positions.where(event),
+        },
+        index=source.index,
+    )

openbacktesting/indicators/trend/pivotlow.py

@@ -0,0 +1,23 @@
+"""ta.pivotlow: Fixed causal sequence contract."""
+
+import numpy as np
+import pandas as pd
+
+from ..calculus import clean
+
+
+def compute(*, low, left, right):
+    source = clean(low)
+    candidate = source.shift(right)
+    lhs = source.shift(right + 1).rolling(left).min()
+    rhs = source.rolling(right).min()
+    event = (candidate <= lhs) & (candidate < rhs)
+    positions = pd.Series(np.arange(len(source), dtype=float), index=source.index)
+    return pd.DataFrame(
+        {
+            "value": candidate.where(event),
+            "pivot_bar": (positions - right).where(event),
+            "confirmed_at": positions.where(event),
+        },
+        index=source.index,
+    )

openbacktesting/indicators/trend/plus_dm.py

@@ -0,0 +1,10 @@
+"""ta.plus_dm: Computation wrapper for the pinned dependency with canonical outputs."""
+
+from pandas_ta_classic.trend.plus_dm import plus_dm as _calculate
+
+from ..common import named_series
+
+
+def compute(*, high, low, length, drift, talib):
+    result = _calculate(high=high, low=low, length=length, drift=drift, talib=talib)
+    return named_series(result, "ta.plus_dm", "plus_dm")

openbacktesting/indicators/trend/pmax.py

@@ -0,0 +1,18 @@
+"""ta.pmax: Computation wrapper for the pinned dependency with canonical outputs."""
+
+from pandas_ta_classic.trend.pmax import pmax as _calculate
+
+from ..common import named_series
+
+
+def compute(*, high, low, close, length, multiplier, mamode, talib):
+    result = _calculate(
+        high=high,
+        low=low,
+        close=close,
+        length=length,
+        multiplier=multiplier,
+        mamode=mamode,
+        talib=talib,
+    )
+    return named_series(result, "ta.pmax", "pmax")

openbacktesting/indicators/trend/psar.py

@@ -0,0 +1,19 @@
+"""ta.psar: Computation wrapper for the pinned dependency with canonical outputs."""
+
+from pandas_ta_classic.trend.psar import psar as _calculate
+
+from ..common import named_frame
+
+
+def compute(*, high, low, close, af0, af, max_af, talib):
+    result = _calculate(high=high, low=low, close=close, af0=af0, af=af, max_af=max_af, talib=talib)
+    return named_frame(
+        result,
+        "ta.psar",
+        {
+            f"PSARl_{af0}_{max_af}": "long",
+            f"PSARs_{af0}_{max_af}": "short",
+            f"PSARaf_{af0}_{max_af}": "acceleration",
+            f"PSARr_{af0}_{max_af}": "reversal",
+        },
+    )

openbacktesting/indicators/trend/qstick.py

@@ -0,0 +1,10 @@
+"""ta.qstick: Computation wrapper for the pinned dependency with canonical outputs."""
+
+from pandas_ta_classic.trend.qstick import qstick as _calculate
+
+from ..common import named_series
+
+
+def compute(*, open_, close, length, talib):
+    result = _calculate(open_=open_, close=close, length=length, talib=talib)
+    return named_series(result, "ta.qstick", "qstick")

openbacktesting/indicators/trend/sarext.py

@@ -0,0 +1,35 @@
+"""ta.sarext: Computation wrapper for the pinned dependency with canonical outputs."""
+
+from pandas_ta_classic.trend.sarext import sarext as _calculate
+
+from ..common import named_series
+
+
+def compute(
+    *,
+    high,
+    low,
+    startvalue,
+    offsetonreverse,
+    accelerationinitlong,
+    accelerationlong,
+    accelerationmaxlong,
+    accelerationinitshort,
+    accelerationshort,
+    accelerationmaxshort,
+    talib,
+):
+    result = _calculate(
+        high=high,
+        low=low,
+        startvalue=startvalue,
+        offsetonreverse=offsetonreverse,
+        accelerationinitlong=accelerationinitlong,
+        accelerationlong=accelerationlong,
+        accelerationmaxlong=accelerationmaxlong,
+        accelerationinitshort=accelerationinitshort,
+        accelerationshort=accelerationshort,
+        accelerationmaxshort=accelerationmaxshort,
+        talib=talib,
+    )
+    return named_series(result, "ta.sarext", "sarext")

openbacktesting/indicators/trend/short_run.py

@@ -0,0 +1,10 @@
+"""ta.short_run: Computation wrapper for the pinned dependency with canonical outputs."""
+
+from pandas_ta_classic.trend.short_run import short_run as _calculate
+
+from ..common import named_series
+
+
+def compute(*, fast, slow, length, talib):
+    result = _calculate(fast=fast, slow=slow, length=length, talib=talib)
+    return named_series(result, "ta.short_run", "short_run")

openbacktesting/indicators/trend/tsignals.py

@@ -0,0 +1,26 @@
+"""ta.tsignals: Computation wrapper for the pinned dependency with canonical outputs."""
+
+from pandas_ta_classic.trend.tsignals import tsignals as _calculate
+
+from ..common import named_frame
+
+
+def compute(*, trend, asbool, trade_offset, drift, trend_reset, talib):
+    result = _calculate(
+        trend=trend,
+        asbool=asbool,
+        trade_offset=trade_offset,
+        drift=drift,
+        trend_reset=trend_reset,
+        talib=talib,
+    )
+    return named_frame(
+        result,
+        "ta.tsignals",
+        {
+            "TS_Trends": "trend",
+            "TS_Trades": "trades",
+            "TS_Entries": "entries",
+            "TS_Exits": "exits",
+        },
+    )

openbacktesting/indicators/trend/ttm_trend.py

@@ -0,0 +1,16 @@
+"""ta.ttm_trend: Computation wrapper for the pinned dependency with canonical outputs."""
+
+from pandas_ta_classic.trend.ttm_trend import ttm_trend as _calculate
+
+from ..common import named_frame
+
+
+def compute(*, high, low, close, length, talib):
+    result = _calculate(high=high, low=low, close=close, length=length, talib=talib)
+    return named_frame(
+        result,
+        "ta.ttm_trend",
+        {
+            f"TTM_TRND_{length}": "ttm_trend",
+        },
+    )

openbacktesting/indicators/trend/vhf.py

@@ -0,0 +1,10 @@
+"""ta.vhf: Computation wrapper for the pinned dependency with canonical outputs."""
+
+from pandas_ta_classic.trend.vhf import vhf as _calculate
+
+from ..common import named_series
+
+
+def compute(*, close, length, drift, talib):
+    result = _calculate(close=close, length=length, drift=drift, talib=talib)
+    return named_series(result, "ta.vhf", "vhf")

openbacktesting/indicators/trend/volatility_stop.py

@@ -0,0 +1,33 @@
+"""ta.volatility_stop: Independent formula with a fixed initialization contract."""
+
+import numpy as np
+import pandas as pd
+
+from ..calculus import atr, segments
+
+
+def compute(*, high, low, close, length, multiplier):
+    width = atr(high, low, close, length).to_numpy() * multiplier
+    prices = close.to_numpy()
+    stop = np.full(len(close), np.nan)
+    direction = stop.copy()
+    valid = np.isfinite(np.column_stack([high, low, close])).all(axis=1)
+    for start, end in segments(valid):
+        if end - start <= length:
+            continue
+        bullish = prices[start + length - 1] > prices[start]
+        initial = prices[start : start + length]
+        extreme = initial.max() if bullish else initial.min()
+        confirmed = False
+        for i in range(start + length, end):
+            level = extreme - width[i - 1] if bullish else extreme + width[i - 1]
+            if confirmed:
+                stop[i], direction[i] = level, 1 if bullish else -1
+            reverse = prices[i] < level if bullish else prices[i] > level
+            if reverse:
+                bullish = not bullish
+                extreme = prices[i]
+                confirmed = True
+            else:
+                extreme = max(extreme, prices[i]) if bullish else min(extreme, prices[i])
+    return pd.DataFrame({"stop": stop, "direction": direction}, index=close.index)

openbacktesting/indicators/trend/vortex.py

@@ -0,0 +1,17 @@
+"""ta.vortex: Computation wrapper for the pinned dependency with canonical outputs."""
+
+from pandas_ta_classic.trend.vortex import vortex as _calculate
+
+from ..common import named_frame
+
+
+def compute(*, high, low, close, length, drift, talib):
+    result = _calculate(high=high, low=low, close=close, length=length, drift=drift, talib=talib)
+    return named_frame(
+        result,
+        "ta.vortex",
+        {
+            f"VTXP_{length}": "positive",
+            f"VTXM_{length}": "negative",
+        },
+    )

openbacktesting/indicators/trend/xsignals.py

@@ -0,0 +1,29 @@
+"""ta.xsignals: Computation wrapper for the pinned dependency with canonical outputs."""
+
+from pandas_ta_classic.trend.xsignals import xsignals as _calculate
+
+from ..common import named_frame
+
+
+def compute(*, signal, xa, xb, above, long, asbool, trade_offset, trend_reset, talib):
+    result = _calculate(
+        signal=signal,
+        xa=xa,
+        xb=xb,
+        above=above,
+        long=long,
+        asbool=asbool,
+        trade_offset=trade_offset,
+        trend_reset=trend_reset,
+        talib=talib,
+    )
+    return named_frame(
+        result,
+        "ta.xsignals",
+        {
+            "TS_Trends": "trend",
+            "TS_Trades": "trades",
+            "TS_Entries": "entries",
+            "TS_Exits": "exits",
+        },
+    )