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

backtrader/indicators/contrib/laguerre_plus_di_proxy.py

@@ -0,0 +1,57 @@
+#!/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__ = [
+    "LaguerrePlusDiProxy",
+]
+
+
+class LaguerrePlusDiProxy(Indicator):
+    """Laguerre-style +DI proxy normalized to the 0..1 range.
+
+    Approximates the directional-movement balance used by the original EA by
+    computing positive/negative directional movement and true range over the
+    lookback period and emitting the normalized +DI share.
+    """
+
+    lines = ("value",)
+    params = (("period", 14),)
+
+    def __init__(self):
+        """Set the minimum period required before emitting values."""
+        self.addminperiod(self.p.period + 3)
+
+    def next(self):
+        """Compute the normalized +DI ratio for the current bar."""
+        pdm_vals = []
+        mdm_vals = []
+        tr_vals = []
+        for idx in range(self.p.period):
+            high0 = float(self.data.high[-idx])
+            high1 = float(self.data.high[-idx - 1])
+            low0 = float(self.data.low[-idx])
+            low1 = float(self.data.low[-idx - 1])
+            close1 = float(self.data.close[-idx - 1])
+            up_move = high0 - high1
+            down_move = low1 - low0
+            pdm = up_move if up_move > down_move and up_move > 0 else 0.0
+            mdm = down_move if down_move > up_move and down_move > 0 else 0.0
+            tr = max(high0 - low0, abs(high0 - close1), abs(low0 - close1))
+            pdm_vals.append(pdm)
+            mdm_vals.append(mdm)
+            tr_vals.append(tr)
+        tr_sum = sum(tr_vals)
+        if tr_sum <= 1e-12:
+            self.lines.value[0] = 0.5
+            return
+        pdi = 100.0 * sum(pdm_vals) / tr_sum
+        mdi = 100.0 * sum(mdm_vals) / tr_sum
+        denom = pdi + mdi
+        ratio = 0.5 if denom <= 1e-12 else pdi / denom
+        self.lines.value[0] = max(0.0, min(1.0, ratio))

backtrader/indicators/contrib/laguerre_roc_indicator.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.
+"""
+
+from .. import Indicator
+
+__all__ = [
+    "LaguerreRocIndicator",
+]
+
+
+class LaguerreRocIndicator(Indicator):
+    """Laguerre ROC indicator emitting value, midline, and color."""
+
+    lines = ("lroc", "midline", "color")
+    params = (
+        ("vperiod", 5),
+        ("gamma", 0.5),
+        ("up_level", 0.75),
+        ("dn_level", 0.25),
+        ("point", 0.01),
+    )
+
+    def __init__(self):
+        """Initialize rolling state and warm-up period."""
+        self.addminperiod(int(self.p.vperiod) + 4)
+        self._initialized = False
+        self._l0 = self._l1 = self._l2 = self._l3 = None
+
+    def next(self):
+        """Calculate laguerre recursive values and output normalized ROC color."""
+        if len(self.data) <= int(self.p.vperiod):
+            self.lines.lroc[0] = 0.5
+            self.lines.midline[0] = 0.5
+            self.lines.color[0] = 2
+            return
+        reference = float(self.data.close[-int(self.p.vperiod)])
+        if reference == 0:
+            roc = float(self.p.point)
+        else:
+            roc = (float(self.data.close[0]) - reference) / reference + float(self.p.point)
+        gamma = float(self.p.gamma)
+        if not self._initialized:
+            self._l0 = self._l1 = self._l2 = self._l3 = roc
+            self._initialized = True
+        l0_prev, l1_prev, l2_prev, l3_prev = self._l0, self._l1, self._l2, self._l3
+        l0 = (1.0 - gamma) * roc + gamma * l0_prev
+        l1 = -gamma * l0 + l0_prev + gamma * l1_prev
+        l2 = -gamma * l1 + l1_prev + gamma * l2_prev
+        l3 = -gamma * l2 + l2_prev + gamma * l3_prev
+        cu = 0.0
+        cd = 0.0
+        if l0 >= l1:
+            cu += l0 - l1
+        else:
+            cd += l1 - l0
+        if l1 >= l2:
+            cu += l1 - l2
+        else:
+            cd += l2 - l1
+        if l2 >= l3:
+            cu += l2 - l3
+        else:
+            cd += l3 - l2
+        lroc = cu / (cu + cd) if (cu + cd) != 0 else 0.5
+        color = 2
+        if lroc > float(self.p.up_level):
+            color = 4
+        elif lroc > 0.5:
+            color = 3
+        if lroc < float(self.p.dn_level):
+            color = 0
+        elif lroc < 0.5:
+            color = 1
+        self.lines.lroc[0] = lroc
+        self.lines.midline[0] = 0.5
+        self.lines.color[0] = color
+        self._l0, self._l1, self._l2, self._l3 = l0, l1, l2, l3

backtrader/indicators/contrib/le_man_signal_indicator.py

@@ -0,0 +1,63 @@
+#!/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__ = [
+    "LeManSignalIndicator",
+]
+
+
+class LeManSignalIndicator(Indicator):
+    """Reconstructs LeManSignal from its MQ5 source.
+
+    Compares two consecutive LPeriod-window high/low ranges shifted by 1 bar
+    and by LPeriod bars to detect breakouts.
+    buy_arrow: H3<=H4 && H1>H2  (high range expansion upward)
+    sell_arrow: L3>=L4 && L1<L2  (low range expansion downward)
+    """
+
+    lines = ("buy_arrow", "sell_arrow")
+    params = (
+        ("lperiod", 12),
+        ("point", 0.0001),
+    )
+
+    def __init__(self):
+        """Store LPeriod/rules and initialize lookback requirements."""
+        self._lp = int(self.p.lperiod)
+        self.addminperiod(self._lp * 2 + 3)
+
+    def next(self):
+        """Compute LeManSignal buy/sell arrows from rolling high-low ranges."""
+        lp = self._lp
+        # MQ5 as-series indexing: bar=0 is current, bar+1 is 1 ago, etc.
+        # H1 = max high over [bar+1, bar+1+LPeriod)  => [-1 .. -(lp)]
+        # H2 = max high over [bar+1+LPeriod, bar+1+2*LPeriod) => [-(lp+1) .. -(2*lp)]
+        # H3 = max high over [bar+2, bar+2+LPeriod)  => [-2 .. -(lp+1)]
+        # H4 = max high over [bar+2+LPeriod, bar+2+2*LPeriod) => [-(lp+2) .. -(2*lp+1)]
+        H1 = max(float(self.data.high[-i]) for i in range(1, lp + 1))
+        H2 = max(float(self.data.high[-i]) for i in range(lp + 1, 2 * lp + 1))
+        H3 = max(float(self.data.high[-i]) for i in range(2, lp + 2))
+        H4 = max(float(self.data.high[-i]) for i in range(lp + 2, 2 * lp + 2))
+
+        L1 = min(float(self.data.low[-i]) for i in range(1, lp + 1))
+        L2 = min(float(self.data.low[-i]) for i in range(lp + 1, 2 * lp + 1))
+        L3 = min(float(self.data.low[-i]) for i in range(2, lp + 2))
+        L4 = min(float(self.data.low[-i]) for i in range(lp + 2, 2 * lp + 2))
+
+        buy_val = 0.0
+        sell_val = 0.0
+        pt = float(self.p.point)
+
+        if H3 <= H4 and H1 > H2:
+            buy_val = float(self.data.high[-1]) + pt
+        if L3 >= L4 and L1 < L2:
+            sell_val = float(self.data.low[-1]) - pt
+
+        self.lines.buy_arrow[0] = buy_val
+        self.lines.sell_arrow[0] = sell_val

backtrader/indicators/contrib/linear_reg_slope_v2_indicator.py

@@ -0,0 +1,136 @@
+#!/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 collections import deque
+
+import pandas as pd
+
+from .. import (
+    EMA,
+    SMA,
+    Indicator,
+    SmoothedMovingAverage,
+    WeightedMovingAverage,
+)
+
+__all__ = [
+    "LinearRegSlopeV2Indicator",
+]
+
+
+def resolve_ma_class(name):
+    """Resolve a human-readable moving-average mode name to a Backtrader class.
+
+    Args:
+        name: Strategy parameter value such as ``sma``, ``ema``, or ``smma``.
+
+    Returns:
+        The matching Backtrader moving-average indicator class.
+    """
+    mode = str(name).lower()
+    if mode in {"sma", "mode_sma"}:
+        return SMA
+    if mode in {"ema", "mode_ema"}:
+        return EMA
+    if mode in {"smma", "mode_smma"}:
+        return SmoothedMovingAverage
+    return WeightedMovingAverage
+
+
+def resolve_price_line(data, mode):
+    """Resolve an abstract price mode name to a concrete price series line.
+
+    Args:
+        data: A Backtrader data feed exposing OHLCV lines.
+        mode: Price selector such as ``price_close``, ``price_open``, etc.
+
+    Returns:
+        A line-like object representing the selected price calculation.
+    """
+    price_mode = str(mode).lower()
+    if price_mode in {"price_open", "open"}:
+        return data.open
+    if price_mode in {"price_high", "high"}:
+        return data.high
+    if price_mode in {"price_low", "low"}:
+        return data.low
+    if price_mode in {"price_median", "median"}:
+        return (data.high + data.low) / 2.0
+    if price_mode in {"price_typical", "typical"}:
+        return (data.high + data.low + data.close) / 3.0
+    if price_mode in {"price_weighted", "weighted"}:
+        return (data.high + data.low + data.close + data.close) / 4.0
+    if price_mode in {"price_simpl", "simpl"}:
+        return (data.open + data.close) / 2.0
+    if price_mode in {"price_quarter", "quarter"}:
+        return (data.high + data.low + data.open + data.close) / 4.0
+    if price_mode in {"price_trendfollow0", "trendfollow0"}:
+        return (data.high + data.low + data.close + data.close) / 4.0
+    if price_mode in {"price_trendfollow1", "trendfollow1"}:
+        return (data.high + data.low + data.open + data.close + data.close) / 5.0
+    return data.close
+
+
+class LinearRegSlopeV2Indicator(Indicator):
+    """Indicator that computes a linear-regression slope proxy and trigger line."""
+
+    lines = (
+        "reg_slope",
+        "trigger",
+    )
+    params = (
+        ("sl_method", "sma"),
+        ("sl_length", 12),
+        ("sl_phase", 15),
+        ("ipc", "price_close"),
+        ("trigger_shift", 1),
+    )
+
+    def __init__(self):
+        """Initialize smoothing, regression buffers, and phase-shift settings."""
+        ma_cls = resolve_ma_class(self.p.sl_method)
+        price_line = resolve_price_line(self.data, self.p.ipc)
+        self.smooth = ma_cls(price_line, period=self.p.sl_length)
+        self._window = deque(maxlen=self.p.sl_length)
+        self._sum_x = self.p.sl_length * (self.p.sl_length - 1) * 0.5
+        sum_x_sqr = (
+            (self.p.sl_length - 1.0) * self.p.sl_length * (2.0 * self.p.sl_length - 1.0) / 6.0
+        )
+        self._divisor = self._sum_x * self._sum_x - self.p.sl_length * sum_x_sqr
+        if self.p.trigger_shift > self.p.sl_length - 2:
+            self._trig_shift = 1
+            self._trig_shift_back = self.p.sl_length - 2
+        else:
+            self._trig_shift = self.p.sl_length - 1 - self.p.trigger_shift
+            self._trig_shift_back = self.p.trigger_shift
+        self.addminperiod(self.p.sl_length + self.p.trigger_shift + 3)
+
+    def next(self):
+        """Update one bar of regression slope and trigger calculations."""
+        self._window.appendleft(float(self.smooth[0]))
+        if len(self._window) < self.p.sl_length:
+            self.lines.reg_slope[0] = float("nan")
+            self.lines.trigger[0] = float("nan")
+            return
+        sum_y = sum(self._window[i] for i in range(self.p.sl_length))
+        sum_xy = sum(i * self._window[i] for i in range(self.p.sl_length))
+        slope = (
+            (self.p.sl_length * sum_xy - self._sum_x * sum_y) / self._divisor
+            if self._divisor
+            else float("nan")
+        )
+        intercept = (sum_y - slope * self._sum_x) / self.p.sl_length
+        reg_value = intercept + slope * self._trig_shift
+        self.lines.reg_slope[0] = reg_value
+        if len(self) > self._trig_shift_back and not pd.isna(
+            self.lines.reg_slope[-self._trig_shift_back]
+        ):
+            self.lines.trigger[0] = 2.0 * reg_value - float(
+                self.lines.reg_slope[-self._trig_shift_back]
+            )
+        else:
+            self.lines.trigger[0] = float("nan")

backtrader/indicators/contrib/loco_indicator.py

@@ -0,0 +1,88 @@
+#!/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__ = [
+    "LocoIndicator",
+]
+
+
+def _applied_price(data, mode, ago=0):
+    mode = str(mode).lower()
+    o = float(data.open[ago])
+    h = float(data.high[ago])
+    low_price = float(data.low[ago])
+    c = float(data.close[ago])
+    if mode in ("price_open", "open", "price_open_"):
+        return o
+    if mode in ("price_high", "high", "price_high_"):
+        return h
+    if mode in ("price_low", "low", "price_low_"):
+        return low_price
+    if mode in ("price_median", "median", "price_median_"):
+        return (h + low_price) / 2.0
+    if mode in ("price_typical", "typical", "price_typical_"):
+        return (h + low_price + c) / 3.0
+    if mode in ("price_weighted", "weighted", "price_weighted_"):
+        return (h + low_price + 2.0 * c) / 4.0
+    if mode in ("price_simpl", "simpl", "simple", "price_simpl_"):
+        return (o + c) / 2.0
+    if mode in ("price_quarter", "quarter", "price_quarter_"):
+        return (h + low_price + o + c) / 4.0
+    return c
+
+
+class LocoIndicator(Indicator):
+    """Loco follow-through line with a binary bullish/bearish color flag.
+
+    Tracks the applied price and produces a ``loco`` line plus a ``color`` flag
+    (0 = bullish, 1 = bearish) that flips when price reverses its run of higher
+    or lower readings.
+    """
+
+    lines = ("loco", "color")
+    params = (
+        ("length", 1),
+        ("ipc", "price_close_"),
+        ("price_shift_points", 0.0),
+    )
+
+    def __init__(self):
+        """Reserve the warm-up window and initialise carry-forward state."""
+        self.addminperiod(max(int(self.p.length), 1) + 2)
+        self._initialized = False
+        self._prev = None
+
+    def next(self):
+        """Update the Loco line and color flag for the current bar."""
+        series0 = _applied_price(self.data, self.p.ipc, 0)
+        if not self._initialized:
+            result = series0
+            color = 0
+            self._prev = result
+            self._initialized = True
+        else:
+            prev = float(self._prev)
+            ago = min(int(self.p.length), len(self.data) - 1)
+            series1 = _applied_price(self.data, self.p.ipc, -ago)
+            if series1 > prev and series0 > prev:
+                result = max(prev, series0 * 0.999)
+                color = 0
+            elif series1 < prev and series0 < prev:
+                result = min(prev, series0 * 1.001)
+                color = 1
+            else:
+                if series0 > prev:
+                    result = series0 * 0.999
+                    color = 0
+                else:
+                    result = series0 * 1.001
+                    color = 1
+            self._prev = result
+        self.lines.loco[0] = result + float(self.p.price_shift_points)
+        self.lines.color[0] = color

backtrader/indicators/contrib/lrma_indicator.py

@@ -0,0 +1,185 @@
+#!/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,
+    SimpleMovingAverage,
+    SmoothedMovingAverage,
+    StandardDeviation,
+    WeightedMovingAverage,
+)
+
+__all__ = [
+    "LRMAIndicator",
+    "ChangeOfVolatilityIndicator",
+    "VininITrendLRMAIndicator",
+]
+
+
+def resolve_ma_class(name):
+    """Map a moving-average method name to a backtrader indicator class.
+
+    Args:
+        name: Moving-average method identifier (e.g. ``sma``, ``ema``,
+            ``smma``).
+
+    Returns:
+        The backtrader moving-average indicator class matching ``name``,
+        defaulting to WeightedMovingAverage for unknown names.
+    """
+    mode = str(name).lower()
+    if mode in {"sma", "mode_sma"}:
+        return SimpleMovingAverage
+    if mode in {
+        "ema",
+        "mode_ema",
+        "ama",
+        "mode_ama",
+        "jjma",
+        "mode_jjma",
+        "jurx",
+        "mode_jurx",
+        "parma",
+        "mode_parma",
+        "t3",
+        "mode_t3",
+        "vidya",
+        "mode_vidya",
+    }:
+        return ExponentialMovingAverage
+    if mode in {"smma", "mode_smma"}:
+        return SmoothedMovingAverage
+    return WeightedMovingAverage
+
+
+def resolve_price_line(data, mode):
+    """Select the price line for a given applied-price mode.
+
+    Args:
+        data: The data feed exposing open/high/low/close lines.
+        mode: Applied-price identifier (e.g. ``price_close``, ``price_median``,
+            ``price_typical``, ``price_weighted``).
+
+    Returns:
+        The data line or derived line expression for the requested price mode,
+        defaulting to the close line.
+    """
+    price_mode = str(mode).lower()
+    if price_mode in {"price_open", "open"}:
+        return data.open
+    if price_mode in {"price_high", "high"}:
+        return data.high
+    if price_mode in {"price_low", "low"}:
+        return data.low
+    if price_mode in {"price_median", "median"}:
+        return (data.high + data.low) / 2.0
+    if price_mode in {"price_typical", "typical"}:
+        return (data.high + data.low + data.close) / 3.0
+    if price_mode in {"price_weighted", "weighted"}:
+        return (data.high + data.low + data.close + data.close) / 4.0
+    return data.close
+
+
+class LRMAIndicator(Indicator):
+    """Linear regression moving average projected to the latest bar."""
+
+    lines = ("lrma",)
+    params = (("period", 13),)
+
+    def __init__(self):
+        """Set the minimum period required before the LRMA can be computed."""
+        self.addminperiod(int(self.p.period))
+
+    def next(self):
+        """Fit a least-squares line over the window and emit its endpoint."""
+        period = int(self.p.period)
+        xs = list(range(period))
+        ys = [float(self.data[-period + 1 + i]) for i in range(period)]
+        mean_x = sum(xs) / period
+        mean_y = sum(ys) / period
+        num = sum((x - mean_x) * (y - mean_y) for x, y in zip(xs, ys))
+        den = sum((x - mean_x) ** 2 for x in xs)
+        slope = num / den if den else 0.0
+        intercept = mean_y - slope * mean_x
+        self.lines.lrma[0] = intercept + slope * (period - 1)
+
+
+class ChangeOfVolatilityIndicator(Indicator):
+    """Ratio of short- to long-window momentum dispersion (as a percentage)."""
+
+    lines = ("trend",)
+    params = (
+        ("mperiod", 1),
+        ("short", 6),
+        ("long", 100),
+    )
+
+    def __init__(self):
+        """Build short/long momentum SMAs and standard deviations."""
+        period = int(self.p.mperiod)
+        momentum = self.data.close - self.data.close(-period)
+        self._sma_long = SimpleMovingAverage(momentum, period=max(1, int(self.p.long)))
+        self._sma_short = SimpleMovingAverage(momentum, period=max(1, int(self.p.short)))
+        self._std_long = StandardDeviation(momentum, period=max(1, int(self.p.long)))
+        self._std_short = StandardDeviation(momentum, period=max(1, int(self.p.short)))
+        self.addminperiod(int(self.p.mperiod) + max(int(self.p.short), int(self.p.long)) + 3)
+
+    def next(self):
+        """Emit the short/long volatility ratio scaled to a percentage."""
+        long_std = float(self._std_long[0])
+        short_std = float(self._std_short[0])
+        self.lines.trend[0] = 100.0 * short_std / long_std if long_std else 0.0
+
+
+class VininITrendLRMAIndicator(Indicator):
+    """Trend oscillator scoring LRMA against a fan of moving averages."""
+
+    lines = ("trend",)
+    params = (
+        ("lrma_period", 13),
+        ("ma_method1", "sma"),
+        ("length1", 3),
+        ("phase1", 15),
+        ("ma_step", 10),
+        ("ma_count", 10),
+        ("ma_method2", "jjma"),
+        ("length2", 20),
+        ("phase2", 100),
+        ("ipc", "price_close"),
+    )
+
+    def __init__(self):
+        """Construct the LRMA, the MA fan, and the output smoother."""
+        price_line = resolve_price_line(self.data, self.p.ipc)
+        self._lrma = LRMAIndicator(price_line, period=self.p.lrma_period)
+        periods = [
+            int(self.p.length1 + idx * self.p.ma_step) for idx in range(int(self.p.ma_count))
+        ]
+        ma_cls = resolve_ma_class(self.p.ma_method1)
+        self._ma_lines = [ma_cls(self._lrma.lrma, period=max(1, p)) for p in periods]
+        smooth_cls = resolve_ma_class(self.p.ma_method2)
+        self._smooth = smooth_cls(self.lines.trend, period=max(1, int(self.p.length2)))
+        self.addminperiod(int(self.p.lrma_period) + max(periods) + int(self.p.length2) + 5)
+
+    def next(self):
+        """Score LRMA versus the MA fan and exponentially smooth the result."""
+        lrma_value = float(self._lrma.lrma[0])
+        score = 0
+        for ma_line in self._ma_lines:
+            if lrma_value > float(ma_line[0]):
+                score += 1
+            else:
+                score -= 1
+        raw = 100.0 * score / max(1, len(self._ma_lines))
+        period = max(1, int(self.p.length2))
+        alpha = 2.0 / (period + 1.0)
+        prev = float(self.lines.trend[-1]) if len(self) > 0 else raw
+        if len(self) == 0:
+            self.lines.trend[0] = raw
+        else:
+            self.lines.trend[0] = alpha * raw + (1.0 - alpha) * prev