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

backtrader/feeds/btcsv.py

@@ -0,0 +1,203 @@
+#!/usr/bin/env python
+"""Backtrader CSV Data Feed Module - Test CSV format.
+
+This module provides the BacktraderCSVData feed for parsing
+a custom CSV format used for testing.
+
+Classes:
+    BacktraderCSVData: Parses backtrader test CSV format.
+
+Example:
+    >>> data = bt.feeds.BacktraderCSVData(dataname='test.csv')
+    >>> cerebro.adddata(data)
+"""
+
+import math
+from datetime import date
+
+from .. import feed
+from ..utils.log_message import get_logger
+
+logger = get_logger(__name__)
+
+_HOURS_PER_DAY = 24.0
+_MINUTES_PER_DAY = 1440.0
+_SECONDS_PER_DAY = 86400.0
+_MICROSECONDS_PER_DAY = 86400000000.0
+_INF = float("inf")
+_NEG_INF = float("-inf")
+
+
+def _set_current_value(line, value):
+    """Set the current line slot, falling back when binding propagation is needed."""
+    if value in (_INF, _NEG_INF):
+        value = line._default_value
+
+    if line.bindings:
+        line[0] = value
+        return
+
+    idx = line._idx
+    if idx < 0:
+        line[0] = value
+        return
+
+    try:
+        line.array[idx] = value
+    except IndexError:
+        line[0] = value
+
+
+class BacktraderCSVData(feed.CSVDataBase):
+    """
+    Parses a self-defined CSV Data used for testing.
+
+    Specific parameters:
+
+      - ``dataname``: The filename to parse or a file-like object
+    """
+
+    def _loadline(self, linetokens):
+        """Parse a line from the CSV file.
+
+        Args:
+            linetokens: List of tokenized CSV values.
+
+        Returns:
+            True if line was successfully parsed.
+        """
+        try:
+            (
+                line_datetime,
+                line_open,
+                line_high,
+                line_low,
+                line_close,
+                line_volume,
+                line_openinterest,
+            ) = self._btcsv_line_refs
+        except AttributeError:
+            lines = self.lines
+            line_datetime = lines.datetime
+            line_open = lines.open
+            line_high = lines.high
+            line_low = lines.low
+            line_close = lines.close
+            line_volume = lines.volume
+            line_openinterest = lines.openinterest
+            self._btcsv_line_refs = (
+                line_datetime,
+                line_open,
+                line_high,
+                line_low,
+                line_close,
+                line_volume,
+                line_openinterest,
+            )
+
+        # Date processing
+        dttxt = linetokens[0]  # The Format is YYYY-MM-DD - skip char 4 and 7
+        year = int(dttxt[0:4])
+        month = int(dttxt[5:7])
+        day = int(dttxt[8:10])
+        dtnum = float(date(year, month, day).toordinal())
+        # If there are 8 columns, time exists, second column is time, process time, if not 8 columns, no time, time uses sessionend
+        if len(linetokens) == 8:
+            tmtxt = linetokens[1]  # Format if present HH:MM:SS, skip 3 and 6
+            dtnum = math.fsum(
+                (
+                    dtnum,
+                    int(tmtxt[0:2]) / _HOURS_PER_DAY,
+                    int(tmtxt[3:5]) / _MINUTES_PER_DAY,
+                    int(tmtxt[6:8]) / _SECONDS_PER_DAY,
+                    0.0,
+                )
+            )
+            offset = 2
+        else:
+            tm = self.p.sessionend  # end of the session parameter
+            dtnum = math.fsum(
+                (
+                    dtnum,
+                    tm.hour / _HOURS_PER_DAY,
+                    tm.minute / _MINUTES_PER_DAY,
+                    tm.second / _SECONDS_PER_DAY,
+                    tm.microsecond / _MICROSECONDS_PER_DAY,
+                )
+            )
+            offset = 1
+        open_value = float(linetokens[offset])
+        high_value = float(linetokens[offset + 1])
+        low_value = float(linetokens[offset + 2])
+        close_value = float(linetokens[offset + 3])
+        volume_value = float(linetokens[offset + 4])
+        openinterest_value = float(linetokens[offset + 5])
+
+        idx_datetime = line_datetime._idx
+        idx_open = line_open._idx
+        idx_high = line_high._idx
+        idx_low = line_low._idx
+        idx_close = line_close._idx
+        idx_volume = line_volume._idx
+        idx_openinterest = line_openinterest._idx
+        if (
+            idx_datetime >= 0
+            and idx_open >= 0
+            and idx_high >= 0
+            and idx_low >= 0
+            and idx_close >= 0
+            and idx_volume >= 0
+            and idx_openinterest >= 0
+            and not line_datetime.bindings
+            and not line_open.bindings
+            and not line_high.bindings
+            and not line_low.bindings
+            and not line_close.bindings
+            and not line_volume.bindings
+            and not line_openinterest.bindings
+        ):
+            if open_value in (_INF, _NEG_INF):
+                open_value = line_open._default_value
+            if high_value in (_INF, _NEG_INF):
+                high_value = line_high._default_value
+            if low_value in (_INF, _NEG_INF):
+                low_value = line_low._default_value
+            if close_value in (_INF, _NEG_INF):
+                close_value = line_close._default_value
+            if volume_value in (_INF, _NEG_INF):
+                volume_value = line_volume._default_value
+            if openinterest_value in (_INF, _NEG_INF):
+                openinterest_value = line_openinterest._default_value
+
+            try:
+                line_datetime.array[idx_datetime] = dtnum
+                line_open.array[idx_open] = open_value
+                line_high.array[idx_high] = high_value
+                line_low.array[idx_low] = low_value
+                line_close.array[idx_close] = close_value
+                line_volume.array[idx_volume] = volume_value
+                line_openinterest.array[idx_openinterest] = openinterest_value
+                return True
+            except IndexError:
+                logger.debug("btcsv:181 ignored IndexError")
+
+        # Fallback preserves binding propagation and LineBuffer boundary handling.
+        set_current = _set_current_value
+        set_current(line_datetime, dtnum)
+        set_current(line_open, open_value)
+        set_current(line_high, high_value)
+        set_current(line_low, low_value)
+        set_current(line_close, close_value)
+        set_current(line_volume, volume_value)
+        set_current(line_openinterest, openinterest_value)
+
+        return True
+
+
+class BacktraderCSV(feed.CSVFeedBase):
+    """Backtrader CSV feed class.
+
+    Wrapper class for BacktraderCSVData feed functionality.
+    """
+
+    DataCls = BacktraderCSVData

backtrader/feeds/chainer.py

@@ -0,0 +1,114 @@
+#!/usr/bin/env python
+"""Chainer Data Feed Module - Chain multiple data feeds.
+
+This module provides the Chainer feed for chaining multiple data
+feeds together seamlessly during backtesting.
+
+Classes:
+    Chainer: Chains multiple data feeds together.
+
+Example:
+    >>> data1 = bt.feeds.BacktraderCSVData(dataname='part1.csv')
+    >>> data2 = bt.feeds.BacktraderCSVData(dataname='part2.csv')
+    >>> data = bt.feeds.Chainer(data1, data2)
+    >>> cerebro.adddata(data)
+"""
+
+from datetime import datetime
+
+from backtrader.utils.py3 import range
+
+from ..feed import DataBase
+from ..utils import date
+
+
+class Chainer(DataBase):
+    """Class that chains datas"""
+
+    # When data is live data, will avoid preloading and runonce behavior
+    def islive(self):
+        """Returns ``True`` to notify ``Cerebro`` that preloading and runonce
+        should be deactivated"""
+        return True
+
+    def __init__(self, *args, **kwargs):
+        """Initialize the Chainer data feed.
+
+        Args:
+            *args: Data feeds to chain together.
+            **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)
+
+        self._lastdt = None
+        self._d = None
+        self._ds = None
+        self._args = args
+
+    def start(self):
+        """Start the Chainer data feed.
+
+        Initializes all chained data feeds.
+        """
+        super().start()
+        for d in self._args:
+            d.setenvironment(self._env)
+            d._start()
+
+        # put the references in a separate list to have pops
+        self._ds = list(self._args)
+        self._d = self._ds.pop(0) if self._ds else None
+        self._lastdt = datetime.min
+
+    def stop(self):
+        """Stop the Chainer data feed.
+
+        Stops all underlying data feeds.
+        """
+        super().stop()
+        for d in self._args:
+            d.stop()
+
+    def get_notifications(self):
+        """Get notifications from the current data feed.
+
+        Returns:
+            list: Notifications from active data feed or empty list.
+        """
+        return [] if self._d is None else self._d.get_notifications()
+
+    # Get timezone
+    def _gettz(self):
+        """To be overriden by subclasses which may auto-calculate the
+        timezone"""
+        if self._args:
+            return self._args[0]._gettz()
+        return date.Localizer(self.p.tz)
+
+    # Load data, this processing looks quite clever, planning to handle futures contract rollover or remove data when it expires later
+    def _load(self):
+        while self._d is not None:
+            if not self._d.next():  # no values from current data source
+                self._d = self._ds.pop(0) if self._ds else None
+                continue
+
+            # Cannot deliver a date equal or less than an already delivered
+            dt = self._d.datetime.datetime()
+            if dt <= self._lastdt:
+                continue
+
+            self._lastdt = dt
+
+            for i in range(self._d.size()):
+                self.lines[i][0] = self._d.lines[i][0]
+
+            return True
+
+        # Out of the loop -> self._d is None, no data feed to return from
+        return False

backtrader/feeds/cryptohftdata.py

@@ -0,0 +1,164 @@
+#!/usr/bin/env python
+"""Historical cryptocurrency data feed backed by CryptoHFTData."""
+
+import os
+from datetime import datetime, timezone
+from typing import Any, Dict, Iterator
+
+import pandas as pd
+
+from ..dataseries import TimeFrame
+from ..feed import DataBase
+from ..utils import date2num
+from ..utils.log_message import get_logger
+
+logger = get_logger(__name__)
+
+__all__ = ["CryptoHFTData"]
+
+
+_TIMEFRAME_RULES = {
+    TimeFrame.Seconds: "s",
+    TimeFrame.Minutes: "min",
+    TimeFrame.Days: "D",
+}
+
+
+class CryptoHFTData(DataBase):
+    """Load historical exchange trades from CryptoHFTData.
+
+    Tick requests emit one OHLCV-shaped backtrader bar per trade. Second,
+    minute, and daily requests aggregate the same trades into UTC-aligned
+    bars. Use ``TimeFrame.Minutes`` with ``compression=60`` for hourly bars.
+
+    ``fromdate`` and ``todate`` are required to avoid accidental unbounded
+    high-frequency downloads. Naive datetimes are interpreted as UTC.
+    """
+
+    params = (
+        ("exchange", None),
+        ("api_key", None),
+        ("client", None),
+        ("timeframe", TimeFrame.Minutes),
+        ("compression", 1),
+    )
+
+    def __init__(self):
+        """Initialize an empty historical row iterator."""
+        super().__init__()
+        self._rows: Iterator[Dict[str, Any]] = iter(())
+
+    def start(self):
+        """Download the requested trades and prepare chronological bars."""
+        super().start()
+        if not self.p.dataname:
+            raise ValueError("CryptoHFTData requires dataname to be a symbol such as BTCUSDT")
+        if not self.p.exchange:
+            raise ValueError("CryptoHFTData requires an exchange such as binance_futures")
+        if self.p.fromdate is None or self.p.todate is None:
+            raise ValueError("CryptoHFTData requires both fromdate and todate")
+        if self.p.compression < 1:
+            raise ValueError("CryptoHFTData compression must be at least 1")
+
+        start = _as_utc(self.p.fromdate)
+        end = _as_utc(self.p.todate)
+        if end < start:
+            raise ValueError("CryptoHFTData todate must not precede fromdate")
+
+        client = self.p.client or self._create_client()
+        trades = client.get_trades(
+            symbol=str(self.p.dataname).upper(),
+            exchange=self.p.exchange,
+            start_date=start.date().isoformat(),
+            end_date=end.date().isoformat(),
+        )
+        self._rows = iter(self._prepare_rows(trades, start, end))
+
+    def _create_client(self):
+        """Create the optional CryptoHFTData SDK client lazily."""
+        try:
+            from cryptohftdata import CryptoHFTDataClient
+        except ImportError as exc:
+            logger.error("cryptohftdata:81 re-raising ImportError", exc_info=True)
+            raise ImportError(
+                "CryptoHFTData feed requires the optional dependency; "
+                "install backtrader[cryptohftdata]"
+            ) from exc
+
+        api_key = self.p.api_key or os.getenv("CRYPTOHFTDATA_API_KEY") or None
+        return CryptoHFTDataClient(api_key=api_key)
+
+    def _prepare_rows(self, trades, start: datetime, end: datetime):
+        """Normalize SDK trades and optionally aggregate them into bars."""
+        required = {"trade_time", "trade_id", "price", "quantity"}
+        missing = required.difference(trades.columns)
+        if missing:
+            raise ValueError(
+                "CryptoHFTData response is missing required columns: " + ", ".join(sorted(missing))
+            )
+        if trades.empty:
+            return []
+
+        frame = trades.copy()
+        frame["datetime"] = pd.to_datetime(frame["trade_time"], unit="ms", utc=True)
+        frame["price"] = pd.to_numeric(frame["price"], errors="coerce")
+        frame["quantity"] = pd.to_numeric(frame["quantity"], errors="coerce")
+        frame = frame.dropna(subset=["datetime", "price", "quantity"])
+        frame = frame.loc[
+            (frame["datetime"] >= pd.Timestamp(start)) & (frame["datetime"] <= pd.Timestamp(end))
+        ]
+        frame = frame.sort_values(["trade_time", "trade_id"], kind="stable")
+
+        if self.p.timeframe == TimeFrame.Ticks:
+            frame = frame.assign(
+                open=frame["price"],
+                high=frame["price"],
+                low=frame["price"],
+                close=frame["price"],
+                volume=frame["quantity"],
+            )
+            return frame[["datetime", "open", "high", "low", "close", "volume"]].to_dict("records")
+
+        suffix = _TIMEFRAME_RULES.get(self.p.timeframe)
+        if suffix is None:
+            name = TimeFrame.getname(self.p.timeframe, self.p.compression)
+            raise ValueError(f"CryptoHFTData does not support the {name} timeframe")
+        rule = f"{self.p.compression}{suffix}"
+        bars = (
+            frame.set_index("datetime")
+            .resample(rule, label="left", closed="left")
+            .agg(
+                open=("price", "first"),
+                high=("price", "max"),
+                low=("price", "min"),
+                close=("price", "last"),
+                volume=("quantity", "sum"),
+            )
+            .dropna(subset=["open"])
+            .reset_index()
+        )
+        return bars.to_dict("records")
+
+    def _load(self):
+        """Emit the next normalized trade or bar."""
+        try:
+            row = next(self._rows)
+        except StopIteration:
+            return False
+
+        timestamp = row["datetime"].to_pydatetime().astimezone(timezone.utc).replace(tzinfo=None)
+        self.lines.datetime[0] = date2num(timestamp)
+        self.lines.open[0] = float(row["open"])
+        self.lines.high[0] = float(row["high"])
+        self.lines.low[0] = float(row["low"])
+        self.lines.close[0] = float(row["close"])
+        self.lines.volume[0] = float(row["volume"])
+        self.lines.openinterest[0] = 0.0
+        return True
+
+
+def _as_utc(value: datetime) -> datetime:
+    """Return an aware UTC datetime, interpreting naive values as UTC."""
+    if value.tzinfo is None:
+        return value.replace(tzinfo=timezone.utc)
+    return value.astimezone(timezone.utc)