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

backtrader/feeds/yahoo.py

@@ -0,0 +1,399 @@
+#!/usr/bin/env python
+"""Yahoo Finance Data Feed Module - Yahoo CSV data parsing.
+
+This module provides the YahooFinanceCSVData feed for parsing
+pre-downloaded Yahoo Finance CSV files.
+
+Classes:
+    YahooFinanceCSVData: Parses Yahoo Finance format CSV files.
+
+Example:
+    >>> data = bt.feeds.YahooFinanceCSVData(dataname='yahoo.csv')
+    >>> cerebro.adddata(data)
+"""
+
+import collections
+import io
+import itertools
+from datetime import date, datetime
+
+from .. import feed
+from ..dataseries import TimeFrame
+from ..utils import date2num
+from ..utils.log_message import get_logger
+
+logger = get_logger(__name__)
+
+
+class YahooFinanceCSVData(feed.CSVDataBase):
+    """
+    Parses pre-downloaded Yahoo CSV Data Feeds (or locally generated if they
+    comply to the Yahoo format)
+
+    Specific parameters:
+
+      - ``dataname``
+
+        The filename to parse or a file-like object
+
+      - ``reverse``
+
+        It is assumed that locally stored files have the newest lines at the
+        bottom
+
+        If this is not the case, pass *reverse* = ``True``
+
+      - ``adjclose`` (default: ``True``)
+        Whether to use the dividend/split adjusted close and adjust all
+        values according to it.
+
+      - ``adjvolume`` (default: ``True``)
+        Do also adjust ``volume`` if ``adjclose`` is also ``True``
+
+      - ``round`` (default: ``True``)
+        Whether to round the values to a specific number of decimals after
+        having adjusted the close
+
+      - ``roundvolume`` (default: ``0``)
+        Round the resulting volume to the given number of decimals after having
+        adjusted it
+
+      - ``decimals`` (default: ``2``)
+        Number of decimals to round to
+
+      - ``swapcloses`` (default: ``False``)
+        [2018-11-16] It would seem that the order of *close* and *adjusted
+        close* is now fixed. The parameter is retained, in case the need to
+        swap the columns again arose.
+
+    """
+
+    # Add a line
+    lines = ("adjclose",)
+
+    params = (
+        ("reverse", False),
+        ("adjclose", True),
+        ("adjvolume", True),
+        ("round", True),
+        ("decimals", 2),
+        ("roundvolume", False),
+        ("swapcloses", False),
+    )
+
+    def start(self):
+        """Start the Yahoo Finance CSV data feed.
+
+        Reverses data order if needed for correct chronological sequence.
+        """
+        super().start()
+        # If reverse is False, return directly, don't run code below
+        if not self.params.reverse:
+            return
+
+        # Yahoo sends data in reverse order and the file is still unreversed
+        # Use deque double-ended queue, appending to left is much more efficient than list.
+        # If file dates are reversed, data is reversed during transfer, so dates in new file are in correct order
+        dq: collections.deque = collections.deque()
+        for line in self.f:
+            dq.appendleft(line)
+        # Create a string buffer object, write queue data to file, move pointer to 0th character, close file, assign file to self.f
+        f = io.StringIO(newline=None)
+        f.writelines(dq)
+        f.seek(0)
+        self.f.close()
+        self.f = f
+
+    def _loadline(self, linetokens):
+        # _loadline code is relatively familiar, all quite similar
+        # A while loop
+        while True:
+            nullseen = False
+            for tok in linetokens[1:]:
+                if tok == "null":
+                    nullseen = True
+                    linetokens = self._getnextline()  # refetch tokens
+                    if not linetokens:
+                        return False  # cannot fetch, go away
+
+                    # out of for to carry on wiwth while True logic
+                    break
+
+            if not nullseen:
+                break  # can proceed
+        # Counter, value increases by 1 when calling next(i)
+        i = itertools.count(0)
+        # Get time string
+        dttxt = linetokens[next(i)]
+        # Generate time
+        dt = date(int(dttxt[0:4]), int(dttxt[5:7]), int(dttxt[8:10]))
+        # Convert time to number
+        dtnum = date2num(datetime.combine(dt, self.p.sessionend))
+        # Assign value to datetime line
+        self.lines.datetime[0] = dtnum
+        # Get open, high, low, close, open interest
+        o = float(linetokens[next(i)])
+        h = float(linetokens[next(i)])
+        low = float(linetokens[next(i)])
+        c = float(linetokens[next(i)])
+        self.lines.openinterest[0] = 0.0
+
+        # 2018-11-16 ... Adjusted Close seems to always be delivered after
+        # the close and before the volume columns
+        # Get adjusted price
+        adjustedclose = float(linetokens[next(i)])
+        # Try to get volume, if not available, set to 0
+        try:
+            v = float(linetokens[next(i)])
+        except (ValueError, TypeError, IndexError, StopIteration) as e:
+            # cover the case in which volume is "null" / missing
+            logger.warning("volume parse failed, defaulting to 0.0: %s", e)
+            v = 0.0
+        # If swapping close price and adjusted close price, perform swap
+        if self.p.swapcloses:  # swap closing prices if requested
+            c, adjustedclose = adjustedclose, c
+        # Calculate adjustment factor, the calculation method seems different from conventional usage, but not necessarily wrong
+        adjfactor = c / adjustedclose if adjustedclose != 0.0 else 1.0
+
+        # in v7 "adjusted prices" seem to be given, scale back for non adj
+        # If price adjustment is needed, divide by adjustment factor
+        if self.params.adjclose:
+            o /= adjfactor
+            h /= adjfactor
+            low /= adjfactor
+            c = adjustedclose
+            # If the price goes down, volume must go up and viceversa
+            # If adjusting volume
+            if self.p.adjvolume:
+                v *= adjfactor
+        # If rounding is needed, round the prices
+        if self.p.round:
+            decimals = self.p.decimals
+            o = round(o, decimals)
+            h = round(h, decimals)
+            low = round(low, decimals)
+            c = round(c, decimals)
+        # Round the volume
+        v = round(v, self.p.roundvolume)
+        # Assign calculated data to corresponding lines
+        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.adjclose[0] = adjustedclose
+
+        return True
+
+
+class YahooLegacyCSV(YahooFinanceCSVData):
+    """
+    This is intended to load files which were downloaded before Yahoo
+    discontinued the original service in May-2017
+    Used to load data downloaded before May 2017
+    """
+
+    params = (("version", ""),)
+
+
+class YahooFinanceCSV(feed.CSVFeedBase):
+    """Yahoo Finance CSV feed class.
+
+    Wrapper class for YahooFinanceCSVData feed functionality.
+    """
+
+    DataCls = YahooFinanceCSVData
+
+
+class YahooFinanceData(YahooFinanceCSVData):
+    # This is a method to directly crawl data from Yahoo
+    """
+    Executes a direct download of data from Yahoo servers for the given time
+    range.
+
+    Specific parameters (or specific meaning):
+
+      - ``dataname``
+
+        The ticker to download ('YHOO' for Yahoo own stock quotes)
+
+      - ``proxies``
+
+        A dict indicating which proxy to go through for the download as in
+        {'http': 'http://myproxy.com'} or {'http': 'http://127.0.0.1:8080'}
+
+      - ``period``
+
+        The timeframe to download data in. Pass 'w' for weekly and 'm' for
+        monthly.
+
+      - ``reverse``
+
+        [2018-11-16] The latest incarnation of Yahoo online downloads returns
+        the data in the proper order. The default value of ``reverse`` for the
+        online download is therefore set to ``False``
+
+      - ``adjclose``
+
+        Whether to use the dividend/split adjusted close and adjust all values
+        according to it.
+
+      - ``urlhist``
+
+        The url of the historical quotes in Yahoo Finance used to gather a
+        ``crumb`` authorization cookie for the download
+
+      - ``urldown``
+
+        The url of the actual download server
+
+      - ``retries``
+
+        Number of times (each) to try to get a ``crumb`` cookie and download
+        the data
+
+    """
+
+    params: tuple = (
+        ("proxies", {}),
+        ("period", "d"),
+        ("reverse", False),
+        ("urlhist", "https://finance.yahoo.com/quote/{}/history"),
+        ("urldown", "https://query1.finance.yahoo.com/v7/finance/download"),
+        ("retries", 3),
+    )
+
+    def __init__(self):
+        """Initialize the Yahoo Finance data feed.
+
+        Sets up error tracking for data downloads.
+        """
+        self.error = None
+
+    def start_v7(self):
+        """Start Yahoo Finance data download using v7 API.
+
+        Fetches crumb cookie and downloads historical data.
+        """
+        try:
+            import requests
+        except ImportError:
+            msg = (
+                "The new Yahoo data feed requires to have the requests "
+                "module installed. Please use pip install requests or "
+                "the method of your choice"
+            )
+            raise ImportError(msg) from None
+
+        self.error = None
+        url = self.p.urlhist.format(self.p.dataname)
+
+        sesskwargs = {}
+        if self.p.proxies:
+            sesskwargs["proxies"] = self.p.proxies
+
+        crumb = None
+        sess = requests.Session()
+        for i in range(self.p.retries + 1):  # at least once
+            resp = sess.get(url, **sesskwargs)
+            if resp.status_code != requests.codes.ok:
+                continue
+
+            txt = resp.text
+            i = txt.find("CrumbStore")
+            if i == -1:
+                continue
+            i = txt.find("crumb", i)
+            if i == -1:
+                continue
+            istart = txt.find('"', i + len("crumb") + 1)
+            if istart == -1:
+                continue
+            istart += 1
+            iend = txt.find('"', istart)
+            if iend == -1:
+                continue
+
+            crumb = txt[istart:iend]
+            crumb = crumb.encode("ascii").decode("unicode-escape")
+            break
+
+        if crumb is None:
+            self.error = "Crumb not found"
+            self.f = None
+            return
+
+        from ..utils.py3 import urlquote
+
+        crumb = urlquote(crumb)
+
+        # urldown/ticker?period1=posix1&period2=posix2&interval=1d&events=history&crumb=crumb
+
+        # Try to download
+        urld = f"{self.p.urldown}/{self.p.dataname}"
+
+        urlargs = []
+        posix = date(1970, 1, 1)
+        if self.p.todate is not None:
+            period2 = (self.p.todate.date() - posix).total_seconds()
+            urlargs.append(f"period2={int(period2)}")
+
+        if self.p.todate is not None:
+            period1 = (self.p.fromdate.date() - posix).total_seconds()
+            urlargs.append(f"period1={int(period1)}")
+
+        intervals = {
+            TimeFrame.Days: "1d",
+            TimeFrame.Weeks: "1wk",
+            TimeFrame.Months: "1mo",
+        }
+
+        urlargs.append(f"interval={intervals[self.p.timeframe]}")
+        urlargs.append("events=history")
+        urlargs.append(f"crumb={crumb}")
+
+        urld = "{}?{}".format(urld, "&".join(urlargs))
+        f = None
+        for i in range(self.p.retries + 1):  # at least once
+            resp = sess.get(urld, **sesskwargs)
+            if resp.status_code != requests.codes.ok:
+                continue
+
+            ctype = resp.headers["Content-Type"]
+            # Cover as many text types as possible for Yahoo changes
+            if not ctype.startswith("text/"):
+                self.error = "Wrong content type: %s" % ctype
+                continue  # HTML returned? wrong url?
+
+            # buffer everything from the socket into a local buffer
+            try:
+                # r.encoding = 'UTF-8'
+                f = io.StringIO(resp.text, newline=None)
+            except Exception as e:
+                logger.warning("Yahoo response read failed, retrying: %s", e)
+                continue  # try again if possible
+
+            break
+
+        self.f = f
+
+    def start(self):
+        """Start the Yahoo Finance data feed.
+
+        Initiates download and prepares CSV parser.
+        """
+        self.start_v7()
+
+        # Prepared a "path" file -  CSV Parser can take over
+        super().start()
+
+
+class YahooFinance(feed.CSVFeedBase):
+    """Yahoo Finance feed class.
+
+    Wrapper class for YahooFinanceData feed functionality.
+    """
+
+    DataCls = YahooFinanceData
+    # Get specific parameters and form tuple
+    params = DataCls.params._gettuple()

backtrader/fillers.py

@@ -0,0 +1,148 @@
+#!/usr/bin/env python
+"""Fillers Module - Order execution size calculation.
+
+This module provides filler classes that determine how much of an order
+can be executed based on available volume, price constraints, and
+user-defined parameters.
+
+Classes:
+    FixedSize: Execute with fixed maximum size.
+    FixedBarPerc: Execute using percentage of bar volume.
+    BarPointPerc: Execute distributing volume across price range.
+
+Example:
+    >>> cerebro.broker.set_filler(backtrader.fillers.FixedBarPerc(perc=50.0))
+"""
+
+from .parameters import ParameterizedBase
+from .utils.py3 import MAXINT
+
+
+# Fixed size filtering, when order executes can only trade current volume, need minimum of order quantity and size, if size is None, ignore size
+class FixedSize(ParameterizedBase):
+    """Returns the execution size for a given order using a *percentage* of the
+    volume in a bar.
+
+    This percentage is set with the parameter ``perc``
+
+    Params:
+
+      - ``size`` (default: ``None``) maximum size to be executed.
+      The actual
+        volume of the bar at execution time is also a limit if smaller than the
+        size
+
+        If the value of this parameter evaluates to False, the entire volume
+        of the bar will be used to match the order
+    """
+
+    params = (("size", None),)
+
+    def __call__(self, order, price, ago):
+        """Calculate the execution size for an order.
+
+        Args:
+            order: The order being executed.
+            price: Execution price.
+            ago: Number of bars back (0 for current, -1 for previous).
+
+        Returns:
+            float: The maximum size that can be executed, limited by
+                bar volume, remaining order size, and configured size.
+        """
+        size = self.p.size or MAXINT
+        return min((order.data.volume[ago], abs(order.executed.remsize), size))
+
+
+# Fixed percentage, use a certain percentage of current volume and compare with order quantity, choose minimum for trading
+class FixedBarPerc(ParameterizedBase):
+    """Returns the execution size for a given order using a *percentage* of the
+    volume in a bar.
+
+    This percentage is set with the parameter ``perc``
+
+    Params:
+
+      - ``perc`` (default: ``100.0``) (valied values: ``0.0-100.0``)
+
+        Percentage of the volume bar to use to execute an order
+    """
+
+    params = (("perc", 100.0),)
+
+    def __call__(self, order, price, ago):
+        """Calculate the execution size using percentage of bar volume.
+
+        Args:
+            order: The order being executed.
+            price: Execution price.
+            ago: Number of bars back (0 for current, -1 for previous).
+
+        Returns:
+            float: The maximum size that can be executed based on
+                percentage of bar volume and remaining order size.
+        """
+        # Get the volume and scale it to the requested perc
+        maxsize = (order.data.volume[ago] * self.p.perc) // 100
+        # Return the maximum possible executed volume
+        return min(maxsize, abs(order.executed.remsize))
+
+
+# Distribute according to bar's fluctuation range by percentage
+class BarPointPerc(ParameterizedBase):
+    """Returns the execution size for a given order. The volume will be
+    distributed uniformly in the range *high*-*low* using ``minmov`` to
+    partition.
+
+    From the allocated volume for the given price, the `perc` percentage will
+    be used
+
+    Params:
+
+      - ``minmov`` (default: ``0.01``)
+
+        Minimum price movement. Used to partition the range *high*-*low* to
+        proportionally distribute the volume amongst possible prices
+
+      - ``perc`` (default: ``100.0``) (valied values: ``0.0-100.0``)
+
+        Percentage of the volume allocated to the order execution price to use
+        for matching
+        # minmov defaults to 0.01, based on distance between high and low prices, see how many parts can be divided
+        # perc defaults to 100, trading limit is order can only be placed for each part's perc
+    """
+
+    # Specific parameters
+    params = (
+        ("minmov", None),
+        ("perc", 100.0),
+    )
+
+    def __call__(self, order, price, ago):
+        """Calculate the execution size distributing volume across price range.
+
+        Args:
+            order: The order being executed.
+            price: Execution price.
+            ago: Number of bars back (0 for current, -1 for previous).
+
+        Returns:
+            float: The maximum size that can be executed based on
+                proportional distribution across the price range.
+        """
+        # Data
+        data = order.data
+        # Minimum price movement
+        minmov = self.p.minmov
+        # Calculate how many parts can be divided
+        parts = 1
+        if minmov:
+            # high - low + minmov to account for open-ended minus op
+            parts = (data.high[ago] - data.low[ago] + minmov) // minmov
+            if parts < 1:
+                parts = 1
+        # Calculate how much each part can trade
+        alloc_vol = ((data.volume[ago] / parts) * self.p.perc) // 100.0
+        # return max possible executable volume
+        # Return maximum possible executable order quantity
+        return min(alloc_vol, abs(order.executed.remsize))

backtrader/filters/__init__.py

@@ -0,0 +1,34 @@
+#!/usr/bin/env python
+"""Data Filters Module - Data transformation and filtering.
+
+This module provides filter classes for transforming and filtering
+data feeds. Filters can be used to resample data, fill missing values,
+calculate derived data types like Heikin Ashi candles, and more.
+
+Available Filters:
+    - CalendarDays: Filter for calendar day operations.
+    - DataFilter: Base class for data filtering.
+    - DataFiller: Fill missing data values.
+    - DaySteps: Filter for day step operations.
+    - HeikinAshi: Calculate Heikin Ashi candles.
+    - Renko: Calculate Renko bricks.
+    - Session: Filter for session operations.
+    - BSplitter: Split data into multiple parts.
+
+Example:
+    Using a filter with data:
+    >>> data = bt.feeds.GenericCSVData(dataname='data.csv')
+    >>> cerebro.adddata(data)
+    >>> cerebro.adddata(bt.feeds.GenericCSVData(dataname='data2.csv'),
+    ...                  filter=bt.filters.HeikinAshi())
+"""
+
+from ..flt import Filter as Filter
+from .bsplitter import *
+from .calendardays import *
+from .datafiller import *
+from .datafilter import *
+from .daysteps import *
+from .heikinashi import *
+from .renko import *
+from .session import *

backtrader/filters/bsplitter.py

@@ -0,0 +1,127 @@
+#!/usr/bin/env python
+"""Bar Splitter Filter Module - Daily bar splitting.
+
+This module provides the DaySplitterClose filter for splitting daily
+bars into two parts for intraday replay simulation.
+
+Classes:
+    DaySplitterClose: Splits daily bars into OHLX and CCCC ticks.
+
+Example:
+    >>> data = bt.feeds.GenericCSVData(dataname='daily.csv')
+    >>> data.addfilter(bt.filters.DaySplitterClose())
+    >>> cerebro.adddata(data)
+"""
+
+import datetime
+
+from backtrader.parameters import ParameterizedBase
+
+__all__ = ["DaySplitterClose", "DaySplitter_Close"]
+
+
+class DaySplitterClose(ParameterizedBase):
+    """
+    Splits a daily bar in two parts simulating 2 ticks which will be used to
+    replay the data:
+
+      - First tick: ``OHLX``
+
+        The ``Close`` will be replaced by the *average* of ``Open``, ``High``
+        and ``Low``
+
+        The session opening time is used for this tick
+
+      And
+
+      - Second tick: ``CCCC``
+
+        The `Close` price will be used for the four components of the price
+
+        The session closing time is used for this tick
+
+    The volume will be split amongst the 2 ticks using the parameters:
+
+      - ``closevol`` (default: ``0.5``) The value indicates which percentage, in
+        absolute terms from 0.0 to 1.0, has to be assigned to the *closing*
+        tick. The rest will be assigned to the ``OHLX`` tick.
+
+    **This filter is meant to be used together with** ``cerebro.replaydata``
+
+    """
+
+    params = (("closevol", 0.5),)  # 0 -> 1 amount of volume to keep for close
+
+    # replaying = True
+
+    def __init__(self, data, **kwargs):
+        """Initialize the DaySplitterClose filter.
+
+        Args:
+            data: The data feed to apply the filter to.
+            **kwargs: Additional keyword arguments passed to parent class.
+        """
+        super().__init__(**kwargs)
+        self.lastdt = None
+
+    def __call__(self, data):
+        """Process the data feed to split daily bars.
+
+        This method is called for each bar in the data feed. It splits the daily
+        bar into two parts - an OHLX tick and a CCCC tick - to simulate intraday
+        trading behavior.
+
+        Args:
+            data: The data feed containing the bar to process.
+
+        Returns:
+            bool: False if the initial tick can be further processed from stack.
+        """
+        # Make a copy of the new bar and remove it from stream
+        datadt = data.datetime.date()  # keep the date
+
+        if self.lastdt == datadt:
+            return False  # skip bars that come again in the filter
+
+        self.lastdt = datadt  # keep ref to last seen bar
+
+        # Make a copy of current data for ohlbar
+        ohlbar = [data.lines[i][0] for i in range(data.size())]
+        closebar = ohlbar[:]  # Make a copy for the close
+
+        # replace close price with o-h-l average
+        ohlprice = ohlbar[data.Open] + ohlbar[data.High] + ohlbar[data.Low]
+        ohlbar[data.Close] = ohlprice / 3.0
+
+        vol = ohlbar[data.Volume]  # adjust volume
+        ohlbar[data.Volume] = vohl = int(vol * (1.0 - self.p.closevol))
+
+        oi = ohlbar[data.OpenInterest]  # adjust open interst
+        ohlbar[data.OpenInterest] = 0
+
+        # Adjust times
+        dt = datetime.datetime.combine(datadt, data.p.sessionstart)
+        ohlbar[data.DateTime] = data.date2num(dt)
+
+        # Ajust closebar to generate a single tick -> close price
+        closebar[data.Open] = cprice = closebar[data.Close]
+        closebar[data.High] = cprice
+        closebar[data.Low] = cprice
+        closebar[data.Volume] = vol - vohl
+        ohlbar[data.OpenInterest] = oi
+
+        # Adjust times
+        dt = datetime.datetime.combine(datadt, data.p.sessionend)
+        closebar[data.DateTime] = data.date2num(dt)
+
+        # Update stream
+        data.backwards(force=True)  # remove the copied bar from stream
+        data._add2stack(ohlbar)  # add ohlbar to stack
+        # Add 2nd part to stash to delay processing to next round
+        data._add2stack(closebar, stash=True)
+
+        return False  # initial tick can be further processed from stack
+
+
+# Alias for backward compatibility
+DaySplitter_Close = DaySplitterClose