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

backtrader/indicators/contrib/center_of_gravity_indicator.py

@@ -0,0 +1,70 @@
+#!/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 (
+    EMA,
+    SMA,
+    Indicator,
+    WeightedMovingAverage,
+)
+
+__all__ = [
+    "CenterOfGravityIndicator",
+]
+
+
+class CenterOfGravityIndicator(Indicator):
+    """Center of Gravity indicator composed of price selection and smoothed center line."""
+
+    lines = (
+        "center",
+        "signal",
+        "state",
+    )
+    params = (
+        ("period", 10),
+        ("smooth_period", 3),
+        ("ma_method", "sma"),
+        ("applied_price", "close"),
+        ("point", 0.01),
+    )
+
+    def __init__(self):
+        """Initialize base MAs and derived center/signal/state lines."""
+        ma_cls = SMA if str(self.p.ma_method).lower() == "sma" else EMA
+        price = self._price_line()
+        sma = SMA(price, period=self.p.period)
+        lwma = WeightedMovingAverage(price, period=self.p.period)
+        self.lines.center = (sma * lwma) / self.p.point
+        self.lines.signal = ma_cls(self.lines.center, period=self.p.smooth_period)
+        self.addminperiod(self.p.period + self.p.smooth_period + 5)
+
+    def _price_line(self):
+        mode = str(self.p.applied_price).lower()
+        if mode == "open":
+            return self.data.open
+        if mode == "high":
+            return self.data.high
+        if mode == "low":
+            return self.data.low
+        if mode == "median":
+            return (self.data.high + self.data.low) / 2.0
+        if mode == "typical":
+            return (self.data.high + self.data.low + self.data.close) / 3.0
+        if mode == "weighted":
+            return (self.data.high + self.data.low + self.data.close + self.data.close) / 4.0
+        if mode == "simpl":
+            return (self.data.open + self.data.close) / 2.0
+        if mode == "quarter":
+            return (self.data.high + self.data.low + self.data.open + self.data.close) / 4.0
+        return self.data.close
+
+    def next(self):
+        """Compute the state classification for the current bar."""
+        self.lines.state[0] = (
+            2.0 if float(self.lines.center[0]) < float(self.lines.signal[0]) else 1.0
+        )

backtrader/indicators/contrib/cg_oscillator.py

@@ -0,0 +1,40 @@
+#!/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__ = [
+    "CGOscillator",
+]
+
+
+class CGOscillator(Indicator):
+    """Center of Gravity (CG) oscillator with a one-bar-lagged signal line.
+
+    The main line is a length-weighted ratio of recent median prices, shifted
+    to centre around zero. The signal line is the previous bar's main value.
+    """
+
+    lines = ("main", "signal")
+    params = (("length", 10),)
+
+    def __init__(self):
+        """Set the minimum period and precompute the CG centring shift."""
+        self.addminperiod(int(self.p.length) + 1)
+        self.cgshift = (float(self.p.length) + 1.0) / 2.0
+
+    def next(self):
+        """Compute the CG main and lagged signal value for the current bar."""
+        num = 0.0
+        denom = 0.0
+        length = int(self.p.length)
+        for count in range(length):
+            price = (float(self.data.high[-count]) + float(self.data.low[-count])) / 2.0
+            num += (1.0 + count) * price
+            denom += price
+        self.lines.main[0] = (-num / denom + self.cgshift) if denom else 0.0
+        self.lines.signal[0] = self.lines.main[-1] if len(self) > 1 else 0.0

backtrader/indicators/contrib/close_line_cci.py

@@ -0,0 +1,38 @@
+#!/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,
+    MeanDev,
+    MovAv,
+)
+
+__all__ = [
+    "CloseLineCCI",
+]
+
+
+class CloseLineCCI(Indicator):
+    """Custom CCI indicator designed to evaluate simple single close lines instead of HLC.
+
+    Lines:
+        cci (Line): Output Commodity Channel Index line.
+    """
+
+    lines = ("cci",)
+    params = (
+        ("period", 20),
+        ("factor", 0.015),
+        ("movav", MovAv.Simple),
+    )
+
+    def __init__(self):
+        """Initialize and calculate close-based CCI indicator components."""
+        tp = self.data
+        tpmean = self.p.movav(tp, period=self.p.period)
+        meandev = MeanDev(tp, tpmean, period=self.p.period)
+        self.lines.cci = (tp - tpmean) / (self.p.factor * meandev)

backtrader/indicators/contrib/close_price_fractals.py

@@ -0,0 +1,47 @@
+#!/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__ = [
+    "ClosePriceFractals",
+]
+
+
+class ClosePriceFractals(Indicator):
+    """Custom 5-period Fractal indicator calculated solely on closing prices.
+
+    Lines:
+        upper: Contains fractal peak closing price if upper fractal is formed.
+        lower: Contains fractal valley closing price if lower fractal is formed.
+    """
+
+    lines = ("upper", "lower")
+
+    def __init__(self):
+        """Initialize the indicator with a minimum period of 5 bars."""
+        self.addminperiod(5)
+
+    def next(self):
+        """Determine if a peak or valley fractal forms on bar -2 based on close prices."""
+        self.lines.upper[0] = float("nan")
+        self.lines.lower[0] = float("nan")
+        candidate = float(self.data.close[-2])
+        if (
+            candidate > float(self.data.close[-3])
+            and candidate > float(self.data.close[-4])
+            and candidate >= float(self.data.close[-1])
+            and candidate >= float(self.data.close[0])
+        ):
+            self.lines.upper[0] = candidate
+        if (
+            candidate < float(self.data.close[-3])
+            and candidate < float(self.data.close[-4])
+            and candidate <= float(self.data.close[-1])
+            and candidate <= float(self.data.close[0])
+        ):
+            self.lines.lower[0] = candidate

backtrader/indicators/contrib/color3rd_gen_xma_indicator.py

@@ -0,0 +1,122 @@
+#!/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,
+    If,
+    Indicator,
+    SimpleMovingAverage,
+    SmoothedMovingAverage,
+    WeightedMovingAverage,
+)
+
+__all__ = [
+    "Color3rdGenXMAIndicator",
+]
+
+
+def resolve_ma_class(name):
+    """Map a moving-average name to its backtrader indicator class.
+
+    Args:
+        name: MA type name (e.g. ``sma``, ``ema``, ``smma`` or MT5-style
+            ``mode_*`` variants); several smoothing variants map to EMA.
+
+    Returns:
+        The matching backtrader moving-average indicator class, defaulting to
+        the weighted moving average for unrecognized names.
+    """
+    mode = str(name).lower()
+    if mode in {"mode_sma", "sma"}:
+        return SimpleMovingAverage
+    if mode in {
+        "mode_ema",
+        "ema",
+        "mode_jjma",
+        "jjma",
+        "mode_jurx",
+        "jurx",
+        "mode_parma",
+        "parma",
+        "mode_t3",
+        "t3",
+        "mode_vidya",
+        "vidya",
+        "mode_ama",
+        "ama",
+    }:
+        return ExponentialMovingAverage
+    if mode in {"mode_smma", "smma"}:
+        return SmoothedMovingAverage
+    return WeightedMovingAverage
+
+
+def resolve_price_line(data, mode):
+    """Return the applied-price line for a data feed given a price mode.
+
+    Args:
+        data: The data feed providing OHLC lines.
+        mode: Applied-price selector (e.g. ``price_close``, ``price_typical``,
+            ``price_weighted`` or their short forms).
+
+    Returns:
+        A line expression for the selected applied price, defaulting to the
+        typical price for unrecognized modes.
+    """
+    price_mode = str(mode).lower()
+    if price_mode in {"price_close", "close"}:
+        return data.close
+    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 (2.0 * data.close + data.high + data.low) / 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
+    return (data.high + data.low + data.close) / 3.0
+
+
+class Color3rdGenXMAIndicator(Indicator):
+    """Third-generation (reduced-lag) moving average with a slope color.
+
+    Combines a base moving average with a re-smoothed version using a
+    lambda-derived alpha to cut lag, exposing the resulting line on ``value`` and
+    a ``color`` line marking whether it is rising (2), falling (0) or flat (1).
+    """
+
+    lines = ("value", "color")
+    params = (
+        ("xma_method", "ema"),
+        ("xlength", 50),
+        ("xphase", 15),
+        ("ipc", "price_typical"),
+        ("price_shift", 0),
+    )
+
+    def __init__(self):
+        """Build the two-stage moving average and the value/color lines."""
+        price = resolve_price_line(self.data, self.p.ipc)
+        ma_cls = resolve_ma_class(self.p.xma_method)
+        slength = max(1, int(self.p.xlength) * 2)
+        self._x1 = ma_cls(price, period=slength)
+        self._x2 = ma_cls(self._x1, period=max(1, int(self.p.xlength)))
+        lam = float(slength) / max(1.0, float(self.p.xlength))
+        self._alpha = lam * (slength - 1.0) / max(1e-9, (slength - lam))
+        self._dprice_shift = float(self.p.price_shift) * 0.00001
+        value = (self._alpha + 1.0) * self._x1 - self._alpha * self._x2 + self._dprice_shift
+        self.lines.value = value
+        self.lines.color = If(value > value(-1), 2.0, If(value < value(-1), 0.0, 1.0))
+        self.addminperiod(slength + int(self.p.xlength) + 5)

backtrader/indicators/contrib/color_bb_candles_indicator.py

@@ -0,0 +1,108 @@
+#!/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 (
+    EMA,
+    SMA,
+    Indicator,
+    StandardDeviation,
+)
+
+__all__ = [
+    "ColorBBCandlesIndicator",
+]
+
+
+class ColorBBCandlesIndicator(Indicator):
+    """Color BBCandles indicator producing zone states from volatility envelopes.
+
+    The indicator computes a moving-average center line and standard deviation
+    bands with multiple deviation levels, then emits a discrete state 0..10.
+    """
+
+    lines = (
+        "state",
+        "price_line",
+        "mid",
+    )
+    params = (
+        ("period", 100),
+        ("deviation1", 1.0),
+        ("deviation2", 1.5),
+        ("deviation3", 2.0),
+        ("deviation4", 2.5),
+        ("deviation5", 3.0),
+        ("ma_method", "ema"),
+        ("applied_price", "close"),
+    )
+
+    def __init__(self):
+        """Prepare price line selector and required indicator buffers."""
+        ma_cls = EMA if str(self.p.ma_method).lower() == "ema" else SMA
+        self.price = self._price_line()
+        self.lines.price_line = self.price
+        self.lines.mid = ma_cls(self.price, period=self.p.period)
+        self.stddev = StandardDeviation(self.price, period=self.p.period)
+        self.addminperiod(self.p.period + 5)
+
+    def _price_line(self):
+        mode = str(self.p.applied_price).lower()
+        if mode == "open":
+            return self.data.open
+        if mode == "high":
+            return self.data.high
+        if mode == "low":
+            return self.data.low
+        if mode == "median":
+            return (self.data.high + self.data.low) / 2.0
+        if mode == "typical":
+            return (self.data.high + self.data.low + self.data.close) / 3.0
+        if mode == "weighted":
+            return (self.data.high + self.data.low + self.data.close + self.data.close) / 4.0
+        if mode == "simpl":
+            return (self.data.open + self.data.close) / 2.0
+        if mode == "quarter":
+            return (self.data.high + self.data.low + self.data.open + self.data.close) / 4.0
+        return self.data.close
+
+    def next(self):
+        """Evaluate the current bar and emit the normalized volatility state."""
+        price = float(self.price[0])
+        mid = float(self.lines.mid[0])
+        stdev = float(self.stddev[0])
+        up1 = mid + stdev * self.p.deviation1
+        up2 = mid + stdev * self.p.deviation2
+        up3 = mid + stdev * self.p.deviation3
+        up4 = mid + stdev * self.p.deviation4
+        up5 = mid + stdev * self.p.deviation5
+        dn1 = mid - stdev * self.p.deviation1
+        dn2 = mid - stdev * self.p.deviation2
+        dn3 = mid - stdev * self.p.deviation3
+        dn4 = mid - stdev * self.p.deviation4
+        dn5 = mid - stdev * self.p.deviation5
+        state = 5.0
+        if price > up5:
+            state = 10.0
+        elif price > up4:
+            state = 9.0
+        elif price > up3:
+            state = 8.0
+        elif price > up2:
+            state = 7.0
+        elif price > up1:
+            state = 6.0
+        elif price < dn5:
+            state = 0.0
+        elif price < dn4:
+            state = 1.0
+        elif price < dn3:
+            state = 2.0
+        elif price < dn2:
+            state = 3.0
+        elif price < dn1:
+            state = 4.0
+        self.lines.state[0] = state

backtrader/indicators/contrib/color_coppock_indicator.py

@@ -0,0 +1,157 @@
+#!/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,
+    WeightedMovingAverage,
+)
+
+__all__ = [
+    "ColorCoppockIndicator",
+]
+
+
+def resolve_ma_class(name):
+    """Map configured MA mode strings to Backtrader MA classes.
+
+    Args:
+        name: MA mode token from configuration.
+
+    Returns:
+        MA indicator class.
+    """
+    mode = str(name).lower()
+    if mode in {"mode_sma", "sma"}:
+        return SimpleMovingAverage
+    if mode in {
+        "mode_ema",
+        "ema",
+        "mode_jjma",
+        "jjma",
+        "mode_jurx",
+        "jurx",
+        "mode_parma",
+        "parma",
+        "mode_t3",
+        "t3",
+        "mode_vidya",
+        "vidya",
+        "mode_ama",
+        "ama",
+    }:
+        return ExponentialMovingAverage
+    if mode in {"mode_smma", "smma"}:
+        return SmoothedMovingAverage
+    return WeightedMovingAverage
+
+
+def resolve_price_line(data, mode):
+    """Resolve a price selector key to a data line for indicator input.
+
+    Args:
+        data: Backtrader data feed.
+        mode: Price selector token.
+
+    Returns:
+        Price series corresponding to the requested selector.
+    """
+    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 (2.0 * data.close + data.high + data.low) / 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
+    return data.close
+
+
+class ColorCoppockIndicator(Indicator):
+    """Compute Coppock oscillator value and its directional color state."""
+
+    lines = ("value", "color")
+    params = (
+        ("roc1_period", 14),
+        ("roc2_period", 10),
+        ("xma_method", "lwma"),
+        ("xma_period", 12),
+        ("xma_phase", 100),
+        ("applied_price", "price_close"),
+    )
+
+    def __init__(self):
+        """Initialize ROC sum and the final smoothing moving average."""
+        price_line = resolve_price_line(self.data, self.p.applied_price)
+        roc1 = (price_line - price_line(-int(self.p.roc1_period))) / price_line(
+            -int(self.p.roc1_period)
+        )
+        roc2 = (price_line - price_line(-int(self.p.roc2_period))) / price_line(
+            -int(self.p.roc2_period)
+        )
+        self._roc_sum = roc1 + roc2
+        ma_cls = resolve_ma_class(self.p.xma_method)
+        self._smooth = ma_cls(self._roc_sum, period=max(1, int(self.p.xma_period)))
+        self.addminperiod(
+            max(int(self.p.roc1_period), int(self.p.roc2_period)) + int(self.p.xma_period) + 3
+        )
+
+    def next(self):
+        """Update value and color for the current bar."""
+        value = float(self._smooth[0])
+        prev = float(self._smooth[-1])
+        self.lines.value[0] = value
+        color = 2
+        if value > 0:
+            if value > prev:
+                color = 4
+            elif value < prev:
+                color = 3
+        if value < 0:
+            if value < prev:
+                color = 0
+            elif value > prev:
+                color = 1
+        self.lines.color[0] = color
+
+    def once(self, start, end):
+        """Fill value/color lines for preloaded bars in a batch run."""
+        smooth = self._smooth.array
+        value_line = self.lines.value.array
+        color_line = self.lines.color.array
+        for line in (value_line, color_line):
+            while len(line) < end:
+                line.append(float("nan"))
+
+        actual_end = min(end, len(smooth))
+        for i in range(start, actual_end):
+            value = float(smooth[i])
+            prev = float(smooth[i - 1]) if i > 0 else value
+            color = 2
+            if value > 0:
+                if value > prev:
+                    color = 4
+                elif value < prev:
+                    color = 3
+            if value < 0:
+                if value < prev:
+                    color = 0
+                elif value > prev:
+                    color = 1
+            value_line[i] = value
+            color_line[i] = color

backtrader/indicators/contrib/color_hma.py

@@ -0,0 +1,71 @@
+#!/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__ = [
+    "ColorHMA",
+]
+
+
+def _weighted_ma(values):
+    weights = list(range(1, len(values) + 1))
+    denominator = float(sum(weights))
+    return sum(value * weight for value, weight in zip(values, weights)) / denominator
+
+
+class ColorHMA(Indicator):
+    """Hull Moving Average line plus its slope-direction ("color") line."""
+
+    lines = ("hma", "direction")
+    params = (("period", 13),)
+
+    def __init__(self):
+        """Derive the half, full, and sqrt periods and set the warmup window."""
+        self.period = max(int(self.p.period), 2)
+        self.half_period = max(int(math.floor(self.period / 2.0)), 1)
+        self.sqrt_period = max(int(math.floor(math.sqrt(self.period))), 1)
+        self._dma_history = []
+        self.addminperiod(self.period + self.sqrt_period + 2)
+
+    def _window(self, length):
+        return [float(self.data[-idx]) for idx in range(length - 1, -1, -1)]
+
+    def next(self):
+        """Compute the HMA value for this bar and update its slope direction."""
+        if len(self.data) < self.period:
+            current = (
+                float(self.data.close[0]) if hasattr(self.data, "close") else float(self.data[0])
+            )
+            self._dma_history.append(current)
+            self.l.hma[0] = current
+            self.l.direction[0] = 0.0
+            return
+
+        half_values = self._window(self.half_period)
+        full_values = self._window(self.period)
+        lwma_half = _weighted_ma(half_values)
+        lwma_full = _weighted_ma(full_values)
+        dma = 2.0 * lwma_half - lwma_full
+        self._dma_history.append(dma)
+
+        if len(self._dma_history) >= self.sqrt_period:
+            hma = _weighted_ma(self._dma_history[-self.sqrt_period :])
+        else:
+            hma = dma
+
+        self.l.hma[0] = hma
+        if len(self) < 2:
+            self.l.direction[0] = 0.0
+        elif self.l.hma[-1] < self.l.hma[0]:
+            self.l.direction[0] = 1.0
+        elif self.l.hma[-1] > self.l.hma[0]:
+            self.l.direction[0] = -1.0
+        else:
+            self.l.direction[0] = self.l.direction[-1]