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 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 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)
