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

backtrader/indicators/contrib/accumulation_distribution_line.py

@@ -0,0 +1,92 @@
+#!/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,
+)
+
+__all__ = [
+    "AccumulationDistributionLine",
+    "ChaikinOscillator",
+    "LineCCI",
+    "CCIDualOnMA",
+]
+
+
+class AccumulationDistributionLine(Indicator):
+    """Accumulate the ADL indicator from price and volume progression."""
+
+    lines = ("adl",)
+
+    def next(self):
+        """Compute one bar's accumulation/distribution line value."""
+        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 high == low:
+            money_flow_multiplier = 0.0
+        else:
+            money_flow_multiplier = ((close - low) - (high - close)) / (high - low)
+        previous = float(self.lines.adl[-1]) if len(self) > 1 else 0.0
+        self.lines.adl[0] = previous + money_flow_multiplier * volume
+
+
+class ChaikinOscillator(Indicator):
+    """Chaikin oscillator as EMA(short) minus EMA(long) of ADL."""
+
+    lines = ("cho",)
+    params = (
+        ("fast_period", 3),
+        ("slow_period", 10),
+    )
+
+    def __init__(self):
+        """Initialize fast/slow ADL EMAs."""
+        self.adl = AccumulationDistributionLine(self.data)
+        fast = ExponentialMovingAverage(self.adl, period=self.p.fast_period)
+        slow = ExponentialMovingAverage(self.adl, period=self.p.slow_period)
+        self.lines.cho = fast - slow
+
+
+class LineCCI(Indicator):
+    """Custom CCI computation on the selected input data."""
+
+    lines = ("cci",)
+    params = (("period", 14),)
+
+    def next(self):
+        """Calculate a bar's CCI value with zero-handling for degenerate windows."""
+        if len(self.data) < self.p.period:
+            self.lines.cci[0] = 0.0
+            return
+        values = [float(self.data[-i]) for i in range(self.p.period)]
+        mean_value = sum(values) / self.p.period
+        mean_dev = sum(abs(v - mean_value) for v in values) / self.p.period
+        if mean_dev == 0:
+            self.lines.cci[0] = 0.0
+            return
+        self.lines.cci[0] = (float(self.data[0]) - mean_value) / (0.015 * mean_dev)
+
+
+class CCIDualOnMA(Indicator):
+    """Provide fast/slow CCI values computed on a smoothing moving average."""
+
+    lines = ("fast", "slow")
+    params = (
+        ("ma_period", 12),
+        ("fast_period", 14),
+        ("slow_period", 50),
+    )
+
+    def __init__(self):
+        """Initialize smoothed MA and dual CCI lines."""
+        self.ma = SimpleMovingAverage(self.data.close, period=self.p.ma_period)
+        self.lines.fast = LineCCI(self.ma, period=self.p.fast_period)
+        self.lines.slow = LineCCI(self.ma, period=self.p.slow_period)

backtrader/indicators/contrib/adx_cross_hull_style_indicator.py

@@ -0,0 +1,249 @@
+#!/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 (
+    AverageTrueRange,
+    ExponentialMovingAverage,
+    Indicator,
+    MinusDirectionalIndicator,
+    PlusDirectionalIndicator,
+    SimpleMovingAverage,
+    SmoothedMovingAverage,
+    WeightedMovingAverage,
+)
+
+__all__ = [
+    "ADXCrossHullStyleIndicator",
+    "UltraXMAIndicator",
+]
+
+
+def resolve_ma_class(name):
+    """Map an MT5 moving-average method name to a backtrader indicator class.
+
+    Args:
+        name: MT5 MA method name (e.g. ``'sma'``, ``'ema'``, ``'jjma'``).
+
+    Returns:
+        The backtrader moving-average indicator class for the method, defaulting
+        to WeightedMovingAverage 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):
+    """Build an applied-price line from a data feed per MT5 price modes.
+
+    Args:
+        data: The backtrader data feed providing OHLC lines.
+        mode: MT5 applied-price mode (e.g. ``'price_close'``, ``'price_typical'``).
+
+    Returns:
+        A backtrader line expression for the selected applied price, defaulting
+        to the close line.
+    """
+    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_simple", "simple"}:
+        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 ADXCrossHullStyleIndicator(Indicator):
+    """Hull-style ADX cross indicator emitting up/down directional signal levels.
+
+    Builds smoothed +DI/-DI values from a full and a half-length directional
+    index and marks an ``up`` level on a bullish DI cross or a ``down`` level on a
+    bearish DI cross, each offset from price by a fraction of ATR.
+    """
+
+    lines = ("up", "down")
+    params = (("adx_period", 14),)
+
+    def __init__(self):
+        """Construct the directional-index and ATR components and set min period."""
+        period = max(2, int(self.p.adx_period))
+        self._plus1 = PlusDirectionalIndicator(self.data, period=period)
+        self._plus2 = PlusDirectionalIndicator(self.data, period=max(2, period // 2))
+        self._minus1 = MinusDirectionalIndicator(self.data, period=period)
+        self._minus2 = MinusDirectionalIndicator(self.data, period=max(2, period // 2))
+        self._atr = AverageTrueRange(self.data, period=10)
+        self.addminperiod(period + 12)
+
+    def next(self):
+        """Compute the per-bar up/down signal levels from smoothed DI crosses."""
+        b4plusdi = 2.0 * float(self._plus2[-1]) - float(self._plus1[-1])
+        nowplusdi = 2.0 * float(self._plus2[0]) - float(self._plus1[0])
+        b4minusdi = 2.0 * float(self._minus2[-1]) - float(self._minus1[-1])
+        nowminusdi = 2.0 * float(self._minus2[0]) - float(self._minus1[0])
+        self.lines.up[0] = 0.0
+        self.lines.down[0] = 0.0
+        if b4plusdi < b4minusdi and nowplusdi > nowminusdi:
+            self.lines.up[0] = float(self.data.low[0]) - 0.25 * float(self._atr[0])
+        if b4plusdi > b4minusdi and nowplusdi < nowminusdi:
+            self.lines.down[0] = float(self.data.high[0]) + 0.25 * float(self._atr[0])
+
+    def once(self, start, end):
+        """Vectorized batch computation of up/down signal levels over a range.
+
+        Args:
+            start: First index in the array range to compute.
+            end: One past the last index in the array range to compute.
+        """
+        plus1 = self._plus1.array
+        plus2 = self._plus2.array
+        minus1 = self._minus1.array
+        minus2 = self._minus2.array
+        atr = self._atr.array
+        low = self.data.low.array
+        high = self.data.high.array
+        up_line = self.lines.up.array
+        down_line = self.lines.down.array
+        for line in (up_line, down_line):
+            while len(line) < end:
+                line.append(float("nan"))
+
+        actual_end = min(
+            end, len(plus1), len(plus2), len(minus1), len(minus2), len(atr), len(low), len(high)
+        )
+        for i in range(start, actual_end):
+            up_line[i] = 0.0
+            down_line[i] = 0.0
+            if i <= 0:
+                continue
+            b4plusdi = 2.0 * float(plus2[i - 1]) - float(plus1[i - 1])
+            nowplusdi = 2.0 * float(plus2[i]) - float(plus1[i])
+            b4minusdi = 2.0 * float(minus2[i - 1]) - float(minus1[i - 1])
+            nowminusdi = 2.0 * float(minus2[i]) - float(minus1[i])
+            if b4plusdi < b4minusdi and nowplusdi > nowminusdi:
+                up_line[i] = float(low[i]) - 0.25 * float(atr[i])
+            if b4plusdi > b4minusdi and nowplusdi < nowminusdi:
+                down_line[i] = float(high[i]) + 0.25 * float(atr[i])
+
+
+class UltraXMAIndicator(Indicator):
+    """UltraXMA breadth indicator counting rising vs falling fanned moving averages.
+
+    Computes a fan of moving averages over increasing periods, counts how many
+    are rising (bulls) versus falling (bears) each bar, and smooths those counts
+    with an exponential factor to produce trend-strength breadth lines.
+    """
+
+    lines = ("bulls", "bears")
+    params = (
+        ("w_method", "jjma"),
+        ("start_length", 3),
+        ("wphase", 100),
+        ("step", 5),
+        ("steps_total", 10),
+        ("smooth_method", "jjma"),
+        ("smooth_length", 3),
+        ("smooth_phase", 100),
+        ("ipc", "price_close"),
+    )
+
+    def __init__(self):
+        """Build the fan of moving averages and breadth smoothing, set min period."""
+        price_line = resolve_price_line(self.data, self.p.ipc)
+        ma_cls = resolve_ma_class(self.p.w_method)
+        smooth_cls = resolve_ma_class(self.p.smooth_method)
+        self._periods = [
+            int(self.p.start_length + i * self.p.step) for i in range(int(self.p.steps_total) + 1)
+        ]
+        self._ma_lines = [ma_cls(price_line, period=max(1, p)) for p in self._periods]
+        self._bull_smooth = smooth_cls(self.lines.bulls, period=max(1, int(self.p.smooth_length)))
+        self._bear_smooth = smooth_cls(self.lines.bears, period=max(1, int(self.p.smooth_length)))
+        self.addminperiod(max(self._periods) + int(self.p.smooth_length) + 5)
+
+    def next(self):
+        """Compute and smooth the per-bar bullish/bearish moving-average counts."""
+        upsch = 0.0
+        dnsch = 0.0
+        for ma_line in self._ma_lines:
+            if float(ma_line[0]) > float(ma_line[-1]):
+                upsch += 1.0
+            else:
+                dnsch += 1.0
+        period = max(1, int(self.p.smooth_length))
+        alpha = 2.0 / (period + 1.0)
+        prev_bulls = float(self.lines.bulls[-1]) if len(self) > 0 else upsch
+        prev_bears = float(self.lines.bears[-1]) if len(self) > 0 else dnsch
+        if prev_bulls != prev_bulls:
+            prev_bulls = upsch
+        if prev_bears != prev_bears:
+            prev_bears = dnsch
+        self.lines.bulls[0] = alpha * upsch + (1.0 - alpha) * prev_bulls if len(self) > 0 else upsch
+        self.lines.bears[0] = alpha * dnsch + (1.0 - alpha) * prev_bears if len(self) > 0 else dnsch
+
+    def once(self, start, end):
+        """Vectorized batch computation of smoothed breadth counts over a range.
+
+        Args:
+            start: First index in the array range to compute.
+            end: One past the last index in the array range to compute.
+        """
+        ma_arrays = [ma_line.array for ma_line in self._ma_lines]
+        bulls_line = self.lines.bulls.array
+        bears_line = self.lines.bears.array
+        for line in (bulls_line, bears_line):
+            while len(line) < end:
+                line.append(float("nan"))
+
+        period = max(1, int(self.p.smooth_length))
+        alpha = 2.0 / (period + 1.0)
+        prev_bulls = None
+        prev_bears = None
+        actual_end = min([end] + [len(array) for array in ma_arrays])
+        for i in range(start, actual_end):
+            upsch = 0.0
+            dnsch = 0.0
+            for ma_array in ma_arrays:
+                if i > 0 and float(ma_array[i]) > float(ma_array[i - 1]):
+                    upsch += 1.0
+                else:
+                    dnsch += 1.0
+            bulls = upsch if prev_bulls is None else alpha * upsch + (1.0 - alpha) * prev_bulls
+            bears = dnsch if prev_bears is None else alpha * dnsch + (1.0 - alpha) * prev_bears
+            bulls_line[i] = bulls
+            bears_line[i] = bears
+            prev_bulls = bulls
+            prev_bears = bears

backtrader/indicators/contrib/adxdmi.py

@@ -0,0 +1,34 @@
+#!/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,
+    MinusDirectionalIndicator,
+    PlusDirectionalIndicator,
+)
+
+__all__ = [
+    "ADXDMI",
+]
+
+
+class ADXDMI(Indicator):
+    """DMI direction indicator exposing plus/minus directional values."""
+
+    lines = ("plus", "minus")
+    params = (("period", 14),)
+
+    def __init__(self):
+        """Initialize plus and minus directional sub-indicators."""
+        self.addminperiod(int(self.p.period) + 3)
+        self.plus_di = PlusDirectionalIndicator(self.data, period=int(self.p.period))
+        self.minus_di = MinusDirectionalIndicator(self.data, period=int(self.p.period))
+
+    def next(self):
+        """Write current directional index values to output lines."""
+        self.lines.plus[0] = float(self.plus_di[0])
+        self.lines.minus[0] = float(self.minus_di[0])

backtrader/indicators/contrib/ai_acceleration_deceleration_oscillator.py

@@ -0,0 +1,34 @@
+#!/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__ = [
+    "AIAccelerationDecelerationOscillator",
+]
+
+
+class AIAccelerationDecelerationOscillator(Indicator):
+    """Indicator computing acceleration/deceleration oscillator from SMA spread."""
+
+    lines = ("ac",)
+    params = (
+        ("fast", 5),
+        ("slow", 34),
+        ("signal", 5),
+    )
+
+    def __init__(self):
+        """Initialize AC line based on fast/slow/signal SMAs."""
+        median = (self.data.high + self.data.low) / 2.0
+        ao = SimpleMovingAverage(median, period=self.p.fast) - SimpleMovingAverage(
+            median, period=self.p.slow
+        )
+        self.lines.ac = ao - SimpleMovingAverage(ao, period=self.p.signal)

backtrader/indicators/contrib/altr_trend_signal_v22.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 (
+    AverageDirectionalMovementIndex,
+    Indicator,
+)
+
+__all__ = [
+    "AltrTrendSignalV22",
+]
+
+
+class AltrTrendSignalV22(Indicator):
+    """Adaptive trend breakout indicator used by the strategy."""
+
+    lines = ("sell", "buy")
+    params = (
+        ("k", 30),
+        ("kstop", 0.5),
+        ("kperiod", 150),
+        ("per_adx", 14),
+    )
+
+    def __init__(self):
+        """Create ADX trend indicator and initialize state."""
+        self.adx = AverageDirectionalMovementIndex(self.data, period=max(int(self.p.per_adx), 1))
+        self.addminperiod(max(int(self.p.per_adx), 1) + 2)
+        self._trend = 0
+
+    def next(self):
+        """Compute breakout level and emit short/long trigger values."""
+        self.lines.buy[0] = 0.0
+        self.lines.sell[0] = 0.0
+
+        adx_prev = float(self.adx[-1]) if len(self) > 1 else float(self.adx[0])
+        if math.isnan(adx_prev) or adx_prev <= 0:
+            return
+
+        ssp = max(int(math.ceil(float(self.p.kperiod) / adx_prev)), 1)
+        lookback = min(ssp, len(self.data))
+        if lookback <= 0:
+            return
+
+        highs = []
+        lows = []
+        avg_range = 0.0
+        for idx in range(lookback):
+            high = float(self.data.high[-idx])
+            low = float(self.data.low[-idx])
+            highs.append(high)
+            lows.append(low)
+            avg_range += abs(high - low)
+
+        trading_range = avg_range / (ssp + 1.0)
+        ss_max = max(highs)
+        ss_min = min(lows)
+        threshold = (ss_max - ss_min) * float(self.p.k) / 100.0
+        smin = ss_min + threshold
+        smax = ss_max - threshold
+
+        previous_trend = self._trend
+        trend = previous_trend
+        close = float(self.data.close[0])
+
+        if close < smin:
+            trend = -1
+        if close > smax:
+            trend = 1
+
+        if previous_trend == 0:
+            previous_trend = trend
+
+        if trend != previous_trend and close > smax:
+            self.lines.buy[0] = float(self.data.low[0]) - trading_range * float(self.p.kstop)
+        if trend != previous_trend and close < smin:
+            self.lines.sell[0] = float(self.data.high[0]) + trading_range * float(self.p.kstop)
+
+        self._trend = trend if trend != 0 else previous_trend

backtrader/indicators/contrib/anchored_momentum_line.py

@@ -0,0 +1,115 @@
+#!/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,
+)
+
+__all__ = [
+    "AnchoredMomentumLine",
+    "AnchoredMomentumCandleIndicator",
+]
+
+
+class AnchoredMomentumLine(Indicator):
+    """Anchored Momentum line: EMA-vs-SMA percentage plus a zone classifier."""
+
+    lines = ("momentum", "zone")
+    params = (
+        ("mom_period", 8),
+        ("smooth_period", 6),
+        ("up_level", 0.025),
+        ("dn_level", -0.025),
+    )
+
+    def __init__(self):
+        """Create the SMA/EMA sub-indicators and set the minimum period."""
+        self.sma = SimpleMovingAverage(self.data, period=int(self.p.mom_period))
+        self.ema = ExponentialMovingAverage(self.data, period=int(self.p.mom_period))
+        self.addminperiod(int(self.p.mom_period) + 2)
+
+    def next(self):
+        """Compute the percentage momentum and assign its up/neutral/down zone."""
+        sma = float(self.sma[0])
+        if sma == 0:
+            momentum = 0.0
+        else:
+            momentum = 100.0 * (float(self.ema[0]) / sma - 1.0)
+        self.lines.momentum[0] = momentum
+        if momentum > float(self.p.up_level):
+            zone = 2
+        elif momentum < float(self.p.dn_level):
+            zone = 0
+        else:
+            zone = 1
+        self.lines.zone[0] = zone
+
+
+class AnchoredMomentumCandleIndicator(Indicator):
+    """Synthetic candle from Anchored Momentum on each OHLC price plus colour."""
+
+    lines = ("a_open", "a_high", "a_low", "a_close", "color")
+    params = (
+        ("mom_period", 8),
+        ("smooth_period", 6),
+        ("up_level", 0.025),
+        ("dn_level", -0.025),
+    )
+
+    def __init__(self):
+        """Create the four per-price Anchored Momentum lines and set min period."""
+        self.mom_open = AnchoredMomentumLine(
+            self.data.open,
+            mom_period=self.p.mom_period,
+            smooth_period=self.p.smooth_period,
+            up_level=self.p.up_level,
+            dn_level=self.p.dn_level,
+        )
+        self.mom_high = AnchoredMomentumLine(
+            self.data.high,
+            mom_period=self.p.mom_period,
+            smooth_period=self.p.smooth_period,
+            up_level=self.p.up_level,
+            dn_level=self.p.dn_level,
+        )
+        self.mom_low = AnchoredMomentumLine(
+            self.data.low,
+            mom_period=self.p.mom_period,
+            smooth_period=self.p.smooth_period,
+            up_level=self.p.up_level,
+            dn_level=self.p.dn_level,
+        )
+        self.mom_close = AnchoredMomentumLine(
+            self.data.close,
+            mom_period=self.p.mom_period,
+            smooth_period=self.p.smooth_period,
+            up_level=self.p.up_level,
+            dn_level=self.p.dn_level,
+        )
+        self.addminperiod(int(self.p.mom_period) + 2)
+
+    def next(self):
+        """Assemble the momentum candle OHLC and colour for the current bar."""
+        o = float(self.mom_open.momentum[0])
+        h = max(float(self.mom_high.momentum[0]), o)
+        low_price = min(float(self.mom_low.momentum[0]), o)
+        c = float(self.mom_close.momentum[0])
+        h = max(h, c)
+        low_price = min(low_price, c)
+        self.lines.a_open[0] = o
+        self.lines.a_high[0] = h
+        self.lines.a_low[0] = low_price
+        self.lines.a_close[0] = c
+        if o < c:
+            color = 2
+        elif o > c:
+            color = 0
+        else:
+            color = 1
+        self.lines.color[0] = color

backtrader/indicators/contrib/any_range_cld_tail_indicator.py

@@ -0,0 +1,82 @@
+#!/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 backtrader.utils.dateintern import num2date
+
+from .. import Indicator
+
+__all__ = [
+    "AnyRangeCldTailIndicator",
+]
+
+
+class AnyRangeCldTailIndicator(Indicator):
+    """Compute a session-based daily channel and color-state trend signal."""
+
+    lines = ("color_state", "upper", "lower")
+    params = (
+        ("time1", "02:00"),
+        ("time2", "07:00"),
+    )
+
+    def __init__(self):
+        """Initialize session boundaries and window tracking state."""
+        self._time1 = self._parse_hhmm(self.p.time1)
+        self._time2 = self._parse_hhmm(self.p.time2)
+        self._window_start = min(self._time1, self._time2)
+        self._window_end = max(self._time1, self._time2)
+        self._current_day = None
+        self._range_high = None
+        self._range_low = None
+        self._channel_high = None
+        self._channel_low = None
+        self._window_finalized = False
+        self.addminperiod(2)
+
+    @staticmethod
+    def _parse_hhmm(value):
+        hour, minute = value.split(":")
+        return int(hour) * 60 + int(minute)
+
+    def next(self):
+        """Update channel bounds and emit color state for the current bar."""
+        dt = num2date(self.data.datetime[0])
+        day = dt.date()
+        minute = dt.hour * 60 + dt.minute
+        if self._current_day != day:
+            self._current_day = day
+            self._range_high = None
+            self._range_low = None
+            self._channel_high = None
+            self._channel_low = None
+            self._window_finalized = False
+        in_window = self._window_start < minute <= self._window_end
+        if in_window:
+            high = float(self.data.high[0])
+            low = float(self.data.low[0])
+            self._range_high = high if self._range_high is None else max(self._range_high, high)
+            self._range_low = low if self._range_low is None else min(self._range_low, low)
+        elif (
+            minute > self._window_end
+            and not self._window_finalized
+            and self._range_high is not None
+            and self._range_low is not None
+        ):
+            self._channel_high = self._range_high
+            self._channel_low = self._range_low
+            self._window_finalized = True
+        color = 4.0
+        if self._channel_high is not None and self._channel_low is not None and not in_window:
+            close = float(self.data.close[0])
+            open_ = float(self.data.open[0])
+            if close > self._channel_high:
+                color = 3.0 if close >= open_ else 2.0
+            elif close < self._channel_low:
+                color = 0.0 if close <= open_ else 1.0
+        self.lines.color_state[0] = color
+        self.lines.upper[0] = self._channel_high if self._channel_high is not None else float("nan")
+        self.lines.lower[0] = self._channel_low if self._channel_low is not None else float("nan")