backtrader-next 2.1.1__py3-none-any.whl → 2.2.0__py3-none-any.whl

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/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/version.py

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

{backtrader_next-2.1.1.dist-info → backtrader_next-2.2.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: backtrader_next
-Version: 2.1.1
+Version: 2.2.0
 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.dist-info → backtrader_next-2.2.0.dist-info}/RECORD

@@ -17,7 +17,7 @@ backtrader_next/lineseries.py,sha256=-aNlK6FiOm47-cfyH3oIUDI3awsyEmbyAyAg_o-rETA
 backtrader_next/mathsupport.py,sha256=jc2fTjaf3dWzQ4ZV-ypvVPrHnKnoJbrWLHd-pIhdQ2w,1923
 backtrader_next/metabase.py,sha256=1g18zfwPOQQlL0MVEYI2pQ-W-FQvfJpG071a_Xbn-N4,11136
 backtrader_next/observer.py,sha256=xlR7JCYgEcZuwpgLbORPVccRD6cA5RhlkXAfKjVQjdY,2255
-backtrader_next/order.py,sha256=IYyHAZzia11jZ40D6o2ZoJdU_vzEnUL2ErgOoLOrS2E,24896
+backtrader_next/order.py,sha256=H2pfRnxDwD9eOq0HdirDBKkzaQ3D_VW8axA5YcSMazk,26866
 backtrader_next/position.py,sha256=odBPNNkWVRHZnNY03SqP0TSlhP1I8xoCMHJCuS2rH7E,7445
 backtrader_next/resamplerfilter.py,sha256=z0hqTqbj4nj7gWQPR9qtBk9Iqz8wcqgF3iqL04cMJdA,26141
 backtrader_next/signal.py,sha256=WwhQUu9L35209K3NEv343dvd57-gBGow1yN9VbmvqPM,1899
@@ -28,13 +28,13 @@ backtrader_next/talib.py,sha256=Q9t2V-jgp-7I9vvPg2BuCJi73GOa7B2LfMrAygPi2nc,9100
 backtrader_next/timer.py,sha256=WrY5dpyXpGUOEeOtr_3pjiOldQyiUcXQTBpl8Jd2QCY,7578
 backtrader_next/trade.py,sha256=3AABrbLCxsMubZfenHyONKDCY6j3e-d7bk0ejQPvD8g,11633
 backtrader_next/tradingcal.py,sha256=X4VQ0dojoKgWoOVTd8aYTyvZYiFZV1TALrQ9sWzb9Rg,9903
-backtrader_next/version.py,sha256=1UOF0BNyEf9cJp15SoIPSkFlFw6Q2AeTdv6SbRb2SmQ,1105
+backtrader_next/version.py,sha256=7T7z-LB2VTNCmy6PwRuT-O8G4FwDO4Wti4A4VS9p7PU,1105
 backtrader_next/writer.py,sha256=eDyz3xRsDp1i8WIZrXou6MZ80QHpYBzkf_DAqPGOcAw,7712
 backtrader_next/analyzers/__init__.py,sha256=krHAQhnqyHj0MKGyTIDNqXqqVUTX7dnQeAB1eRwcD9I,1568
 backtrader_next/analyzers/annualreturn.py,sha256=iIuQAE0nacVEPMyc1JUqIsfkWOG_8kwW104FlXvYd0s,2784
 backtrader_next/analyzers/calmar.py,sha256=eyfIxodGigJ_BgAhDKC8R9SctGsdUMK9K0WagFVviTM,3826
 backtrader_next/analyzers/drawdown.py,sha256=cHE5_SMuxYQN7WXDQ9SOyEWZcXRWUV_1QJuqHUcKV1w,6523
-backtrader_next/analyzers/eq.py,sha256=vnbvqYHIAzMqca7UhLy8TY10ze9lvt98yDUxqZ2qUE4,15877
+backtrader_next/analyzers/eq.py,sha256=SKd-0jNiBXTnelocjewaH-bGoe5WfG-OWYrH4fiSiho,15245
 backtrader_next/analyzers/leverage.py,sha256=XjEp6AvSJuALYyIFCLX9U1nZohJ9KmOQmHTxIT4myLY,2402
 backtrader_next/analyzers/logreturnsrolling.py,sha256=DJimm1ywT2moXVgu27zB-hOrtyA5s1hkQ_et5PYlCwU,5025
 backtrader_next/analyzers/periodstats.py,sha256=-i1_wTtsLn-pBNDBpYQSdyx-2zxFmsGhaczTSgW9N0g,3570
@@ -201,7 +201,7 @@ backtrader_next/utils/dateintern.py,sha256=VcFWhMw_NazuVMHSvSueNgMxRqiEgu5YmRnz5
 backtrader_next/utils/flushfile.py,sha256=ekrNdFCs0j4HwRRxho-Fnl0XZBCrpd0uHyq02kV2wjE,1588
 backtrader_next/utils/ordereddefaultdict.py,sha256=8y7FDnqI1mTcr1NwVfgqsaK-42XwC76Mu_iYRVvLmLM,2091
 backtrader_next/utils/py3.py,sha256=hSoodWo9-eUXzUCcLoQWPtTR51QxD-m01QzZNcuK9A8,2416
-backtrader_next-2.1.1.dist-info/METADATA,sha256=8E6A61lvfRKsmpXjTGpX0LBGT17zw8PQC-Xub-aLCXQ,10774
-backtrader_next-2.1.1.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-backtrader_next-2.1.1.dist-info/licenses/LICENSE,sha256=4cCtcomD2KVzNeUs8QZPGv_R1FQXPYzr0-2LSnK0hwQ,35121
-backtrader_next-2.1.1.dist-info/RECORD,,
+backtrader_next-2.2.0.dist-info/METADATA,sha256=YIWlou26cB6I2rGP2jmH9AsF7EJM4cE9gBhKkhceORE,11359
+backtrader_next-2.2.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+backtrader_next-2.2.0.dist-info/licenses/LICENSE,sha256=4cCtcomD2KVzNeUs8QZPGv_R1FQXPYzr0-2LSnK0hwQ,35121
+backtrader_next-2.2.0.dist-info/RECORD,,