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

backtrader/indicators/contrib/three_line_break_indicator.py

@@ -0,0 +1,64 @@
+#!/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__ = [
+    "ThreeLineBreakIndicator",
+]
+
+
+class ThreeLineBreakIndicator(Indicator):
+    """Three Line Break indicator used as a higher-timeframe trend signal source.
+
+    The indicator tracks a directional swing state based on the last
+    ``lines_break`` bars. A bearish-to-bullish and bullish-to-bearish shift
+    is confirmed by breakouts above the recent highs or below the recent lows.
+
+    Output lines:
+    - ``trend``: ``1.0`` for bullish trend, ``0.0`` for bearish trend.
+    - ``line_high``: current bar high value.
+    - ``line_low``: current bar low value.
+    """
+
+    lines = ("trend", "line_high", "line_low")
+    params = (("lines_break", 3),)
+
+    def __init__(self):
+        """Initialize internal swing state and minimum period.
+
+        Args:
+            lines_break: Number of bars used for the breakout envelope.
+        """
+        self._swing = True
+        self._initialized = False
+        self.addminperiod(int(self.p.lines_break) + 2)
+
+    def next(self):
+        """Advance the Three Line Break trend and output the current trend lines.
+
+        Returns:
+            None.
+        """
+        lines_break = int(self.p.lines_break)
+        if len(self.data) <= lines_break:
+            self.lines.trend[0] = 0.0 if self._swing else 1.0
+            self.lines.line_high[0] = float(self.data.high[0])
+            self.lines.line_low[0] = float(self.data.low[0])
+            return
+
+        hh = max(float(self.data.high[-i]) for i in range(1, lines_break + 1))
+        ll = min(float(self.data.low[-i]) for i in range(1, lines_break + 1))
+
+        if self._swing and float(self.data.low[0]) < ll:
+            self._swing = False
+        if (not self._swing) and float(self.data.high[0]) > hh:
+            self._swing = True
+
+        self.lines.line_high[0] = float(self.data.high[0])
+        self.lines.line_low[0] = float(self.data.low[0])
+        self.lines.trend[0] = 0.0 if self._swing else 1.0

backtrader/indicators/contrib/time_line.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 backtrader.utils.dateintern import num2date
+
+from .. import Indicator
+
+__all__ = [
+    "TimeLine",
+]
+
+
+class TimeLine(Indicator):
+    """Time average price line indicator
+
+    Calculate the cumulative average of the day's closing prices as the time average price line
+    """
+
+    lines = ("day_avg_price",)
+    params = (("day_end_time", (15, 0, 0)),)
+
+    def __init__(self):
+        """Initialize the TimeLine indicator.
+
+        Creates an empty list to store closing prices for the current day.
+        The cumulative average of these prices will be calculated as the
+        time average price line.
+        """
+        self.day_close_price_list = []
+
+    def next(self):
+        """Calculate the time average price for the current bar.
+
+        This method is called for each bar in the data series. It:
+        1. Appends the current bar's close price to the day's price list
+        2. Calculates the cumulative average of all prices in the list
+        3. Resets the price list at the end of the trading day
+
+        The time average price line is useful for intraday strategies as it
+        represents the average entry price of all market participants throughout
+        the day.
+        """
+        self.day_close_price_list.append(self.data.close[0])
+        self.lines.day_avg_price[0] = sum(self.day_close_price_list) / len(
+            self.day_close_price_list
+        )
+
+        self.current_datetime = num2date(self.data.datetime[0])
+        self.current_hour = self.current_datetime.hour
+        self.current_minute = self.current_datetime.minute
+        day_end_hour, day_end_minute, _ = self.p.day_end_time
+        if self.current_hour == day_end_hour and self.current_minute == day_end_minute:
+            self.day_close_price_list = []

backtrader/indicators/contrib/trading_channel_index_proxy.py

@@ -0,0 +1,48 @@
+#!/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,
+    StandardDeviation,
+)
+
+__all__ = [
+    "TradingChannelIndexProxy",
+]
+
+
+class TradingChannelIndexProxy(Indicator):
+    """Indicator computing Trading Channel Index (TCI) and quantized state."""
+
+    lines = ("tci", "color_index")
+    params = (
+        ("length1", 60),
+        ("length2", 30),
+        ("coeff", 0.015),
+        ("high_level", 50),
+        ("low_level", -50),
+    )
+
+    def __init__(self):
+        """Initialize indicator inputs used by the TCI computation."""
+        self.sma1 = SimpleMovingAverage(self.data.close, period=self.p.length1)
+        self.dev = StandardDeviation(self.data.close, period=self.p.length1)
+        self.addminperiod(max(self.p.length1, self.p.length2) + 5)
+
+    def next(self):
+        """Compute raw TCI and discretized color state for the current bar."""
+        base = float(self.sma1[0])
+        dev = max(float(self.dev[0]), 1e-8)
+        raw = (float(self.data.close[0]) - base) / (dev * self.p.coeff)
+        self.lines.tci[0] = raw
+        if raw <= self.p.low_level:
+            self.lines.color_index[0] = 0.0
+        elif raw >= self.p.high_level:
+            self.lines.color_index[0] = 4.0
+        else:
+            self.lines.color_index[0] = 2.0

backtrader/indicators/contrib/trend_arrows_indicator.py

@@ -0,0 +1,109 @@
+#!/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__ = [
+    "TrendArrowsIndicator",
+]
+
+
+class TrendArrowsIndicator(Indicator):
+    """Reconstructs trend_arrows indicator.
+
+    Computes AverageHigh (avg of highest highs over iPeriod sub-windows)
+    and AverageLow (avg of lowest lows over iPeriod sub-windows).
+    TrendUp = LL when close > HH; TrendDown = HH when close < LL;
+    else continues previous trend.
+    SignUp when TrendUp appears fresh; SignDown when TrendDown appears fresh.
+    Buffers: 0=TrendUp, 1=TrendDown, 2=SignUp(buy), 3=SignDown(sell).
+    """
+
+    lines = ("trend_up", "trend_down", "sign_up", "sign_down")
+    params = (
+        ("iperiod", 15),
+        ("ifullperiods", 1),
+    )
+
+    def __init__(self):
+        """Initialize cached period lengths for trend arrow reconstruction."""
+        self._ip = int(self.p.iperiod)
+        self._ifp = int(self.p.ifullperiods)
+        self._window = self._ip + self._ifp
+        self.addminperiod(self._window + 2)
+
+    def next(self):
+        """Compute trend and signal buffers for the current bar.
+
+        The method:
+        1. Splits the lookback window into `iperiod` sub-windows and averages highs/lows.
+        2. Generates TrendUp/TrendDown buffers based on close relative to aggregated levels.
+        3. Emits SignUp/SignDown only on fresh transitions from inactive to active.
+        """
+        ip = self._ip
+        window = self._window
+
+        # Compute AverageHigh: average of highest highs over ip sub-windows
+        segment_size = max(window // ip, 1)
+        hh_sum = 0.0
+        ll_sum = 0.0
+        count = 0
+        for seg in range(ip):
+            start = seg * segment_size
+            end = min(start + segment_size, window)
+            if start >= len(self.data):
+                break
+            seg_high = -1e30
+            seg_low = 1e30
+            for k in range(start, min(end, len(self.data))):
+                h = float(self.data.high[-k]) if k > 0 else float(self.data.high[0])
+                low_price = float(self.data.low[-k]) if k > 0 else float(self.data.low[0])
+                if h > seg_high:
+                    seg_high = h
+                if low_price < seg_low:
+                    seg_low = low_price
+            hh_sum += seg_high
+            ll_sum += seg_low
+            count += 1
+
+        hh = hh_sum / count if count else float(self.data.high[0])
+        ll = ll_sum / count if count else float(self.data.low[0])
+
+        close_val = float(self.data.close[0])
+        prev_tu = float(self.lines.trend_up[-1]) if len(self.lines.trend_up) > 1 else 0.0
+        prev_td = float(self.lines.trend_down[-1]) if len(self.lines.trend_down) > 1 else 0.0
+        if math.isnan(prev_tu):
+            prev_tu = 0.0
+        if math.isnan(prev_td):
+            prev_td = 0.0
+
+        tu = 0.0
+        td = 0.0
+
+        if close_val > hh:
+            tu = ll
+        elif close_val < ll:
+            td = hh
+        else:
+            if prev_td != 0.0:
+                td = hh
+            if prev_tu != 0.0:
+                tu = ll
+
+        su = 0.0
+        sd = 0.0
+        if prev_tu == 0.0 and tu != 0.0:
+            su = tu
+        if prev_td == 0.0 and td != 0.0:
+            sd = td
+
+        self.lines.trend_up[0] = tu
+        self.lines.trend_down[0] = td
+        self.lines.sign_up[0] = su
+        self.lines.sign_down[0] = sd

backtrader/indicators/contrib/trend_continuation_indicator.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.
+"""
+
+from .. import (
+    ExponentialMovingAverage,
+    Indicator,
+    SimpleMovingAverage,
+    SmoothedMovingAverage,
+    WeightedMovingAverage,
+)
+
+__all__ = [
+    "TrendContinuationIndicator",
+]
+
+
+def resolve_ma_class(name):
+    """Resolve a strategy MA mode string to a Backtrader MA indicator class."""
+    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):
+    """Resolve requested price source string to the corresponding line in data.
+
+    Args:
+        data: Backtrader data feed.
+        mode: Configured price selector such as ``price_close`` or ``price_open``.
+
+    Returns:
+        A line object for the selected price representation.
+    """
+    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 TrendContinuationIndicator(Indicator):
+    """Momentum continuation indicator using smoothed up/down directional components."""
+
+    lines = ("up", "down")
+    params = (
+        ("nperiod", 20),
+        ("xmethod", "t3"),
+        ("xperiod", 5),
+        ("xphase", 61),
+        ("ipc", "price_close"),
+    )
+
+    def __init__(self):
+        """Resolve price source and moving-average class then enforce warm-up period."""
+        self._price = resolve_price_line(self.data, self.p.ipc)
+        self._ma_cls = resolve_ma_class(self.p.xmethod)
+        self.addminperiod(int(self.p.nperiod) + int(self.p.xperiod) + 5)
+
+    def next(self):
+        """Compute smoothed up/down continuation values from directional price differences."""
+        nperiod = max(2, int(self.p.nperiod))
+        float(self._price[0]) - float(self._price[-1])
+        positives = []
+        negatives = []
+        cf_p = []
+        cf_n = []
+        running_p = 0.0
+        running_n = 0.0
+        for i in range(nperiod):
+            diff = float(self._price[-i]) - float(self._price[-i - 1])
+            pos = -diff if diff > 0 else 0.0
+            neg = diff if diff < 0 else 0.0
+            running_p += pos
+            running_n += neg
+            positives.append(pos)
+            negatives.append(neg)
+            cf_p.append(running_p)
+            cf_n.append(running_n)
+        ch_p = sum(positives)
+        ch_n = sum(negatives)
+        cff_p = sum(cf_p)
+        cff_n = sum(cf_n)
+        k_p = ch_p - cff_n
+        k_n = ch_n - cff_p
+        period = max(1, int(self.p.xperiod))
+        alpha = 2.0 / (period + 1.0)
+        prev_up = float(self.lines.up[-1]) if len(self) > 0 else k_p
+        prev_dn = float(self.lines.down[-1]) if len(self) > 0 else k_n
+        self.lines.up[0] = alpha * k_p + (1.0 - alpha) * prev_up if len(self) > 0 else k_p
+        self.lines.down[0] = alpha * k_n + (1.0 - alpha) * prev_dn if len(self) > 0 else k_n

backtrader/indicators/contrib/trend_intensity_index_proxy.py

@@ -0,0 +1,51 @@
+#!/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,
+    StandardDeviation,
+)
+
+__all__ = [
+    "TrendIntensityIndexProxy",
+]
+
+
+class TrendIntensityIndexProxy(Indicator):
+    """Indicator computing Trend Intensity Index (TII) and quantized state."""
+
+    lines = ("tii", "color_index")
+    params = (
+        ("length1", 60),
+        ("length2", 30),
+        ("high_level", 80),
+        ("low_level", 20),
+    )
+
+    def __init__(self):
+        """Initialize SMA/EMA/dev components for TII calculation."""
+        self.sma = SimpleMovingAverage(self.data.close, period=self.p.length1)
+        self.smooth = ExponentialMovingAverage(self.data.close, period=self.p.length2)
+        self.dev = StandardDeviation(self.data.close, period=self.p.length1)
+        self.addminperiod(max(self.p.length1, self.p.length2) + 5)
+
+    def next(self):
+        """Compute normalized TII value and discretized color state."""
+        baseline = float(self.sma[0])
+        smoothed = float(self.smooth[0])
+        dev = max(float(self.dev[0]), 1e-8)
+        value = 50.0 + (smoothed - baseline) / dev * 10.0
+        value = max(0.0, min(100.0, value))
+        self.lines.tii[0] = value
+        if value <= self.p.low_level:
+            self.lines.color_index[0] = 0.0
+        elif value >= self.p.high_level:
+            self.lines.color_index[0] = 4.0
+        else:
+            self.lines.color_index[0] = 2.0

backtrader/indicators/contrib/trend_manager_indicator.py

@@ -0,0 +1,39 @@
+#!/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__ = [
+    "TrendManagerIndicator",
+]
+
+
+class TrendManagerIndicator(Indicator):
+    """Simple MA-based trend indicator generating color state."""
+
+    lines = ("color_state", "fast_line", "slow_line")
+    params = (
+        ("length1", 23),
+        ("length2", 84),
+    )
+
+    def __init__(self):
+        """Initialize fast and slow SMAs for crossover detection."""
+        self.fast = SimpleMovingAverage(self.data.close, period=self.p.length1)
+        self.slow = SimpleMovingAverage(self.data.close, period=self.p.length2)
+        self.addminperiod(max(self.p.length1, self.p.length2) + 3)
+
+    def next(self):
+        """Update trend lines and color state on each bar."""
+        fast = float(self.fast[0])
+        slow = float(self.slow[0])
+        self.lines.fast_line[0] = fast
+        self.lines.slow_line[0] = slow
+        self.lines.color_state[0] = 0.0 if fast >= slow else 1.0

backtrader/indicators/contrib/tri_x_candle_indicator.py

@@ -0,0 +1,51 @@
+#!/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 (
+    TRIX,
+    Indicator,
+)
+
+__all__ = [
+    "TriXCandleIndicator",
+]
+
+
+class TriXCandleIndicator(Indicator):
+    """Indicator that transforms TRIX values into a candle-style representation."""
+
+    lines = ("o", "h", "l", "c", "color")
+    params = (("period", 14),)
+
+    def __init__(self):
+        """Initialize TRIX line calculators and minimum data warmup."""
+        self.addminperiod(int(self.p.period) + 2)
+        self.trix_open = TRIX(self.data.open, period=int(self.p.period))
+        self.trix_high = TRIX(self.data.high, period=int(self.p.period))
+        self.trix_low = TRIX(self.data.low, period=int(self.p.period))
+        self.trix_close = TRIX(self.data.close, period=int(self.p.period))
+
+    def next(self):
+        """Compute per-bar TRIX O/H/L/C proxy values and color state."""
+        o = float(self.trix_open[0])
+        h = float(self.trix_high[0])
+        low_price = float(self.trix_low[0])
+        c = float(self.trix_close[0])
+        mx = max(o, c)
+        mn = min(o, c)
+        h = max(mx, h)
+        low_price = min(mn, low_price)
+        color = 1
+        if o < c:
+            color = 2
+        elif o > c:
+            color = 0
+        self.lines.o[0] = o
+        self.lines.h[0] = h
+        self.lines.l[0] = low_price
+        self.lines.c[0] = c
+        self.lines.color[0] = color

backtrader/indicators/contrib/trigger_line.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__ = [
+    "TriggerLine",
+]
+
+
+class TriggerLine(Indicator):
+    """Trigger-line indicator tracking momentum-driven main and signal lines."""
+
+    lines = ("main", "signal")
+    params = (
+        ("rperiod", 24),
+        ("lsma_period", 6),
+        ("price", "close"),
+    )
+
+    def __init__(self):
+        """Initialize indicator coefficients and warmup."""
+        self.addminperiod(int(self.p.rperiod) + 3)
+        self.lengthvar = (int(self.p.rperiod) + 1) / 3.0
+        self.kr = 6.0 / (float(self.p.rperiod) * (float(self.p.rperiod) + 1.0))
+        self.klsma = 2.0 / (float(self.p.lsma_period) + 1.0)
+
+    def _price(self, index=0):
+        p = str(self.p.price).lower()
+        if p == "open":
+            return float(self.data.open[index])
+        if p == "high":
+            return float(self.data.high[index])
+        if p == "low":
+            return float(self.data.low[index])
+        if p == "median":
+            return (float(self.data.high[index]) + float(self.data.low[index])) / 2.0
+        if p == "typical":
+            return (
+                float(self.data.high[index])
+                + float(self.data.low[index])
+                + float(self.data.close[index])
+            ) / 3.0
+        if p == "weighted":
+            return (
+                float(self.data.high[index])
+                + float(self.data.low[index])
+                + 2.0 * float(self.data.close[index])
+            ) / 4.0
+        return float(self.data.close[index])
+
+    def next(self):
+        """Compute main and signal values for current bar."""
+        total = 0.0
+        rp = int(self.p.rperiod)
+        for iii in range(rp, 0, -1):
+            idx = -(rp - iii)
+            total += (iii - self.lengthvar) * self._price(idx)
+        main = total * self.kr
+        prev_main = float(self.lines.main[-1]) if len(self) > 1 else main
+        self.lines.main[0] = main
+        self.lines.signal[0] = prev_main + (main - prev_main) * self.klsma

backtrader/indicators/contrib/triple_ema_rate.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 (
+    EMA,
+    Indicator,
+)
+
+__all__ = [
+    "TripleEmaRate",
+]
+
+
+class TripleEmaRate(Indicator):
+    """TRIX: the bar-over-bar rate of change of a triple-smoothed EMA."""
+
+    lines = ("value",)
+    params = (("period", 14),)
+
+    def __init__(self):
+        """Build the three chained EMAs and set the minimum warm-up period."""
+        self.ema1 = EMA(self.data, period=self.p.period)
+        self.ema2 = EMA(self.ema1, period=self.p.period)
+        self.ema3 = EMA(self.ema2, period=self.p.period)
+        self.addminperiod(self.p.period * 3 + 2)
+
+    def next(self):
+        """Emit the fractional change of the triple EMA versus the prior bar."""
+        prev = float(self.ema3[-1])
+        self.lines.value[0] = (float(self.ema3[0]) - prev) / prev if prev else 0.0