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

backtrader/filters/calendardays.py

@@ -0,0 +1,121 @@
+#!/usr/bin/env python
+"""Calendar Days Filter Module - Calendar day filling.
+
+This module provides the CalendarDays filter for adding missing
+calendar days to trading day data.
+
+Classes:
+    CalendarDays: Fills missing calendar days.
+
+Example:
+    >>> data = bt.feeds.GenericCSVData(dataname='data.csv')
+    >>> data.addfilter(bt.filters.CalendarDays())
+    >>> cerebro.adddata(data)
+"""
+
+from datetime import date, datetime, timedelta
+
+from ..parameters import ParameterizedBase
+
+
+class CalendarDays(ParameterizedBase):
+    """
+    Bar Filler to add missing calendar days to trading days
+
+    Params:
+
+      - fill_price (def: None):
+
+        > 0: The given value to fill
+        0 or None: Use the last known closing price
+        -1: Use the midpoint of the last bar (High-Low average)
+
+      - 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
+    """
+
+    params = (
+        ("fill_price", None),
+        ("fill_vol", float("NaN")),
+        ("fill_oi", float("NaN")),
+    )
+
+    ONEDAY = timedelta(days=1)
+    lastdt = date.max
+
+    def __init__(self, data, **kwargs):
+        """Initialize the CalendarDays filter.
+
+        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):
+        """
+        If the data has a gap larger than 1 day amongst bars, the missing bars
+        are added to the stream.
+
+        Params:
+          - data: the data source to filter/process
+
+        Returns:
+          - False (always): this filter does not remove bars from the stream
+
+        """
+        dt = data.datetime.date()
+        if (dt - self.lastdt) > self.ONEDAY:  # gap in place
+            self._fillbars(data, dt, self.lastdt)
+
+        self.lastdt = dt
+        return False  # no bar has been removed from the stream
+
+    def _fillbars(self, data, dt, lastdt):
+        """
+        Fills one by one bars as needed from time_start to time_end
+
+        Invalidates the control dtime_prev if requested
+        """
+        tm = data.datetime.time(0)  # get time part
+
+        # Same price for all bars
+        fp = self.p.fill_price
+        if fp is not None and fp > 0:
+            price = fp
+        elif fp == -1:
+            price = (data.high[-1] + data.low[-1]) / 2.0
+        else:
+            # None, 0, or any other falsy value → use last close
+            price = data.close[-1]
+
+        while lastdt < dt:
+            lastdt += self.ONEDAY
+
+            # Prepare an array of the necessary size
+            bar = [float("Nan")] * data.size()
+            # Fill the datetime
+            bar[data.DateTime] = data.date2num(datetime.combine(lastdt, tm))
+
+            # Fill price fields
+            for pricetype in [data.Open, data.High, data.Low, data.Close]:
+                bar[pricetype] = price
+
+            # Fill volume and open interest
+            bar[data.Volume] = self.p.fill_vol
+            bar[data.OpenInterest] = self.p.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 this constructed bar to the stack of the stream
+            data._add2stack(bar)
+
+        # Save to stack the bar that signaled the gap
+        data._save2stack(erase=True)

backtrader/filters/datafiller.py

@@ -0,0 +1,192 @@
+#!/usr/bin/env python
+"""Data Filler Filter Module - Gap filling for data feeds.
+
+This module provides the DataFiller for filling gaps in data feeds
+when bars are missing.
+
+Classes:
+    DataFiller: Fills gaps in data with specified values.
+
+Example:
+    >>> data = bt.feeds.GenericCSVData(dataname='data.csv')
+    >>> data.addfilter(bt.filters.DataFiller())
+    >>> cerebro.adddata(data)
+"""
+
+import collections
+from datetime import datetime, timedelta
+
+from ..dataseries import TimeFrame
+from ..feed import AbstractDataBase
+
+
+class DataFiller(AbstractDataBase):
+    """This class will fill gaps in the source data using the following
+    information bits from the underlying data source
+
+      - timeframe and compression are to dimension the output bars
+
+      - sessionstart and sessionend
+
+    If a data feed has missing bars in between 10:31 and 10:34 and the
+    timeframe is minutes, the output will be filled with bars for minutes
+    10:32 and 10:33 using the closing price of the last bar (10:31)
+
+    Bars can be missing amongst other things because
+
+    Params:
+      - ``fill_price`` (def: None): if None (or evaluates to False), the
+        closing price will be used, else the passed value (which can be
+        for example 'NaN' to have a missing bar in terms of evaluation but
+        present in terms of time
+
+      - ``fill_vol`` (def: NaN): used to fill the volume with missing bars
+
+      - ``fill_oi`` (def: NaN): used to fill the openinterest with missing bars
+    """
+
+    params = (
+        ("fill_price", None),
+        ("fill_vol", float("NaN")),
+        ("fill_oi", float("NaN")),
+    )
+
+    def __init__(self):
+        """Initialize the DataFiller.
+
+        Sets up internal state variables for tracking timeframe,
+        compression, data bars, and fill bars queue.
+        """
+        self._timeframe = None
+        self._compression = None
+        self._dbar = None
+        self._fillbars = None
+
+    def start(self):
+        """Start the data filler.
+
+        Initializes the fill bars queue and data bar flag.
+        This method is called when the data feed starts processing.
+        """
+        super().start()
+        self._fillbars = collections.deque()
+        self._dbar = False
+
+    def preload(self):
+        """Preload data from the underlying data source.
+
+        If the underlying data is not preloaded, loads it completely.
+        Copies timeframe and compression settings from the source data
+        after it has started (some sources do autodetection).
+
+        This method ensures all necessary data is available before processing.
+        """
+        if len(self.p.dataname) == self.p.dataname.buflen():
+            # if data is not preloaded … do it
+            self.p.dataname.start()
+            self.p.dataname.preload()
+            self.p.dataname.home()
+
+        # Copy timeframe from data after start (some sources do autodetection)
+        self.p.timeframe = self._timeframe = self.p.dataname._timeframe
+        self.p.compression = self._compression = self.p.dataname._compression
+
+        super().preload()
+
+    def _copyfromdata(self):
+        # Data is allowed - Copy size which is "number of lines"
+        for i in range(self.p.dataname.size()):
+            self.lines[i][0] = self.p.dataname.lines[i][0]
+
+        self._dbar = False  # invalidate a flag for read bar
+
+        return True
+
+    def _frombars(self):
+        dtime, price = self._fillbars.popleft()
+
+        price = self.p.fill_price or price
+
+        self.lines.datetime[0] = self.p.dataname.date2num(dtime)
+        self.lines.open[0] = price
+        self.lines.high[0] = price
+        self.lines.low[0] = price
+        self.lines.close[0] = price
+        self.lines.volume[0] = self.p.fill_vol
+        self.lines.openinterest[0] = self.p.fill_oi
+
+        return True
+
+    # Minimum delta unit in between bars
+    _tdeltas = {
+        TimeFrame.Minutes: timedelta(seconds=60),
+        TimeFrame.Seconds: timedelta(seconds=1),
+        TimeFrame.MicroSeconds: timedelta(microseconds=1),
+    }
+
+    def _load(self):
+        if not len(self.p.dataname):
+            self.p.dataname.start()  # start data if not done somewhere else
+
+            # Copy from underlying data
+            self._timeframe = self.p.dataname._timeframe
+            self._compression = self.p.dataname._compression
+
+            self.p.timeframe = self._timeframe
+            self.p.compression = self._compression
+
+            # Calculate and save timedelta for timeframe
+            self._tdunit = self._tdeltas[self._timeframe]
+            self._tdunit *= self._compression
+
+        if self._fillbars:
+            return self._frombars()
+
+        # use existing bar or fetch a bar
+        self._dbar = self._dbar or self.p.dataname.next()
+        if not self._dbar:
+            return False  # no more data
+
+        if len(self) == 1:
+            # Cannot yet look backwards - deliver data as is
+            return self._copyfromdata()
+
+        # previous (delivered) close
+        pclose = self.lines.close[-1]
+        # Get time of previous (already delivered) bar
+        dtime_prev = self.lines.datetime.datetime(-1)
+        # Get time of current (from a data source) bar
+        dtime_cur = self.p.dataname.datetime.datetime(0)
+
+        # Calculate the session end for previous bar
+        send = datetime.combine(dtime_prev.date(), self.p.dataname.sessionend)
+
+        if dtime_cur > send:  # if jumped boundary
+            # 1. check for missing bars until boundary (end)
+            dtime_prev += self._tdunit
+            while dtime_prev < send:
+                self._fillbars.append((dtime_prev, pclose))
+                dtime_prev += self._tdunit
+
+            # Calculate session start for new bar
+            sstart = datetime.combine(dtime_cur.date(), self.p.dataname.sessionstart)
+
+            # 2. check for missing bars from new boundary (start)
+            # check a gap from new sessionstart
+            while sstart < dtime_cur:
+                self._fillbars.append((sstart, pclose))
+                sstart += self._tdunit
+        else:
+            # no boundary jumped - check the gap until current time
+            dtime_prev += self._tdunit
+            while dtime_prev < dtime_cur:
+                self._fillbars.append((dtime_prev, pclose))
+                dtime_prev += self._tdunit
+
+        if self._fillbars:
+            self._dbar = True  # flag a pending data bar is available
+
+            # return an accumulated bar in the current cycle
+            return self._frombars()
+
+        return self._copyfromdata()

backtrader/filters/datafilter.py

@@ -0,0 +1,74 @@
+#!/usr/bin/env python
+"""Data Filter Module - Generic data filtering.
+
+This module provides the DataFilter for filtering bars from a
+data source based on a callable function.
+
+Classes:
+    DataFilter: Filters bars based on a filter function.
+
+Example:
+    >>> data = bt.feeds.GenericCSVData(dataname='data.csv')
+    >>> data.addfilter(bt.filters.DataFilter(funcfilter=my_filter_func))
+    >>> cerebro.adddata(data)
+"""
+
+from ..feed import AbstractDataBase
+
+
+class DataFilter(AbstractDataBase):
+    """
+    This class filters out bars from a given data source. In addition to the
+    standard parameters of a DataBase, it takes a ``funcfilter`` parameter which
+    can be any callable
+
+    Logic:
+
+      - ``funcfilter`` will be called with the underlying data source
+
+        It can be any callable
+
+        - Return value ``True``: current data source bar values will be used
+        - Return value ``False``: current data source bar values will discard
+    """
+
+    params = (("funcfilter", None),)
+
+    def preload(self):
+        """Preload data from the underlying data source.
+
+        If the underlying data is not preloaded, loads it completely.
+        Copies timeframe and compression settings from the source data
+        after it has started (some sources do autodetection).
+
+        This method ensures all necessary data is available before processing.
+        """
+        if len(self.p.dataname) == self.p.dataname.buflen():
+            # if data is not preloaded … do it
+            self.p.dataname.start()
+            self.p.dataname.preload()
+            self.p.dataname.home()
+
+        # Copy timeframe from data after start (some sources do autodetection)
+        self.p.timeframe = self._timeframe = self.p.dataname._timeframe
+        self.p.compression = self._compression = self.p.dataname._compression
+
+        super().preload()
+
+    def _load(self):
+        if not len(self.p.dataname):
+            self.p.dataname.start()  # start data if not done somewhere else
+
+        # Tell the underlying source to get next data
+        while self.p.dataname.next():
+            # Try to load the data from the underlying source
+            if not self.p.funcfilter(self.p.dataname):
+                continue
+
+            # Data is allowed - Copy size which is "number of lines"
+            for i in range(self.p.dataname.size()):
+                self.lines[i][0] = self.p.dataname.lines[i][0]
+
+            return True
+
+        return False  # no more data from an underlying source

backtrader/filters/daysteps.py

@@ -0,0 +1,96 @@
+#!/usr/bin/env python
+"""Day Steps Filter Module - Bar replay simulation.
+
+This module provides the BarReplayerOpen filter for splitting bars
+to simulate replay behavior.
+
+Classes:
+    BarReplayerOpen: Splits bars into open and OHLC parts.
+
+Example:
+    >>> data = bt.feeds.GenericCSVData(dataname='data.csv')
+    >>> data.addfilter(bt.filters.BarReplayerOpen())
+    >>> cerebro.adddata(data)
+"""
+
+
+class BarReplayerOpen:
+    """
+    This filters splits a bar in two parts:
+
+      - ``Open``: the opening price of the bar will be used to deliver an
+        initial price bar in which the four components (OHLC) are equal
+
+        The volume/openinterest fields are zero for this initial bar
+
+      - ``OHLC``: the original bar is delivered complete with the original
+        ``volume``/``openinterest``
+
+    The split simulates a replay without the need to use the *replay* filter.
+    """
+
+    def __init__(self, data):
+        """Initialize the BarReplayerOpen filter.
+
+        Args:
+            data: The data feed to apply the filter to.
+                  The filter sets resampling=1 and replaying=True on the data.
+        """
+        self.pendingbar = None
+        data.resampling = 1
+        data.replaying = True
+
+    def __call__(self, data):
+        """Process the data feed to split bars into open and OHLC parts.
+
+        This method is called for each bar in the data feed. It splits the bar
+        into two parts - an initial bar with only the open price (OHLC=Open)
+        and the original OHLC bar. This simulates intraday replay behavior.
+
+        Args:
+            data: The data feed containing the bar to process.
+
+        Returns:
+            bool: True if the length of the stream was changed,
+                  False if it remained unchanged.
+        """
+        ret = True
+
+        # Make a copy of the new bar and remove it from stream
+        newbar = [data.lines[i][0] for i in range(data.size())]
+        data.backwards()  # remove the copied bar from stream
+
+        openbar = newbar[:]  # Make an open only bar
+        o = newbar[data.Open]
+        for field_idx in [data.High, data.Low, data.Close]:
+            openbar[field_idx] = o
+
+        # Nullify Volume/OpenInteres at the open
+        openbar[data.Volume] = 0.0
+        openbar[data.OpenInterest] = 0.0
+
+        # Overwrite the new data bar with our pending data - except start point
+        if self.pendingbar is not None:
+            data._updatebar(self.pendingbar)
+            ret = False
+
+        self.pendingbar = newbar  # update the pending bar to the new bar
+        data._add2stack(openbar)  # Add the openbar to the stack for processing
+
+        return ret  # the length of the stream was not changed
+
+    def last(self, data):
+        """Called when the data is no longer producing bars
+        Can be called multiple times. It has the chance to (for example)
+        produce extra bars"""
+        if self.pendingbar is not None:
+            data.backwards()  # remove delivered open bar
+            data._add2stack(self.pendingbar)  # add remaining
+            self.pendingbar = None  # No further action
+            return True  # something delivered
+
+        return False  # nothing delivered here
+
+
+# Alias
+DayStepsFilter = BarReplayerOpen

backtrader/filters/heikinashi.py

@@ -0,0 +1,63 @@
+#!/usr/bin/env python
+"""Heikin Ashi Filter Module - Heikin Ashi candlestick filter.
+
+This module provides the HeikinAshi filter for remodeling price
+data into Heikin Ashi candlesticks.
+
+Classes:
+    HeikinAshi: Creates Heikin Ashi candlesticks.
+
+Example:
+    >>> data = bt.feeds.GenericCSVData(dataname='data.csv')
+    >>> data.addfilter(bt.filters.HeikinAshi())
+    >>> cerebro.adddata(data)
+"""
+
+__all__ = ["HeikinAshi"]
+
+
+class HeikinAshi:
+    """
+    The filter remodels the open, high, low, close to make HeikinAshi
+    candlesticks
+
+    See:
+      - https://en.wikipedia.org/wiki/Candlestick_chart#Heikin_Ashi_candlesticks
+      - http://stockcharts.com/school/doku.php?id=chart_school:chart_analysis:heikin_ashi
+
+    """
+
+    def __init__(self, data):
+        """Initialize the HeikinAshi filter.
+
+        Args:
+            data: The data feed to apply the filter to.
+                  No specific parameters are required.
+        """
+
+    def __call__(self, data):
+        """Convert standard OHLC data to Heikin Ashi candlesticks.
+
+        This method transforms the OHLC data into Heikin Ashi format, which
+        uses the average of open, high, low, and close for the close price,
+        and averages the previous close and open for the current open price.
+
+        Args:
+            data: The data feed containing OHLC values to convert.
+
+        Returns:
+            bool: False (the length of data stream is unaltered).
+        """
+        o, h, low, c = data.open[0], data.high[0], data.low[0], data.close[0]
+
+        data.close[0] = ha_close0 = (o + h + low + c) / 4.0
+
+        if len(data) > 1:
+            data.open[0] = ha_open0 = (data.open[-1] + data.close[-1]) / 2.0
+            data.high[0] = max(ha_open0, ha_close0, h)
+            data.low[0] = min(ha_open0, ha_close0, low)
+
+        else:  # len is 1, no lookback is possible
+            data.open[0] = ha_open0 = (o + c) / 2.0
+
+        return False  # length of data stream is unaltered