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

backtrader/indicators/contrib/x_de_marker_histogram_vol_direct_indicator.py

@@ -0,0 +1,145 @@
+#!/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 collections import deque
+
+from .. import Indicator
+
+__all__ = [
+    "XDeMarkerHistogramVolDirectIndicator",
+]
+
+
+class XDeMarkerHistogramVolDirectIndicator(Indicator):
+    """Indicator that calculates DeMarker histogram zone and direct trend color."""
+
+    lines = ("value", "color_zone", "color_direct", "upper2", "upper1", "lower1", "lower2")
+    params = (
+        ("de_marker_period", 14),
+        ("volume_type", "tick"),
+        ("high_level2", 20),
+        ("high_level1", 15),
+        ("low_level1", -15),
+        ("low_level2", -20),
+        ("ma_method", "MODE_SMA_"),
+        ("ma_length", 12),
+        ("ma_phase", 15),
+    )
+
+    def __init__(self):
+        """Initialize de_marker state deques and warm-up period."""
+        self._demax = deque(maxlen=max(1, int(self.p.de_marker_period)))
+        self._demin = deque(maxlen=max(1, int(self.p.de_marker_period)))
+        self._raw = deque(maxlen=max(1, int(self.p.ma_length)))
+        self._vol = deque(maxlen=max(1, int(self.p.ma_length)))
+        self.addminperiod(max(int(self.p.de_marker_period), int(self.p.ma_length)) + 2)
+
+    @staticmethod
+    def _nan():
+        return float("nan")
+
+    @staticmethod
+    def _finite(value):
+        return value is not None and math.isfinite(value)
+
+    def _bar_volume(self):
+        volume_type = str(self.p.volume_type).lower()
+        if volume_type in {"real", "volume_real", "volume"}:
+            raw = float(self.data.openinterest[0])
+            if math.isfinite(raw) and raw > 0:
+                return raw
+        raw = float(self.data.volume[0])
+        return raw if math.isfinite(raw) else 0.0
+
+    def next(self):
+        """Compute de_marker-derived raw value, smoothing, and colors."""
+        if len(self.data) < 2:
+            for line in self.lines:
+                line[0] = self._nan()
+            return
+
+        high_now = float(self.data.high[0])
+        high_prev = float(self.data.high[-1])
+        low_now = float(self.data.low[0])
+        low_prev = float(self.data.low[-1])
+        vol_now = self._bar_volume()
+
+        self._demax.append(max(high_now - high_prev, 0.0))
+        self._demin.append(max(low_prev - low_now, 0.0))
+
+        value = self._nan()
+        color_zone = self._nan()
+        color_direct = (
+            self.lines.color_direct[-1]
+            if len(self) > 1 and self._finite(self.lines.color_direct[-1])
+            else self._nan()
+        )
+        upper2 = self._nan()
+        upper1 = self._nan()
+        lower1 = self._nan()
+        lower2 = self._nan()
+
+        if len(self._demax) >= int(self.p.de_marker_period) and len(self._demin) >= int(
+            self.p.de_marker_period
+        ):
+            sum_max = sum(self._demax)
+            sum_min = sum(self._demin)
+            denom = sum_max + sum_min
+            demarker = (sum_max / denom) if denom > 0 else 0.5
+            raw = ((demarker * 100.0) - 50.0) * vol_now
+            self._raw.append(raw)
+            self._vol.append(vol_now)
+
+            if len(self._raw) >= int(self.p.ma_length) and len(self._vol) >= int(self.p.ma_length):
+                if str(self.p.ma_method).upper() != "MODE_SMA_":
+                    raise ValueError(
+                        "Current backtrader migration only supports MODE_SMA_ for XDeMarker_Histogram_Vol_Direct"
+                    )
+                value = sum(self._raw) / len(self._raw)
+                avg_vol = sum(self._vol) / len(self._vol)
+                upper2 = self.p.high_level2 * avg_vol
+                upper1 = self.p.high_level1 * avg_vol
+                lower1 = self.p.low_level1 * avg_vol
+                lower2 = self.p.low_level2 * avg_vol
+                if value > upper2:
+                    color_zone = 0.0
+                elif value > upper1:
+                    color_zone = 1.0
+                elif value < lower2:
+                    color_zone = 4.0
+                elif value < lower1:
+                    color_zone = 3.0
+                else:
+                    color_zone = 2.0
+
+                prev_value = (
+                    self.lines.value[-1]
+                    if len(self) > 1 and self._finite(self.lines.value[-1])
+                    else self._nan()
+                )
+                prev_direct = (
+                    self.lines.color_direct[-1]
+                    if len(self) > 1 and self._finite(self.lines.color_direct[-1])
+                    else 1.0
+                )
+                if not self._finite(prev_value):
+                    color_direct = prev_direct
+                elif value > prev_value:
+                    color_direct = 0.0
+                elif value < prev_value:
+                    color_direct = 1.0
+                else:
+                    color_direct = prev_direct
+
+        self.lines.value[0] = value
+        self.lines.color_zone[0] = color_zone
+        self.lines.color_direct[0] = color_direct
+        self.lines.upper2[0] = upper2
+        self.lines.upper1[0] = upper1
+        self.lines.lower1[0] = lower1
+        self.lines.lower2[0] = lower2

backtrader/indicators/contrib/x_fisher_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.
+"""
+
+import math
+
+from .. import Indicator
+
+__all__ = [
+    "XFisherIndicator",
+]
+
+
+class XFisherIndicator(Indicator):
+    """Fisher Transform of Williams %R position with an EMA-smoothed signal line."""
+
+    lines = ("xfisher", "signal")
+    params = (
+        ("flength", 7),
+        ("ma_length", 5),
+    )
+
+    def __init__(self):
+        """Set the warm-up period, recurrence seeds, and EMA smoothing factor."""
+        self.addminperiod(self.p.flength + self.p.ma_length + 2)
+        self._value_prev = 0.0
+        self._fish_prev = 0.0
+        self._smooth_prev = None
+        self._alpha = 2.0 / (self.p.ma_length + 1.0)
+
+    def next(self):
+        """Compute the smoothed Fisher value and store it with its lagged signal."""
+        highs = [float(self.data.high[-i]) for i in range(self.p.flength)]
+        lows = [float(self.data.low[-i]) for i in range(self.p.flength)]
+        smax = max(highs)
+        smin = min(lows)
+        spread = smax - smin
+        if spread == 0:
+            spread = 1e-12
+
+        price = float(self.data.close[0])
+        wpr = (price - smin) / spread
+        value = (wpr - 0.5) + 0.67 * self._value_prev
+        value = max(min(value, 0.999), -0.999)
+
+        ratio = (1.0 + value) / (1.0 - value)
+        ratio = max(ratio, 1e-7)
+        fish = 0.5 * math.log(ratio) + 0.5 * self._fish_prev
+        smooth = (
+            fish
+            if self._smooth_prev is None
+            else self._smooth_prev + self._alpha * (fish - self._smooth_prev)
+        )
+
+        prev_smooth = smooth if len(self) <= 1 else float(self.lines.xfisher[-1])
+        self.lines.xfisher[0] = smooth
+        self.lines.signal[0] = prev_smooth
+
+        self._value_prev = value
+        self._fish_prev = fish
+        self._smooth_prev = smooth

backtrader/indicators/contrib/xcci_histogram_vol_direct_indicator.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
+
+__all__ = [
+    "XCCIHistogramVolDirectIndicator",
+]
+
+
+class XCCIHistogramVolDirectIndicator(Indicator):
+    """Direct XCCI histogram indicator producing smoothed value and color state."""
+
+    lines = ("color_state", "value")
+    params = (
+        ("cci_period", 14),
+        ("ma_length", 12),
+    )
+
+    def __init__(self):
+        """Initialize rolling scaled-history buffers and minimum periods."""
+        self._scaled_history = []
+        self.addminperiod(max(self.p.cci_period, self.p.ma_length) + 3)
+
+    def next(self):
+        """Compute CCI*volume histogram value and binary color transition."""
+        typical_prices = []
+        for idx in range(self.p.cci_period):
+            typical_prices.append(
+                (
+                    float(self.data.high[-idx])
+                    + float(self.data.low[-idx])
+                    + float(self.data.close[-idx])
+                )
+                / 3.0
+            )
+        tp_now = typical_prices[0]
+        tp_sma = sum(typical_prices) / float(len(typical_prices))
+        mean_dev = sum(abs(tp - tp_sma) for tp in typical_prices) / float(len(typical_prices))
+        if mean_dev <= 1e-12:
+            cci_value = 0.0
+        else:
+            cci_value = (tp_now - tp_sma) / (0.015 * mean_dev)
+        raw = cci_value * float(self.data.volume[0])
+        self._scaled_history.append(raw)
+        if len(self._scaled_history) > self.p.ma_length:
+            self._scaled_history.pop(0)
+        current = sum(self._scaled_history) / float(len(self._scaled_history))
+        previous = self.lines.value[-1] if len(self) else 0.0
+        color = 0.0 if current >= previous else 1.0
+        self.lines.value[0] = current
+        self.lines.color_state[0] = color

backtrader/indicators/contrib/xcci_histogram_vol_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__ = [
+    "XCCIHistogramVolIndicator",
+]
+
+
+class XCCIHistogramVolIndicator(Indicator):
+    """Compute volume-scaled XCCI histogram levels and color state."""
+
+    lines = ("color_state", "value", "max_level", "up_level", "dn_level", "min_level")
+    params = (
+        ("cci_period", 14),
+        ("high_level2", 100),
+        ("high_level1", 80),
+        ("low_level1", -80),
+        ("low_level2", -100),
+        ("ma_length", 12),
+    )
+
+    def __init__(self):
+        """Initialize rolling CCI and volume histories."""
+        self._scaled_history = []
+        self._volume_history = []
+        self.addminperiod(max(self.p.cci_period, self.p.ma_length) + 3)
+
+    def next(self):
+        """Update scaled CCI, levels, and derived color state."""
+        vol = float(self.data.volume[0]) if len(self.data.volume) else 0.0
+        typical_prices = []
+        for idx in range(self.p.cci_period):
+            typical_prices.append(
+                (
+                    float(self.data.high[-idx])
+                    + float(self.data.low[-idx])
+                    + float(self.data.close[-idx])
+                )
+                / 3.0
+            )
+        tp_now = typical_prices[0]
+        tp_sma = sum(typical_prices) / float(len(typical_prices))
+        mean_dev = sum(abs(tp - tp_sma) for tp in typical_prices) / float(len(typical_prices))
+        if mean_dev <= 1e-12:
+            cci_value = 0.0
+        else:
+            cci_value = (tp_now - tp_sma) / (0.015 * mean_dev)
+        raw = cci_value * vol
+        self._scaled_history.append(raw)
+        self._volume_history.append(vol)
+        if len(self._scaled_history) > self.p.ma_length:
+            self._scaled_history.pop(0)
+        if len(self._volume_history) > self.p.ma_length:
+            self._volume_history.pop(0)
+        scaled = sum(self._scaled_history) / float(len(self._scaled_history))
+        avg_vol = (
+            sum(self._volume_history) / float(len(self._volume_history))
+            if self._volume_history
+            else max(vol, 1.0)
+        )
+        max_level = self.p.high_level2 * avg_vol
+        up_level = self.p.high_level1 * avg_vol
+        dn_level = self.p.low_level1 * avg_vol
+        min_level = self.p.low_level2 * avg_vol
+        clr = 2.0
+        if scaled > max_level:
+            clr = 0.0
+        elif scaled > up_level:
+            clr = 1.0
+        elif scaled < min_level:
+            clr = 4.0
+        elif scaled < dn_level:
+            clr = 3.0
+        self.lines.value[0] = scaled
+        self.lines.max_level[0] = max_level
+        self.lines.up_level[0] = up_level
+        self.lines.dn_level[0] = dn_level
+        self.lines.min_level[0] = min_level
+        self.lines.color_state[0] = clr

backtrader/indicators/contrib/xma_ichimoku.py

@@ -0,0 +1,163 @@
+#!/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__ = [
+    "XmaIchimoku",
+    "TwoXmaIchimokuOscillator",
+]
+
+
+class XmaIchimoku(Indicator):
+    """Calculate a smoothed midpoint of selected high/low ranges."""
+
+    lines = ("value",)
+
+    params = (
+        ("up_period", 6),
+        ("dn_period", 6),
+        ("up_mode", "HIGH"),
+        ("dn_mode", "LOW"),
+        ("xma_method", "SMA"),
+        ("x_length", 25),
+        ("x_phase", 15),
+        ("price_shift", 0.0),
+    )
+
+    def __init__(self):
+        """Initialize Ichimoku-like windows and smoothing helpers."""
+        self.addminperiod(
+            max(int(self.p.up_period), int(self.p.dn_period)) + int(self.p.x_length) + 5
+        )
+        self._raw_buf = []
+        self._smooth_prev = None
+
+    def _series_value(self, mode, ago):
+        mode = str(mode).upper()
+        if mode == "OPEN":
+            return float(self.data.open[ago])
+        if mode == "LOW":
+            return float(self.data.low[ago])
+        if mode == "HIGH":
+            return float(self.data.high[ago])
+        return float(self.data.close[ago])
+
+    def _smooth_value(self, raw_value):
+        method = str(self.p.xma_method).upper()
+        if method in ("MODE_SMA_", "SMA"):
+            period = max(1, int(self.p.x_length))
+            if len(self._raw_buf) < period:
+                return raw_value
+            return sum(self._raw_buf[-period:]) / float(period)
+
+        length = max(1, int(self.p.x_length))
+        phase = max(-100, min(100, int(self.p.x_phase)))
+        alpha = 2.0 / (length + 1.0)
+        alpha *= 1.0 + 0.35 * (phase / 100.0)
+        alpha = max(0.01, min(0.99, alpha))
+        if self._smooth_prev is None or not math.isfinite(self._smooth_prev):
+            smooth = raw_value
+        else:
+            smooth = self._smooth_prev + alpha * (raw_value - self._smooth_prev)
+        self._smooth_prev = smooth
+        return smooth
+
+    def next(self):
+        """Compute smoothed range midpoint for each bar."""
+        up_period = int(self.p.up_period)
+        dn_period = int(self.p.dn_period)
+        if len(self.data) < max(up_period, dn_period):
+            self.lines.value[0] = 0.0
+            return
+
+        highs = [self._series_value(self.p.up_mode, -i) for i in range(up_period)]
+        lows = [self._series_value(self.p.dn_mode, -i) for i in range(dn_period)]
+        ish_up = max(highs)
+        ish_dn = min(lows)
+        raw_value = (ish_up + ish_dn) / 2.0
+        self._raw_buf.append(raw_value)
+        smooth = self._smooth_value(raw_value) + float(self.p.price_shift)
+        self.lines.value[0] = smooth
+
+
+class TwoXmaIchimokuOscillator(Indicator):
+    """Combine two XMA windows into oscillator value and color channels."""
+
+    lines = (
+        "line",
+        "color",
+    )
+
+    params = (
+        ("up_period1", 6),
+        ("dn_period1", 6),
+        ("up_period2", 9),
+        ("dn_period2", 9),
+        ("up_mode1", "HIGH"),
+        ("dn_mode1", "LOW"),
+        ("up_mode2", "HIGH"),
+        ("dn_mode2", "LOW"),
+        ("xma1_method", "SMA"),
+        ("xma2_method", "SMA"),
+        ("x_length1", 25),
+        ("x_length2", 80),
+        ("x_phase", 15),
+        ("point", 0.01),
+    )
+
+    def __init__(self):
+        """Create two :class:`XmaIchimoku` instances and reset color state."""
+        self.xma1 = XmaIchimoku(
+            self.data,
+            up_period=self.p.up_period1,
+            dn_period=self.p.dn_period1,
+            up_mode=self.p.up_mode1,
+            dn_mode=self.p.dn_mode1,
+            xma_method=self.p.xma1_method,
+            x_length=self.p.x_length1,
+            x_phase=self.p.x_phase,
+        )
+        self.xma2 = XmaIchimoku(
+            self.data,
+            up_period=self.p.up_period2,
+            dn_period=self.p.dn_period2,
+            up_mode=self.p.up_mode2,
+            dn_mode=self.p.dn_mode2,
+            xma_method=self.p.xma2_method,
+            x_length=self.p.x_length2,
+            x_phase=self.p.x_phase,
+        )
+        self._prev_color = 2.0
+
+    def next(self):
+        """Update oscillator value and derived color trend state."""
+        point = float(self.p.point) if float(self.p.point) != 0 else 1.0
+        line_value = (float(self.xma1[0]) - float(self.xma2[0])) / point
+        self.lines.line[0] = line_value
+
+        if len(self) < 2:
+            self.lines.color[0] = 2.0
+            self._prev_color = 2.0
+            return
+
+        prev_line = float(self.lines.line[-1])
+        color = self._prev_color
+        if line_value >= 0:
+            if line_value > prev_line:
+                color = 0.0
+            elif line_value < prev_line:
+                color = 1.0
+        else:
+            if line_value < prev_line:
+                color = 4.0
+            elif line_value > prev_line:
+                color = 3.0
+        self.lines.color[0] = color
+        self._prev_color = color

backtrader/indicators/contrib/xma_ishimoku_channel_indicator.py

@@ -0,0 +1,65 @@
+#!/usr/bin/env python
+"""Functional-test indicators migrated to contrib.
+
+Generated from a single functional strategy module to preserve file-local
+helper functions and constants without cross-test name collisions.
+"""
+
+from .. import (
+    EMA,
+    SMA,
+    Highest,
+    Indicator,
+    Lowest,
+    SmoothedMovingAverage,
+    WeightedMovingAverage,
+)
+
+__all__ = [
+    "XMAIshimokuChannelIndicator",
+]
+
+
+def resolve_ma_class(name):
+    """Resolve a moving-average identifier into a Backtrader indicator 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 XMAIshimokuChannelIndicator(Indicator):
+    """Compute XMA-smoothed midpoint channel lines."""
+
+    lines = (
+        "mid",
+        "upper",
+        "lower",
+    )
+    params = (
+        ("up_period", 3),
+        ("dn_period", 3),
+        ("up_mode", "high"),
+        ("dn_mode", "low"),
+        ("xma_method", "sma"),
+        ("xlength", 100),
+        ("xphase", 15),
+        ("up_percent", 1.0),
+        ("dn_percent", 1.0),
+        ("price_shift", 0),
+    )
+
+    def __init__(self):
+        """Prepare indicator buffers and min-period for channel outputs."""
+        ma_cls = resolve_ma_class(self.p.xma_method)
+        highest = Highest(self.data.high, period=self.p.up_period)
+        lowest = Lowest(self.data.low, period=self.p.dn_period)
+        midpoint = (highest + lowest) / 2.0
+        self.lines.mid = ma_cls(midpoint, period=self.p.xlength) + self.p.price_shift
+        self.lines.upper = self.lines.mid * (1.0 + self.p.up_percent / 100.0)
+        self.lines.lower = self.lines.mid * (1.0 - self.p.dn_percent / 100.0)
+        self.addminperiod(max(self.p.up_period, self.p.dn_period, self.p.xlength) + 3)

backtrader/indicators/contrib/xma_ishimoku_line.py

@@ -0,0 +1,68 @@
+#!/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,
+    Highest,
+    Indicator,
+    Lowest,
+    SmoothedMovingAverage,
+    WeightedMovingAverage,
+)
+
+__all__ = [
+    "XMAIshimokuLine",
+]
+
+
+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
+
+
+class XMAIshimokuLine(Indicator):
+    """Smoothed Ishimoku-style midprice line.
+
+    Computes the midpoint of the rolling highest high and lowest low over the
+    up/down periods, then smooths it with the configured moving average over
+    ``xlength`` to produce a single ``xma`` trend line.
+    """
+
+    lines = ("xma",)
+    params = (
+        ("up_period", 3),
+        ("dn_period", 3),
+        ("xma_method", "sma"),
+        ("xlength", 8),
+        ("xphase", 15),
+    )
+
+    def __init__(self):
+        """Build the high/low midpoint and its moving average; set min period."""
+        highest = Highest(self.data.high, period=self.p.up_period)
+        lowest = Lowest(self.data.low, period=self.p.dn_period)
+        midpoint = (highest + lowest) / 2.0
+        ma_cls = resolve_ma_class(self.p.xma_method)
+        self.lines.xma = ma_cls(midpoint, period=self.p.xlength)
+        self.addminperiod(max(self.p.up_period, self.p.dn_period, self.p.xlength) + 3)