openbacktesting 0.2.0__py3-none-any.whl

openbacktesting/indicators/volatility/aberration.py

@@ -0,0 +1,21 @@
+"""ta.aberration: Computation wrapper for the pinned dependency with canonical outputs."""
+
+from pandas_ta_classic.volatility.aberration import aberration as _calculate
+
+from ..common import named_frame
+
+
+def compute(*, high, low, close, length, atr_length, talib):
+    result = _calculate(
+        high=high, low=low, close=close, length=length, atr_length=atr_length, talib=talib
+    )
+    return named_frame(
+        result,
+        "ta.aberration",
+        {
+            f"ABER_ZG_{length}_{atr_length}": "middle",
+            f"ABER_SG_{length}_{atr_length}": "upper",
+            f"ABER_XG_{length}_{atr_length}": "lower",
+            f"ABER_ATR_{length}_{atr_length}": "atr",
+        },
+    )

openbacktesting/indicators/volatility/accbands.py

@@ -0,0 +1,20 @@
+"""ta.accbands: Computation wrapper for the pinned dependency with canonical outputs."""
+
+from pandas_ta_classic.volatility.accbands import accbands as _calculate
+
+from ..common import named_frame
+
+
+def compute(*, high, low, close, length, c, mamode, drift, talib):
+    result = _calculate(
+        high=high, low=low, close=close, length=length, c=c, mamode=mamode, drift=drift, talib=talib
+    )
+    return named_frame(
+        result,
+        "ta.accbands",
+        {
+            f"ACCBL_{length}": "lower",
+            f"ACCBM_{length}": "middle",
+            f"ACCBU_{length}": "upper",
+        },
+    )

openbacktesting/indicators/volatility/adr.py

@@ -0,0 +1,7 @@
+"""ta.adr: Independent formula with a fixed initialization contract."""
+
+from ..calculus import clean
+
+
+def compute(*, high, low, length):
+    return (clean(high) - clean(low)).rolling(length).mean().rename("adr")

openbacktesting/indicators/volatility/atr.py

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

openbacktesting/indicators/volatility/avolume.py

@@ -0,0 +1,10 @@
+"""ta.avolume: Computation wrapper for the pinned dependency with canonical outputs."""
+
+from pandas_ta_classic.volatility.avolume import avolume 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.avolume", "avolume")

openbacktesting/indicators/volatility/bbands.py

@@ -0,0 +1,20 @@
+"""ta.bbands: Computation wrapper for the pinned dependency with canonical outputs."""
+
+from pandas_ta_classic.volatility.bbands import bbands as _calculate
+
+from ..common import named_frame
+
+
+def compute(*, close, length, std, ddof, mamode, talib):
+    result = _calculate(close=close, length=length, std=std, ddof=ddof, mamode=mamode, talib=talib)
+    return named_frame(
+        result,
+        "ta.bbands",
+        {
+            f"BBL_{length}_{std}": "lower",
+            f"BBM_{length}_{std}": "middle",
+            f"BBU_{length}_{std}": "upper",
+            f"BBB_{length}_{std}": "bandwidth",
+            f"BBP_{length}_{std}": "percent",
+        },
+    )

openbacktesting/indicators/volatility/ce.py

@@ -0,0 +1,25 @@
+"""ta.ce: Computation wrapper for the pinned dependency with canonical outputs."""
+
+from pandas_ta_classic.volatility.ce import ce as _calculate
+
+from ..common import named_frame
+
+
+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_frame(
+        result,
+        "ta.ce",
+        {
+            f"CE_L_{length}_{multiplier}": "long",
+            f"CE_S_{length}_{multiplier}": "short",
+        },
+    )

openbacktesting/indicators/volatility/cvi.py

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

openbacktesting/indicators/volatility/donchian.py

@@ -0,0 +1,20 @@
+"""ta.donchian: Computation wrapper for the pinned dependency with canonical outputs."""
+
+from pandas_ta_classic.volatility.donchian import donchian as _calculate
+
+from ..common import named_frame
+
+
+def compute(*, high, low, lower_length, upper_length, talib):
+    result = _calculate(
+        high=high, low=low, lower_length=lower_length, upper_length=upper_length, talib=talib
+    )
+    return named_frame(
+        result,
+        "ta.donchian",
+        {
+            f"DCL_{lower_length}_{upper_length}": "lower",
+            f"DCM_{lower_length}_{upper_length}": "middle",
+            f"DCU_{lower_length}_{upper_length}": "upper",
+        },
+    )

openbacktesting/indicators/volatility/hvol.py

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

openbacktesting/indicators/volatility/hwc.py

@@ -0,0 +1,27 @@
+"""ta.hwc: Computation wrapper for the pinned dependency with canonical outputs."""
+
+from pandas_ta_classic.volatility.hwc import hwc as _calculate
+
+from ..common import named_frame
+
+
+def compute(*, close, na, nb, nc, nd, scalar, channel_eval, talib):
+    result = _calculate(
+        close=close,
+        na=na,
+        nb=nb,
+        nc=nc,
+        nd=nd,
+        scalar=scalar,
+        channel_eval=channel_eval,
+        talib=talib,
+    )
+    return named_frame(
+        result,
+        "ta.hwc",
+        {
+            "HWM": "middle",
+            "HWU": "upper",
+            "HWL": "lower",
+        },
+    )

openbacktesting/indicators/volatility/kc.py

@@ -0,0 +1,27 @@
+"""ta.kc: Computation wrapper for the pinned dependency with canonical outputs."""
+
+from pandas_ta_classic.volatility.kc import kc as _calculate
+
+from ..common import named_frame
+
+
+def compute(*, high, low, close, length, scalar, mamode, talib, use_true_range):
+    result = _calculate(
+        high=high,
+        low=low,
+        close=close,
+        length=length,
+        scalar=scalar,
+        mamode=mamode,
+        talib=talib,
+        tr=use_true_range,
+    )
+    return named_frame(
+        result,
+        "ta.kc",
+        {
+            f"KCL{mamode[0]}_{length}_{float(scalar)}": "lower",
+            f"KCB{mamode[0]}_{length}_{float(scalar)}": "middle",
+            f"KCU{mamode[0]}_{length}_{float(scalar)}": "upper",
+        },
+    )

openbacktesting/indicators/volatility/massi.py

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

openbacktesting/indicators/volatility/natr.py

@@ -0,0 +1,19 @@
+"""ta.natr: Computation wrapper for the pinned dependency with canonical outputs."""
+
+from pandas_ta_classic.volatility.natr import natr 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.natr", "natr")

openbacktesting/indicators/volatility/pdist.py

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

openbacktesting/indicators/volatility/rvi.py

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

openbacktesting/indicators/volatility/starc.py

@@ -0,0 +1,11 @@
+"""ta.starc: Independent formula with a fixed initialization contract."""
+
+import pandas as pd
+
+from ..calculus import atr, clean
+
+
+def compute(*, high, low, close, length, atr_length, multiplier):
+    middle = clean(close).rolling(length).mean()
+    spread = atr(high, low, close, atr_length) * multiplier
+    return pd.DataFrame({"middle": middle, "upper": middle + spread, "lower": middle - spread})

openbacktesting/indicators/volatility/thermo.py

@@ -0,0 +1,28 @@
+"""ta.thermo: Computation wrapper for the pinned dependency with canonical outputs."""
+
+from pandas_ta_classic.volatility.thermo import thermo as _calculate
+
+from ..common import named_frame
+
+
+def compute(*, high, low, length, long, short, mamode, drift, talib):
+    result = _calculate(
+        high=high,
+        low=low,
+        length=length,
+        long=long,
+        short=short,
+        mamode=mamode,
+        drift=drift,
+        talib=talib,
+    )
+    return named_frame(
+        result,
+        "ta.thermo",
+        {
+            f"THERMO_{length}_{float(long)}_{float(short)}": "thermo",
+            f"THERMOma_{length}_{float(long)}_{float(short)}": "average",
+            f"THERMOl_{length}_{float(long)}_{float(short)}": "long",
+            f"THERMOs_{length}_{float(long)}_{float(short)}": "short",
+        },
+    )

openbacktesting/indicators/volatility/true_range.py

@@ -0,0 +1,31 @@
+"""Legacy default TR calculation with explicit fallback for missing previous Close."""
+
+import numpy as np
+import pandas as pd
+from pandas_ta_classic.volatility.true_range import true_range as _calculate
+
+from ..common import named_series
+
+
+def compute(*, high, low, close, drift, talib, handle_na):
+    if not handle_na:
+        result = named_series(
+            _calculate(high=high, low=low, close=close, drift=drift, talib=talib),
+            "ta.true_range",
+            "true_range",
+        )
+        if result is not None:
+            result.attrs["indicator_valid"] = np.isfinite(np.column_stack([high, low, close])).all(
+                axis=1
+            )
+        return result
+    previous = close.shift(drift).to_numpy()
+    h, l = high.to_numpy(), low.to_numpy()
+    with np.errstate(over="ignore", invalid="ignore"):
+        value = np.where(
+            np.isfinite(previous),
+            np.maximum.reduce([h - l, abs(h - previous), abs(l - previous)]),
+            h - l,
+        )
+    value = np.where(np.isfinite(h) & np.isfinite(l) & (h >= l), value, np.nan)
+    return pd.Series(value, index=high.index, name="true_range")

openbacktesting/indicators/volatility/ui.py

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

openbacktesting/indicators/volume/ad.py

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

openbacktesting/indicators/volume/adosc.py

@@ -0,0 +1,19 @@
+"""ta.adosc: Computation wrapper for the pinned dependency with canonical outputs."""
+
+from pandas_ta_classic.volume.adosc import adosc as _calculate
+
+from ..common import named_series
+
+
+def compute(*, high, low, close, volume, fast, slow, open_, talib):
+    result = _calculate(
+        high=high,
+        low=low,
+        close=close,
+        volume=volume,
+        fast=fast,
+        slow=slow,
+        open_=open_,
+        talib=talib,
+    )
+    return named_series(result, "ta.adosc", "adosc")

openbacktesting/indicators/volume/aobv.py

@@ -0,0 +1,31 @@
+"""ta.aobv: Computation wrapper for the pinned dependency with canonical outputs."""
+
+from pandas_ta_classic.volume.aobv import aobv as _calculate
+
+from ..common import named_frame
+
+
+def compute(*, close, volume, fast, slow, max_lookback, min_lookback, mamode, talib):
+    result = _calculate(
+        close=close,
+        volume=volume,
+        fast=fast,
+        slow=slow,
+        max_lookback=max_lookback,
+        min_lookback=min_lookback,
+        mamode=mamode,
+        talib=talib,
+    )
+    return named_frame(
+        result,
+        "ta.aobv",
+        {
+            "OBV": "obv",
+            f"OBV_min_{min_lookback}": "minimum",
+            f"OBV_max_{max_lookback}": "maximum",
+            f"OBV{mamode[0]}_{fast}": "fast",
+            f"OBV{mamode[0]}_{slow}": "slow",
+            "AOBV_LR_2": "long",
+            "AOBV_SR_2": "short",
+        },
+    )

openbacktesting/indicators/volume/cmf.py

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

openbacktesting/indicators/volume/efi.py

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

openbacktesting/indicators/volume/emv.py

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

openbacktesting/indicators/volume/eom.py

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

openbacktesting/indicators/volume/iii.py

@@ -0,0 +1,9 @@
+"""ta.iii: Independent formula with a fixed initialization contract."""
+
+from ..calculus import clean, ratio
+
+
+def compute(*, high, low, close, volume):
+    return ratio(
+        clean(volume) * (2 * clean(close) - clean(high) - clean(low)), clean(high) - clean(low)
+    ).rename("iii")

openbacktesting/indicators/volume/kvo.py

@@ -0,0 +1,28 @@
+"""ta.kvo: Computation wrapper for the pinned dependency with canonical outputs."""
+
+from pandas_ta_classic.volume.kvo import kvo as _calculate
+
+from ..common import named_frame
+
+
+def compute(*, high, low, close, volume, fast, slow, signal, mamode, drift, talib):
+    result = _calculate(
+        high=high,
+        low=low,
+        close=close,
+        volume=volume,
+        fast=fast,
+        slow=slow,
+        signal=signal,
+        mamode=mamode,
+        drift=drift,
+        talib=talib,
+    )
+    return named_frame(
+        result,
+        "ta.kvo",
+        {
+            f"KVO_{fast}_{slow}_{signal}": "kvo",
+            f"KVOs_{fast}_{slow}_{signal}": "signal",
+        },
+    )

openbacktesting/indicators/volume/marketfi.py

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

openbacktesting/indicators/volume/mfi.py

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

openbacktesting/indicators/volume/nvi.py

@@ -0,0 +1,26 @@
+"""NVI: Update the preceding index by the price ratio under the volume condition."""
+
+import numpy as np
+import pandas as pd
+
+
+def compute(*, close, volume, length, initial):
+    prices, amounts = close.to_numpy(), volume.to_numpy()
+    result = np.full(len(close), np.nan)
+    value = None
+    for i in range(len(close)):
+        if not np.isfinite(prices[i]) or not np.isfinite(amounts[i]):
+            continue
+        if value is None:
+            value = float(initial)
+        elif (
+            i < length
+            or not np.isfinite(prices[i - length])
+            or prices[i - length] == 0
+            or not np.isfinite(amounts[i - 1])
+        ):
+            continue
+        elif amounts[i] < amounts[i - 1]:
+            value *= prices[i] / prices[i - length]
+        result[i] = value
+    return pd.Series(result, index=close.index, name="nvi")

openbacktesting/indicators/volume/obv.py

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

openbacktesting/indicators/volume/pvi.py

@@ -0,0 +1,26 @@
+"""PVI: Update the preceding index by the price ratio under the volume condition."""
+
+import numpy as np
+import pandas as pd
+
+
+def compute(*, close, volume, length, initial):
+    prices, amounts = close.to_numpy(), volume.to_numpy()
+    result = np.full(len(close), np.nan)
+    value = None
+    for i in range(len(close)):
+        if not np.isfinite(prices[i]) or not np.isfinite(amounts[i]):
+            continue
+        if value is None:
+            value = float(initial)
+        elif (
+            i < length
+            or not np.isfinite(prices[i - length])
+            or prices[i - length] == 0
+            or not np.isfinite(amounts[i - 1])
+        ):
+            continue
+        elif amounts[i] > amounts[i - 1]:
+            value *= prices[i] / prices[i - length]
+        result[i] = value
+    return pd.Series(result, index=close.index, name="pvi")

openbacktesting/indicators/volume/pvol.py

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

openbacktesting/indicators/volume/pvr.py

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