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

backtrader/observers/buysell.py

@@ -0,0 +1,144 @@
+#!/usr/bin/env python
+"""BuySell Observer Module - Buy/sell signal visualization.
+
+This module provides the BuySell observer for visualizing buy and sell
+orders on the chart.
+
+Classes:
+    BuySell: Observer that plots buy/sell markers on the chart.
+
+Example:
+    >>> cerebro = bt.Cerebro()
+    >>> cerebro.addobserver(bt.observers.BuySell)
+"""
+
+import math
+
+from ..observer import Observer
+
+
+# Buy and sell point markers
+class BuySell(Observer):
+    """
+    This observer keeps track of the individual buy/sell orders (individual
+    executions) and will plot them on the chart along the data around the
+    execution price level
+
+    Params:
+      - ``barplot`` (default: ``False``) Plot buy signals below the minimum and
+        sell signals above the maximum.
+
+        If `False`, it will plot on the average price of executions during a
+        bar
+
+      - ``bardist`` (default: ``0.015`` 1.5%) Distance to max/min when
+        ``barplot`` is ``True``
+    """
+
+    lines = (
+        "buy",
+        "sell",
+    )
+
+    plotinfo = {"plot": True, "subplot": False, "plotlinelabels": True}
+    plotlines = {
+        "buy": {"marker": "^", "markersize": 8.0, "color": "lime", "fillstyle": "full", "ls": ""},
+        "sell": {"marker": "v", "markersize": 8.0, "color": "red", "fillstyle": "full", "ls": ""},
+    }
+
+    params = (
+        ("barplot", False),  # plot above/below max/min for clarity in bar plot
+        ("bardist", 0.015),  # distance to max/min in absolute perc
+    )
+
+    def __init__(self):
+        """Initialize the BuySell observer.
+
+        Sets up tracking for buy/sell order lengths.
+        """
+        self.curbuylen = 0
+        self.curselllen = 0
+        self._lastbar = None
+
+    def next(self):
+        """Update buy/sell markers based on executed orders.
+
+        Calculates average prices for buy and sell orders during the bar.
+        """
+        try:
+            barref = self.data.datetime[0]
+        except (IndexError, AttributeError, TypeError):
+            barref = None
+
+        sentinel = object()
+        if getattr(self, "_lastbar", sentinel) != barref:
+            self.lines.buy[0] = float("nan")
+            self.lines.sell[0] = float("nan")
+            self.curbuylen = 0
+            self.curselllen = 0
+            self._lastbar = barref
+
+        buy = []
+        sell = []
+        # If there are pending orders
+        for order in self._owner._orderspending:
+            # If no data or size is 0, skip
+            if order.data is not self.data or not order.executed.size:
+                continue
+            # If it's a buy order, add price to buy, if it's a sell order, add price to sell
+            if order.isbuy():
+                buy.append(order.executed.price)
+            else:
+                sell.append(order.executed.price)
+
+        # Take into account replay ... something could already be in there
+        # Write down the average buy/sell price
+
+        # BUY
+        # Get buy price
+        curbuy = self.lines.buy[0]
+        # If NaN, curbuy equals 0, curbuylen=0, otherwise, curbuylen = self.curbuylen
+        if curbuy != curbuy:  # NaN
+            curbuy = 0.0
+            self.curbuylen = curbuylen = 0
+        else:
+            curbuylen = self.curbuylen
+        # Current total price
+        buyops = curbuy + math.fsum(buy)
+        # Current total order count
+        buylen = curbuylen + len(buy)
+        # Calculate average price
+        value = buyops / float(buylen or "NaN")
+        # If not plotting, get average price, if plotting, get a percentage of lowest price for better display
+        if not self.p.barplot:
+            self.lines.buy[0] = value
+        elif value == value:  # Not NaN
+            pbuy = self.data.low[0] * (1 - self.p.bardist)
+            self.lines.buy[0] = pbuy
+
+        # Update buylen values
+        curbuy = buyops
+        self.curbuylen = buylen
+
+        # For sell orders, similar logic
+        # SELL
+        cursell = self.lines.sell[0]
+        if cursell != cursell:  # NaN
+            cursell = 0.0
+            self.curselllen = curselllen = 0
+        else:
+            curselllen = self.curselllen
+
+        sellops = cursell + math.fsum(sell)
+        selllen = curselllen + len(sell)
+
+        value = sellops / float(selllen or "NaN")
+        if not self.p.barplot:
+            self.lines.sell[0] = value
+        elif value == value:  # Not NaN
+            psell = self.data.high[0] * (1 + self.p.bardist)
+            self.lines.sell[0] = psell
+
+        # Update selllen values
+        cursell = sellops
+        self.curselllen = selllen

backtrader/observers/drawdown.py

@@ -0,0 +1,161 @@
+#!/usr/bin/env python
+"""DrawDown Observer Module - Drawdown tracking observer.
+
+This module provides the DrawDown observer for tracking current and maximum
+drawdown levels during backtesting.
+
+Classes:
+    DrawDown: Observer that tracks drawdown and max drawdown levels.
+
+Example:
+    >>> cerebro = bt.Cerebro()
+    >>> cerebro.addobserver(bt.observers.DrawDown)
+"""
+
+from ..analyzers import DrawDown as DrawDownAnalyzer
+from ..observer import Observer
+
+
+# Drawdown
+class DrawDown(Observer):
+    """This observer keeps track of the current drawdown level (plotted) and
+    the maxdrawdown (not plotted) levels
+
+    Params:
+
+      - ``fund`` (default: ``None``)
+
+        If `None`, the actual mode of the broker (fundmode - True/False) will
+        be autodetected to decide if the returns are based on the total net
+        asset value or on the fund value. See ``set_fundmode`` in the broker
+        documentation
+
+        Set it to ``True`` or ``False`` for a specific behavior
+
+    """
+
+    _stclock = True
+
+    params = (("fund", None),)
+
+    lines = (
+        "drawdown",
+        "maxdrawdown",
+    )
+
+    plotinfo = {"plot": True, "subplot": True}
+
+    plotlines = {
+        "maxdrawdown": {
+            "_plotskip": True,
+        }
+    }
+
+    def __init__(self):
+        """Initialize the DrawDown observer.
+
+        Adds DrawDown analyzer to track drawdown levels.
+        """
+        kwargs = self.p._getkwargs()
+        self._dd = self._owner._addanalyzer_slave(DrawDownAnalyzer, **kwargs)
+
+    def next(self):
+        """Update drawdown values for the current period.
+
+        Gets current and maximum drawdown from the analyzer.
+        """
+        self.lines.drawdown[0] = self._dd.rets.drawdown  # update drawdown
+        self.lines.maxdrawdown[0] = self._dd.rets.max.drawdown  # update max
+
+
+# Drawdown length
+class DrawDownLength(Observer):
+    """This observer keeps track of the current drawdown length (plotted) and
+    the drawdown max length (not plotted)
+
+    Params: None
+    """
+
+    _stclock = True
+
+    lines = (
+        "len",
+        "maxlen",
+    )
+
+    plotinfo = {"plot": True, "subplot": True}
+
+    plotlines = {
+        "maxlen": {
+            "_plotskip": True,
+        }
+    }
+
+    def __init__(self):
+        """Initialize the DrawDownLength observer.
+
+        Adds DrawDown analyzer to track drawdown length.
+        """
+        self._dd = self._owner._addanalyzer_slave(DrawDownAnalyzer)
+
+    def next(self):
+        """Update drawdown length values.
+
+        Gets current and maximum drawdown length from the analyzer.
+        """
+        self.lines.len[0] = self._dd.rets.len  # update drawdown length
+        self.lines.maxlen[0] = self._dd.rets.max.len  # update max length
+
+
+# Old method for max drawdown, calculated within this class instead of calling DrawDown from analyzers
+class DrawDownOld(Observer):
+    """This observer keeps track of the current drawdown level (plotted) and
+    the maxdrawdown (not plotted) levels
+
+    Params: None
+    """
+
+    _stclock = True
+
+    lines = (
+        "drawdown",
+        "maxdrawdown",
+    )
+
+    plotinfo = {"plot": True, "subplot": True}
+
+    plotlines = {
+        "maxdrawdown": {
+            "_plotskip": True,
+        }
+    }
+
+    def __init__(self):
+        """Initialize the DrawDownOld observer.
+
+        Sets up peak and max drawdown tracking variables.
+        """
+        super().__init__()
+
+        self.maxdd = 0.0
+        self.peak = float("-inf")
+
+    def next(self):
+        """Calculate and update drawdown values.
+
+        Computes drawdown from peak value and updates maximum.
+        """
+        value = self._owner.broker.getvalue()
+
+        # update the maximum seen peak
+        if value > self.peak:
+            self.peak = value
+
+        # calculate the current drawdown
+        if self.peak:
+            self.lines.drawdown[0] = dd = 100.0 * (self.peak - value) / self.peak
+        else:
+            self.lines.drawdown[0] = dd = 0.0
+
+        # update the maxdrawdown if needed
+        self.lines.maxdrawdown[0] = self.maxdd = max(self.maxdd, dd)

backtrader/observers/logreturns.py

@@ -0,0 +1,113 @@
+#!/usr/bin/env python
+"""LogReturns Observer Module - Log returns tracking.
+
+This module provides observers for tracking log returns of the strategy
+or a data feed.
+
+Classes:
+    LogReturns: Observer that tracks log returns.
+    LogReturns2: Alternative log returns observer.
+
+Example:
+    >>> cerebro = bt.Cerebro()
+    >>> cerebro.addobserver(bt.observers.LogReturns)
+"""
+
+from ..analyzers import LogReturnsRolling
+from ..dataseries import TimeFrame
+from ..observer import Observer
+
+__all__ = ["LogReturns", "LogReturns2"]
+
+
+# Get log returns
+class LogReturns(Observer):
+    """This observer stores the *log returns* of the strategy or a
+
+    Params:
+
+      - ``timeframe`` (default: ``None``)
+        If ``None`` then the complete return over the entire backtested period
+        will be reported
+
+        Pass ``TimeFrame.NoTimeFrame`` to consider the entire dataset with no
+        time constraints
+
+      - ``compression`` (default: ``None``)
+
+        Only used for sub-day timeframes to, for example, work on an hourly
+        timeframe by specifying "TimeFrame.Minutes" and 60 as compression
+
+      - ``fund`` (default: ``None``)
+
+        If `None`, the actual mode of the broker (fundmode - True/False) will
+        be autodetected to decide if the returns are based on the total net
+        asset value or on the fund value. See ``set_fundmode`` in the broker
+        documentation
+
+        Set it to ``True`` or ``False`` for a specific behavior
+
+    Remember that at any moment of a `run` the current values can be checked
+    by looking at the *lines* by name at index ``0``.
+
+    """
+
+    _stclock = True
+
+    lines = ("logret1",)
+    plotinfo = {"plot": True, "subplot": True}
+
+    params = (
+        ("timeframe", None),
+        ("compression", None),
+        ("fund", None),
+    )
+
+    # Plot labels
+    def _plotlabel(self):
+        return [
+            TimeFrame.getname(self.p.timeframe, self.p.compression),
+            str(self.p.compression or 1),
+        ]
+
+    def __init__(self):
+        """Initialize the LogReturns observer.
+
+        Adds LogReturnsRolling analyzer to track log returns.
+        """
+        self.logret1 = self._owner._addanalyzer_slave(
+            LogReturnsRolling, data=self.data0, **self.p._getkwargs()
+        )
+
+    def next(self):
+        """Update log return value for the current period.
+
+        Gets the log return from the analyzer.
+        """
+        self.lines.logret1[0] = self.logret1.rets.get(self.logret1.dtkey, float("NaN"))
+
+
+# Show log returns for the second instrument
+class LogReturns2(LogReturns):
+    """Extends the observer LogReturns to show two instruments"""
+
+    lines = ("logret2",)
+
+    def __init__(self):
+        """Initialize the LogReturns2 observer.
+
+        Adds analyzer for second data feed's log returns.
+        """
+        super().__init__()
+
+        self.logret2 = self._owner._addanalyzer_slave(
+            LogReturnsRolling, data=self.data1, **self.p._getkwargs()
+        )
+
+    def next(self):
+        """Update log return values for both data feeds.
+
+        Updates logret1 from parent and logret2 for second feed.
+        """
+        super().next()
+        self.lines.logret2[0] = self.logret2.rets.get(self.logret2.dtkey, float("NaN"))

backtrader/observers/timereturn.py

@@ -0,0 +1,86 @@
+#!/usr/bin/env python
+"""TimeReturn Observer Module - Time-based returns tracking.
+
+This module provides the TimeReturn observer for tracking strategy
+returns over different time periods.
+
+Classes:
+    TimeReturn: Observer that tracks returns over time periods.
+
+Example:
+    >>> cerebro = bt.Cerebro()
+    >>> cerebro.addobserver(bt.observers.TimeReturn, timeframe=bt.TimeFrame.Days)
+"""
+
+from ..analyzers.timereturn import TimeReturn as TimeReturnAnalyzer
+from ..dataseries import TimeFrame
+from ..observer import Observer
+
+
+# Time return class
+class TimeReturn(Observer):
+    """This observer stores the *returns* of the strategy.
+
+    Params:
+
+      - ``timeframe`` (default: ``None``)
+        If ``None`` then the complete return over the entire backtested period
+        will be reported
+
+        Pass ``TimeFrame.NoTimeFrame`` to consider the entire dataset with no
+        time constraints
+
+      - ``compression`` (default: ``None``)
+
+        Only used for sub-day timeframes to, for example, work on an hourly
+        timeframe by specifying "TimeFrame.Minutes" and 60 as compression
+
+      - ``fund`` (default: ``None``)
+
+        If `None`, the actual mode of the broker (fundmode - True/False) will
+        be autodetected to decide if the returns are based on the total net
+        asset value or on the fund value. See ``set_fundmode`` in the broker
+        documentation
+
+        Set it to ``True`` or ``False`` for a specific behavior
+
+    Remember that at any moment of a `run` the current values can be checked
+    by looking at the *lines* by name at index ``0``.
+
+    """
+
+    _stclock = True
+    # Set lines
+    lines = ("timereturn",)
+    # Plot info
+    plotinfo = {"plot": True, "subplot": True}
+    # Set plotlines
+    plotlines = {"timereturn": {"_name": "Return"}}
+    # Parameters
+    params = (
+        ("timeframe", None),
+        ("compression", None),
+        ("fund", None),
+    )
+
+    # Plot labels
+    def _plotlabel(self):
+        return [
+            # Use the final tf/comp values calculated by the return analyzer
+            TimeFrame.getname(self.treturn.timeframe, self.treturn.compression),
+            str(self.treturn.compression),
+        ]
+
+    def __init__(self):
+        """Initialize the TimeReturn observer.
+
+        Adds TimeReturn analyzer to track returns over time.
+        """
+        self.treturn = self._owner._addanalyzer_slave(TimeReturnAnalyzer, **self.p._getkwargs())
+
+    def next(self):
+        """Update the time return value for the current period.
+
+        Gets the return value from the analyzer for the current time key.
+        """
+        self.lines.timereturn[0] = self.treturn.rets.get(self.treturn.dtkey, float("NaN"))