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

backtrader/indicators/contrib/bulls_power.py

@@ -0,0 +1,56 @@
+#!/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,
+)
+
+__all__ = [
+    "BullsPower",
+    "BearsPower",
+]
+
+
+class BullsPower(Indicator):
+    """Indicator for Bulls Power built from high price minus EMA."""
+
+    lines = ("value",)
+    params = (("period", 5),)
+
+    def __init__(self):
+        """Initialize EMA and minimum period.
+
+        Args:
+            self: Instance reference.
+        """
+        self.ema = ExponentialMovingAverage(self.data.close, period=self.p.period)
+        self.addminperiod(self.p.period + 3)
+
+    def next(self):
+        """Update current Bulls Power value."""
+        self.lines.value[0] = float(self.data.high[0]) - float(self.ema[0])
+
+
+class BearsPower(Indicator):
+    """Indicator for Bears Power built from low price minus EMA."""
+
+    lines = ("value",)
+    params = (("period", 5),)
+
+    def __init__(self):
+        """Initialize EMA and minimum period.
+
+        Args:
+            self: Instance reference.
+        """
+        self.ema = ExponentialMovingAverage(self.data.close, period=self.p.period)
+        self.addminperiod(self.p.period + 3)
+
+    def next(self):
+        """Update current Bears Power value."""
+        self.lines.value[0] = float(self.data.low[0]) - float(self.ema[0])

backtrader/indicators/contrib/bw_wise_man1_signal.py

@@ -0,0 +1,102 @@
+#!/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,
+    SmoothedMovingAverage,
+)
+
+__all__ = [
+    "BWWiseMan1Signal",
+]
+
+
+class BWWiseMan1Signal(Indicator):
+    """Generate long/short trigger values based on Alligator-like MAs and ATR.
+
+    The indicator outputs two value lines (`buy`, `sell`) that represent candidate
+    entry levels for short and long flips under the configured market regime.
+    """
+
+    lines = ("sell", "buy")
+    params = (
+        ("retrogradely", True),
+        ("back", 2),
+        ("jaw_period", 13),
+        ("jaw_shift", 8),
+        ("teeth_period", 8),
+        ("teeth_shift", 5),
+        ("lips_period", 5),
+        ("lips_shift", 3),
+        ("atr_period", 15),
+    )
+
+    def __init__(self):
+        """Initialize moving average and ATR lines and minimum period requirements."""
+        median_price = (self.data.high + self.data.low) / 2.0
+        self.jaw = SmoothedMovingAverage(median_price, period=max(int(self.p.jaw_period), 1))
+        self.teeth = SmoothedMovingAverage(median_price, period=max(int(self.p.teeth_period), 1))
+        self.lips = SmoothedMovingAverage(median_price, period=max(int(self.p.lips_period), 1))
+        self.atr = ATR(self.data, period=max(int(self.p.atr_period), 1))
+        self.addminperiod(
+            max(
+                int(self.p.jaw_period) + int(self.p.jaw_shift),
+                int(self.p.teeth_period) + int(self.p.teeth_shift),
+                int(self.p.lips_period) + int(self.p.lips_shift),
+                int(self.p.atr_period),
+            )
+            + int(self.p.back)
+            + 2
+        )
+
+    def next(self):
+        """Compute current `buy`/`sell` trigger values from MA and ATR relationships."""
+        self.lines.buy[0] = 0.0
+        self.lines.sell[0] = 0.0
+
+        if len(self.data) <= max(
+            int(self.p.jaw_shift), int(self.p.teeth_shift), int(self.p.lips_shift), int(self.p.back)
+        ):
+            return
+
+        jaw = float(self.jaw[-int(self.p.jaw_shift)])
+        teeth = float(self.teeth[-int(self.p.teeth_shift)])
+        lips = float(self.lips[-int(self.p.lips_shift)])
+        high = float(self.data.high[0])
+        low = float(self.data.low[0])
+        close = float(self.data.close[0])
+        mid = (high + low) / 2.0
+        atr = float(self.atr[0])
+
+        raw_sell = 0.0
+        raw_buy = 0.0
+
+        if low > lips and low > teeth and low > jaw and close < mid:
+            contup = True
+            for i in range(1, int(self.p.back) + 1):
+                if high <= float(self.data.high[-i]):
+                    contup = False
+                    break
+            if contup:
+                raw_sell = high + atr * 3.0 / 8.0
+
+        if high < lips and high < teeth and high < jaw and close > mid:
+            contup = True
+            for i in range(1, int(self.p.back) + 1):
+                if low >= float(self.data.low[-i]):
+                    contup = False
+                    break
+            if contup:
+                raw_buy = low - atr * 3.0 / 8.0
+
+        if bool(self.p.retrogradely):
+            self.lines.buy[0] = raw_sell
+            self.lines.sell[0] = raw_buy
+        else:
+            self.lines.buy[0] = raw_buy
+            self.lines.sell[0] = raw_sell

backtrader/indicators/contrib/bykov_trend_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.
+"""
+
+from .. import Indicator
+
+__all__ = [
+    "BykovTrendIndicator",
+]
+
+
+class BykovTrendIndicator(Indicator):
+    """Reconstructs BykovTrend from its MQ5 source.
+
+    Uses WPR(SSP) + ATR(15) to detect trend flips.
+    Outputs buy_arrow / sell_arrow (non-zero price level when arrow fires).
+    """
+
+    lines = ("buy_arrow", "sell_arrow")
+    params = (
+        ("risk", 3),
+        ("ssp", 9),
+    )
+
+    def __init__(self):
+        """Cache WPR/ATR periods, the risk threshold, and set indicator warmup."""
+        self._k = 33 - int(self.p.risk)
+        self._atr_period = 15
+        self._wpr_period = int(self.p.ssp)
+        self._uptrend = True
+        self._old = True
+        self.addminperiod(max(self._wpr_period, self._atr_period) + 2)
+
+    def _calc_wpr(self):
+        period = self._wpr_period
+        if len(self.data) < period:
+            return 0.0
+        hh = max(float(self.data.high[-i]) for i in range(period))
+        ll = min(float(self.data.low[-i]) for i in range(period))
+        close_val = float(self.data.close[0])
+        if hh == ll:
+            return 0.0
+        return -100.0 * (hh - close_val) / (hh - ll)
+
+    def _calc_atr(self):
+        period = self._atr_period
+        if len(self.data) < period + 1:
+            return 0.0
+        total = 0.0
+        for i in range(period):
+            hi = float(self.data.high[-i])
+            lo = float(self.data.low[-i])
+            prev_close = float(self.data.close[-(i + 1)])
+            tr = max(hi - lo, abs(hi - prev_close), abs(prev_close - lo))
+            total += tr
+        return total / period
+
+    def next(self):
+        """Update the trend state and emit buy/sell arrow offsets on flips."""
+        k = self._k
+        wpr = self._calc_wpr()
+        atr = self._calc_atr()
+        rng = atr * 3.0 / 8.0
+
+        uptrend = self._uptrend
+        if wpr < -100 + k:
+            uptrend = False
+        if wpr > -k:
+            uptrend = True
+
+        buy_val = 0.0
+        sell_val = 0.0
+        if not self._old and uptrend:
+            buy_val = float(self.data.low[0]) - rng
+        if self._old and not uptrend:
+            sell_val = float(self.data.high[0]) + rng
+
+        self.lines.buy_arrow[0] = buy_val
+        self.lines.sell_arrow[0] = sell_val
+
+        self._old = uptrend
+        self._uptrend = uptrend

backtrader/indicators/contrib/candle_stop_color.py

@@ -0,0 +1,46 @@
+#!/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__ = [
+    "CandleStopColor",
+]
+
+
+class CandleStopColor(Indicator):
+    """Indicator computing highest-high/ lowest-low trailing stop channels with color breakout signal."""
+
+    lines = ("color_idx", "upper", "lower")
+    params = (
+        ("up_trail_periods", 5),
+        ("up_trail_shift", 5),
+        ("dn_trail_periods", 5),
+        ("dn_trail_shift", 5),
+    )
+
+    def next(self):
+        """Compute trailing high/low range and set color index based on close position."""
+        hh_indices = range(self.p.up_trail_shift, self.p.up_trail_shift + self.p.up_trail_periods)
+        ll_indices = range(self.p.dn_trail_shift, self.p.dn_trail_shift + self.p.dn_trail_periods)
+        highs = [float(self.data.high[-idx]) for idx in hh_indices if len(self.data) > idx]
+        lows = [float(self.data.low[-idx]) for idx in ll_indices if len(self.data) > idx]
+        if not highs or not lows:
+            self.lines.color_idx[0] = 4.0
+            return
+        upper = max(highs)
+        lower = min(lows)
+        close = float(self.data.close[0])
+        open_ = float(self.data.open[0])
+        self.lines.upper[0] = upper
+        self.lines.lower[0] = lower
+        color = 4.0
+        if close > upper:
+            color = 3.0 if close >= open_ else 2.0
+        elif close < lower:
+            color = 0.0 if close <= open_ else 1.0
+        self.lines.color_idx[0] = color

backtrader/indicators/contrib/candles_x_smoothed_indicator.py

@@ -0,0 +1,69 @@
+#!/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,
+    SmoothedMovingAverage,
+    WeightedMovingAverage,
+)
+
+__all__ = [
+    "CandlesXSmoothedIndicator",
+]
+
+
+def resolve_ma_class(name):
+    """Resolve moving-average strategy by string key.
+
+    Args:
+        name (str): MA method key from config.
+
+    Returns:
+        indicator: Corresponding Backtrader MA 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
+
+
+class CandlesXSmoothedIndicator(Indicator):
+    """Indicator that smooths OHLC bars with configurable MA and derives color state."""
+
+    lines = (
+        "smooth_open",
+        "smooth_high",
+        "smooth_low",
+        "smooth_close",
+        "color_state",
+    )
+    params = (
+        ("ma_method", "lwma"),
+        ("ma_length", 30),
+        ("ma_phase", 100),
+    )
+
+    def __init__(self):
+        """Initialize all smoothed OHLC lines and color state."""
+        ma_cls = resolve_ma_class(self.p.ma_method)
+        self.lines.smooth_open = ma_cls(self.data.open, period=self.p.ma_length)
+        self.lines.smooth_high = ma_cls(self.data.high, period=self.p.ma_length)
+        self.lines.smooth_low = ma_cls(self.data.low, period=self.p.ma_length)
+        self.lines.smooth_close = ma_cls(self.data.close, period=self.p.ma_length)
+        self.addminperiod(self.p.ma_length + 2)
+
+    def next(self):
+        """Set color state to bullish (`0`) or bearish (`1`) for current bar."""
+        self.lines.color_state[0] = (
+            0.0 if float(self.lines.smooth_open[0]) < float(self.lines.smooth_close[0]) else 1.0
+        )

backtrader/indicators/contrib/candlesticks_bw.py

@@ -0,0 +1,45 @@
+#!/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 (
+    SMA,
+    AwesomeOscillator,
+    Indicator,
+)
+
+__all__ = [
+    "CandlesticksBW",
+]
+
+
+class CandlesticksBW(Indicator):
+    """Indicator that encodes AO/AC state into a numeric candle color code."""
+
+    lines = ("color",)
+    params = ()
+
+    def __init__(self):
+        """Set up AO and AC dependencies and minimum period."""
+        self.addminperiod(40)
+        self.ao = AwesomeOscillator(self.data)
+        self.ac = self.ao - SMA(self.ao, period=5)
+
+    def next(self):
+        """Compute the color code for the current bar."""
+        ao0 = float(self.ao[0])
+        ao1 = float(self.ao[-1])
+        ac0 = float(self.ac[0])
+        ac1 = float(self.ac[-1])
+        open_ = float(self.data.open[0])
+        close = float(self.data.close[0])
+        if ao0 >= ao1 and ac0 >= ac1:
+            color = 0.0 if open_ <= close else 1.0
+        elif ao0 <= ao1 and ac0 <= ac1:
+            color = 5.0 if open_ >= close else 4.0
+        else:
+            color = 2.0 if open_ <= close else 3.0
+        self.lines.color[0] = color

backtrader/indicators/contrib/caudate_x_period_candle_color.py

@@ -0,0 +1,56 @@
+#!/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__ = [
+    "CaudateXPeriodCandleColor",
+]
+
+
+class CaudateXPeriodCandleColor(Indicator):
+    """Synthetic period-candle indicator emitting a color index and smoothed OHLC."""
+
+    lines = ("color_idx", "xopen", "xclose", "xhigh", "xlow")
+    params = (
+        ("cperiod", 5),
+        ("ma_length", 3),
+    )
+
+    def __init__(self):
+        """Build the smoothed OHLC moving averages and set the warmup period."""
+        self.smooth_open = SimpleMovingAverage(self.data.open, period=self.p.ma_length)
+        self.smooth_high = SimpleMovingAverage(self.data.high, period=self.p.ma_length)
+        self.smooth_low = SimpleMovingAverage(self.data.low, period=self.p.ma_length)
+        self.smooth_close = SimpleMovingAverage(self.data.close, period=self.p.ma_length)
+        self.addminperiod(self.p.ma_length + self.p.cperiod)
+
+    def next(self):
+        """Build the period candle and assign its color index from the midpoint."""
+        lookback = max(1, int(self.p.cperiod))
+        start = -(lookback - 1)
+        xopen = float(self.smooth_open[start])
+        xclose = float(self.smooth_close[0])
+        highs = [float(self.smooth_high[-i]) for i in range(lookback)]
+        lows = [float(self.smooth_low[-i]) for i in range(lookback)]
+        xhigh = max(highs)
+        xlow = min(lows)
+        self.lines.xopen[0] = xopen
+        self.lines.xclose[0] = xclose
+        self.lines.xhigh[0] = xhigh
+        self.lines.xlow[0] = xlow
+
+        color = 2.0 if xopen <= xclose else 4.0
+        candle_half = (xhigh + xlow) / 2.0
+        if xopen > candle_half and xclose > candle_half:
+            color = 0.0 if xopen <= xclose else 1.0
+        elif xopen < candle_half and xclose < candle_half:
+            color = 6.0 if xopen >= xclose else 5.0
+        self.lines.color_idx[0] = color

backtrader/indicators/contrib/cci_histogram_indicator.py

@@ -0,0 +1,53 @@
+#!/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 (
+    CommodityChannelIndex,
+    Indicator,
+)
+
+__all__ = [
+    "CCIHistogramIndicator",
+]
+
+
+class CCIHistogramIndicator(Indicator):
+    """CCI-based colour-state indicator classifying CCI into three zones.
+
+    Lines
+    -----
+    cci : float
+        Commodity Channel Index value.
+    color_state : float
+        0.0 = overbought (CCI > high_level), 1.0 = neutral, 2.0 = oversold.
+    hist_base : float
+        Always 0.0 (placeholder for histogram baseline).
+    """
+
+    lines = ("cci", "color_state", "hist_base")
+    params = (
+        ("cci_period", 14),
+        ("high_level", 100),
+        ("low_level", -100),
+    )
+
+    def __init__(self):
+        """Initialise indicator state: attach CCI sub-indicator and set minimum period."""
+        cci = CommodityChannelIndex(self.data, period=int(self.p.cci_period))
+        self.lines.cci = cci
+        self.addminperiod(int(self.p.cci_period) + 2)
+
+    def next(self):
+        """Classify current CCI value into colour state (0=overbought, 1=neutral, 2=oversold)."""
+        cci_value = float(self.lines.cci[0])
+        color = 1.0
+        if cci_value > float(self.p.high_level):
+            color = 0.0
+        elif cci_value < float(self.p.low_level):
+            color = 2.0
+        self.lines.color_state[0] = color
+        self.lines.hist_base[0] = 0.0

backtrader/indicators/contrib/cci_woodies_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 Indicator
+
+__all__ = [
+    "CCIWoodiesIndicator",
+]
+
+
+def _applied_price(data, price_type, ago=0):
+    """Get price based on ENUM_APPLIED_PRICE."""
+    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  # PRICE_CLOSE
+    if price_type == 1:
+        return o  # PRICE_OPEN
+    if price_type == 2:
+        return h  # PRICE_HIGH
+    if price_type == 3:
+        return low_price  # PRICE_LOW
+    if price_type == 4:
+        return (h + low_price) / 2  # PRICE_MEDIAN
+    if price_type == 5:
+        return (h + low_price + c) / 3  # PRICE_TYPICAL
+    if price_type == 6:
+        return (h + low_price + c + c) / 4  # PRICE_WEIGHTED
+    return c
+
+
+class CCIWoodiesIndicator(Indicator):
+    """Reconstructs CCI_Woodies indicator.
+
+    DRAW_FILLING between FastCCI and SlowCCI.
+    Buffer 0 = FastCCI, Buffer 1 = SlowCCI.
+    When Fast > Slow → bullish (Lime fill); when Fast < Slow → bearish (Plum fill).
+    """
+
+    lines = ("fast_cci", "slow_cci")
+    params = (
+        ("fast_period", 6),
+        ("fast_price", 4),
+        ("slow_period", 14),
+        ("slow_price", 4),
+    )
+
+    def __init__(self):
+        """Build internal period and price type state for fast and slow CCI."""
+        self._fp = int(self.p.fast_period)
+        self._sp = int(self.p.slow_period)
+        self._fpr = int(self.p.fast_price)
+        self._spr = int(self.p.slow_price)
+        self.addminperiod(max(self._fp, self._sp) + 2)
+
+    def _calc_cci(self, period, price_type):
+        prices = []
+        for i in range(period):
+            if i >= len(self.data):
+                break
+            prices.append(_applied_price(self.data, price_type, i))
+        if not prices:
+            return 0.0
+        mean = sum(prices) / len(prices)
+        mad = sum(abs(p - mean) for p in prices) / len(prices)
+        tp = prices[0]  # current bar
+        if mad == 0:
+            return 0.0
+        return (tp - mean) / (0.015 * mad)
+
+    def next(self):
+        """Compute and store current fast and slow CCI values for each bar."""
+        self.lines.fast_cci[0] = self._calc_cci(self._fp, self._fpr)
+        self.lines.slow_cci[0] = self._calc_cci(self._sp, self._spr)

backtrader/indicators/contrib/center_of_gravity_candle_indicator.py

@@ -0,0 +1,83 @@
+#!/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__ = [
+    "CenterOfGravityCandleIndicator",
+]
+
+
+class CenterOfGravityCandleIndicator(Indicator):
+    """Center-of-Gravity Candle indicator exposing center, signal, and state lines."""
+
+    lines = ("center", "signal", "state")
+    params = (
+        ("period", 10),
+        ("smooth_period", 3),
+        ("ma_method", "sma"),
+        ("applied_price", "close"),
+        ("point", 0.01),
+    )
+
+    def __init__(self):
+        """Build the center, signal, and warmup period from the applied price.
+
+        Side effects:
+            Computes ``center`` as the point-scaled product of an SMA and a LWMA
+            of the applied price, derives ``signal`` by smoothing ``center``, and
+            sets the minimum warmup period.
+        """
+        ma_cls = self._ma_class()
+        price = self._price_line()
+        sma = SimpleMovingAverage(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 _ma_class(self):
+        mode = str(self.p.ma_method).lower()
+        if mode in {"ema", "mode_ema"}:
+            return ExponentialMovingAverage
+        if mode in {"smma", "smoothed", "mode_smma"}:
+            return SmoothedMovingAverage
+        if mode in {"lwma", "wma", "mode_lwma"}:
+            return WeightedMovingAverage
+        return SimpleMovingAverage
+
+    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):
+        """Set ``state`` to 2 when center is above signal, else 0, for the bar."""
+        self.lines.state[0] = (
+            2.0 if float(self.lines.center[0]) > float(self.lines.signal[0]) else 0.0
+        )