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

backtrader/indicators/contrib/ema_rsi_va.py

@@ -0,0 +1,80 @@
+#!/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 (
+    RSI,
+    Indicator,
+)
+
+__all__ = [
+    "EmaRsiVa",
+]
+
+
+class EmaRsiVa(Indicator):
+    """Volatility-adaptive EMA whose smoothing reacts to RSI distance from 50."""
+
+    lines = ("value",)
+    params = (
+        ("rsi_period", 14),
+        ("ema_periods", 14.0),
+        ("applied_price", "close"),
+    )
+
+    def __init__(self):
+        """Resolve the applied price line, build RSI, and set warmup period."""
+        self.price_line = self._resolve_price_line()
+        self.rsi = RSI(self.price_line, period=self.p.rsi_period)
+        self.addminperiod(max(2, int(self.p.rsi_period) * 2))
+
+    def _resolve_price_line(self):
+        ap = str(self.p.applied_price).lower()
+        if ap in ("close", "price_close"):
+            return self.data.close
+        if ap in ("open", "price_open"):
+            return self.data.open
+        if ap in ("high", "price_high"):
+            return self.data.high
+        if ap in ("low", "price_low"):
+            return self.data.low
+        if ap in ("median", "price_median"):
+            return (self.data.high + self.data.low) / 2.0
+        if ap in ("typical", "price_typical"):
+            return (self.data.high + self.data.low + self.data.close) / 3.0
+        if ap in ("weighted", "price_weighted"):
+            return (self.data.high + self.data.low + self.data.close * 2.0) / 4.0
+        return self.data.close
+
+    def next(self):
+        """Update the adaptive EMA line using the RSI-modulated smoothing factor."""
+        price = float(self.price_line[0])
+        if len(self) == int(self.p.rsi_period) * 2:
+            self.lines.value[0] = price
+            return
+
+        rsi_value = float(self.rsi[0]) if len(self.rsi) else float("nan")
+        if not math.isfinite(rsi_value):
+            prev = (
+                float(self.lines.value[-1]) if math.isfinite(float(self.lines.value[-1])) else price
+            )
+            self.lines.value[0] = prev
+            return
+
+        rsvoltl = abs(rsi_value - 50.0) + 1.0
+        multi = (5.0 + 100.0 / float(self.p.rsi_period)) / (
+            0.06 + 0.92 * rsvoltl + 0.02 * rsvoltl**2
+        )
+        pdsx = max(1.0, multi * float(self.p.ema_periods))
+        alpha = 2.0 / (pdsx + 1.0)
+
+        prev_value = float(self.lines.value[-1])
+        if not math.isfinite(prev_value):
+            prev_value = float(self.price_line[-1])
+
+        self.lines.value[0] = price * alpha + prev_value * (1.0 - alpha)

backtrader/indicators/contrib/envelopes_jp_alonso.py

@@ -0,0 +1,32 @@
+#!/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,
+    SimpleMovingAverage,
+)
+
+__all__ = [
+    "EnvelopesJpAlonso",
+]
+
+
+class EnvelopesJpAlonso(Indicator):
+    """Compute static upper/lower envelope bands around a simple moving average."""
+
+    lines = ("mid", "upper", "lower")
+    params = (
+        ("period", 200),
+        ("deviation", 0.35),
+    )
+
+    def __init__(self):
+        """Initialize envelope lines from the configured SMA period and deviation."""
+        self.lines.mid = SimpleMovingAverage(self.data.close, period=self.p.period)
+        ratio = float(self.p.deviation) / 100.0
+        self.lines.upper = self.lines.mid * (1.0 + ratio)
+        self.lines.lower = self.lines.mid * (1.0 - ratio)

backtrader/indicators/contrib/f2a_ao_indicator.py

@@ -0,0 +1,120 @@
+#!/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 (
+    ExponentialMovingAverage,
+    Indicator,
+)
+
+__all__ = [
+    "F2aAOIndicator",
+]
+
+
+class F2aAOIndicator(Indicator):
+    """F2a_AO arrow indicator from a fast/slow/filter EMA system.
+
+    Builds fast, slow and filter EMAs of a weighted price and emits a ``buy``
+    arrow below the bar when the fast-minus-slow spread turns up with filter
+    confirmation, or a ``sell`` arrow above the bar on the bearish turn, using an
+    internal latch so arrows alternate direction.
+    """
+
+    lines = ("sell", "buy")
+    params = (
+        ("ma_filtr", 3),
+        ("ma_fast", 13),
+        ("ma_slow", 144),
+    )
+
+    def __init__(self):
+        """Build the fast/slow/filter EMAs and set the minimum period."""
+        series = (
+            self.data.close * 5.0 + self.data.open * 2.0 + self.data.high + self.data.low
+        ) / 9.0
+        self._fast = ExponentialMovingAverage(series, period=max(1, int(self.p.ma_fast)))
+        self._slow = ExponentialMovingAverage(series, period=max(1, int(self.p.ma_slow)))
+        self._filter = ExponentialMovingAverage(series, period=max(1, int(self.p.ma_filtr)))
+        self.addminperiod(max(int(self.p.ma_slow), int(self.p.ma_fast), int(self.p.ma_filtr)) + 20)
+        self._trend = 0
+
+    def next(self):
+        """Compute buy/sell arrows for the current bar (event-driven mode).
+
+        Detects a confirmed turn in the fast-minus-slow spread and plots a buy
+        arrow below the low or a sell arrow above the high, offset by half the
+        recent average range, toggling the internal trend latch.
+        """
+        value1_0 = float(self._fast[0]) - float(self._slow[0])
+        value1_1 = float(self._fast[-1]) - float(self._slow[-1])
+        value1_2 = float(self._fast[-2]) - float(self._slow[-2])
+        current = float(self._filter[0])
+        prev = float(self._filter[-1])
+        avg_range = 0.0
+        for count in range(10):
+            avg_range += abs(float(self.data.high[-count]) - float(self.data.low[-count]))
+        range_value = avg_range / 10.0
+        self.lines.buy[0] = 0.0
+        self.lines.sell[0] = 0.0
+        if self._trend <= 0:
+            if value1_0 > value1_1 and current >= prev and value1_1 <= value1_2:
+                self.lines.buy[0] = float(self.data.low[0]) - range_value * 0.5
+                self._trend = 1
+        if self._trend >= 0:
+            if value1_0 < value1_1 and current <= prev and value1_1 >= value1_2:
+                self.lines.sell[0] = float(self.data.high[0]) + range_value * 0.5
+                self._trend = -1
+
+    def once(self, start, end):
+        """Compute buy/sell arrows over a range of bars (vectorized mode).
+
+        Vectorized equivalent of ``next`` used under ``runonce``: iterates the
+        arrays from ``start`` to ``end``, detecting confirmed spread turns and
+        writing buy/sell arrow values while maintaining the trend latch.
+
+        Args:
+            start: First bar index to process.
+            end: Stop index (exclusive) for processing.
+        """
+        fast = self._fast.array
+        slow = self._slow.array
+        filtr = self._filter.array
+        high = self.data.high.array
+        low = self.data.low.array
+        buy = self.lines.buy.array
+        sell = self.lines.sell.array
+        trend = 0
+        for i in range(start, end):
+            buy[i] = 0.0
+            sell[i] = 0.0
+            if i < 12:
+                continue
+            value1_0 = float(fast[i]) - float(slow[i])
+            value1_1 = float(fast[i - 1]) - float(slow[i - 1])
+            value1_2 = float(fast[i - 2]) - float(slow[i - 2])
+            current = float(filtr[i])
+            prev = float(filtr[i - 1])
+            if not all(math.isfinite(v) for v in (value1_0, value1_1, value1_2, current, prev)):
+                continue
+            avg_range = 0.0
+            valid_ranges = 0
+            for count in range(10):
+                idx = i - count
+                bar_range = abs(float(high[idx]) - float(low[idx]))
+                if math.isfinite(bar_range):
+                    avg_range += bar_range
+                    valid_ranges += 1
+            range_value = avg_range / valid_ranges if valid_ranges else 0.0
+            if trend <= 0 and value1_0 > value1_1 and current >= prev and value1_1 <= value1_2:
+                buy[i] = float(low[i]) - range_value * 0.5
+                trend = 1
+            if trend >= 0 and value1_0 < value1_1 and current <= prev and value1_1 >= value1_2:
+                sell[i] = float(high[i]) + range_value * 0.5
+                trend = -1
+        self._trend = trend

backtrader/indicators/contrib/fatl_filter.py

@@ -0,0 +1,179 @@
+#!/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__ = [
+    "FatlFilter",
+    "JFatlApprox",
+    "JFatlCandleApprox",
+]
+
+
+class FatlFilter(Indicator):
+    """Finite impulse response filter approximation used by JFatl indicators."""
+
+    lines = ("fatl",)
+    coeffs = (
+        0.4360409450,
+        0.3658689069,
+        0.2460452079,
+        0.1104506886,
+        -0.0054034585,
+        -0.0760367731,
+        -0.0933058722,
+        -0.0670110374,
+        -0.0190795053,
+        0.0259609206,
+        0.0502044896,
+        0.0477818607,
+        0.0249252327,
+        -0.0047706151,
+        -0.0272432537,
+        -0.0338917071,
+        -0.0244141482,
+        -0.0055774838,
+        0.0128149838,
+        0.0226522218,
+        0.0208778257,
+        0.0100299086,
+        -0.0036771622,
+        -0.0136744850,
+        -0.0160483392,
+        -0.0108597376,
+        -0.0016060704,
+        0.0069480557,
+        0.0110573605,
+        0.0095711419,
+        0.0040444064,
+        -0.0023824623,
+        -0.0067093714,
+        -0.0072003400,
+        -0.0047717710,
+        0.0005541115,
+        0.0007860160,
+        0.0130129076,
+        0.0040364019,
+    )
+
+    def __init__(self):
+        """Initialize the indicator with its required minimum period."""
+        self.addminperiod(len(self.coeffs))
+
+    def next(self):
+        """Compute the FIR-style filtered value for the active bar."""
+        total = 0.0
+        for idx, coef in enumerate(self.coeffs):
+            total += coef * float(self.data[-idx])
+        self.lines.fatl[0] = total
+
+
+class JFatlApprox(Indicator):
+    """Double-smoothed approximation indicator built from JFatl coefficients."""
+
+    lines = ("jfatl",)
+    params = (
+        ("length", 5),
+        ("phase", 100),
+    )
+
+    def __init__(self):
+        """Initialize smoothing state, limits, and minimum period."""
+        self._length = max(2, int(self.p.length))
+        self._phase = max(-100, min(100, int(self.p.phase)))
+        self._coeffs = FatlFilter.coeffs
+        base_alpha = 2.0 / (self._length + 1.0)
+        self._alpha = max(0.01, min(0.95, base_alpha * (1.0 + self._phase / 200.0)))
+        self._phase_gain = self._phase / 200.0
+        self._ema1 = None
+        self._ema2 = None
+        self.addminperiod(len(self._coeffs))
+
+    def next(self):
+        """Update smoothed output from incoming raw weighted observations."""
+        raw = 0.0
+        for idx, coef in enumerate(self._coeffs):
+            raw += coef * float(self.data[-idx])
+        if self._ema1 is None:
+            self._ema1 = raw
+            self._ema2 = raw
+        else:
+            self._ema1 = self._ema1 + self._alpha * (raw - self._ema1)
+            self._ema2 = self._ema2 + self._alpha * (self._ema1 - self._ema2)
+        self.lines.jfatl[0] = self._ema1 + self._phase_gain * (self._ema1 - self._ema2)
+
+
+class JFatlCandleApprox(Indicator):
+    """Reconstruct candle-like open/high/low/close and color state from JFatl."""
+
+    lines = ("open_value", "high_value", "low_value", "close_value", "color_state")
+    params = (
+        ("length", 5),
+        ("phase", 100),
+    )
+
+    def __init__(self):
+        """Initialize per-field smoothing states and min-period requirements."""
+        self._coeffs = FatlFilter.coeffs
+        self._length = max(2, int(self.p.length))
+        self._phase = max(-100, min(100, int(self.p.phase)))
+        base_alpha = 2.0 / (self._length + 1.0)
+        self._alpha = max(0.01, min(0.95, base_alpha * (1.0 + self._phase / 200.0)))
+        self._phase_gain = self._phase / 200.0
+        self._states = {
+            "open": {"ema1": None, "ema2": None},
+            "high": {"ema1": None, "ema2": None},
+            "low": {"ema1": None, "ema2": None},
+            "close": {"ema1": None, "ema2": None},
+        }
+        self.addminperiod(len(self._coeffs))
+
+    @staticmethod
+    def _finite(value):
+        return value is not None and math.isfinite(value)
+
+    def _raw_fatl(self, line):
+        total = 0.0
+        for idx, coef in enumerate(self._coeffs):
+            total += coef * float(line[-idx])
+        return total
+
+    def _smooth(self, key, raw):
+        state = self._states[key]
+        if state["ema1"] is None:
+            state["ema1"] = raw
+            state["ema2"] = raw
+        else:
+            state["ema1"] = state["ema1"] + self._alpha * (raw - state["ema1"])
+            state["ema2"] = state["ema2"] + self._alpha * (state["ema1"] - state["ema2"])
+        return state["ema1"] + self._phase_gain * (state["ema1"] - state["ema2"])
+
+    def next(self):
+        """Generate smoothed OHLC and direction color values for the current bar."""
+        open_value = self._smooth("open", self._raw_fatl(self.data.open))
+        high_value = self._smooth("high", self._raw_fatl(self.data.high))
+        low_value = self._smooth("low", self._raw_fatl(self.data.low))
+        close_value = self._smooth("close", self._raw_fatl(self.data.close))
+        if not all(self._finite(v) for v in (open_value, high_value, low_value, close_value)):
+            self.lines.open_value[0] = float("nan")
+            self.lines.high_value[0] = float("nan")
+            self.lines.low_value[0] = float("nan")
+            self.lines.close_value[0] = float("nan")
+            self.lines.color_state[0] = float("nan")
+            return
+        max_value = max(open_value, close_value)
+        min_value = min(open_value, close_value)
+        high_value = max(max_value, high_value)
+        low_value = min(min_value, low_value)
+        color_state = 2.0 if open_value < close_value else 0.0 if open_value > close_value else 1.0
+        self.lines.open_value[0] = open_value
+        self.lines.high_value[0] = high_value
+        self.lines.low_value[0] = low_value
+        self.lines.close_value[0] = close_value
+        self.lines.color_state[0] = color_state

backtrader/indicators/contrib/fibo_candles_indicator.py

@@ -0,0 +1,78 @@
+#!/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__ = [
+    "FiboCandlesIndicator",
+]
+
+
+FIBO_LEVELS = {1: 0.236, 2: 0.382, 3: 0.500, 4: 0.618, 5: 0.762}
+
+
+class FiboCandlesIndicator(Indicator):
+    """Reconstructs the FiboCandles indicator from MQ5 source.
+
+    Uses period-bar high/low range * fibo level to detect trend flips.
+    color line: 0 = bullish (trend +1), 1 = bearish (trend -1).
+    """
+
+    lines = ("color",)
+    params = (
+        ("period", 10),
+        ("fibo_level", 1),
+    )
+
+    def __init__(self):
+        """Initialize indicator variables, selected fibonacci ratio level, and trend state."""
+        self._level = FIBO_LEVELS.get(int(self.p.fibo_level), 0.236)
+        self._trend = 1
+        self.addminperiod(int(self.p.period) + 1)
+
+    def next(self):
+        """Determine trend direction and assign bullish/bearish candle colors."""
+        period = int(self.p.period)
+        level = self._level
+
+        # maxHigh / minLow over [bar, bar+period) in MQ5 (as-series)
+        # In backtrader forward indexing: last `period` bars including current
+        max_high = max(float(self.data.high[-i]) for i in range(period))
+        min_low = min(float(self.data.low[-i]) for i in range(period))
+        rng = max_high - min_low
+
+        o = float(self.data.open[0])
+        c = float(self.data.close[0])
+        float(self.data.high[0])
+        float(self.data.low[0])
+        trend = self._trend
+
+        if o > c:  # bearish candle
+            if not (trend < 0 and rng * level < c - min_low):
+                trend = 1
+            else:
+                trend = -1
+        else:  # bullish candle
+            if not (trend > 0 and rng * level < max_high - c):
+                trend = -1
+            else:
+                trend = 1
+
+        # Color assignment
+        if trend == 1:
+            open_buf = max(o, c)
+            close_buf = min(o, c)
+        else:
+            open_buf = min(o, c)
+            close_buf = max(o, c)
+
+        if open_buf > close_buf:
+            self.lines.color[0] = 1.0  # bearish color
+        else:
+            self.lines.color[0] = 0.0  # bullish color
+
+        self._trend = trend

backtrader/indicators/contrib/fine_tuning_ma.py

@@ -0,0 +1,100 @@
+#!/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__ = [
+    "FineTuningMA",
+]
+
+
+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 (close + high + low) / 3.0
+    if key in ("weighted", "7", "price_weighted"):
+        return (2.0 * close + high + low) / 4.0
+    if key in ("simple", "8", "price_simpl"):
+        return (open_ + close) / 2.0
+    if key in ("quarter", "9", "price_quarter"):
+        return (open_ + close + high + low) / 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 FineTuningMA(Indicator):
+    """Weighted moving average with rank/shift-shaped per-bar weights."""
+
+    lines = ("value",)
+    params = (
+        ("ftma", 10),
+        ("rank1", 2.0),
+        ("rank2", 2.0),
+        ("rank3", 2.0),
+        ("shift1", 1.0),
+        ("shift2", 1.0),
+        ("shift3", 1.0),
+        ("ipc", "typical"),
+    )
+
+    def __init__(self):
+        """Precompute the normalized FineTuningMA weights and warmup period."""
+        self.ftma = max(int(self.p.ftma), 1)
+        self.weights = []
+        total = 0.0
+        for h in range(self.ftma):
+            denom = max(self.ftma - 1.0, 1.0)
+            part = float(h) / denom
+            w = self.p.shift1 + math.pow(part, float(self.p.rank1)) * (1.0 - self.p.shift1)
+            w = (
+                self.p.shift2 + math.pow(1.0 - part, float(self.p.rank2)) * (1.0 - self.p.shift2)
+            ) * w
+            w = (
+                self.p.shift3
+                + math.pow(1.0 - abs(part - 0.5) * 2.0, float(self.p.rank3)) * (1.0 - self.p.shift3)
+            ) * w
+            self.weights.append(w)
+            total += w
+        self.weights = [w / total for w in self.weights] if total else [1.0 / self.ftma] * self.ftma
+        self.addminperiod(self.ftma + 2)
+
+    def next(self):
+        """Output the weighted average of the applied price over the window."""
+        if len(self.data) < self.ftma:
+            self.l.value[0] = _price_value(self.data, 0, self.p.ipc)
+            return
+        total = 0.0
+        for h in range(self.ftma):
+            total += self.weights[h] * _price_value(self.data, h, self.p.ipc)
+        self.l.value[0] = total

backtrader/indicators/contrib/fisher_org_v1.py

@@ -0,0 +1,102 @@
+#!/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__ = [
+    "FisherOrgV1",
+]
+
+
+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 FisherOrgV1(Indicator):
+    """Fisher Transform indicator producing a Gaussian-like signal line and its lagged trigger.
+
+    Lines
+    -----
+    fisher : float
+        Current smoothed Fisher Transform value.
+    trigger : float
+        Previous bar's fisher value, used for crossover detection.
+    """
+
+    lines = ("fisher", "trigger")
+    params = (
+        ("length", 7),
+        ("ipc", 1),
+    )
+
+    def __init__(self):
+        """Initialise indicator state and smoothing recursive value."""
+        self.addminperiod(int(self.p.length) + 2)
+        self._value1 = 0.0
+
+    def next(self):
+        """Compute Fisher Transform value and set fisher/trigger 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)
+        fisher_prev = float(self.lines.fisher[-1]) if len(self) > 1 else 0.0
+        if not math.isfinite(fisher_prev):
+            fisher_prev = 0.0
+        res2 = (1.0 + value0) / (1.0 - value0)
+        if res2 < 1e-7:
+            res2 = 1.0
+        fisher = 0.5 * math.log(res2) + 0.5 * fisher_prev
+        self.lines.fisher[0] = fisher
+        self.lines.trigger[0] = fisher_prev
+        self._value1 = value0