rqalpha 5.3.7__tar.gz → 5.3.9__tar.gz

{rqalpha-5.3.7/rqalpha.egg-info → rqalpha-5.3.9}/PKG-INFO

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

{rqalpha-5.3.7 → rqalpha-5.3.9}/rqalpha/_version.py

@@ -8,11 +8,11 @@ import json
 
 version_json = '''
 {
- "date": "2024-03-07T13:57:10+0800",
+ "date": "2024-04-12T18:06:46+0800",
  "dirty": false,
  "error": null,
- "full-revisionid": "598bbf4021485f71cb75b6871997232d926b3a15",
- "version": "5.3.7"
+ "full-revisionid": "9095b0aebd0ed705a38a669b85da16310a714468",
+ "version": "5.3.9"
 }
 '''  # END VERSION_JSON
 

{rqalpha-5.3.7 → rqalpha-5.3.9}/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.7 → rqalpha-5.3.9}/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 = {
@@ -400,3 +400,8 @@ class BaseDataSource(AbstractDataSource):
 
     def get_algo_bar(self, id_or_ins, start_min, end_min, dt):
         raise NotImplementedError("open source rqalpha not support algo order")
+
+    def get_open_auction_volume(self, instrument, dt):
+        # type: (Instrument, datetime.datetime) -> float
+        volume = self.get_open_auction_bar(instrument, dt)['volume']
+        return volume

{rqalpha-5.3.7 → rqalpha-5.3.9}/rqalpha/data/base_data_source/storages.py

@@ -116,7 +116,7 @@ class FutureInfoStore(object):
         order_book_id = instrument.order_book_id
         underlying_symbol = instrument.underlying_symbol
         custom_info = self._custom_data.get(order_book_id) or self._custom_data.get(underlying_symbol)
-        info = self._default_data.get(order_book_id) or self._custom_data.get(underlying_symbol)
+        info = self._default_data.get(order_book_id) or self._default_data.get(underlying_symbol)
         if custom_info:
             info = copy(info) or {}
             info.update(custom_info)

{rqalpha-5.3.7 → rqalpha-5.3.9}/rqalpha/data/bundle.py

@@ -18,17 +18,23 @@ import os
 import pickle
 import re
 from itertools import chain
+from typing import Callable, Optional, List
 
 import h5py
 import numpy as np
+import pandas as pd
 from rqalpha.apis.api_rqdatac import rqdatac
 from rqalpha.utils.concurrent import (ProgressedProcessPoolExecutor,
                                       ProgressedTask)
 from rqalpha.utils.datetime_func import (convert_date_to_date_int,
-                                         convert_date_to_int)
+                                         convert_date_to_int,)
 from rqalpha.utils.exception import RQDatacVersionTooLow
 from rqalpha.utils.i18n import gettext as _
-from rqalpha.utils.logger import system_log, user_system_log
+from rqalpha.utils.logger import system_log
+from rqalpha.const import TRADING_CALENDAR_TYPE
+from rqalpha.utils.functools import lru_cache
+from rqalpha.environment import Environment
+from rqalpha.model.instrument import Instrument
 
 START_DATE = 20050104
 END_DATE = 29991231
@@ -624,3 +630,96 @@ def update_futures_trading_parameters(path, end_date):
         FUTURES_TRADING_PARAMETERS_FIELDS, 
         end_date
     )
+
+
+class AutomaticUpdateBundle(object):
+    def __init__(self, path: str, filename: str, api: Callable, fields: List[str], end_date: datetime.date) -> None:
+        if not os.path.exists(path):
+            os.makedirs(path)
+        self._file = os.path.join(path, filename)
+        self._trading_dates = None
+        self._filename = filename
+        self._api = api
+        self._fields = fields
+        self._end_date = end_date
+        self.updated = []
+        self._env = Environment.get_instance()
+
+    def get_data(self, instrument: Instrument, dt: datetime.date) -> Optional[np.ndarray]:
+        dt = convert_date_to_date_int(dt)
+        data = self._get_data_all_time(instrument)
+        if data is None:
+            return data
+        else:
+            try:
+                data = data[np.searchsorted(data['trading_dt'], dt)]
+            except IndexError:
+                data = None
+            return data
+
+    @lru_cache(128)
+    def _get_data_all_time(self, instrument: Instrument) -> Optional[np.ndarray]:
+        if instrument.order_book_id not in self.updated:
+            self._auto_update_task(instrument)
+            self.updated.append(instrument.order_book_id)
+        with h5py.File(self._file, "r") as h5:
+            data = h5[instrument.order_book_id][:]
+            if len(data) == 0:
+                return None
+        return data
+    
+    def _auto_update_task(self, instrument: Instrument) -> None:
+        """
+        在 rqalpha 策略运行过程中自动更新所需的日线数据
+
+        :param instrument: 合约对象
+        :type instrument: `Instrument`
+        """
+        order_book_id = instrument.order_book_id
+        start_date = START_DATE
+        try:
+            h5 = h5py.File(self._file, "a")
+            if order_book_id in h5:
+                if len(h5[order_book_id][:]) != 0:
+                    last_date = datetime.datetime.strptime(str(h5[order_book_id][-1]['trading_dt']), "%Y%m%d").date()
+                    if last_date >= self._end_date:
+                        return
+                    start_date = self._env.data_proxy._data_source.get_next_trading_date(last_date).date()
+                    if start_date > self._end_date:
+                        return
+            arr = self._get_array(instrument, start_date)
+            if arr is None:
+                if order_book_id not in h5:
+                    arr = np.array([])
+                    h5.create_dataset(order_book_id, data=arr)
+            else:
+                if order_book_id in h5:
+                    data = np.array(
+                        [tuple(i) for i in chain(h5[order_book_id][:], arr)],
+                        dtype=h5[order_book_id].dtype)
+                    del h5[order_book_id]
+                    h5.create_dataset(order_book_id, data=data)
+                else:
+                    h5.create_dataset(order_book_id, data=arr)
+        except OSError as e:
+            raise OSError(_("File {} update failed, if it is using, please update later, "
+                          "or you can delete then update again".format(self._file))) from e 
+        finally:
+            h5.close()
+    
+    def _get_array(self, instrument: Instrument, start_date: datetime.date) -> Optional[np.ndarray]:
+        df = self._api(instrument.order_book_id, start_date, self._end_date, self._fields)
+        if not (df is None or df.empty):
+            df = df[self._fields].loc[instrument.order_book_id] # rqdatac.get_open_auction_info get Futures's data will auto add 'open_interest' and 'prev_settlement'
+            record = df.iloc[0: 1].to_records()
+            dtype = [('trading_dt', 'int')]
+            for field in self._fields:
+                dtype.append((field, record.dtype[field]))
+            trading_dt = self._env.data_proxy._data_source.batch_get_trading_date(df.index)
+            trading_dt = convert_date_to_date_int(trading_dt)
+            arr = np.ones((trading_dt.shape[0], ), dtype=dtype)
+            arr['trading_dt'] = trading_dt
+            for field in self._fields:
+                arr[field] = df[field].values
+            return arr
+        return None

{rqalpha-5.3.7 → rqalpha-5.3.9}/rqalpha/data/data_proxy.py

@@ -185,6 +185,11 @@ class DataProxy(TradingDatesMixin):
                 "datetime", "open", "limit_up", "limit_down", "volume", "total_turnover"
             ]}
         return PartialBarObject(instrument, bar)
+    
+    def get_open_auction_volume(self, order_book_id, dt):
+        instrument = self.instruments(order_book_id)
+        volume = self._data_source.get_open_auction_volume(instrument, dt)
+        return volume
 
     def history(self, order_book_id, bar_count, frequency, field, dt):
         data = self.history_bars(order_book_id, bar_count, frequency,
@@ -321,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.7 → rqalpha-5.3.9}/rqalpha/data/trading_dates_mixin.py

@@ -19,6 +19,7 @@ import datetime
 from typing import Dict, Optional, Union
 
 import pandas as pd
+import numpy as np
 
 from rqalpha.utils.functools import lru_cache
 from rqalpha.const import TRADING_CALENDAR_TYPE
@@ -114,3 +115,11 @@ class TradingDatesMixin(object):
             return trading_dates[pos + 1]
 
         return td
+    
+    def batch_get_trading_date(self, dt_index: pd.DatetimeIndex):
+        # 获取 numpy.array 中所有时间所在的交易日
+        # 认为晚八点后为第二个交易日，认为晚八点至次日凌晨四点为夜盘
+        dt = dt_index - datetime.timedelta(hours=4)
+        trading_dates = self.get_trading_calendar(TRADING_CALENDAR_TYPE.EXCHANGE)
+        pos = trading_dates.searchsorted(dt.date) + np.where(dt.hour >= 16, 1, 0)
+        return trading_dates[pos]

{rqalpha-5.3.7 → rqalpha-5.3.9}/rqalpha/environment.py

@@ -18,19 +18,22 @@
 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):
     _env = None  # type: Environment
 
-    def __init__(self, config):
+    def __init__(self, config, rqdatac_init):
         Environment._env = self
         self.config = config
         self.data_proxy = None  # type: Optional[rqalpha.data.data_proxy.DataProxy]
@@ -55,6 +58,7 @@ class Environment(object):
         self._frontend_validators = {}  # type: Dict[str, List]
         self._default_frontend_validators = []
         self._transaction_cost_decider_dict = {}
+        self.rqdatac_init = rqdatac_init # type: Boolean
 
         # Environment.event_bus used in StrategyUniverse()
         from rqalpha.core.strategy_universe import StrategyUniverse
@@ -113,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
 
@@ -123,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()
@@ -178,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.7 → rqalpha-5.3.9}/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
@@ -347,6 +349,20 @@ class AbstractDataSource(object):
             datetime, open, limit_up, limit_down, volume, total_turnover
         """
         raise NotImplementedError
+    
+    def get_open_auction_volume(self, instrument, dt):
+        """
+        获取指定资产当日的集合竞价成交量
+
+        :param instrument: 合约对象
+        :type instrument: class:`~Instrument`
+
+        :param dt: 集合竞价时间
+        :type dt: datetime.datetime
+
+        :return: `float`
+        """
+        raise NotImplementedError
 
     def get_settle_price(self, instrument, date):
         """
@@ -635,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.7 → rqalpha-5.3.9}/rqalpha/main.py

@@ -122,12 +122,14 @@ def init_rqdatac(rqdatac_uri):
         init_rqdatac_env(rqdatac_uri)
         try:
             rqdatac.init()
+            return True
         except Exception as e:
             system_log.warn(_('rqdatac init failed, some apis will not function properly: {}').format(str(e)))
+            return
 
 
 def run(config, source_code=None, user_funcs=None):
-    env = Environment(config)
+    env = Environment(config, init_rqdatac(getattr(config.base, 'rqdatac_uri', None)))
     persist_helper = None
     init_succeed = False
     mod_handler = ModHandler()
@@ -136,7 +138,6 @@ def run(config, source_code=None, user_funcs=None):
         # avoid register handlers everytime
         # when running in ipython
         set_loggers(config)
-        init_rqdatac(getattr(config.base, 'rqdatac_uri', None))
         system_log.debug("\n" + pformat(config.convert_to_dict()))
 
         env.set_strategy_loader(init_strategy_loader(env, source_code, user_funcs, config))

{rqalpha-5.3.7 → rqalpha-5.3.9}/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.7 → rqalpha-5.3.9}/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.7 → rqalpha-5.3.9}/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.7 → rqalpha-5.3.9}/rqalpha/mod/rqalpha_mod_sys_accounts/position_model.py

@@ -318,6 +318,12 @@ class FuturePosition(Position):
             user_system_log.warn(_(u"{order_book_id} is expired, close all positions by system").format(
                 order_book_id=self._order_book_id
             ))
+            account = self._env.get_account(self._order_book_id)
+            side = SIDE.SELL if self.direction == POSITION_DIRECTION.LONG else SIDE.BUY
+            trade = Trade.__from_create__(
+                None, self.last_price, self._quantity, side, POSITION_EFFECT.CLOSE, self._order_book_id
+            )
+            self._env.event_bus.publish_event(Event(EVENT.TRADE, account=account, trade=trade, order=None))
             self._quantity = self._old_quantity = 0
         return delta_cash