def __get_realposition_basket():
redis_title_name = 'market:typelist:realposition'
if r.llen(redis_title_name) > 0:
r.ltrim(redis_title_name, 1, 0)
server_model = ServerConstant().get_server_model('local118')
session_aggregation = server_model.get_db_session('aggregation')
total_position_dict = dict()
total_money = Decimal(0.0)
for basket_name in multifactor_strategy_list:
ticker_position_dict = dict()
basket_total_money = Decimal(0.0)
last_trading_day = date_utils.get_today_str('%Y-%m-%d')
query_sql = "select a.SYMBOL,sum(a.`LONG`) from aggregation.pf_position a \
left join aggregation.pf_account b on a.SERVER_NAME = b.SERVER_NAME and a.id = b.id \
where a.DATE = '%s' and b.FUND_NAME like '%%%s%%' group by a.SYMBOL" % (
last_trading_day, basket_name)
for position_item in session_aggregation.execute(query_sql):
ticker = position_item[0]
long_value = Decimal(position_item[1])
if long_value <= 0:
continue
if ticker not in instrument_dict:
continue
instrument_minbar_info = instrument_dict[ticker]
ticker_money = long_value * instrument_minbar_info.prev_close
ticker_position_dict[ticker] = (ticker_money, long_value)
basket_total_money += ticker_money
total_money += ticker_money
if basket_total_money == 0:
continue
r.lpush(redis_title_name, basket_name)
basket_dict[basket_name] = []
for (ticker, ticker_value) in ticker_position_dict.items():
(ticker_money, long_value) = ticker_value
ticker_weight = ticker_money / basket_total_money
basket_dict[basket_name].append(
'%s,%.4f,%s' % (ticker, ticker_weight, long_value))
if ticker in total_position_dict:
(temp_money, temp_long_value) = total_position_dict[ticker]
temp_money += ticker_money
temp_long_value += long_value
total_position_dict[ticker] = (temp_money, temp_long_value)
else:
total_position_dict[ticker] = (ticker_money, long_value)
total_pf_account_name = 'MultiFactor_Total'
basket_dict[total_pf_account_name] = []
r.lpush(redis_title_name, total_pf_account_name)
for (ticker, (ticker_money,
ticker_long_value)) in total_position_dict.items():
ticker_weight = ticker_money / total_money
basket_dict[total_pf_account_name].append(
'%s,%.4f,%s' % (ticker, ticker_weight, ticker_long_value))
def commission_check():
# 找到手续费文件夹
for commission_file_name in os.listdir('./'):
if '手续费' in commission_file_name:
commission_folder = './' + commission_file_name + '/'
break
# 检查统一期货公司各个帐户的手续费是否一致，并得到南华和中信的手续费dict
[nanhua_commissiton_dict, zhongxin_commissiton_dict] = self_check(commission_folder)
print 'self check finished!'
# 获得国信的手续费
guoxin_commissiton_dict = get_guoxin_commission_dict(commission_folder)
# 获得鲁证的手续费
luzheng_commissiton_dict = get_luzheng_commission_dict(commission_folder)
# 检查我们的手续费表格与上面的是否一致
server_model_nanhua = ServerConstant().get_server_model('nanhua')
server_model_zhongxin = ServerConstant().get_server_model('zhongxin')
server_model_guoxin = ServerConstant().get_server_model('guoxin')
server_model_luzheng = ServerConstant().get_server_model('luzheng')
print '\n nanhua:'
commission_check_sql(server_model_nanhua, nanhua_commissiton_dict)
print '\n zhongxin:'
commission_check_sql(server_model_zhongxin, zhongxin_commissiton_dict)
print '\n guoxin:'
commission_check_sql(server_model_guoxin, guoxin_commissiton_dict)
print '\n luzheng:'
commission_check_sql(server_model_luzheng, luzheng_commissiton_dict)
def __get_instrument_list():
server_model = ServerConstant().get_server_model('host')
session_common = server_model.get_db_session('common')
query = session_common.query(Instrument)
for instrument_db in query.filter(Instrument.type_id.in_((4, 6))):
instrument_minbar_info = Instrument_Minbar_Info(
instrument_db.ticker, instrument_db.prev_close)
instrument_dict[instrument_db.ticker] = instrument_minbar_info
def __build_pf_account_dict():
global pf_account_dict
pf_account_dict = dict()
server_host = ServerConstant().get_server_model(server_name)
session_portfolio = server_host.get_db_session('portfolio')
query_pf_account = session_portfolio.query(PfAccount)
for pf_account_db in query_pf_account.filter(
PfAccount.group_name == 'Event_Real'):
pf_account_dict[pf_account_db.name] = pf_account_db
def get_strategy_name_list():
strategy_name_list = []
server_model_host = ServerConstant().get_server_model('host')
session_strategy = server_model_host.get_db_session('strategy')
query_sql = "select `NAME` from strategy.strategy_online where strategy_type = 'CTA' and `ENABLE` = 1;"
query_result = session_strategy.execute(query_sql)
for query_line in query_result:
strategy_name_list.append(query_line[0])
return strategy_name_list
def __read_future_daily_file(date_str):
server_model = ServerConstant().get_server_model('local118')
session_portfolio = server_model.get_db_session('dump_wind')
query_sql = "select t.S_INFO_WINDCODE, t.S_DQ_CLOSE from dump_wind.CINDEXFUTURESEODPRICES t where t.TRADE_DT='%s'" % (date_str.replace('-', ''),)
future_file_dict = dict()
for db_item in session_portfolio.execute(query_sql):
ticker = db_item[0].split('.')[0]
future_file_dict[ticker] = db_item[1]
return future_file_dict
def dailyreturn_test(server_name, group_name):
server_model = ServerConstant().get_server_model(server_name)
session_portfolio = server_model.get_db_session('portfolio')
__build_ticker_exchange(server_model)
query_pf_account = session_portfolio.query(PfAccount)
for pf_account_db in query_pf_account.filter(
PfAccount.group_name.like('%' + group_name + '%')):
__dailyreturn_test(server_model, pf_account_db)
def __save_to_db(trade2_history_list, pf_position_list):
server_model = ServerConstant().get_server_model(server_name)
session_om = server_model.get_db_session('om')
for trade2_history_db in trade2_history_list:
session_om.add(trade2_history_db)
session_om.commit()
session_portfolio = server_model.get_db_session('portfolio')
for pf_position_db in pf_position_list:
session_portfolio.add(pf_position_db)
session_portfolio.commit()
def position_change_job():
strategy_name_list = get_strategy_name_list()
server_model_server = ServerConstant().get_server_model(server_name)
session_strategy = server_model_server.get_db_session('strategy')
fr = open(position_change_insert_sql_path, 'w+')
for strategy_name in strategy_name_list:
print strategy_name
parameter_value_str = ''
query_sql = "select Value from strategy.strategy_parameter where `NAME` = '%s' order by time desc limit 1;" \
% strategy_name
query_result = session_strategy.execute(query_sql)
for query_line in query_result:
parameter_value_str = query_line[0]
break
parameter_value_dict = json.loads(parameter_value_str)
if 'tq.%s.max_long_position' % account_name in parameter_value_dict:
max_long_value = float(
parameter_value_dict['tq.%s.max_long_position' % account_name])
max_short_value = float(
parameter_value_dict['tq.%s.max_short_position' %
account_name])
qty_per_trade_value = float(
parameter_value_dict['tq.%s.qty_per_trade' % account_name])
else:
continue
new_max_long_value = int(max_long_value * multiple_number)
new_max_short_value = int(max_short_value * multiple_number)
new_qty_per_trade_value = int(qty_per_trade_value * multiple_number)
if new_qty_per_trade_value < 2 * max(new_max_long_value,
new_max_short_value):
new_qty_per_trade_value = 2 * max(new_max_long_value,
new_max_short_value)
parameter_value_dict['tq.%s.max_long_position' %
account_name] = new_max_long_value
parameter_value_dict['tq.%s.max_short_position' %
account_name] = new_max_short_value
parameter_value_dict['tq.%s.qty_per_trade' %
account_name] = new_qty_per_trade_value
new_parameter_str = json.dumps(parameter_value_dict)
insert_sql = '''Insert Into strategy.strategy_parameter(TIME,NAME,VALUE) VALUES(sysdate(),'%s','%s');''' \
% (strategy_name, new_parameter_str)
fr.write(insert_sql + '\n')
# session_strategy.execute(insert_sql)
# session_strategy.commit()
fr.close()
server_model_server.close()
def read_structure_fund_file(server_name):
structure_fund_file_dict = dict()
file_path = 'E:/market_file/structure_fund_list.csv'
input_file = open(file_path)
for line in input_file.xreadlines():
line_item = line.split(',')
structure_fund_file_dict[line_item[0]] = (line_item[1], line_item[2],
line_item[3])
structure_fund_db_dict = dict()
host_server_model = ServerConstant().get_server_model(server_name)
session_common = host_server_model.get_db_session('common')
query = session_common.query(Instrument)
for instrument_db in query.filter(Instrument.type_id == 16):
structure_fund_db_dict[instrument_db.ticker] = instrument_db
index_dict = dict()
for instrument_db in query.filter(Instrument.type_id == 6):
index_dict[instrument_db.ticker] = instrument_db
for parent_ticker in structure_fund_file_dict.keys():
print 'Parent Ticker:', parent_ticker
if parent_ticker not in structure_fund_db_dict:
print ' unfind in db'
continue
parent_instrument_db = structure_fund_db_dict[parent_ticker]
if parent_instrument_db.tranche is not None:
print ' tranche error'
(sub_ticker_db1,
sub_ticker_db2) = parent_instrument_db.undl_tickers.split(';')
(sub_ticker1, sub_ticker2,
undel_index) = structure_fund_file_dict[parent_ticker]
if sub_ticker_db1 != sub_ticker1 or sub_ticker_db2 != sub_ticker2:
print 'error'
sub_instrument_db1 = structure_fund_db_dict[sub_ticker_db1]
sub_instrument_db2 = structure_fund_db_dict[sub_ticker_db2]
if sub_instrument_db1.tranche != 'A':
print 'sub ticker:%s tranche is not A' % sub_instrument_db1.ticker
if sub_instrument_db2.tranche != 'B':
print 'sub ticker:%s tranche is not B' % sub_instrument_db2.ticker
if sub_instrument_db1.undl_tickers is not None and sub_instrument_db1.undl_tickers not in index_dict:
print 'sub ticker:%s, undl_tickers:%s error' % (
sub_instrument_db1.ticker, sub_instrument_db1.undl_tickers)
if sub_instrument_db2.undl_tickers is not None and sub_instrument_db2.undl_tickers not in index_dict:
print 'sub ticker:%s, undl_tickers:%s error' % (
sub_instrument_db2.ticker, sub_instrument_db2.undl_tickers)
def start():
server_model = ServerConstant().get_server_model('huabao')
pf_account_db_list = get_account_id_list(server_model)
for pf_account_db in pf_account_db_list:
server_enter(server_model, pf_account_db)
__email_algo_pf_position(pf_account_db_list)
def start():
server_model = ServerConstant().get_server_model('nanhua')
trading_day_list = date_utils.get_trading_day_list(
date_utils.string_toDatetime('2016-09-23'),
date_utils.string_toDatetime('2016-10-14'))
for trading_day in trading_day_list:
__trade_strategy_build(server_model, trading_day.strftime("%Y-%m-%d"))
def __enter__(self):
server_model = ServerConstant().get_server_model(self.server_name)
self.ftp = FTP()
self.ftp.set_pasv(False)
self.ftp.connect(server_model.ip, server_model.port)
self.ftp.login(server_model.userName, server_model.passWord)
return self
def risk_management():
server_constant = ServerConstant()
server_host = server_constant.get_server_model('host')
session_jobs = server_host.get_db_session('jobs')
email_content_list = []
for risk_management_db in session_jobs.query(RiskManagement):
email_content_list.append('Title:%s' %
risk_management_db.monitor_index)
email_content_list.append('Describe:%s' % risk_management_db.describe)
temp_email_content = []
if risk_management_db.fund_risk_list != '':
for fund_risk_item in risk_management_db.fund_risk_list.split(';'):
temp_email_content.append(fund_risk_item.split('|'))
html_table_list = email_utils2.list_to_html(
'FundName,Warn_Line,Error_Line', temp_email_content)
email_content_list.append(''.join(html_table_list))
email_content_list.append('<br><br>')
email_utils2.send_email_group_all('RiskManagementInfo',
'<br>'.join(email_content_list), 'html')
def update_trading_time(server_name, include_history_flag):
server_model = ServerConstant().get_server_model(server_name)
trading_info_dict = dict()
future_type_list = __get_future_type(server_model)
for future_type in future_type_list:
trading_info_list = __get_trading_info_list(server_model, future_type)
if len(trading_info_list) == 0:
print 'Error future_type:', future_type
continue
trading_info_dict[future_type] = trading_info_list
__update_db(server_model, trading_info_dict, include_history_flag)
for type_info in trading_info_dict.keys():
print type_info + ':------------------------'
print '\n'.join(trading_info_dict[type_info])
def rebuild_strategy_parameter():
server_model1 = ServerConstant().get_server_model('host')
session_strategy1 = server_model1.get_db_session('strategy')
query_sql = 'select a.name from strategy.strategy_online a group by a.name'
strategy_name_list = []
for db_item in session_strategy1.execute(query_sql):
strategy_name_list.append(db_item[0])
session_strategy1.commit()
server_model = ServerConstant().get_server_model(server_name)
session_strategy = server_model.get_db_session('strategy')
strategy_parameter_db_list = []
query_strategy_parameter = session_strategy.query(StrategyParameter)
for strategy_name in strategy_name_list:
strategy_parameter_db = query_strategy_parameter.filter(
StrategyParameter.name == strategy_name).order_by(
desc(StrategyParameter.time)).first()
if strategy_parameter_db is None:
print 'unfind %s' % strategy_name
continue
strategy_parameter_dict = json.loads(strategy_parameter_db.value)
if 'Target' in strategy_parameter_dict:
target_ticker_str = strategy_parameter_dict['Target']
new_target_ticker_list = []
change_flag = False
for target_ticker in target_ticker_str.split(';'):
if target_ticker in contract_change_dict2:
change_flag = True
change_ticker = contract_change_dict2[target_ticker]
new_target_ticker_list.append(change_ticker)
else:
new_target_ticker_list.append(target_ticker)
if change_flag:
print '%s:%s ---> %s' % (strategy_name, target_ticker_str,
';'.join(new_target_ticker_list))
strategy_parameter_dict['Target'] = ';'.join(
new_target_ticker_list)
strategy_parameter_db.value = json.dumps(
strategy_parameter_dict)
strategy_parameter_db_list.append(strategy_parameter_db)
else:
print '%s:%s' % (strategy_name, target_ticker_str)
for strategy_parameter_db in strategy_parameter_db_list:
session_strategy.merge(strategy_parameter_db)
session_strategy.commit()
def __get_account_id_list():
server_model = ServerConstant().get_server_model('host')
session_strategy = server_model.get_db_session('strategy')
query_sql = 'select a.STRATEGY_NAME from strategy.strategy_online a group by a.STRATEGY_NAME'
strategy_name_list = []
for db_item in session_strategy.execute(query_sql):
strategy_name_list.append(db_item[0])
pf_account_id_list = []
server_model = ServerConstant().get_server_model(server_name)
session_portfolio = server_model.get_db_session('portfolio')
query_pf_account = session_portfolio.query(PfAccount)
for pf_account_db in query_pf_account.filter(
PfAccount.group_name.in_(tuple(strategy_name_list))):
pf_account_id_list.append(int(pf_account_db.id))
return pf_account_id_list
def commission_check(base_path):
exchange_folder = os.path.join(base_path, u'交易所')
exchange_commission_file = get_abs_filepath(exchange_folder)[0]
exchange_commission_dict = get_exchange_commission_dict(exchange_commission_file)
for folder_name in os.listdir(base_path):
flag = True
if u'中信' in folder_name:
commission_folder = os.path.join(base_path, folder_name)
file_list = get_abs_filepath(commission_folder)
if len(file_list) > 1:
f_commission_dict = get_zhongxin_commission_dict(file_list[0])
for i in file_list[1:]:
s_commission_dict = get_zhongxin_commission_dict(i)
if not dict_check(f_commission_dict, s_commission_dict):
flag = False
break
if flag:
commission_dict = get_zhongxin_commission_dict(file_list[0])
server_name = 'zhongxin'
elif u'南华' in folder_name:
commission_folder = os.path.join(base_path, folder_name)
commission_dict = get_commission_dict_bymultiple(exchange_commission_dict, 1.05)
server_name = 'nanhua'
elif u'鲁证' in folder_name:
commission_folder = os.path.join(base_path, folder_name)
server_name = 'luzheng'
elif u'兴证' in folder_name:
commission_folder = os.path.join(base_path, folder_name)
commission_dict = get_commission_dict_bymultiple(exchange_commission_dict, 1.05)
server_name = 'xinzheng'
else:
continue
server_model = ServerConstant().get_server_model(server_name)
if flag:
print server_name, ': '
commission_check_sql(server_model, commission_dict)
# -*- coding: utf-8 -*-
import os
from eod_aps.model.schema_jobs import SpecialTickers
from eod_aps.model.server_constans import ServerConstant
server_constant = ServerConstant()
server_host = server_constant.get_server_model('host')
session_jobs = server_host.get_db_session('jobs')
special_ticker_list = []
for special_ticker in session_jobs.query(SpecialTickers).filter(
SpecialTickers.date == '2019-02-27'):
if special_ticker.describe in ('High_Stop', 'Low_Stop'):
special_ticker_list.append(special_ticker.ticker)
print special_ticker_list
base_folder = 'E:/test'
last_ticker_list = []
last_folder = os.path.join(base_folder, '20190226_change')
for file_name in os.listdir(last_folder):
with open(os.path.join(last_folder, file_name), 'rb') as fr:
if not file_name.endswith('.txt'):
continue
for line in fr.readlines():
last_ticker_list.append(line.split(',')[0])
print last_ticker_list
today_ticker_list = []
today_folder = os.path.join(base_folder, '20190227_change')
for file_name in os.listdir(today_folder):
with open(os.path.join(today_folder, file_name), 'rb') as fr:
# -*- coding: utf-8 -*-
from eod_aps.model.schema_strategy import StrategyParameter, StrategyChangeHistory, StrategyOnline
from eod_aps.model.server_constans import ServerConstant
from eod_aps.tools.date_utils import DateUtils
from eod_aps.wsdl.cta_strategy_wsdl import *
from cfg import custom_log
server_constant = ServerConstant()
date_utils = DateUtils()
def __strategy_online(session, strategy_change_history):
query = session.query(StrategyOnline)
strategy_online_db = query.filter(
StrategyOnline.name == strategy_change_history.name).first()
if strategy_online_db is None:
custom_log.log_error_task('unfind strategy:%s' %
strategy_change_history.name)
return
target_server_list = strategy_online_db.target_server.split('|')
parameter_server_list = strategy_online_db.parameter_server.split('|')
for index in range(0, len(target_server_list)):
server_name = target_server_list[index]
parameter_value = parameter_server_list[index]
server_model = server_constant.get_server_model(server_name)
session_strategy = server_model.get_db_session('strategy')
strategy_parameter = StrategyParameter()
strategy_parameter.time = date_utils.get_now()
if start_date is None:
start_date = trading_info[1]
if str(trading_info[1]) in const.HOLIDAYS:
continue
if last_trading_time is None:
last_trading_time = trading_info[2]
if trading_info[2] != last_trading_time:
trading_info_list.append('(%s,%s)%s' %
(start_date, end_date, last_trading_time))
start_date = trading_info[1]
end_date = trading_info[1]
last_trading_time = trading_info[2]
end_date = '20991231'
trading_info_list.append('(%s,%s)%s' %
(start_date, end_date, last_trading_time))
return trading_info_list
if __name__ == '__main__':
server_constant = ServerConstant()
host_server_model = server_constant.get_server_model('host')
session_common = host_server_model.get_db_session('common')
add_future_option()
# session.commit()
rate_db_str = (float(rate_db.open_ratio_by_money),
float(rate_db.open_ratio_by_volume),
float(rate_db.close_ratio_by_money),
float(rate_db.close_ratio_by_volume),
float(rate_db.close_today_ratio_by_money),
float(rate_db.close_today_ratio_by_volume))
if rate_db_str != rate_file:
print 'ticker:%s|rate_db:%s|reate_file:%s' % (key, rate_db_str,
rate_file)
rate_db.open_ratio_by_money = rate_file[0]
rate_db.open_ratio_by_volume = rate_file[1]
rate_db.close_ratio_by_money = rate_file[2]
rate_db.close_ratio_by_volume = rate_file[3]
rate_db.close_today_ratio_by_money = rate_file[4]
rate_db.close_today_ratio_by_volume = rate_file[5]
session_common.merge(rate_db)
def commission_rat_update():
__get_rate_file_list()
__get_rate_db_list()
__rate_compare()
if __name__ == '__main__':
host_server_model = ServerConstant().get_server_model(server_name)
session_common = host_server_model.get_db_session('common')
commission_rat_update()
session_common.commit()
def main_contract_change_tools(symbol, filter_date_str):
pf_account_id_list = __get_account_id_list()
next_trading_day = date_utils.get_next_trading_day('%Y-%m-%d',
filter_date_str)
server_model = ServerConstant().get_server_model(server_name)
session_om = server_model.get_db_session('om')
pf_account_dict = dict()
session_portfolio = server_model.get_db_session('portfolio')
query_pf_account = session_portfolio.query(PfAccount)
for pf_account_db in query_pf_account:
pf_account_dict[pf_account_db.id] = pf_account_db
instrument_db_dict = dict()
session_common = server_model.get_db_session('common')
query = session_common.query(Instrument)
for instrument_db in query.filter(Instrument.type_id == 1):
if instrument_db.exchange_id == 20:
exchange_name = 'SHF'
if instrument_db.exchange_id == 21:
exchange_name = 'DCE'
if instrument_db.exchange_id == 22:
exchange_name = 'ZCE'
dict_key = '%s %s' % (instrument_db.ticker, exchange_name)
if instrument_db.exchange_id == 25:
dict_key = instrument_db.ticker
instrument_db_dict[dict_key] = instrument_db
fictitious_symbol_position_dict = dict()
fictitious_change_symbol_position_dict = dict()
session_portfolio = server_model.get_db_session('portfolio')
query_pf_position = session_portfolio.query(PfPosition)
for pf_position_db in query_pf_position.filter(
PfPosition.symbol.like(symbol + '%'),
PfPosition.date == next_trading_day,
PfPosition.id.in_(tuple(pf_account_id_list))):
if pf_position_db.long == 0 and pf_position_db.short == 0:
continue
pf_account_db = pf_account_dict[pf_position_db.id]
if 'All_Weather_1' in pf_account_db.fund_name:
account_name = '11610021-CTP-All_Weather_1-00'
fictitious_account_id = fictitious_account_dict['All_Weather_1']
elif 'All_Weather_2' in pf_account_db.fund_name:
account_name = '11610021-CTP-All_Weather_2-00'
fictitious_account_id = fictitious_account_dict['All_Weather_2']
elif 'All_Weather_3' in pf_account_db.fund_name:
account_name = '11610021-CTP-All_Weather_3-00'
fictitious_account_id = fictitious_account_dict['All_Weather_3']
elif 'absolute_return' in pf_account_db.fund_name:
account_name = '120301313-CTP-absolute_return-00'
fictitious_account_id = fictitious_account_dict['absolute_return']
elif 'steady_return' in pf_account_db.fund_name:
account_name = '120301312-CTP-steady_return-00'
fictitious_account_id = fictitious_account_dict['steady_return']
fictitious_account_db = pf_account_dict[int(fictitious_account_id)]
symbol = pf_position_db.symbol
instrument_db = instrument_db_dict[symbol]
trade2_history1 = Trade2History()
trade2_history1.time = '%s 15:00:00' % filter_date_str
trade2_history1.symbol = symbol
trade2_history1.price = instrument_db.close
trade2_history1.trade_type = 3
trade2_history1.strategy_id = '%s.%s' % (pf_account_db.group_name,
pf_account_db.name)
trade2_history1.account = account_name
if pf_position_db.short > 0:
trade2_history1.qty = pf_position_db.short
elif pf_position_db.long > 0:
trade2_history1.qty = -pf_position_db.long
trade2_history2 = Trade2History()
trade2_history2.time = '%s 15:00:00' % filter_date_str
trade2_history2.symbol = symbol
trade2_history2.price = instrument_db.close
trade2_history2.trade_type = 2
trade2_history2.strategy_id = '%s.%s' % (
fictitious_account_db.group_name, fictitious_account_db.name)
trade2_history2.account = account_name
if pf_position_db.short > 0:
trade2_history2.qty = -pf_position_db.short
elif pf_position_db.long > 0:
trade2_history2.qty = pf_position_db.long
change_symbol = contract_change_dict[pf_position_db.symbol]
change_instrument_db = instrument_db_dict[change_symbol]
trade2_history3 = Trade2History()
trade2_history3.time = '%s 15:00:00' % filter_date_str
trade2_history3.symbol = change_symbol
trade2_history3.price = change_instrument_db.close
trade2_history3.trade_type = 2
trade2_history3.strategy_id = '%s.%s' % (pf_account_db.group_name,
pf_account_db.name)
trade2_history3.account = account_name
if pf_position_db.short > 0:
trade2_history3.qty = -pf_position_db.short
elif pf_position_db.long > 0:
trade2_history3.qty = pf_position_db.long
trade2_history4 = Trade2History()
trade2_history4.time = '%s 15:00:00' % filter_date_str
trade2_history4.symbol = change_symbol
trade2_history4.price = change_instrument_db.close
trade2_history4.trade_type = 2
trade2_history4.strategy_id = '%s.%s' % (
fictitious_account_db.group_name, fictitious_account_db.name)
trade2_history4.account = account_name
if pf_position_db.short > 0:
trade2_history4.qty = pf_position_db.short
elif pf_position_db.long > 0:
trade2_history4.qty = -pf_position_db.long
session_om.merge(trade2_history1)
session_om.merge(trade2_history2)
session_om.merge(trade2_history3)
session_om.merge(trade2_history4)
pf_position_db2 = PfPosition()
pf_position_db2.date = next_trading_day
pf_position_db2.id = fictitious_account_id
pf_position_db2.symbol = symbol
pf_position_db2.long = pf_position_db.long
pf_position_db2.long_cost = pf_position_db.long * instrument_db.close * instrument_db.fut_val_pt
pf_position_db2.long_avail = pf_position_db.long_avail
pf_position_db2.short = pf_position_db.short
pf_position_db2.short_cost = pf_position_db.short * instrument_db.close * instrument_db.fut_val_pt
pf_position_db2.short_avail = pf_position_db.short_avail
pf_position_db2.yd_position_long = pf_position_db.long
pf_position_db2.yd_long_remain = pf_position_db.long
pf_position_db2.yd_position_short = pf_position_db.short
pf_position_db2.yd_short_remain = pf_position_db.short
pf_position_db2.prev_net = pf_position_db2.yd_position_long - pf_position_db2.yd_position_short
pf_position_db3 = PfPosition()
pf_position_db3.date = next_trading_day
pf_position_db3.id = fictitious_account_id
pf_position_db3.symbol = change_symbol
if pf_position_db.short > 0:
pf_position_db3.long = pf_position_db.short
pf_position_db3.long_cost = pf_position_db.short * change_instrument_db.close * change_instrument_db.fut_val_pt
pf_position_db3.long_avail = pf_position_db.short_avail
elif pf_position_db.long > 0:
pf_position_db3.short = pf_position_db.long
pf_position_db3.short_cost = pf_position_db.long * change_instrument_db.close * change_instrument_db.fut_val_pt
pf_position_db3.short_avail = pf_position_db.long_avail
pf_position_db3.yd_position_long = pf_position_db.long
pf_position_db3.yd_long_remain = pf_position_db.long
pf_position_db3.yd_position_short = pf_position_db.short
pf_position_db3.yd_short_remain = pf_position_db.short
pf_position_db3.prev_net = pf_position_db3.yd_position_long - pf_position_db3.yd_position_short
pf_position_db1 = pf_position_db
pf_position_db1.symbol = change_symbol
pf_position_db1.long = pf_position_db.long
pf_position_db1.long_cost = pf_position_db.long * change_instrument_db.close * instrument_db.fut_val_pt
pf_position_db1.long_avail = pf_position_db.long_avail
pf_position_db1.short = pf_position_db.short
pf_position_db1.short_cost = pf_position_db.short * change_instrument_db.close * instrument_db.fut_val_pt
pf_position_db1.short_avail = pf_position_db.short_avail
pf_position_db1.yd_position_long = pf_position_db.long
pf_position_db1.yd_long_remain = pf_position_db.long
pf_position_db1.yd_position_short = pf_position_db.short
pf_position_db1.yd_short_remain = pf_position_db.short
pf_position_db1.prev_net = pf_position_db1.yd_position_long - pf_position_db1.yd_position_short
session_portfolio.merge(pf_position_db1)
if fictitious_account_id in fictitious_symbol_position_dict:
fictitious_symbol_position_dict[fictitious_account_id].append(
pf_position_db2)
else:
fictitious_symbol_position_dict[fictitious_account_id] = [
pf_position_db2
]
if fictitious_account_id in fictitious_change_symbol_position_dict:
fictitious_change_symbol_position_dict[
fictitious_account_id].append(pf_position_db3)
else:
fictitious_change_symbol_position_dict[fictitious_account_id] = [
pf_position_db3
]
for (fictitious_account_id, fictitious_symbol_position_list
) in fictitious_symbol_position_dict.items():
pf_position_db2 = __rebuild_position(server_model, next_trading_day,
fictitious_symbol_position_list)
session_portfolio.merge(pf_position_db2)
for (fictitious_account_id, fictitious_symbol_position_list
) in fictitious_change_symbol_position_dict.items():
pf_position_db3 = __rebuild_position(server_model, next_trading_day,
fictitious_symbol_position_list)
session_portfolio.merge(pf_position_db3)
session_om.commit()
session_portfolio.commit()
def daily_return_report_check(account_id, date_str):
server_model = ServerConstant().get_server_model('huabao')
pf_account_db = get_account_id(server_model, account_id)
server_enter(server_model, pf_account_db, date_str)
# -*- coding: utf-8 -*-
# 策略持仓修改工具
import xlrd
from eod_aps.model.pf_account import PfAccount
from sqlalchemy import desc
from eod_aps.model.pf_position import PfPosition
from eod_aps.model.server_constans import ServerConstant
from datetime import datetime
server_constant = ServerConstant()
pf_account_dict = dict()
def pf_position_modify(symbol_key, account_id, long_volume, short_volume):
server_model = server_constant.get_server_model('host')
session_portfolio = server_model.get_db_session('portfolio')
query_position = session_portfolio.query(PfPosition)
pf_position_db = query_position.filter(
PfPosition.symbol.like('%' + symbol_key + '%')).order_by(
desc(PfPosition.date)).first()
if pf_position_db.long_avail > 0:
unit_price = pf_position_db.long_cost / pf_position_db.long_avail
elif pf_position_db.short_avail > 0:
unit_price = pf_position_db.short_cost / pf_position_db.short_avail
pf_position = PfPosition()
pf_position.date = datetime.now()
pf_position.id = account_id
if long_volume > 0:
pf_position.long = long_volume
return future_file_dict
def __build_ticker_exchange(server_model):
instrument_dict = dict()
session_common = server_model.get_db_session('common')
query = session_common.query(Instrument).filter(Instrument.type_id.in_((1, 4)))
for instrument_db in query:
instrument_dict[instrument_db.ticker] = instrument_db
return instrument_dict
def get_account_id(server_model, account_id):
session_portfolio = server_model.get_db_session('portfolio')
query_pf_account = session_portfolio.query(PfAccount)
pf_account_db = query_pf_account.filter(PfAccount.id == str(account_id)).first()
return pf_account_db
def daily_return_report_check(account_id, date_str):
server_model = ServerConstant().get_server_model('huabao')
pf_account_db = get_account_id(server_model, account_id)
server_enter(server_model, pf_account_db, date_str)
if __name__ == '__main__':
# daily_return_report_check('172', '2017-03-27')
server_model = ServerConstant().get_server_model('host')
__build_ticker_exchange(server_model)
def ipo_stock_monitor():
__wind_close()
__wind_login()
stock_server_list = server_constant.get_stock_servers()
email_list = []
for server_name in stock_server_list:
print server_name
server_model = ServerConstant().get_server_model(server_name)
session_portfolio = server_model.get_db_session('portfolio')
# query ipo id
query_sql1 = "select `ID` from portfolio.pf_account where FUND_NAME like 'container-Iposub%'"
query_result1 = session_portfolio.execute(query_sql1)
ipo_account_list = []
for query_line in query_result1:
ipo_account_list.append(str(query_line[0]))
if len(ipo_account_list) == 0:
continue
# query max date
query_sql2 = "select MAX(DATE) from portfolio.pf_position;"
query_result2 = session_portfolio.execute(query_sql2)
max_date = datetime.datetime.now().strftime('%Y-%m-%d')
for query_line in query_result2:
max_date = datetime.datetime.strftime(query_line[0], '%Y-%m-%d')
# query ipo id
query_sql3 = "select `SYMBOL` from portfolio.pf_position where id in (%s) and date = '%s';" % \
(','.join(ipo_account_list), max_date)
query_result3 = session_portfolio.execute(query_sql3)
ipo_id_list = []
for query_line in query_result3:
ipo_id_list.append(query_line[0])
# rebuild stock ticker
query_sql4 = "select ticker, exchange_id from common.instrument where ticker in (%s) and type_id = 4" % ','.join(ipo_id_list)
query_result4 = session_portfolio.execute(query_sql4)
rebuild_ipo_id_list = []
for query_line in query_result4:
if query_line[1] == 18:
rebuild_ipo_id_list.append(query_line[0] + '.SH')
elif query_line[1] == 19:
rebuild_ipo_id_list.append(query_line[0] + '.SZ')
else:
continue
# rebuild date
date_str_1 = date_utils.get_last_trading_day('%Y-%m-%d', max_date)
date_str_2 = date_utils.get_last_trading_day('%Y-%m-%d', date_str_1)
# get wind price
wind_price_dict = dict()
wind_data = w.wsd(rebuild_ipo_id_list, "close", date_str_2, date_str_1, "")
for i in range(len(wind_data['Codes'])):
wind_price_dict[wind_data['Codes'][i]] = wind_data['Data'][i]
# build table
html_title = 'Ticker,Close_%s,Close_%s' % (date_str_2, date_str_1)
table_list = []
for (wind_ticker, wind_price_list) in sorted(wind_price_dict.items()):
tr_list = []
if wind_price_list[1] / wind_price_list[0] - 1 > 0.095:
tr_list.append(str(wind_ticker))
tr_list.append(str(wind_price_list[0]))
tr_list.append(str(wind_price_list[1]))
else:
tr_list.append(str(wind_ticker))
tr_list.append(str(wind_price_list[0]) + '(Error)')
tr_list.append(str(wind_price_list[1]) + '(Error)')
table_list.append(tr_list)
html_list = email_utils.list_to_html(html_title, table_list)
email_list.append(server_name + ':<br>')
email_list.append(''.join(html_list))
server_model.close()
email_utils.send_email_group_all(unicode('打新股票开板校验', 'gbk'), '\n'.join(email_list), 'html')
__wind_close()
