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

backtrader/indicators/contrib/j_tpo_proxy.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__ = [
+    "JTpoProxy",
+]
+
+
+class JTpoProxy(Indicator):
+    """Proxy oscillator measuring close deviation from its moving average."""
+
+    lines = ("value",)
+    params = (("period", 14),)
+
+    def __init__(self):
+        """Set up the SMA and minimum period from the period parameter."""
+        self.period = max(2, int(self.p.period))
+        self.ma = SimpleMovingAverage(self.data.close, period=self.period)
+        self.addminperiod(self.period + 1)
+
+    def next(self):
+        """Compute the current close-minus-SMA deviation value."""
+        self.lines.value[0] = float(self.data.close[0]) - float(self.ma[0])

backtrader/indicators/contrib/jma_slope_indicator.py

@@ -0,0 +1,73 @@
+#!/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,
+)
+
+__all__ = [
+    "JMASlopeIndicator",
+]
+
+
+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_median``,
+            ``price_typical`` or their short forms).
+
+    Returns:
+        A line expression for the selected applied price, defaulting to the
+        close 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 (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 JMASlopeIndicator(Indicator):
+    """Slope of a Jurik-style moving average with a rising/falling color.
+
+    Approximates the JMA with an EMA of the applied price, then exposes its
+    bar-over-bar change on the ``value`` line and a ``color`` line marking
+    whether the slope is positive (4), negative (0) or flat (2).
+    """
+
+    lines = ("value", "color")
+    params = (
+        ("jlength", 14),
+        ("jphase", 0),
+        ("ipc", "price_close"),
+    )
+
+    def __init__(self):
+        """Build the JMA proxy and its slope/color lines; set the min period."""
+        price_line = resolve_price_line(self.data, self.p.ipc)
+        self._jma = ExponentialMovingAverage(price_line, period=max(1, int(self.p.jlength)))
+        delta = self._jma - self._jma(-1)
+        self.lines.value = delta
+        self.lines.color = If(delta > 0.0, 4.0, If(delta < 0.0, 0.0, 2.0))
+        self.addminperiod(32 + int(self.p.jlength))

backtrader/indicators/contrib/kalman_filter_indicator.py

@@ -0,0 +1,119 @@
+#!/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__ = [
+    "KalmanFilterIndicator",
+]
+
+
+APPLIED_PRICE_MAP = {
+    "PRICE_CLOSE": 0,
+    "PRICE_OPEN": 1,
+    "PRICE_HIGH": 2,
+    "PRICE_LOW": 3,
+    "PRICE_MEDIAN": 4,
+    "PRICE_TYPICAL": 5,
+    "PRICE_WEIGHTED": 6,
+    "PRICE_OPEN_CLOSE": 8,
+    "PRICE_OHLC_AVERAGE": 9,
+    "PRICE_DEMARK": 10,
+    "PRICE_AVERAGE_DEMARK": 11,
+}
+
+
+SIGNAL_MODE_MAP = {
+    "Trend": 0,
+    "Kalman": 1,
+}
+
+
+class KalmanFilterIndicator(Indicator):
+    """Kalman-style adaptive price filter producing value and direction lines."""
+
+    lines = ("value", "color_idx")
+    params = (
+        ("k", 1.0),
+        ("applied_price", "PRICE_WEIGHTED"),
+        ("signal_mode", "Kalman"),
+        ("price_shift", 0),
+        ("point", 0.01),
+    )
+
+    def __init__(self):
+        """Initialize internal state and precompute coefficients."""
+        self.addminperiod(2)
+        self._velocity = 0.0
+        self._sqrt100 = math.sqrt(float(self.p.k) / 100.0) if float(self.p.k) > 0 else 0.0
+        self._k100 = float(self.p.k) / 100.0
+        self._price_shift = float(self.p.point) * float(self.p.price_shift)
+
+    def _mode_value(self, mapping, value, default_value):
+        if isinstance(value, str):
+            return mapping.get(value, default_value)
+        return int(value)
+
+    def _price(self, ago=0):
+        mode = self._mode_value(APPLIED_PRICE_MAP, self.p.applied_price, 0)
+        open_ = float(self.data.open[ago])
+        high = float(self.data.high[ago])
+        low = float(self.data.low[ago])
+        close = float(self.data.close[ago])
+        if mode == 0:
+            return close
+        if mode == 1:
+            return open_
+        if mode == 2:
+            return high
+        if mode == 3:
+            return low
+        if mode == 4:
+            return (high + low) / 2.0
+        if mode == 5:
+            return (close + high + low) / 3.0
+        if mode == 6:
+            return (2.0 * close + high + low) / 4.0
+        if mode == 8:
+            return (open_ + close) / 2.0
+        if mode == 9:
+            return (open_ + close + high + low) / 4.0
+        if mode == 10:
+            if close > open_:
+                return high
+            if close < open_:
+                return low
+            return close
+        if mode == 11:
+            if close > open_:
+                return (high + close) / 2.0
+            if close < open_:
+                return (low + close) / 2.0
+            return close
+        return close
+
+    def next(self):
+        """Update the filtered value and direction for each bar."""
+        price = self._price(0)
+        if len(self) == 1:
+            self.lines.value[0] = price
+            self.lines.color_idx[0] = 0.0
+            self._velocity = 0.0
+            return
+        prev_value = float(self.lines.value[-1])
+        distance = price - prev_value
+        error = prev_value + distance * self._sqrt100
+        self._velocity += distance * self._k100
+        value = error + self._velocity + self._price_shift
+        self.lines.value[0] = value
+        signal_mode = self._mode_value(SIGNAL_MODE_MAP, self.p.signal_mode, 1)
+        if signal_mode == 0:
+            self.lines.color_idx[0] = 0.0 if prev_value > value else 1.0
+        else:
+            self.lines.color_idx[0] = 1.0 if self._velocity > 0 else 0.0

backtrader/indicators/contrib/kalman_filter_line.py

@@ -0,0 +1,127 @@
+#!/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__ = [
+    "KalmanFilterLine",
+    "KalmanFilterCandleIndicator",
+]
+
+
+def weighted_price(data, ago=0):
+    """Return the weighted price ``(high + low + 2*close) / 4`` for a bar.
+
+    Args:
+        data: Data feed exposing high/low/close lines.
+        ago: Bar offset (0 is the current bar).
+
+    Returns:
+        The weighted price as a float.
+    """
+    return (float(data.high[ago]) + float(data.low[ago]) + 2.0 * float(data.close[ago])) / 4.0
+
+
+def indicator_source_price(data, ago=0):
+    """Return the indicator source price for a bar or scalar line.
+
+    Args:
+        data: Data feed with OHLC lines, or a single value line.
+        ago: Bar offset (0 is the current bar).
+
+    Returns:
+        The weighted price when OHLC lines are present, otherwise the line's
+        value at ``ago``.
+    """
+    if all(hasattr(data, attr) for attr in ("high", "low", "close")):
+        return weighted_price(data, ago)
+    return float(data[ago])
+
+
+class KalmanFilterLine(Indicator):
+    """Single-series Kalman-style adaptive filter with a velocity term."""
+
+    lines = ("value", "color")
+    params = (
+        ("k", 1.0),
+        ("price_shift_points", 0.0),
+    )
+
+    def __init__(self):
+        """Set the minimum period and initialize filter state."""
+        self.addminperiod(2)
+        self._initialized = False
+        self._velocity = 0.0
+        self.sqrt100 = math.sqrt(float(self.p.k) / 100.0)
+        self.k100 = float(self.p.k) / 100.0
+
+    def next(self):
+        """Advance the filter one bar and emit the value and color lines."""
+        source_price = indicator_source_price(self.data, 0)
+        if not self._initialized:
+            self.lines.value[0] = source_price + float(self.p.price_shift_points)
+            self.lines.color[0] = 0
+            self._velocity = 0.0
+            self._initialized = True
+            return
+        prev_value = float(self.lines.value[-1]) - float(self.p.price_shift_points)
+        distance = source_price - prev_value
+        error = prev_value + distance * self.sqrt100
+        self._velocity += distance * self.k100
+        filtered = error + self._velocity + float(self.p.price_shift_points)
+        self.lines.value[0] = filtered
+        self.lines.color[0] = 1 if self._velocity > 0 else 0
+
+
+class KalmanFilterCandleIndicator(Indicator):
+    """Builds Kalman-filtered OHLC candles and a bull/bear color line."""
+
+    lines = ("k_open", "k_high", "k_low", "k_close", "color")
+    params = (
+        ("k", 1.0),
+        ("point", 0.01),
+        ("price_shift", 0),
+    )
+
+    def __init__(self):
+        """Construct per-OHLC Kalman filter lines and set the minimum period."""
+        price_shift_points = float(self.p.point) * float(self.p.price_shift)
+        self.k_open_line = KalmanFilterLine(
+            self.data.open, k=self.p.k, price_shift_points=price_shift_points
+        )
+        self.k_high_line = KalmanFilterLine(
+            self.data.high, k=self.p.k, price_shift_points=price_shift_points
+        )
+        self.k_low_line = KalmanFilterLine(
+            self.data.low, k=self.p.k, price_shift_points=price_shift_points
+        )
+        self.k_close_line = KalmanFilterLine(
+            self.data.close, k=self.p.k, price_shift_points=price_shift_points
+        )
+        self.addminperiod(3)
+
+    def next(self):
+        """Assemble the filtered candle and classify its bull/bear color."""
+        o = float(self.k_open_line.value[0])
+        h = max(float(self.k_high_line.value[0]), o)
+        low_price = min(float(self.k_low_line.value[0]), o)
+        c = float(self.k_close_line.value[0])
+        h = max(h, c)
+        low_price = min(low_price, c)
+        self.lines.k_open[0] = o
+        self.lines.k_high[0] = h
+        self.lines.k_low[0] = low_price
+        self.lines.k_close[0] = c
+        if o < c:
+            color = 2
+        elif o > c:
+            color = 0
+        else:
+            color = 1
+        self.lines.color[0] = color

backtrader/indicators/contrib/kama_indicator.py

@@ -0,0 +1,150 @@
+#!/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__ = [
+    "KAMAIndicator",
+    "ColorMomentumAMAIndicator",
+]
+
+
+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
+    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 KAMAIndicator(Indicator):
+    """Kaufman Adaptive Moving Average with both event and vectorized modes."""
+
+    lines = ("ama",)
+    params = (
+        ("period", 9),
+        ("fast_period", 2),
+        ("slow_period", 30),
+        ("power", 2.0),
+    )
+
+    def __init__(self):
+        """Set the minimum period required before emitting values."""
+        self.addminperiod(max(self.p.period, self.p.slow_period) + 2)
+
+    def next(self):
+        """Compute the adaptive moving average for the current bar."""
+        period = int(self.p.period)
+        current = float(self.data[0])
+        prev = float(self.lines.ama[-1]) if len(self) > 0 else current
+        if not math.isfinite(prev):
+            prev = 0.0
+        if not math.isfinite(current):
+            self.lines.ama[0] = prev
+            return
+        if len(self.data) <= period:
+            self.lines.ama[0] = current
+            return
+        change = abs(float(self.data[0]) - float(self.data[-period]))
+        volatility = 0.0
+        for i in range(period):
+            left = float(self.data[-i])
+            right = float(self.data[-i - 1])
+            if math.isfinite(left) and math.isfinite(right):
+                volatility += abs(left - right)
+        er = (change / volatility) if volatility else 0.0
+        fast_sc = 2.0 / (int(self.p.fast_period) + 1.0)
+        slow_sc = 2.0 / (int(self.p.slow_period) + 1.0)
+        sc = (er * (fast_sc - slow_sc) + slow_sc) ** float(self.p.power)
+        self.lines.ama[0] = prev + sc * (current - prev)
+
+    def once(self, start, end):
+        """Vectorized KAMA computation over the array index range.
+
+        Args:
+            start: Start index (inclusive) of the range to compute.
+            end: End index (exclusive) of the range to compute.
+        """
+        period = int(self.p.period)
+        src = self.data.array
+        dst = self.lines.ama.array
+        fast_sc = 2.0 / (int(self.p.fast_period) + 1.0)
+        slow_sc = 2.0 / (int(self.p.slow_period) + 1.0)
+        power = float(self.p.power)
+        for i in range(start, end):
+            current = float(src[i])
+            prev = float(dst[i - 1]) if i > 0 else current
+            if not math.isfinite(prev):
+                prev = 0.0
+            if not math.isfinite(current):
+                dst[i] = prev
+                continue
+            if i <= period:
+                dst[i] = current
+                continue
+            change = abs(current - float(src[i - period]))
+            volatility = 0.0
+            for j in range(period):
+                left = float(src[i - j])
+                right = float(src[i - j - 1])
+                if math.isfinite(left) and math.isfinite(right):
+                    volatility += abs(left - right)
+            er = (change / volatility) if volatility else 0.0
+            sc = (er * (fast_sc - slow_sc) + slow_sc) ** power
+            dst[i] = prev + sc * (current - prev)
+
+
+class ColorMomentumAMAIndicator(Indicator):
+    """EMA-smoothed momentum line used by the ColorMomentum_AMA strategy."""
+
+    lines = ("value",)
+    params = (
+        ("alength", 8),
+        ("ama_period", 9),
+        ("fast_ma_period", 2),
+        ("slow_ma_period", 30),
+        ("ipc", "price_close"),
+        ("g", 2.0),
+    )
+
+    def __init__(self):
+        """Build the EMA-smoothed momentum line and set the minimum period."""
+        price_line = resolve_price_line(self.data, self.p.ipc)
+        momentum = price_line - price_line(-int(self.p.alength))
+        self.lines.value = ExponentialMovingAverage(
+            momentum,
+            period=max(1, int(self.p.ama_period)),
+        )
+        self.addminperiod(int(self.p.alength) + int(self.p.ama_period) + 5)

backtrader/indicators/contrib/karacatica_indicator.py

@@ -0,0 +1,99 @@
+#!/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__ = [
+    "KaracaticaIndicator",
+]
+
+
+class KaracaticaIndicator(Indicator):
+    """Reconstructs Karacatica from MQ5 source.
+
+    Uses ATR(iPeriod), ADX(iPeriod) +DI/-DI, and close-vs-close(iPeriod-ago)
+    to generate buy/sell arrows with direction latch to avoid repeats.
+    """
+
+    lines = ("buy_arrow", "sell_arrow")
+    params = (("iperiod", 70),)
+
+    def __init__(self):
+        """Initialize the ATR scaling factor, direction latch, and min period."""
+        self._s = 1.5 / 2.0
+        self._ltr = 0  # 0=none, 1=last was buy, 2=last was sell
+        self.addminperiod(int(self.p.iperiod) + 2)
+
+    def _calc_atr(self):
+        period = int(self.p.iperiod)
+        total = 0.0
+        for i in range(period):
+            hi = float(self.data.high[-i])
+            lo = float(self.data.low[-i])
+            prev_c = float(self.data.close[-(i + 1)])
+            total += max(hi - lo, abs(hi - prev_c), abs(prev_c - lo))
+        return total / period
+
+    def _calc_adx_di(self):
+        period = int(self.p.iperiod)
+        plus_dm_sum = 0.0
+        minus_dm_sum = 0.0
+        tr_sum = 0.0
+        for i in range(period):
+            hi = float(self.data.high[-i])
+            lo = float(self.data.low[-i])
+            prev_hi = float(self.data.high[-(i + 1)])
+            prev_lo = float(self.data.low[-(i + 1)])
+            prev_c = float(self.data.close[-(i + 1)])
+            up_move = hi - prev_hi
+            down_move = prev_lo - lo
+            plus_dm = up_move if (up_move > down_move and up_move > 0) else 0.0
+            minus_dm = down_move if (down_move > up_move and down_move > 0) else 0.0
+            tr = max(hi - lo, abs(hi - prev_c), abs(prev_c - lo))
+            plus_dm_sum += plus_dm
+            minus_dm_sum += minus_dm
+            tr_sum += tr
+        if tr_sum == 0:
+            return 0.0, 0.0
+        plus_di = 100.0 * plus_dm_sum / tr_sum
+        minus_di = 100.0 * minus_dm_sum / tr_sum
+        return plus_di, minus_di
+
+    def next(self):
+        """Emit ATR-offset buy/sell arrows on latched directional breakouts.
+
+        Computes ATR and +DI/-DI over ``iperiod`` and, when the close exceeds
+        its value ``iperiod`` bars ago with +DI dominant (and the last arrow was
+        not a buy), places a buy arrow below the low; the symmetric condition
+        places a sell arrow above the high. The direction latch prevents
+        consecutive arrows of the same side.
+        """
+        period = int(self.p.iperiod)
+        if len(self.data) < period + 2:
+            self.lines.buy_arrow[0] = 0.0
+            self.lines.sell_arrow[0] = 0.0
+            return
+
+        atr = self._calc_atr()
+        plus_di, minus_di = self._calc_adx_di()
+        cur_close = float(self.data.close[0])
+        past_close = float(self.data.close[-period])
+        cur_high = float(self.data.high[0])
+        cur_low = float(self.data.low[0])
+
+        buy_val = 0.0
+        sell_val = 0.0
+
+        if cur_close > past_close and plus_di > minus_di and self._ltr != 1:
+            buy_val = cur_low - atr * self._s
+            self._ltr = 1
+        if cur_close < past_close and plus_di < minus_di and self._ltr != 2:
+            sell_val = cur_high + atr * self._s
+            self._ltr = 2
+
+        self.lines.buy_arrow[0] = buy_val
+        self.lines.sell_arrow[0] = sell_val

backtrader/indicators/contrib/kdj_indicator.py

@@ -0,0 +1,59 @@
+#!/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__ = [
+    "KDJIndicator",
+]
+
+
+class KDJIndicator(Indicator):
+    """Indicator class implementing the custom KDJ oscillator.
+
+    Lines:
+        kdc (Line): Output difference line (%K - %D).
+        rsv (Line): Raw Stochastic Value line.
+        k (Line): Smoothed %K line.
+        d (Line): Smoothed %D line.
+    """
+
+    lines = ("kdc", "rsv", "k", "d")
+    params = (
+        ("m1", 3),
+        ("m2", 6),
+        ("kdj_period", 30),
+    )
+
+    def __init__(self):
+        """Initialize the custom KDJ indicator and establish minimum warmup period."""
+        self.addminperiod(int(self.p.kdj_period) + int(self.p.m2) + 2)
+
+    def next(self):
+        """Calculate RSV, %K, %D, and %K-%D values on each new bar."""
+        kdj_period = int(self.p.kdj_period)
+        m1 = int(self.p.m1)
+        m2 = int(self.p.m2)
+        highs = [float(self.data.high[-i]) for i in range(kdj_period)]
+        lows = [float(self.data.low[-i]) for i in range(kdj_period)]
+        max_high = max(highs)
+        min_low = min(lows)
+        if max_high - min_low != 0.0:
+            self.lines.rsv[0] = (float(self.data.close[0]) - min_low) / (max_high - min_low) * 100.0
+        else:
+            self.lines.rsv[0] = 1.0
+        rsv_values = []
+        for i in range(m1):
+            value = float(self.lines.rsv[-i]) if len(self) > i else 50.0
+            rsv_values.append(value)
+        self.lines.k[0] = sum(rsv_values) / float(m1)
+        k_values = []
+        for i in range(m2):
+            value = float(self.lines.k[-i]) if len(self) > i else 50.0
+            k_values.append(value)
+        self.lines.d[0] = sum(k_values) / float(m2)
+        self.lines.kdc[0] = float(self.lines.k[0]) - float(self.lines.d[0])