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

backtrader/indicators/contrib/vinin_i_trend_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.
+"""
+
+from .. import (
+    ExponentialMovingAverage,
+    Indicator,
+    SimpleMovingAverage,
+    SmoothedMovingAverage,
+    WeightedMovingAverage,
+)
+
+__all__ = [
+    "VininITrendIndicator",
+]
+
+
+def resolve_ma_class(name):
+    """Resolve MA method identifier to a Backtrader MA class.
+
+    Args:
+        name: Method name from configuration.
+
+    Returns:
+        Backtrader MA class.
+    """
+    mode = str(name).lower()
+    if mode in {"sma", "mode_sma"}:
+        return SimpleMovingAverage
+    if mode in {"ema", "mode_ema"}:
+        return ExponentialMovingAverage
+    if mode in {"smma", "mode_smma"}:
+        return SmoothedMovingAverage
+    return WeightedMovingAverage
+
+
+def resolve_price_line(data, mode):
+    """Resolve an applied price variant from raw data lines.
+
+    Args:
+        data: Backtrader feed or data object.
+        mode: Price selector key.
+
+    Returns:
+        backtrader line: Selected price series.
+    """
+    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 VininITrendIndicator(Indicator):
+    """Indicator that calculates a smoothed trend score from MA comparisons."""
+
+    lines = ("trend",)
+    params = (
+        ("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):
+        """Build MA lines and required warmup length."""
+        price_line = resolve_price_line(self.data, self.p.ipc)
+        periods = [
+            int(self.p.length1 + idx * self.p.ma_step) for idx in range(int(self.p.ma_count))
+        ]
+        self._ma_lines = [
+            resolve_ma_class(self.p.ma_method1)(price_line, period=max(1, p)) for p in periods
+        ]
+        self._smooth = resolve_ma_class(self.p.ma_method2)(
+            self.lines.trend, period=max(1, int(self.p.length2))
+        )
+        self.addminperiod(max(periods) + int(self.p.length2) + 5)
+
+    def next(self):
+        """Compute trend score and one-step EMA-smoothed trend value."""
+        close_value = float(self.data.close[0])
+        score = 0
+        for ma_line in self._ma_lines:
+            if close_value > float(ma_line[0]):
+                score += 1
+            else:
+                score -= 1
+        raw = 100.0 * score / max(1, len(self._ma_lines))
+        prev = float(self.lines.trend[-1]) if len(self) > 0 else raw
+        if prev != prev:
+            prev = raw
+        period = max(1, int(self.p.length2))
+        alpha = 2.0 / (period + 1.0)
+        if len(self) == 0:
+            self.lines.trend[0] = raw
+        else:
+            self.lines.trend[0] = alpha * raw + (1.0 - alpha) * prev
+
+    def once(self, start, end):
+        """Compute trend values for startup/backfill path."""
+        close_array = self.data.close.array
+        ma_arrays = [ma_line.array for ma_line in self._ma_lines]
+        trend_line = self.lines.trend.array
+        while len(trend_line) < end:
+            trend_line.append(float("nan"))
+
+        period = max(1, int(self.p.length2))
+        alpha = 2.0 / (period + 1.0)
+        prev = None
+        actual_end = min([end, len(close_array)] + [len(array) for array in ma_arrays])
+        for i in range(start, actual_end):
+            close_value = float(close_array[i])
+            score = 0
+            for ma_array in ma_arrays:
+                if close_value > float(ma_array[i]):
+                    score += 1
+                else:
+                    score -= 1
+            raw = 100.0 * score / max(1, len(ma_arrays))
+            value = raw if prev is None else alpha * raw + (1.0 - alpha) * prev
+            trend_line[i] = value
+            prev = value

backtrader/indicators/contrib/volume_weighted_ma_indicator.py

@@ -0,0 +1,78 @@
+#!/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__ = [
+    "VolumeWeightedMAIndicator",
+]
+
+
+def _applied_price(data, price_type, ago=0):
+    o = float(data.open[-ago])
+    h = float(data.high[-ago])
+    low_price = float(data.low[-ago])
+    c = float(data.close[-ago])
+    if price_type == 0:
+        return c
+    if price_type == 1:
+        return o
+    if price_type == 2:
+        return h
+    if price_type == 3:
+        return low_price
+    if price_type == 4:
+        return (h + low_price) / 2.0
+    if price_type == 5:
+        return (h + low_price + c) / 3.0
+    if price_type == 6:
+        return (h + low_price + c + c) / 4.0
+    return c
+
+
+class VolumeWeightedMAIndicator(Indicator):
+    """Volume-weighted moving average of an applied price.
+
+    Averages the applied price (selected by ``ipc``) over ``length`` bars,
+    weighting each bar by its tick volume (or open interest when
+    ``use_tick_volume`` is False); falls back to the plain applied price when
+    the total weight is zero.
+    """
+
+    lines = ("vwma",)
+    params = (
+        ("length", 12),
+        ("ipc", 0),
+        ("use_tick_volume", True),
+    )
+
+    def __init__(self):
+        """Set the minimum period to cover the averaging window."""
+        self.addminperiod(int(self.p.length) + 2)
+
+    def next(self):
+        """Compute the volume-weighted average price for the current bar."""
+        length = int(self.p.length)
+        weights = []
+        total = 0.0
+        for i in range(length):
+            vol = (
+                float(self.data.volume[-i])
+                if self.p.use_tick_volume
+                else float(self.data.openinterest[-i])
+            )
+            if vol < 0:
+                vol = 0.0
+            weights.append(vol)
+            total += vol
+        if total == 0.0:
+            self.lines.vwma[0] = _applied_price(self.data, int(self.p.ipc), 0)
+            return
+        value = 0.0
+        for i in range(length):
+            value += _applied_price(self.data, int(self.p.ipc), i) * (weights[i] / total)
+        self.lines.vwma[0] = value

backtrader/indicators/contrib/volume_weighted_ma_st_dev_indicator.py

@@ -0,0 +1,111 @@
+#!/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__ = [
+    "VolumeWeightedMAStDevIndicator",
+]
+
+
+def _applied_price(data, price_type, ago=0):
+    o = float(data.open[-ago])
+    h = float(data.high[-ago])
+    low_price = float(data.low[-ago])
+    c = float(data.close[-ago])
+    if price_type == 0:
+        return c
+    if price_type == 1:
+        return o
+    if price_type == 2:
+        return h
+    if price_type == 3:
+        return low_price
+    if price_type == 4:
+        return (h + low_price) / 2.0
+    if price_type == 5:
+        return (h + low_price + c) / 3.0
+    if price_type == 6:
+        return (h + low_price + c + c) / 4.0
+    return c
+
+
+class VolumeWeightedMAStDevIndicator(Indicator):
+    """Volume-weighted MA with standard-deviation graded signal lines.
+
+    Computes a volume-weighted moving average (``vwma``) and measures the
+    standard deviation of its change. When the latest change exceeds the
+    ``dk1``/``dk2`` standard-deviation bands it sets the corresponding
+    ``bulls1``/``bulls2`` or ``bears1``/``bears2`` signal lines.
+    """
+
+    lines = ("vwma", "bears1", "bulls1", "bears2", "bulls2")
+    params = (
+        ("length", 12),
+        ("ipc", 0),
+        ("use_tick_volume", True),
+        ("dk1", 1.5),
+        ("dk2", 2.5),
+        ("std_period", 9),
+    )
+
+    def __init__(self):
+        """Reserve the warm-up window for the VWMA and std-dev calculations."""
+        self.addminperiod(int(self.p.length) + int(self.p.std_period) + 3)
+
+    def _vwma_at(self, ago):
+        length = int(self.p.length)
+        weights = []
+        total = 0.0
+        for i in range(length):
+            idx = ago + i
+            vol = (
+                float(self.data.volume[-idx])
+                if self.p.use_tick_volume
+                else float(self.data.openinterest[-idx])
+            )
+            if vol < 0:
+                vol = 0.0
+            weights.append(vol)
+            total += vol
+        if total == 0.0:
+            return _applied_price(self.data, int(self.p.ipc), ago)
+        value = 0.0
+        for i in range(length):
+            value += _applied_price(self.data, int(self.p.ipc), ago + i) * (weights[i] / total)
+        return value
+
+    def next(self):
+        """Update the VWMA and set graded bull/bear signal lines."""
+        self.lines.bears1[0] = float("nan")
+        self.lines.bulls1[0] = float("nan")
+        self.lines.bears2[0] = float("nan")
+        self.lines.bulls2[0] = float("nan")
+        vwma_now = self._vwma_at(0)
+        self.lines.vwma[0] = vwma_now
+        std_period = int(self.p.std_period)
+        dvwma = []
+        for i in range(std_period):
+            v0 = self._vwma_at(i)
+            v1 = self._vwma_at(i + 1)
+            dvwma.append(v0 - v1)
+        mean = sum(dvwma) / std_period
+        variance = sum((x - mean) ** 2 for x in dvwma) / std_period
+        stdev = math.sqrt(variance)
+        dstd = dvwma[0]
+        filter1 = float(self.p.dk1) * stdev
+        filter2 = float(self.p.dk2) * stdev
+        if dstd < -filter1 and dstd >= -filter2:
+            self.lines.bears1[0] = vwma_now
+        if dstd < -filter2:
+            self.lines.bears2[0] = vwma_now
+        if dstd > filter1 and dstd <= filter2:
+            self.lines.bulls1[0] = vwma_now
+        if dstd > filter2:
+            self.lines.bulls2[0] = vwma_now

backtrader/indicators/contrib/vwap_close_indicator.py

@@ -0,0 +1,65 @@
+#!/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__ = [
+    "VWAPCloseIndicator",
+]
+
+
+class VWAPCloseIndicator(Indicator):
+    """Reconstructs VWAP_Close indicator.
+
+    VWAP = sum(close[i] * volume[i], i=0..n-1) / sum(volume[i], i=0..n-1)
+    Uses tick volume by default.
+    Buffer 0 = VWAP line.
+    """
+
+    lines = ("vwap",)
+    params = (("n", 2),)
+
+    def __init__(self):
+        """Initialize VWAP rolling window size and minimum period.
+
+        The indicator keeps the latest ``n`` bar prices and volumes and starts
+        producing values only after enough history is available.
+        """
+        self._n = int(self.p.n)
+        self.addminperiod(self._n + 1)
+
+    def next(self):
+        """Compute and emit the next VWAP-close value.
+
+        The calculation uses close*volume weighted average over up to ``n`` prior
+        bars and falls back to the previous VWAP value when volume is not
+        available.
+        """
+        n = self._n
+        sum1 = 0.0
+        sum2 = 0
+        for i in range(n):
+            if i >= len(self.data):
+                break
+            c = float(self.data.close[-i])
+            v = float(self.data.volume[-i])
+            if v < 1:
+                v = 1
+            sum1 += c * v
+            sum2 += v
+
+        if sum2 > 0:
+            self.lines.vwap[0] = sum1 / sum2
+        else:
+            prev = (
+                float(self.lines.vwap[-1])
+                if len(self.lines.vwap) > 1
+                else float(self.data.close[0])
+            )
+            self.lines.vwap[0] = prev if not math.isnan(prev) else float(self.data.close[0])

backtrader/indicators/contrib/vwma_candle.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__ = [
+    "VWMACandle",
+]
+
+
+class VWMACandle(Indicator):
+    """Volume-weighted candle color indicator.
+
+    Computes volume-weighted moving averages of the open and close over
+    ``length`` bars and emits a ``color`` line of 2.0 (bullish), 0.0 (bearish)
+    or 1.0 (neutral) depending on their relationship.
+    """
+
+    lines = ("color",)
+    params = (
+        ("length", 12),
+        ("use_tick_volume", True),
+    )
+
+    def __init__(self):
+        """Reserve the warm-up window needed for the volume-weighted average."""
+        self.addminperiod(int(self.p.length) + 3)
+
+    def _vwma(self, field, ago=0):
+        length = int(self.p.length)
+        total = 0.0
+        vals = 0.0
+        for i in range(length):
+            idx = ago + i
+            vol = (
+                float(self.data.volume[-idx])
+                if self.p.use_tick_volume
+                else float(self.data.openinterest[-idx])
+            )
+            total += max(vol, 0.0)
+            vals += float(getattr(self.data, field)[-idx]) * max(vol, 0.0)
+        return float(getattr(self.data, field)[-ago]) if total == 0.0 else vals / total
+
+    def next(self):
+        """Set the candle color from volume-weighted open vs close."""
+        op = self._vwma("open", 0)
+        cl = self._vwma("close", 0)
+        color = 1.0
+        if op < cl:
+            color = 2.0
+        elif op > cl:
+            color = 0.0
+        self.lines.color[0] = color

backtrader/indicators/contrib/vwma_digit_system.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 Indicator
+
+__all__ = [
+    "VWMADigitSystem",
+]
+
+
+class VWMADigitSystem(Indicator):
+    """Digit-rounded volume-weighted band color indicator.
+
+    Builds digit-rounded volume-weighted high and low levels over ``length``
+    bars and emits a ``color`` line encoding whether the close breaks above the
+    upper level or below the lower level, combined with candle direction.
+    """
+
+    lines = ("color",)
+    params = (
+        ("length", 12),
+        ("digit", 2),
+        ("shift", 2),
+        ("use_tick_volume", True),
+        ("point", 0.01),
+    )
+
+    def __init__(self):
+        """Reserve the warm-up window for the shifted weighted levels."""
+        self.addminperiod(int(self.p.length) + int(self.p.shift) + 3)
+
+    def _weighted_level(self, series_name, ago=0):
+        length = int(self.p.length)
+        weights = []
+        total = 0.0
+        for i in range(length):
+            idx = ago + i
+            vol = (
+                float(self.data.volume[-idx])
+                if self.p.use_tick_volume
+                else float(self.data.openinterest[-idx])
+            )
+            weights.append(max(vol, 0.0))
+            total += max(vol, 0.0)
+        if total == 0.0:
+            return float(getattr(self.data, series_name)[-ago])
+        value = 0.0
+        for i in range(length):
+            idx = ago + i
+            value += float(getattr(self.data, series_name)[-idx]) * (weights[i] / total)
+        step = float(self.p.point) * (10 ** int(self.p.digit))
+        return round(value / step) * step if step else value
+
+    def next(self):
+        """Set the band color from close breaks of the weighted levels."""
+        shift = int(self.p.shift)
+        up = self._weighted_level("high", shift)
+        dn = self._weighted_level("low", shift)
+        close = float(self.data.close[0])
+        open_ = float(self.data.open[0])
+        color = 2.0
+        if close > up:
+            color = 4.0 if open_ < close else 3.0
+        if close < dn:
+            color = 0.0 if open_ > close else 1.0
+        self.lines.color[0] = color

backtrader/indicators/contrib/wami.py

@@ -0,0 +1,43 @@
+#!/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__ = [
+    "Wami",
+]
+
+
+class Wami(Indicator):
+    """Calculate a WAMI-style oscillator and signal line from close-price MAs."""
+
+    lines = ("wami", "signal")
+    params = (
+        ("period_ma1", 4),
+        ("period_ma2", 13),
+        ("period_ma3", 13),
+        ("period_sig", 4),
+        ("point_size", 0.01),
+    )
+
+    def __init__(self):
+        """Initialize WAMI indicator stages and output lines."""
+        base_ma = SimpleMovingAverage(self.data.close, period=1)
+        diff = base_ma - base_ma(-1)
+        ma1 = SimpleMovingAverage(diff, period=self.p.period_ma1)
+        ma2 = SimpleMovingAverage(ma1, period=self.p.period_ma2)
+        ma3 = SimpleMovingAverage(ma2, period=self.p.period_ma3)
+        sig = SimpleMovingAverage(ma3, period=self.p.period_sig)
+        scale = self.p.point_size if self.p.point_size else 1.0
+        self.lines.wami = ma3 / scale
+        self.lines.signal = sig / scale
+        self.addminperiod(
+            1 + self.p.period_ma1 + self.p.period_ma2 + self.p.period_ma3 + self.p.period_sig
+        )

backtrader/indicators/contrib/wprsi_signal_indicator.py

@@ -0,0 +1,105 @@
+#!/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__ = [
+    "WPRSISignalIndicator",
+]
+
+
+class WPRSISignalIndicator(Indicator):
+    """Reconstructs WPRSIsignal indicator from its MQ5 source.
+
+    Uses WPR and RSI with same period.
+    Buy: WPR crosses above -20 from below AND RSI > 50, with filterUP lookback confirmation.
+    Sell: WPR crosses below -80 from above AND RSI < 50, with filterDN lookback confirmation.
+    """
+
+    lines = ("sell_arrow", "buy_arrow")  # buffer 0 = sell, buffer 1 = buy
+    params = (
+        ("wprsi_period", 27),
+        ("filter_up", 10),
+        ("filter_dn", 10),
+    )
+
+    def __init__(self):
+        """Reserve warm-up bars covering the WPRSI period plus the filter window."""
+        self._period = int(self.p.wprsi_period)
+        self._filter_up = int(self.p.filter_up)
+        self._filter_dn = int(self.p.filter_dn)
+        filter_max = max(self._filter_up, self._filter_dn)
+        self.addminperiod(self._period + filter_max + 3)
+
+    def _calc_wpr(self, ago=0):
+        period = self._period
+        highest = max(float(self.data.high[-(ago + i)]) for i in range(period))
+        lowest = min(float(self.data.low[-(ago + i)]) for i in range(period))
+        close = float(self.data.close[-ago])
+        if highest == lowest:
+            return -50.0
+        return -100.0 * (highest - close) / (highest - lowest)
+
+    def _calc_rsi(self, ago=0):
+        period = self._period
+        gains = 0.0
+        losses = 0.0
+        for i in range(period):
+            idx = ago + i
+            c = float(self.data.close[-idx])
+            cp = float(self.data.close[-(idx + 1)])
+            diff = c - cp
+            if diff > 0:
+                gains += diff
+            else:
+                losses -= diff
+        avg_gain = gains / period
+        avg_loss = losses / period
+        if avg_loss == 0:
+            return 100.0
+        rs = avg_gain / avg_loss
+        return 100.0 - (100.0 / (1.0 + rs))
+
+    def next(self):
+        """Emit buy/sell arrows on filtered Williams %R crosses confirmed by RSI."""
+        wpr_0 = self._calc_wpr(0)
+        wpr_1 = self._calc_wpr(1)
+        rsi_0 = self._calc_rsi(0)
+
+        buy_val = 0.0
+        sell_val = 0.0
+
+        cur_high = float(self.data.high[0])
+        cur_low = float(self.data.low[0])
+        rng = cur_high - cur_low
+
+        # Buy: WPR crosses above -20 from below, RSI > 50
+        if wpr_0 > -20.0 and wpr_1 < -20.0 and rsi_0 > 50.0:
+            z = 0
+            for k in range(2, self._filter_up + 3):
+                if k < len(self.data):
+                    wk = self._calc_wpr(k)
+                    if wk > -20.0:
+                        z = 1
+                        break
+            if z == 0:
+                buy_val = cur_low - rng / 2.0
+
+        # Sell: WPR crosses below -80 from above, RSI < 50
+        if wpr_1 > -80.0 and wpr_0 < -80.0 and rsi_0 < 50.0:
+            h = 0
+            for c in range(2, self._filter_dn + 3):
+                if c < len(self.data):
+                    wk = self._calc_wpr(c)
+                    if wk < -80.0:
+                        h = 1
+                        break
+            if h == 0:
+                sell_val = cur_high + rng / 2.0
+
+        self.lines.sell_arrow[0] = sell_val
+        self.lines.buy_arrow[0] = buy_val