def __init__(self, redis_url): super(AbstractIndayBars, self).__init__() if not (redis_url.startswith("redis://") or redis_url.startswith("tcp://")): redis_url = "redis://" + redis_url.splits("//")[-1] system_log.info("Connected to Redis on: %s" % redis_url) self._client = RedisClient(redis_url)
def clock_worker(self): data_proxy = self._env.data_proxy while True: # wait for the first data ready if data_proxy.current_snapshot("000001.XSHG", None, None).datetime.date() == datetime.date.today(): system_log.info(_("Market data is ready, start to work now!")) break time.sleep(0.1) while True: time.sleep(self.fps) if is_holiday_today(): time.sleep(60) continue dt = datetime.datetime.now() if dt.strftime("%H:%M:%S") >= "08:30:00" and dt.date() > self.before_trading_fire_date: self.event_queue.put((dt, EVENT.BEFORE_TRADING)) self.before_trading_fire_date = dt.date() elif dt.strftime("%H:%M:%S") >= "15:10:00" and dt.date() > self.after_trading_fire_date: self.event_queue.put((dt, EVENT.AFTER_TRADING)) self.after_trading_fire_date = dt.date() elif dt.strftime("%H:%M:%S") >= "15:10:00" and dt.date() > self.settlement_fire_date: self.event_queue.put((dt, EVENT.SETTLEMENT)) self.settlement_fire_date = dt.date() if is_tradetime_now(): self.event_queue.put((dt, EVENT.BAR))
def start_up(self, env, mod_config): env.set_price_board(StockLimitUpDownPriceBoard()) type_ = DataSourceType(mod_config.source) if type_ in [DataSourceType.MONGO, DataSourceType.REAL_TIME]: args = (env.config.base.data_bundle_path, mod_config.mongo_url) data_source_cls = MongoCacheDataSource if mod_config.enable_cache else MongoDataSource elif type_ == DataSourceType.BUNDLE: args = (env.config.base.data_bundle_path, mod_config.bundle_path) data_source_cls = BundleCacheDataSource if mod_config.enable_cache else BundleDataSource else: raise RuntimeError("data source type [%s] is not supported" % mod_config.source) if mod_config.enable_cache: if mod_config.cache_length: CacheMixin.set_cache_length(int(mod_config.cache_length)) if mod_config.max_cache_space: CacheMixin.set_cache_length(int(mod_config.cache_length)) data_source = data_source_cls(*args) mod_config.redis_uri = mod_config.redis_url # fit rqalpha if env.config.base.run_type is RUN_TYPE.BACKTEST and env.config.base.persist_mode == PERSIST_MODE.ON_NORMAL_EXIT: # generate user context using backtest persist_provider = DiskPersistProvider(mod_config.persist_path) env.set_persist_provider(persist_provider) is_real_time = env.config.base.run_type in (RUN_TYPE.PAPER_TRADING, RUN_TYPE.LIVE_TRADING) if is_real_time or type_ == DataSourceType.REAL_TIME: user_system_log.warn( _("[Warning] When you use this version of RealtimeTradeMod, history_bars can only " "get data from yesterday.")) if mod_config.redis_url: data_source = RedisDataSource(env.config.base.data_bundle_path, mod_config.redis_url, datasource=data_source) system_log.info(_("RealtimeTradeMod using market from redis")) else: data_source = DirectDataSource( env.config.base.data_bundle_path) system_log.info( _("RealtimeTradeMod using market from network")) if is_real_time: event_source = RealTimeEventSource(mod_config.fps, mod_config) # add persist persist_provider = DiskPersistProvider(mod_config.persist_path) env.set_persist_provider(persist_provider) env.config.base.persist = True env.config.base.persist_mode = PERSIST_MODE.REAL_TIME else: event_source = IntervalEventSource(env) env.set_data_source(data_source) # a patch to start_date since it's real time mod if env.config.base.start_date == datetime.now().date(): trading_dates = data_source.get_trading_calendar() pos = trading_dates.searchsorted(env.config.base.start_date) if trading_dates[pos].to_pydatetime().date( ) != env.config.base.start_date: env.config.base.start_date = trading_dates[max( 0, pos - 1)].to_pydatetime().date() env.set_event_source(event_source)
def start_up(self, env, mod_config): if mod_config.data_source == 'tushare_pro': apis = [ts.pro_api(token) for token in mod_config.tushare_tokens] env.set_data_source(TushareProDataSource(env, apis)) if mod_config.broker == 'thsauto': env.set_broker(ThsBroker(env, mod_config)) env.set_price_board(McTraderPriceBoard(env)) env.set_data_proxy(DataProxy(env.data_source, env.price_board)) env.set_event_source(McTraderEventSource(env, mod_config)) env.set_persist_provider(McPersistProvider(env, mod_config)) if mod_config.log_file: user_log.handlers = [] user_system_log.handlers = [] user_handler = FileHandler(mod_config.log_file, bubble=True) if not env.config.extra.user_log_disabled: user_log.handlers.append(user_handler) if not env.config.extra.user_system_log_disabled: user_system_log.handlers.append(user_handler) system_log.handlers = [ FileHandler(mod_config.log_file, mode='a', bubble=True) ] basic_system_log.handlers = [ FileHandler(mod_config.log_file, bubble=True) ] system_log.info('\n{}'.format(mod_config))
def start_up(self, env, mod_config): if env.config.base.run_type in (RUN_TYPE.PAPER_TRADING, RUN_TYPE.LIVE_TRADING): user_system_log.warn( _("[Warning] When you use this version of RealtimeTradeMod, history_bars can only get data from yesterday." )) if mod_config.redis_uri: env.set_data_source( RedisDataSource(env.config.base.data_bundle_path, mod_config.redis_uri)) system_log.info(_("RealtimeTradeMod using market from redis")) else: env.set_data_source( DirectDataSource(env.config.base.data_bundle_path)) system_log.info( _("RealtimeTradeMod using market from network")) env.set_event_source( RealtimeEventSource(mod_config.fps, mod_config)) # add persist persist_provider = DiskPersistProvider(mod_config.persist_path) env.set_persist_provider(persist_provider) env.config.base.persist = True env.config.base.persist_mode = PERSIST_MODE.REAL_TIME
def onRspUserLogin(self, data, error, n, last): # 登录后会自动订阅之前已订阅了的合约 super(RqCtpMdApi, self).onRspUserLogin(data, error, n, last) if error['ErrorID'] == 0: system_log.info('CTP行情服务器登录成功') else: system_log.error('CTP行情服务器登录错误,错误代码:%s,错误信息:%s' % (str(error['ErrorID']), error['ErrorMsg'].decode('gbk')))
def __init__(self, path, redis_url, datasource=None): super(RedisDataSource, self).__init__(path) if not (redis_url.startswith("redis://") or redis_url.startswith("tcp://")): redis_url = "redis://" + redis_url.splits("//")[-1] self._history_datasource = datasource system_log.info("Connected to Redis on: %s" % redis_url) self._client = RedisClient(redis_url)
def quotation_server(redis_url): """ [sys_stock_realtime] quotation service, download market data into redis Multiple RQAlpha instance can use single market data service. """ import redis import time import json from .utils import get_realtime_quotes redis_client = redis.from_url(redis_url) from rqalpha.data.data_proxy import DataProxy config = parse_config({}, verify_config=False) data_source = BaseDataSource(config.base.data_bundle_path) data_proxy = DataProxy(data_source) order_book_id_list = sorted(ins.order_book_id for ins in data_proxy.all_instruments("CS")) def record_market_data(total_df): for order_book_id, item in total_df.iterrows(): redis_client[order_book_id] = json.dumps(item.to_dict()) while True: try: total_df = get_realtime_quotes(order_book_id_list, include_limit=True) except Exception as e: system_log.exception("get_realtime_quotes fail. {}", e) continue system_log.info("Fetching snapshots, size {}", len(total_df)) record_market_data(total_df) time.sleep(1)
def onRspUserLogin(self, data, error, n, last): if error['ErrorID'] == 0: self.frontID = str(data['FrontID']) self.sessionID = str(data['SessionID']) self.loginStatus = True self.gateway.tdConnected = True system_log.info('CTP交易服务器登录成功') else: system_log.error('CTP交易服务器登录错误,错误代码:%s,错误信息:%s' % (str(error['ErrorID']), error['ErrorMsg'].decode('gbk')))
def start_up(self, env, mod_config): origin = env.strategy_loader strategy_loader = ShipaneWrappedStrategyLoader(origin) strategy_loader.set_manager_id(mod_config.manager_id) env.set_strategy_loader(strategy_loader) env.event_bus.add_listener(EVENT.POST_SYSTEM_INIT, self.on_post_system_init) for export_name in api.__all__: export_as_api(getattr(api, export_name)) system_log.info("策略实盘易对接完成,策略manager_id为[%s]" % strategy_loader.get_manager_id())
def _init(self, event): env = self._env mod_config = self._mod_config system_log.info("use recorder {}", mod_config.recorder) if mod_config.recorder == "CsvRecorder": if not mod_config.persist_folder: raise RuntimeError( _(u"You need to set persist_folder to use CsvRecorder")) persist_provider = DiskPersistProvider( os.path.join(mod_config.persist_folder, "persist")) self._recorder = recorders.CsvRecorder(mod_config.persist_folder) elif mod_config.recorder == "MongodbRecorder": if mod_config.strategy_id is None: raise RuntimeError(_(u"You need to set strategy_id")) persist_provider = persist_providers.MongodbPersistProvider( mod_config.strategy_id, mod_config.mongo_url, mod_config.mongo_dbname) self._recorder = recorders.MongodbRecorder(mod_config.strategy_id, mod_config.mongo_url, mod_config.mongo_dbname) else: raise RuntimeError( _(u"unknown recorder {}").format(mod_config.recorder)) if env.persist_provider is None: env.set_persist_provider(persist_provider) self._meta = { "strategy_id": mod_config.strategy_id, "origin_start_date": self._env.config.base.start_date.strftime("%Y-%m-%d"), "start_date": self._env.config.base.start_date.strftime("%Y-%m-%d"), "end_date": self._env.config.base.end_date.strftime("%Y-%m-%d"), "last_run_time": datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S"), } persist_meta = self._recorder.load_meta() if persist_meta: if persist_meta["end_date"] >= self._meta["start_date"]: raise RuntimeError( _(u"current start_date {} is before last end_date {}"). format(self._meta["start_date"], persist_meta["end_date"])) else: self._meta["origin_start_date"] = persist_meta[ "origin_start_date"] env.event_bus.add_listener(EVENT.TRADE, self.on_trade) env.event_bus.add_listener(EVENT.POST_SETTLEMENT, self.on_settlement)
def quotation_server(redis_url): """ [stock_realtime] quotation service, download market data into redis Multiple RQAlpha instance can use single market data service. """ import redis import time import json from .utils import get_realtime_quotes redis_client = redis.from_url(redis_url) from rqalpha.environment import Environment from rqalpha.data.data_proxy import DataProxy # 通过 parse_config 函数 获取 默认 data_bundle 的配置 # 由于 parse_config 会进行配置检查,如果没有设置 account 会提示报错,因此随意设置一个股票初始资金,来保证正确获取默认参数配置 config = parse_config({ 'base': { 'accounts': { 'stock': 10000 } } }) Environment(config) data_source = BaseDataSource(config.base.data_bundle_path) data_proxy = DataProxy(data_source) order_book_id_list = sorted(ins.order_book_id for ins in data_proxy.all_instruments("CS")) def record_market_data(total_df): for order_book_id, item in total_df.iterrows(): redis_client[order_book_id] = json.dumps(item.to_dict()) retry_cnt = 0 while True: try: total_df = get_realtime_quotes(order_book_id_list, include_limit=True) except (OSError, IOError) as e: system_log.exception("get_realtime_quotes socket error. retry {} {}", retry_cnt, e) time.sleep(retry_cnt * 2) retry_cnt += 1 continue system_log.info("Fetching snapshots, size {}", len(total_df)) record_market_data(total_df) time.sleep(1) retry_cnt = 0
def init_rqdatac(rqdatac_uri): try: import rqdatac except ImportError: system_log.info( _('rqdatac is not available, some apis will not function properly') ) return try: init_rqdatac_env(rqdatac_uri) rqdatac.init() except ValueError as e: system_log.warn( _('rqdatac init failed, some apis will not function properly: {}'). format(str(e)))
def start_up(self, env, mod_config): self.env = env self.mod_config = mod_config if env.config.base.run_type != RUN_TYPE.LIVE_TRADING: system_log.info("Mod booking will only run in live trading") return if env.config.base.init_positions: raise RuntimeError("RQAlpha receive init positions. rqalpha_mod_sys_booking does not support init_positions") self.booking_account = BookingAccount(register_event=True) # 昨仓 trades = [] position_list = self._get_old_position_list() for position_dict in position_list: if position_dict["buy_quantity"] != 0: trade = self._create_trade( position_dict["order_book_id"], position_dict["buy_quantity"], SIDE.BUY, POSITION_EFFECT.OPEN, ) trades.append(trade) if position_dict["sell_quantity"] != 0: trade = self._create_trade( position_dict["order_book_id"], position_dict["sell_quantity"], SIDE.SELL, POSITION_EFFECT.OPEN, ) trades.append(trade) system_log.info("yesterday positions trades") for trade in trades: system_log.info("trade: {:9}, qtx {}, side {}", trade.order_book_id, trade.last_quantity, trade.side) self.booking_account.fast_forward([], trades=trades) self.booking_account._settlement(None, check_delist=False) # 计算今仓 trades = [] trade_list = self._get_trade_list() for trade_dict in trade_list: trade = self._create_trade( trade_dict["order_book_id"], trade_dict["last_quantity"], SIDE_DICT[trade_dict["side"]], POSITION_EFFECT_DICT[trade_dict["position_effect"]], ) trades.append(trade) system_log.info("today trades: {}", trades) self.booking_account.fast_forward([], trades=trades) env.event_bus.add_listener(EVENT.BEFORE_SYSTEM_RESTORED, self.on_before_system_restore)
def start_up(self, env, mod_config): if env.config.base.run_type in (RUN_TYPE.PAPER_TRADING, RUN_TYPE.LIVE_TRADING): user_system_log.warn(_("[Warning] When you use this version of RealtimeTradeMod, history_bars can only get data from yesterday.")) if mod_config.redis_uri: env.set_data_source(RedisDataSource(env.config.base.data_bundle_path, mod_config.redis_uri)) system_log.info(_("RealtimeTradeMod using market from redis")) else: env.set_data_source(DirectDataSource(env.config.base.data_bundle_path)) system_log.info(_("RealtimeTradeMod using market from network")) env.set_event_source(RealtimeEventSource(mod_config.fps, mod_config)) # add persist persist_provider = DiskPersistProvider(mod_config.persist_path) env.set_persist_provider(persist_provider) env.config.base.persist = True env.config.base.persist_mode = PERSIST_MODE.REAL_TIME
def convert_8code(codes: list or str): # [000001.XSHE, 000702.XSHE]-->[SZ000001, SZ000702] """ 转换为 SH600001 格式 :param codes: :return: """ if len(codes) == 0: return [] if type(codes) == str: codes = [codes] if re.match(stock_format[1], codes[0]): # 600001.XSHG # .XSHE --> SZ codes = list(map(lambda x: little8code(x[6:]) + x[:6], codes)) elif re.match(stock_format[0], codes[0]): # SH600001 pass else: system_log.info(codes) system_log.debug("股票格式不对") return codes
def convert_11code(codes: list or str): """ # 转换为 600001.XSHG 格式 :param self: :param codes: :return: """ if len(codes) == 0: return [] if type(codes) == str: codes = [codes] if re.match(stock_format[1], codes[0]): # 600001.XSHG pass elif re.match(stock_format[0], codes[0]): # SH600001 codes = list(map(lambda x: (x[2:8] + little11code(x[:2])), codes)) else: system_log.info(codes) system_log.debug("股票格式不对") codes.sort() return codes
def start_up(self, env, mod_config): # forward compatible try: order_book_id = mod_config.order_book_id or env.config.base.benchmark except AttributeError: order_book_id = None if not order_book_id: system_log.info("No order_book_id set, BenchmarkMod disabled.") return env.event_bus.add_listener(EVENT.POST_SYSTEM_INIT, lambda e: self._validate_benchmark(order_book_id, env)) if env.config.base.run_type == RUN_TYPE.BACKTEST: from .benchmark_provider import BackTestPriceSeriesBenchmarkProvider as BTProvider env.set_benchmark_provider(BTProvider(order_book_id)) else: from .benchmark_provider import RealTimePriceSeriesBenchmarkProvider as RTProvider env.set_benchmark_provider(RTProvider(order_book_id))
def _init(self, event): env = self._env mod_config = self._mod_config system_log.info("use recorder {}", mod_config.recorder) if mod_config.recorder == "CsvRecorder": if not mod_config.persist_folder: raise RuntimeError(_(u"You need to set persist_folder to use CsvRecorder")) persist_provider = DiskPersistProvider(os.path.join(mod_config.persist_folder, "persist")) self._recorder = recorders.CsvRecorder(mod_config.persist_folder) elif mod_config.recorder == "MongodbRecorder": if mod_config.strategy_id is None: raise RuntimeError(_(u"You need to set strategy_id")) persist_provider = persist_providers.MongodbPersistProvider(mod_config.strategy_id, mod_config.mongo_url, mod_config.mongo_dbname) self._recorder = recorders.MongodbRecorder(mod_config.strategy_id, mod_config.mongo_url, mod_config.mongo_dbname) else: raise RuntimeError(_(u"unknown recorder {}").format(mod_config.recorder)) if env.persist_provider is None: env.set_persist_provider(persist_provider) self._meta = { "strategy_id": mod_config.strategy_id, "origin_start_date": self._env.config.base.start_date.strftime("%Y-%m-%d"), "start_date": self._env.config.base.start_date.strftime("%Y-%m-%d"), "end_date": self._env.config.base.end_date.strftime("%Y-%m-%d"), "last_run_time": datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S"), } persist_meta = self._recorder.load_meta() if persist_meta: if persist_meta["end_date"] >= self._meta["start_date"]: raise RuntimeError( _(u"current start_date {} is before last end_date {}").format(self._meta["start_date"], persist_meta["end_date"])) else: self._meta["origin_start_date"] = persist_meta["origin_start_date"] env.event_bus.add_listener(EVENT.TRADE, self.on_trade) env.event_bus.add_listener(EVENT.POST_SETTLEMENT, self.on_settlement)
def start_up(self, env, mod_config): # forward compatible try: order_book_id = mod_config.order_book_id or env.config.base.benchmark except AttributeError: order_book_id = None if not order_book_id: system_log.info("No order_book_id set, BenchmarkMod disabled.") return env.event_bus.add_listener( EVENT.POST_SYSTEM_INIT, lambda e: self._validate_benchmark(order_book_id, env)) if env.config.base.run_type == RUN_TYPE.BACKTEST: from .benchmark_provider import BackTestPriceSeriesBenchmarkProvider as BTProvider env.set_benchmark_provider(BTProvider(order_book_id)) else: from .benchmark_provider import RealTimePriceSeriesBenchmarkProvider as RTProvider env.set_benchmark_provider(RTProvider(order_book_id))
def clock_worker(self): data_proxy = self._env.data_proxy quotation = eq.use('sina') data = quotation.stocks('sh000001', prefix=True) df = pd.DataFrame(data).T #df.date[0]==str(datetime.date.today()) while True: # wait for the first data ready #To do Error msg #if data_proxy.current_snapshot("000001.XSHG", None, None).datetime.date() == datetime.date.today(): if df.date[0] == str(datetime.date.today()): system_log.info(_("Market data is ready, start to work now!")) break time.sleep(1) while True: time.sleep(self.fps) if is_holiday_today(): time.sleep(60) continue dt = datetime.datetime.now() if dt.strftime("%H:%M:%S") >= "08:30:00" and dt.date( ) > self.before_trading_fire_date: self.event_queue.put((dt, EVENT.BEFORE_TRADING)) self.before_trading_fire_date = dt.date() elif dt.strftime("%H:%M:%S") >= "15:10:00" and dt.date( ) > self.after_trading_fire_date: self.event_queue.put((dt, EVENT.AFTER_TRADING)) self.after_trading_fire_date = dt.date() if is_tradetime_now(): self.event_queue.put((dt, EVENT.BAR))
def start_up(self, env, mod_config): if os.environ.get("RQDATAC2_CONF") or os.environ.get("RQDATAC_CONF"): system_log.info('rqdatac use RQDATAC2_CONF or RQDATAC_CONF') rqdatac.init() else: addr = (mod_config.rqdata_client_addr, mod_config.rqdata_client_port) env.system_log.info('rqdatac use address {}', addr) rqdatac.init( username=mod_config.rqdata_client_username, password=mod_config.rqdata_client_password, addr=addr, lazy=True ) # noinspection PyUnresolvedReferences from rqdatac import fundamentals, Fundamentals, financials, Financials, fenji, query from rqalpha.api.api_base import register_api register_api("fundamentals", fundamentals) register_api("Fundamentals", Fundamentals) register_api("financials", financials) register_api("Financials", Financials) register_api("fenji", fenji) register_api("query", query)
def on_log(log): system_log.info(log)
def onFrontConnected(self): super(RqCtpTdApi, self).onFrontConnected() system_log.info('CTP交易服务器连接成功')
def onRspUserLogout(self, data, error, n, last): super(RqCtpTdApi, self).onRspUserLogout(data, error, n, last) if error['ErrorID'] == 0: system_log.info('CTP交易服务器登出成功') else: system_log.error('CTP交易服务器登出错误,错误代码:%s,错误信息:%s' % (str(error['ErrorID']), error['ErrorMsg'].decode('gbk')))
def onRspAuthenticate(self, data, error, n, last): super(RqCtpTdApi, self).onRspAuthenticate(data, error, n, last) if error['ErrorID'] == 0: system_log.info('CTP交易服务器验证成功')
def onFrontDisconnected(self, n): super(RqCtpTdApi, self).onFrontDisconnected(n) system_log.info('CTP交易服务器断开连接')
def apply_settlement(self, event): prev_trading_date = self._env.data_proxy.get_previous_trading_date(self._env.trading_dt).date() system_log.info("booking settlement on {}".format(prev_trading_date)) super(Booking, self).apply_settlement(prev_trading_date)
def _set_env_and_data_source(self): env = self._env mod_config = self._mod_config system_log.info("use recorder {}", mod_config.recorder) if mod_config.recorder == "CsvRecorder": if not mod_config.persist_folder: raise RuntimeError( _(u"You need to set persist_folder to use CsvRecorder")) persist_provider = DiskPersistProvider( os.path.join(mod_config.persist_folder, "persist")) self._recorder = recorders.CsvRecorder(mod_config.persist_folder) elif mod_config.recorder == "MongodbRecorder": if mod_config.strategy_id is None: raise RuntimeError(_(u"You need to set strategy_id")) persist_provider = persist_providers.MongodbPersistProvider( mod_config.strategy_id, mod_config.mongo_url, mod_config.mongo_dbname) self._recorder = recorders.MongodbRecorder(mod_config.strategy_id, mod_config.mongo_url, mod_config.mongo_dbname) else: raise RuntimeError( _(u"unknown recorder {}").format(mod_config.recorder)) if env.persist_provider is None: env.set_persist_provider(persist_provider) self._meta = { "strategy_id": mod_config.strategy_id, "origin_start_date": self._env.config.base.start_date.strftime("%Y-%m-%d"), "start_date": self._env.config.base.start_date.strftime("%Y-%m-%d"), "end_date": self._env.config.base.end_date.strftime("%Y-%m-%d"), "last_end_time": self._env.config.base.end_date.strftime("%Y-%m-%d"), "last_run_time": datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S"), } event_start_time = self._env.config.base.start_date persist_meta = self._recorder.load_meta() if persist_meta: # 不修改回测开始时间 self._env.config.base.start_date = persist_meta['start_date'] event_start_time = datetime.datetime.strptime( persist_meta['last_end_time'], '%Y-%m-%d').date() + datetime.timedelta(days=1) # 代表历史有运行过,根据历史上次运行的end_date下一天设为事件发送的start_time self._meta["origin_start_date"] = persist_meta["origin_start_date"] self._meta["start_date"] = persist_meta["start_date"] self._meta[ "last_end_time"] = self._env.config.base.end_date.strftime( "%Y-%m-%d") env.set_data_source( IncrementcalDataSource( self._env.config.base.data_bundle_path, getattr(self._env.config.base, "future_info", {}), self._env.config.base.start_date)) event_source = IncrementalEventSource(env, event_start_time, self._env.config.base.end_date) env.set_event_source(event_source)
def tear_down(self, code, exception=None): system_log.info('tear_down %s' % code)
def onRspSettlementInfoConfirm(self, data, error, n, last): system_log.info('CTP交易服务器结算信息确认成功') self.gateway.onSettlementInfoConfirm()
def on_log(self, event): log = event.dict_['data'] system_log.info(log.logContent)
def start_up(self, env, mod_config): self.env = env self.mod_config = mod_config if env.config.base.run_type != RUN_TYPE.LIVE_TRADING: system_log.info("Mod booking will only run in live trading") return if env.config.base.init_positions: raise RuntimeError( "RQAlpha receive init positions. rqalpha_mod_sys_booking does not support init_positions" ) self.booking_account = BookingAccount(register_event=True) # 昨仓 trades = [] position_list = self._get_old_position_list() for position_dict in position_list: if position_dict["buy_quantity"] != 0: trade = self._create_trade( position_dict["order_book_id"], position_dict["buy_quantity"], SIDE.BUY, POSITION_EFFECT.OPEN, ) trades.append(trade) if position_dict["sell_quantity"] != 0: trade = self._create_trade( position_dict["order_book_id"], position_dict["sell_quantity"], SIDE.SELL, POSITION_EFFECT.OPEN, ) trades.append(trade) system_log.info("yesterday positions trades") for trade in trades: system_log.info("trade: {:9}, qtx {}, side {}", trade.order_book_id, trade.last_quantity, trade.side) self.booking_account.fast_forward([], trades=trades) self.booking_account._settlement(None, check_delist=False) # 计算今仓 trades = [] trade_list = self._get_trade_list() for trade_dict in trade_list: trade = self._create_trade( trade_dict["order_book_id"], trade_dict["last_quantity"], SIDE_DICT[trade_dict["side"]], POSITION_EFFECT_DICT[trade_dict["position_effect"]], ) trades.append(trade) system_log.info("today trades: {}", trades) self.booking_account.fast_forward([], trades=trades) env.event_bus.add_listener(EVENT.BEFORE_SYSTEM_RESTORED, self.on_before_system_restore)
def on_log(self, log): system_log.info(log)
def apply_settlement(self, event): prev_trading_date = self._env.data_proxy.get_previous_trading_date( self._env.trading_dt).date() system_log.info("booking settlement on {}".format(prev_trading_date)) super(Booking, self).apply_settlement(prev_trading_date)