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

backtrader/indicators/contrib/kwan_ccc_indicator.py

@@ -0,0 +1,195 @@
+#!/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__ = [
+    "KwanCccIndicator",
+]
+
+
+class KwanCccIndicator(Indicator):
+    """Custom Kwan CCC technical indicator.
+
+    Lines:
+        kwan (LineSeries): Smoothed combination of Chaikin, CCI, and Momentum.
+        direction (LineSeries): Directional momentum flag (0 = bullish, 1 = flat, 2 = bearish).
+    """
+
+    lines = (
+        "kwan",
+        "direction",
+    )
+
+    params = (
+        ("fast_ma_period", 3),
+        ("slow_ma_period", 10),
+        ("ma_method", "LWMA"),
+        ("cci_period", 14),
+        ("cci_price", "MEDIAN"),
+        ("momentum_period", 7),
+        ("momentum_price", "CLOSE"),
+        ("xma_method", "JJMA"),
+        ("x_length", 7),
+        ("x_phase", 100),
+    )
+
+    def __init__(self):
+        """Initialize indicator variables, buffer lists, and min periods."""
+        self.addminperiod(
+            max(self.p.slow_ma_period, self.p.cci_period, self.p.momentum_period)
+            + self.p.x_length
+            + 5
+        )
+        self._adl_buf = []
+        self._chaikin_buf = []
+        self._cci_price_buf = []
+        self._momentum_price_buf = []
+        self._raw_buf = []
+        self._smooth_prev = None
+        self._smooth_buf = []
+
+    def _select_price(self, mode):
+        mode = str(mode).upper()
+        if mode == "OPEN":
+            return float(self.data.open[0])
+        if mode == "HIGH":
+            return float(self.data.high[0])
+        if mode == "LOW":
+            return float(self.data.low[0])
+        if mode == "MEDIAN":
+            return (float(self.data.high[0]) + float(self.data.low[0])) / 2.0
+        if mode == "TYPICAL":
+            return (
+                float(self.data.high[0]) + float(self.data.low[0]) + float(self.data.close[0])
+            ) / 3.0
+        if mode == "WEIGHTED":
+            return (
+                float(self.data.high[0]) + float(self.data.low[0]) + 2.0 * float(self.data.close[0])
+            ) / 4.0
+        return float(self.data.close[0])
+
+    @staticmethod
+    def _sma(values, period):
+        if len(values) < period or period <= 0:
+            return None
+        window = values[-period:]
+        return sum(window) / float(period)
+
+    @staticmethod
+    def _lwma(values, period):
+        if len(values) < period or period <= 0:
+            return None
+        window = values[-period:]
+        weights = list(range(1, period + 1))
+        denom = sum(weights)
+        return sum(v * w for v, w in zip(window, weights)) / float(denom)
+
+    def _ma(self, values, period, method):
+        method = str(method).upper()
+        if method in ("MODE_LWMA", "LWMA"):
+            return self._lwma(values, period)
+        return self._sma(values, period)
+
+    def _calc_cci(self):
+        period = int(self.p.cci_period)
+        if len(self._cci_price_buf) < period or period <= 0:
+            return None
+        window = self._cci_price_buf[-period:]
+        sma = sum(window) / float(period)
+        mean_dev = sum(abs(v - sma) for v in window) / float(period)
+        if mean_dev == 0:
+            return 0.0
+        return (window[-1] - sma) / (0.015 * mean_dev)
+
+    def _calc_momentum(self):
+        period = int(self.p.momentum_period)
+        if len(self._momentum_price_buf) <= period or period <= 0:
+            return None
+        prev_price = self._momentum_price_buf[-(period + 1)]
+        curr_price = self._momentum_price_buf[-1]
+        if prev_price == 0:
+            return None
+        return 100.0 * curr_price / prev_price
+
+    def _smooth_value(self, raw_value):
+        method = str(self.p.xma_method).upper()
+        if method in ("MODE_SMA_", "SMA"):
+            period = max(1, int(self.p.x_length))
+            if len(self._raw_buf) < period:
+                return raw_value
+            return sum(self._raw_buf[-period:]) / float(period)
+
+        length = max(1, int(self.p.x_length))
+        phase = max(-100, min(100, int(self.p.x_phase)))
+        alpha = 2.0 / (length + 1.0)
+        alpha *= 1.0 + 0.35 * (phase / 100.0)
+        alpha = max(0.01, min(0.99, alpha))
+        if self._smooth_prev is None or not math.isfinite(self._smooth_prev):
+            smooth = raw_value
+        else:
+            smooth = self._smooth_prev + alpha * (raw_value - self._smooth_prev)
+        self._smooth_prev = smooth
+        return smooth
+
+    def next(self):
+        """Compute the Kwan CCC metric and directional momentum flags on each bar."""
+        high = float(self.data.high[0])
+        low = float(self.data.low[0])
+        close = float(self.data.close[0])
+        volume = float(self.data.volume[0]) if math.isfinite(float(self.data.volume[0])) else 0.0
+
+        if high != low:
+            mf_mult = ((close - low) - (high - close)) / (high - low)
+        else:
+            mf_mult = 0.0
+        adl_prev = self._adl_buf[-1] if self._adl_buf else 0.0
+        adl = adl_prev + mf_mult * volume
+        self._adl_buf.append(adl)
+
+        chaikin_fast = self._ma(self._adl_buf, int(self.p.fast_ma_period), self.p.ma_method)
+        chaikin_slow = self._ma(self._adl_buf, int(self.p.slow_ma_period), self.p.ma_method)
+        if chaikin_fast is None or chaikin_slow is None:
+            self.lines.kwan[0] = 0.0
+            self.lines.direction[0] = 1.0
+            return
+        chaikin = chaikin_fast - chaikin_slow
+        self._chaikin_buf.append(chaikin)
+
+        self._cci_price_buf.append(self._select_price(self.p.cci_price))
+        self._momentum_price_buf.append(self._select_price(self.p.momentum_price))
+
+        cci = self._calc_cci()
+        momentum = self._calc_momentum()
+        if cci is None or momentum is None:
+            self.lines.kwan[0] = 0.0
+            self.lines.direction[0] = 1.0
+            return
+
+        if momentum == 0 or not math.isfinite(momentum):
+            raw_value = 100.0
+        else:
+            raw_value = chaikin * cci / momentum
+        self._raw_buf.append(raw_value)
+
+        smooth = self._smooth_value(raw_value)
+        self._smooth_buf.append(smooth)
+        self.lines.kwan[0] = smooth
+
+        if len(self._smooth_buf) < 2:
+            self.lines.direction[0] = 1.0
+            return
+
+        prev_smooth = self._smooth_buf[-2]
+        if smooth > prev_smooth:
+            self.lines.direction[0] = 0.0
+        elif smooth < prev_smooth:
+            self.lines.direction[0] = 2.0
+        else:
+            self.lines.direction[0] = 1.0

backtrader/indicators/contrib/kwan_nrp_indicator.py

@@ -0,0 +1,113 @@
+#!/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,
+    MomentumOscillator,
+    Stochastic,
+)
+
+__all__ = [
+    "KwanNrpIndicator",
+]
+
+
+class KwanNrpIndicator(Indicator):
+    """Compute smoothed KWAN_NRP value and direction direction states."""
+
+    lines = (
+        "kwan",
+        "direction",
+    )
+
+    params = (
+        ("k_period", 5),
+        ("d_period", 3),
+        ("slowing", 3),
+        ("rsi_period", 14),
+        ("momentum_period", 14),
+        ("x_length", 3),
+    )
+
+    def __init__(self):
+        """Prepare stochastic, RSI, and momentum components for indicator output."""
+        # --- Stochastic %D (signal line) ---
+        stoch = Stochastic(
+            self.data,
+            period=self.p.k_period,
+            period_dfast=self.p.slowing,
+            period_dslow=self.p.d_period,
+        )
+        self.stoch_d = stoch.percD
+
+        # --- RSI ---
+        self.rsi = RSI(
+            self.data.close,
+            period=self.p.rsi_period,
+        )
+
+        # --- Momentum Oscillator  = 100 * close / close[-period] ---
+        self.mom_osc = MomentumOscillator(
+            self.data.close,
+            period=self.p.momentum_period,
+        )
+
+        # --- Raw KWAN oscillator ---
+        # kwan_raw = stoch_d * rsi / mom_osc
+        # Guard against mom_osc == 0 in next() and protect period alignment.
+        self.addminperiod(
+            max(
+                self.p.k_period + self.p.slowing + self.p.d_period,
+                self.p.rsi_period,
+                self.p.momentum_period,
+            )
+            + self.p.x_length
+            + 2
+        )
+
+        # Internal raw value buffer.
+        self._raw_buf = []
+
+    def next(self):
+        """Update KWAN value and directional signal line."""
+        mom = self.mom_osc[0]
+        if mom == 0 or not math.isfinite(mom):
+            kwan_raw = 100.0
+        else:
+            kwan_raw = self.stoch_d[0] * self.rsi[0] / mom
+
+        self._raw_buf.append(kwan_raw)
+
+        # Smooth raw values with a simple moving average of the last XLength bars.
+        xl = self.p.x_length
+        if len(self._raw_buf) >= xl:
+            smoothed = sum(self._raw_buf[-xl:]) / xl
+        else:
+            smoothed = kwan_raw
+
+        self.lines.kwan[0] = smoothed
+
+        # Determine direction: rise / fall / flat versus previous smoothed value.
+        if len(self._raw_buf) < xl + 1:
+            self.lines.direction[0] = 1.0
+            return
+
+        prev_smoothed_vals = self._raw_buf[-(xl + 1) : -1]
+        if len(prev_smoothed_vals) >= xl:
+            prev_smoothed = sum(prev_smoothed_vals[-xl:]) / xl
+        else:
+            prev_smoothed = smoothed
+
+        if smoothed > prev_smoothed:
+            self.lines.direction[0] = 0.0  # rising
+        elif smoothed < prev_smoothed:
+            self.lines.direction[0] = 2.0  # falling
+        else:
+            self.lines.direction[0] = 1.0

backtrader/indicators/contrib/kwan_rdp_indicator.py

@@ -0,0 +1,192 @@
+#!/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__ = [
+    "KwanRdpIndicator",
+]
+
+
+class KwanRdpIndicator(Indicator):
+    """Custom Kwan RDP technical indicator.
+
+    Lines:
+        kwan (LineSeries): Smoothed combination of DeMarker, MFI, and Momentum.
+        direction (LineSeries): Directional momentum flag (0 = bullish, 1 = flat, 2 = bearish).
+    """
+
+    lines = (
+        "kwan",
+        "direction",
+    )
+
+    params = (
+        ("demarker_period", 14),
+        ("mfi_period", 14),
+        ("volume_type", "TICK"),
+        ("momentum_period", 14),
+        ("momentum_price", "CLOSE"),
+        ("xma_method", "JJMA"),
+        ("x_length", 7),
+        ("x_phase", 100),
+    )
+
+    def __init__(self):
+        """Initialize indicator state: rolling buffers and minperiod."""
+        self.addminperiod(
+            max(self.p.demarker_period, self.p.mfi_period, self.p.momentum_period)
+            + self.p.x_length
+            + 5
+        )
+        self._high_buf = []
+        self._low_buf = []
+        self._close_buf = []
+        self._typical_buf = []
+        self._money_flow_buf = []
+        self._raw_buf = []
+        self._smooth_prev = None
+        self._smooth_buf = []
+
+    def _select_price(self, mode):
+        """Return the selected price value (open/high/low/median/typical/weighted/close)."""
+        mode = str(mode).upper()
+        if mode == "OPEN":
+            return float(self.data.open[0])
+        if mode == "HIGH":
+            return float(self.data.high[0])
+        if mode == "LOW":
+            return float(self.data.low[0])
+        if mode == "MEDIAN":
+            return (float(self.data.high[0]) + float(self.data.low[0])) / 2.0
+        if mode == "TYPICAL":
+            return (
+                float(self.data.high[0]) + float(self.data.low[0]) + float(self.data.close[0])
+            ) / 3.0
+        if mode == "WEIGHTED":
+            return (
+                float(self.data.high[0]) + float(self.data.low[0]) + 2.0 * float(self.data.close[0])
+            ) / 4.0
+        return float(self.data.close[0])
+
+    def _calc_demarker(self):
+        """Compute DeMarker oscillator from rolling high/low buffers."""
+        p = int(self.p.demarker_period)
+        if len(self._high_buf) <= p or len(self._low_buf) <= p:
+            return None
+        demax = []
+        demin = []
+        for i in range(len(self._high_buf) - p, len(self._high_buf)):
+            high_diff = self._high_buf[i] - self._high_buf[i - 1]
+            low_diff = self._low_buf[i - 1] - self._low_buf[i]
+            demax.append(max(high_diff, 0.0))
+            demin.append(max(low_diff, 0.0))
+        smax = sum(demax)
+        smin = sum(demin)
+        denom = smax + smin
+        if denom == 0:
+            return 0.5
+        return smax / denom
+
+    def _calc_mfi(self):
+        """Compute Money Flow Index from typical price and volume buffers."""
+        p = int(self.p.mfi_period)
+        if len(self._typical_buf) <= p or len(self._money_flow_buf) <= p:
+            return None
+        pos_flow = 0.0
+        neg_flow = 0.0
+        start = len(self._typical_buf) - p
+        for i in range(start, len(self._typical_buf)):
+            prev_tp = self._typical_buf[i - 1]
+            curr_tp = self._typical_buf[i]
+            curr_flow = self._money_flow_buf[i]
+            if curr_tp > prev_tp:
+                pos_flow += curr_flow
+            elif curr_tp < prev_tp:
+                neg_flow += curr_flow
+        if neg_flow == 0:
+            return 100.0
+        money_ratio = pos_flow / neg_flow
+        return 100.0 - (100.0 / (1.0 + money_ratio))
+
+    def _calc_momentum(self):
+        """Compute momentum as percentage change of selected price over period."""
+        p = int(self.p.momentum_period)
+        if len(self._close_buf) <= p:
+            return None
+        prev_price = self._close_buf[-(p + 1)]
+        curr_price = self._select_price(self.p.momentum_price)
+        if prev_price == 0:
+            return None
+        return 100.0 * curr_price / prev_price
+
+    def _smooth_value(self, raw_value):
+        """Smooth raw_value using SMA or phase-adjusted exponential (JJMA-like)."""
+        method = str(self.p.xma_method).upper()
+        if method in ("MODE_SMA_", "SMA"):
+            period = max(1, int(self.p.x_length))
+            if len(self._raw_buf) < period:
+                return raw_value
+            return sum(self._raw_buf[-period:]) / float(period)
+
+        length = max(1, int(self.p.x_length))
+        phase = max(-100, min(100, int(self.p.x_phase)))
+        alpha = 2.0 / (length + 1.0)
+        alpha *= 1.0 + 0.35 * (phase / 100.0)
+        alpha = max(0.01, min(0.99, alpha))
+        if self._smooth_prev is None or not math.isfinite(self._smooth_prev):
+            smooth = raw_value
+        else:
+            smooth = self._smooth_prev + alpha * (raw_value - self._smooth_prev)
+        self._smooth_prev = smooth
+        return smooth
+
+    def next(self):
+        """Compute Kwan RDP indicator: composite of DeMarker * MFI / momentum, smoothed."""
+        high = float(self.data.high[0])
+        low = float(self.data.low[0])
+        close = float(self.data.close[0])
+        volume = float(self.data.volume[0]) if math.isfinite(float(self.data.volume[0])) else 0.0
+
+        self._high_buf.append(high)
+        self._low_buf.append(low)
+        self._close_buf.append(close)
+        typical = (high + low + close) / 3.0
+        self._typical_buf.append(typical)
+        self._money_flow_buf.append(typical * volume)
+
+        demarker = self._calc_demarker()
+        mfi = self._calc_mfi()
+        momentum = self._calc_momentum()
+        if demarker is None or mfi is None or momentum is None:
+            self.lines.kwan[0] = 0.0
+            self.lines.direction[0] = 1.0
+            return
+
+        if momentum == 0 or not math.isfinite(momentum):
+            raw_value = 100.0
+        else:
+            raw_value = 100.0 * demarker * mfi / momentum
+        self._raw_buf.append(raw_value)
+
+        smooth = self._smooth_value(raw_value)
+        self._smooth_buf.append(smooth)
+        self.lines.kwan[0] = smooth
+
+        if len(self._smooth_buf) < 2:
+            self.lines.direction[0] = 1.0
+            return
+
+        prev_smooth = self._smooth_buf[-2]
+        if smooth > prev_smooth:
+            self.lines.direction[0] = 0.0
+        elif smooth < prev_smooth:
+            self.lines.direction[0] = 2.0
+        else:
+            self.lines.direction[0] = 1.0

backtrader/indicators/contrib/laguerre_adx_indicator.py

@@ -0,0 +1,85 @@
+#!/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,
+    MinusDirectionalIndicator,
+    PlusDirectionalIndicator,
+)
+
+__all__ = [
+    "LaguerreAdxIndicator",
+]
+
+
+class LaguerreAdxIndicator(Indicator):
+    """Laguerre-filtered ADX directional components built from +/- DI."""
+
+    lines = ("up", "down")
+    params = (
+        ("adx_period", 14),
+        ("gamma", 0.764),
+    )
+
+    def __init__(self):
+        """Initialize DI inputs, laguerre states, and minimum period."""
+        self.addminperiod(int(self.p.adx_period) + 5)
+        self.plus_di = PlusDirectionalIndicator(self.data, period=int(self.p.adx_period))
+        self.minus_di = MinusDirectionalIndicator(self.data, period=int(self.p.adx_period))
+        self._p = {"l0": 0.0, "l1": 0.0, "l2": 0.0, "l3": 0.0}
+        self._m = {"l0": 0.0, "l1": 0.0, "l2": 0.0, "l3": 0.0}
+
+    def _laguerre_step(self, value, state, previous_output):
+        gamma = float(self.p.gamma)
+        l0a = state["l0"]
+        l1a = state["l1"]
+        l2a = state["l2"]
+        l3a = state["l3"]
+        l0 = (1.0 - gamma) * value + gamma * l0a
+        l1 = -gamma * l0 + l0a + gamma * l1a
+        l2 = -gamma * l1 + l1a + gamma * l2a
+        l3 = -gamma * l2 + l2a + gamma * l3a
+        state["l0"] = l0
+        state["l1"] = l1
+        state["l2"] = l2
+        state["l3"] = l3
+        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
+        if cu + cd != 0.0:
+            return cu / (cu + cd)
+        return previous_output
+
+    def next(self):
+        """Compute smoothed up/down values from directional indicators."""
+        prev_up = (
+            float(self.lines.up[-1])
+            if len(self) > 0 and math.isfinite(float(self.lines.up[-1]))
+            else 0.0
+        )
+        prev_down = (
+            float(self.lines.down[-1])
+            if len(self) > 0 and math.isfinite(float(self.lines.down[-1]))
+            else 0.0
+        )
+        plus_value = float(self.plus_di[0]) if math.isfinite(float(self.plus_di[0])) else 0.0
+        minus_value = float(self.minus_di[0]) if math.isfinite(float(self.minus_di[0])) else 0.0
+        self.lines.up[0] = self._laguerre_step(plus_value, self._p, prev_up)
+        self.lines.down[0] = self._laguerre_step(minus_value, self._m, prev_down)

backtrader/indicators/contrib/laguerre_filter_indicator.py

@@ -0,0 +1,66 @@
+#!/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__ = [
+    "LaguerreFilterIndicator",
+]
+
+
+class LaguerreFilterIndicator(Indicator):
+    """Laguerre smoothing indicator with finite impulse response fallback lines."""
+
+    lines = ("laguerre", "fir")
+    params = (("gamma", 0.7),)
+
+    def __init__(self):
+        """Initialize internal Laguerre filter state and warm-up requirements."""
+        self.addminperiod(4)
+        self._l0 = None
+        self._l1 = None
+        self._l2 = None
+        self._l3 = None
+
+    def _price(self, ago=0):
+        return (float(self.data.high[ago]) + float(self.data.low[ago])) / 2.0
+
+    def next(self):
+        """Compute current Laguerre and FIR values for the current bar."""
+        price = self._price(0)
+        if self._l0 is None:
+            self._l0 = price
+            self._l1 = price
+            self._l2 = price
+            self._l3 = price
+            self.lines.laguerre[0] = price
+            self.lines.fir[0] = price
+            return
+        l0a = self._l0
+        l1a = self._l1
+        l2a = self._l2
+        l3a = self._l3
+        gamma = float(self.p.gamma)
+        l0 = (1.0 - gamma) * price + gamma * l0a
+        l1 = -gamma * l0 + l0a + gamma * l1a
+        l2 = -gamma * l1 + l1a + gamma * l2a
+        l3 = -gamma * l2 + l2a + gamma * l3a
+        self._l0 = l0
+        self._l1 = l1
+        self._l2 = l2
+        self._l3 = l3
+        if len(self) > 4:
+            self.lines.laguerre[0] = (l0 + 2.0 * l1 + 2.0 * l2 + l3) / 6.0
+            self.lines.fir[0] = (
+                1.0 * self._price(0)
+                + 2.0 * self._price(-1)
+                + 2.0 * self._price(-2)
+                + 1.0 * self._price(-3)
+            ) / 6.0
+        else:
+            self.lines.laguerre[0] = price
+            self.lines.fir[0] = price