backtrader-next 2.1.1__tar.gz → 2.2.1__tar.gz

{backtrader_next-2.1.1 → backtrader_next-2.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: backtrader_next
-Version: 2.1.1
+Version: 2.2.1
 Summary: Live Trading and backtesting platform in Python
 Project-URL: Homepage, https://github.com/smalinin/backtrader_next
 Project-URL: Source, https://github.com/smalinin/backtrader_next
@@ -37,6 +37,7 @@ Live Trading and backtesting platform written in Python.
 ```
 pip install backtrader-next
 ```
+
 ## History
 Package is based on [backtrader](https://github.com/mementum/backtrader)
 
@@ -51,6 +52,21 @@ Changes:
  - Detailed results
  - Interactive visualizations
 
+## Performance
+
+Performance comparison using the [perf_compare](https://github.com/smalinin/backtrader_next/tree/master/examples/3_perf_compare) benchmark.
+
+- **Backtrader-next**  using an optimized **PandasData** feed 
+- [Backtrader](https://github.com/mementum/backtrader) with **PandasData** feed
+- [Backtesting.py](https://github.com/kernc/backtesting.py) 
+
+| Framework | Execution Time | Relative Speed |
+|---|---|---|
+| Backtesting | 2.95 sec | 14.3x faster than Backtrader |
+| Backtrader-next | 12.33 sec | 3.4x faster than Backtrader |
+| Backtrader | 42.25 sec | Baseline |
+
+
 ## Here a snippet of a Simple Moving Average CrossOver.
 ```python
 import pandas as pd

{backtrader_next-2.1.1 → backtrader_next-2.2.1}/README.md

@@ -15,6 +15,7 @@ Live Trading and backtesting platform written in Python.
 ```
 pip install backtrader-next
 ```
+
 ## History
 Package is based on [backtrader](https://github.com/mementum/backtrader)
 
@@ -29,6 +30,21 @@ Changes:
  - Detailed results
  - Interactive visualizations
 
+## Performance
+
+Performance comparison using the [perf_compare](https://github.com/smalinin/backtrader_next/tree/master/examples/3_perf_compare) benchmark.
+
+- **Backtrader-next**  using an optimized **PandasData** feed 
+- [Backtrader](https://github.com/mementum/backtrader) with **PandasData** feed
+- [Backtesting.py](https://github.com/kernc/backtesting.py) 
+
+| Framework | Execution Time | Relative Speed |
+|---|---|---|
+| Backtesting | 2.95 sec | 14.3x faster than Backtrader |
+| Backtrader-next | 12.33 sec | 3.4x faster than Backtrader |
+| Backtrader | 42.25 sec | Baseline |
+
+
 ## Here a snippet of a Simple Moving Average CrossOver.
 ```python
 import pandas as pd

{backtrader_next-2.1.1 → backtrader_next-2.2.1}/backtrader_next/analyzers/eq.py

@@ -7,15 +7,13 @@ import numpy as np
 import pandas as pd
 from pandas import DataFrame as df
 from numbers import Number
-from typing import Dict, List, Optional, Sequence, Union, cast
+from typing import Union
 import math
-# from math import copysign
 
 
 class Eq(bt.Analyzer):
-    '''This analyzer calculates trading system drawdowns stats such as drawdown
-    values in %s and in dollars, max drawdown in %s and in dollars, drawdown
-    length and drawdown max length
+    '''This analyzer calculates comprehensive trading system performance statistics
+    including equity curves, drawdown analysis, returns, risk metrics, and trade statistics.
 
     Params:
 
@@ -28,20 +26,42 @@ class Eq(bt.Analyzer):
 
         Set it to ``True`` or ``False`` for a specific behavior
 
+      - ``data`` (default: ``None``)
+
+        Specific data feed to analyze. If ``None``, all data is analyzed.
+
+      - ``cash`` (default: ``True``)
+
+        Whether to include cash information in equity tracking.
+
     Methods:
 
-      - ``get_analysis``
+      - ``compute_stats(risk_free_rate=0.0)``
+
+        Returns a pandas Series with comprehensive trading statistics including:
+
+        - Equity metrics: Start, End, Duration, Peak equity
+        - Returns: Cumulative return %, Annualized return, CAGR
+        - Risk metrics: Volatility (Ann.), Sharpe Ratio, Sortino Ratio, Smart Sharpe Ratio
+        - Drawdown stats: Max Drawdown %, Avg Drawdown %, Drawdown Duration
+        - Trade statistics: Win Rate, Best/Worst/Avg Trade, # of Trades
+        - Performance ratios: Calmar Ratio, VWR Ratio, Profit Factor, SQN, Kelly Criterion
+
+      - ``gen_eq()``
+
+        Returns equity curve as a pandas DataFrame with datetime index.
+
+      - ``gen_eq_dd()``
+
+        Returns equity and drawdown data as a pandas DataFrame.
 
-        Returns a dictionary (with . notation support and subdctionaries) with
-        drawdown stats as values, the following keys/attributes are available:
+      - ``gen_trades(data_name=None, pct=False)``
 
-        - ``drawdown`` - drawdown value in 0.xx %
-        - ``moneydown`` - drawdown value in monetary units
-        - ``len`` - drawdown length
+        Returns trade-level statistics as a pandas DataFrame.
 
-        - ``max.drawdown`` - max drawdown value in 0.xx %
-        - ``max.moneydown`` - max drawdown value in monetary units
-        - ``max.len`` - max drawdown length
+      - ``gen_orders(data_name=None)``
+
+        Returns order history as a pandas DataFrame.
     '''
 
     params = (
@@ -136,7 +156,6 @@ class Eq(bt.Analyzer):
     def gen_trades(self, data_name=None, pct=False) -> 'DataFrame':
         if self.trades_df is None:
             self.trades_df = df.from_records(self.trades, columns=self.trades_header)
-            # self.trades_df = df.from_records(self.trades, index=self.trades_header[0], columns=self.trades_header)
         if data_name is None:
             rdf = self.trades_df.copy()
         else:
@@ -211,7 +230,6 @@ class Eq(bt.Analyzer):
         # our risk doesn't; they use the simpler approach below.
         annualized_return = (1 + gmean_day_return) ** annual_trading_days - 1
         s.loc['Return (Ann.) [%]'] = round(annualized_return * 100, 4)
-        # s.loc['Risk (Ann.) [%]'] = day_returns.std(ddof=1) * np.sqrt(annual_trading_days) * 100
         s.loc['Volatility (Ann.) [%]'] = volatility = round(day_returns.std(ddof=1) * np.sqrt(annual_trading_days) * 100, 4)
 
         # CAGR from quantstats
@@ -286,10 +304,6 @@ class Eq(bt.Analyzer):
         else:
             s.loc['Kelly Criterion [%]'] = np.nan
 
-        # s.loc['_strategy'] = strategy_instance
-        # s.loc['_equity_curve'] = equity_df
-        # s.loc['_trades'] = trades_df
-        #
         return s
 
 
@@ -322,39 +336,6 @@ def geometric_mean(returns: pd.Series) -> float:
     return np.exp(np.log(returns).sum() / (len(returns) or np.nan)) - 1
 
 
-def calc_vwr0(eq_days: np.array, sdev_max=2.0, tau=0.20) -> float:
-    eq = eq_days #.to_numpy()
-    eq_0 = eq_days.shift().to_numpy()
-
-    try:
-        nlrtot = eq[-1] / eq[0]
-    except ZeroDivisionError:
-        rtot = float('-inf')
-    else:
-        if nlrtot <= 0.0:
-            rtot = float('-inf')
-        else:
-            rtot = math.log(nlrtot)
-
-    ravg = rtot / len(eq)
-    rnorm = math.expm1(ravg * 252)
-    rnorm100 = rnorm * 100.0
-
-    dts = []
-    for n, zip_data in enumerate(zip(eq_0, eq), 0):
-        eq0, eq1 = zip_data
-        if (n > 0):
-            _v = (eq0 * math.exp(ravg * n))
-            if _v != 0:
-                dt = eq1 / (eq0 * math.exp(ravg * n)) - 1.0
-                dts.append(dt)
-            else:
-                dts.append(0.0)
-
-    sdev_p = np.array(dts).std(ddof=True)
-    vwr = rnorm100 * (1.0 - pow(sdev_p / sdev_max, tau))
-    return vwr
-
 #    calc VariabilityWeightedReturn
 #    See:
 #      - https://www.crystalbull.com/sharpe-ratio-better-with-log-returns/

{backtrader_next-2.1.1 → backtrader_next-2.2.1}/backtrader_next/order.py

@@ -283,6 +283,21 @@ class OrderBase(with_metaclass(MetaParams, object)):
         self._plimit = val
 
     plimit = property(_getplimit, _setplimit)
+    
+    @property
+    def owner(self):
+        if self._owner_classname and not self.p.owner:
+            class_name = self._owner_classname
+            for s in self.broker.cerebro.runningstrategies:
+                if s.__class__.__name__ == class_name:
+                    self.p.owner = s
+                    self._owner_classname = None
+                    break
+        return self.p.owner
+    
+    @owner.setter
+    def owner(self, value):
+        self.p.owner = value
 
     def __getattr__(self, name):
         # Return attr from params if not found in order
@@ -323,6 +338,9 @@ class OrderBase(with_metaclass(MetaParams, object)):
         self.info = AutoOrderedDict()
         self.comminfo = None
         self.triggered = False
+        self.parent_ref = None
+        self._owner_classname = None
+        self._restored = False
 
         self._active = self.parent is None
         self.status = Order.Created
@@ -337,10 +355,10 @@ class OrderBase(with_metaclass(MetaParams, object)):
 
         # Set a reference price if price is not set using
         # the close price
-        pclose = self.data.close[0] if not self.p.simulated else self.price
+        pclose = self.data.close[0] if not self.p.simulated and not self._restored else self.price
         price = pclose if not self.price and not self.pricelimit else self.price
 
-        dcreated = self.data.datetime[0] if not self.p.simulated else 0.0
+        dcreated = self.data.datetime[0] if not self.p.simulated and not self._restored else 0.0
         self.created = OrderData(dt=dcreated,
                                  size=self.size,
                                  price=price,
@@ -382,7 +400,7 @@ class OrderBase(with_metaclass(MetaParams, object)):
             else:  # assume float
                 valid = self.data.datetime[0] + self.valid
 
-        if not self.p.simulated:
+        if not self.p.simulated and not self._restored:
             # provisional end-of-session
             # get next session end
             dtime = self.data.datetime.datetime(0)
@@ -655,52 +673,80 @@ class Order(OrderBase):
                     'price': v.price,
                     'pricelimit': v.pricelimit,
                     'remsize': v.remsize,
+                    'pclose': v.pclose,
                     'trailamount': v.trailamount,
                     'trailpercent': v.trailpercent,
+                    'value': v.value,
+                    'comm': v.comm,
+                    'margin': v.margin,
+                    'pnl': v.pnl,
+                    'psize': v.psize,
+                    'pprice': v.pprice,
                 }
-            elif k in ('broker', 'data'):
+            elif k in ('broker', 'data','params','comminfo','info',):
                 # handled below
                 pass
-            elif k in ('parent',):
-                odict[k] = v.ref if v else None
+            elif k == 'parent':
+                odict['parent'] = None
+                if v is not None:
+                    odict['parent_ref'] = v.ref
                 # handled below
-                pass
+            elif k in ('p',):
+                odict['params'] = vars(v).copy()
+                odict['params']['_owner_classname'] = v.owner.__class__.__qualname__ if v.owner else None
+                odict['params']['owner'] = None
+                odict['params']['data'] = v.data._name if v.data else None
             else:
                 odict[k] = v
+        odict['ordtype'] = self.ordtype
         return odict
 
     @classmethod
-    def from_dict(cls, odict):
+    def from_dict(cls, params, odict):
         '''Loads the order data from a dictionary representation'''
+        odict['_restored'] = True
         ordtype = odict.get('ordtype', None)
         ord = None
         if ordtype is None:
-            return None
+            ord = Order(**params)
         if ordtype == cls.Buy:
-            ord = BuyOrder()
+            ord = BuyOrder(**params)
         elif ordtype == cls.Sell:
-            ord = SellOrder()
+            ord = SellOrder(**params)
         else:
-            ord = Order()
+            ord = Order(**params)
 
         for key, val in odict.items():
-            if key == 'created' or key == 'executed':
-                ord.created = OrderData(
+            if key in ('created', 'executed'):
+                odata = OrderData(
                     dt=val.get('dt', None),
                     size=val.get('size', 0),
                     price=val.get('price', 0.0),
                     pricelimit=val.get('pricelimit', 0.0),
+                    remsize=val.get('remsize', 0),
+                    pclose=val.get('pclose', 0.0),
                     trailamount=val.get('trailamount', 0.0),
                     trailpercent=val.get('trailpercent', 0.0),
                 )
+                odata.value = val.get('value', 0.0)
+                odata.comm = val.get('comm', 0.0)
+                odata.margin = val.get('margin', None)
+                odata.pnl = val.get('pnl', 0.0)
+                odata.psize = val.get('psize', 0)
+                odata.pprice = val.get('pprice', 0.0)
+                if key == 'created':
+                    ord.created = odata
+                else:
+                    ord.executed = odata
+            elif key in ('ordtype', 'params'):
+                pass # already handled
             elif key == 'info':
                 for ik, iv in val.items():
                     ord.info[ik] = iv
             elif key == 'comminfo':
-                ord.comminfo = val  #?? string representation only
+                ord.comminfo = None
             elif key == 'parent':
-                ref = val
-                ord.parent = None  #??TODO
+                ord.parent = None
             elif hasattr(ord, key):
                 setattr(ord, key, val)
         return ord

{backtrader_next-2.1.1 → backtrader_next-2.2.1}/backtrader_next/version.py

@@ -22,6 +22,6 @@ from __future__ import (absolute_import, division, print_function,
                         unicode_literals)
 
 
-__version__ = '2.1.0'
+__version__ = '2.2.1'
 
 __btversion__ = tuple(int(x) for x in __version__.split('.'))

backtrader_next-2.2.1/examples/3_perf_compare/.gitignore

@@ -0,0 +1,10 @@
+# Python-generated files
+__pycache__/
+*.py[oc]
+build/
+dist/
+wheels/
+*.egg-info
+
+# Virtual environments
+.venv

backtrader_next-2.2.1/examples/3_perf_compare/.python-version

@@ -0,0 +1 @@
+3.13

backtrader_next-2.2.1/examples/3_perf_compare/README.md

@@ -0,0 +1,70 @@
+
+# Trading Strategy Performance Comparison: Dual Moving Averages
+
+This project provides a comprehensive performance benchmark comparing three Python backtesting frameworks: **Backtesting**, **Backtrader**, and **Backtrader-next**. 
+The comparison is based on a dual moving average crossover strategy tested on 430,000 historical price candles.
+
+## Backtesting Frameworks
+
+1. [Backtesting.py](https://github.com/kernc/backtesting.py) - Lightweight and easy-to-use framework (doesn't support trading, only for backtesting)
+2. [Backtrader](https://github.com/mementum/backtrader) - Feature-rich framework with extensive capabilities
+3. [Backtrader-next](https://github.com/smalinin/backtrader_next) - Modern fork of Backtrader with optimizations  
+
+ 
+## Testing Parameters
+
+The performance test was conducted with the following specifications:
+
+- **Python Version:** 3.13
+- **Asset Type:** Stock / Equity
+- **Historical Data Period:** January 1, 2024 - October 10, 2025 (~21 months)
+- **Dataset Size:** 430,000 price candles
+- **Position Size:** 1 contract per trade
+- **Strategy:** Dual Simple Moving Average (SMA) Crossover
+  - **SMA1 (Fast):** 15 periods
+  - **SMA2 (Slow):** 91 periods
+- **Backtest Mode:** Single full pass through historical data (no re-optimization)
+
+
+## Installation and Usage
+
+### Prerequisites
+
+Ensure you have Python 3.13 installed on your system.
+
+### 1. Install the `uv` Package Manager
+
+We use `uv` for fast and efficient dependency management:
+
+```bash
+pip install uv
+```
+
+### 2. Run the Backtest
+
+Execute any of the three frameworks:
+
+**Backtesting** - Fastest execution
+```bash
+uv run main_backtesting.py
+```
+
+**Backtrader** - Feature-rich but slower
+```bash
+uv run main_backtrader.py
+```
+
+**Backtrader-next** - Modern optimized version
+```bash
+uv run main_backtrader_next.py
+```
+
+### 3. Performance Results
+
+| Framework | Execution Time | Relative Speed |
+|---|---|---|
+| Backtesting | 2.95 sec | 14.3x faster than Backtrader |
+| Backtrader-next | 12.33 sec | 3.4x faster than Backtrader |
+| Backtrader | 42.25 sec | Baseline |
+
+

backtrader_next-2.2.1/examples/3_perf_compare/main_backtesting.py

@@ -0,0 +1,52 @@
+import time
+import pandas as pd
+from backtesting import Strategy, Backtest
+from backtesting.lib import crossover
+
+
+def SMA(values, n):
+    """
+    Return simple moving average of `values`, at
+    each step taking into account `n` previous values.
+    """
+    return pd.Series(values).rolling(n).mean()
+
+
+
+class SmaCross(Strategy):
+    n1 = 15 
+    n2 = 91
+    
+    def init(self):
+        # Precompute the two moving averages
+        self.sma1 = self.I(SMA, self.data.df['Close'], self.n1)
+        self.sma2 = self.I(SMA, self.data.df['Close'], self.n2)
+
+    
+    def next(self):
+        # If sma1 crosses above sma2, close any existing
+        # short trades, and buy the asset
+        if crossover(self.sma1, self.sma2):
+            self.position.close()
+            self.buy(size=1)
+
+        # Else, if sma1 crosses below sma2, close any existing
+        # long trades, and sell the asset
+        elif crossover(self.sma2, self.sma1):
+            self.position.close()
+            #self.sell(size=1)
+
+
+start = time.perf_counter()
+dt = pd.read_csv("./STOCK_M1.csv.zip", sep=";",  parse_dates=["Datetime"], index_col=0)
+
+# set commision 0.04% per trade
+bt = Backtest(dt, SmaCross, cash=1_000_000, commission=0.0004, margin=1)
+stats = bt.run()
+
+end = time.perf_counter()
+print(f"Execution time for sum_list: {end - start:.4f} seconds\n\n")
+
+#print(stats)
+
+

backtrader_next-2.2.1/examples/3_perf_compare/main_backtrader.py

@@ -0,0 +1,69 @@
+import time
+import pandas as pd
+import backtrader as bt
+from backtrader.feeds import PandasData
+
+
+class SmaCross(bt.Strategy):
+    params = (
+        ('MA1', 15),
+        ('MA2', 91),
+    )
+
+    def __init__(self):
+        self.Order = None
+        self.ma1 = bt.indicators.SMA(self.data.close, period=self.p.MA1)
+        self.ma2 = bt.indicators.SMA(self.data.close, period=self.p.MA2)
+
+
+    def notify_order(self, order):
+        if order.status in [order.Submitted, order.Accepted]:  # Order is submitted/accepted
+            return  # Do nothing until the order is completed
+
+        elif order.status in [order.Canceled, order.Margin, order.Rejected]:  # Canceled, Margin, Rejected
+            print('Order was Canceled/Margin/Rejected')
+
+        self.Order = None  # Reset order
+
+
+
+    def next(self):
+        # Use ONLY Long Positions
+        if self.crossover(self.ma1, self.ma2):
+            pos = self.getposition()
+            if pos:
+                self.close(size=pos.size)
+            self.Order = self.buy(size=1)
+        elif self.crossover(self.ma2, self.ma1):
+            pos = self.getposition()
+            if pos:
+                self.close(size=pos.size)
+            # self.Order = self.sell()
+
+    def crossover(self, ma1, ma2):
+        try:
+            return ma1[-1] <= ma2[-1] and ma1[0] > ma2[0]
+        except IndexError:
+            return False
+
+
+
+if __name__ == '__main__':
+    cerebro = bt.Cerebro()
+    cerebro.broker.setcash(1_000_000.0)
+    cerebro.broker.set_shortcash(False)
+    cerebro.broker.setcommission(commission=0.0004, leverage=1) # 0.04% per trade
+
+    start = time.perf_counter()
+    df = pd.read_csv(f"STOCK_M1.csv.zip", sep=";", parse_dates=["Datetime"], index_col=0)
+
+    data = PandasData(dataname=df, timeframe=bt.TimeFrame.Minutes, compression=1)
+    cerebro.adddata(data, name='STOCK')
+
+    cerebro.addstrategy(SmaCross, )
+
+    results = cerebro.run(runonce=True)
+    end = time.perf_counter()
+    print(f"Execution time for sum_list: {end - start:.4f} seconds\n\n")
+
+

backtrader_next-2.2.1/examples/3_perf_compare/main_backtrader_next.py

@@ -0,0 +1,72 @@
+import time
+import pandas as pd
+import backtrader_next as bt
+from backtrader_next.feeds import PandasData
+
+
+class SmaCross(bt.Strategy):
+    params = (
+        ('MA1', 15),
+        ('MA2', 91),
+    )
+
+    def __init__(self):
+        self.Order = None
+        # self.ma1 = bt.indicators.SMA(self.data.close, period=self.p.MA1)
+        # self.ma2 = bt.indicators.SMA(self.data.close, period=self.p.MA2)
+        self.ma1 = bt.nind.SMA(self.data.close, period=self.p.MA1) #Numba based indicator
+        self.ma2 = bt.nind.SMA(self.data.close, period=self.p.MA2) #Numba based indicator
+
+
+    def notify_order(self, order):
+        if order.status in [order.Submitted, order.Accepted]:  # Order is submitted/accepted
+            return  # Do nothing until the order is completed
+
+        elif order.status in [order.Canceled, order.Margin, order.Rejected]:  # Canceled, Margin, Rejected
+            print('Order was Canceled/Margin/Rejected')
+
+        self.Order = None  # Reset order
+
+
+
+    def next(self):
+        # Use ONLY Long Positions
+        if self.crossover(self.ma1, self.ma2):
+            pos = self.getposition()
+            if pos:
+                self.close(size=pos.size)
+            self.Order = self.buy(size=1)
+        elif self.crossover(self.ma2, self.ma1):
+            pos = self.getposition()
+            if pos:
+                self.close(size=pos.size)
+            # self.Order = self.sell()
+
+    def crossover(self, ma1, ma2):
+        try:
+            return ma1[-1] <= ma2[-1] and ma1[0] > ma2[0]
+        except IndexError:
+            return False
+
+
+
+if __name__ == '__main__':
+    cerebro = bt.Cerebro()
+    cerebro.broker.setcash(1_000_000.0)
+    cerebro.broker.set_shortcash(False)
+    cerebro.broker.setcommission(commission=0.0004, leverage=1) # 0.04% per trade
+
+    start = time.perf_counter()
+    df = pd.read_csv(f"STOCK_M1.csv.zip", sep=";", parse_dates=["Datetime"], index_col=0)
+
+    data = PandasData(dataframe=df, timeframe=bt.TimeFrame.Minutes, compression=1)
+    cerebro.adddata(data, name='STOCK')
+
+    cerebro.addstrategy(SmaCross, )
+
+    results = cerebro.run()
+    end = time.perf_counter()
+    print(f"Execution time for sum_list: {end - start:.4f} seconds\n\n")
+    #print(cerebro.statistics)
+
+

backtrader_next-2.2.1/examples/3_perf_compare/pyproject.toml

@@ -0,0 +1,11 @@
+[project]
+name = "3-perf-compare"
+version = "0.1.0"
+description = "Add your description here"
+readme = "README.md"
+requires-python = ">=3.13"
+dependencies = [
+    "backtesting>=0.6.5",
+    "backtrader>=1.9.78.123",
+    "backtrader-next>=2.1.1",
+]

{backtrader_next-2.1.1 → backtrader_next-2.2.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "backtrader_next"
-version = "2.1.1"
+version = "2.2.1"
 description = "Live Trading and backtesting platform in Python"
 readme = "README.md"
 license = { text = "GPL-3.0-or-later" }