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

backtrader/indicators/contrib/lsma_angle_indicator.py

@@ -0,0 +1,106 @@
+#!/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__ = [
+    "LsmaAngleIndicator",
+]
+
+
+class LsmaAngleIndicator(Indicator):
+    """Compute LSMA slope angle and map it to a color-state indicator.
+
+    The indicator evaluates two least-squares MAs at different shifts and uses
+    the angle and trend persistence to classify bullish/bearish momentum states.
+
+    Args:
+        lsma_period: Look-back window used for each LSMA estimate.
+        angle_threshold: Threshold used to classify the angle magnitude.
+        start_shift: Shift index for the start LSMA sample.
+        end_shift: Shift index for the end LSMA sample.
+    """
+
+    lines = ("angle", "color_index")
+    params = (
+        ("lsma_period", 25),
+        ("angle_threshold", 15),
+        ("start_shift", 4),
+        ("end_shift", 0),
+    )
+
+    def __init__(self):
+        """Set minimum-history requirement and initialize derived scale factor."""
+        needed = (
+            int(max(self.p.lsma_period + self.p.start_shift, self.p.lsma_period + self.p.end_shift))
+            + 2
+        )
+        self.addminperiod(needed)
+        self._m_factor = None
+
+    def _lsma(self, shift):
+        period = int(self.p.lsma_period)
+        values = [float(self.data.close[-(shift + i)]) for i in range(period)]
+        x = list(range(period))
+        x_mean = sum(x) / period
+        y_mean = sum(values) / period
+        numerator = sum((xi - x_mean) * (yi - y_mean) for xi, yi in zip(x, values))
+        denominator = sum((xi - x_mean) ** 2 for xi in x)
+        slope = numerator / denominator if denominator else 0.0
+        intercept = y_mean - slope * x_mean
+        return intercept + slope * (period - 1)
+
+    def _ensure_factor(self):
+        if self._m_factor is not None:
+            return
+        point = (
+            float(getattr(self.data, "_dataname", None).attrs["point"])
+            if hasattr(getattr(self.data, "_dataname", None), "attrs")
+            and "point" in self.data._dataname.attrs
+            else None
+        )
+        if point is None or point <= 0:
+            close0 = float(self.data.close[0]) if len(self.data) else 0.0
+            point = 0.01 if abs(close0) >= 10 and abs(close0) < 1000 else 0.0001
+        shift_diff = float(int(self.p.start_shift) - int(self.p.end_shift))
+        self._m_factor = (
+            1000.0
+            if abs(float(self.data.close[0])) >= 10 and abs(float(self.data.close[0])) < 1000
+            else 100000.0
+        ) / shift_diff
+
+    def next(self):
+        """Calculate the current angle and update color index for the next bar."""
+        if int(self.p.end_shift) >= int(self.p.start_shift):
+            self.lines.angle[0] = 0.0
+            self.lines.color_index[0] = 2
+            return
+        self._ensure_factor()
+        end_ma = self._lsma(int(self.p.end_shift))
+        start_ma = self._lsma(int(self.p.start_shift))
+        angle = self._m_factor * (end_ma - start_ma) / 2.0
+        self.lines.angle[0] = angle
+        clr = 2
+        threshold = float(self.p.angle_threshold)
+        prev_angle = (
+            float(self.lines.angle[-1])
+            if len(self) > 0 and math.isfinite(float(self.lines.angle[-1]))
+            else angle
+        )
+        if angle > threshold:
+            if angle > prev_angle:
+                clr = 4
+            elif angle < prev_angle:
+                clr = 3
+        if angle < -threshold:
+            if angle < prev_angle:
+                clr = 0
+            elif angle > prev_angle:
+                clr = 1
+        self.lines.color_index[0] = clr

backtrader/indicators/contrib/ma_rounding_channel_indicator.py

@@ -0,0 +1,149 @@
+#!/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 (
+    ATR,
+    EMA,
+    SMA,
+    Indicator,
+    SmoothedMovingAverage,
+    WeightedMovingAverage,
+)
+
+__all__ = [
+    "MARoundingChannelIndicator",
+]
+
+
+def resolve_ma_class(name):
+    """Map MA method name to the corresponding Backtrader 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):
+    """Map a configured price selector string to feed line values."""
+    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 MARoundingChannelIndicator(Indicator):
+    """Indicator that derives rounded moving-average centerline and channel bounds."""
+
+    lines = (
+        "base",
+        "upper",
+        "lower",
+    )
+    params = (
+        ("xma_method", "sma"),
+        ("xlength", 12),
+        ("xphase", 15),
+        ("ipc", "price_close"),
+        ("ma_round", 500),
+        ("atr_period", 12),
+        ("atr_factor", 1.0),
+        ("chan_continuity", False),
+    )
+
+    def __init__(self):
+        """Resolve MA and ATR dependencies and initialize rolling channel state."""
+        ma_cls = resolve_ma_class(self.p.xma_method)
+        price_line = resolve_price_line(self.data, self.p.ipc)
+        self.ma = ma_cls(price_line, period=self.p.xlength)
+        self.atr = ATR(self.data, period=self.p.atr_period)
+        self._ma_ro = None
+        self._prev_ma = None
+        self._prev_dir = 0
+        self._prev_range = 0.0
+        self._prev_base = None
+        self._prev_prev_base = None
+        self._prev_upper = 0.0
+        self._prev_lower = 0.0
+        self.addminperiod(max(self.p.xlength, self.p.atr_period) + 3)
+
+    def next(self):
+        """Update channel base/upper/lower values from latest MA and ATR context."""
+        if self._ma_ro is None:
+            self._ma_ro = (
+                float(self.data.close[0]) * 0.0 + self.data._dataname["close"].iloc[0] * 0.0
+                if False
+                else None
+            )
+        ma_ro = float(getattr(self.data, "_compression", 0) or 0)
+        if not ma_ro:
+            point = 0.01 if abs(float(self.data.close[0])) >= 1 else 0.0001
+            ma_ro = point * float(self.p.ma_round)
+        mov_ave0 = float(self.ma[0])
+        if self._prev_ma is None:
+            self._prev_ma = mov_ave0
+        res1 = self._prev_base if self._prev_base is not None else mov_ave0
+        if (
+            mov_ave0 > self._prev_ma + ma_ro
+            or mov_ave0 < self._prev_ma - ma_ro
+            or mov_ave0 > res1 + ma_ro
+            or mov_ave0 < res1 - ma_ro
+            or (mov_ave0 > res1 and self._prev_dir == 1)
+            or (mov_ave0 < res1 and self._prev_dir == -1)
+        ):
+            base = mov_ave0
+        else:
+            base = res1
+        direction = 0
+        if base < res1:
+            direction = -1
+        elif base > res1:
+            direction = 1
+        else:
+            direction = self._prev_dir
+        upper = 0.0
+        lower = 0.0
+        range0 = self._prev_range
+        if base == res1:
+            if self._prev_prev_base is None or res1 != self._prev_prev_base:
+                range0 = float(self.atr[0]) * float(self.p.atr_factor)
+            upper = base + range0
+            lower = base - range0
+        elif self.p.chan_continuity:
+            upper = self._prev_upper
+            lower = self._prev_lower
+        self.lines.base[0] = base
+        self.lines.upper[0] = upper
+        self.lines.lower[0] = lower
+        self._prev_dir = direction
+        self._prev_ma = mov_ave0
+        self._prev_range = range0
+        self._prev_prev_base = self._prev_base
+        self._prev_base = base
+        self._prev_upper = upper
+        self._prev_lower = lower

backtrader/indicators/contrib/macd2_indicator.py

@@ -0,0 +1,61 @@
+#!/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 (
+    MACD,
+    Indicator,
+)
+
+__all__ = [
+    "Macd2Indicator",
+]
+
+
+class Macd2Indicator(Indicator):
+    """MACD-derived indicator carrying cloud and histogram state for MACD-2."""
+
+    lines = ("cloud_a", "cloud_b", "hist", "color")
+    params = (
+        ("fast_macd", 12),
+        ("slow_macd", 26),
+        ("signal_macd", 9),
+    )
+
+    def __init__(self):
+        """Create MACD-based cloud and initialize indicator warmup."""
+        self.macd = MACD(
+            self.data,
+            period_me1=int(self.p.fast_macd),
+            period_me2=int(self.p.slow_macd),
+            period_signal=int(self.p.signal_macd),
+        )
+        self.addminperiod(
+            int(self.p.signal_macd) + max(int(self.p.fast_macd), int(self.p.slow_macd)) + 2
+        )
+
+    def next(self):
+        """Populate cloud, histogram, and trend color lines each bar."""
+        main = float(self.macd.macd[0])
+        signal = float(self.macd.signal[0])
+        hist = 3.0 * (main - signal)
+        self.lines.cloud_a[0] = main
+        self.lines.cloud_b[0] = signal
+        self.lines.hist[0] = hist
+        color = 2
+        if len(self) > 1:
+            prev_hist = float(self.lines.hist[-1])
+            if hist > 0:
+                if hist > prev_hist:
+                    color = 4
+                elif hist < prev_hist:
+                    color = 3
+            elif hist < 0:
+                if hist < prev_hist:
+                    color = 0
+                elif hist > prev_hist:
+                    color = 1
+        self.lines.color[0] = color

backtrader/indicators/contrib/macd_candle_indicator.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.
+"""
+
+from .. import (
+    MACD,
+    Indicator,
+)
+
+__all__ = [
+    "MacdCandleIndicator",
+]
+
+
+class MacdCandleIndicator(Indicator):
+    """MACD-based candle indicator returning open/high/low/close values."""
+
+    lines = ("macd_open", "macd_high", "macd_low", "macd_close", "color")
+    params = (
+        ("fast_ema_period", 12),
+        ("slow_ema_period", 26),
+        ("signal_period", 9),
+        ("mode", "signal"),
+    )
+
+    def __init__(self):
+        """Create MACD lines and register warmup period."""
+        self.addminperiod(
+            max(int(self.p.fast_ema_period), int(self.p.slow_ema_period))
+            + int(self.p.signal_period)
+            + 3
+        )
+        self.macd_open = MACD(
+            self.data.open,
+            period_me1=int(self.p.fast_ema_period),
+            period_me2=int(self.p.slow_ema_period),
+            period_signal=int(self.p.signal_period),
+        )
+        self.macd_high = MACD(
+            self.data.high,
+            period_me1=int(self.p.fast_ema_period),
+            period_me2=int(self.p.slow_ema_period),
+            period_signal=int(self.p.signal_period),
+        )
+        self.macd_low = MACD(
+            self.data.low,
+            period_me1=int(self.p.fast_ema_period),
+            period_me2=int(self.p.slow_ema_period),
+            period_signal=int(self.p.signal_period),
+        )
+        self.macd_close = MACD(
+            self.data.close,
+            period_me1=int(self.p.fast_ema_period),
+            period_me2=int(self.p.slow_ema_period),
+            period_signal=int(self.p.signal_period),
+        )
+
+    def _value(self, macd_obj):
+        return float(macd_obj.signal[0]) if self.p.mode == "signal" else float(macd_obj.macd[0])
+
+    def next(self):
+        """Populate output candle components and derive color state per bar."""
+        open_value = self._value(self.macd_open)
+        high_value = self._value(self.macd_high)
+        low_value = self._value(self.macd_low)
+        close_value = self._value(self.macd_close)
+        self.lines.macd_open[0] = open_value
+        self.lines.macd_high[0] = high_value
+        self.lines.macd_low[0] = low_value
+        self.lines.macd_close[0] = close_value
+        if open_value < close_value:
+            color = 2
+        elif open_value > close_value:
+            color = 0
+        else:
+            color = 1
+        self.lines.color[0] = color

backtrader/indicators/contrib/malr_indicator.py

@@ -0,0 +1,77 @@
+#!/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,
+    StandardDeviation,
+    WeightedMovingAverage,
+)
+
+__all__ = [
+    "MalrIndicator",
+]
+
+
+class MalrIndicator(Indicator):
+    """Compute MALR trend channels used for breakout-trigger detection."""
+
+    lines = ("malr", "malrh", "malrl", "malrhh", "malrll")
+    params = (
+        ("ma_period", 120),
+        ("ma_shift", 0),
+        ("channel_reversal", 1.1),
+        ("channel_breakout", 1.1),
+    )
+
+    def __init__(self):
+        """Initialize MA basis and channel deviation buffers."""
+        sma = SimpleMovingAverage(self.data.close, period=self.p.ma_period)
+        lwma = WeightedMovingAverage(self.data.close, period=self.p.ma_period)
+        self._ff = 3.0 * lwma - 2.0 * sma
+        diff = self.data.close - self._ff
+        self._std = StandardDeviation(diff, period=self.p.ma_period)
+        self.addminperiod(int(self.p.ma_period) * 2 + 3)
+
+    def next(self):
+        """Calculate MALR center and channel boundaries for the current bar."""
+        ff = float(self._ff[0])
+        std = float(self._std[0])
+        t1 = std * float(self.p.channel_reversal)
+        t2 = std * (float(self.p.channel_reversal) + float(self.p.channel_breakout))
+        self.lines.malr[0] = ff
+        self.lines.malrh[0] = ff + t1
+        self.lines.malrl[0] = ff - t1
+        self.lines.malrhh[0] = ff + t2
+        self.lines.malrll[0] = ff - t2
+
+    def once(self, start, end):
+        """Vectorized computation path for backtesting efficiency."""
+        ff_array = self._ff.array
+        std_array = self._std.array
+        lines = (
+            self.lines.malr.array,
+            self.lines.malrh.array,
+            self.lines.malrl.array,
+            self.lines.malrhh.array,
+            self.lines.malrll.array,
+        )
+        for line in lines:
+            while len(line) < end:
+                line.append(float("nan"))
+
+        actual_end = min(end, len(ff_array), len(std_array))
+        for i in range(start, actual_end):
+            ff = float(ff_array[i])
+            std = float(std_array[i])
+            t1 = std * float(self.p.channel_reversal)
+            t2 = std * (float(self.p.channel_reversal) + float(self.p.channel_breakout))
+            lines[0][i] = ff
+            lines[1][i] = ff + t1
+            lines[2][i] = ff - t1
+            lines[3][i] = ff + t2
+            lines[4][i] = ff - t2

backtrader/indicators/contrib/momentum_candle_sign_indicator.py

@@ -0,0 +1,51 @@
+#!/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 (
+    ATR,
+    Indicator,
+    Momentum,
+)
+
+__all__ = [
+    "MomentumCandleSignIndicator",
+]
+
+
+class MomentumCandleSignIndicator(Indicator):
+    """Emit ATR-offset buy/sell dots on open/close momentum crossovers."""
+
+    lines = ("sell_signal", "buy_signal", "momentum_open", "momentum_close")
+    params = (
+        ("period", 12),
+        ("atr_period", 15),
+    )
+
+    def __init__(self):
+        """Build open/close momentum and ATR sub-indicators and set min period."""
+        self.addminperiod(max(int(self.p.period), int(self.p.atr_period)) + 3)
+        self.momentum_open = Momentum(self.data.open, period=int(self.p.period))
+        self.momentum_close = Momentum(self.data.close, period=int(self.p.period))
+        self.atr = ATR(self.data, period=int(self.p.atr_period))
+
+    def next(self):
+        """Detect momentum crossovers and place ATR-offset signal dots."""
+        self.lines.sell_signal[0] = 0.0
+        self.lines.buy_signal[0] = 0.0
+        self.lines.momentum_open[0] = float(self.momentum_open[0])
+        self.lines.momentum_close[0] = float(self.momentum_close[0])
+        if len(self.data) < 2:
+            return
+        prev_open = float(self.momentum_open[-1])
+        prev_close = float(self.momentum_close[-1])
+        curr_open = float(self.momentum_open[0])
+        curr_close = float(self.momentum_close[0])
+        atr = float(self.atr[0])
+        if prev_open >= prev_close and curr_open < curr_close:
+            self.lines.buy_signal[0] = float(self.data.low[0]) - atr * 3.0 / 8.0
+        if prev_open <= prev_close and curr_open > curr_close:
+            self.lines.sell_signal[0] = float(self.data.high[0]) + atr * 3.0 / 8.0

backtrader/indicators/contrib/moving_average_fn_indicator.py

@@ -0,0 +1,139 @@
+#!/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 re
+from collections import deque
+from pathlib import Path
+
+from .. import Indicator
+
+__all__ = [
+    "MovingAverageFNIndicator",
+]
+
+
+SOURCE_MQ5 = (
+    Path(__file__).resolve().parents[2]
+    / "ea"
+    / "1276_Exp_MovingAverage_FN"
+    / "movingaverage_fn.mq5"
+)
+
+
+def resolve_price_line(data, mode):
+    """Return the price line selected by an MT5 applied-price mode.
+
+    Args:
+        data: The data feed providing OHLC lines.
+        mode: Applied-price mode name (e.g. ``price_close``, ``price_median``).
+
+    Returns:
+        The line or line expression for the requested applied price; defaults
+        to the close line for unrecognized modes.
+    """
+    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
+
+
+def load_fn_coefficients(filter_name="N44"):
+    """Parse FIR filter coefficients for a named filter from the MQ5 source.
+
+    Args:
+        filter_name: Filter case name (e.g. ``N44``) to extract.
+
+    Returns:
+        List of float coefficients ordered by price-series offset; ``[1.0]`` if
+        the source file is missing.
+
+    Raises:
+        ValueError: If the filter or the following case marker is not found.
+    """
+    if not SOURCE_MQ5.exists():
+        return [1.0]
+    raw = SOURCE_MQ5.read_bytes()
+    candidates = []
+    for encoding in ("utf-16", "utf-16-le", "utf-8", "latin-1"):
+        candidates.append(raw.decode(encoding, errors="ignore"))
+    text = ""
+    for candidate in candidates:
+        normalized = candidate.replace("\x00", "")
+        if f"case {filter_name}:" in normalized:
+            text = normalized
+            break
+    if not text:
+        text = raw.decode("latin-1", errors="ignore").replace("\x00", "")
+    start = text.find(f"case {filter_name}:")
+    if start == -1:
+        raise ValueError(f"Filter {filter_name} not found in {SOURCE_MQ5}")
+    next_case = re.search(r"\n\s*case\s+N\d+:", text[start + 1 :])
+    if not next_case:
+        raise ValueError(f"Could not locate next filter after {filter_name}")
+    block = text[start : start + 1 + next_case.start()]
+    matches = re.findall(
+        r"([+-]?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?)\*PriceSeries\(Price,index(?:-(\d+))?", block
+    )
+    coeff_map = {int(offset or "0"): float(coef) for coef, offset in matches}
+    coeffs = [coeff_map[i] for i in range(max(coeff_map) + 1)]
+    return coeffs
+
+
+class MovingAverageFNIndicator(Indicator):
+    """FIR moving average built from named filter coefficients plus smoothing."""
+
+    lines = ("mafn",)
+    params = (
+        ("filter_number", "N44"),
+        ("xma_method", "jjma"),
+        ("xlength", 12),
+        ("xphase", 15),
+        ("ipc", "price_close"),
+        ("price_shift", 0),
+    )
+
+    def __init__(self):
+        """Load the filter coefficients and set up the smoothing buffer."""
+        self._coeffs = load_fn_coefficients(self.p.filter_number)
+        self._price_line = resolve_price_line(self.data, self.p.ipc)
+        self._smooth_values = deque(maxlen=max(1, int(self.p.xlength)))
+        self.addminperiod(len(self._coeffs) + self.p.xlength + 5)
+
+    def _smooth_filtered(self, value):
+        self._smooth_values.append(value)
+        values = list(self._smooth_values)
+        if not values:
+            return value
+        mode = str(self.p.xma_method).lower()
+        if mode in {"sma", "mode_sma"}:
+            return sum(values) / len(values)
+        if mode in {"ema", "mode_ema"}:
+            alpha = 2.0 / (len(values) + 1.0)
+            ema = values[0]
+            for item in values[1:]:
+                ema = alpha * item + (1.0 - alpha) * ema
+            return ema
+        weights = list(range(1, len(values) + 1))
+        weight_sum = float(sum(weights))
+        return sum(v * w for v, w in zip(values, weights)) / weight_sum
+
+    def next(self):
+        """Convolve the filter coefficients with price and emit the smoothed value."""
+        filtered = 0.0
+        for offset, coef in enumerate(self._coeffs):
+            filtered += coef * float(self._price_line[-offset])
+        self.lines.mafn[0] = self._smooth_filtered(filtered) + float(self.p.price_shift)