def run_tests(file_path=None):
if file_path is not None:
files = [file_path]
else:
files = [f for f in os.listdir(TEST_DIR) if f.find("test") == 0]
error_map = {}
for filename in files:
try:
r, result_data = run_test(filename)
if r is not None:
error_map[filename.replace(".py", "")] = result_data
except Exception as e:
system_log.exception()
error_map[filename.replace(".py", "")] = e
for filename, result_data in iteritems(error_map):
print(u"*" * 20, u"[{}]did not pass!".format(filename), u"*" * 20)
if isinstance(result_data, Exception):
system_log.error(result_data)
else:
df, old_df, result = result_data
# print("+" * 10, "old test Dataframe: ", "+" * 10)
# print(old_df.drop(result.columns[result.all()], axis=1))
# print("+" * 10, "new test Dataframe: ", "+" * 10)
# print(df.drop(result.columns[result.all()], axis=1))
print(result.all())
print(u"=" * 40)
print(u"[{}|{}] strategies has been passed!".format(len(files) - len(error_map), len(files)))
return len(error_map)
def run_tests(file_path=None):
tests = {
f.replace(".py", ""): f
for f in ((file_path, ) if file_path else (
f for f in os.listdir(TEST_DIR) if f.find("test") == 0))
}
error_map = {}
for name, filename in tests.items():
try:
result_data = run_test(filename)
if result_data is not None:
error_map[name] = result_data
except Exception as e:
error_map[name] = e
for filename, result_data in iteritems(error_map):
print(u"*" * 20, u"[{}]did not pass!".format(filename), u"*" * 20)
if isinstance(result_data, Exception):
system_log.error(result_data)
else:
_, __, result = result_data
print(result.all())
print(u"=" * 40)
print("[{}|{}] strategies has been passed!".format(
len(tests) - len(error_map), len(tests)))
return len(error_map)
def run_tests(file_path=None):
if file_path is not None:
files = [file_path]
else:
files = [f for f in os.listdir(TEST_DIR) if f.find("test") == 0]
error_map = {}
for filename in files:
try:
r, result_data = run_test(filename)
if r is not None:
error_map[filename.replace(".py", "")] = result_data
except Exception as e:
system_log.exception()
error_map[filename.replace(".py", "")] = e
for filename, result_data in iteritems(error_map):
print(u"*" * 20, u"[{}]did not pass!".format(filename), u"*" * 20)
if isinstance(result_data, Exception):
system_log.error(result_data)
else:
df, old_df, result = result_data
# print("+" * 10, "old test Dataframe: ", "+" * 10)
# print(old_df.drop(result.columns[result.all()], axis=1))
# print("+" * 10, "new test Dataframe: ", "+" * 10)
# print(df.drop(result.columns[result.all()], axis=1))
print(result.all())
print(u"=" * 40)
print(u"[{}|{}] strategies has been passed!".format(
len(files) - len(error_map), len(files)))
return len(error_map)
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 subscribe(self, order_book_id):
subscribe_req = self._data_factory.make_subscribe_req(order_book_id)
if subscribe_req is None:
system_log.error('Cannot find contract whose order_book_id is %s' %
order_book_id)
return
self.vnpy_gateway.subscribe(subscribeReq=subscribe_req)
def _init_gateway(self):
self.gateway_type = self._config.gateway_type
if self.gateway_type == 'CTP':
self.vnpy_gateway = RQCtpGateway(
self.event_engine, self.gateway_type,
getattr(self._config, self.gateway_type))
else:
system_log.error('No Gateway named {}', self.gateway_type)
def get_limit_up(self, order_book_id):
tick_snapshot = self._data_factory.get_tick_snapshot(order_book_id)
if tick_snapshot is None:
system_log.error(
'Cannot find such tick whose order_book_id is {} ',
order_book_id)
return
return tick_snapshot['limit_up']
def get_limit_down(self, order_book_id):
tick_snapshot = self._cache.snapshot.get(order_book_id)
if tick_snapshot is None:
system_log.error(
'Cannot find such tick whose order_book_id is {} ',
order_book_id)
return
return tick_snapshot['limit_down']
def get_last_price(self, order_book_id):
tick_snapshot = self._md_gateway.snapshot.get(order_book_id)
if tick_snapshot is None:
tick_snapshot = self._trade_gateway.snapshot.get(order_book_id)
if tick_snapshot is None:
system_log.error('Cannot find such tick whose order_book_id is {} ', order_book_id)
return
return tick_snapshot['last']
def current_snapshot(self, instrument, frequency, dt):
if frequency != 'tick':
raise NotImplementedError
order_book_id = instrument.order_book_id
tick_snapshot = self._md_gateway.snapshot.get(order_book_id)
if tick_snapshot is None:
system_log.error('Cannot find such tick whose order_book_id is {} ', order_book_id)
return SnapshotObject(instrument, tick_snapshot, dt)
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 _query_futu_market_state(self):
print("请求当前市场状态")
ret, state_dict = self._quote_context.get_global_state()
if ret == 0:
mkt_val = int(state_dict[self._mkt_key])
if mkt_val in self._mkt_dic.keys():
self._market_state = self._mkt_dic[mkt_val]
else:
err_log = "Unknown market state: {}".format(mkt_val)
system_log.error(err_log)
return ret
def _init_gateway(self):
self.gateway_type = self._config.gateway_type
if self.gateway_type == 'CTP':
try:
from .vnpy_gateway import RQVNCTPGateway
self.vnpy_gateway = RQVNCTPGateway(
self.event_engine, self.gateway_type,
dict(getattr(self._config, self.gateway_type)))
QueryExecutor.interval = self._config.query_interval
QueryExecutor.start()
except ImportError as e:
system_log.exception("No Gateway named CTP")
else:
system_log.error('No Gateway named {}', self.gateway_type)
def _exception_handler(e):
try:
sys.excepthook(e.error.exc_type, e.error.exc_val, e.error.exc_tb)
except Exception as e:
system_log.exception("hook exception failed")
user_system_log.error(e.error)
if not is_user_exc(e.error.exc_val):
code = const.EXIT_CODE.EXIT_INTERNAL_ERROR
system_log.error(_(u"strategy execute exception"), exc=e)
else:
code = const.EXIT_CODE.EXIT_USER_ERROR
user_detail_log.error(_(u"strategy execute exception"), exc=e)
return code
def _exception_handler(e):
try:
sys.excepthook(e.error.exc_type, e.error.exc_val, e.error.exc_tb)
except Exception as e:
system_log.exception("hook exception failed")
user_system_log.error(e.error)
if not is_user_exc(e.error.exc_val):
code = const.EXIT_CODE.EXIT_INTERNAL_ERROR
system_log.error(_(u"strategy execute exception"), exc=e)
else:
code = const.EXIT_CODE.EXIT_USER_ERROR
user_detail_log.error(_(u"strategy execute exception"), exc=e)
return code
def get_price(self,
instrument,
start_date,
end_date,
frequency='1d',
fields=None,
adjust_type='pre',
skip_suspended=False):
"""
:param instrument:
:param start_date: 开始日期 (格式：YYYYMMDD)
:param end_date: 结束日期 (格式：YYYYMMDD)
:param frequency: 1MIN表示1分钟（1/5/15/30/60分钟） D日线 ，默认D
:param fields:
:param adjust_type: 复权类型(只针对股票)：None未复权 qfq前复权 hfq后复权 , 默认None
:param skip_suspended:
:return:
"""
# 获取order_book_id 将其转成tushare 所能识别的 code
# order_book_id = ricequant_to_tushare(instrument.order_book_id)
order_book_id = ricequant_to_tushare(instrument)
# adj: None未复权 qfq前复权 hfq后复权 , 默认None
# asset: 资产类别：E股票 I沪深指数 C数字货币 FT期货 FD基金 O期权，默认E
adj = map_adjust_type[adjust_type]
start_date = '{}'.format(start_date).replace("-", "")
end_date = '{}'.format(end_date).replace("-", "")
bar_data = ts.pro_bar(pro_api=self._pro,
ts_code=order_book_id,
adj=adjust_type,
start_date=start_date,
end_date=end_date)
if bar_data is None or bar_data.empty:
system_log.error("tuahre get_tushare_k_data return date is None")
else:
bar_data['trade_date'] = pd.to_datetime(bar_data['trade_date'])
bar_data.set_index(bar_data['trade_date'], inplace=True)
bar_data.rename(columns={'vol': 'volume'}, inplace=True)
bar_data.sort_index(inplace=True)
if isinstance(fields,
six.string_types) and fields in bar_data.columns:
return bar_data[fields].values
# fields = [fields]
fields = [field for field in fields if field in bar_data.columns]
# return bar_data[fields].values
return bar_data[fields]
def code_config(config, source_code=None):
try:
if source_code is None:
with codecs.open(config["base"]["strategy_file"], encoding="utf-8") as f:
source_code = f.read()
# FIXME: hardcode for parametric mod
def noop(*args, **kwargs):
pass
scope = {'define_parameter': noop}
code = compile(source_code, config["base"]["strategy_file"], 'exec')
six.exec_(code, scope)
return scope.get('__config__', {})
except Exception as e:
system_log.error(_(u"in parse_user_config, exception: {e}").format(e=e))
return {}
def code_config(config, source_code=None):
try:
if source_code is None:
with codecs.open(config["base"]["strategy_file"], encoding="utf-8") as f:
source_code = f.read()
# FIXME: hardcode for parametric mod
def noop(*args, **kwargs):
pass
scope = {'define_parameter': noop}
code = compile(source_code, config["base"]["strategy_file"], 'exec')
six.exec_(code, scope)
return scope.get('__config__', {})
except Exception as e:
system_log.error(_(u"in parse_user_config, exception: {e}").format(e=e))
return {}
def write_csv(path, fields):
old_test_times = []
if not os.path.exists(path):
with open(path, 'w') as csv_file:
writer = csv.DictWriter(csv_file, fieldnames=fields)
writer.writeheader()
with open(path) as csv_file:
reader = csv.DictReader(csv_file)
for row in reader:
old_test_times.append(row)
if performance_path is None:
if len(old_test_times) != 0 and time_spend > float(old_test_times[-1]["time_spend"]) * 1.1:
system_log.error("代码咋写的，太慢了！")
system_log.error("上次测试用例执行的总时长为：" + old_test_times[-1]["time_spend"])
system_log.error("本次测试用例执行的总时长增长为: " + str(time_spend))
else:
with open(path, 'a') as csv_file:
writer = csv.DictWriter(csv_file, fieldnames=fields)
writer.writerow({'date_time': end_time, 'time_spend': time_spend})
else:
if 0 < len(old_test_times) < 5 and time_spend > float(sum(float(i['time_spend']) for i in old_test_times)) / len(old_test_times) * 1.1:
print('Average time of last 5 runs:', float(sum(float(i['time_spend']) for i in old_test_times))/len(old_test_times))
print('Now time spend:', time_spend)
raise RuntimeError('Performance regresses!')
elif len(old_test_times) >= 5 and time_spend > float(sum(float(i['time_spend']) for i in old_test_times[-5:])) / 5 * 1.1:
print('Average time of last 5 runs:',
float(sum(float(i['time_spend']) for i in old_test_times[-5:])) / 5)
print('Now time spend:', time_spend)
raise RuntimeError('Performance regresses!')
else:
with open(path, 'a') as csv_file:
writer = csv.DictWriter(csv_file, fieldnames=fields)
writer.writerow({'date_time': end_time, 'time_spend': time_spend})
def import_mod(mod_name):
try:
from importlib import import_module
return import_module(mod_name)
except Exception as e:
system_log.error("*" * 30)
system_log.error("Mod Import Error: {}, error: {}", mod_name, e)
system_log.error("*" * 30)
raise
def import_mod(mod_name):
try:
from importlib import import_module
return import_module(mod_name)
except Exception as e:
system_log.error("*" * 30)
system_log.error("Mod Import Error: {}, error: {}", mod_name, e)
system_log.error("*" * 30)
raise
def run_tests(file_path=None):
if file_path is not None:
files = [file_path]
else:
files = [f for f in os.listdir(TEST_DIR) if f.find("test") == 0]
error_map = {}
for filename in files:
try:
r, result_data = run_test(filename)
if r is not None:
error_map[filename.replace(".py", "")] = result_data
except Exception as e:
system_log.exception()
error_map[filename.replace(".py", "")] = e
for filename, result_data in iteritems(error_map):
print(u"*" * 20, u"[{}]did not pass!".format(filename), u"*" * 20)
if isinstance(result_data, Exception):
system_log.error(result_data)
else:
df, old_df, result = result_data
# print("+" * 10, "old test Dataframe: ", "+" * 10)
# print(old_df.drop(result.columns[result.all()], axis=1))
# print("+" * 10, "new test Dataframe: ", "+" * 10)
# print(df.drop(result.columns[result.all()], axis=1))
if "summary" in df.keys():
df["summary"] = pd.DataFrame([df["summary"]])
old_df["summary"] = pd.DataFrame([old_df["summary"]])
for k in df.keys():
d = old_df[k][~old_df[k].isin(df[k])].dropna()
if not d.empty:
print(k, 'max diff:', d.abs().max(), "\n")
print(result.all())
print(u"=" * 40)
print(u"[{}|{}] strategies has been passed!".format(
len(files) - len(error_map), len(files)))
return len(error_map)
def _register_event(self):
self.event_engine.register(EVENT_ORDER, self.on_order)
self.event_engine.register(EVENT_CONTRACT, self.on_contract)
self.event_engine.register(EVENT_TRADE, self.on_trade)
self.event_engine.register(EVENT_TICK, self.on_tick)
self.event_engine.register(EVENT_LOG, self.on_log)
self.event_engine.register(EVENT_ACCOUNT, self.on_account)
self.event_engine.register(EVENT_POSITION, self.on_positions)
self.event_engine.register(EVENT_POSITION_EXTRA,
self.on_position_extra)
self.event_engine.register(EVENT_CONTRACT_EXTRA,
self.on_contract_extra)
self.event_engine.register(EVENT_COMMISSION, self.on_commission)
self.event_engine.register(EVENT_ERROR,
lambda e: system_log.error(e.dict_['data']))
self._env.event_bus.add_listener(EVENT.POST_UNIVERSE_CHANGED,
self.on_universe_changed)
def onRspError(self, error, n, last):
system_log.error('CTP交易服务器错误，错误代码：%s，错误信息：%s' % (str(error['ErrorID']), error['ErrorMsg'].decode('gbk')))
def onRspOrderInsert(self, data, error, n, last):
system_log.error('CTP交易服务器发单错误，错误代码：%s，错误信息：%s' % (str(error['ErrorID']), error['ErrorMsg'].decode('gbk')))
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 on_err(self, error):
system_log.error(
'CTP 错误，错误代码：%s，错误信息：%s' %
(str(error['ErrorID']), error['ErrorMsg'].decode('GBK')))
def on_err(error, func_name):
system_log.error('CTP 错误，错误代码：%s，错误信息：%s' %
(str(error.ErrorID), error.ErrorMsg.decode('GBK')))
if error_count == 0:
time_csv_file_path = os.path.join(TEST_OUT, "time.csv")
field_names = ['date_time', 'time_spend']
old_test_times = []
time_spend = (end_time - start_time).total_seconds()
if not os.path.exists(time_csv_file_path):
with open(time_csv_file_path, 'w') as csv_file:
writer = csv.DictWriter(csv_file, fieldnames=field_names)
writer.writeheader()
with open(time_csv_file_path) as csv_file:
reader = csv.DictReader(csv_file)
for row in reader:
old_test_times.append(row)
if len(old_test_times) != 0 and time_spend > float(
old_test_times[-1]["time_spend"]) * 1.1:
system_log.error("代码咋写的，太慢了！")
system_log.error("上次测试用例执行的总时长为：" +
old_test_times[-1]["time_spend"])
system_log.error("本次测试用例执行的总时长增长为: " + str(time_spend))
else:
with open(time_csv_file_path, 'a') as csv_file:
writer = csv.DictWriter(csv_file, fieldnames=field_names)
writer.writerow({
'date_time': end_time,
'time_spend': time_spend
})
else:
print('Failed!')
sys.exit(-1)
if is_enable_coverage():
def onErrRtnOrderAction(self, data, error):
system_log.error('CTP交易服务器撤单错误，错误代码：%s，错误信息：%s' % (str(error['ErrorID']), error['ErrorMsg'].decode('gbk')))
def run(config, source_code=None, user_funcs=None):
env = Environment(config)
persist_helper = None
init_succeed = False
mod_handler = ModHandler()
try:
# 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))
mod_handler.set_env(env)
mod_handler.start_up()
if not env.data_source:
env.set_data_source(
BaseDataSource(config.base.data_bundle_path,
getattr(config.base, "future_info", {})))
if env.price_board is None:
from rqalpha.data.bar_dict_price_board import BarDictPriceBoard
env.price_board = BarDictPriceBoard()
env.set_data_proxy(DataProxy(env.data_source, env.price_board))
_adjust_start_date(env.config, env.data_proxy)
ctx = ExecutionContext(const.EXECUTION_PHASE.GLOBAL)
ctx._push()
# FIXME
start_dt = datetime.datetime.combine(config.base.start_date,
datetime.datetime.min.time())
env.calendar_dt = start_dt
env.trading_dt = start_dt
assert env.broker is not None
assert env.event_source is not None
if env.portfolio is None:
from rqalpha.portfolio import Portfolio
env.set_portfolio(
Portfolio(config.base.accounts, config.base.init_positions))
env.event_bus.publish_event(Event(EVENT.POST_SYSTEM_INIT))
scope = create_base_scope()
scope.update({"g": env.global_vars})
scope.update(get_strategy_apis())
scope = env.strategy_loader.load(scope)
if config.extra.enable_profiler:
enable_profiler(env, scope)
ucontext = StrategyContext()
executor = Executor(env)
persist_helper = init_persist_helper(env, ucontext, executor, config)
user_strategy = Strategy(env.event_bus, scope, ucontext)
env.user_strategy = user_strategy
env.event_bus.publish_event(Event(EVENT.BEFORE_STRATEGY_RUN))
if persist_helper:
with LogCapture(user_log) as log_capture:
user_strategy.init()
else:
user_strategy.init()
if config.extra.context_vars:
for k, v in config.extra.context_vars.items():
if isinstance(v, RqAttrDict):
v = v.__dict__
setattr(ucontext, k, v)
if persist_helper:
env.event_bus.publish_event(Event(EVENT.BEFORE_SYSTEM_RESTORED))
restored_obj_state = persist_helper.restore(None)
check_key = ["global_vars", "user_context", "executor", "universe"]
kept_current_init_data = not any(
v for k, v in restored_obj_state.items() if k in check_key)
system_log.debug(
"restored_obj_state: {}".format(restored_obj_state))
system_log.debug(
"kept_current_init_data: {}".format(kept_current_init_data))
if kept_current_init_data:
# 未能恢复init相关数据 保留当前策略初始化变量(展示当前策略初始化日志)
log_capture.replay()
else:
user_system_log.info(_('system restored'))
env.event_bus.publish_event(Event(EVENT.POST_SYSTEM_RESTORED))
init_succeed = True
bar_dict = BarMap(env.data_proxy, config.base.frequency)
executor.run(bar_dict)
env.event_bus.publish_event(Event(EVENT.POST_STRATEGY_RUN))
if env.profile_deco:
output_profile_result(env)
release_print(scope)
except CustomException as e:
if init_succeed and persist_helper and env.config.base.persist_mode == const.PERSIST_MODE.ON_CRASH:
persist_helper.persist()
code = _exception_handler(e)
mod_handler.tear_down(code, e)
except Exception as e:
system_log.error(traceback.format_exc())
if init_succeed and persist_helper and env.config.base.persist_mode == const.PERSIST_MODE.ON_CRASH:
persist_helper.persist()
exc_type, exc_val, exc_tb = sys.exc_info()
user_exc = create_custom_exception(exc_type, exc_val, exc_tb,
config.base.strategy_file)
code = _exception_handler(user_exc)
mod_handler.tear_down(code, user_exc)
else:
if persist_helper and env.config.base.persist_mode == const.PERSIST_MODE.ON_NORMAL_EXIT:
persist_helper.persist()
result = mod_handler.tear_down(const.EXIT_CODE.EXIT_SUCCESS)
system_log.debug(_(u"strategy run successfully, normal exit"))
return result
def get_limit_up(self, order_book_id):
tick_snapshot = self._md_gateway.snapshot.get(order_book_id)
if tick_snapshot is None:
system_log.error('Cannot find such tick whose order_book_id is {} ', order_book_id)
return
return tick_snapshot['limit_up']
