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

backtrader/feeds/rollover.py

@@ -0,0 +1,229 @@
+#!/usr/bin/env python
+"""Rollover Data Feed Module - Futures contract rollover.
+
+This module provides the RollOver feed for automatically rolling over
+to the next futures contract when conditions are met.
+
+Classes:
+    RollOver: Rolls over to the next future when conditions are met.
+
+Example:
+    >>> data_old = bt.feeds.BacktraderCSVData(dataname='contract_old.csv')
+    >>> data_new = bt.feeds.BacktraderCSVData(dataname='contract_new.csv')
+    >>> data = bt.feeds.RollOver(data_old, data_new, checkdate=my_check_func)
+    >>> cerebro.adddata(data)
+"""
+
+from datetime import datetime
+
+from ..feed import DataBase
+from ..utils.date import Localizer
+
+
+class RollOver(DataBase):
+    # Roll over to the next future when conditions are met
+    """Class that rolls over to the next future when a condition is met
+
+    Params:
+
+        - ``checkdate`` (default: ``None``)
+
+          This must be a *callable* with the following signature::
+
+            Checkdate(dt, d):
+
+          Where:
+
+            - ``dt`` is a ``datetime.datetime`` object
+            - ``d`` is the current data feed for the active future
+
+          Expected Return Values:
+
+            - ``True``: as long as the callable returns this, a switchover can
+              happen to the next future
+
+        If a commodity expires on the 3rd Friday of March, `checkdate` could
+        return `True` for the entire week in which the expiration takes
+        place.
+
+            - ``False``: the expiration cannot take place
+
+        # This parameter is a callable object checkdate(dt,d), where dt is a time object, d is current active data,
+        # If return value is True, will switch to next contract; if False, will not switch to next contract
+
+        - ``checkcondition`` (default: ``None``)
+
+          **Note**: This will only be called if ``checkdate`` has returned
+          ``True``
+
+          If ``None`` this will evaluate to ``True`` (execute roll over)
+          internally
+
+          Else this must be a *callable* with this signature::
+
+            Checkcondition(d0, d1)
+
+          Where:
+
+            - ``d0`` is the current data feed for the active future
+            - ``d1`` is the data feed for the next expiration
+
+          Expected Return Values:
+
+            - ``True``: roll-over to the next future
+
+        Following with the example from ``checkdate``, this could say that the
+        roll-over can only happen if the *volume* from ``d0`` is already less
+        than the volume from ``d1``
+
+            - ``False``: the expiration cannot take place
+        # When checkdate returns True, this function will be called, this must be a callable object, checkcondition(d0,d1)
+        # Where d0 is current active futures contract, d1 is next expiring contract, if True, will switch from d0 to d1, if not, switch will not happen.
+    """
+
+    params = (
+        # ('rolls', []),  # array of futures to roll over
+        ("checkdate", None),  # callable
+        ("checkcondition", None),  # callable
+    )
+
+    def islive(self):
+        # Make data live form, will avoid preloading and runonce
+        """Returns ``True`` to notify ``Cerebro`` that preloading and runonce
+        should be deactivated"""
+        return True
+
+    def __init__(self, *args, **kwargs):
+        """Initialize the RollOver data feed.
+
+        Args:
+            *args: Data feeds to roll over between.
+            **kwargs: Keyword arguments for data feed configuration.
+        """
+        # Handle timeframe and compression parameters, originally handled by metaclass
+        if args:
+            # Copy timeframe and compression from first data source
+            kwargs.setdefault("timeframe", getattr(args[0], "_timeframe", None))
+            kwargs.setdefault("compression", getattr(args[0], "_compression", None))
+
+        super().__init__(**kwargs)
+
+        # Prepare futures contracts for rollover
+        self._dts = None
+        self._dexp = None
+        self._d = None
+        self._ds = None
+        self._rolls = args
+
+    def start(self):
+        """Start the RollOver data feed.
+
+        Initializes all data feeds for rollover functionality.
+        """
+        super().start()
+        # Loop through all data, prepare to start
+        for d in self._rolls:
+            d.setenvironment(self._env)
+            d._start()
+
+        # put the references in a separate list to have pops
+        self._ds = list(self._rolls)
+        # First data
+        self._d = self._ds.pop(0) if self._ds else None
+        # Expiration data
+        self._dexp = None
+        # Here defaults a minimum time, when comparing with any time, will move
+        self._dts = [datetime.min for xx in self._ds]
+
+    def stop(self):
+        """Stop the RollOver data feed.
+
+        Stops all underlying data feeds.
+        """
+        # End data
+        super().stop()
+        for d in self._rolls:
+            d.stop()
+
+    def _gettz(self):
+        # Get specific timezone
+        """To be overriden by subclasses which may auto-calculate the
+        timezone"""
+        if self._rolls:
+            return self._rolls[0]._gettz()
+        return Localizer(self.p.tz)
+
+    def _checkdate(self, dt, d):
+        # Calculate if current rollover conditions are met
+        if self.p.checkdate is not None:
+            return self.p.checkdate(dt, d)
+
+        return False
+
+    def _checkcondition(self, d0, d1):
+        # Prepare to start rollover
+        if self.p.checkcondition is not None:
+            return self.p.checkcondition(d0, d1)
+
+        return True
+
+    def _load(self):
+        # Method to load data
+        while self._d is not None:
+            # When self._d is not None, call next
+            _next = self._d.next()
+            # If _next value is None, continue calling next
+            if _next is None:  # no values yet, more will come
+                continue
+            # If _next value is False, current data switches to next data,
+            if _next is False:  # no values from current data src
+                if self._ds:
+                    self._d = self._ds.pop(0)
+                    self._dts.pop(0)
+                else:
+                    self._d = None
+                continue
+            # Current time of current data
+            dt0 = self._d.datetime.datetime()  # current dt for active data
+
+            # Synchronize other datas using dt0
+            # Synchronize other data based on current time
+            for i, d_dt in enumerate(zip(self._ds, self._dts)):
+                d, dt = d_dt
+                # If other data's time is less than current time, move other data forward, increase time, and save time to self._dts
+                while dt < dt0:
+                    if d.next() is None:
+                        continue
+                    self._dts[i] = dt = d.datetime.datetime()
+
+            # Move expired future as much as needed
+            # Move expired data
+            while self._dexp is not None:
+                if not self._dexp.next():
+                    self._dexp = None
+                    break
+
+                if self._dexp.datetime.datetime() < dt0:
+                    continue
+
+            if self._dexp is None and self._checkdate(dt0, self._d):
+                # rule has been met ... check other factors only if 2 datas
+                # still there
+                if self._ds and self._checkcondition(self._d, self._ds[0]):
+                    # Time to switch to next data
+                    self._dexp = self._d
+                    self._d = self._ds.pop(0)
+                    self._dts.pop(0)
+
+            # Fill the line and tell we die
+            self.lines.datetime[0] = self._d.lines.datetime[0]
+            self.lines.open[0] = self._d.lines.open[0]
+            self.lines.high[0] = self._d.lines.high[0]
+            self.lines.low[0] = self._d.lines.low[0]
+            self.lines.close[0] = self._d.lines.close[0]
+            self.lines.volume[0] = self._d.lines.volume[0]
+            self.lines.openinterest[0] = self._d.lines.openinterest[0]
+            return True
+
+        # Out of the loop -> self._d is None, no data feed to return from
+        return False

backtrader/feeds/sierrachart.py

@@ -0,0 +1,30 @@
+#!/usr/bin/env python
+"""Sierra Chart CSV Data Feed Module - SierraChart CSV parsing.
+
+This module provides the SierraChartCSVData feed for parsing
+Sierra Chart exported CSV files.
+
+Classes:
+    SierraChartCSVData: Parses SierraChart CSV format files.
+
+Example:
+    >>> data = bt.feeds.SierraChartCSVData(dataname='sierra.csv')
+    >>> cerebro.adddata(data)
+"""
+
+from . import GenericCSVData
+
+
+# Read format with time format '%Y/%m/%d'
+class SierraChartCSVData(GenericCSVData):
+    """
+    Parses a `SierraChart <http://www.sierrachart.com>`_ CSV exported file.
+
+    Specific parameters (or specific meaning):
+
+      - ``dataname``: The filename to parse or a file-like object
+
+      - Uses GenericCSVData and simply modifies the dateformat (dtformat) to
+    """
+
+    params = (("dtformat", "%Y/%m/%d"),)

backtrader/feeds/vchart.py

@@ -0,0 +1,162 @@
+#!/usr/bin/env python
+"""Visual Chart Binary Data Feed Module - VisualChart binary files.
+
+This module provides the VChartData feed for reading VisualChart
+binary on-disk data files.
+
+Classes:
+    VChartData: Reads VisualChart binary data files.
+
+Example:
+    >>> data = bt.feeds.VChartData(dataname='data.fd')
+    >>> cerebro.adddata(data)
+"""
+
+import datetime
+import os.path
+import struct
+
+from .. import feed
+from ..dataseries import TimeFrame
+from ..utils import date2num
+
+
+# Process Visual Chart binary data, supports daily or intraday data formats
+class VChartData(feed.DataBase):
+    """
+    Support for `Visual Chart <www.visualchart.com>`_ binary on-disk files for
+    both daily and intradaily formats.
+
+    Note:
+
+      - ``dataname``: to file or open file-like an object
+
+        If a file-like object is passed, the ``timeframe`` parameter will be
+        used to determine which is the actual timeframe.
+
+        Else the file extension (``.fd`` for daily and ``.min`` for intraday)
+        will be used.
+    """
+
+    def __init__(self):
+        """Initialize the VChart data feed."""
+        self.barfmt = None
+        self.f = None
+        self.barsize = None
+        self.dtsize = None
+        self.ext = None
+
+    def start(self):
+        """Start the VChart data feed.
+
+        Opens the VisualChart binary file for reading.
+        """
+        super().start()
+
+        # Not yet known if an extension is needed
+        self.ext = ""
+
+        if not hasattr(self.p.dataname, "read"):
+            # assume is a string because it has no write method
+
+            if self.p.dataname.endswith(".fd"):
+                self.p.timeframe = TimeFrame.Days
+            elif self.p.dataname.endswith(".min"):
+                self.p.timeframe = TimeFrame.Minutes
+            else:
+                # Neither fd nor min ... just the code, assign extension
+                if self.p.timeframe == TimeFrame.Days:
+                    self.ext = ".fd"
+                else:
+                    self.ext = ".min"
+
+        if self.p.timeframe >= TimeFrame.Days:
+            self.barsize = 28
+            self.dtsize = 1
+            self.barfmt = "IffffII"
+        else:
+            self.dtsize = 2
+            self.barsize = 32
+            self.barfmt = "IIffffII"
+
+        self.f = None
+        if hasattr(self.p.dataname, "read"):
+            # A file has been passed in (ex: from a GUI)
+            self.f = self.p.dataname
+        else:
+            dataname = self.p.dataname + self.ext
+            # Let an exception propagate
+            self.f = open(dataname, "rb")
+
+    def stop(self):
+        """Stop the VChart data feed.
+
+        Closes the open file handle.
+        """
+        if self.f is not None:
+            self.f.close()
+            self.f = None
+
+    def _load(self):
+        if self.f is None:
+            return False
+
+        # Let an exception propagate to let the caller know
+        bardata = self.f.read(self.barsize)
+        if not bardata:
+            return False
+
+        bdata = struct.unpack(self.barfmt, bardata)
+
+        # Years are stored as if they had 500 days
+        y, md = divmod(bdata[0], 500)
+        # Months are stored as if they had 32 days
+        m, d = divmod(md, 32)
+        dt = datetime.datetime(y, m, d)
+
+        if self.dtsize > 1:  # Minute Bars
+            # Daily Time is stored in seconds
+            hhmm, ss = divmod(bdata[1], 60)
+            hh, mm = divmod(hhmm, 60)
+            dt = dt.replace(hour=hh, minute=mm, second=ss)
+
+        self.lines.datetime[0] = date2num(dt)
+
+        o, h, low, c, v, oi = bdata[self.dtsize :]
+        self.lines.open[0] = o
+        self.lines.high[0] = h
+        self.lines.low[0] = low
+        self.lines.close[0] = c
+        self.lines.volume[0] = v
+        self.lines.openinterest[0] = oi
+
+        return True
+
+
+class VChartFeed(feed.FeedBase):
+    """VisualChart feed class.
+
+    Wrapper class for VChartData feed functionality.
+    """
+
+    DataCls = VChartData
+
+    params = (("basepath", ""),) + DataCls.params._gettuple()
+
+    def _getdata(self, dataname, **kwargs):
+        maincode = dataname[0:2]
+        subcode = dataname[2:6]
+
+        datapath = os.path.join(
+            self.p.basepath,
+            "RealServer",
+            "Data",
+            maincode,
+            subcode,
+            dataname,  # 01 00XX
+        )
+
+        newkwargs = self.p._getkwargs()
+        newkwargs.update(kwargs)
+        kwargs["dataname"] = datapath
+        return self.DataCls(**kwargs)

backtrader/feeds/vchartcsv.py

@@ -0,0 +1,84 @@
+#!/usr/bin/env python
+"""VisualChart CSV Data Feed Module - VisualChart CSV parsing.
+
+This module provides the VChartCSVData feed for parsing VisualChart
+CSV exported files.
+
+Classes:
+    VChartCSVData: Parses VisualChart CSV format files.
+
+Example:
+    >>> data = bt.feeds.VChartCSVData(dataname='vchart.csv')
+    >>> cerebro.adddata(data)
+"""
+
+import datetime
+
+from .. import feed
+from ..dataseries import TimeFrame
+from ..utils import date2num
+
+
+# Process Visual Chart CSV files
+class VChartCSVData(feed.CSVDataBase):
+    """
+    Parses a `VisualChart <http://www.visualchart.com>`_ CSV exported file.
+
+    Specific parameters (or specific meaning):
+
+      - ``dataname``: The filename to parse or a file-like object
+    """
+
+    vctframes = {
+        "I": TimeFrame.Minutes,
+        "D": TimeFrame.Days,
+        "W": TimeFrame.Weeks,
+        "M": TimeFrame.Months,
+    }
+
+    def _loadline(self, linetokens):
+        itokens = iter(linetokens)
+
+        ticker = next(itokens)  # skip ticker name
+        if not self._name:
+            self._name = ticker
+
+        # day/intraday indication
+        timeframe = next(itokens)
+
+        self._timeframe = self.vctframes[timeframe]
+
+        dttxt = next(itokens)
+        y, m, d = int(dttxt[0:4]), int(dttxt[4:6]), int(dttxt[6:8])
+
+        tmtxt = next(itokens)
+        if timeframe == "I":
+            # use the provided time
+            hh, mmss = divmod(int(tmtxt), 10000)
+            mm, ss = divmod(mmss, 100)
+        else:
+            # put it at the end of the session parameter
+            hh = self.p.sessionend.hour
+            mm = self.p.sessionend.minute
+            ss = self.p.sessionend.second
+
+        dtnum = date2num(datetime.datetime(y, m, d, hh, mm, ss))
+
+        self.lines.datetime[0] = dtnum
+        self.lines.open[0] = float(next(itokens))
+        self.lines.high[0] = float(next(itokens))
+        self.lines.low[0] = float(next(itokens))
+        self.lines.close[0] = float(next(itokens))
+        self.lines.volume[0] = float(next(itokens))
+        self.lines.openinterest[0] = float(next(itokens))
+
+        return True
+
+
+class VChartCSV(feed.CSVFeedBase):
+    """VisualChart CSV feed class.
+
+    Wrapper class for VChartCSVData feed functionality.
+    """
+
+    DataCls = VChartCSVData

backtrader/feeds/vchartfile.py

@@ -0,0 +1,153 @@
+#!/usr/bin/env python
+"""VChartFile Data Feed Module - VisualChart file interface.
+
+This module provides the VChartFile feed for reading VisualChart
+binary on-disk files using market codes.
+
+Classes:
+    VChartFile: VisualChart binary file feed by market code.
+
+Example:
+    >>> data = bt.feeds.VChartFile(dataname='015ES')
+    >>> cerebro.adddata(data)
+"""
+
+import os.path
+from datetime import datetime
+from struct import unpack
+
+from .. import stores
+from ..dataseries import TimeFrame
+from ..feed import DataBase
+from ..utils import date2num  # avoid dict lookups
+from ..utils.log_message import get_logger
+
+logger = get_logger(__name__)
+
+
+class VChartFile(DataBase):
+    """
+    Support for `Visual Chart <www.visualchart.com>`_ binary on-disk files for
+    both daily and intradaily formats.
+
+    Note:
+
+      - ``dataname``: Market code displayed by Visual Chart. Example: 015ES for
+        EuroStoxx 50 continuous future
+    """
+
+    def __init__(self, **kwargs):
+        """Initialize the VChartFile data feed.
+
+        Args:
+            **kwargs: Keyword arguments for data feed configuration.
+        """
+        super().__init__(**kwargs)
+        # Handle original metaclass registration functionality
+        if hasattr(stores, "VChartFile"):
+            stores.VChartFile.DataCls = self.__class__
+
+        self.f = None
+        self._barfmt = None
+        self._dtsize = None
+        self._barsize = None
+        self._store = None
+
+    def start(self):
+        """Start the VChartFile data feed.
+
+        Opens the VisualChart binary file for reading.
+        """
+        super().start()
+        if self._store is None:
+            self._store = stores.VChartFile()
+            self._store.start()
+
+        self._store.start(data=self)
+
+        # Choose extension and extraction/calculation parameters
+        if self.p.timeframe < TimeFrame.Minutes:
+            ext = ".tck"  # seconds will still need resampling
+            # FIXME: find reference to tick counter for format
+        elif self.p.timeframe < TimeFrame.Days:
+            ext = ".min"
+            self._dtsize = 2
+            self._barsize = 32
+            self._barfmt = "IIffffII"
+        else:
+            ext = ".fd"
+            self._barsize = 28
+            self._dtsize = 1
+            self._barfmt = "IffffII"
+
+        # Construct a full path
+        basepath = self._store.get_datapath()
+
+        # Example: 01 + 0 + 015ES + .fd -> 010015ES.fd
+        dataname = "01" + "0" + self.p.dataname + ext
+        # 015ES -> 0 + 015 -> 0015
+        mktcode = "0" + self.p.dataname[0:3]
+
+        # basepath/0015/010015ES.fd
+        path = os.path.join(basepath, mktcode, dataname)
+        try:
+            self.f = open(path, "rb")
+        except OSError:
+            self.f = None
+
+    def stop(self):
+        """Stop the VChartFile data feed.
+
+        Closes the open file handle.
+        """
+        if self.f is not None:
+            self.f.close()
+            self.f = None
+
+    def _load(self):
+        if self.f is None:
+            return False  # cannot load more
+
+        try:
+            bardata = self.f.read(self._barsize)
+        except OSError:
+            self.f = None  # cannot return, nullify file
+            return False  # cannot load more
+
+        if not bardata or len(bardata) < self._barsize:
+            self.f = None  # cannot return, nullify file
+            return False  # cannot load more
+
+        try:
+            bdata = unpack(self._barfmt, bardata)
+        except Exception as e:
+            logger.warning("vchart bar unpack failed, stopping feed: %s", e)
+            self.f = None
+            return False
+
+        # First Date
+        y, md = divmod(bdata[0], 500)  # Years stored as if they had 500 days
+        m, d = divmod(md, 32)  # Months stored as if they had 32 days
+        dt = datetime(y, m, d)
+
+        # Time
+        if self._dtsize > 1:  # Minute Bars
+            # Daily Time is stored in seconds
+            hhmm, ss = divmod(bdata[1], 60)
+            hh, mm = divmod(hhmm, 60)
+            dt = dt.replace(hour=hh, minute=mm, second=ss)
+        else:  # Daily Bars
+            dt = datetime.combine(dt, self.p.sessionend)
+
+        self.lines.datetime[0] = date2num(dt)  # Store time
+
+        # Get the rest of the fields
+        o, h, low, c, v, oi = bdata[self._dtsize :]
+        self.lines.open[0] = o
+        self.lines.high[0] = h
+        self.lines.low[0] = low
+        self.lines.close[0] = c
+        self.lines.volume[0] = v
+        self.lines.openinterest[0] = oi
+
+        return True  # a bar has been successfully loaded