openbacktesting 0.2.0__py3-none-any.whl

openbacktesting/indicators/momentum/rocr100.py

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

openbacktesting/indicators/momentum/rsi.py

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

openbacktesting/indicators/momentum/rsx.py

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

openbacktesting/indicators/momentum/rvgi.py

@@ -0,0 +1,26 @@
+"""ta.rvgi: Computation wrapper for the pinned dependency with canonical outputs."""
+
+from pandas_ta_classic.momentum.rvgi import rvgi as _calculate
+
+from ..common import named_frame
+
+
+def compute(*, open_, high, low, close, length, swma_length, talib):
+    result = _calculate(
+        open_=open_,
+        high=high,
+        low=low,
+        close=close,
+        length=length,
+        swma_length=swma_length,
+        talib=talib,
+    )
+    return named_frame(
+        result,
+        "ta.rvgi",
+        {
+            f"RVGIh_{length}_{swma_length}": "histogram",
+            f"RVGI_{length}_{swma_length}": "rvgi",
+            f"RVGIs_{length}_{swma_length}": "signal",
+        },
+    )

openbacktesting/indicators/momentum/slope.py

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

openbacktesting/indicators/momentum/smc_sweep.py

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

openbacktesting/indicators/momentum/smi.py

@@ -0,0 +1,21 @@
+"""ta.smi: Computation wrapper for the pinned dependency with canonical outputs."""
+
+from pandas_ta_classic.momentum.smi import smi as _calculate
+
+from ..common import named_frame
+
+
+def compute(*, close, fast, slow, signal, scalar, talib):
+    result = _calculate(
+        close=close, fast=fast, slow=slow, signal=signal, scalar=scalar, talib=talib
+    )
+    suffix = f"_{scalar}" if scalar != 1 else ""
+    return named_frame(
+        result,
+        "ta.smi",
+        {
+            f"SMI_{fast}_{slow}_{signal}{suffix}": "smi",
+            f"SMIs_{fast}_{slow}_{signal}{suffix}": "signal",
+            f"SMIo_{fast}_{slow}_{signal}{suffix}": "oscillator",
+        },
+    )

openbacktesting/indicators/momentum/smi_stochastic.py

@@ -0,0 +1,15 @@
+"""ta.smi_stochastic: Independent formula with a fixed initialization contract."""
+
+import pandas as pd
+
+from ..calculus import average, clean, ratio
+
+
+def compute(*, high, low, close, length, smooth, double, signal):
+    hi, lo = clean(high).rolling(length).max(), clean(low).rolling(length).min()
+    distance = clean(close) - (hi + lo) / 2
+    spread = hi - lo
+    numerator = average(average(distance, smooth, seeded=False), double, seeded=False)
+    denominator = average(average(spread, smooth, seeded=False), double, seeded=False)
+    smi = ratio(200 * numerator, denominator)
+    return pd.DataFrame({"smi": smi, "signal": average(smi, signal, seeded=False)})

openbacktesting/indicators/momentum/squeeze.py

@@ -0,0 +1,47 @@
+"""ta.squeeze: Computation wrapper for the pinned dependency with canonical outputs."""
+
+from pandas_ta_classic.momentum.squeeze import squeeze as _calculate
+
+from ..common import named_frame
+
+
+def compute(
+    *,
+    high,
+    low,
+    close,
+    bb_length,
+    bb_std,
+    kc_length,
+    kc_scalar,
+    mom_length,
+    mom_smooth,
+    use_tr,
+    mamode,
+    talib,
+):
+    result = _calculate(
+        high=high,
+        low=low,
+        close=close,
+        bb_length=bb_length,
+        bb_std=bb_std,
+        kc_length=kc_length,
+        kc_scalar=kc_scalar,
+        mom_length=mom_length,
+        mom_smooth=mom_smooth,
+        tr=use_tr,
+        mamode=mamode,
+        talib=talib,
+    )
+    mode = "" if use_tr else "hlr"
+    return named_frame(
+        result,
+        "ta.squeeze",
+        {
+            f"SQZ{mode}_{bb_length}_{bb_std}_{kc_length}_{kc_scalar}": "squeeze",
+            "SQZ_ON": "on",
+            "SQZ_OFF": "off",
+            "SQZ_NO": "none",
+        },
+    )

openbacktesting/indicators/momentum/squeeze_pro.py

@@ -0,0 +1,53 @@
+"""ta.squeeze_pro: Computation wrapper for the pinned dependency with canonical outputs."""
+
+from pandas_ta_classic.momentum.squeeze_pro import squeeze_pro as _calculate
+
+from ..common import named_frame
+
+
+def compute(
+    *,
+    high,
+    low,
+    close,
+    bb_length,
+    bb_std,
+    kc_length,
+    kc_scalar_wide,
+    kc_scalar_normal,
+    kc_scalar_narrow,
+    mom_length,
+    mom_smooth,
+    use_tr,
+    mamode,
+    talib,
+):
+    result = _calculate(
+        high=high,
+        low=low,
+        close=close,
+        bb_length=bb_length,
+        bb_std=bb_std,
+        kc_length=kc_length,
+        kc_scalar_wide=kc_scalar_wide,
+        kc_scalar_normal=kc_scalar_normal,
+        kc_scalar_narrow=kc_scalar_narrow,
+        mom_length=mom_length,
+        mom_smooth=mom_smooth,
+        tr=use_tr,
+        mamode=mamode,
+        talib=talib,
+    )
+    mode = "" if use_tr else "hlr"
+    return named_frame(
+        result,
+        "ta.squeeze_pro",
+        {
+            f"SQZPRO{mode}_{bb_length}_{bb_std}_{kc_length}_{float(kc_scalar_wide)}_{float(kc_scalar_normal)}_{float(kc_scalar_narrow)}": "squeeze",
+            "SQZPRO_ON_WIDE": "on_wide",
+            "SQZPRO_ON_NORMAL": "on_normal",
+            "SQZPRO_ON_NARROW": "on_narrow",
+            "SQZPRO_OFF": "off",
+            "SQZPRO_NO": "none",
+        },
+    )

openbacktesting/indicators/momentum/stc.py

@@ -0,0 +1,20 @@
+"""ta.stc: Computation wrapper for the pinned dependency with canonical outputs."""
+
+from pandas_ta_classic.momentum.stc import stc as _calculate
+
+from ..common import named_frame
+
+
+def compute(*, close, tclength, fast, slow, factor, talib):
+    result = _calculate(
+        close=close, tclength=tclength, fast=fast, slow=slow, factor=factor, talib=talib
+    )
+    return named_frame(
+        result,
+        "ta.stc",
+        {
+            f"STC_{tclength}_{fast}_{slow}_{factor}": "stc",
+            f"STCmacd_{tclength}_{fast}_{slow}_{factor}": "macd",
+            f"STCstoch_{tclength}_{fast}_{slow}_{factor}": "stochastic",
+        },
+    )

openbacktesting/indicators/momentum/stoch.py

@@ -0,0 +1,19 @@
+"""ta.stoch: Computation wrapper for the pinned dependency with canonical outputs."""
+
+from pandas_ta_classic.momentum.stoch import stoch as _calculate
+
+from ..common import named_frame
+
+
+def compute(*, high, low, close, k, d, smooth_k, mamode, talib):
+    result = _calculate(
+        high=high, low=low, close=close, k=k, d=d, smooth_k=smooth_k, mamode=mamode, talib=talib
+    )
+    return named_frame(
+        result,
+        "ta.stoch",
+        {
+            f"STOCHk_{k}_{d}_{smooth_k}": "k",
+            f"STOCHd_{k}_{d}_{smooth_k}": "d",
+        },
+    )

openbacktesting/indicators/momentum/stochf.py

@@ -0,0 +1,19 @@
+"""ta.stochf: Computation wrapper for the pinned dependency with canonical outputs."""
+
+from pandas_ta_classic.momentum.stochf import stochf as _calculate
+
+from ..common import named_frame
+
+
+def compute(*, high, low, close, fastk, fastd, mamode, talib):
+    result = _calculate(
+        high=high, low=low, close=close, fastk=fastk, fastd=fastd, mamode=mamode, talib=talib
+    )
+    return named_frame(
+        result,
+        "ta.stochf",
+        {
+            f"STOCHFk_{fastk}_{fastd}": "k",
+            f"STOCHFd_{fastk}_{fastd}": "d",
+        },
+    )

openbacktesting/indicators/momentum/stochrsi.py

@@ -0,0 +1,19 @@
+"""ta.stochrsi: Computation wrapper for the pinned dependency with canonical outputs."""
+
+from pandas_ta_classic.momentum.stochrsi import stochrsi as _calculate
+
+from ..common import named_frame
+
+
+def compute(*, close, length, rsi_length, k, d, mamode, talib):
+    result = _calculate(
+        close=close, length=length, rsi_length=rsi_length, k=k, d=d, mamode=mamode, talib=talib
+    )
+    return named_frame(
+        result,
+        "ta.stochrsi",
+        {
+            f"STOCHRSIk_{length}_{rsi_length}_{k}_{d}": "k",
+            f"STOCHRSId_{length}_{rsi_length}_{k}_{d}": "d",
+        },
+    )

openbacktesting/indicators/momentum/td_seq.py

@@ -0,0 +1,17 @@
+"""ta.td_seq: Computation wrapper for the pinned dependency with canonical outputs."""
+
+from pandas_ta_classic.momentum.td_seq import td_seq as _calculate
+
+from ..common import named_frame
+
+
+def compute(*, close, asint, show_all, talib):
+    result = _calculate(close=close, asint=asint, show_all=show_all, talib=talib)
+    return named_frame(
+        result,
+        "ta.td_seq",
+        {
+            "TD_SEQ_UPa": "up",
+            "TD_SEQ_DNa": "down",
+        },
+    )

openbacktesting/indicators/momentum/trix.py

@@ -0,0 +1,19 @@
+"""ta.trix: Computation wrapper for the pinned dependency with canonical outputs."""
+
+from pandas_ta_classic.momentum.trix import trix as _calculate
+
+from ..common import named_frame
+
+
+def compute(*, close, length, signal, scalar, drift, talib):
+    result = _calculate(
+        close=close, length=length, signal=signal, scalar=scalar, drift=drift, talib=talib
+    )
+    return named_frame(
+        result,
+        "ta.trix",
+        {
+            f"TRIX_{length}_{signal}": "trix",
+            f"TRIXs_{length}_{signal}": "signal",
+        },
+    )

openbacktesting/indicators/momentum/trixh.py

@@ -0,0 +1,20 @@
+"""ta.trixh: Computation wrapper for the pinned dependency with canonical outputs."""
+
+from pandas_ta_classic.momentum.trixh import trixh as _calculate
+
+from ..common import named_frame
+
+
+def compute(*, close, length, signal, scalar, drift, talib):
+    result = _calculate(
+        close=close, length=length, signal=signal, scalar=scalar, drift=drift, talib=talib
+    )
+    return named_frame(
+        result,
+        "ta.trixh",
+        {
+            f"TRIX_{length}_{signal}": "trix",
+            f"TRIXs_{length}_{signal}": "signal",
+            f"TRIXh_{length}_{signal}": "histogram",
+        },
+    )

openbacktesting/indicators/momentum/tsi.py

@@ -0,0 +1,26 @@
+"""ta.tsi: Computation wrapper for the pinned dependency with canonical outputs."""
+
+from pandas_ta_classic.momentum.tsi import tsi as _calculate
+
+from ..common import named_frame
+
+
+def compute(*, close, fast, slow, signal, scalar, mamode, drift, talib):
+    result = _calculate(
+        close=close,
+        fast=fast,
+        slow=slow,
+        signal=signal,
+        scalar=scalar,
+        mamode=mamode,
+        drift=drift,
+        talib=talib,
+    )
+    return named_frame(
+        result,
+        "ta.tsi",
+        {
+            f"TSI_{fast}_{slow}_{signal}": "tsi",
+            f"TSIs_{fast}_{slow}_{signal}": "signal",
+        },
+    )

openbacktesting/indicators/momentum/uo.py

@@ -0,0 +1,22 @@
+"""ta.uo: Computation wrapper for the pinned dependency with canonical outputs."""
+
+from pandas_ta_classic.momentum.uo import uo as _calculate
+
+from ..common import named_series
+
+
+def compute(*, high, low, close, fast, medium, slow, fast_w, medium_w, slow_w, drift, talib):
+    result = _calculate(
+        high=high,
+        low=low,
+        close=close,
+        fast=fast,
+        medium=medium,
+        slow=slow,
+        fast_w=fast_w,
+        medium_w=medium_w,
+        slow_w=slow_w,
+        drift=drift,
+        talib=talib,
+    )
+    return named_series(result, "ta.uo", "uo")

openbacktesting/indicators/momentum/vwmacd.py

@@ -0,0 +1,20 @@
+"""ta.vwmacd: Computation wrapper for the pinned dependency with canonical outputs."""
+
+from pandas_ta_classic.momentum.vwmacd import vwmacd as _calculate
+
+from ..common import named_frame
+
+
+def compute(*, close, volume, fast, slow, signal, talib):
+    result = _calculate(
+        close=close, volume=volume, fast=fast, slow=slow, signal=signal, talib=talib
+    )
+    return named_frame(
+        result,
+        "ta.vwmacd",
+        {
+            f"VWMACD_{fast}_{slow}_{signal}": "macd",
+            f"VWMACDh_{fast}_{slow}_{signal}": "histogram",
+            f"VWMACDs_{fast}_{slow}_{signal}": "signal",
+        },
+    )

openbacktesting/indicators/momentum/wavetrend.py

@@ -0,0 +1,15 @@
+"""ta.wavetrend: Independent formula with a fixed initialization contract."""
+
+import pandas as pd
+
+from ..calculus import average as ema
+from ..calculus import clean, ratio
+
+
+def compute(*, high, low, close, length, average, signal):
+    price = (clean(high) + clean(low) + clean(close)) / 3
+    basis = ema(price, length, seeded=False)
+    deviation = ema((price - basis).abs(), length, seeded=False)
+    normalized = ratio(price - basis, 0.015 * deviation)
+    wave = ema(normalized, average, seeded=False)
+    return pd.DataFrame({"wave": wave, "signal": wave.rolling(signal).mean()})

openbacktesting/indicators/momentum/willr.py

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

openbacktesting/indicators/overlap/alligator.py

@@ -0,0 +1,13 @@
+"""ta.alligator: Independent formula with a fixed initialization contract."""
+
+import pandas as pd
+
+from ..calculus import average, clean
+
+
+def compute(*, high, low, jaw, teeth, lips):
+    middle = (clean(high) + clean(low)) / 2
+    j = average(middle, jaw, alpha=1 / jaw)
+    t = average(middle, teeth, alpha=1 / teeth)
+    l = average(middle, lips, alpha=1 / lips)
+    return pd.DataFrame({"jaw": j, "teeth": t, "lips": l})

openbacktesting/indicators/overlap/alma.py

@@ -0,0 +1,33 @@
+"""ta.alma: Computation wrapper for the pinned dependency with canonical outputs."""
+
+import numpy as np
+import pandas as pd
+from pandas_ta_classic.overlap.alma import alma as _calculate
+
+from ..common import named_series
+
+
+def compute(*, close, length, sigma, distribution_offset, talib, floor):
+    if floor:
+        center = np.floor(distribution_offset * (length - 1))
+        distance = np.arange(length, dtype=float) - center
+        # The center is an integer, ensuring at least one weight is exactly 1; other weights can safely underflow for extreme sigma.
+        with np.errstate(over="ignore", under="ignore"):
+            scaled = distance * (sigma / length)
+            weights = np.exp(-0.5 * scaled * scaled)
+        weights /= weights.sum()
+        output = np.full(len(close), np.nan)
+        if len(close) >= length:
+            windows = np.lib.stride_tricks.sliding_window_view(close.to_numpy(), length)
+            with np.errstate(invalid="ignore", over="ignore"):
+                values = windows @ weights[::-1]
+            output[length - 1 :] = np.where(np.isfinite(windows).all(axis=1), values, np.nan)
+        return pd.Series(output, index=close.index, name="alma")
+    result = _calculate(
+        close=close,
+        length=length,
+        sigma=sigma,
+        distribution_offset=distribution_offset,
+        talib=talib,
+    )
+    return named_series(result, "ta.alma", "alma")

openbacktesting/indicators/overlap/anchored_vwap.py

@@ -0,0 +1,50 @@
+"""Weighted accumulation with explicit condition anchors; no inference of sessions or higher timeframes."""
+
+from math import isfinite, sqrt
+
+import numpy as np
+import pandas as pd
+
+from ..calculus import condition
+from ..types import IndicatorError
+
+
+def _calculate(*, source, volume, anchor, indicator, stdev_mult):
+    reset = condition(anchor, indicator)
+    if reset.isna().any():
+        raise IndicatorError("invalid-input", indicator, "Anchors must not be missing")
+    if ((volume < 0) & np.isfinite(volume)).any():
+        raise IndicatorError("invalid-input", indicator, "Volume must not be negative")
+    values = np.full((len(source), 3), np.nan)
+    started = False
+    weight = mean = moment = 0.0
+    for i, (x, v, flag) in enumerate(zip(source, volume, reset)):
+        if flag == 1:
+            started = True
+            weight = mean = moment = 0.0
+        if not started or not (isfinite(x) and isfinite(v)):
+            continue
+        if v > 0:
+            total = weight + v
+            if weight == 0:
+                mean = x
+            else:
+                delta = x - mean
+                mean += delta * (v / total)
+                # Equivalent to weighted Welford central-moment increments; all factors are nonnegative, avoiding negative variance from cancellation.
+                moment += delta * delta * (weight / total) * v
+            weight = total
+        if weight == 0:
+            continue
+        spread = stdev_mult * sqrt(moment / weight)
+        row = mean, mean - spread, mean + spread
+        if not all(isfinite(value) for value in (*row, weight, moment)):
+            raise IndicatorError("calculation-failed", indicator, "VWAP accumulation or output overflow")
+        values[i] = row
+    return pd.DataFrame(values, index=source.index, columns=["vwap", "lower", "upper"])
+
+
+def compute(*, source, volume, anchor):
+    return _calculate(
+        source=source, volume=volume, anchor=anchor, indicator="ta.anchored_vwap", stdev_mult=0.0
+    )["vwap"]

openbacktesting/indicators/overlap/anchored_vwap_bands.py

@@ -0,0 +1,13 @@
+"""Volume-weighted population standard-deviation bands for conditional VWAP."""
+
+from .anchored_vwap import _calculate
+
+
+def compute(*, source, volume, anchor, stdev_mult):
+    return _calculate(
+        source=source,
+        volume=volume,
+        anchor=anchor,
+        indicator="ta.anchored_vwap_bands",
+        stdev_mult=stdev_mult,
+    )

openbacktesting/indicators/overlap/avgprice.py

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

openbacktesting/indicators/overlap/dema.py

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

openbacktesting/indicators/overlap/ema.py

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

openbacktesting/indicators/overlap/frama.py

@@ -0,0 +1,29 @@
+"""ta.frama: Independent formula with a fixed initialization contract."""
+
+import numpy as np
+import pandas as pd
+
+from ..calculus import clean
+
+
+def compute(*, high, low, close, length):
+    high, low, close = clean(high), clean(low), clean(close)
+    half = length // 2
+    small = (high.rolling(half).max() - low.rolling(half).min()) / half
+    full = (high.rolling(length).max() - low.rolling(length).min()) / length
+    combined = small + small.shift(half)
+    with np.errstate(divide="ignore", invalid="ignore"):
+        dimension = np.log(combined / full) / np.log(2)
+        alpha = np.exp(-4.6 * (dimension - 1)).clip(0.01, 1)
+    alpha = alpha.mask((combined == 0) & (full == 0), 1.0)
+    result = np.full(len(close), np.nan)
+    previous = np.nan
+    for i, (price, weight) in enumerate(zip(close, alpha)):
+        if not np.isfinite(price) or not np.isfinite(weight):
+            previous = np.nan
+        else:
+            previous = (
+                price if not np.isfinite(previous) else weight * price + (1 - weight) * previous
+            )
+            result[i] = previous
+    return pd.Series(result, index=close.index, name="frama")