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

backtrader/filters/renko.py

@@ -0,0 +1,164 @@
+#!/usr/bin/env python
+"""Renko Filter Module - Renko chart bars.
+
+This module provides the Renko filter for converting price data
+into Renko bricks for charting.
+
+Classes:
+    Renko: Creates Renko bars from price data.
+
+Example:
+    >>> data = bt.feeds.GenericCSVData(dataname='data.csv')
+    >>> data.addfilter(bt.filters.Renko(size=10))
+    >>> cerebro.adddata(data)
+"""
+
+from . import Filter
+
+__all__ = ["Renko"]
+
+
+class Renko(Filter):
+    """Modify the data stream to draw Renko bars (or bricks)
+
+    Params:
+
+      - ``hilo`` (default: *False*) Use high and low instead of close to decide
+        if a new brick is needed
+
+      - ``size`` (default: *None*) The size to consider for each brick
+
+      - ``autosize`` (default: *20.0*) If *size* is *None*, this will be used
+        to autocalculate the size of the bricks (simply dividing the current
+        price by the given value)
+
+      - ``dynamic`` (default: *False*) If *True* and using *autosize*, the size
+        of the bricks will be recalculated when moving to a new brick. This
+         will, of course, eliminate the perfect alignment of Renko bricks.
+
+      - ``align`` (default: *1.0*) Factor used to align the price boundaries of
+        the bricks. If the price is for example *3563.25* and *align* is
+        *10.0*, the resulting aligned price will be *3560*. The calculation:
+
+          - 3563.25 / 10.0 = 356.325
+          - round it and remove the decimals -> 356
+          - 356 * 10.0 -> 3560
+
+      - ``roundstart`` (default: *True*) If *True*, round the initial start
+        value to int. Else keep the original value, which should aid when
+        backtesting penny stocks
+
+    See:
+      - http://stockcharts.com/school/doku.php?id=chart_school:chart_analysis:renko
+
+    """
+
+    params = (
+        ("hilo", False),
+        ("size", None),
+        ("autosize", 20.0),
+        ("dynamic", False),
+        ("align", 1.0),
+        ("roundstart", True),
+    )
+
+    def __init__(self, data, *args, **kwargs):
+        """Initialize the Renko filter.
+
+        Args:
+            data: The data feed to apply the filter to.
+            *args: Variable length argument list.
+            **kwargs: Additional keyword arguments passed to parent class.
+        """
+        super().__init__(data, *args, **kwargs)
+        self._bot = None
+        self._top = None
+        self._size = None
+
+    def nextstart(self, data):
+        """Initialize Renko brick boundaries on the first data point.
+
+        This method sets up the initial brick size and top/bottom boundaries
+        based on the opening price and configured parameters.
+
+        Args:
+            data: The data feed containing the first bar.
+        """
+        o = data.open[0]
+        o = round(o / self.p.align, 0) * self.p.align  # aligned
+        self._size = self.p.size or (float(o // self.p.autosize) if self.p.autosize else 1.0)
+        if self.p.roundstart:
+            o = int(o)
+
+        self._top = o + self._size
+        self._bot = o - self._size
+
+    def next(self, data):
+        """Process each bar to create Renko bricks.
+
+        This method analyzes the current price data and creates Renko bricks
+        when price moves beyond the current brick boundaries. Each brick has
+        a fixed size, and new bricks are created when price breaks through
+        the current brick's top or bottom boundary.
+
+        Args:
+            data: The data feed containing current bar data.
+
+        Returns:
+            bool: True if the stream length changed (bar removed),
+                  False if unchanged (Renko brick created).
+        """
+        c = data.close[0]
+        h = data.high[0]
+        low = data.low[0]
+
+        if self.p.hilo:
+            hiprice = h
+            loprice = low
+        else:
+            hiprice = loprice = c
+
+        if hiprice >= self._top:
+            # deliver a renko brick from top -> top + size
+            self._bot = bot = self._top
+
+            if self.p.size is None and self.p.dynamic:
+                self._size = float(c // self.p.autosize) if self.p.autosize else 1.0
+                top = bot + self._size
+                top = round(top / self.p.align, 0) * self.p.align  # aligned
+            else:
+                top = bot + self._size
+
+            self._top = top
+
+            data.open[0] = bot
+            data.low[0] = bot
+            data.high[0] = top
+            data.close[0] = top
+            data.volume[0] = 0.0
+            data.openinterest[0] = 0.0
+            return False  # length of data stream is unaltered
+
+        if loprice <= self._bot:
+            # deliver a renko brick from bot -> bot - size
+            self._top = top = self._bot
+
+            if self.p.size is None and self.p.dynamic:
+                self._size = float(c // self.p.autosize) if self.p.autosize else 1.0
+                bot = top - self._size
+                bot = round(bot / self.p.align, 0) * self.p.align  # aligned
+            else:
+                bot = top - self._size
+
+            self._bot = bot
+
+            data.open[0] = top
+            data.low[0] = top
+            data.high[0] = bot
+            data.close[0] = bot
+            data.volume[0] = 0.0
+            data.openinterest[0] = 0.0
+            return False  # length of data stream is unaltered
+
+        data.backwards()
+        return True  # length of stream was changed, get new bar

backtrader/filters/session.py

@@ -0,0 +1,289 @@
+#!/usr/bin/env python
+"""Session Filter Module - Session bar filling.
+
+This module provides the SessionFiller filter for adding missing
+bars over gaps within a trading session.
+
+Classes:
+    SessionFiller: Fills missing bars within a session.
+
+Example:
+    >>> data = bt.feeds.GenericCSVData(dataname='data.csv')
+    >>> data.addfilter(bt.filters.SessionFiller())
+    >>> cerebro.adddata(data)
+"""
+
+from datetime import datetime, timedelta
+
+from ..dataseries import TimeFrame
+from ..parameters import ParameterDescriptor, ParameterizedBase
+
+
+class SessionFiller(ParameterizedBase):
+    """
+    Bar Filler to add missing bars over gaps in a session.
+
+    This class has been refactored from MetaParams to the new ParameterizedBase
+    system for Day 36-38 of the metaprogramming removal project.
+
+    How to use it:
+
+      - Instantiate the class (1 instance per filter needed)
+
+      - ``addfilter`` it to the data with ``data.addfilter(filter_instance)``
+
+    Bar ``fill`` logic:
+
+      - The ``fill_price`` will be used to fill ``open``, ``high``, ``low`` and
+        ``close``
+
+        If ``None`` then the ``close`` price of the last (previous) bar will be
+        used.
+
+      - Volume will be set to ``fill_vol``
+
+      - ``openinterest`` will be set to ``fill_oi``
+
+    Parameters:
+
+      - fill_price (def: None):
+
+        Price to be used to fill missing bars. If None will be used the closing
+        price of the previous bar
+
+      - fill_vol (def: float('NaN')):
+
+        Value to use to fill the missing volume
+
+      - Fill_oi (def: float('NaN')):
+
+        Value to use to fill the missing Open Interest
+
+      - Skip_first_fill (def: True):
+
+        Upon seeing the 1st valid bar do not fill from the sessionstart up to
+        that bar
+    """
+
+    # Use new parameter descriptor system to define parameters
+    fill_price = ParameterDescriptor(
+        default=None,
+        doc="Price to be used to fill missing bars. If None will be used the closing price of the previous bar",
+    )
+    fill_vol = ParameterDescriptor(
+        default=float("NaN"), type_=float, doc="Value to use to fill the missing volume"
+    )
+    fill_oi = ParameterDescriptor(
+        default=float("NaN"), type_=float, doc="Value to use to fill the missing Open Interest"
+    )
+    skip_first_fill = ParameterDescriptor(
+        default=True,
+        type_=bool,
+        doc="Upon seeing the 1st valid bar do not fill from the sessionstart up to that bar",
+    )
+
+    MAXDATE = datetime.max
+
+    # Minimum delta unit in between bars
+    _tdeltas = {
+        TimeFrame.Minutes: timedelta(seconds=60),
+        TimeFrame.Seconds: timedelta(seconds=1),
+        TimeFrame.MicroSeconds: timedelta(microseconds=1),
+    }
+
+    def __init__(self, data, **kwargs):
+        """Initialize the SessionFiller.
+
+        Args:
+            data: The data feed to apply the filter to.
+            **kwargs: Additional keyword arguments passed to parent class.
+        """
+        super().__init__(**kwargs)
+        # Calculate and save timedelta for timeframe
+        self._tdframe = self._tdeltas[data._timeframe]
+        self._tdunit = self._tdeltas[data._timeframe] * data._compression
+
+        self.seenbar = False  # control if at least one bar has been seen
+        self.sessend = self.MAXDATE  # maxdate is the control for session bar
+
+    def __call__(self, data):
+        """
+        Params:
+          - data: the data source to filter/process
+
+        Returns:
+          - False (always) because this filter does not remove bars from the
+        stream
+
+        The logic (starting with a session end control flag of MAXDATE)
+
+          - If new bar is over session end (never true for 1st bar)
+
+            Fill up to the session end.
+            Reset sessionend to MAXDATE & fall through
+
+          - If the session end is flagged as MAXDATE
+
+            Recalculate session limits and check whether the bar is within them
+
+            If so, fill up and record the last seen tim
+
+          - Else ... the incoming bar is in the session, fill up to it
+        """
+        # Get time of current (from a data source) bar
+        ret = False
+
+        dtime_cur = data.datetime.datetime()
+
+        if dtime_cur > self.sessend:
+            # bar over session end - fill up and invalidate
+            # Do not put current bar in stack to let it be evaluated below
+            # Fill up to endsession + the smallest unit of timeframe
+            ret = self._fillbars(data, self.dtime_prev, self.sessend + self._tdframe, tostack=False)
+            self.sessend = self.MAXDATE
+
+        # Fall through from previous check ... the bar which is over the
+        # session could already be in a new session and within the limits
+        if self.sessend == self.MAXDATE:
+            # No bar seen yet or one went over the previous session limit
+            ddate = dtime_cur.date()
+            sessstart = datetime.combine(ddate, data.p.sessionstart)
+            self.sessend = sessend = datetime.combine(ddate, data.p.sessionend)
+
+            if sessstart <= dtime_cur <= sessend:
+                # 1st bar from session in the session - fill from session start
+                if self.seenbar or not self.get_param("skip_first_fill"):
+                    ret = self._fillbars(data, sessstart - self._tdunit, dtime_cur)
+
+            self.seenbar = True
+            self.dtime_prev = dtime_cur
+
+        else:
+            # Seen a previous bar, and this is in the session - fill up to it
+            ret = self._fillbars(data, self.dtime_prev, dtime_cur)
+            self.dtime_prev = dtime_cur
+
+        return ret
+
+    def _fillbars(self, data, time_start, time_end, tostack=True):
+        """
+        Fills one by one bars as needed from time_start to time_end
+
+        Invalidates the control dtime_prev if requested
+        """
+        # Control flag - bars added to the stack
+        dirty = 0
+
+        time_start += self._tdunit
+        while time_start < time_end:
+            dirty += self._fillbar(data, time_start)
+            time_start += self._tdunit
+
+        if dirty and tostack:
+            data._save2stack(erase=True)
+
+        return bool(dirty) or not tostack
+
+    def _fillbar(self, data, dtime):
+        # Prepare an array of the necessary size
+        bar = [float("Nan")] * data.size()
+
+        # Fill datetime
+        bar[data.DateTime] = data.date2num(dtime)
+
+        # Fill the prices
+        price = self.get_param("fill_price") or data.close[-1]
+        for pricetype in [data.Open, data.High, data.Low, data.Close]:
+            bar[pricetype] = price
+
+        # Fill volume and open interest
+        bar[data.Volume] = self.get_param("fill_vol")
+        bar[data.OpenInterest] = self.get_param("fill_oi")
+
+        # Fill extra lines the data feed may have defined beyond DateTime
+        for i in range(data.DateTime + 1, data.size()):
+            bar[i] = data.lines[i][0]
+
+        # Add to the stack of bars to save
+        data._add2stack(bar)
+
+        return True
+
+
+class SessionFilterSimple(ParameterizedBase):
+    """
+    This class can be applied to a data source as a filter and will filter out
+    intraday bars which fall outside the regular session times (ie: pre/post
+    market data)
+
+    This class has been refactored from MetaParams to the new ParameterizedBase
+    system for Day 36-38 of the metaprogramming removal project.
+
+    This is a "simple" filter and must NOT manage the stack of the data (passed
+    during init and __call__)
+
+    It needs no "last" method because it has nothing to deliver
+
+    Bar Management will be done by the SimpleFilterWrapper class made which is
+    added durint the DataBase.addfilter_simple call
+    """
+
+    def __init__(self, data, **kwargs):
+        """Initialize the SessionFilterSimple.
+
+        Args:
+            data: The data feed to apply the filter to.
+            **kwargs: Additional keyword arguments passed to parent class.
+        """
+        super().__init__(**kwargs)
+
+    def __call__(self, data):
+        """
+        Return Values:
+
+          - False: nothing to filter
+          - True: filter current bar (because it's not in the session times)
+        """
+        # Both ends of the comparison are in the session
+        return not (data.p.sessionstart <= data.datetime.time(0) <= data.p.sessionend)
+
+
+class SessionFilter(ParameterizedBase):
+    """
+    This class can be applied to a data source as a filter and will filter out
+    intraday bars which fall outside the regular session times (ie: pre/post
+    market data)
+
+    This class has been refactored from MetaParams to the new ParameterizedBase
+    system for Day 36-38 of the metaprogramming removal project.
+
+    This is a "non-simple" filter and must manage the stack of the data (passed
+    during init and __call__)
+
+    It needs no "last" method because it has nothing to deliver
+    """
+
+    def __init__(self, data, **kwargs):
+        """Initialize the SessionFilter.
+
+        Args:
+            data: The data feed to apply the filter to.
+            **kwargs: Additional keyword arguments passed to parent class.
+        """
+        super().__init__(**kwargs)
+
+    def __call__(self, data):
+        """
+        Return Values:
+
+          - False: data stream was not touched
+          - True: data stream was manipulated (bar outside session times and
+          - removed)
+        """
+        if data.p.sessionstart <= data.datetime.time(0) <= data.p.sessionend:
+            # Both ends of the comparison are in the session
+            return False  # say the stream is untouched
+
+        # bar outside the regular session times
+        data.backwards()  # remove bar from data stack
+        return True  # the signal the data was manipulated

backtrader/flt.py

@@ -0,0 +1,80 @@
+#!/usr/bin/env python
+"""Filter Module - Data filtering for backtrader.
+
+This module provides the base Filter class for data filtering operations.
+Filters can be applied to data feeds to modify or filter bars during
+backtesting.
+
+Classes:
+    Filter: Base class for data filters.
+
+Example:
+    >>> class MyFilter(bt.Filter):
+    ...     def next(self, data):
+    ...         # Modify data bar
+    ...         pass
+"""
+
+from .parameters import ParameterizedBase
+
+__all__ = ["Filter"]
+
+
+# Filter class - refactored to use new parameter system
+class Filter(ParameterizedBase):
+    """Base class for data filters in backtrader.
+
+    Filters process data bars and can modify or reject them. Subclasses
+    should override the next() method to implement custom filtering logic.
+
+    Attributes:
+        _firsttime: Tracks if this is the first call.
+
+    This class has been refactored from MetaParams to the new ParameterizedBase
+    system for Day 36-38 of the metaprogramming removal project.
+    """
+
+    _firsttime = True
+
+    def __init__(self, data_, **kwargs):
+        """Initialize the Filter.
+
+        Args:
+            data_: The data feed to filter.
+            **kwargs: Additional keyword arguments for parameters.
+        """
+        # Call parent class initialization
+        super().__init__(**kwargs)
+
+    def __call__(self, data):
+        """Process a data bar through the filter.
+
+        Args:
+            data: The data feed being filtered.
+        """
+        # If first time, call nextstart, then set _firsttime to False
+        if self._firsttime:
+            self.nextstart(data)
+            self._firsttime = False
+        # Call next
+        self.next(data)
+
+    def nextstart(self, data):
+        """Called on the first bar before filtering starts.
+
+        Args:
+            data: The data feed being filtered.
+
+        Note:
+            Override this method to perform one-time initialization.
+        """
+
+    def next(self, data):
+        """Process each data bar.
+
+        Args:
+            data: The data feed being filtered.
+
+        Note:
+            Subclasses must override this method to implement filtering logic.
+        """