openbacktesting 0.2.0__py3-none-any.whl

openbacktesting/indicators/momentum/ac.py

@@ -0,0 +1,9 @@
+"""ta.ac: Independent formula with a fixed initialization contract."""
+
+from ..calculus import clean
+
+
+def compute(*, high, low, fast, slow, signal):
+    middle = (clean(high) + clean(low)) / 2
+    ao = middle.rolling(fast).mean() - middle.rolling(slow).mean()
+    return (ao - ao.rolling(signal).mean()).rename("ac")

openbacktesting/indicators/momentum/ao.py

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

openbacktesting/indicators/momentum/apo.py

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

openbacktesting/indicators/momentum/bias.py

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

openbacktesting/indicators/momentum/bop.py

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

openbacktesting/indicators/momentum/brar.py

@@ -0,0 +1,26 @@
+"""ta.brar: Computation wrapper for the pinned dependency with canonical outputs."""
+
+from pandas_ta_classic.momentum.brar import brar as _calculate
+
+from ..common import named_frame
+
+
+def compute(*, open_, high, low, close, length, scalar, drift, talib):
+    result = _calculate(
+        open_=open_,
+        high=high,
+        low=low,
+        close=close,
+        length=length,
+        scalar=scalar,
+        drift=drift,
+        talib=talib,
+    )
+    return named_frame(
+        result,
+        "ta.brar",
+        {
+            f"AR_{length}": "ar",
+            f"BR_{length}": "br",
+        },
+    )

openbacktesting/indicators/momentum/cci.py

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

openbacktesting/indicators/momentum/cfo.py

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

openbacktesting/indicators/momentum/cg.py

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

openbacktesting/indicators/momentum/cmo.py

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

openbacktesting/indicators/momentum/coppock.py

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

openbacktesting/indicators/momentum/crsi.py

@@ -0,0 +1,28 @@
+"""ta.crsi: Independent formula with a fixed initialization contract."""
+
+import numpy as np
+import pandas as pd
+
+from ..calculus import clean, strength
+
+
+def compute(*, close, length, streak, rank):
+    close = clean(close)
+    delta = close.diff()
+    streaks = np.full(len(close), np.nan)
+    previous = 0.0
+    for i, value in enumerate(delta):
+        if not np.isfinite(value):
+            previous = 0.0
+        elif value == 0:
+            previous = 0.0
+            streaks[i] = previous
+        else:
+            sign = np.sign(value)
+            previous = previous + sign if previous * sign > 0 else sign
+            streaks[i] = previous
+    streak_series = pd.Series(streaks, index=close.index)
+    roc = (close / close.shift(1) - 1).where(close.shift(1) > 0)
+    percentile = (roc.rolling(rank + 1).rank(method="min") - 1) * 100 / rank
+    result = (strength(delta, length) + strength(streak_series.diff(), streak) + percentile) / 3
+    return result.rename("crsi")

openbacktesting/indicators/momentum/cti.py

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

openbacktesting/indicators/momentum/dm.py

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

openbacktesting/indicators/momentum/er.py

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

openbacktesting/indicators/momentum/eri.py

@@ -0,0 +1,17 @@
+"""ta.eri: Computation wrapper for the pinned dependency with canonical outputs."""
+
+from pandas_ta_classic.momentum.eri import eri 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.eri",
+        {
+            f"BULLP_{length}": "bull_power",
+            f"BEARP_{length}": "bear_power",
+        },
+    )

openbacktesting/indicators/momentum/fisher.py

@@ -0,0 +1,17 @@
+"""ta.fisher: Computation wrapper for the pinned dependency with canonical outputs."""
+
+from pandas_ta_classic.momentum.fisher import fisher as _calculate
+
+from ..common import named_frame
+
+
+def compute(*, high, low, length, signal, talib):
+    result = _calculate(high=high, low=low, length=length, signal=signal, talib=talib)
+    return named_frame(
+        result,
+        "ta.fisher",
+        {
+            f"FISHERT_{length}_{signal}": "fisher",
+            f"FISHERTs_{length}_{signal}": "signal",
+        },
+    )

openbacktesting/indicators/momentum/fosc.py

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

openbacktesting/indicators/momentum/gator.py

@@ -0,0 +1,13 @@
+"""ta.gator: 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({"upper": (j - t).abs(), "lower": -(t - l).abs()})

openbacktesting/indicators/momentum/ibs.py

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

openbacktesting/indicators/momentum/inertia.py

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

openbacktesting/indicators/momentum/kdj.py

@@ -0,0 +1,18 @@
+"""ta.kdj: Computation wrapper for the pinned dependency with canonical outputs."""
+
+from pandas_ta_classic.momentum.kdj import kdj as _calculate
+
+from ..common import named_frame
+
+
+def compute(*, high, low, close, length, signal, talib):
+    result = _calculate(high=high, low=low, close=close, length=length, signal=signal, talib=talib)
+    return named_frame(
+        result,
+        "ta.kdj",
+        {
+            f"K_{length}_{signal}": "k",
+            f"D_{length}_{signal}": "d",
+            f"J_{length}_{signal}": "j",
+        },
+    )

openbacktesting/indicators/momentum/kst.py

@@ -0,0 +1,30 @@
+"""ta.kst: Computation wrapper for the pinned dependency with canonical outputs."""
+
+from pandas_ta_classic.momentum.kst import kst as _calculate
+
+from ..common import named_frame
+
+
+def compute(*, close, roc1, roc2, roc3, roc4, sma1, sma2, sma3, sma4, signal, drift, talib):
+    result = _calculate(
+        close=close,
+        roc1=roc1,
+        roc2=roc2,
+        roc3=roc3,
+        roc4=roc4,
+        sma1=sma1,
+        sma2=sma2,
+        sma3=sma3,
+        sma4=sma4,
+        signal=signal,
+        drift=drift,
+        talib=talib,
+    )
+    return named_frame(
+        result,
+        "ta.kst",
+        {
+            f"KST_{roc1}_{roc2}_{roc3}_{roc4}_{sma1}_{sma2}_{sma3}_{sma4}": "kst",
+            f"KSTs_{signal}": "signal",
+        },
+    )

openbacktesting/indicators/momentum/lrsi.py

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

openbacktesting/indicators/momentum/macd.py

@@ -0,0 +1,27 @@
+"""ta.macd: Computation wrapper for the pinned dependency with canonical outputs."""
+
+from pandas_ta_classic.momentum.macd import macd as _calculate
+
+from ..common import named_frame
+
+
+def compute(*, close, fast, slow, signal, offset, asmode, signal_indicators, talib):
+    result = _calculate(
+        close=close,
+        fast=fast,
+        slow=slow,
+        signal=signal,
+        offset=offset,
+        asmode=asmode,
+        signal_indicators=signal_indicators,
+        talib=talib,
+    )
+    return named_frame(
+        result,
+        "ta.macd",
+        {
+            f"MACD_{fast}_{slow}_{signal}": "macd",
+            f"MACDh_{fast}_{slow}_{signal}": "histogram",
+            f"MACDs_{fast}_{slow}_{signal}": "signal",
+        },
+    )

openbacktesting/indicators/momentum/macdext.py

@@ -0,0 +1,27 @@
+"""ta.macdext: Computation wrapper for the pinned dependency with canonical outputs."""
+
+from pandas_ta_classic.momentum.macdext import macdext as _calculate
+
+from ..common import named_frame
+
+
+def compute(*, close, fast, slow, signal, fastmatype, slowmatype, signalmatype, talib):
+    result = _calculate(
+        close=close,
+        fast=fast,
+        slow=slow,
+        signal=signal,
+        fastmatype=fastmatype,
+        slowmatype=slowmatype,
+        signalmatype=signalmatype,
+        talib=talib,
+    )
+    return named_frame(
+        result,
+        "ta.macdext",
+        {
+            f"MACDEXT_{fast}_{slow}_{signal}": "macd",
+            f"MACDEXTs_{fast}_{slow}_{signal}": "signal",
+            f"MACDEXTh_{fast}_{slow}_{signal}": "histogram",
+        },
+    )

openbacktesting/indicators/momentum/macdfix.py

@@ -0,0 +1,18 @@
+"""ta.macdfix: Computation wrapper for the pinned dependency with canonical outputs."""
+
+from pandas_ta_classic.momentum.macdfix import macdfix as _calculate
+
+from ..common import named_frame
+
+
+def compute(*, close, signal, talib):
+    result = _calculate(close=close, signal=signal, talib=talib)
+    return named_frame(
+        result,
+        "ta.macdfix",
+        {
+            f"MACDFIX_{signal}_{signal}": "macd",
+            f"MACDFIXh_{signal}_{signal}": "histogram",
+            f"MACDFIXs_{signal}_{signal}": "signal",
+        },
+    )

openbacktesting/indicators/momentum/mom.py

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

openbacktesting/indicators/momentum/pgo.py

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

openbacktesting/indicators/momentum/pmo.py

@@ -0,0 +1,13 @@
+"""ta.pmo: Independent formula with a fixed initialization contract."""
+
+import pandas as pd
+
+from ..calculus import average, clean, ratio
+
+
+def compute(*, close, length, smooth, signal):
+    close = clean(close)
+    roc = 100 * (ratio(close, close.shift(1)) - 1)
+    first = average(roc, length, alpha=2 / length)
+    pmo = average(first * 10, smooth, alpha=2 / smooth)
+    return pd.DataFrame({"pmo": pmo, "signal": average(pmo, signal)})

openbacktesting/indicators/momentum/po.py

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

openbacktesting/indicators/momentum/ppo.py

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

openbacktesting/indicators/momentum/psl.py

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

openbacktesting/indicators/momentum/pvo.py

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

openbacktesting/indicators/momentum/qqe.py

@@ -0,0 +1,31 @@
+"""ta.qqe: Computation wrapper for the pinned dependency with canonical outputs."""
+
+from pandas_ta_classic.momentum.qqe import qqe as _calculate
+
+from ..common import named_frame
+
+
+def compute(*, close, length, smooth, factor, mamode, drift, talib):
+    result = _calculate(
+        close=close,
+        length=length,
+        smooth=smooth,
+        factor=factor,
+        mamode=mamode,
+        drift=drift,
+        talib=talib,
+    )
+    mode = mamode[0] if mamode != "ema" else ""
+    return named_frame(
+        result,
+        "ta.qqe",
+        {
+            f"QQE{mode}_{length}_{smooth}_{factor}": "qqe",
+            f"QQE{mode}_{length}_{smooth}_{factor}_RSI{mode.upper()}MA": "smoothed_rsi",
+            f"QQEl{mode}_{length}_{smooth}_{factor}": "long",
+            f"QQEs{mode}_{length}_{smooth}_{factor}": "short",
+            f"QQEb_l{mode}_{length}_{smooth}_{factor}": "basis_long",
+            f"QQEb_s{mode}_{length}_{smooth}_{factor}": "basis_short",
+            f"QQEd{mode}_{length}_{smooth}_{factor}": "direction",
+        },
+    )

openbacktesting/indicators/momentum/rci.py

@@ -0,0 +1,20 @@
+"""ta.rci: Independent formula with a fixed initialization contract."""
+
+import numpy as np
+
+from ..calculus import clean
+
+
+def compute(*, close, length):
+    time = np.arange(length, dtype=float)
+    time -= time.mean()
+    time_norm = np.dot(time, time)
+
+    def correlation(values):
+        _, inverse, counts = np.unique(values, return_inverse=True, return_counts=True)
+        ranks = (np.cumsum(counts) - (counts - 1) / 2)[inverse]
+        ranks -= ranks.mean()
+        norm = np.dot(ranks, ranks)
+        return 100 * np.dot(time, ranks) / np.sqrt(time_norm * norm) if norm else np.nan
+
+    return clean(close).rolling(length).apply(correlation, raw=True).rename("rci")

openbacktesting/indicators/momentum/rmi.py

@@ -0,0 +1,7 @@
+"""ta.rmi: Independent formula with a fixed initialization contract."""
+
+from ..calculus import clean, strength
+
+
+def compute(*, close, length, momentum):
+    return strength(clean(close).diff(momentum), length).rename("rmi")

openbacktesting/indicators/momentum/roc.py

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

openbacktesting/indicators/momentum/rocp.py

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

openbacktesting/indicators/momentum/rocr.py

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