rqalpha 5.3.6__tar.gz → 5.3.8__tar.gz

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

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

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

@@ -8,11 +8,11 @@ import json
 
 version_json = '''
 {
- "date": "2024-02-26T14:19:56+0800",
+ "date": "2024-03-27T18:19:51+0800",
  "dirty": false,
  "error": null,
- "full-revisionid": "402b725ee25e325490fbe89deaf97cf061f94d47",
- "version": "5.3.6"
+ "full-revisionid": "7322d2b4d1da97bcde04288d0bd114624dc4c6d2",
+ "version": "5.3.8"
 }
 '''  # END VERSION_JSON
 

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

@@ -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.6 → rqalpha-5.3.8}/rqalpha/data/base_data_source/storages.py

@@ -100,14 +100,15 @@ class FutureInfoStore(object):
     
     def _to_namedtuple(self, info):
         # type: (dict) -> FuturesTradingParameters
-        info['long_margin_ratio'], info['short_margin_ratio'] = info['margin_rate'], info['margin_rate']
-        del info['margin_rate'], info['tick_size']
+        futures_info = copy(info)
+        futures_info['long_margin_ratio'], futures_info['short_margin_ratio'] = futures_info['margin_rate'], futures_info['margin_rate']
+        del futures_info['margin_rate'], futures_info['tick_size']
         try:
-            del info['order_book_id']
+            del futures_info['order_book_id']
         except KeyError:
-            del info['underlying_symbol']
-        info = FuturesTradingParameters(**info)
-        return info
+            del futures_info['underlying_symbol']
+        futures_info = FuturesTradingParameters(**futures_info)
+        return futures_info
     
     @lru_cache(8)
     def get_tick_size(self, instrument):
@@ -115,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.6 → rqalpha-5.3.8}/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
@@ -519,10 +525,10 @@ class FuturesTradingParametersTask(object):
         if recreate_futures_list:
             self.generate_futures_trading_parameters(path, fields, last_date, recreate_futures_list=recreate_futures_list)
         if end_date > last_date:
-            system_log.info(_("Futures historical trading parameters data is being updated, please wait......"))
             if rqdatac.get_previous_trading_date(end_date) == last_date:
                 return
             else:
+                system_log.info(_("Futures historical trading parameters data is being updated, please wait......"))
                 start_date = rqdatac.get_next_trading_date(last_date)
                 df = rqdatac.futures.get_trading_parameters(self._order_book_ids, start_date, end_date, fields)
                 if not(df is None or df.empty):
@@ -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.6 → rqalpha-5.3.8}/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,

{rqalpha-5.3.6 → rqalpha-5.3.8}/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.6 → rqalpha-5.3.8}/rqalpha/environment.py

@@ -30,7 +30,7 @@ from rqalpha.utils.i18n import gettext as _
 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 +55,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

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

@@ -347,6 +347,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):
         """

{rqalpha-5.3.6 → rqalpha-5.3.8}/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.6 → rqalpha-5.3.8}/rqalpha/mod/rqalpha_mod_sys_accounts/position_model.py

@@ -191,9 +191,13 @@ class StockPosition(Position):
             round_lot = self._instrument.round_lot
             amount = int(Decimal(amount) / Decimal(round_lot)) * round_lot
             if amount > 0:
-                self.apply_trade(Trade.__from_create__(
+                account = self._env.get_account(self._order_book_id)
+                trade = Trade.__from_create__(
                     None, last_price, amount, SIDE.BUY, POSITION_EFFECT.OPEN, self._order_book_id
-                ))
+                )
+                trade._commission = self._env.get_trade_commission(trade)
+                trade._tax = self._env.get_trade_tax(trade)
+                self._env.event_bus.publish_event(Event(EVENT.TRADE, account=account, trade=trade, order=None))
             return dividend_value - amount * last_price
         else:
             return dividend_value
@@ -314,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
     

{rqalpha-5.3.6 → rqalpha-5.3.8}/rqalpha/mod/rqalpha_mod_sys_simulation/matcher.py

@@ -85,7 +85,7 @@ class DefaultBarMatcher(AbstractMatcher):
 
     def _get_bar_volume(self, order, open_auction=False):
         if open_auction:
-            volume = self._env.data_proxy.get_open_auction_bar(order.order_book_id, self._env.trading_dt).volume
+            volume = self._env.data_proxy.get_open_auction_volume(order.order_book_id, self._env.trading_dt)
         else:
             if isinstance(order.style, ALGO_ORDER_STYLES):
                 _, volume = self._env.data_proxy.get_algo_bar(order.order_book_id, order.style, self._env.calendar_dt)

{rqalpha-5.3.6 → rqalpha-5.3.8}/rqalpha/utils/testing/fixtures.py

@@ -26,7 +26,7 @@ class EnvironmentFixture(RQAlphaFixture):
         from rqalpha.environment import Environment
 
         super(EnvironmentFixture, self).init_fixture()
-        self.env = Environment(RqAttrDict(self.env_config))
+        self.env = Environment(RqAttrDict(self.env_config), False)
 
     @contextmanager
     def mock_env_method(self, name, mock_method):

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

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

{rqalpha-5.3.6 → rqalpha-5.3.8}/rqalpha.egg-info/SOURCES.txt

@@ -157,9 +157,11 @@ rqalpha/utils/translations/zh_Hans_CN/LC_MESSAGES/messages.mo
 rqalpha/utils/translations/zh_Hans_CN/LC_MESSAGES/messages.po
 tests/__init__.py
 tests/test_f_buy_and_hold.py
+tests/test_f_delivery.py
 tests/test_f_macd.py
 tests/test_f_macd_signal.py
 tests/test_f_mean_reverting.py
+tests/test_f_tick_size.py
 tests/test_s_buy_and_hold.py
 tests/test_s_dual_thrust.py
 tests/test_s_pit_tax.py
@@ -196,6 +198,8 @@ tests/unittest/__init__.py
 tests/unittest/test_data/__init__.py
 tests/unittest/test_data/test_instrument_mixin.py
 tests/unittest/test_data/test_trading_dates_mixin.py
+tests/unittest/test_data/test_auto_update_bundle/__init__.py
+tests/unittest/test_data/test_auto_update_bundle/test_auto_update_bundle_mixin.py
 tests/unittest/test_mod/__init__.py
 tests/unittest/test_mod/test_sys_simulation/__init__.py
 tests/unittest/test_mod/test_sys_simulation/test_simulation_event_source.py

{rqalpha-5.3.6 → rqalpha-5.3.8}/setup.cfg

@@ -1,6 +1,6 @@
 [metadata]
 name = rqalpha
-version = 5.3.6
+version = 5.3.8
 
 [versioneer]
 VCS = git

{rqalpha-5.3.6 → rqalpha-5.3.8}/tests/api_tests/mod/sys_simulation/test_simulation_broker.py

@@ -43,6 +43,9 @@ __config__ = {
 
 def test_open_auction_match():
     __config__ = {
+        "base": {
+            "auto_update_bundle": False,
+        },
         "mod": {
             "sys_simulation": {
                 "volume_limit": True,

rqalpha-5.3.8/tests/test_f_delivery.py

@@ -0,0 +1,42 @@
+import datetime
+
+def init(context):
+    context.f1 = "IH2402"
+    context.f2 = "IC2402"
+    context.fired = False
+
+
+def handle_bar(context, bar_dict):
+    if not context.fired:
+        buy_open(context.f1, 3)
+        sell_open(context.f2, 3)
+        context.fired = True
+    if bar_dict._dt.date() == datetime.date(2024, 2, 19):
+        context.cash_before_delivery = context.portfolio.cash
+        context.daily_pnl = context.portfolio.daily_pnl
+    if bar_dict._dt.date() == datetime.date(2024, 2, 20):
+        assert get_position(context.f1).quantity == 0
+        assert get_position(context.f2).quantity == 0
+        assert abs(context.portfolio.cash - (((2363 * 300) + (5105.6 * 200)) * 0.12 * 3 + context.cash_before_delivery + context.daily_pnl)) < 0.0000001
+        assert context.portfolio.total_value == context.portfolio.cash
+
+
+__config__ = {
+    "base": {
+        "start_date": "2024-02-05",
+        "end_date": "2024-02-20",
+        "frequency": "1d",
+        "accounts": {
+            "future": 10000000,
+        },
+    },
+    "extra": {
+        "log_level": "error",
+    },
+    "mod": {
+        "sys_progress": {
+            "enabled":True,
+            "show": True,
+        },
+    },
+}

rqalpha-5.3.8/tests/test_f_tick_size.py

@@ -0,0 +1,67 @@
+from rqalpha.environment import Environment
+
+SLIPPAGE = 10
+price = 0
+futures_1 = "AG1702"  # future_info.json 中存有该合约的数据
+futures_2 = "AG1612"  # future_info.json 中不存在该合约的数据，需要通过 underlying_symbol 获取
+
+
+def init(context):
+    context.count = 0
+
+    subscribe_event(EVENT.TRADE, on_trade)
+
+
+def on_trade(context, event):
+    
+    global price
+    trade = event.trade
+    order_book_id = trade.order_book_id
+    tick_size = Environment.get_instance().get_instrument(order_book_id).tick_size()
+    assert tick_size == 1.0
+    assert trade.last_price == price + tick_size * SLIPPAGE
+
+
+def before_trading(context):
+    pass
+
+
+def handle_bar(context, bar_dict):
+    global price
+    context.count += 1
+    if context.count == 1:
+        price = bar_dict[futures_1].close
+        buy_open(futures_1, 10)
+    elif context.count == 2:
+        price = bar_dict[futures_2].close
+        buy_open(futures_2, 10)
+
+
+def after_trading(context):
+    pass
+
+__config__ = {
+    "base": {
+        "start_date": "2016-09-01",
+        "end_date": "2016-09-30",
+        "frequency": "1d",
+        "matching_type": "current_bar",
+        "accounts": {
+            "future": 1000000
+        }
+    },
+    "extra": {
+        "log_level": "error",
+    },
+    "mod": {
+        "sys_progress": {
+            "enabled": True,
+            "show": True,
+        },
+        "sys_simulation": {
+            "signal": True,
+            "slippage_model": "TickSizeSlippage",
+            "slippage": SLIPPAGE,
+        }
+    },
+}

rqalpha-5.3.8/tests/unittest/test_data/test_auto_update_bundle/__init__.py

@@ -0,0 +1,7 @@
+import os
+
+
+def load_tests(loader, standard_tests, pattern):
+    this_dir = os.path.dirname(__file__)
+    standard_tests.addTests(loader.discover(start_dir=this_dir, pattern=pattern))
+    return standard_tests

rqalpha-5.3.8/tests/unittest/test_data/test_auto_update_bundle/test_auto_update_bundle_mixin.py

@@ -0,0 +1,75 @@
+# -*- coding: utf-8 -*-
+# 版权所有 2019 深圳米筐科技有限公司（下称“米筐科技”）
+#
+# 除非遵守当前许可，否则不得使用本软件。
+#
+#     * 非商业用途（非商业用途指个人出于非商业目的使用本软件，或者高校、研究所等非营利机构出于教育、科研等目的使用本软件）：
+#         遵守 Apache License 2.0（下称“Apache 2.0 许可”），您可以在以下位置获得 Apache 2.0 许可的副本：http://www.apache.org/licenses/LICENSE-2.0。
+#         除非法律有要求或以书面形式达成协议，否则本软件分发时需保持当前许可“原样”不变，且不得附加任何条件。
+#
+#     * 商业用途（商业用途指个人出于任何商业目的使用本软件，或者法人或其他组织出于任何目的使用本软件）：
+#         未经米筐科技授权，任何个人不得出于任何商业目的使用本软件（包括但不限于向第三方提供、销售、出租、出借、转让本软件、本软件的衍生产品、引用或借鉴了本软件功能或源代码的产品或服务），任何法人或其他组织不得出于任何目的使用本软件，否则米筐科技有权追究相应的知识产权侵权责任。
+#         在此前提下，对本软件的使用同样需要遵守 Apache 2.0 许可，Apache 2.0 许可与本许可冲突之处，以本许可为准。
+#         详细的授权流程，请联系 public@ricequant.com 获取。
+
+import os
+import datetime
+import pickle
+import tempfile
+
+from rqalpha.utils.testing import DataProxyFixture, RQAlphaTestCase
+from rqalpha.data.bundle import AutomaticUpdateBundle
+from rqalpha.data.trading_dates_mixin import TradingDatesMixin
+
+
+class AutomaticUpdateBundleTestCase(DataProxyFixture, RQAlphaTestCase):
+    def __init__(self, *args, **kwargs):
+        super(AutomaticUpdateBundleTestCase, self).__init__(*args, **kwargs)
+        self._path = tempfile.TemporaryDirectory().name
+
+    def init_fixture(self):
+        super(AutomaticUpdateBundleTestCase, self).init_fixture()
+        self._auto_update_bundle_module = AutomaticUpdateBundle(
+            path=self._path,
+            filename="open_auction_volume.h5",
+            api=self._mock_get_open_auction_info,
+            fields=['volume'],
+            end_date=datetime.date(2024, 2, 28),
+        )
+        trading_dates_mixin = TradingDatesMixin(self.base_data_source.get_trading_calendars())
+        self.base_data_source.batch_get_trading_date = trading_dates_mixin.batch_get_trading_date
+        self.base_data_source.get_next_trading_date = trading_dates_mixin.get_next_trading_date
+
+    def _mock_get_open_auction_info(self, order_book_id, *args, **kwargs):
+        df = pickle.loads(open(
+            os.path.join(os.path.dirname(__file__), "mock_data/mock_open_auction_info.pkl"), "rb"
+        ).read())
+        df = df.loc[order_book_id].reset_index()
+        df['order_book_id'] = order_book_id
+        df = df.set_index(["order_book_id", "datetime"])
+        return df
+    
+    def _mock_get_open_auction_volume(self, instrument, dt):
+        # type: (Instrument, datetime.date) -> float
+        data = self._auto_update_bundle_module.get_data(instrument, dt)
+        if data is None:
+            volume = 0
+        else:
+            volume = 0 if len(data) == 0 else data['volume']
+        return volume
+
+    def test_auto_update_bundle(self):
+        s_volume = self._mock_get_open_auction_volume(self.env.get_instrument("000001.XSHE"), datetime.date(2023, 12, 28))
+        f_volume = self._mock_get_open_auction_volume(self.env.get_instrument("A2401"), datetime.date(2023, 12, 28))
+        assert os.path.exists(os.path.join(self._path, "open_auction_volume.h5")) == True
+
+        pickle_data = pickle.loads(open(
+            os.path.join(os.path.dirname(__file__), "mock_data/mock_open_auction_info.pkl"), "rb"
+        ).read())
+
+        s_df = pickle_data.loc["000001.XSHE"]
+        assert s_volume == s_df[s_df.index.date == datetime.date(2023, 12, 28)].volume[0]
+        f_df = pickle_data.loc['A2401']
+        # 期货由于有夜盘，open_auction_info 的时间为前一个交易日的晚上，即从 pickle 文件中获取时，date 应该提前一个交易日
+        assert f_volume == f_df[f_df.index.date == datetime.date(2023, 12, 27)].volume[0]
+