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

backtrader/indicators/contrib/go_indicator.py

@@ -0,0 +1,93 @@
+#!/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 (
+    ExponentialMovingAverage,
+    Indicator,
+    SimpleMovingAverage,
+    SmoothedMovingAverage,
+    WeightedMovingAverage,
+)
+
+__all__ = [
+    "GOIndicator",
+]
+
+
+class GOIndicator(Indicator):
+    """Indicator that derives a GO signal from smoothed OHLC components."""
+
+    lines = ("go",)
+    params = (
+        ("period", 174),
+        ("ma_method", "SMA"),
+    )
+
+    def __init__(self):
+        """Build MA buffers for OHLC input series and warmup period.
+
+        Args:
+            None.
+
+        Returns:
+            None.
+
+        Side effects:
+            Creates ``ma_open``, ``ma_high``, ``ma_low``, ``ma_close`` lines.
+        """
+        ma_cls = {
+            "SMA": SimpleMovingAverage,
+            "EMA": ExponentialMovingAverage,
+            "SMMA": SmoothedMovingAverage,
+            "WMA": WeightedMovingAverage,
+        }.get(str(self.p.ma_method).upper(), SimpleMovingAverage)
+        self.ma_open = ma_cls(self.data.open, period=self.p.period)
+        self.ma_high = ma_cls(self.data.high, period=self.p.period)
+        self.ma_low = ma_cls(self.data.low, period=self.p.period)
+        self.ma_close = ma_cls(self.data.close, period=self.p.period)
+        self.addminperiod(int(self.p.period) + 1)
+
+    def _calc_go(self, ma_open, ma_high, ma_low, ma_close, volume):
+        values = (ma_open, ma_high, ma_low, ma_close, volume)
+        if not all(math.isfinite(float(v)) for v in values):
+            return 0.0
+        return (
+            (ma_close - ma_open)
+            + (ma_high - ma_open)
+            + (ma_low - ma_open)
+            + (ma_close - ma_low)
+            + (ma_close - ma_high)
+        ) * volume
+
+    def next(self):
+        """Compute GO for current bar and publish it to ``lines.go``."""
+        self.lines.go[0] = self._calc_go(
+            float(self.ma_open[0]),
+            float(self.ma_high[0]),
+            float(self.ma_low[0]),
+            float(self.ma_close[0]),
+            float(self.data.volume[0]),
+        )
+
+    def once(self, start, end):
+        """Compute GO for buffered bars in run-once mode."""
+        ma_open = self.ma_open.array
+        ma_high = self.ma_high.array
+        ma_low = self.ma_low.array
+        ma_close = self.ma_close.array
+        volume = self.data.volume.array
+        go = self.lines.go.array
+        for i in range(start, end):
+            go[i] = self._calc_go(
+                float(ma_open[i]),
+                float(ma_high[i]),
+                float(ma_low[i]),
+                float(ma_close[i]),
+                float(volume[i]),
+            )

backtrader/indicators/contrib/hlr_indicator.py

@@ -0,0 +1,95 @@
+#!/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 (
+    Highest,
+    Indicator,
+    Lowest,
+)
+
+__all__ = [
+    "HLRIndicator",
+    "ZeroLagHLRIndicator",
+]
+
+
+class HLRIndicator(Indicator):
+    """Base HLR indicator returning a normalized high-low range position."""
+
+    lines = ("value",)
+    params = (("period", 40),)
+
+    def __init__(self):
+        """Initialize highest/lowest trackers and line averaging setup."""
+        period = int(self.p.period)
+        self.highest = Highest(self.data.high, period=period)
+        self.lowest = Lowest(self.data.low, period=period)
+        self.mid = (self.data.high + self.data.low) / 2.0
+        self.addminperiod(period + 1)
+
+    def next(self):
+        """Compute the HLR oscillator value for current bar."""
+        hh = float(self.highest[0])
+        ll = float(self.lowest[0])
+        span = hh - ll
+        self.l.value[0] = 0.0 if span == 0.0 else 100.0 * ((float(self.mid[0]) - ll) / span)
+
+
+class ZeroLagHLRIndicator(Indicator):
+    """Zero-lag variant of HLR computed from a blended set of HLR periods."""
+
+    lines = ("fast", "slow")
+    params = (
+        ("smoothing", 15),
+        ("factor1", 0.05),
+        ("hlr_period1", 8),
+        ("factor2", 0.1),
+        ("hlr_period2", 21),
+        ("factor3", 0.16),
+        ("hlr_period3", 34),
+        ("factor4", 0.26),
+        ("hlr_period4", 55),
+        ("factor5", 0.43),
+        ("hlr_period5", 89),
+        ("preserve_source_hlr3_weight", True),
+    )
+
+    def __init__(self):
+        """Instantiate source HLR components and initialize smoothing state."""
+        self.hlr1 = HLRIndicator(self.data, period=int(self.p.hlr_period1))
+        self.hlr2 = HLRIndicator(self.data, period=int(self.p.hlr_period2))
+        self.hlr3 = HLRIndicator(self.data, period=int(self.p.hlr_period3))
+        self.hlr4 = HLRIndicator(self.data, period=int(self.p.hlr_period4))
+        self.hlr5 = HLRIndicator(self.data, period=int(self.p.hlr_period5))
+        self.smooth_const = (float(self.p.smoothing) - 1.0) / float(self.p.smoothing)
+        self.hlr3_weight = float(
+            self.p.factor2 if self.p.preserve_source_hlr3_weight else self.p.factor3
+        )
+        max_period = max(
+            int(self.p.hlr_period1),
+            int(self.p.hlr_period2),
+            int(self.p.hlr_period3),
+            int(self.p.hlr_period4),
+            int(self.p.hlr_period5),
+        )
+        self.addminperiod((3 * max_period) + 3)
+
+    def next(self):
+        """Update fast and smoothed slow HLR outputs."""
+        fast = (
+            float(self.p.factor1) * float(self.hlr1.value[0])
+            + float(self.p.factor2) * float(self.hlr2.value[0])
+            + self.hlr3_weight * float(self.hlr3.value[0])
+            + float(self.p.factor4) * float(self.hlr4.value[0])
+            + float(self.p.factor5) * float(self.hlr5.value[0])
+        )
+        if len(self) <= 1:
+            slow = fast / float(self.p.smoothing)
+        else:
+            slow = (fast / float(self.p.smoothing)) + (float(self.l.slow[-1]) * self.smooth_const)
+        self.l.fast[0] = fast
+        self.l.slow[0] = slow

backtrader/indicators/contrib/hma.py

@@ -0,0 +1,50 @@
+#!/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,
+    WeightedMovingAverage,
+)
+
+__all__ = [
+    "HMA",
+    "OsHMAIndicator",
+]
+
+
+class HMA(Indicator):
+    """Hull Moving Average indicator used by OsHMA."""
+
+    lines = ("hma",)
+    params = (("period", 13),)
+
+    def __init__(self):
+        """Initialize the HMA with smoothed weighted moving averages."""
+        half = max(1, int(self.p.period // 2))
+        sqrt_period = max(1, int(self.p.period**0.5))
+        wma_half = WeightedMovingAverage(self.data, period=half)
+        wma_full = WeightedMovingAverage(self.data, period=int(self.p.period))
+        diff = (2.0 * wma_half) - wma_full
+        self.lines.hma = WeightedMovingAverage(diff, period=sqrt_period)
+        self.addminperiod(int(self.p.period) + sqrt_period + 3)
+
+
+class OsHMAIndicator(Indicator):
+    """Histogram indicator that combines fast and slow HMA lines."""
+
+    lines = ("hist",)
+    params = (
+        ("fast_hma", 13),
+        ("slow_hma", 26),
+    )
+
+    def __init__(self):
+        """Initialize fast and slow HMA sub-indicators and histogram output."""
+        fast = HMA(self.data.close, period=self.p.fast_hma)
+        slow = HMA(self.data.close, period=self.p.slow_hma)
+        self.lines.hist = fast.hma - slow.hma
+        self.addminperiod(max(self.p.fast_hma, self.p.slow_hma) + int(self.p.slow_hma**0.5) + 5)

backtrader/indicators/contrib/i4_drfv2.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
+
+__all__ = [
+    "I4DRFV2",
+]
+
+
+class I4DRFV2(Indicator):
+    """Close-difference indicator producing value and binary color trend state."""
+
+    lines = ("color", "value")
+    params = (("period", 11),)
+
+    def __init__(self):
+        """Initialize the minimum period requirement."""
+        self.addminperiod(int(self.p.period) + 2)
+
+    def next(self):
+        """Compute current indicator value and color."""
+        total = 0.0
+        period = int(self.p.period)
+        for i in range(period):
+            diff = float(self.data.close[-i]) - float(self.data.close[-(i + 1)])
+            total += 1.0 if diff > 0 else -1.0
+        value = total / float(period) * 100.0
+        self.lines.value[0] = value
+        self.lines.color[0] = 1.0 if value > 0 else 0.0

backtrader/indicators/contrib/i4_drfv3.py

@@ -0,0 +1,38 @@
+#!/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__ = [
+    "I4DRFV3",
+]
+
+
+class I4DRFV3(Indicator):
+    """Indicator producing a direction color and synthetic value from highs/lows."""
+
+    lines = ("color", "value")
+    params = (("period", 11),)
+
+    def __init__(self):
+        """Initialize minimum history and derived signal parameters."""
+        self.addminperiod(int(self.p.period) + 2)
+
+    def next(self):
+        """Calculate directional value and color for the current bar."""
+        total = 0.0
+        period = int(self.p.period)
+        for i in range(period):
+            high_diff = float(self.data.high[-i]) - float(self.data.high[-(i + 1)])
+            low_diff = float(self.data.low[-i]) - float(self.data.low[-(i + 1)])
+            if high_diff > 0:
+                total += 1.0
+            if low_diff < 0:
+                total -= 1.0
+        value = total / float(period) * 100.0
+        self.lines.value[0] = value
+        self.lines.color[0] = 1.0 if value > 0 else 0.0

backtrader/indicators/contrib/i_anch_mom_indicator.py

@@ -0,0 +1,72 @@
+#!/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__ = [
+    "IAnchMomIndicator",
+]
+
+
+def get_price_line(data, price_mode):
+    """Select an applied-price line from a data feed by mode name.
+
+    Args:
+        data: The backtrader data feed providing OHLC lines.
+        price_mode: Applied-price mode (e.g. ``'close'``, ``'median'``,
+            ``'typical'``, ``'weighted'``); case-insensitive.
+
+    Returns:
+        The selected price line or a derived combination of OHLC lines.
+
+    Raises:
+        ValueError: If ``price_mode`` is not recognised.
+    """
+    mode = str(price_mode).lower()
+    if mode in ("close", "price_close", "price_close_"):
+        return data.close
+    if mode in ("open", "price_open", "price_open_"):
+        return data.open
+    if mode in ("high", "price_high", "price_high_"):
+        return data.high
+    if mode in ("low", "price_low", "price_low_"):
+        return data.low
+    if mode in ("median", "price_median", "price_median_"):
+        return (data.high + data.low) / 2.0
+    if mode in ("typical", "price_typical", "price_typical_"):
+        return (data.high + data.low + data.close) / 3.0
+    if mode in ("weighted", "price_weighted", "price_weighted_"):
+        return (data.high + data.low + data.close + data.close) / 4.0
+    raise ValueError(f"Unsupported price mode: {price_mode}")
+
+
+class IAnchMomIndicator(Indicator):
+    """Anchored-momentum oscillator: percentage gap of a fast EMA over a slow SMA."""
+
+    lines = ("value",)
+    params = (
+        ("sma_period", 34),
+        ("ema_period", 20),
+        ("price_type", "close"),
+    )
+
+    def __init__(self):
+        """Build the SMA and EMA of the applied price and set the warm-up period."""
+        price = get_price_line(self.data, self.p.price_type)
+        self.sma = SimpleMovingAverage(price, period=int(self.p.sma_period))
+        self.ema = ExponentialMovingAverage(price, period=int(self.p.ema_period))
+        self.addminperiod(int(self.p.sma_period) + 2)
+
+    def next(self):
+        """Emit the percentage gap ``100 * (ema / sma - 1)`` for the current bar."""
+        sma = float(self.sma[0])
+        ema = float(self.ema[0])
+        self.l.value[0] = 0.0 if sma == 0.0 else 100.0 * ((ema / sma) - 1.0)

backtrader/indicators/contrib/i_de_marker_sign_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 (
+    ATR,
+    Indicator,
+)
+
+__all__ = [
+    "IDeMarkerSignIndicator",
+]
+
+
+class IDeMarkerSignIndicator(Indicator):
+    """DeMarker oscillator that emits buy/sell triggers on level crossings."""
+
+    lines = ("sell", "buy", "demarker", "atr")
+    params = (
+        ("atr_period", 14),
+        ("demarker_period", 14),
+        ("up_level", 0.7),
+        ("dn_level", 0.3),
+    )
+
+    def __init__(self):
+        """Build the ATR sub-indicator and set the minimum warmup period."""
+        self._atr = ATR(self.data, period=int(self.p.atr_period))
+        self.addminperiod(max(int(self.p.atr_period), int(self.p.demarker_period) + 1) + 2)
+
+    def _calc_demarker(self):
+        period = int(self.p.demarker_period)
+        demax_sum = 0.0
+        demin_sum = 0.0
+        for i in range(period):
+            high0 = float(self.data.high[-i])
+            high1 = float(self.data.high[-(i + 1)])
+            low0 = float(self.data.low[-i])
+            low1 = float(self.data.low[-(i + 1)])
+            demax_sum += max(high0 - high1, 0.0)
+            demin_sum += max(low1 - low0, 0.0)
+        denom = demax_sum + demin_sum
+        if denom == 0.0:
+            return 0.5
+        return demax_sum / denom
+
+    def next(self):
+        """Compute the DeMarker value and set buy/sell triggers on crossings."""
+        self.lines.sell[0] = float("nan")
+        self.lines.buy[0] = float("nan")
+        demarker_now = self._calc_demarker()
+        self.lines.demarker[0] = demarker_now
+        self.lines.atr[0] = float(self._atr[0])
+        if len(self) < 2:
+            return
+        demarker_prev = float(self.lines.demarker[-1])
+        atr_now = float(self._atr[0])
+        if demarker_now > float(self.p.dn_level) and demarker_prev <= float(self.p.dn_level):
+            self.lines.buy[0] = float(self.data.low[0]) - atr_now * 3.0 / 8.0
+        if demarker_now < float(self.p.up_level) and demarker_prev >= float(self.p.up_level):
+            self.lines.sell[0] = float(self.data.high[0]) + atr_now * 3.0 / 8.0

backtrader/indicators/contrib/i_gap_indicator.py

@@ -0,0 +1,45 @@
+#!/usr/bin/env python
+"""Functional-test indicators migrated to contrib.
+
+Generated from a single functional strategy module to preserve file-local
+helper functions and constants without cross-test name collisions.
+"""
+
+from .. import (
+    ATR,
+    Indicator,
+)
+
+__all__ = [
+    "IGapIndicator",
+]
+
+
+class IGapIndicator(Indicator):
+    """Detect opening gaps and emit ATR-offset buy/sell arrow levels."""
+
+    lines = ("sell_signal", "buy_signal", "atr_value")
+    params = (
+        ("size_gap", 5),
+        ("point", 0.01),
+        ("atr_period", 15),
+    )
+
+    def __init__(self):
+        """Set the warm-up period, build the ATR, and cache the gap distance."""
+        self.addminperiod(int(self.p.atr_period) + int(self.p.size_gap) + 4)
+        self.atr = ATR(self.data, period=int(self.p.atr_period))
+        self.gap_distance = float(self.p.size_gap) * float(self.p.point)
+
+    def next(self):
+        """Emit buy/sell arrow levels when the prior close gaps past the open."""
+        self.lines.sell_signal[0] = 0.0
+        self.lines.buy_signal[0] = 0.0
+        atr_value = float(self.atr[0])
+        self.lines.atr_value[0] = atr_value
+        if len(self.data) < 2:
+            return
+        if float(self.data.close[-1]) > float(self.data.open[0]) + self.gap_distance:
+            self.lines.buy_signal[0] = float(self.data.low[0]) - atr_value * 3.0 / 8.0
+        if float(self.data.close[-1]) < float(self.data.open[0]) - self.gap_distance:
+            self.lines.sell_signal[0] = float(self.data.high[0]) + atr_value * 3.0 / 8.0

backtrader/indicators/contrib/i_stoch_komposter_indicator.py

@@ -0,0 +1,77 @@
+#!/usr/bin/env python
+"""Functional-test indicators migrated to contrib.
+
+Generated from a single functional strategy module to preserve file-local
+helper functions and constants without cross-test name collisions.
+"""
+
+from .. import (
+    ATR,
+    Indicator,
+)
+
+__all__ = [
+    "IStochKomposterIndicator",
+]
+
+
+class IStochKomposterIndicator(Indicator):
+    """Stochastic-and-ATR composite that prints offset buy/sell markers.
+
+    Emits a buy line below the bar low (and a sell line above the bar high),
+    offset by 3/8 of ATR, whenever the slowed %K stochastic crosses up through
+    the lower level or down through the upper level respectively.
+    """
+
+    lines = ("sell", "buy", "sto", "atr")
+    params = (
+        ("atr_period", 14),
+        ("k_period", 5),
+        ("d_period", 3),
+        ("slowing", 3),
+        ("up_level", 70),
+        ("dn_level", 30),
+    )
+
+    def __init__(self):
+        """Build the ATR sub-indicator and set the warm-up minimum period."""
+        self._atr = ATR(self.data, period=int(self.p.atr_period))
+        self.addminperiod(
+            max(
+                int(self.p.atr_period),
+                int(self.p.k_period) + int(self.p.d_period) + int(self.p.slowing) + 1,
+            )
+            + 2
+        )
+
+    def _raw_k(self, ago):
+        period = int(self.p.k_period)
+        highs = [float(self.data.high[-(ago + i)]) for i in range(period)]
+        lows = [float(self.data.low[-(ago + i)]) for i in range(period)]
+        hh = max(highs)
+        ll = min(lows)
+        cp = float(self.data.close[-ago])
+        if hh == ll:
+            return 50.0
+        return 100.0 * (cp - ll) / (hh - ll)
+
+    def _main_stochastic(self):
+        slowing = int(self.p.slowing)
+        vals = [self._raw_k(i) for i in range(slowing)]
+        return sum(vals) / len(vals)
+
+    def next(self):
+        """Compute the slowed stochastic and emit ATR-offset cross markers."""
+        self.lines.sell[0] = float("nan")
+        self.lines.buy[0] = float("nan")
+        sto_now = self._main_stochastic()
+        self.lines.sto[0] = sto_now
+        self.lines.atr[0] = float(self._atr[0])
+        if len(self) < 2:
+            return
+        sto_prev = float(self.lines.sto[-1])
+        atr_now = float(self._atr[0])
+        if sto_now > float(self.p.dn_level) and sto_prev <= float(self.p.dn_level):
+            self.lines.buy[0] = float(self.data.low[0]) - atr_now * 3.0 / 8.0
+        if sto_now < float(self.p.up_level) and sto_prev >= float(self.p.up_level):
+            self.lines.sell[0] = float(self.data.high[0]) + atr_now * 3.0 / 8.0