仅在交易时段内撮合

rqalpha/mod/rqalpha_mod_sys_simulation/signal_broker.py

@@ -24,10 +24,11 @@
 from rqalpha.utils.logger import user_system_log
 from rqalpha.utils.i18n import gettext as _
 from rqalpha.utils import is_valid_price
+from rqalpha.core.execution_context import ExecutionContext
 from rqalpha.core.events import EVENT, Event
 from rqalpha.model.trade import Trade
 from rqalpha.model.order import ALGO_ORDER_STYLES
-from rqalpha.const import SIDE, ORDER_TYPE, POSITION_EFFECT
+from rqalpha.const import SIDE, ORDER_TYPE, POSITION_EFFECT, EXECUTION_PHASE
 
 from .slippage import SlippageDecider
 
@@ -37,9 +38,11 @@ def __init__(self, env, mod_config):
         self._env = env
         self._slippage_decider = SlippageDecider(mod_config.slippage_model, mod_config.slippage)
         self._price_limit = mod_config.price_limit
+        self._open_orders = []
+        self._env.event_bus.add_listener(EVENT.BAR, self.on_bar)
 
     def get_open_orders(self, order_book_id=None):
-        return []
+        return [order for _, order in self._open_orders]
 
     def submit_order(self, order):
         if order.position_effect == POSITION_EFFECT.EXERCISE:
@@ -50,12 +53,23 @@ def submit_order(self, order):
             return
         order.active()
         self._env.event_bus.publish_event(Event(EVENT.ORDER_CREATION_PASS, account=account, order=order))
-        self._match(account, order)
+        instrument = self._env.data_proxy.instrument(order.order_book_id)
+        if ExecutionContext.phase() == EXECUTION_PHASE.ON_BAR and not instrument.during_continuous_auction(self._env.calendar_dt):
+            self._open_orders.append((account, order))
+        else:
+            self._match(account, order)
 
     def cancel_order(self, order):
         user_system_log.warn(_(u"cancel_order function is not supported in signal mode"))
         return None
 
+    def on_bar(self, event):
+        for account, order in self._open_orders:
+            instrument = self._env.data_proxy.instrument(order.order_book_id)
+            if not order.is_final() and instrument.during_continuous_auction(self._env.calendar_dt):
+                self._match(account, order)
+        self._open_orders = [(a, o) for a, o in self._open_orders if not o.is_final()]
+
     def _match(self, account, order):
         order_book_id = order.order_book_id
         price_board = self._env.price_board

rqalpha/mod/rqalpha_mod_sys_simulation/simulation_broker.py

@@ -166,8 +166,16 @@ def on_tick(self, event):
         self._match(tick.order_book_id)
 
     def _match(self, order_book_id=None):
-        order_filter = lambda a_and_o: not (a_and_o[1].is_final() or (order_book_id and a_and_o[1].order_book_id != order_book_id))
-        for account, order in filter(order_filter, self._open_orders):
+        order_filter = lambda a_and_o: all([
+            not a_and_o[1].is_final(),                                                          # 订单未完成
+            True if order_book_id is None else a_and_o[1].order_book_id == order_book_id,       # 只撮合指定的订单
+        ])
+        open_order_filter = lambda a_and_o: all([
+            order_filter(a_and_o),
+            # 得在交易时段内
+            self._env.data_proxy.instrument(a_and_o[1].order_book_id).during_continuous_auction(self._env.calendar_dt)
+        ])
+        for account, order in filter(open_order_filter, self._open_orders):
             self._get_matcher(order.order_book_id).match(account, order, open_auction=False)
         for account, order in filter(order_filter, self._open_auction_orders):
             self._get_matcher(order.order_book_id).match(account, order, open_auction=True)

rqalpha/model/instrument.py

@@ -375,6 +375,13 @@ def trading_hours(self):
                 trading_period.append(TimeRange(start, end))
         return trading_period
 
+    def during_continuous_auction(self, dt):
+        """ 是否处于连续竞价时间段内 """
+        for time_range in self.trading_hours:
+            if time_range.start <= dt.time() <= time_range.end:
+                return True
+        return False
+
     @property
     def trading_code(self):
         # type: () -> str