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

backtrader/indicators/percentchange.py

@@ -0,0 +1,83 @@
+#!/usr/bin/env python
+"""Percent Change Indicator Module - Percentage change calculation.
+
+This module provides the Percent Change indicator for measuring the
+percentage change in price over a given period.
+
+Classes:
+    PercentChange: Percentage change indicator (alias: PctChange).
+
+Example:
+    class MyStrategy(bt.Strategy):
+        def __init__(self):
+            # Measure 30-period percent change
+            self.pctchange = bt.indicators.PctChange(self.data.close, period=30)
+
+        def next(self):
+            # Buy when percent change is positive
+            if self.pctchange[0] > 0:
+                self.buy()
+"""
+
+from . import Indicator
+
+__all__ = ["PercentChange", "PctChange"]
+
+
+class PercentChange(Indicator):
+    """
+    Measures the percentage change of the current value with respect to that
+    of period bars ago
+    """
+
+    alias = ("PctChange",)
+    lines = ("pctchange",)
+
+    # Fancy plotting name
+    plotlines = {"pctchange": {"_name": "%change"}}
+
+    # update value to the standard for Moving Averages
+    params = (("period", 30),)
+
+    def __init__(self):
+        """Initialize the Percent Change indicator.
+
+        Sets minimum period to period + 1 for comparison calculation.
+        """
+        super().__init__()
+        self.addminperiod(self.p.period + 1)
+
+    def next(self):
+        """Calculate percent change for the current bar.
+
+        Formula: pctchange = (current_value / value_period_ago) - 1.0
+        Returns 0.0 if the previous value is 0 to avoid division by zero.
+        """
+        prev_val = self.data[-self.p.period]
+        if prev_val != 0:
+            self.lines.pctchange[0] = self.data[0] / prev_val - 1.0
+        else:
+            self.lines.pctchange[0] = 0.0
+
+    def once(self, start, end):
+        """Calculate percent change in runonce mode.
+
+        Computes percentage change for each bar relative to the value
+        'period' bars ago.
+        """
+        darray = self.data.array
+        larray = self.lines.pctchange.array
+        period = self.p.period
+
+        while len(larray) < end:
+            larray.append(float("nan"))
+
+        for i in range(period, min(end, len(darray))):
+            prev_val = darray[i - period]
+            if prev_val != 0:
+                larray[i] = darray[i] / prev_val - 1.0
+            else:
+                larray[i] = 0.0
+
+
+PctChange = PercentChange

backtrader/indicators/percentrank.py

@@ -0,0 +1,46 @@
+#!/usr/bin/env python
+"""Percent Rank Indicator Module - Percentile ranking.
+
+This module provides the Percent Rank indicator for calculating
+the percentile rank of current values within a period.
+
+Classes:
+    PercentRank: Percent rank indicator (alias: PctRank).
+
+Example:
+    class MyStrategy(bt.Strategy):
+        def __init__(self):
+            # Calculate 50-period percent rank
+            self.pctrank = bt.indicators.PctRank(self.data.close, period=50)
+
+        def next(self):
+            # Buy when price is in top 20% (percent rank > 0.8)
+            if self.pctrank[0] > 0.8:
+                self.buy()
+            # Sell when price is in bottom 20% (percent rank < 0.2)
+            elif self.pctrank[0] < 0.2:
+                self.sell()
+"""
+
+from math import fsum
+
+from . import BaseApplyN
+
+__all__ = ["PercentRank", "PctRank"]
+
+
+class PercentRank(BaseApplyN):
+    """
+    Measures the percent rank of the current value with respect to that of
+    period bars ago
+    """
+
+    alias = ("PctRank",)
+    lines = ("pctrank",)
+    params = (
+        ("period", 50),
+        ("func", lambda d: fsum(x < d[-1] for x in d) / len(d)),
+    )
+
+
+PctRank = PercentRank

backtrader/indicators/pivotpoint.py

@@ -0,0 +1,469 @@
+#!/usr/bin/env python
+"""Pivot Point Indicator Module - Support and resistance levels.
+
+This module provides Pivot Point indicators for calculating support
+and resistance levels from previous period price data.
+
+Classes:
+    PivotPoint: Standard pivot points with 2 support/resistance levels.
+    FibonacciPivotPoint: Pivot points with Fibonacci-based levels.
+    DemarkPivotPoint: Demark pivot point calculation.
+
+Example:
+    class MyStrategy(bt.Strategy):
+        def __init__(self):
+            # Calculate pivot points from resampled data (data1)
+            self.pivot = bt.indicators.PivotPoint(self.data1)
+
+        def next(self):
+            # Buy when price breaks above resistance level 1
+            if self.data.close[0] > self.pivot.r1[0]:
+                self.buy()
+            # Sell when price breaks below support level 1
+            elif self.data.close[0] < self.pivot.s1[0]:
+                self.sell()
+"""
+
+from . import Indicator
+
+
+class PivotPoint(Indicator):
+    """
+    Defines a level of significance by taking into account the average of price
+    bar components of the past period of a larger timeframe.
+    For example, when
+    operating with days, the values are taking from the already "past" month
+    fixed prices.
+
+    Example of using this indicator:
+
+      data = btfeeds.ADataFeed(dataname=x, timeframe=bt.TimeFrame.Days)
+      cerebro.adddata(data)
+      cerebro.resampledata(data, timeframe=bt.TimeFrame.Months)
+
+    In the ``__init__`` method of the strategy:
+
+      pivotindicator = btind.PivotPoiont(self.data1) # the resampled data
+
+    The indicator will try to automatically plo to the non-resampled data.
+    To
+    disable this behavior, use the following during construction:
+
+      - _autoplot=False
+
+    Note:
+
+      The example shows *days* and *months*, but any combination of timeframes
+      can be used.
+      See the literature for recommended combinations
+
+    Formula:
+      - pivot = (h + l + c) / 3 # variants duplicate close or add open
+      - support1 = 2.0 * pivot - high
+      - support2 = pivot - (high - low)
+      - resistance1 = 2.0 * pivot - low
+      - resistance2 = pivot + (high - low)
+
+    See:
+      - http://stockcharts.com/school/doku.php?id=chart_school:technical_indicators:pivot_points
+      - https://en.wikipedia.org/wiki/Pivot_point_(technical_analysis)
+    """
+
+    lines = (
+        "p",
+        "s1",
+        "s2",
+        "r1",
+        "r2",
+    )
+    plotinfo = {"subplot": False}
+
+    params = (
+        ("open", False),  # add opening price to the pivot point
+        ("close", False),  # use close twice in the calcs
+        ("_autoplot", True),  # attempt to plot on real target data
+    )
+
+    def _plotinit(self):
+        """Initialize plot settings for Pivot Point.
+
+        Attempts to plot on the actual timeframe master data
+        rather than the resampled data.
+        """
+        # Try to plot to the actual timeframe master
+        if self.p._autoplot:
+            if hasattr(self.data, "data"):
+                self.plotinfo.plotmaster = self.data.data
+
+    def __init__(self):
+        """Initialize the Pivot Point indicator.
+
+        Sets up coupler to follow real object if autoplot is enabled.
+        """
+        super().__init__()  # enable coopertive inheritance
+
+        if self.p._autoplot:
+            self.plotinfo.plot = False  # disable own plotting
+            self()  # Coupler to follow a real object
+
+    def next(self):
+        """Calculate pivot point and support/resistance levels.
+
+        Standard formula: p = (h + l + c) / 3
+        Support/Resistance levels derived from pivot and high-low range.
+        """
+        o = self.data.open[0]
+        h = self.data.high[0]
+        low = self.data.low[0]
+        c = self.data.close[0]
+
+        if self.p.close:
+            p = (h + low + 2.0 * c) / 4.0
+        elif self.p.open:
+            p = (h + low + c + o) / 4.0
+        else:
+            p = (h + low + c) / 3.0
+
+        self.lines.p[0] = p
+        self.lines.s1[0] = 2.0 * p - h
+        self.lines.r1[0] = 2.0 * p - low
+        self.lines.s2[0] = p - (h - low)
+        self.lines.r2[0] = p + (h - low)
+
+    def once(self, start, end):
+        """Calculate pivot point levels in runonce mode.
+
+        Computes pivot, support, and resistance levels across all bars.
+        """
+        o_array = self.data.open.array
+        h_array = self.data.high.array
+        l_array = self.data.low.array
+        c_array = self.data.close.array
+        p_array = self.lines.p.array
+        s1_array = self.lines.s1.array
+        s2_array = self.lines.s2.array
+        r1_array = self.lines.r1.array
+        r2_array = self.lines.r2.array
+
+        for arr in [p_array, s1_array, s2_array, r1_array, r2_array]:
+            while len(arr) < end:
+                arr.append(float("nan"))
+
+        use_close = self.p.close
+        use_open = self.p.open
+
+        for i in range(start, min(end, len(h_array), len(l_array), len(c_array))):
+            o = o_array[i] if i < len(o_array) else 0.0
+            h = h_array[i] if i < len(h_array) else 0.0
+            low = l_array[i] if i < len(l_array) else 0.0
+            c = c_array[i] if i < len(c_array) else 0.0
+
+            if use_close:
+                p = (h + low + 2.0 * c) / 4.0
+            elif use_open:
+                p = (h + low + c + o) / 4.0
+            else:
+                p = (h + low + c) / 3.0
+
+            p_array[i] = p
+            s1_array[i] = 2.0 * p - h
+            r1_array[i] = 2.0 * p - low
+            s2_array[i] = p - (h - low)
+            r2_array[i] = p + (h - low)
+
+
+class FibonacciPivotPoint(Indicator):
+    """
+    Defines a level of significance by taking into account the average of price
+    bar components of the past period of a larger timeframe.
+    For example, when
+    operating with days, the values are taking from the already "past" month
+    fixed prices.
+
+    Fibonacci levels (configurable) are used to define the support/resistance levels
+
+    Example of using this indicator:
+
+      data = btfeeds.ADataFeed(dataname=x, timeframe=bt.TimeFrame.Days)
+      cerebro.adddata(data)
+      cerebro.resampledata(data, timeframe=bt.TimeFrame.Months)
+
+    In the ``__init__`` method of the strategy:
+
+      pivotindicator = btind.FibonacciPivotPoiont(self.data1) # the resampled data
+
+    The indicator will try to automatically plo to the non-resampled data.
+    To
+    disable this behavior, use the following during construction:
+
+      - _autoplot=False
+
+    Note:
+
+      The example shows *days* and *months*, but any combination of timeframes
+      can be used.
+      See the literature for recommended combinations
+
+    Formula:
+      - pivot = (h + l + c) / 3  # variants duplicate close or add open
+      - support1 = p - level1 * (high - low)  # level1 0.382
+      - support2 = p - level2 * (high - low)  # level2 0.618
+      - support3 = p - level3 * (high - low)  # level3 1.000
+      - resistance1 = p + level1 * (high - low)  # level1 0.382
+      - resistance2 = p + level2 * (high - low)  # level2 0.618
+      - resistance3 = p + level3 * (high - low)  # level3 1.000
+
+    See:
+      - http://stockcharts.com/school/doku.php?id=chart_school:technical_indicators:pivot_points
+    """
+
+    lines = ("p", "s1", "s2", "s3", "r1", "r2", "r3")
+    plotinfo = {"subplot": False}
+    params = (
+        ("open", False),  # add opening price to the pivot point
+        ("close", False),  # use close twice in the calcs
+        ("_autoplot", True),  # attempt to plot on real target data
+        ("level1", 0.382),
+        ("level2", 0.618),
+        ("level3", 1.0),
+    )
+
+    def _plotinit(self):
+        """Initialize plot settings for Fibonacci Pivot Point.
+
+        Attempts to plot on the actual timeframe master data
+        rather than the resampled data.
+        """
+        # Try to plot to the actual timeframe master
+        if self.p._autoplot:
+            if hasattr(self.data, "data"):
+                self.plotinfo.plotmaster = self.data.data
+
+    def __init__(self):
+        """Initialize the Fibonacci Pivot Point indicator.
+
+        Sets up coupler to follow real object if autoplot is enabled.
+        """
+        super().__init__()
+
+        if self.p._autoplot:
+            self.plotinfo.plot = False  # disable own plotting
+            self()  # Coupler to follow a real object
+
+    def next(self):
+        """Calculate Fibonacci pivot point and support/resistance levels.
+
+        Uses Fibonacci ratios (0.382, 0.618, 1.0) to calculate
+        support/resistance levels from pivot point.
+        """
+        o = self.data.open[0]
+        h = self.data.high[0]
+        low = self.data.low[0]
+        c = self.data.close[0]
+
+        if self.p.close:
+            p = (h + low + 2.0 * c) / 4.0
+        elif self.p.open:
+            p = (h + low + c + o) / 4.0
+        else:
+            p = (h + low + c) / 3.0
+
+        hl_range = h - low
+        self.lines.p[0] = p
+        self.lines.s1[0] = p - self.p.level1 * hl_range
+        self.lines.s2[0] = p - self.p.level2 * hl_range
+        self.lines.s3[0] = p - self.p.level3 * hl_range
+        self.lines.r1[0] = p + self.p.level1 * hl_range
+        self.lines.r2[0] = p + self.p.level2 * hl_range
+        self.lines.r3[0] = p + self.p.level3 * hl_range
+
+    def once(self, start, end):
+        """Calculate Fibonacci pivot point levels in runonce mode.
+
+        Computes pivot and Fibonacci-based support/resistance levels
+        across all bars.
+        """
+        o_array = self.data.open.array
+        h_array = self.data.high.array
+        l_array = self.data.low.array
+        c_array = self.data.close.array
+        p_array = self.lines.p.array
+        s1_array = self.lines.s1.array
+        s2_array = self.lines.s2.array
+        s3_array = self.lines.s3.array
+        r1_array = self.lines.r1.array
+        r2_array = self.lines.r2.array
+        r3_array = self.lines.r3.array
+
+        for arr in [p_array, s1_array, s2_array, s3_array, r1_array, r2_array, r3_array]:
+            while len(arr) < end:
+                arr.append(float("nan"))
+
+        use_close = self.p.close
+        use_open = self.p.open
+        level1 = self.p.level1
+        level2 = self.p.level2
+        level3 = self.p.level3
+
+        for i in range(start, min(end, len(h_array), len(l_array), len(c_array))):
+            o = o_array[i] if i < len(o_array) else 0.0
+            h = h_array[i] if i < len(h_array) else 0.0
+            low = l_array[i] if i < len(l_array) else 0.0
+            c = c_array[i] if i < len(c_array) else 0.0
+
+            if use_close:
+                p = (h + low + 2.0 * c) / 4.0
+            elif use_open:
+                p = (h + low + c + o) / 4.0
+            else:
+                p = (h + low + c) / 3.0
+
+            hl_range = h - low
+            p_array[i] = p
+            s1_array[i] = p - level1 * hl_range
+            s2_array[i] = p - level2 * hl_range
+            s3_array[i] = p - level3 * hl_range
+            r1_array[i] = p + level1 * hl_range
+            r2_array[i] = p + level2 * hl_range
+            r3_array[i] = p + level3 * hl_range
+
+
+class DemarkPivotPoint(Indicator):
+    """
+    Defines a level of significance by taking into account the average of price
+    bar components of the past period of a larger timeframe.
+    For example, when
+    operating with days, the values are taking from the already "past" month
+    fixed prices.
+
+    Example of using this indicator:
+
+      data = btfeeds.ADataFeed(dataname=x, timeframe=bt.TimeFrame.Days)
+      cerebro.adddata(data)
+      cerebro.resampledata(data, timeframe=bt.TimeFrame.Months)
+
+    In the ``__init__`` method of the strategy:
+
+      pivotindicator = btind.DemarkPivotPoiont(self.data1) # the resampled data
+
+    The indicator will try to automatically plo to the non-resampled data.
+    To
+    disable this behavior, use the following during construction:
+
+      - _autoplot=False
+
+    Note:
+
+      The example shows *days* and *months*, but any combination of timeframes
+      can be used.
+      See the literature for recommended combinations
+
+    Formula:
+      - if close < open x = high + (2 x low) + close
+
+      - If close > open x = (2 x high) + low + close
+
+      - If Close == open x = high + low + (2 x close)
+
+      - P = x / 4
+
+      - Support1 = x / 2 - high
+      - resistance1 = x / 2 - low
+
+    See:
+      - http://stockcharts.com/school/doku.php?id=chart_school:technical_indicators:pivot_points
+    """
+
+    lines = (
+        "p",
+        "s1",
+        "r1",
+    )
+    plotinfo = {"subplot": False}
+    params = (
+        ("open", False),  # add opening price to the pivot point
+        ("close", False),  # use close twice in the calcs
+        ("_autoplot", True),  # attempt to plot on real target data
+        ("level1", 0.382),
+        ("level2", 0.618),
+        ("level3", 1.0),
+    )
+
+    def _plotinit(self):
+        """Initialize plot settings for Demark Pivot Point.
+
+        Attempts to plot on the actual timeframe master data
+        rather than the resampled data.
+        """
+        # Try to plot to the actual timeframe master
+        if self.p._autoplot:
+            if hasattr(self.data, "data"):
+                self.plotinfo.plotmaster = self.data.data
+
+    def __init__(self):
+        """Initialize the Demark Pivot Point indicator.
+
+        Sets up coupler to follow real object if autoplot is enabled.
+        """
+        super().__init__()
+
+        if self.p._autoplot:
+            self.plotinfo.plot = False  # disable own plotting
+            self()  # Coupler to follow a real object
+
+    def next(self):
+        """Calculate Demark pivot point and support/resistance levels.
+
+        Demark formula uses relationship between open and close
+        to determine the calculation method.
+        """
+        h = self.data.high[0]
+        low = self.data.low[0]
+        o = self.data.open[0]
+        c = self.data.close[0]
+
+        if c < o:
+            x = h + 2.0 * low + c
+        elif c > o:
+            x = 2.0 * h + low + c
+        else:
+            x = h + low + 2.0 * c
+
+        self.lines.p[0] = x / 4.0
+        self.lines.s1[0] = x / 2.0 - h
+        self.lines.r1[0] = x / 2.0 - low
+
+    def once(self, start, end):
+        """Calculate Demark pivot point levels in runonce mode.
+
+        Computes Demark-style pivot, support, and resistance levels
+        across all bars.
+        """
+        o_array = self.data.open.array
+        h_array = self.data.high.array
+        l_array = self.data.low.array
+        c_array = self.data.close.array
+        p_array = self.lines.p.array
+        s1_array = self.lines.s1.array
+        r1_array = self.lines.r1.array
+
+        for arr in [p_array, s1_array, r1_array]:
+            while len(arr) < end:
+                arr.append(float("nan"))
+
+        for i in range(start, min(end, len(h_array), len(l_array), len(c_array), len(o_array))):
+            o = o_array[i] if i < len(o_array) else 0.0
+            h = h_array[i] if i < len(h_array) else 0.0
+            low = l_array[i] if i < len(l_array) else 0.0
+            c = c_array[i] if i < len(c_array) else 0.0
+
+            if c < o:
+                x = h + 2.0 * low + c
+            elif c > o:
+                x = 2.0 * h + low + c
+            else:
+                x = h + low + 2.0 * c
+
+            p_array[i] = x / 4.0
+            s1_array[i] = x / 2.0 - h
+            r1_array[i] = x / 2.0 - low

backtrader/indicators/prettygoodoscillator.py

@@ -0,0 +1,113 @@
+#!/usr/bin/env python
+"""Pretty Good Oscillator Module - PGO indicator.
+
+This module provides the Pretty Good Oscillator (PGO) developed
+by Mark Johnson for measuring price distance from moving average
+in terms of ATR.
+
+Classes:
+    PrettyGoodOscillator: PGO indicator (aliases: PGO, PrettyGoodOsc).
+
+Example:
+    class MyStrategy(bt.Strategy):
+        def __init__(self):
+            # Calculate Pretty Good Oscillator with 14-period
+            self.pgo = bt.indicators.PrettyGoodOscillator(self.data, period=14)
+
+        def next(self):
+            # Buy when PGO rises above 3.0 (breakout signal)
+            if self.pgo[0] > 3.0:
+                self.buy()
+            # Sell short when PGO falls below -3.0
+            elif self.pgo[0] < -3.0:
+                self.sell()
+            # Exit positions when returning to zero
+            elif len(self.position) > 0 and abs(self.pgo[0]) < 0.5:
+                self.close()
+"""
+
+import math
+
+from . import ATR, Indicator, MovAv
+
+
+class PrettyGoodOscillator(Indicator):
+    """
+    The "Pretty Good Oscillator" (PGO) by Mark Johnson measures the distance of
+    the current close from its simple moving average of period
+    Average), expressed in terms of an average true range (see Average True
+    Range) over a similar period.
+
+    So for instance a PGO value of +2.5 would mean the current close is 2.5
+    average days' range above the SMA.
+
+    Johnson's approach was to use it as a breakout system for longer term
+    trades. If the PGO rises above 3.0 then go long, or below -3.0 then go
+    short, and in both cases exit on returning to zero (which is a close back
+    at the SMA).
+
+    Formula:
+      - pgo = (data.close - sma(data, period)) / atr(data, period)
+
+    See also:
+      - http://user42.tuxfamily.org/chart/manual/Pretty-Good-Oscillator.html
+
+    """
+
+    alias = (
+        "PGO",
+        "PrettyGoodOsc",
+    )
+    lines = ("pgo",)
+
+    params = (
+        ("period", 14),
+        ("_movav", MovAv.Simple),
+    )
+
+    def __init__(self):
+        """Initialize the Pretty Good Oscillator.
+
+        Creates moving average and ATR sub-indicators.
+        """
+        super().__init__()
+        self.movav = self.p._movav(self.data, period=self.p.period)
+        self.atr = ATR(self.data, period=self.p.period)
+
+    def next(self):
+        """Calculate PGO for the current bar.
+
+        Formula: PGO = (price - MA) / ATR
+        """
+        atr_val = self.atr[0]
+        if atr_val != 0:
+            self.lines.pgo[0] = (self.data[0] - self.movav[0]) / atr_val
+        else:
+            self.lines.pgo[0] = 0.0
+
+    def once(self, start, end):
+        """Calculate PGO in runonce mode."""
+        darray = self.data.array
+        ma_array = self.movav.lines[0].array
+        atr_array = self.atr.lines[0].array
+        larray = self.lines.pgo.array
+
+        while len(larray) < end:
+            larray.append(float("nan"))
+
+        for i in range(start, min(end, len(darray), len(ma_array), len(atr_array))):
+            data_val = darray[i] if i < len(darray) else 0.0
+            ma_val = ma_array[i] if i < len(ma_array) else 0.0
+            atr_val = atr_array[i] if i < len(atr_array) else 0.0
+
+            if (
+                isinstance(ma_val, float)
+                and math.isnan(ma_val)
+                or isinstance(atr_val, float)
+                and math.isnan(atr_val)
+            ):
+                larray[i] = float("nan")
+            elif atr_val != 0:
+                larray[i] = (data_val - ma_val) / atr_val
+            else:
+                larray[i] = 0.0