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

backtrader/indicators/contrib/zpf_indicator.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 (
+    EMA,
+    SMA,
+    Indicator,
+    SmoothedMovingAverage,
+    WeightedMovingAverage,
+)
+
+__all__ = [
+    "ZPFIndicator",
+]
+
+
+def resolve_ma_class(name):
+    """Map a moving-average name to its backtrader indicator class.
+
+    Args:
+        name: MA type name (e.g. ``sma``, ``ema``, ``smma`` or MT5-style
+            ``mode_*`` variants).
+
+    Returns:
+        The matching backtrader moving-average indicator class, defaulting to
+        the weighted moving average for unrecognized names.
+    """
+    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
+
+
+def resolve_price_line(data, mode):
+    """Return the applied-price line for a data feed given a price mode.
+
+    Args:
+        data: The data feed providing OHLC lines.
+        mode: Applied-price selector (e.g. ``price_close``, ``price_median``,
+            ``price_typical`` or their short forms).
+
+    Returns:
+        A line expression for the selected applied price, defaulting to the
+        close for unrecognized modes.
+    """
+    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_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
+    if price_mode in {"price_trendfollow0", "trendfollow0"}:
+        return (data.high + data.low + data.close + data.close) / 4.0
+    if price_mode in {"price_trendfollow1", "trendfollow1"}:
+        return (data.high + data.low + data.close + data.open + data.close) / 5.0
+    return data.close
+
+
+class ZPFIndicator(Indicator):
+    """Zero Power Flow oscillator (volume-weighted MA spread).
+
+    Multiplies a moving average of volume by the gap between a short and a long
+    moving average of an applied price, producing a volume-weighted
+    trend-strength value (``zpf``) that oscillates around zero, with symmetric
+    ``line1``/``line2`` envelopes.
+    """
+
+    lines = (
+        "line1",
+        "line2",
+        "zpf",
+    )
+    params = (
+        ("xma_method", "sma"),
+        ("xlength", 12),
+        ("xphase", 15),
+        ("ipc", "price_close"),
+        ("volume_type", "tick"),
+    )
+
+    def __init__(self):
+        """Build the price/volume moving averages and the ZPF lines."""
+        ma_cls = resolve_ma_class(self.p.xma_method)
+        price_line = resolve_price_line(self.data, self.p.ipc)
+        volume_line = (
+            self.data.volume
+            if str(self.p.volume_type).lower() == "tick"
+            else self.data.openinterest
+        )
+        self.x1ma = ma_cls(price_line, period=self.p.xlength)
+        self.x2ma = ma_cls(price_line, period=max(1, 2 * self.p.xlength))
+        self.xvol = ma_cls(volume_line, period=self.p.xlength)
+        self.lines.zpf = self.xvol * (self.x1ma - self.x2ma) / 2.0
+        self.lines.line1 = -self.lines.zpf
+        self.lines.line2 = self.lines.zpf
+        self.addminperiod(max(2 * self.p.xlength, self.p.xlength) + 2)

backtrader/indicators/crossover.py

@@ -0,0 +1,337 @@
+#!/usr/bin/env python
+"""Crossover Indicator Module - Crossover detection indicators.
+
+This module provides indicators for detecting when two data series cross
+each other (upward or downward).
+
+Classes:
+    NonZeroDifference: Tracks difference, memorizing last non-zero value (alias: NZD).
+    CrossUp: Detects upward crossover.
+    CrossDown: Detects downward crossover.
+    CrossOver: Detects both directional crossovers.
+
+Example:
+    class MyStrategy(bt.Strategy):
+        def __init__(self):
+            self.sma_fast = bt.indicators.SMA(self.data, period=10)
+            self.sma_slow = bt.indicators.SMA(self.data, period=20)
+            self.crossover = bt.indicators.CrossOver(self.sma_fast, self.sma_slow)
+
+        def next(self):
+            if self.crossover[0] > 0:
+                self.buy()
+            elif self.crossover[0] < 0:
+                self.sell()
+"""
+
+from . import Indicator
+
+
+class NonZeroDifference(Indicator):
+    """
+    Keeps track of the difference between two data inputs, memorizing
+    the last non-zero value if the current difference is zero
+    """
+
+    _mindatas = 2
+    alias = ("NZD",)
+    lines = ("nzd",)
+
+    def __init__(self):
+        """Initialize the NonZeroDifference indicator.
+
+        Tracks difference between two data sources.
+        """
+        super().__init__()
+
+    def nextstart(self):
+        """Initialize NZD on first valid bar.
+
+        Sets initial difference value.
+        """
+        self.l.nzd[0] = self.data0[0] - self.data1[0]
+
+    def next(self):
+        """Calculate NZD for the current bar.
+
+        Memorizes last non-zero difference when current difference is zero.
+        """
+        d = self.data0[0] - self.data1[0]
+        # Memorize last non-zero value
+        new_val = d if d else self.l.nzd[-1]
+        self.l.nzd[0] = new_val
+
+    # Don't override once() - let framework call next() for each bar
+
+
+class _CrossBase(Indicator):
+    _mindatas = 2
+    lines = ("cross",)
+    plotinfo = {"plotymargin": 0.05, "plotyhlines": [0.0, 1.0]}
+
+    def __init__(self):
+        """Initialize the crossover base indicator.
+
+        Creates NonZeroDifference for crossover detection.
+        """
+        super().__init__()  # CRITICAL: Call parent init first
+        self.nzd = NonZeroDifference(self.data0, self.data1)
+
+    def next(self):
+        """Detect crossover for the current bar.
+
+        Returns 1.0 if crossover detected, 0.0 otherwise.
+        """
+        # Check for crossover
+        if hasattr(self, "_crossup"):
+            if self._crossup:
+                # Upward cross: previous diff < 0 (strictly), now data0 > data1
+                before = self.nzd(-1) < 0.0  # STRICT inequality
+                after = self.data0[0] > self.data1[0]
+            else:
+                # Downward cross: previous diff > 0 (strictly), now data0 < data1
+                before = self.nzd(-1) > 0.0  # STRICT inequality
+                after = self.data0[0] < self.data1[0]
+
+            self.lines.cross[0] = 1.0 if (before and after) else 0.0
+        else:
+            self.lines.cross[0] = 0.0
+
+    # Don't override once() - let framework call next() for each bar
+
+
+class CrossUp(_CrossBase):
+    """Upward cross indicator"""
+
+    _crossup = True
+
+
+class CrossDown(_CrossBase):
+    """Downward cross indicator"""
+
+    _crossup = False
+
+
+class CrossOver(Indicator):
+    """
+    Gives signal for data crossover:
+    1.0 for upward cross, -1.0 for downward cross, 0.0 otherwise
+    """
+
+    _mindatas = 2
+    lines = ("crossover",)
+    plotinfo = {"plotymargin": 0.05, "plotyhlines": [-1.0, 1.0]}
+
+    def __init__(self):
+        """Initialize the CrossOver indicator.
+
+        Sets up minperiod and tracking variables for crossover detection.
+        """
+        super().__init__()
+        # CRITICAL FIX: Inherit minperiod from data sources first
+        # This is needed because the framework's automatic inheritance isn't working
+        if hasattr(self, "datas") and self.datas:
+            data_minperiods = [getattr(d, "_minperiod", 1) for d in self.datas]
+            self._minperiod = max([self._minperiod] + data_minperiods)
+        # CRITICAL FIX: Add minperiod for lookback requirement (nzd(-1) in master)
+        # addminperiod(n) adds n-1 to minperiod, so addminperiod(2) adds 1
+        self.addminperiod(2)
+        # For next() mode: track last non-zero difference
+        self._last_nzd = None
+        # CRITICAL FIX: Track owner's data length to detect replay mode
+        # In replay mode, we should only calculate crossover when the bar is complete
+        # The owner (strategy) has the actual data feed whose length changes when bars complete
+        self._last_owner_data_len = 0
+        self._owner_data = None  # Will be set to owner's data feed in next()
+
+    def prenext(self):
+        """Track difference during warmup period.
+
+        Updates _last_nzd for use in nextstart/next crossover detection.
+        """
+        # Track difference during warmup period so _last_nzd is available in nextstart
+        # This is similar to MACD's prenext that calculates MACD values during warmup
+        diff = self.data0[0] - self.data1[0]
+        # Update _last_nzd (memorize non-zero)
+        if self._last_nzd is None:
+            self._last_nzd = diff
+        else:
+            self._last_nzd = diff if diff != 0.0 else self._last_nzd
+
+    def nextstart(self):
+        """Calculate crossover on first valid bar.
+
+        Handles replay mode special case and calculates initial crossover.
+        """
+        # CRITICAL FIX: In replay mode, the first bar after minperiod doesn't have a valid
+        # "previous" bar in the compressed timeframe context. Skip crossover calculation
+        # on the first bar ONLY when in replay mode. For normal mode, calculate normally.
+        diff = self.data0[0] - self.data1[0]
+
+        # Check if we're in replay mode by checking owner's datas for replaying attribute
+        is_replay = False
+        if hasattr(self, "_owner") and hasattr(self._owner, "datas"):
+            for data in self._owner.datas:
+                if hasattr(data, "replaying") and data.replaying > 0:
+                    is_replay = True
+                    break
+
+        if is_replay:
+            # In replay mode, skip crossover on first bar - set to 0 and update _last_nzd
+            self.lines.crossover[0] = 0.0
+            # Update _last_nzd for next()
+            prev_nzd = self._last_nzd if self._last_nzd is not None else diff
+            self._last_nzd = diff if diff != 0.0 else prev_nzd
+            return
+
+        # Normal mode: calculate crossover normally
+        # Get previous non-zero difference (set during prenext)
+        prev_nzd = self._last_nzd if self._last_nzd is not None else diff
+
+        # Check for crossover
+        up_cross = 1.0 if (prev_nzd < 0.0 and self.data0[0] > self.data1[0]) else 0.0
+        down_cross = 1.0 if (prev_nzd > 0.0 and self.data0[0] < self.data1[0]) else 0.0
+        self.lines.crossover[0] = up_cross - down_cross
+
+        # Update _last_nzd for next()
+        self._last_nzd = diff if diff != 0.0 else prev_nzd
+
+    def next(self):
+        """Calculate crossover for the current bar.
+
+        Returns 1.0 for upward cross, -1.0 for downward cross, 0.0 otherwise.
+        Handles replay mode correctly by deferring calculation when bars are updating.
+        """
+        # Current difference
+        diff = self.data0[0] - self.data1[0]
+
+        # CRITICAL FIX: In replay mode with runonce, the same bar is updated multiple times.
+        # The key insight is that we should only calculate crossover when we're at a NEW bar
+        # (idx has advanced), not when we're updating the same bar multiple times.
+        # We detect this by checking if idx < len - 1, which means we haven't advanced yet.
+        # IMPORTANT: Only apply this logic in replay mode, not in exactbars mode!
+
+        # Check if we're in replay mode
+        is_replay = False
+        if hasattr(self, "_owner") and hasattr(self._owner, "datas"):
+            for data in self._owner.datas:
+                if hasattr(data, "replaying") and data.replaying > 0:
+                    is_replay = True
+                    break
+
+        # Only defer crossover calculation in replay mode
+        if is_replay and hasattr(self.lines[0], "idx") and hasattr(self.lines[0], "__len__"):
+            current_idx = self.lines[0].idx
+            current_len = len(self.lines[0])
+            # If idx < len - 1, we're still filling the current bar, not at a new bar yet
+            # Defer crossover calculation by updating _last_nzd but setting crossover to 0
+            if current_idx < current_len - 1:
+                # Still updating current bar - defer crossover calculation
+                if self._last_nzd is None or diff != 0.0:
+                    self._last_nzd = diff
+                self.lines.crossover[0] = 0.0
+                return
+
+        # At this point, we're at a new bar (idx == len - 1), calculate crossover
+        # using the previous bar's difference (stored in _last_nzd or from data[-1])
+        try:
+            prev_diff = self.data0[-1] - self.data1[-1]
+            # Find last non-zero difference by looking at line values
+            if prev_diff == 0.0:
+                prev_nzd = self._last_nzd if self._last_nzd is not None else diff
+            else:
+                prev_nzd = prev_diff
+        except (IndexError, TypeError):
+            # Fall back to cached value
+            prev_nzd = self._last_nzd if self._last_nzd is not None else diff
+
+        # Update _last_nzd for next bar
+        if self._last_nzd is None or diff != 0.0:
+            self._last_nzd = diff
+
+        # Check for crossover using STRICT inequalities
+        # Upward: prev < 0 and now data0 > data1
+        up_cross = 1.0 if (prev_nzd < 0.0 and self.data0[0] > self.data1[0]) else 0.0
+
+        # Downward: prev > 0 and now data0 < data1
+        down_cross = 1.0 if (prev_nzd > 0.0 and self.data0[0] < self.data1[0]) else 0.0
+
+        # Combine
+        self.lines.crossover[0] = up_cross - down_cross
+
+    def once(self, start, end):
+        """Calculate crossover in runonce mode.
+
+        Vectorized implementation that processes all bars at once.
+        """
+        # Vectorized once() implementation matching next() behavior
+        d0array = self.data0.array
+        d1array = self.data1.array
+        crossarray = self.line.array
+
+        # Handle case where data is shorter than minperiod
+        if start >= end:
+            # No bars to process - initialize all to 0
+            while len(crossarray) < len(d0array):
+                crossarray.append(0.0)
+            return
+
+        # Ensure array is large enough
+        while len(crossarray) < end:
+            crossarray.append(0.0)
+
+        # Defensive bound: never read past either input array. This protects
+        # against orphan sub-indicators (e.g., bt.indicators.SMA constructed
+        # at module level with no data) whose array remains empty when used
+        # as a CrossOver data source.
+        effective_end = min(end, len(d0array), len(d1array))
+        if effective_end <= start:
+            return
+
+        # Initialize prev_nzd from prenext period (bar before start)
+        # This matches next() which uses _last_nzd set during prenext
+        if start > 0 and start - 1 < len(d0array) and start - 1 < len(d1array):
+            prev_nzd = d0array[start - 1] - d1array[start - 1]
+            # Scan backwards to find last non-zero difference (like prenext does)
+            for j in range(start - 1, -1, -1):
+                diff_j = d0array[j] - d1array[j]
+                if diff_j != 0.0:
+                    prev_nzd = diff_j
+                    break
+        else:
+            prev_nzd = 0.0
+
+        # CRITICAL FIX: For replay mode, skip crossover on the very first bar.
+        # The first bar after minperiod doesn't have a valid "previous" bar in the
+        # compressed timeframe context. Defer crossover to the second bar.
+        # This prevents false positive crossovers at the start of replay data.
+        # ONLY apply this fix when in replay mode.
+        is_replay = False
+        if hasattr(self, "_owner") and hasattr(self._owner, "datas"):
+            for data in self._owner.datas:
+                if hasattr(data, "replaying") and data.replaying > 0:
+                    is_replay = True
+                    break
+
+        first_bar = start if is_replay else -1  # -1 means never skip
+
+        # Process ALL bars from start
+        for i in range(start, effective_end):
+            d0_val = d0array[i]
+            d1_val = d1array[i]
+            diff = d0_val - d1_val
+
+            # Skip crossover calculation on first bar ONLY in replay mode
+            if i == first_bar:
+                crossarray[i] = 0.0
+                # Still update prev_nzd for next iteration
+                prev_nzd = diff if diff != 0.0 else prev_nzd
+                continue
+
+            # Check crossover using prev_nzd (from previous bar)
+            up_cross = 1.0 if (prev_nzd < 0.0 and d0_val > d1_val) else 0.0
+            down_cross = 1.0 if (prev_nzd > 0.0 and d0_val < d1_val) else 0.0
+            crossarray[i] = up_cross - down_cross
+
+            # Update prev_nzd for next iteration (memorize non-zero)
+            prev_nzd = diff if diff != 0.0 else prev_nzd

backtrader/indicators/dema.py

@@ -0,0 +1,175 @@
+#!/usr/bin/env python
+"""DEMA/TEMA Indicator Module - Double/Triple Exponential Moving Average.
+
+This module provides DEMA and TEMA indicators introduced by Patrick G. Mulloy
+in 1994 to reduce the lag associated with traditional moving averages.
+
+Classes:
+    DoubleExponentialMovingAverage: DEMA indicator (alias: DEMA).
+    TripleExponentialMovingAverage: TEMA indicator (alias: TEMA).
+
+Example:
+    class MyStrategy(bt.Strategy):
+        def __init__(self):
+            self.dema = bt.indicators.DEMA(self.data.close, period=20)
+
+        def next(self):
+            if self.data.close[0] > self.dema[0]:
+                self.buy()
+            elif self.data.close[0] < self.dema[0]:
+                self.sell()
+"""
+
+import math
+
+from . import MovingAverageBase
+from .ema import EMA
+
+
+class DoubleExponentialMovingAverage(MovingAverageBase):
+    """
+    DEMA was first time introduced in 1994, in the article "Smoothing Data with
+    Faster-Moving Averages" by Patrick G. Mulloy in "Technical Analysis of
+    Stocks & Commodities" magazine.
+
+    It attempts to reduce the inherent lag associated with Moving Averages
+
+    Formula:
+      - dema = (2.0 - ema(data, period) - ema(ema(data, period), period)
+
+    See:
+      (None)
+    """
+
+    alias = (
+        "DEMA",
+        "MovingAverageDoubleExponential",
+    )
+
+    lines = ("dema",)
+    params = (("_movav", EMA),)
+
+    def __init__(self):
+        """Initialize the DEMA indicator.
+
+        Creates two EMAs for the DEMA calculation.
+        """
+        super().__init__()
+        self.ema1 = self.p._movav(self.data, period=self.p.period)
+        self.ema2 = self.p._movav(self.ema1, period=self.p.period)
+        # minperiod = 2 * period - 1 for DEMA
+        self._minperiod = max(self._minperiod, 2 * self.p.period - 1)
+
+    def next(self):
+        """Calculate DEMA for the current bar.
+
+        Formula: DEMA = 2 * EMA1 - EMA(EMA1)
+        """
+        self.lines.dema[0] = 2.0 * self.ema1[0] - self.ema2[0]
+
+    def once(self, start, end):
+        """Calculate DEMA in runonce mode."""
+        ema1_array = self.ema1.lines[0].array
+        ema2_array = self.ema2.lines[0].array
+        larray = self.lines.dema.array
+
+        while len(larray) < end:
+            larray.append(float("nan"))
+
+        minperiod = 2 * self.p.period - 1
+        for i in range(min(minperiod - 1, len(ema1_array))):
+            if i < len(larray):
+                larray[i] = float("nan")
+
+        for i in range(minperiod - 1, min(end, len(ema1_array), len(ema2_array))):
+            ema1_val = ema1_array[i] if i < len(ema1_array) else 0.0
+            ema2_val = ema2_array[i] if i < len(ema2_array) else 0.0
+
+            if (
+                isinstance(ema1_val, float)
+                and math.isnan(ema1_val)
+                or isinstance(ema2_val, float)
+                and math.isnan(ema2_val)
+            ):
+                larray[i] = float("nan")
+            else:
+                larray[i] = 2.0 * ema1_val - ema2_val
+
+
+# Triple Exponential Moving Average
+class TripleExponentialMovingAverage(MovingAverageBase):
+    """
+    TEMA was first time introduced in 1994, in the article "Smoothing Data with
+    Faster-Moving Averages" by Patrick G. Mulloy in "Technical Analysis of
+    Stocks & Commodities" magazine.
+
+    It attempts to reduce the inherent lag associated with Moving Averages
+
+    Formula:
+      - ema1 = ema(data, period)
+      - ema2 = ema(ema1, period)
+      - ema3 = ema(ema2, period)
+      - tema = 3 * ema1 - 3 * ema2 + ema3
+
+    See:
+      (None)
+    """
+
+    alias = (
+        "TEMA",
+        "MovingAverageTripleExponential",
+    )
+
+    lines = ("tema",)
+    params = (("_movav", EMA),)
+
+    def __init__(self):
+        """Initialize the TEMA indicator.
+
+        Creates three EMAs for the TEMA calculation.
+        """
+        super().__init__()
+        self.ema1 = self.p._movav(self.data, period=self.p.period)
+        self.ema2 = self.p._movav(self.ema1, period=self.p.period)
+        self.ema3 = self.p._movav(self.ema2, period=self.p.period)
+        # minperiod = 3 * period - 2 for TEMA
+        self._minperiod = max(self._minperiod, 3 * self.p.period - 2)
+
+    def next(self):
+        """Calculate TEMA for the current bar.
+
+        Formula: TEMA = 3 * EMA1 - 3 * EMA2 + EMA3
+        """
+        self.lines.tema[0] = 3.0 * self.ema1[0] - 3.0 * self.ema2[0] + self.ema3[0]
+
+    def once(self, start, end):
+        """Calculate TEMA in runonce mode."""
+        ema1_array = self.ema1.lines[0].array
+        ema2_array = self.ema2.lines[0].array
+        ema3_array = self.ema3.lines[0].array
+        larray = self.lines.tema.array
+
+        while len(larray) < end:
+            larray.append(float("nan"))
+
+        minperiod = 3 * self.p.period - 2
+        for i in range(min(minperiod - 1, len(ema1_array))):
+            if i < len(larray):
+                larray[i] = float("nan")
+
+        for i in range(minperiod - 1, min(end, len(ema1_array), len(ema2_array), len(ema3_array))):
+            ema1_val = ema1_array[i] if i < len(ema1_array) else 0.0
+            ema2_val = ema2_array[i] if i < len(ema2_array) else 0.0
+            ema3_val = ema3_array[i] if i < len(ema3_array) else 0.0
+
+            if (
+                isinstance(ema1_val, float)
+                and math.isnan(ema1_val)
+                or isinstance(ema2_val, float)
+                and math.isnan(ema2_val)
+                or isinstance(ema3_val, float)
+                and math.isnan(ema3_val)
+            ):
+                larray[i] = float("nan")
+            else:
+                larray[i] = 3.0 * ema1_val - 3.0 * ema2_val + ema3_val