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

backtrader/indicators/contrib/derivative_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 Indicator
+
+__all__ = [
+    "DerivativeIndicator",
+]
+
+
+APPLIED_PRICE_MAP = {
+    "PRICE_CLOSE": 0,
+    "PRICE_OPEN": 1,
+    "PRICE_HIGH": 2,
+    "PRICE_LOW": 3,
+    "PRICE_MEDIAN": 4,
+    "PRICE_TYPICAL": 5,
+    "PRICE_WEIGHTED": 6,
+    "PRICE_OPEN_CLOSE": 8,
+    "PRICE_OHLC_AVERAGE": 9,
+    "PRICE_DEMARK": 10,
+    "PRICE_AVERAGE_DEMARK": 11,
+}
+
+
+class DerivativeIndicator(Indicator):
+    """Derivative indicator derived from a selected applied price.
+
+    The computed `value` line is a momentum-like slope:
+    ``100 * (price[0] - price[-i_slowing]) / i_slowing``.
+    """
+
+    lines = ("value",)
+    params = (
+        ("i_slowing", 34),
+        ("applied_price", "PRICE_WEIGHTED"),
+    )
+
+    def __init__(self):
+        """Require at least ``i_slowing + 1`` bars before emitting values."""
+        self.addminperiod(int(self.p.i_slowing) + 1)
+
+    def _mode_value(self, value, default_value):
+        if isinstance(value, str):
+            return APPLIED_PRICE_MAP.get(value, default_value)
+        return int(value)
+
+    def _price(self, ago=0):
+        mode = self._mode_value(self.p.applied_price, 0)
+        open_ = float(self.data.open[ago])
+        high = float(self.data.high[ago])
+        low = float(self.data.low[ago])
+        close = float(self.data.close[ago])
+        if mode == 0:
+            return close
+        if mode == 1:
+            return open_
+        if mode == 2:
+            return high
+        if mode == 3:
+            return low
+        if mode == 4:
+            return (high + low) / 2.0
+        if mode == 5:
+            return (close + high + low) / 3.0
+        if mode == 6:
+            return (2.0 * close + high + low) / 4.0
+        if mode == 8:
+            return (open_ + close) / 2.0
+        if mode == 9:
+            return (open_ + close + high + low) / 4.0
+        if mode == 10:
+            if close > open_:
+                return high
+            if close < open_:
+                return low
+            return close
+        if mode == 11:
+            if close > open_:
+                return (high + close) / 2.0
+            if close < open_:
+                return (low + close) / 2.0
+            return close
+        return close
+
+    def next(self):
+        """Update the derivative value for the current bar."""
+        lag = int(self.p.i_slowing)
+        current = self._price(0)
+        past = self._price(-lag)
+        self.lines.value[0] = 100.0 * (current - past) / float(lag)

backtrader/indicators/contrib/digital_ft01_indicator.py

@@ -0,0 +1,112 @@
+#!/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__ = [
+    "DigitalFT01Indicator",
+]
+
+
+DIGITAL_WEIGHTS = [
+    0.24470985659780,
+    0.23139774006970,
+    0.20613796947320,
+    0.17166230340640,
+    0.13146907903600,
+    0.08950387549560,
+    0.04960091651250,
+    0.01502270569607,
+    -0.01188033734430,
+    -0.02989873856137,
+    -0.03898967104900,
+    -0.04014113626390,
+    -0.03511968085800,
+    -0.02611613850342,
+    -0.01539056955666,
+    -0.00495353651394,
+    0.00368588764825,
+    0.00963614049782,
+    0.01265138888314,
+    0.01307496106868,
+    0.01169702291063,
+    0.00974841844086,
+    0.00898900012545,
+    -0.00649745721156,
+]
+
+
+class DigitalFT01Indicator(Indicator):
+    """Fixed-weight digital filter with a channel trigger for crossover signals."""
+
+    lines = ("digital", "trigger")
+    params = (
+        ("halfchannel", 25),
+        ("applied_price_code", 1),
+        ("point", 0.01),
+        ("signal_period_minutes", 180),
+    )
+
+    def __init__(self):
+        """Set the minimum period to cover the digital-filter kernel length."""
+        self.addminperiod(len(DIGITAL_WEIGHTS) + 10)
+
+    def _price_value(self, shift):
+        o = float(self.data.open[-shift] if shift else self.data.open[0])
+        h = float(self.data.high[-shift] if shift else self.data.high[0])
+        low_price = float(self.data.low[-shift] if shift else self.data.low[0])
+        c = float(self.data.close[-shift] if shift else self.data.close[0])
+        code = int(self.p.applied_price_code)
+        if code == 1:
+            return c
+        if code == 2:
+            return o
+        if code == 3:
+            return h
+        if code == 4:
+            return low_price
+        if code == 5:
+            return (h + low_price) / 2.0
+        if code == 6:
+            return (h + low_price + c) / 3.0
+        if code == 7:
+            return (h + low_price + c + c) / 4.0
+        if code == 8:
+            return (o + h + low_price + c) / 4.0
+        if code == 12:
+            base = h + low_price + c
+            if c < o:
+                return (base + low_price) / 4.0
+            if c > o:
+                return (base + h) / 4.0
+            return (base + c) / 4.0
+        return c
+
+    def next(self):
+        """Compute the digital-filter value and channel trigger for this bar.
+
+        Convolves the fixed DIGITAL_WEIGHTS kernel with the applied price, then
+        sets the trigger to a reference close plus/minus the half-channel
+        depending on whether the filtered value is above or below that close.
+        """
+        if len(self.data) < len(DIGITAL_WEIGHTS):
+            return
+        digital = 0.0
+        for shift, weight in enumerate(DIGITAL_WEIGHTS):
+            digital += weight * self._price_value(shift)
+        dt = num2date(self.data.datetime[0])
+        period_minutes = max(int(self.p.signal_period_minutes), 1)
+        bars_from_day_start = int(round((dt.hour * 60 + dt.minute) / float(period_minutes)) + 1)
+        if len(self.data) <= bars_from_day_start:
+            return
+        ref_close = float(self.data.close[-bars_from_day_start])
+        halfchannel = float(self.p.halfchannel) * float(self.p.point)
+        trigger = ref_close + halfchannel if digital >= ref_close else ref_close - halfchannel
+        self.lines.digital[0] = digital
+        self.lines.trigger[0] = trigger

backtrader/indicators/contrib/digital_macd.py

@@ -0,0 +1,200 @@
+#!/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 collections import deque
+
+from .. import (
+    Indicator,
+    SimpleMovingAverage,
+)
+
+__all__ = [
+    "DigitalMacd",
+]
+
+
+class DigitalMacd(Indicator):
+    """Digital MACD indicator built from fixed FIR fast/slow filter banks."""
+
+    lines = ("macd", "signal")
+    params = (
+        ("signal_period", 5),
+        ("point", 0.01),
+    )
+
+    FAST_COEFFS = [
+        0.2149840610,
+        0.2065763732,
+        0.1903728890,
+        0.1675422436,
+        0.1397053150,
+        0.1087951881,
+        0.0768869405,
+        0.0460244906,
+        0.0180517395,
+        -0.0055294579,
+        -0.0236660212,
+        -0.0358140055,
+        -0.0419497760,
+        -0.0425331450,
+        -0.0384279507,
+        -0.0307917433,
+        -0.0209443384,
+        -0.0102335925,
+        0.0000932767,
+        0.0089950015,
+        0.0157131144,
+        0.0198149331,
+        0.0211989019,
+        0.0200639819,
+        0.0168532934,
+        0.0121825067,
+        0.0067474241,
+        0.0012444305,
+        -0.0037087682,
+        -0.0076300416,
+        -0.0102110543,
+        -0.0113306266,
+        -0.0110462105,
+        -0.0095662166,
+        -0.0072080453,
+        -0.0043494435,
+        -0.0013771970,
+        0.0013575268,
+        0.0035760416,
+        0.0050946166,
+        0.0058339574,
+        0.0058160431,
+        0.0051486631,
+        0.0039984014,
+        0.0025619380,
+        0.0010531475,
+        -0.0003481453,
+        -0.0014937154,
+        -0.0022905986,
+        -0.0027000514,
+        -0.0027359080,
+        -0.0024543322,
+        -0.0019409837,
+        -0.0012957482,
+        -0.0006179734,
+        0.0000057542,
+        0.0005111297,
+        0.0008605279,
+        0.0010441921,
+        0.0010775684,
+        0.0009966494,
+        0.0008537300,
+        0.0007142855,
+        0.0006599146,
+        -0.0008151017,
+    ]
+
+    SLOW_COEFFS = [
+        0.0825641231,
+        0.0822783080,
+        0.0814249974,
+        0.0800166909,
+        0.0780735197,
+        0.0756232268,
+        0.0727009740,
+        0.0693478349,
+        0.0656105823,
+        0.0615409157,
+        0.0571939540,
+        0.0526285643,
+        0.0479025123,
+        0.0430785482,
+        0.0382152880,
+        0.0333706133,
+        0.0286021160,
+        0.0239614376,
+        0.0194972056,
+        0.0152532583,
+        0.0112682658,
+        0.0075745482,
+        0.0041980052,
+        0.0011588603,
+        -0.0015292889,
+        -0.0038593393,
+        -0.0058303888,
+        -0.0074473108,
+        -0.0087203043,
+        -0.0096645874,
+        -0.0102995666,
+        -0.0106483424,
+        -0.0107374524,
+        -0.0105952115,
+        -0.0102516944,
+        -0.0097377645,
+        -0.0090838346,
+        -0.0083237046,
+        -0.0074804382,
+        -0.0065902734,
+        -0.0056742995,
+        -0.0047554314,
+        -0.0038574209,
+        -0.0029983549,
+        -0.0021924972,
+        -0.0014513858,
+        -0.0007848072,
+        -0.0001995891,
+        0.0003009728,
+        0.0007162164,
+        0.0010478905,
+        0.0012994016,
+        0.0014755433,
+        0.0015824007,
+        0.0016272598,
+        0.0016185271,
+        0.0015648336,
+        0.0014747659,
+        0.0013569946,
+        0.0012193896,
+        0.0010695971,
+        0.0009140878,
+        0.0007591540,
+        0.0016019033,
+    ]
+
+    def __init__(self):
+        """Cache FIR coefficients, set warmup, and build the signal SMA.
+
+        Side effects:
+            Stores the fast/slow coefficient tuples, allocates the rolling close
+            buffer, sets the minimum warmup period, and wires ``signal`` as an
+            SMA of the ``macd`` line.
+        """
+        self._fast_coeffs = tuple(float(v) for v in self.FAST_COEFFS)
+        self._slow_coeffs = tuple(float(v) for v in self.SLOW_COEFFS)
+        self._max_lookback = max(len(self._fast_coeffs), len(self._slow_coeffs))
+        self._closes = deque(maxlen=self._max_lookback)
+        self.addminperiod(self._max_lookback + max(int(self.p.signal_period), 1))
+        self._point = float(self.p.point) if float(self.p.point) else 1.0
+        self.l.signal = SimpleMovingAverage(self.l.macd, period=max(int(self.p.signal_period), 1))
+
+    def next(self):
+        """Convolve the rolling close window with the FIR banks to set ``macd``.
+
+        Emits NaN until the buffer is full, then writes the point-scaled
+        difference of the fast and slow digital filter outputs to ``macd``.
+        """
+        self._closes.append(float(self.data.close[0]))
+        if len(self._closes) < self._max_lookback:
+            self.l.macd[0] = float("nan")
+            return
+
+        closes = tuple(self._closes)
+        fast_dma = 0.0
+        for idx, coeff in enumerate(self._fast_coeffs):
+            fast_dma += coeff * closes[-(idx + 1)]
+
+        slow_dma = 0.0
+        for idx, coeff in enumerate(self._slow_coeffs):
+            slow_dma += coeff * closes[-(idx + 1)]
+
+        self.l.macd[0] = (fast_dma - slow_dma) / self._point

backtrader/indicators/contrib/donchian_channels_system.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 Indicator
+
+__all__ = [
+    "DonchianChannelsSystem",
+]
+
+
+class DonchianChannelsSystem(Indicator):
+    """Donchian-channel indicator emitting breakout-oriented color states."""
+
+    lines = ("color",)
+    params = (
+        ("period", 20),
+        ("shift", 2),
+        ("margins", -2),
+    )
+
+    def __init__(self):
+        """Initialize warmup period based on configured Donchian window."""
+        self.addminperiod(int(self.p.period) + int(self.p.shift) + 3)
+
+    def next(self):
+        """Update rolling channel bounds and write the current breakout color."""
+        shift = int(self.p.shift)
+        highs = [float(self.data.high[-(shift + i)]) for i in range(int(self.p.period))]
+        lows = [float(self.data.low[-(shift + i)]) for i in range(int(self.p.period))]
+        hh = max(highs)
+        ll = min(lows)
+        smin = ll + (hh - ll) * float(self.p.margins) / 100.0
+        smax = hh - (hh - ll) * float(self.p.margins) / 100.0
+        close = float(self.data.close[0])
+        open_ = float(self.data.open[0])
+        color = 2.0
+        if close > smax:
+            color = 4.0 if open_ <= close else 3.0
+        if close < smin:
+            color = 0.0 if open_ > close else 1.0
+        self.lines.color[0] = color

backtrader/indicators/contrib/dots_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 Indicator
+
+__all__ = [
+    "DotsIndicator",
+]
+
+
+class DotsIndicator(Indicator):
+    """Compute a multi-cycle Dots value and color-change state.
+
+    Attributes:
+        lines: Custom lines ``dots`` and ``color``.
+        params: Indicator parameters used in strategy logic.
+    """
+
+    lines = ("dots", "color")
+    params = (
+        ("length", 10),
+        ("filter_points", 0.0),
+        ("price_code", 1),
+        ("point", 0.01),
+    )
+
+    def __init__(self):
+        """Initialize internal caches and indicator warmup state."""
+        self.addminperiod(int(self.p.length) * 4 + int(self.p.length) + 5)
+        self.res1 = 1.0 / max(float(self.p.length), 1.0)
+        self.phase = max(int(self.p.length) - 1, 0)
+        self.cycle = 4
+        self.filter_distance = float(self.p.filter_points) * float(self.p.point)
+
+    def _price_value(self, shift):
+        o = float(self.data.open[-shift] if shift else self.data.open[0])
+        h = float(self.data.high[-shift] if shift else self.data.high[0])
+        low_price = float(self.data.low[-shift] if shift else self.data.low[0])
+        c = float(self.data.close[-shift] if shift else self.data.close[0])
+        code = int(self.p.price_code)
+        if code == 1:
+            return c
+        if code == 2:
+            return o
+        if code == 3:
+            return h
+        if code == 4:
+            return low_price
+        if code == 5:
+            return (h + low_price) / 2.0
+        if code == 6:
+            return (h + low_price + c) / 3.0
+        if code == 7:
+            return (h + low_price + c + c) / 4.0
+        if code == 8:
+            return (o + h + low_price + c) / 4.0
+        return c
+
+    def next(self):
+        """Update smoothed value and color state for the current bar."""
+        total_len = self.phase + int(self.p.length) * self.cycle
+        if len(self.data) <= total_len:
+            return
+        t = 0.0
+        total = 0.0
+        weight = 0.0
+        for iii in range(total_len):
+            if t <= 0.5:
+                g = 1.0
+            else:
+                g = 1.0 / (self.phase + 1.0)
+            beta = math.cos(math.pi * t)
+            alpha = g * beta
+            price = self._price_value(iii)
+            total += alpha * price
+            weight += alpha
+            if t < 1.0:
+                t += self.res1
+        ma = total / weight if weight else self.data.close[0]
+        prev_ma = float(self.lines.dots[-1]) if len(self.data) > 1 else ma
+        color = float(self.lines.color[-1]) if len(self.data) > 1 else 0.0
+        if ma - prev_ma > self.filter_distance:
+            color = 0.0
+        elif prev_ma - ma > self.filter_distance:
+            color = 1.0
+        self.lines.dots[0] = ma
+        self.lines.color[0] = color

backtrader/indicators/contrib/ef_distance_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 .. import Indicator
+
+__all__ = [
+    "EFDistanceIndicator",
+]
+
+
+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 (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.open + data.close + data.high + data.low) / 4.0
+    return data.close
+
+
+class EFDistanceIndicator(Indicator):
+    """Energy-field distance indicator producing a weighted applied-price value.
+
+    Weights each price in a window by the accumulated powered distance to the
+    other prices in the window, yielding a smoothed ``value`` line whose turns
+    signal momentum shifts.
+    """
+
+    lines = ("value",)
+    params = (
+        ("length", 10),
+        ("power", 2.0),
+        ("ipc", "price_close"),
+        ("price_shift", 0.0),
+    )
+
+    def __init__(self):
+        """Set the minimum period required for the energy-field window."""
+        self.addminperiod(int(self.p.length) * 2 + 2)
+
+    def next(self):
+        """Compute the energy-field weighted price value for the current bar."""
+        length = int(self.p.length)
+        float(resolve_price_line(self.data, self.p.ipc)[0])
+        weights = []
+        prices = []
+        for i in range(length):
+            base_price = float(resolve_price_line(self.data, self.p.ipc)[-i])
+            energy = 0.0
+            for j in range(length):
+                ref_price = float(resolve_price_line(self.data, self.p.ipc)[-(i + j)])
+                energy += abs((base_price - ref_price) ** float(self.p.power))
+            weights.append(energy)
+            prices.append(base_price)
+        norm = sum(weights)
+        value = sum(w * p for w, p in zip(weights, prices)) / norm if norm else 0.0
+        self.lines.value[0] = value + float(self.p.price_shift)