openbacktesting 0.2.0__py3-none-any.whl

openbacktesting/indicators/overlap/fwma.py

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

openbacktesting/indicators/overlap/hilo.py

@@ -0,0 +1,26 @@
+"""ta.hilo: Computation wrapper for the pinned dependency with canonical outputs."""
+
+from pandas_ta_classic.overlap.hilo import hilo as _calculate
+
+from ..common import named_frame
+
+
+def compute(*, high, low, close, high_length, low_length, mamode, talib):
+    result = _calculate(
+        high=high,
+        low=low,
+        close=close,
+        high_length=high_length,
+        low_length=low_length,
+        mamode=mamode,
+        talib=talib,
+    )
+    return named_frame(
+        result,
+        "ta.hilo",
+        {
+            f"HILO_{high_length}_{low_length}": "hilo",
+            f"HILOl_{high_length}_{low_length}": "long",
+            f"HILOs_{high_length}_{low_length}": "short",
+        },
+    )

openbacktesting/indicators/overlap/hl2.py

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

openbacktesting/indicators/overlap/hlc3.py

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

openbacktesting/indicators/overlap/hma.py

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

openbacktesting/indicators/overlap/ht_trendline.py

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

openbacktesting/indicators/overlap/hwma.py

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

openbacktesting/indicators/overlap/ichimoku.py

@@ -0,0 +1,44 @@
+"""ta.ichimoku: Computation wrapper for the pinned dependency with canonical outputs."""
+
+from pandas_ta_classic.overlap.ichimoku import ichimoku as _calculate
+
+from ..common import named_frame
+
+
+def compute(
+    *,
+    high,
+    low,
+    close,
+    tenkan,
+    kijun,
+    senkou,
+    include_chikou,
+    lookahead,
+    as_dataframe,
+    append_span,
+    talib,
+):
+    result = _calculate(
+        high=high,
+        low=low,
+        close=close,
+        tenkan=tenkan,
+        kijun=kijun,
+        senkou=senkou,
+        include_chikou=include_chikou,
+        lookahead=lookahead,
+        as_dataframe=as_dataframe,
+        append_span=append_span,
+        talib=talib,
+    )
+    return named_frame(
+        result,
+        "ta.ichimoku",
+        {
+            f"ISA_{tenkan}": "span_a",
+            f"ISB_{kijun}": "span_b",
+            f"ITS_{tenkan}": "tenkan",
+            f"IKS_{kijun}": "kijun",
+        },
+    )

openbacktesting/indicators/overlap/jma.py

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

openbacktesting/indicators/overlap/kama.py

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

openbacktesting/indicators/overlap/linreg.py

@@ -0,0 +1,15 @@
+"""ta.linreg: Computation wrapper for the pinned dependency with canonical outputs."""
+
+import numpy as np
+from pandas_ta_classic.overlap.linreg import linreg as _calculate
+
+from ..common import named_series
+
+
+def compute(*, close, length, talib, offset):
+    result = _calculate(close=close, length=length, talib=talib)
+    if offset and result is not None:
+        slope = _calculate(close=close, length=length, talib=talib, slope=True)
+        with np.errstate(over="ignore", invalid="ignore"):
+            result = result - slope * float(offset)
+    return named_series(result, "ta.linreg", "linreg")

openbacktesting/indicators/overlap/linregangle.py

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

openbacktesting/indicators/overlap/linregintercept.py

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

openbacktesting/indicators/overlap/linregslope.py

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

openbacktesting/indicators/overlap/ma.py

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

openbacktesting/indicators/overlap/ma_envelopes.py

@@ -0,0 +1,16 @@
+"""ta.ma_envelopes: Independent formula with a fixed initialization contract."""
+
+import pandas as pd
+
+from ..calculus import average, clean
+
+
+def compute(*, close, length, percent, mamode):
+    middle = clean(close).rolling(length).mean() if mamode == "sma" else average(close, length)
+    return pd.DataFrame(
+        {
+            "middle": middle,
+            "upper": middle * (1 + percent / 100),
+            "lower": middle * (1 - percent / 100),
+        }
+    )

openbacktesting/indicators/overlap/mama.py

@@ -0,0 +1,17 @@
+"""ta.mama: Computation wrapper for the pinned dependency with canonical outputs."""
+
+from pandas_ta_classic.overlap.mama import mama as _calculate
+
+from ..common import named_frame
+
+
+def compute(*, close, fastlimit, slowlimit, talib):
+    result = _calculate(close=close, fastlimit=fastlimit, slowlimit=slowlimit, talib=talib)
+    return named_frame(
+        result,
+        "ta.mama",
+        {
+            f"MAMA_{fastlimit}_{slowlimit}": "mama",
+            f"FAMA_{fastlimit}_{slowlimit}": "fama",
+        },
+    )

openbacktesting/indicators/overlap/mavp.py

@@ -0,0 +1,17 @@
+"""ta.mavp: Computation wrapper for the pinned dependency with canonical outputs."""
+
+from pandas_ta_classic.overlap.mavp import mavp as _calculate
+
+from ..common import named_series
+
+
+def compute(*, close, periods, minperiod, maxperiod, mamode, talib):
+    result = _calculate(
+        close=close,
+        periods=periods,
+        minperiod=minperiod,
+        maxperiod=maxperiod,
+        mamode=mamode,
+        talib=talib,
+    )
+    return named_series(result, "ta.mavp", "mavp")

openbacktesting/indicators/overlap/mcgd.py

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

openbacktesting/indicators/overlap/medprice.py

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

openbacktesting/indicators/overlap/midpoint.py

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

openbacktesting/indicators/overlap/midprice.py

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

openbacktesting/indicators/overlap/mmar.py

@@ -0,0 +1,21 @@
+"""ta.mmar: Computation wrapper for the pinned dependency with canonical outputs."""
+
+from pandas_ta_classic.overlap.mmar import mmar as _calculate
+
+from ..common import named_frame
+
+
+def compute(*, close, length, talib):
+    result = _calculate(close=close, length=length, talib=talib)
+    return named_frame(
+        result,
+        "ta.mmar",
+        {
+            f"MMAR_{length}": "ma1",
+            f"MMAR_{length + 5}": "ma2",
+            f"MMAR_{length + 10}": "ma3",
+            f"MMAR_{length + 15}": "ma4",
+            f"MMAR_{length + 20}": "ma5",
+            f"MMAR_{length + 25}": "ma6",
+        },
+    )

openbacktesting/indicators/overlap/ohlc4.py

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

openbacktesting/indicators/overlap/pwma.py

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

openbacktesting/indicators/overlap/rainbow.py

@@ -0,0 +1,25 @@
+"""ta.rainbow: Computation wrapper for the pinned dependency with canonical outputs."""
+
+from pandas_ta_classic.overlap.rainbow import rainbow as _calculate
+
+from ..common import named_frame
+
+
+def compute(*, close, length, talib):
+    result = _calculate(close=close, length=length, talib=talib)
+    return named_frame(
+        result,
+        "ta.rainbow",
+        {
+            "RAINBOW_1": "ma1",
+            "RAINBOW_2": "ma2",
+            "RAINBOW_3": "ma3",
+            "RAINBOW_4": "ma4",
+            "RAINBOW_5": "ma5",
+            "RAINBOW_6": "ma6",
+            "RAINBOW_7": "ma7",
+            "RAINBOW_8": "ma8",
+            "RAINBOW_9": "ma9",
+            "RAINBOW_10": "ma10",
+        },
+    )

openbacktesting/indicators/overlap/rma.py

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

openbacktesting/indicators/overlap/sinwma.py

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

openbacktesting/indicators/overlap/sma.py

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

openbacktesting/indicators/overlap/ssf.py

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

openbacktesting/indicators/overlap/supertrend.py

@@ -0,0 +1,21 @@
+"""ta.supertrend: Computation wrapper for the pinned dependency with canonical outputs."""
+
+from pandas_ta_classic.overlap.supertrend import supertrend as _calculate
+
+from ..common import named_frame
+
+
+def compute(*, high, low, close, length, multiplier, talib):
+    result = _calculate(
+        high=high, low=low, close=close, length=length, multiplier=multiplier, talib=talib
+    )
+    return named_frame(
+        result,
+        "ta.supertrend",
+        {
+            f"SUPERT_{length}_{multiplier}": "trend",
+            f"SUPERTd_{length}_{multiplier}": "direction",
+            f"SUPERTl_{length}_{multiplier}": "long",
+            f"SUPERTs_{length}_{multiplier}": "short",
+        },
+    )

openbacktesting/indicators/overlap/swma.py

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

openbacktesting/indicators/overlap/t3.py

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

openbacktesting/indicators/overlap/tema.py

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

openbacktesting/indicators/overlap/trima.py

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

openbacktesting/indicators/overlap/tsf.py

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

openbacktesting/indicators/overlap/typprice.py

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

openbacktesting/indicators/overlap/vidya.py

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

openbacktesting/indicators/overlap/vwap.py

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

openbacktesting/indicators/overlap/vwma.py

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

openbacktesting/indicators/overlap/wcp.py

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

openbacktesting/indicators/overlap/wma.py

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

openbacktesting/indicators/overlap/zlma.py

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

openbacktesting/indicators/performance/drawdown.py

@@ -0,0 +1,18 @@
+"""ta.drawdown: Computation wrapper for the pinned dependency with canonical outputs."""
+
+from pandas_ta_classic.performance.drawdown import drawdown as _calculate
+
+from ..common import named_frame
+
+
+def compute(*, close, talib):
+    result = _calculate(close=close, talib=talib)
+    return named_frame(
+        result,
+        "ta.drawdown",
+        {
+            "DD": "absolute",
+            "DD_PCT": "percent",
+            "DD_LOG": "logarithmic",
+        },
+    )