def update_strategy_online_check():
server_list = server_constant.get_cta_servers()
root_path = const.EOD_CONFIG_DICT['source_backtest_info_path']
folder_list = [('backtest_info_str', '.csv', []),
('backtest_parameter_str', '.txt', []),
('server_parameter', '.txt', server_list)]
th_list = []
path_list = []
for (folder_name, file_type, children_path_list) in folder_list:
if len(children_path_list) == 0:
tmp_dic = {'label': folder_name, 'prop': '', 'children': []}
path = '%s/%s' % (root_path, folder_name)
path_list.append(path)
else:
tmp_dic = {'label': folder_name, 'prop': '', 'children': []}
for children_path_name in children_path_list:
prop_str = '%s_%s' % (folder_name, children_path_name)
children_dict = {
'label': children_path_name,
'prop': prop_str,
'children': []
}
children_path = '%s/%s/%s' % (root_path, folder_name,
children_path_name)
path_list.append(children_path)
tmp_dic['children'].append(children_dict)
th_list.append(tmp_dic)
td_data = []
server_host = server_constant.get_server_model('host')
session_strategy = server_host.get_db_session('strategy')
for strategy_online_db in session_strategy.query(StrategyOnline).filter(
StrategyOnline.enable == 1, StrategyOnline.strategy_type == 'CTA'):
strategy_name = strategy_online_db.name
tmp_data_dic = {'strategy_name': strategy_name}
for (folder_name, file_type, children_path_list) in folder_list:
file_name = strategy_name + file_type
if len(children_path_list) == 0:
file_path = '%s%s/%s' % (root_path, folder_name, file_name)
tmp_data_dic_key = folder_name
if os.path.exists(file_path):
tmp_data_dic[tmp_data_dic_key] = True
else:
tmp_data_dic[tmp_data_dic_key] = False
else:
for children_path_name in children_path_list:
file_path = '%s%s/%s/%s' % (root_path, folder_name,
children_path_name, file_name)
tmp_data_dic_key = '%s_%s' % (folder_name,
children_path_name)
if os.path.exists(file_path):
tmp_data_dic[tmp_data_dic_key] = True
else:
tmp_data_dic[tmp_data_dic_key] = False
td_data.append(tmp_data_dic)
result = {'th_list': th_list, 'td_data': td_data}
return make_response(jsonify(code=200, data=result), 200)
def start_server_strategy_am():
"""
通过配置自动启动各服务器上的策略
"""
cta_server_list = server_constant.get_cta_servers()
from eod_aps.job.start_server_strategy_job import start_server_strategy_job
start_server_strategy_job(cta_server_list)
def ctp_market_file_check():
date_filter_str = date_utils.get_today_str('%Y-%m-%d')
if int(date_utils.get_today_str('%H%M%S')) < 153000:
date_filter_str = date_utils.get_last_trading_day(
'%Y-%m-%d', date_filter_str)
ctp_market_file_name = 'CTP_Market_%s_2.txt' % (date_filter_str, )
else:
ctp_market_file_name = 'CTP_Market_%s_1.txt' % (date_filter_str, )
server_list = server_constant.get_cta_servers()
market_file_path = const.EOD_CONFIG_DICT['ctp_data_backup_path']
th_list = []
td_data = []
td_item_dic = {'filename': ctp_market_file_name}
for server_name in server_list:
path = '%s/%s' % (market_file_path, server_name)
file_path = '%s/%s' % (path, ctp_market_file_name)
if os.path.exists(file_path):
td_item_dic[server_name] = True
else:
td_item_dic[server_name] = False
th_item_dic = {
'label': server_name,
'prop': server_name,
'children': []
}
th_list.append(th_item_dic)
td_data.append(td_item_dic)
result = {'th_list': th_list, 'td_data': td_data}
return make_response(jsonify(code=200, data=result), 200)
def query_strategy():
query_params = request.json
query_name = query_params.get('name')
query_instance_name = query_params.get('instance_name')
query_enable = query_params.get('enable')
strategy_online_list = []
server_host = server_constant.get_server_model('host')
session_strategy = server_host.get_db_session('strategy')
strategy_grouping_dict = dict()
for strategy_grouping_db in session_strategy.query(StrategyGrouping):
strategy_grouping_dict[
strategy_grouping_db.strategy_name] = strategy_grouping_db
for strategy_online_db in session_strategy.query(StrategyOnline):
if query_name and query_name.lower(
) not in strategy_online_db.name.lower():
continue
if query_instance_name and query_instance_name not in strategy_online_db.instance_name:
continue
if query_enable != '' and query_enable != strategy_online_db.enable:
continue
target_server_list = []
cta_server_list = server_constant.get_cta_servers()
if strategy_online_db.target_server is not None and strategy_online_db.target_server != '':
target_server_list = strategy_online_db.target_server.split('|')
target_server_list = filter(lambda x: x in cta_server_list,
target_server_list)
temp_item_dict = strategy_online_db.to_dict()
temp_item_dict['target_server_list'] = target_server_list
temp_item_dict['grouping_sub_name'] = strategy_grouping_dict[
strategy_online_db.strategy_name].sub_name
strategy_online_list.append(temp_item_dict)
sort_prop = query_params.get('sort_prop')
sort_order = query_params.get('sort_order')
if sort_prop:
if sort_order == 'ascending':
strategy_online_list = sorted(
strategy_online_list,
key=lambda market_item: market_item[sort_prop],
reverse=True)
else:
strategy_online_list = sorted(
strategy_online_list,
key=lambda market_item: market_item[sort_prop])
else:
strategy_online_list.sort(key=lambda obj: obj['name'])
query_page = int(query_params.get('page'))
query_size = int(query_params.get('size'))
result_list = strategy_online_list[(query_page - 1) *
query_size:query_page * query_size]
query_result = {'data': result_list, 'total': len(strategy_online_list)}
return make_response(jsonify(code=200, data=query_result), 200)
def load_strategy_parameter():
try:
for server_name in server_constant.get_cta_servers():
load_server_strategy_parameter(server_name)
except:
import traceback
email_utils.send_email_group_all('[Error]Load Strategy Parameter',
traceback.format_exc(), 'html')
return 0
def cta_test():
cta_test_str = ""
cta_server_list = server_constant.get_cta_servers()
for cta_server in cta_server_list:
server_model = server_constant.get_server_model(cta_server)
result_str = server_model.run_cmd_str('ls')
if 'apps' in result_str:
cta_test_str += '%s: connect success!\n' % cta_server
else:
cta_test_str += '%s: connect error!\n' % cta_server
return cta_test_str
def update_strategy_state_check_am():
"""
启动回测程序获取DMI的结果
"""
import datetime
if datetime.datetime.now().weekday() == 5:
time.sleep(3600)
cta_server_list = server_constant.get_cta_servers()
insert_strategy_state_sql_job(cta_server_list)
# strategy_state_check_job(cta_server_list)
trading_position_check_job(cta_server_list)
def after_start_check_am():
"""
系统启动后检查
"""
cta_server_list = server_constant.get_cta_servers()
trade_servers_list = server_constant.get_trade_servers()
# ts_servers = server_constant.get_ts_servers()
email_message_list = []
email_message_list.extend(strategy_start_check(cta_server_list))
email_message_list.extend(order_route_log_check(trade_servers_list))
email_message_list.extend(service_close_check(trade_servers_list))
email_message_list.extend(trade_version_check(trade_servers_list))
# email_message_list.extend(check_ts_order_group(ts_servers))
email_utils2.send_email_group_all('系统启动后检查', ''.join(email_message_list),
'html')
def update_strategy_online_am():
"""
将策略参数等信息更新至共享盘并缓存到NAS供回测使用
"""
cta_server_list = server_constant.get_cta_servers()
get_backtest_info_job(cta_server_list)
def insert_strategy_state_sql():
cta_server_list = server_constant.get_cta_servers()
from eod_aps.job.insert_strategy_state_sql_job import insert_strategy_state_sql_job
insert_strategy_state_sql_job(cta_server_list)
return 0
def query_parameter():
query_params = request.json
query_name = query_params.get('name')
query_commodity = query_params.get('commodity')
th_list = []
cta_server_list = server_constant.get_cta_servers()
ctp_account_dict = __query_ctp_account_dict()
for server_name in cta_server_list:
th_item_dict = {'label': server_name, 'prop': '', 'children': []}
for fund_name in ctp_account_dict[server_name]:
prop_str = '%s|%s' % (server_name, fund_name)
children_dict = {
'label': fund_name,
'prop': prop_str,
'children': []
}
th_item_dict['children'].append(children_dict)
th_list.append(th_item_dict)
ssp_dict = dict()
date_str = date_utils.get_today_str('%Y-%m-%d')
server_host = server_constant.get_server_model('host')
session_strategy = server_host.get_db_session('strategy')
for ssp_item in session_strategy.query(StrategyServerParameter) \
.filter(StrategyServerParameter.date == date_str):
dict_key = '%s|%s|%s' % (ssp_item.server_name, ssp_item.account_name,
ssp_item.strategy_name)
ssp_dict[dict_key] = ssp_item
if len(ssp_dict) == 0:
query_result = {'th_list': th_list, 'tr_list': [], 'modify_list': []}
return make_response(jsonify(code=200, data=query_result), 200)
# spm_dict中缓存修改过的参数数据
spm_modify_dict = dict()
if 'strategy_parameter_modify_dict' in const.EOD_POOL:
spm_modify_dict = const.EOD_POOL['strategy_parameter_modify_dict']
tr_list = []
for strategy_online_item in session_strategy.query(StrategyOnline).filter(
StrategyOnline.enable == 1, StrategyOnline.strategy_type == 'CTA'):
if 'PairTrading' in strategy_online_item.name:
continue
if query_name and query_name.lower(
) not in strategy_online_item.name.lower():
continue
if query_commodity and query_commodity.lower(
) != strategy_online_item.name.split('.')[1].split('_')[0].lower():
# if query_commodity and query_commodity not in strategy_online_item.instance_name:
continue
tr_item_dict = {'Strategy_Name': strategy_online_item.name}
for th_item_dict in th_list:
server_name = th_item_dict['label']
for children_dict in th_item_dict['children']:
account_name = children_dict['label']
find_key = '%s|%s|%s' % (server_name, account_name,
strategy_online_item.name)
if find_key in ssp_dict:
parameter_value = ssp_dict[find_key].max_long_position
else:
parameter_value = None
if find_key in spm_modify_dict:
parameter_value = '%s->%s' % (
parameter_value,
spm_modify_dict[find_key].max_long_position)
tr_item_dict['%s|%s' %
(server_name, account_name)] = parameter_value
tr_list.append(tr_item_dict)
modify_parameter_list = []
for (dict_key, modify_parameter) in spm_modify_dict.items():
server_parameter = ssp_dict[dict_key]
item_dict = dict(
date=modify_parameter.date,
server_name=modify_parameter.server_name,
strategy_name=modify_parameter.strategy_name,
account_name=modify_parameter.account_name,
max_long_position='%s->%s' % (server_parameter.max_long_position,
modify_parameter.max_long_position),
max_short_position='%s->%s' %
(server_parameter.max_short_position,
modify_parameter.max_short_position),
qty_per_trade='%s->%s' %
(server_parameter.qty_per_trade, modify_parameter.qty_per_trade),
)
modify_parameter_list.append(item_dict)
modify_parameter_list.sort(key=lambda item: item['strategy_name'].lower())
query_result = {
'th_list': th_list,
'tr_list': tr_list,
'modify_list': modify_parameter_list
}
return make_response(jsonify(code=200, data=query_result), 200)
def backtest_files_export_check():
root_path = const.EOD_CONFIG_DICT['backtest_state_insert_folder']
server_list = server_constant.get_cta_servers()
no_night_market_future_types = const.EOD_CONFIG_DICT[
'no_night_market_future_types']
validate_time_str = int(date_utils.get_today_str('%H%M%S'))
th_list = []
db_strategy_dict = dict()
for server_name in server_list:
server_model = server_constant.get_server_model(server_name)
session_strategy = server_model.get_db_session('strategy')
query_sql = 'select a.TIME,a.`NAME`,a.`VALUE` from strategy.strategy_state a, (select `NAME`, max(Time) Time \
from strategy.strategy_state group by `NAME`) b where a.`NAME` = b.`NAME` and a.TIME = b.TIME order by a.`NAME`'
for query_item in session_strategy.execute(query_sql):
dict_key = '%s|%s' % (server_name, query_item[1])
db_strategy_dict[dict_key] = [query_item[2]]
db_strategy_dict[dict_key].append(str(query_item[0]))
tmp_dic = {'label': server_name, 'prop': '', 'children': []}
th_list.append(tmp_dic)
td_data = []
server_host = server_constant.get_server_model('host')
session_strategy = server_host.get_db_session('strategy')
for strategy_online_db in session_strategy.query(StrategyOnline).filter(
StrategyOnline.enable == 1, StrategyOnline.strategy_type == 'CTA'):
ticker_type = filter(lambda x: not x.isdigit(),
strategy_online_db.instance_name)
if ticker_type in no_night_market_future_types.split(
',') and validate_time_str < 155000:
continue
tmp_data_dic = {'filename': strategy_online_db.name}
sql_file_name = '%s_state_insert_sql.txt' % strategy_online_db.name
for server_name in server_list:
sql_file_path = '%s%s/%s' % (root_path, server_name, sql_file_name)
if not os.path.exists(sql_file_path):
tmp_data_dic[server_name] = False
continue
find_key = '%s|%s' % (server_name, strategy_online_db.name)
if find_key not in db_strategy_dict:
tmp_data_dic[server_name] = False
continue
db_value = db_strategy_dict[find_key][0]
state_db_dict = json.loads(db_value.replace('\n', ''))
with open(sql_file_path) as f:
line = f.readlines()[0]
reg = re.compile(
"^Insert Into strategy.strategy_state\(TIME,NAME,VALUE\) VALUES\(sysdate\(\),'(?P<strategy_state_name>[^,]*)','(?P<strategy_state_value>.*)'\)"
)
reg_name_dict = reg.match(line).groupdict()
strategy_state_value = reg_name_dict['strategy_state_value']
state_file_dict = json.loads(strategy_state_value)
tmp_data_dic[server_name] = cmp(state_file_dict,
state_db_dict) == 0
tmp_data_dic['time'] = db_strategy_dict[find_key][1]
td_data.append(tmp_data_dic)
result = {'th_dict': th_list, 'td_data': td_data}
return make_response(jsonify(code=200, data=result), 200)
def update_strategy_state_check_pm():
cta_server_list = server_constant.get_cta_servers()
insert_strategy_state_sql_job(cta_server_list)
# strategy_state_check_job(cta_server_list)
trading_position_check_job(cta_server_list)
def update_strategy_online_pm():
cta_server_list = server_constant.get_cta_servers()
get_backtest_info_job(cta_server_list)
def build_calendarma_transfer_parameter():
"""
生成calendarma.transfer的参数
"""
cta_server_list = server_constant.get_cta_servers()
build_calendarma_transfer_parameter_job(cta_server_list)
def backtest_files_export_pm():
cta_server_list = server_constant.get_cta_servers()
from eod_aps.job.backtest_files_export_job import backtest_files_export_job
backtest_files_export_job(cta_server_list)
def strategy_state_check_am():
"""
对比检查实盘保存的state和回测计算得到的state
"""
cta_server_list = server_constant.get_cta_servers()
strategy_state_check_job(cta_server_list)
def strategy_state_check_pm():
cta_server_list = server_constant.get_cta_servers()
strategy_state_check_job(cta_server_list)