back-trader-python 1.4.0__py3-none-any.whl

backtrader/indicators/contrib/fisher_org_v1_sign.py

@@ -0,0 +1,118 @@
+#!/usr/bin/env python
+"""Functional-test indicators migrated to contrib.
+
+Generated from a single functional strategy module to preserve file-local
+helper functions and constants without cross-test name collisions.
+"""
+
+import math
+
+from .. import (
+    ATR,
+    Indicator,
+)
+
+__all__ = [
+    "FisherOrgV1Sign",
+]
+
+
+def _price(data, mode, ago=0):
+    """Return a price value from OHLC data based on a mode selector.
+
+    Parameters
+    ----------
+    data : DataFeed
+        Data feed with open/high/low/close lines.
+    mode : int
+        Price mode: 2=open, 3=high, 4=low, 5=(h+l)/2, 6=(h+l+c)/3,
+        7=(2c+h+l)/4, 8=(o+c)/2, 9=(o+h+l+c)/4; default returns close.
+    ago : int
+        Bar offset.
+
+    Returns
+    -------
+    float
+        Selected price value.
+    """
+    o = float(data.open[-ago])
+    h = float(data.high[-ago])
+    low_price = float(data.low[-ago])
+    c = float(data.close[-ago])
+    if mode == 2:
+        return o
+    if mode == 3:
+        return h
+    if mode == 4:
+        return low_price
+    if mode == 5:
+        return (h + low_price) / 2.0
+    if mode == 6:
+        return (h + low_price + c) / 3.0
+    if mode == 7:
+        return (2.0 * c + h + low_price) / 4.0
+    if mode == 8:
+        return (o + c) / 2.0
+    if mode == 9:
+        return (o + h + low_price + c) / 4.0
+    return c
+
+
+class FisherOrgV1Sign(Indicator):
+    """Fisher Transform Org V1 Sign indicator.
+
+    Normalises price within a highest-high/lowest-low window over `length`
+    bars, smooths the normalised position via recursive formula, then applies
+    the Fisher Transform (atanh) to produce a near-Gaussian signal. Buy/sell
+    trigger lines are set at ATR-scaled price levels on threshold crossovers.
+
+    Lines
+    -----
+    sell : float
+        Price level for sell signals (high + 3/8 ATR), set on up-cross.
+    buy : float
+        Price level for buy signals (low - 3/8 ATR), set on down-cross.
+    """
+
+    lines = ("sell", "buy")
+    params = (
+        ("atr_period", 14),
+        ("length", 7),
+        ("ipc", 1),
+        ("up_level", 1.5),
+        ("dn_level", -1.5),
+    )
+
+    def __init__(self):
+        """Initialise indicator state: ATR sub-indicator and Fisher smoothing values."""
+        self.addminperiod(max(int(self.p.atr_period), int(self.p.length)) + 3)
+        self.atr = ATR(self.data, period=int(self.p.atr_period))
+        self._value1 = 0.0
+        self._fish1 = 0.0
+
+    def next(self):
+        """Compute Fisher Transform values and set buy/sell signal lines."""
+        length = int(self.p.length)
+        highs = [float(self.data.high[-i]) for i in range(length)]
+        lows = [float(self.data.low[-i]) for i in range(length)]
+        smax = max(highs)
+        smin = min(lows)
+        if smax == smin:
+            smax += 1e-12
+        price = _price(self.data, int(self.p.ipc), 0)
+        wpr = (price - smin) / (smax - smin)
+        value0 = (wpr - 0.5) + 0.67 * self._value1
+        value0 = min(max(value0, -0.999), 0.999)
+        res2 = (1.0 + value0) / (1.0 - value0)
+        if res2 < 1e-7:
+            res2 = 1.0
+        fish0 = 0.5 * math.log(res2) + 0.5 * self._fish1
+        self.lines.buy[0] = float("nan")
+        self.lines.sell[0] = float("nan")
+        atr = float(self.atr[0])
+        if fish0 > float(self.p.dn_level) and self._fish1 <= float(self.p.dn_level):
+            self.lines.buy[0] = float(self.data.low[0]) - atr * 3.0 / 8.0
+        if fish0 < float(self.p.up_level) and self._fish1 >= float(self.p.up_level):
+            self.lines.sell[0] = float(self.data.high[0]) + atr * 3.0 / 8.0
+        self._value1 = value0
+        self._fish1 = fish0

backtrader/indicators/contrib/force_index_ema.py

@@ -0,0 +1,96 @@
+#!/usr/bin/env python
+"""Functional-test indicators migrated to contrib.
+
+Generated from a single functional strategy module to preserve file-local
+helper functions and constants without cross-test name collisions.
+"""
+
+import math
+
+from .. import (
+    ATR,
+    EMA,
+    Indicator,
+)
+
+__all__ = [
+    "ForceIndexEMA",
+    "ForceDiverSign",
+]
+
+
+class ForceIndexEMA(Indicator):
+    """Indicator producing a smoothed force index."""
+
+    lines = ("value",)
+    params = (("period", 3),)
+
+    def __init__(self):
+        """Compute raw force index then smooth with an EMA."""
+        raw = (self.data.close - self.data.close(-1)) * self.data.volume
+        self.l.value = EMA(raw, period=max(int(self.p.period), 1))
+
+
+class ForceDiverSign(Indicator):
+    """Divergence signal detector built from two force-index EMAs."""
+
+    lines = ("sell", "buy")
+    params = (
+        ("i_period1", 3),
+        ("i_period2", 7),
+    )
+
+    def __init__(self):
+        """Initialize ATR filter and dual force-index streams."""
+        self.atr = ATR(self.data, period=10)
+        self.ind1 = ForceIndexEMA(self.data, period=int(self.p.i_period1)).value
+        self.ind2 = ForceIndexEMA(self.data, period=int(self.p.i_period2)).value
+        self.addminperiod(max(int(self.p.i_period1), int(self.p.i_period2)) * 2 + 10)
+
+    def next(self):
+        """Evaluate candle patterns and divergence confirmation each bar."""
+        self.l.sell[0] = float("nan")
+        self.l.buy[0] = float("nan")
+        if len(self.data) < 6:
+            return
+
+        sell_candle = (
+            float(self.data.open[-3]) < float(self.data.close[-3])
+            and float(self.data.open[-2]) > float(self.data.close[-2])
+            and float(self.data.open[-1]) < float(self.data.close[-1])
+        )
+        buy_candle = (
+            float(self.data.open[-3]) > float(self.data.close[-3])
+            and float(self.data.open[-2]) < float(self.data.close[-2])
+            and float(self.data.open[-1]) > float(self.data.close[-1])
+        )
+
+        ind1 = [
+            float(self.ind1[-4]),
+            float(self.ind1[-3]),
+            float(self.ind1[-2]),
+            float(self.ind1[-1]),
+        ]
+        ind2 = [
+            float(self.ind2[-4]),
+            float(self.ind2[-3]),
+            float(self.ind2[-2]),
+            float(self.ind2[-1]),
+        ]
+        atr = float(self.atr[0]) if not math.isnan(float(self.atr[0])) else 0.0
+
+        if sell_candle:
+            if ind1[0] < ind1[1] and ind1[1] > ind1[2] and ind1[2] < ind1[3]:
+                if ind2[0] < ind2[1] and ind2[1] > ind2[2] and ind2[2] < ind2[3]:
+                    if (ind1[1] > ind1[3] and ind2[1] < ind2[3]) or (
+                        ind1[1] < ind1[3] and ind2[1] > ind2[3]
+                    ):
+                        self.l.sell[0] = float(self.data.high[0]) + atr * 3.0 / 8.0
+
+        if buy_candle:
+            if ind1[0] > ind1[1] and ind1[1] < ind1[2] and ind1[2] > ind1[3]:
+                if ind2[0] > ind2[1] and ind2[1] < ind2[2] and ind2[2] > ind2[3]:
+                    if (ind1[1] > ind1[3] and ind2[1] < ind2[3]) or (
+                        ind1[1] < ind1[3] and ind2[1] > ind2[3]
+                    ):
+                        self.l.buy[0] = float(self.data.low[0]) - atr * 3.0 / 8.0

backtrader/indicators/contrib/force_index_ema_2.py

@@ -0,0 +1,27 @@
+#!/usr/bin/env python
+"""Functional-test indicators migrated to contrib.
+
+Generated from a single functional strategy module to preserve file-local
+helper functions and constants without cross-test name collisions.
+"""
+
+from .. import (
+    ExponentialMovingAverage,
+    Indicator,
+)
+
+__all__ = [
+    "ForceIndexEma",
+]
+
+
+class ForceIndexEma(Indicator):
+    """Force Index (price change times volume) smoothed by an EMA."""
+
+    lines = ("value",)
+    params = (("period", 24),)
+
+    def __init__(self):
+        """Build the raw Force Index and apply the EMA smoothing of length ``period``."""
+        raw = (self.data.close - self.data.close(-1)) * self.data.volume
+        self.lines.value = ExponentialMovingAverage(raw, period=self.p.period)

backtrader/indicators/contrib/forecast_oscilator.py

@@ -0,0 +1,145 @@
+#!/usr/bin/env python
+"""Functional-test indicators migrated to contrib.
+
+Generated from a single functional strategy module to preserve file-local
+helper functions and constants without cross-test name collisions.
+"""
+
+from .. import Indicator
+
+__all__ = [
+    "ForecastOscilator",
+]
+
+
+def _price_value(data, shift, mode):
+    key = str(mode).lower()
+    open_ = float(data.open[-shift]) if shift else float(data.open[0])
+    high = float(data.high[-shift]) if shift else float(data.high[0])
+    low = float(data.low[-shift]) if shift else float(data.low[0])
+    close = float(data.close[-shift]) if shift else float(data.close[0])
+    if key in ("close", "1", "price_close"):
+        return close
+    if key in ("open", "2", "price_open"):
+        return open_
+    if key in ("high", "3", "price_high"):
+        return high
+    if key in ("low", "4", "price_low"):
+        return low
+    if key in ("median", "5", "price_median"):
+        return (high + low) / 2.0
+    if key in ("typical", "6", "price_typical"):
+        return (high + low + close) / 3.0
+    if key in ("weighted", "7", "price_weighted"):
+        return (high + low + close + close) / 4.0
+    if key in ("simple", "8", "price_simpl"):
+        return (open_ + close) / 2.0
+    if key in ("quarter", "9", "price_quarter"):
+        return (high + low + open_ + close) / 4.0
+    if key in ("trendfollow0", "10", "price_trendfollow0"):
+        if close > open_:
+            return high
+        if close < open_:
+            return low
+        return close
+    if key in ("trendfollow1", "11", "price_trendfollow1"):
+        if close > open_:
+            return (high + close) / 2.0
+        if close < open_:
+            return (low + close) / 2.0
+        return close
+    return close
+
+
+class ForecastOscilator(Indicator):
+    """Forecast Oscillator with T3-smoothed signal and arrow lines.
+
+    Computes the percentage deviation of price from a linear-regression
+    forecast (the raw ``ind`` line), smooths it with a six-stage T3 moving
+    average into the ``signal`` line, and emits ``buy``/``sell`` arrow values
+    when the oscillator crosses its signal under the configured sign
+    conditions.
+    """
+
+    lines = ("ind", "signal", "buy", "sell")
+    params = (
+        ("length", 15),
+        ("t3", 3),
+        ("b", 0.7),
+        ("ipc", "close"),
+    )
+
+    def __init__(self):
+        """Reserve the warm-up window and initialise T3 smoothing state."""
+        self.addminperiod(int(self.p.length) + 5)
+        self._e1 = 0.0
+        self._e2 = 0.0
+        self._e3 = 0.0
+        self._e4 = 0.0
+        self._e5 = 0.0
+        self._e6 = 0.0
+        self._initialized = False
+
+    def next(self):
+        """Compute the oscillator, T3 signal and arrow lines for this bar."""
+        length = max(int(self.p.length), 1)
+        t3 = max(int(self.p.t3), 1)
+        b = float(self.p.b)
+        b2 = b * b
+        b3 = b2 * b
+        c1 = -b3
+        c2 = 3 * (b2 + b3)
+        c3 = -3 * (2 * b2 + b + b3)
+        c4 = 1 + 3 * b + b3 + 3 * b2
+        n = max(1 + 0.5 * (t3 - 1), 1.0)
+        w1 = 2.0 / (n + 1.0)
+        w2 = 1.0 - w1
+        kx = 6.0 / (length * (length + 1.0))
+        br = (length + 1.0) / 3.0
+
+        if len(self.data) <= length + 2:
+            price = _price_value(self.data, 0, self.p.ipc)
+            self.l.ind[0] = 0.0
+            self.l.signal[0] = 0.0
+            self.l.buy[0] = float("nan")
+            self.l.sell[0] = float("nan")
+            if not self._initialized:
+                self._e1 = self._e2 = self._e3 = self._e4 = self._e5 = self._e6 = price
+                self._initialized = True
+            return
+
+        weighted_sum = 0.0
+        for i in range(length, 0, -1):
+            tmp = i - br
+            weighted_sum += tmp * _price_value(self.data, length - i, self.p.ipc)
+        wt = weighted_sum * kx
+        price_now = _price_value(self.data, 0, self.p.ipc)
+        forecastosc = ((price_now - wt) / wt * 100.0) if wt else 0.0
+
+        if not self._initialized:
+            self._e1 = self._e2 = self._e3 = self._e4 = self._e5 = self._e6 = forecastosc
+            self._initialized = True
+
+        self._e1 = w1 * forecastosc + w2 * self._e1
+        self._e2 = w1 * self._e1 + w2 * self._e2
+        self._e3 = w1 * self._e2 + w2 * self._e3
+        self._e4 = w1 * self._e3 + w2 * self._e4
+        self._e5 = w1 * self._e4 + w2 * self._e5
+        self._e6 = w1 * self._e5 + w2 * self._e6
+        t3_fosc = c1 * self._e6 + c2 * self._e5 + c3 * self._e4 + c4 * self._e3
+
+        self.l.ind[0] = forecastosc
+        self.l.signal[0] = t3_fosc
+        self.l.buy[0] = float("nan")
+        self.l.sell[0] = float("nan")
+
+        if len(self.data) >= length + 4:
+            ind_prev1 = float(self.l.ind[-1])
+            ind_prev2 = float(self.l.ind[-2])
+            sig_prev1 = float(self.l.signal[-1])
+            sig_prev2 = float(self.l.signal[-2])
+            sig_prev3 = float(self.l.signal[-3])
+            if ind_prev1 > sig_prev2 and ind_prev2 <= sig_prev3 and sig_prev1 < 0:
+                self.l.buy[0] = t3_fosc - 0.05
+            if ind_prev1 < sig_prev2 and ind_prev2 >= sig_prev3 and sig_prev1 > 0:
+                self.l.sell[0] = t3_fosc + 0.05

backtrader/indicators/contrib/fractal_amambk.py

@@ -0,0 +1,81 @@
+#!/usr/bin/env python
+"""Functional-test indicators migrated to contrib.
+
+Generated from a single functional strategy module to preserve file-local
+helper functions and constants without cross-test name collisions.
+"""
+
+import math
+
+from .. import Indicator
+
+__all__ = [
+    "FractalAMAMBK",
+]
+
+
+class FractalAMAMBK(Indicator):
+    """FRAMA-style indicator exposing smoothed trend and trigger lines."""
+
+    lines = ("frama", "trigger")
+    params = (
+        ("r_period", 16),
+        ("multiplier", 4.6),
+        ("signal_multiplier", 2.5),
+    )
+
+    def __init__(self):
+        """Set minimum period based on FRAMA computation window."""
+        self.addminperiod(max(int(self.p.r_period), 2) + 2)
+
+    def _range(self, high_line, low_line, start_shift, count):
+        highs = [
+            float(high_line[-shift]) if shift else float(high_line[0])
+            for shift in range(start_shift, start_shift + count)
+        ]
+        lows = [
+            float(low_line[-shift]) if shift else float(low_line[0])
+            for shift in range(start_shift, start_shift + count)
+        ]
+        return max(highs) - min(lows)
+
+    def next(self):
+        """Compute FRAMA and trigger values for the current bar."""
+        period = max(int(self.p.r_period), 2)
+        n = (period // 2) * 2
+        n2 = max(n // 2, 1)
+        price = float(self.data.close[0])
+
+        if len(self.data) <= n:
+            self.l.frama[0] = price
+            self.l.trigger[0] = price
+            return
+
+        r1 = self._range(self.data.high, self.data.low, 0, n2) / n2
+        r2 = self._range(self.data.high, self.data.low, n2, n2) / n2
+        r3 = self._range(self.data.high, self.data.low, 0, n) / n
+
+        if r3 <= 0 or (r1 + r2) <= 0:
+            dimension_estimate = 1.0
+        else:
+            dimension_estimate = (math.log(r1 + r2) - math.log(r3)) * 1.442695
+
+        alpha = math.exp(-float(self.p.multiplier) * (dimension_estimate - 1.0))
+        alpha = min(max(alpha, 0.01), 1.0)
+        alphas = math.exp(-float(self.p.signal_multiplier) * (dimension_estimate - 1.0))
+
+        prev_frama = (
+            float(self.l.frama[-1])
+            if len(self.data) > 1 and math.isfinite(float(self.l.frama[-1]))
+            else float(self.data.close[-1])
+        )
+        prev_trigger = (
+            float(self.l.trigger[-1])
+            if len(self.data) > 1 and math.isfinite(float(self.l.trigger[-1]))
+            else prev_frama
+        )
+
+        frama = alpha * price + (1.0 - alpha) * prev_frama
+        trigger = alphas * frama + (1.0 - alphas) * prev_trigger
+        self.l.frama[0] = frama
+        self.l.trigger[0] = trigger

backtrader/indicators/contrib/frama_series.py

@@ -0,0 +1,84 @@
+#!/usr/bin/env python
+"""Functional-test indicators migrated to contrib.
+
+Generated from a single functional strategy module to preserve file-local
+helper functions and constants without cross-test name collisions.
+"""
+
+import math
+
+from .. import Indicator
+
+__all__ = [
+    "FramaSeries",
+    "FramaLinesIndicator",
+]
+
+
+class FramaSeries(Indicator):
+    """Fractal Adaptive Moving Average (FrAMA) of a single input series."""
+
+    lines = ("frama",)
+    params = (("period", 14),)
+
+    def __init__(self):
+        """Set the minimum period required for the FrAMA computation."""
+        self.addminperiod(max(int(self.p.period), 2))
+
+    def next(self):
+        """Compute the adaptive-alpha FrAMA value for the current bar."""
+        period = max(int(self.p.period), 2)
+        half = max(period // 2, 1)
+        window = [float(self.data[-i]) for i in range(period - 1, -1, -1)]
+        if len(window) < period:
+            self.lines.frama[0] = float(self.data[0])
+            return
+        first = window[:half]
+        second = window[-half:]
+        n1 = (max(first) - min(first)) / float(half)
+        n2 = (max(second) - min(second)) / float(half)
+        n3 = (max(window) - min(window)) / float(period)
+        if n1 > 0.0 and n2 > 0.0 and n3 > 0.0:
+            dim = (math.log(n1 + n2) - math.log(n3)) / math.log(2.0)
+        else:
+            dim = 1.0
+        alpha = math.exp(-4.6 * (dim - 1.0))
+        alpha = min(max(alpha, 0.01), 1.0)
+        prev = float(self.lines.frama[-1]) if len(self) > 0 else float(self.data[0])
+        self.lines.frama[0] = alpha * float(self.data[0]) + (1.0 - alpha) * prev
+
+
+class FramaLinesIndicator(Indicator):
+    """FrAMA candle indicator emitting smoothed OHLC and a color line."""
+
+    lines = ("o", "h", "l", "c", "color")
+    params = (("period", 14),)
+
+    def __init__(self):
+        """Build FrAMA series for each of the open/high/low/close inputs."""
+        self.addminperiod(int(self.p.period) + 2)
+        self.frama_open = FramaSeries(self.data.open, period=int(self.p.period))
+        self.frama_high = FramaSeries(self.data.high, period=int(self.p.period))
+        self.frama_low = FramaSeries(self.data.low, period=int(self.p.period))
+        self.frama_close = FramaSeries(self.data.close, period=int(self.p.period))
+
+    def next(self):
+        """Assemble the smoothed FrAMA candle and classify its color."""
+        o = float(self.frama_open[0])
+        h = float(self.frama_high[0])
+        low_price = float(self.frama_low[0])
+        c = float(self.frama_close[0])
+        mx = max(o, c)
+        mn = min(o, c)
+        h = max(mx, h)
+        low_price = min(mn, low_price)
+        color = 1
+        if o < c:
+            color = 2
+        elif o > c:
+            color = 0
+        self.lines.o[0] = o
+        self.lines.h[0] = h
+        self.lines.l[0] = low_price
+        self.lines.c[0] = c
+        self.lines.color[0] = color

backtrader/indicators/contrib/frasm_av2_indicator.py

@@ -0,0 +1,104 @@
+#!/usr/bin/env python
+"""Functional-test indicators migrated to contrib.
+
+Generated from a single functional strategy module to preserve file-local
+helper functions and constants without cross-test name collisions.
+"""
+
+import math
+
+from .. import Indicator
+
+__all__ = [
+    "FRASMAv2Indicator",
+]
+
+
+def _applied_price(data, price_type, ago=0):
+    o = float(data.open[-ago])
+    h = float(data.high[-ago])
+    low_price = float(data.low[-ago])
+    c = float(data.close[-ago])
+    if price_type == 0:
+        return c
+    if price_type == 1:
+        return o
+    if price_type == 2:
+        return h
+    if price_type == 3:
+        return low_price
+    if price_type == 4:
+        return (h + low_price) / 2.0
+    if price_type == 5:
+        return (h + low_price + c) / 3.0
+    if price_type == 6:
+        return (h + low_price + c + c) / 4.0
+    return c
+
+
+class FRASMAv2Indicator(Indicator):
+    """Fractal-adaptive moving average exposing the ``frasma`` line and slope ``color``."""
+
+    lines = ("frasma", "color")
+    params = (
+        ("e_period", 30),
+        ("normal_speed", 20),
+        ("ipc", 0),
+    )
+
+    def __init__(self):
+        """Set the minimum warmup period from the estimation and speed windows."""
+        self.addminperiod(max(int(self.p.e_period), int(self.p.normal_speed)) + 3)
+
+    def next(self):
+        """Compute the fractal dimension, adapt the averaging speed, and set color.
+
+        Estimates the fractal dimension of the recent price window, derives an
+        adaptive averaging length, writes the resulting value to ``frasma``, and
+        encodes its slope into ``color`` (0 rising, 1 flat, 2 falling).
+        """
+        self.lines.color[0] = 1.0
+        need = max(int(self.p.e_period), int(self.p.normal_speed))
+        prices = [
+            _applied_price(self.data, int(self.p.ipc), i) for i in range(min(need, len(self.data)))
+        ]
+        e_period = int(self.p.e_period)
+        normal_speed = int(self.p.normal_speed)
+        g_period_minus_1 = e_period - 1
+        if len(prices) < e_period:
+            self.lines.frasma[0] = prices[0]
+            return
+        sample = prices[:e_period]
+        price_max = max(sample)
+        price_min = min(sample)
+        price_range = price_max - price_min
+        length = 0.0
+        prior_diff = 0.0
+        for k in range(g_period_minus_1 + 1):
+            if price_range > 0.0:
+                diff = (sample[k] - price_min) / price_range
+                if k > 0:
+                    length += math.sqrt((diff - prior_diff) ** 2 + (1.0 / (e_period**2)))
+                prior_diff = diff
+        if length > 0.0 and g_period_minus_1 > 0:
+            fdi = 1.0 + (math.log(length) + math.log(2.0)) / math.log(2.0 * g_period_minus_1)
+        else:
+            fdi = 0.0
+        res = 2.0 - fdi
+        if res == 0.0:
+            res = 2.0
+        trail_dim = 1.0 / res
+        alpha = trail_dim / 2.0
+        speed = int(min(max(round(normal_speed * alpha), 1), 10000))
+        speed = min(speed, len(prices))
+        value = sum(prices[:speed]) / float(speed)
+        self.lines.frasma[0] = value
+        if len(self) < 2:
+            return
+        prev = float(self.lines.frasma[-1])
+        color = 1.0
+        if prev < value:
+            color = 0.0
+        if prev > value:
+            color = 2.0
+        self.lines.color[0] = color