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

backtrader/feeds/influxfeed.py

@@ -0,0 +1,158 @@
+#!/usr/bin/env python
+"""InfluxDB Data Feed Module - InfluxDB time series data.
+
+This module provides the InfluxDB data feed for reading market data
+from InfluxDB time series database.
+
+Classes:
+    InfluxDB: InfluxDB data feed.
+
+Example:
+    >>> data = bt.feeds.InfluxDB(
+    ...     host='localhost',
+    ...     port=8086,
+    ...     database='market_data'
+    ... )
+    >>> cerebro.adddata(data)
+"""
+
+import datetime as dt
+from typing import Any, Iterator, Optional
+
+from ..dataseries import TimeFrame
+from ..feed import DataBase
+from ..utils import date2num
+from ..utils.log_message import get_logger
+
+logger = get_logger(__name__)
+
+try:
+    from influxdb import InfluxDBClient as idbclient
+    from influxdb.exceptions import InfluxDBClientError
+except Exception:  # pragma: no cover - optional dependency, handled at runtime
+    logger.warning("influxfeed:32 fallback on Exception")
+    idbclient = None
+
+    class InfluxDBClientError(Exception):  # type: ignore[no-redef]
+        """Exception raised for InfluxDB client errors."""
+
+
+# Time period mapping
+TIMEFRAMES = {
+    TimeFrame.Seconds: "s",
+    TimeFrame.Minutes: "m",
+    TimeFrame.Days: "d",
+    TimeFrame.Weeks: "w",
+    TimeFrame.Months: "m",
+    TimeFrame.Years: "y",
+}
+
+
+# backtrader fetches data from InfluxDB
+class InfluxDB(DataBase):
+    """InfluxDB data feed for time series market data.
+
+    Fetches OHLCV data from an InfluxDB time series database.
+    """
+
+    # Import packages
+    frompackages = (
+        ("influxdb", [("InfluxDBClient", "idbclient")]),
+        ("influxdb.exceptions", "InfluxDBClientError"),
+    )
+    # Parameters
+    params = (
+        ("host", "127.0.0.1"),
+        ("port", "8086"),
+        ("username", None),
+        ("password", None),
+        ("database", None),
+        ("timeframe", TimeFrame.Days),
+        ("startdate", None),
+        ("high", "high_p"),
+        ("low", "low_p"),
+        ("open", "open_p"),
+        ("close", "close_p"),
+        ("volume", "volume"),
+        ("ointerest", "oi"),
+    )
+
+    def __init__(self):
+        """Initialize the InfluxDB data feed."""
+        self.biter: Optional[Iterator[Any]] = None
+        self.ndb = None
+
+    def start(self):
+        """Start the InfluxDB data feed.
+
+        Connects to InfluxDB and executes query to fetch data.
+        """
+        super().start()
+        # Try to connect to database
+        try:
+            self.ndb = idbclient(
+                self.p.host, self.p.port, self.p.username, self.p.password, self.p.database
+            )
+        except InfluxDBClientError as err:
+            logger.error("Failed to establish connection to InfluxDB: %s", err)
+        # Specific time period
+        tf = "{multiple}{timeframe}".format(
+            multiple=(self.p.compression if self.p.compression else 1),
+            timeframe=TIMEFRAMES.get(self.p.timeframe, "d"),
+        )
+        # Start time
+        if not self.p.startdate:
+            st = "<= now()"
+        else:
+            st = ">= '%s'" % self.p.startdate
+
+        # The query could already consider parameters like fromdate and todate
+        # to have the database skip them and not the internal code
+        # Specific commands needed for database data retrieval
+        # Note: identifiers (field/measurement names) come from this feed's own
+        # configuration params, not external input; InfluxQL has no parameter
+        # binding for identifiers, so .format() is the only option here.
+        qstr = (
+            'SELECT mean("{open_f}") AS "open", mean("{high_f}") AS "high", '
+            'mean("{low_f}") AS "low", mean("{close_f}") AS "close", '
+            'mean("{vol_f}") AS "volume", mean("{oi_f}") AS "openinterest" '
+            'FROM "{dataname}" '
+            "WHERE time {begin} "
+            "GROUP BY time({timeframe}) fill(none)"
+        ).format(  # nosec B608
+            open_f=self.p.open,
+            high_f=self.p.high,
+            low_f=self.p.low,
+            close_f=self.p.close,
+            vol_f=self.p.volume,
+            oi_f=self.p.ointerest,
+            timeframe=tf,
+            begin=st,
+            dataname=self.p.dataname,
+        )
+        # Get data
+        try:
+            dbars = list(self.ndb.query(qstr).get_points())
+        except InfluxDBClientError as err:
+            logger.error("InfluxDB query failed: %s", err)
+        # Iterate data
+        self.biter = iter(dbars)
+
+    def _load(self):
+        # Try to get next bar data, then add to line
+        if self.biter is None:
+            return False
+        try:
+            bar = next(self.biter)
+        except StopIteration:
+            return False
+
+        self.l.datetime[0] = date2num(dt.datetime.strptime(bar["time"], "%Y-%m-%dT%H:%M:%SZ"))
+
+        self.l.open[0] = bar["open"]
+        self.l.high[0] = bar["high"]
+        self.l.low[0] = bar["low"]
+        self.l.close[0] = bar["close"]
+        self.l.volume[0] = bar["volume"]
+
+        return True

backtrader/feeds/livefeed.py

@@ -0,0 +1,71 @@
+#!/usr/bin/env python
+"""Live Feed Abstract Base Class.
+
+Defines the common interface for live trading data feed implementations.
+The current project direction uses ``BtApiFeed`` as the unified adapter
+and keeps this base class as the reference contract for future providers.
+
+Classes:
+    LiveFeedBase: Abstract base for live-trading data feeds.
+"""
+
+from abc import ABC, abstractmethod
+
+
+class LiveFeedBase(ABC):
+    """Abstract base class for live-trading data feeds.
+
+    A *live feed* streams real-time market data (ticks or bars) from a
+    trading venue into backtrader's Line system. It is responsible for:
+
+    - Connecting to the store's market data channel.
+    - Aggregating ticks into OHLCV bars (if tick-based).
+    - Optionally back-filling historical data on startup.
+    - Signalling when live data begins (``LIVE`` status).
+
+    Subclasses **must** implement every ``@abstractmethod``.
+    """
+
+    # ------------------------------------------------------------------
+    # Lifecycle
+    # ------------------------------------------------------------------
+
+    @abstractmethod
+    def start(self):
+        """Connect to the store and begin receiving data."""
+
+    @abstractmethod
+    def stop(self):
+        """Disconnect and release resources."""
+
+    @abstractmethod
+    def islive(self) -> bool:
+        """Return ``True`` to indicate this is a live (not historical) feed."""
+
+    # ------------------------------------------------------------------
+    # Data loading
+    # ------------------------------------------------------------------
+
+    @abstractmethod
+    def _load(self) -> bool:
+        """Load the next bar/tick into the Line buffers.
+
+        Returns:
+            True if a new bar was loaded, False if no more data.
+        """
+
+    # ------------------------------------------------------------------
+    # Optional: historical backfill
+    # ------------------------------------------------------------------
+
+    def haslivedata(self) -> bool:
+        """Return True if live data is currently available in the queue."""
+        return False
+
+    def _load_history(self) -> bool:
+        """Load historical bars for backfill (optional).
+
+        Returns:
+            True if a historical bar was loaded, False when done.
+        """
+        return False

backtrader/feeds/mixed_channel.py

@@ -0,0 +1,108 @@
+"""Mixed multi-source streaming channel.
+
+Defines :class:`MixedChannel`, a :class:`~backtrader.channel.StreamingEventQueue`
+that merges several event channels (generic, tick, order book, funding) into a
+single time-ordered stream for tick-level backtesting, plus the
+:func:`build_mixed_channel` convenience constructor.
+"""
+
+from backtrader.channel import StreamingEventQueue
+
+__all__ = ["MixedChannel", "build_mixed_channel"]
+
+
+class MixedChannel(StreamingEventQueue):
+    """Streaming event queue that merges multiple channel groups into one stream.
+
+    The constructor flattens the per-group channel lists
+    (``channels``, ``tick_channels``, ``orderbook_channels``,
+    ``funding_channels``) into a single ``merged_channels`` list and
+    delegates to :class:`StreamingEventQueue`. The remaining keyword
+    arguments (``preload_window``, ``max_memory_mb``, ``adaptive``,
+    ``batch_size``) are forwarded unchanged.
+    """
+
+    def __init__(
+        self,
+        channels=None,
+        bars=None,
+        tick_channels=None,
+        orderbook_channels=None,
+        funding_channels=None,
+        preload_window=300.0,
+        max_memory_mb=200,
+        adaptive=True,
+        batch_size=10000,
+    ):
+        """Build a merged-channel streaming queue.
+
+        Args:
+            channels: Optional iterable of generic event channels.
+            bars: Optional iterable of pre-built bar objects. Copied
+                into a list before being forwarded to the base class.
+            tick_channels: Optional iterable of tick event channels.
+            orderbook_channels: Optional iterable of order-book event
+                channels.
+            funding_channels: Optional iterable of funding-rate event
+                channels.
+            preload_window: Preload window size in seconds, forwarded
+                to :class:`StreamingEventQueue`.
+            max_memory_mb: Soft memory cap (in MB) for the queue,
+                forwarded to the base class.
+            adaptive: Whether the queue should adapt its batching
+                strategy, forwarded to the base class.
+            batch_size: Default batch size, forwarded to the base
+                class.
+        """
+        merged_channels: list = []
+        for group in (
+            channels or [],
+            tick_channels or [],
+            orderbook_channels or [],
+            funding_channels or [],
+        ):
+            merged_channels.extend(group)
+
+        super().__init__(
+            channels=merged_channels,
+            bars=list(bars or []),
+            preload_window=preload_window,
+            max_memory_mb=max_memory_mb,
+            adaptive=adaptive,
+            batch_size=batch_size,
+        )
+
+
+def build_mixed_channel(
+    channels=None,
+    bars=None,
+    tick_channels=None,
+    orderbook_channels=None,
+    funding_channels=None,
+    **kwargs,
+):
+    """Construct a :class:`MixedChannel` with the standard per-group arguments.
+
+    All extra keyword arguments are forwarded to :class:`MixedChannel`
+    so callers can pass ``preload_window``, ``max_memory_mb``,
+    ``adaptive`` and ``batch_size`` without listing them explicitly.
+
+    Args:
+        channels: Optional iterable of generic event channels.
+        bars: Optional iterable of pre-built bar objects.
+        tick_channels: Optional iterable of tick event channels.
+        orderbook_channels: Optional iterable of order-book channels.
+        funding_channels: Optional iterable of funding-rate channels.
+        **kwargs: Forwarded to :class:`MixedChannel`.
+
+    Returns:
+        MixedChannel: A new :class:`MixedChannel` instance.
+    """
+    return MixedChannel(
+        channels=channels,
+        bars=bars,
+        tick_channels=tick_channels,
+        orderbook_channels=orderbook_channels,
+        funding_channels=funding_channels,
+        **kwargs,
+    )

backtrader/feeds/mt4csv.py

@@ -0,0 +1,42 @@
+#!/usr/bin/env python
+"""MetaTrader 4 CSV Data Feed Module - MT4 CSV parsing.
+
+This module provides the MT4CSVData feed for parsing MetaTrader 4
+History Center exported CSV files.
+
+Classes:
+    MT4CSVData: Parses MT4 CSV format files.
+
+Example:
+    >>> data = bt.feeds.MT4CSVData(dataname='mt4_data.csv')
+    >>> cerebro.adddata(data)
+"""
+
+from . import GenericCSVData
+
+
+class MT4CSVData(GenericCSVData):
+    """
+    Parses a `Metatrader4 <https://www.metaquotes.net/en/metatrader4>`_ History
+    center CSV exported file.
+
+    Specific parameters (or specific meaning):
+
+      - ``dataname``: The filename to parse or a file-like object
+
+      - Uses GenericCSVData and simply modifies the params
+    """
+
+    # MT4 data class inheriting from CSV, only modifies parameters
+    params = (
+        ("dtformat", "%Y.%m.%d"),
+        ("tmformat", "%H:%M"),
+        ("datetime", 0),
+        ("time", 1),
+        ("open", 2),
+        ("high", 3),
+        ("low", 4),
+        ("close", 5),
+        ("volume", 6),
+        ("openinterest", -1),
+    )