rqalpha 5.3.8__tar.gz → 5.3.10__tar.gz

{rqalpha-5.3.8/rqalpha.egg-info → rqalpha-5.3.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: rqalpha
-Version: 5.3.8
+Version: 5.3.10
 Summary: Ricequant Algorithm Trading System
 Home-page: https://github.com/ricequant/rqalpha
 Author: ricequant

{rqalpha-5.3.8 → rqalpha-5.3.10}/rqalpha/_version.py

@@ -8,11 +8,11 @@ import json
 
 version_json = '''
 {
- "date": "2024-03-27T18:19:51+0800",
+ "date": "2024-04-25T10:32:21+0800",
  "dirty": false,
  "error": null,
- "full-revisionid": "7322d2b4d1da97bcde04288d0bd114624dc4c6d2",
- "version": "5.3.8"
+ "full-revisionid": "215d9b2f7ef5175ff99ced5555a81ff7295416c2",
+ "version": "5.3.10"
 }
 '''  # END VERSION_JSON
 

{rqalpha-5.3.8 → rqalpha-5.3.10}/rqalpha/apis/api_base.py

@@ -170,11 +170,8 @@ def submit_order(id_or_ins, amount, side, price=None, position_effect=None):
     style = cal_style(price, None)
     market_price = env.get_last_price(order_book_id)
     if not is_valid_price(market_price):
-        user_system_log.warn(
-            _(u"Order Creation Failed: [{order_book_id}] No market data").format(
-                order_book_id=order_book_id
-            )
-        )
+        reason = _(u"Order Creation Failed: [{order_book_id}] No market data").format(order_book_id=order_book_id)
+        env.order_creation_failed(order_book_id, reason)
         return
 
     amount = int(amount)

{rqalpha-5.3.8 → rqalpha-5.3.10}/rqalpha/data/base_data_source/data_source.py

@@ -42,7 +42,7 @@ from rqalpha.data.base_data_source.storages import (DateSet, DayBarStore, Divide
                        ExchangeTradingCalendarStore, FutureDayBarStore,
                        FutureInfoStore, FuturesTradingParametersStore,InstrumentStore,
                        ShareTransformationStore, SimpleFactorStore,
-                       YieldCurveStore)
+                       YieldCurveStore, FuturesTradingParameters)
 
 
 BAR_RESAMPLE_FIELD_METHODS = {

{rqalpha-5.3.8 → rqalpha-5.3.10}/rqalpha/data/data_proxy.py

@@ -326,5 +326,3 @@ class DataProxy(TradingDatesMixin):
             return np.nan, 0
         bar = self._data_source.get_algo_bar(id_or_ins, order_style.start_min, order_style.end_min, dt)
         return (bar[order_style.TYPE], bar["volume"]) if bar else (np.nan, 0)
-
-

{rqalpha-5.3.8 → rqalpha-5.3.10}/rqalpha/environment.py

@@ -18,13 +18,16 @@
 from datetime import datetime
 from typing import Optional, Dict, List
 from itertools import chain
+from typing import TYPE_CHECKING
 
 import rqalpha
-from rqalpha.core.events import EventBus
+from rqalpha.core.events import EventBus, Event, EVENT
 from rqalpha.const import INSTRUMENT_TYPE
 from rqalpha.utils.logger import system_log, user_log, user_system_log
 from rqalpha.core.global_var import GlobalVars
 from rqalpha.utils.i18n import gettext as _
+if TYPE_CHECKING:
+    from rqalpha.model.order import Order
 
 
 class Environment(object):
@@ -114,9 +117,7 @@ class Environment(object):
         return chain(self._frontend_validators.get(instrument_type, []), self._default_frontend_validators)
 
     def submit_order(self, order):
-        instrument_type = self.data_proxy.instrument(order.order_book_id).type
-        account = self.portfolio.get_account(order.order_book_id)
-        if all(v.can_submit_order(order, account) for v in self._get_frontend_validators(instrument_type)):
+        if self.can_submit_order(order):
             self.broker.submit_order(order)
             return order
 
@@ -124,9 +125,24 @@ class Environment(object):
         instrument_type = self.data_proxy.instrument(order.order_book_id).type
         account = self.portfolio.get_account(order.order_book_id)
         for v in chain(self._frontend_validators.get(instrument_type, []), self._default_frontend_validators):
-            if not v.can_cancel_order(order, account):
-                return False
+            try:
+                reason = v.validate_cancellation(order, account)
+                if reason:
+                    self.order_cancellation_failed(order_book_id=order.order_book_id, reason=reason)
+                    return False
+            except NotImplementedError:
+                # 避免由于某些 mod 版本未更新，Validator method 未修改
+                if not v.can_cancel_order(order, account):
+                    return False
         return True
+    
+    def order_creation_failed(self, order_book_id, reason):
+        user_system_log.warn(reason)
+        self.event_bus.publish_event(Event(EVENT.ORDER_CREATION_REJECT, order_book_id=order_book_id, reason=reason))
+
+    def order_cancellation_failed(self, order_book_id, reason):
+        user_system_log.warn(reason)
+        self.event_bus.publish_event(Event(EVENT.ORDER_CANCELLATION_REJECT, order_book_id=order_book_id, reason=reason))
 
     def get_universe(self):
         return self._universe.get()
@@ -179,11 +195,18 @@ class Environment(object):
         self.calendar_dt = calendar_dt
         self.trading_dt = trading_dt
 
-    def can_submit_order(self, order):
+    def can_submit_order(self, order: 'Order') -> bool:
         # forward compatible
         instrument_type = self.data_proxy.instrument(order.order_book_id).type
         account = self.portfolio.get_account(order.order_book_id)
         for v in self._get_frontend_validators(instrument_type):
-            if not v.can_submit_order(order, account):
-                return False
+            try:
+                reason = v.validate_submission(order, account)
+                if reason:
+                    self.order_creation_failed(order_book_id=order.order_book_id, reason=reason)
+                    return False
+            except NotImplementedError:
+                # 避免由于某些 mod 版本未更新，Validator method 未修改
+                if not v.can_submit_order(order, account):
+                    return False
         return True

{rqalpha-5.3.8 → rqalpha-5.3.10}/rqalpha/interface.py

@@ -17,7 +17,9 @@
 
 import abc
 from datetime import datetime, date
-from typing import Any, Union, Optional, Iterable, Dict, List, Sequence
+from typing import Any, Union, Optional, Iterable, Dict, List, Sequence, TYPE_CHECKING
+if TYPE_CHECKING:
+    from rqalpha.portfolio.account import Account
 
 import numpy
 from six import with_metaclass
@@ -649,18 +651,21 @@ class AbstractFrontendValidator(with_metaclass(abc.ABCMeta)):
 
     扩展模块可以通过 env.add_frontend_validator 添加自定义的前端风控逻辑
     """
-
     @abc.abstractmethod
-    def can_submit_order(self, order, account=None):
+    def validate_submission(self, order: Order, account: Optional['Account'] = None) -> Optional[str]:
         """
-        判断是否可以下单
+        进行下单前的验证，若通过则返回 None
+
+        :return: `Optional[str]`
         """
         raise NotImplementedError
-
+    
     @abc.abstractmethod
-    def can_cancel_order(self, order, account=None):
+    def validate_cancellation(self, order: Order, account: Optional['Account'] = None) -> Optional[str]:
         """
-        判读是否可以撤单
+        进行撤销订单前的验证，若通过则返回 None
+
+        :return: `Optional[str]`
         """
         raise NotImplementedError
 

{rqalpha-5.3.8 → rqalpha-5.3.10}/rqalpha/mod/rqalpha_mod_sys_accounts/api/api_future.py

@@ -47,9 +47,10 @@ def _submit_order(id_or_ins, amount, side, position_effect, style):
 
     amount = int(amount)
     if amount == 0:
-        user_system_log.warn(_(
-            u"Order Creation Failed: 0 order quantity, order_book_id={order_book_id}"
-        ).format(order_book_id=order_book_id))
+        reason = _(u"Order Creation Failed: 0 order quantity, order_book_id={order_book_id}").format(
+            order_book_id=order_book_id
+        )
+        env.order_creation_failed(order_book_id=order_book_id, reason=reason)
         return None
     if isinstance(style, LimitOrder) and np.isnan(style.get_limit_price()):
         raise RQInvalidArgument(_(u"Limit order price should not be nan."))
@@ -62,23 +63,21 @@ def _submit_order(id_or_ins, amount, side, position_effect, style):
 
     price = env.get_last_price(order_book_id)
     if not is_valid_price(price):
-        user_system_log.warn(
-            _(u"Order Creation Failed: [{order_book_id}] No market data").format(order_book_id=order_book_id)
-        )
+        reason = _(u"Order Creation Failed: [{order_book_id}] No market data").format(order_book_id=order_book_id)
+        env.order_creation_failed(order_book_id=order_book_id, reason=reason)
         return
 
-    env = Environment.get_instance()
-
     orders = []
     if position_effect in (POSITION_EFFECT.CLOSE_TODAY, POSITION_EFFECT.CLOSE):
         direction = POSITION_DIRECTION.LONG if side == SIDE.SELL else POSITION_DIRECTION.SHORT
         position = env.portfolio.get_position(order_book_id, direction)  # type: Position
         if position_effect == POSITION_EFFECT.CLOSE_TODAY:
             if amount > position.today_closable:
-                user_system_log.warning(_(
+                reason = _(
                     "Order Creation Failed: "
-                    "close today amount {amount} is larger than today closable quantity {quantity}"
-                ).format(amount=amount, quantity=position.today_closable))
+                    "close today amount {amount} is larger than today closable quantity {quantity}").format(
+                        amount=amount, quantity=position.today_closable)
+                env.order_creation_failed(order_book_id=order_book_id, reason=reason)
                 return []
             orders.append(Order.__from_create__(
                 order_book_id, amount, side, style, POSITION_EFFECT.CLOSE_TODAY
@@ -86,10 +85,9 @@ def _submit_order(id_or_ins, amount, side, position_effect, style):
         else:
             quantity, old_quantity = position.quantity, position.old_quantity
             if amount > quantity:
-                user_system_log.warn(_(
-                    u"Order Creation Failed: close amount {amount} is larger than position quantity {quantity}").format(
-                    amount=amount, quantity=quantity
-                ))
+                reason = _(u"Order Creation Failed: close amount {amount} is larger than position quantity {quantity}").format(
+                    amount=amount, quantity=quantity)
+                env.order_creation_failed(order_book_id=order_book_id, reason=reason)
                 return []
             if amount > old_quantity:
                 if old_quantity != 0:

{rqalpha-5.3.8 → rqalpha-5.3.10}/rqalpha/mod/rqalpha_mod_sys_accounts/api/api_stock.py

@@ -34,9 +34,9 @@ from rqalpha.const import (DEFAULT_ACCOUNT_TYPE, EXECUTION_PHASE,
                            INSTRUMENT_TYPE, ORDER_TYPE, POSITION_DIRECTION,
                            POSITION_EFFECT, SIDE)
 from rqalpha.core.execution_context import ExecutionContext
+from rqalpha.core.events import Event, EVENT
 from rqalpha.environment import Environment
-from rqalpha.mod.rqalpha_mod_sys_risk.validators.cash_validator import \
-    is_cash_enough
+from rqalpha.mod.rqalpha_mod_sys_risk.validators.cash_validator import validate_cash
 from rqalpha.model.instrument import IndustryCode as industry_code
 from rqalpha.model.instrument import IndustryCodeItem, Instrument
 from rqalpha.model.instrument import SectorCode as sector_code
@@ -100,8 +100,8 @@ def _submit_order(ins, amount, side, position_effect, style, current_quantity, a
         raise RQInvalidArgument(_(u"Limit order price should not be nan."))
     price = env.data_proxy.get_last_price(ins.order_book_id)
     if not is_valid_price(price):
-        user_system_log.warn(
-            _(u"Order Creation Failed: [{order_book_id}] No market data").format(order_book_id=ins.order_book_id))
+        reason = _(u"Order Creation Failed: [{order_book_id}] No market data").format(order_book_id=ins.order_book_id)
+        env.order_creation_failed(order_book_id=ins.order_book_id, reason=reason)
         return
 
     if (side == SIDE.BUY and current_quantity != -amount) or (side == SIDE.SELL and current_quantity != abs(amount)):
@@ -109,14 +109,13 @@ def _submit_order(ins, amount, side, position_effect, style, current_quantity, a
         amount = _round_order_quantity(ins, amount)
 
     if amount == 0:
-        user_system_log.warn(_(
-            u"Order Creation Failed: 0 order quantity, order_book_id={order_book_id}"
-        ).format(order_book_id=ins.order_book_id))
+        reason = _(u"Order Creation Failed: 0 order quantity, order_book_id={order_book_id}").format(order_book_id=ins.order_book_id)
+        env.order_creation_failed(order_book_id=ins.order_book_id, reason=reason)
         return
     order = Order.__from_create__(ins.order_book_id, abs(amount), side, style, position_effect)
     if side == SIDE.BUY and auto_switch_order_value:
         account, position, ins = _get_account_position_ins(ins)
-        if not is_cash_enough(env, order, account.cash):
+        if validate_cash(env, order, account.cash):
             user_system_log.warn(_(
                 "insufficient cash, use all remaining cash({}) to create order"
             ).format(account.cash))
@@ -129,7 +128,7 @@ def _order_shares(ins, amount, style, quantity, auto_switch_order_value):
     return _submit_order(ins, amount, side, position_effect, style, quantity, auto_switch_order_value)
 
 
-def _order_value(account, position, ins, cash_amount, style):
+def _order_value(account, position, ins, cash_amount, style, zero_amount_as_exception=True):
     env = Environment.get_instance()
     if cash_amount > 0:
         cash_amount = min(cash_amount, account.cash)
@@ -138,9 +137,8 @@ def _order_value(account, position, ins, cash_amount, style):
     else:
         price = env.data_proxy.get_last_price(ins.order_book_id)
         if not is_valid_price(price):
-            user_system_log.warn(
-                _(u"Order Creation Failed: [{order_book_id}] No market data").format(order_book_id=ins.order_book_id)
-            )
+            reason = _(u"Order Creation Failed: [{order_book_id}] No market data").format(order_book_id=ins.order_book_id)
+            env.order_creation_failed(order_book_id=ins.order_book_id, reason=reason)
             return
 
     amount = int(Decimal(cash_amount) / Decimal(price))
@@ -155,9 +153,9 @@ def _order_value(account, position, ins, cash_amount, style):
                 break
             amount -= round_lot
         else:
-            user_system_log.warn(_(
-                u"Order Creation Failed: 0 order quantity, order_book_id={order_book_id}"
-            ).format(order_book_id=ins.order_book_id))
+            if zero_amount_as_exception:
+                reason = _(u"Order Creation Failed: 0 order quantity, order_book_id={order_book_id}").format(order_book_id=ins.order_book_id)
+                env.order_creation_failed(order_book_id=ins.order_book_id, reason=reason)
             return
 
     if amount < 0:
@@ -198,7 +196,7 @@ def stock_order_target_value(id_or_ins, cash_amount, price_or_style=None, price=
         )
     _delta = cash_amount - position.market_value
     _style = open_style if _delta > 0 else close_style
-    return _order_value(account, position, ins, _delta, _style)
+    return _order_value(account, position, ins, _delta, _style, zero_amount_as_exception=False)
 
 
 @order_target_percent.register(INST_TYPE_IN_STOCK_ACCOUNT)
@@ -211,7 +209,7 @@ def stock_order_target_percent(id_or_ins, percent, price_or_style=None, price=No
         )
     _delta = account.total_value * percent - position.market_value
     _style = open_style if _delta > 0 else close_style
-    return _order_value(account, position, ins, _delta, _style)
+    return _order_value(account, position, ins, _delta, _style, zero_amount_as_exception=False)
 
 
 @order.register(INST_TYPE_IN_STOCK_ACCOUNT)
@@ -342,9 +340,8 @@ def order_target_portfolio(
         order_book_id = ins.order_book_id
         last_price = env.data_proxy.get_last_price(order_book_id)
         if not is_valid_price(last_price):
-            user_system_log.warn(
-                _(u"Order Creation Failed: [{order_book_id}] No market data").format(order_book_id=order_book_id)
-            )
+            reason = _(u"Order Creation Failed: [{order_book_id}] No market data").format(order_book_id=order_book_id)
+            env.order_creation_failed(order_book_id=order_book_id, reason=reason)
             continue
 
         price_or_style = price_or_styles.get(ins.order_book_id)
@@ -380,12 +377,10 @@ def order_target_portfolio(
         open_price = _get_order_style_price(order_book_id, open_style)
         close_price = _get_order_style_price(order_book_id, close_style)
         if not (is_valid_price(close_price) and is_valid_price(open_price)):
-            user_system_log.warn(_(
-                "Adjust position of {id_or_ins} Failed: "
-                "Invalid close/open price {close_price}/{open_price}").format(
-                    id_or_ins=order_book_id, close_price=close_price, open_price=open_price
-                )
+            reason = _("Adjust position of {id_or_ins} Failed: Invalid close/open price {close_price}/{open_price}").format(
+                id_or_ins=order_book_id, close_price=close_price, open_price=open_price
             )
+            env.order_creation_failed(order_book_id=order_book_id, reason=reason)
             continue
 
         delta_quantity = (account_value * target_percent / close_price) - current_quantities.get(order_book_id, 0)

{rqalpha-5.3.8 → rqalpha-5.3.10}/rqalpha/mod/rqalpha_mod_sys_accounts/component_validator.py

@@ -13,24 +13,18 @@ class MarginComponentValidator(AbstractFrontendValidator):
         self._margin_type = margin_type
         from rqalpha.apis.api_rqdatac import get_margin_stocks
         self._get_margin_stocks = get_margin_stocks
-
-    def can_cancel_order(self, order, account=None):
-        return True
-
-    def can_submit_order(self, order, account=None):
-        # type: (Order, Optional[Account]) -> bool
-
+        
+    def validate_submission(self, order: Order, account: Optional[Account] = None) -> Optional[str]:
         # 没负债等于没融资，则不需要限制股票池
         if account.cash_liabilities == 0:
-            return True
-
+            return None
         symbols = self._get_margin_stocks(margin_type=self._margin_type)
-
         # 是否在股票池中
         if order.order_book_id in set(symbols):
-            return True
+            return None
         else:
-            user_system_log.warn("Order Creation Failed: margin stock pool not contains {}.".format(
-                order.order_book_id)
-            )
-            return False
+            reason = "Order Creation Failed: margin stock pool not contains {}.".format(order.order_book_id)
+            return reason
+    
+    def validate_cancellation(self, order: Order, account: Optional[Account] = None) -> Optional[str]:
+        return None

{rqalpha-5.3.8 → rqalpha-5.3.10}/rqalpha/mod/rqalpha_mod_sys_accounts/position_validator.py

@@ -27,32 +27,31 @@ from rqalpha.utils.i18n import gettext as _
 
 
 class PositionValidator(AbstractFrontendValidator):
-    def can_cancel_order(self, order, account=None):
-        return True
-
-    def can_submit_order(self, order, account=None):
-        # type: (Order, Optional[Account]) -> bool
+    def validate_cancellation(self, order: Order, account: Optional[Account] = None) -> Optional[str]:
+        return None
+    
+    def validate_submission(self, order: Order, account: Optional[Account] = None) -> Optional[str]:
         if account is None:
-            return True
+            return None
         if order.position_effect in (POSITION_EFFECT.OPEN, POSITION_EFFECT.EXERCISE):
-            return True
+            return None
         position = account.get_position(order.order_book_id, order.position_direction)  # type: AbstractPosition
         if order.position_effect == POSITION_EFFECT.CLOSE_TODAY and order.quantity > position.today_closable:
-            user_system_log.warn(_(
+            reason = _(
                 "Order Creation Failed: not enough today position {order_book_id} to close, target"
                 " quantity is {quantity}, closable today quantity is {closable}").format(
                 order_book_id=order.order_book_id,
                 quantity=order.quantity,
                 closable=position.today_closable,
-            ))
-            return False
+            )
+            return reason
         if order.position_effect == POSITION_EFFECT.CLOSE and order.quantity > position.closable:
-            user_system_log.warn(_(
+            reason = _(
                 "Order Creation Failed: not enough position {order_book_id} to close or exercise, target"
                 " sell quantity is {quantity}, closable quantity is {closable}").format(
                 order_book_id=order.order_book_id,
                 quantity=order.quantity,
                 closable=position.closable,
-            ))
-            return False
-        return True
+            )
+            return reason
+        return None

{rqalpha-5.3.8 → rqalpha-5.3.10}/rqalpha/mod/rqalpha_mod_sys_accounts/validator.py

@@ -9,16 +9,12 @@ from rqalpha.portfolio.account import Account
 class MarginInstrumentValidator(AbstractFrontendValidator):
     """ 融资下单品种限制: 当开启股票池限制且有融资余额时只能交易股票和ETF """
 
-    def can_cancel_order(self, order, account=None):
-        return True
-
-    def can_submit_order(self, order, account=None):
-        # type: (Order, Optional[Account]) -> bool
-
+    def validate_submission(self, order: Order, account: Optional[Account] = None) -> Optional[str]:
         if account.cash_liabilities > 0:
-            user_system_log.warn("Order Creation Failed: cash liabilities > 0, {} not support submit order".format(
-                order.order_book_id)
-            )
-            return False
+            reason = "Order Creation Failed: cash liabilities > 0, {} not support submit order".format(order.order_book_id)
+            return reason
         else:
-            return True
+            return None
+    
+    def validate_cancellation(self, order: Order, account: Optional[Account] = None) -> Optional[str]:
+        return None

{rqalpha-5.3.8 → rqalpha-5.3.10}/rqalpha/mod/rqalpha_mod_sys_analyser/mod.py

@@ -33,6 +33,7 @@ from rqalpha.core.events import EVENT
 from rqalpha.interface import AbstractMod, AbstractPosition
 from rqalpha.utils.i18n import gettext as _
 from rqalpha.utils import INST_TYPE_IN_STOCK_ACCOUNT
+from rqalpha.utils.datetime_func import convert_int_to_date
 from rqalpha.utils.logger import user_system_log
 from rqalpha.const import DAYS_CNT
 from rqalpha.api import export_as_api
@@ -131,23 +132,60 @@ class AnalyserMod(AbstractMod):
                 daily_return_list.append((bar.close / bar.prev_close - 1.0, benchmark[1]))
             weights += benchmark[1]
         return sum([daily[0] * daily[1] / weights for daily in daily_return_list])
-
-    def _subscribe_events(self, event):
-        if self._benchmark:
-            _s = self._env.config.base.start_date
-            _e = self._env.config.base.end_date
-            for order_book_id, weight in self._benchmark:
-                ins = self._env.data_proxy.instrument(order_book_id)
-                if ins is None:
-                    raise RuntimeError(
-                        _("benchmark {} not exists, please entry correct order_book_id").format(order_book_id)
-                    )
-                if ins.listed_date.date() > _s or ins.de_listed_date.date() <= _e:
-                    raise RuntimeError(
-                        _("benchmark {} listed date {} > backtest start date {} or de_listed date {} <= backtest end "
-                          "date {}").format(order_book_id, ins.listed_date.date(), _s, ins.de_listed_date.date(), _e)
+    
+    def generate_benchmark_daily_returns_and_portfolio(self, event):
+        _s = self._env.config.base.start_date
+        _e = self._env.config.base.end_date
+        trading_dates = self._env.data_proxy.get_trading_dates(_s, _e)
+        if self._benchmark is None:
+            self._benchmark_daily_returns = list(np.full(len(trading_dates), np.nan))
+            return
+        
+        # generate benchmerk daily returns
+        self._benchmark_daily_returns = np.zeros(len(trading_dates))
+        weights = 0
+        for order_book_id, weight in self._benchmark:
+            ins = self._env.data_proxy.instrument(order_book_id)
+            if ins is None:
+                raise RuntimeError(
+                    _("benchmark {} not exists, please entry correct order_book_id").format(order_book_id)
+                )
+            bars = self._env.data_proxy.history_bars(
+                order_book_id = order_book_id,
+                bar_count = len(trading_dates) + 1,  # Get an extra day for calculation
+                frequency = "1d",
+                field = ["datetime", "close"],
+                dt = _e,
+                skip_suspended=False,
+            )
+            if len(bars) == len(trading_dates) + 1:
+                if convert_int_to_date(bars[1]['datetime']).date() != _s:
+                    raise RuntimeError(_(
+                        "benchmark {} missing data between backtest start date {} and end date {}").format(order_book_id, _s, _e)
                     )
+                daily_returns = (bars['close'] / np.roll(bars['close'], 1) - 1.0)[1: ]
+                self._benchmark_daily_returns = self._benchmark_daily_returns + daily_returns * weight
+                weights += weight
+            else:
+                if len(bars) == 0:
+                    (available_s, available_e) = (ins.listed_date, ins.de_listed_date)
+                else:
+                    (available_s, available_e) = (convert_int_to_date(bars[0]['datetime']).date(), convert_int_to_date(bars[-1]['datetime']).date())
+                raise RuntimeError(
+                    _("benchmark {} available data start date {} >= backtest start date {} or end date {} <= backtest end "
+                    "date {}").format(order_book_id, available_s, _s, available_e, _e)
+                )
+        self._benchmark_daily_returns = self._benchmark_daily_returns / weight
+        
+        # generate benchmark portfolio
+        unit_net_value = (self._benchmark_daily_returns + 1).cumprod()
+        self._total_benchmark_portfolios = {
+            "date": trading_dates,
+            "unit_net_value": unit_net_value
+        }
 
+    def _subscribe_events(self, event):
+        self._env.event_bus.add_listener(EVENT.BEFORE_STRATEGY_RUN, self.generate_benchmark_daily_returns_and_portfolio)
         self._env.event_bus.add_listener(EVENT.TRADE, self._collect_trade)
         self._env.event_bus.add_listener(EVENT.ORDER_CREATION_PASS, self._collect_order)
         self._env.event_bus.prepend_listener(EVENT.POST_SETTLEMENT, self._collect_daily)
@@ -164,11 +202,6 @@ class AnalyserMod(AbstractMod):
 
         self._portfolio_daily_returns.append(portfolio.daily_returns)
         self._total_portfolios.append(self._to_portfolio_record(date, portfolio))
-        self._benchmark_daily_returns.append(self.get_benchmark_daily_returns())
-        self._total_benchmark_portfolios.append({
-            "date": date,
-            "unit_net_value": (np.array(self._benchmark_daily_returns) + 1).prod()
-        })
         self._daily_pnl.append(portfolio.daily_pnl)
 
         for account_type, account in self._env.portfolio.accounts.items():

{rqalpha-5.3.8 → rqalpha-5.3.10}/rqalpha/mod/rqalpha_mod_sys_analyser/report/excel_template.py

@@ -70,9 +70,10 @@ class VerticalSeriesSchema(SheetSchema):
         if not data:
             for key, (row, column, style) in self._cell_map.items():
                 self._write_cell(ws, row, column, None, style)
-        for key, (row, column, style) in self._cell_map.items():
-            for i, item in enumerate(data.get(key, [])):
-                self._write_cell(ws, row + i, column, item, style)
+        else:
+            for key, (row, column, style) in self._cell_map.items():
+                for i, item in enumerate(data.get(key, [])):
+                    self._write_cell(ws, row + i, column, item, style)
 
 
 class SummaryTemplate(ExcelTemplate):
@@ -83,6 +84,7 @@ class SummaryTemplate(ExcelTemplate):
         "月度收益": VerticalSeriesSchema,
         "月度超额收益（几何）": VerticalSeriesSchema,
         "个股权重": VerticalSeriesSchema,
+        "压力测试": VerticalSeriesSchema,
     }