def load_setting(self) -> None:
""""""
# For normal spread
setting = load_json(self.setting_filename)
for spread_setting in setting:
self.add_spread(
spread_setting["name"],
spread_setting["leg_settings"],
spread_setting["active_symbol"],
spread_setting.get("min_volume", 1),
save=False
)
# For advanced spread
setting = load_json(self.advanced_filename)
for spread_setting in setting:
self.add_advanced_spread(
spread_setting["name"],
spread_setting["leg_settings"],
spread_setting["price_formula"],
spread_setting["active_symbol"],
spread_setting.get("min_volume", 1),
save=False
)
def run_child():
"""
Running in the child process.
"""
event_engine = EventEngine()
main_engine = MainEngine(event_engine)
main_engine.add_gateway(BinancesGateway)
rpc_engine = main_engine.add_app(RpcServiceApp)
cta_engine = main_engine.add_app(CtaStrategyApp)
main_engine.add_app(RiskManagerApp)
main_engine.write_log("主引擎创建成功")
log_engine = main_engine.get_engine("log")
event_engine.register(EVENT_CTA_LOG, log_engine.process_log_event)
main_engine.write_log("注册日志事件监听")
binances_setting = load_json("connect_binances.json")
gateway_name = "BINANCES"
main_engine.connect(binances_setting, gateway_name)
main_engine.write_log("连接BINANCES接口")
sleep(10)
rpc_setting = load_json("rpc_service_setting.json")
rpc_engine.start(rpc_setting['rep_address'], rpc_setting['pub_address'])
cta_engine.init_engine()
main_engine.write_log("CTA策略初始化完成")
cta_engine.init_all_strategies(True)
# sleep(10) # Leave enough time to complete strategy initialization
main_engine.write_log("CTA策略全部初始化")
# cta_engine.start_all_strategies()
# main_engine.write_log("CTA策略全部启动")
def ctrl_handler(signum, frame):
cta_engine.stop_all_strategies()
cta_engine.close()
rpc_engine.close()
main_engine.close()
sys.exit(0)
signal.signal(signal.SIGINT, ctrl_handler)
while True:
# connect_data = load_json("proxy_connect_status.json")
# if not connect_data.get(gateway_name):
# main_engine.connect(binances_setting, gateway_name)
# connect_data.update(gateway_name, True)
# save_json("proxy_connect_status.json", connect_data)
# print("重连接口")
sleep(10)
def __init__(self, gateway):
"""Constructor"""
super(CtpTdApi, self).__init__()
self.gateway = gateway
self.gateway_name = gateway.gateway_name
self.reqid = 0
self.order_ref = 0
self.connect_status = False
self.login_status = False
self.auth_status = False
self.login_failed = False
self.contract_inited = False
self.userid = ""
self.password = ""
self.brokerid = ""
self.auth_code = ""
self.appid = ""
self.product_info = ""
self.frontid = 0
self.sessionid = 0
self.order_data = []
self.trade_data = []
self.positions = {}
self.sysid_orderid_map = {}
self.account_date = None #账户日期
self.commission_file_name = 'vt_commission_data'
self.commission_file_path = get_folder_path(self.commission_file_name)
self.commission_req = {} # 手续费查询字典
self.commission_data = {} # 手续费字典
self.margin_ratio_file_name = 'vt_margin_ratio_data'
self.margin_ratio_file_path = get_folder_path(
self.margin_ratio_file_name)
self.margin_ratio_req = {} # 保证金率查询字典
self.margin_ratio_data = {} # 保证金率字典
self.commission_symbol = [
symbol for symbol in load_json("vt_symbol.json").keys()
]
self.margin_ratio_symbol = [
symbol for symbol in load_json("vt_symbol.json").keys()
]
#读取硬盘存储手续费数据，保证金率数据
self.load_commission() # 赋值给 self.commission_data字典
self.load_margin_ratio() # 赋值给 self.margin_ratio_data字典
def load_data(self) -> None:
""""""
data = load_json(self.data_filename)
for portfolio in self.active_portfolios.values():
portfolio_name = portfolio.name
# Load underlying adjustment from setting
chain_adjustments = data.get("chain_adjustments", {})
chain_adjustment_data = chain_adjustments.get(portfolio_name, {})
if chain_adjustment_data:
for chain in portfolio.chains.values():
chain.underlying_adjustment = chain_adjustment_data.get(
chain.chain_symbol, 0)
# Load pricing impv from setting
pricing_impvs = data.get("pricing_impvs", {})
pricing_impv_data = pricing_impvs.get(portfolio_name, {})
if pricing_impv_data:
for chain in portfolio.chains.values():
for index in chain.indexes:
key = f"{chain.chain_symbol}_{index}"
pricing_impv = pricing_impv_data.get(key, 0)
if pricing_impv:
call = chain.calls[index]
call.pricing_impv = pricing_impv
put = chain.puts[index]
put.pricing_impv = pricing_impv
def load_backtesting_setting(self):
""""""
setting = load_json(self.setting_filename)
if not setting:
return
self.class_combo.setCurrentIndex(
self.class_combo.findText(setting["class_name"]))
self.symbol_line.setText(setting["vt_symbol"])
self.interval_combo.setCurrentIndex(
self.interval_combo.findText(setting["interval"]))
self.rate_line.setText(str(setting["rate"]))
self.slippage_line.setText(str(setting["slippage"]))
self.size_line.setText(str(setting["size"]))
self.pricetick_line.setText(str(setting["pricetick"]))
self.capital_line.setText(str(setting["capital"]))
if "start" in setting.keys():
self.start_date_edit.setDate(
datetime.strptime(setting['start'], "%Y-%m-%d"))
self.end_date_edit.setDate(
datetime.strptime(setting['end'], "%Y-%m-%d"))
if not setting["inverse"]:
self.inverse_combo.setCurrentIndex(0)
else:
self.inverse_combo.setCurrentIndex(1)
def load_setting(self):
""""""
setting = load_json(self.setting_filename)
if not setting:
return
self.update_setting(setting)
def load_data(self) -> None:
""""""
data = load_json(self.data_filename)
if not data:
return
today = datetime.now().strftime("%Y-%m-%d")
date_changed = False
date = data.pop("date")
for key, d in data.items():
reference, vt_symbol = key.split(",")
if date == today:
pos = d["open_pos"]
else:
pos = d["last_pos"]
date_changed = True
self.result_symbols.add(vt_symbol)
self.contract_results[(reference, vt_symbol)] = ContractResult(
self, reference, vt_symbol, pos)
# Re-save latest data if date changed
if date_changed:
self.save_data()
def load_backtesting_setting(self):
""""""
self.setting_list = load_json(self.setting_filename)
if not self.setting_list.get(self.class_combo.currentText()):
return
setting = self.setting_list[self.class_combo.currentText()]
self.class_combo.setCurrentIndex(
self.class_combo.findText(setting["class_name"])
)
self.symbol_line.setText(setting["vt_symbol"])
self.interval_combo.setCurrentIndex(
self.interval_combo.findText(setting["interval"])
)
self.rate_line.setText(str(setting["rate"]))
self.slippage_line.setText(str(setting["slippage"]))
self.size_line.setText(str(setting["size"]))
self.pricetick_line.setText(str(setting["pricetick"]))
self.capital_line.setText(str(setting["capital"]))
if not setting["inverse"]:
self.inverse_combo.setCurrentIndex(0)
else:
self.inverse_combo.setCurrentIndex(1)
def run_child():
"""
Running in the child process.
"""
SETTINGS["log.file"] = True
event_engine = EventEngine()
main_engine = MainEngine(event_engine)
huobi = main_engine.add_gateway(HuobiGateway)
cta_engine = main_engine.add_app(CtaStrategyApp)
main_engine.write_log("主引擎创建成功")
log_engine = main_engine.get_engine("log")
event_engine.register(EVENT_CTA_LOG, log_engine.process_log_event)
main_engine.write_log("注册日志事件监听")
filename = f"connect_{huobi.gateway_name.lower()}.json"
setting = load_json(filename)
main_engine.connect(setting, huobi.gateway_name)
main_engine.write_log("连接HUOBI接口")
sleep(10)
cta_engine.init_engine()
main_engine.write_log("CTA策略初始化完成")
cta_engine.init_all_strategies()
sleep(10) # Leave enough time to complete strategy initialization
main_engine.write_log("CTA策略全部初始化")
cta_engine.start_all_strategies()
main_engine.write_log("CTA策略全部启动")
while True:
sleep(1)
def load_backtesting_setting(self):
""""""
setting = load_json(self.setting_filename)
if not setting:
return
self.class_combo.setCurrentIndex(
self.class_combo.findText(setting["class_name"])
)
self.symbol_line.setText(setting["vt_symbol"])
self.interval_combo.setCurrentIndex(
self.interval_combo.findText(setting["interval"])
)
start_str = setting.get("start", "")
if start_str:
start_dt = QtCore.QDate.fromString(start_str, "yyyy-MM-dd")
self.start_date_edit.setDate(start_dt)
self.rate_line.setText(str(setting["rate"]))
self.slippage_line.setText(str(setting["slippage"]))
self.size_line.setText(str(setting["size"]))
self.pricetick_line.setText(str(setting["pricetick"]))
self.capital_line.setText(str(setting["capital"]))
if not setting["inverse"]:
self.inverse_combo.setCurrentIndex(0)
else:
self.inverse_combo.setCurrentIndex(1)
def main():
print("实盘交易")
# 事件引擎
event_engine = EventEngine()
# 把事件引擎附加到主引擎里
main_engine = MainEngine(event_engine)
main_engine.write_log("主引擎创建成功")
main_engine.add_gateway(OkexfGateway)
# 获取所有交易通道
gateway_names = main_engine.get_all_gateway_names()
for name in gateway_names:
# 连接火币平台
connect = ConnectExchange(main_engine=main_engine, gateway_name=name)
connect.connect()
sleep(2)
setting = load_json(filename="jyx_data_recorder_setting.json")
vt_symbols = setting["vt_symbols"]
functions = []
for vt_symbol in vt_symbols:
gevent.sleep(1)
# 交易对， 交易所
symbol, exchange_str = vt_symbol.split(".")
exchange = Exchange(exchange_str)
gateway = main_engine.get_gateway(exchange_str)
functions += start_gevent(gateway=gateway,
symbol=symbol,
exchange=exchange)
gevent.joinall(functions)
def load_strategy_setting(self):
"""
Load setting file.
"""
# 读取引擎得配置
self.engine_config = load_json(self.engine_filename)
self.strategy_setting = load_json(self.setting_filename)
for strategy_name, strategy_config in self.strategy_setting.items():
self.add_strategy(
strategy_config["class_name"],
strategy_name,
strategy_config["vt_symbol"],
strategy_config["setting"]
)
def load_algo_setting(self):
""""""
self.algo_settings = load_json(self.setting_filename)
for setting_name, setting in self.algo_settings.items():
self.put_setting_event(setting_name, setting)
self.write_log("算法配置载入成功")
def load_algo_setting(self):
""""""
self.algo_settings = load_json(self.setting_filename)
for setting_name, setting in self.algo_settings.items():
self.put_setting_event(setting_name, setting)
self.write_log(" the algorithms loaded successfully ")
def load_order(self) -> None:
""""""
order_data = load_json(self.order_filename)
date = order_data.get("date", "")
today = datetime.now().strftime("%Y-%m-%d")
if date == today:
self.order_reference_map = order_data["data"]
def load_setting(self) -> None:
""""""
setting = load_json(self.setting_filename)
if setting:
self.trade_slippage = setting["trade_slippage"]
self.timer_interval = setting["timer_interval"]
self.instant_trade = setting["instant_trade"]
def load_setting(self) -> None:
""""""
setting = load_json(self.setting_filename)
for spread_setting in setting:
self.add_spread(spread_setting["name"],
spread_setting["leg_settings"],
spread_setting["active_symbol"],
save=False)
def save_trade_data(self):
"""保存策略实盘数据
tips: 实盘时调用"""
if self.instance_name is None:
return
if not os.path.exists(self.save_path):
os.makedirs(self.save_path)
if len(self.order_list) != 0:
csv_add_rows(data_list=self.order_list,
header=[
"datetime", "direction", "exchange",
"gateway_name", "offset", "orderid", "price",
"status", "symbol", "time", "traded", "type",
"volume", "vt_orderid", "vt_symbol"
],
csv_path=os.path.join(self.save_path, "orders.csv"))
self.order_list = []
if len(self.trade_list) != 0:
csv_add_rows(data_list=self.trade_list,
header=[
"datetime", "direction", "exchange",
"gateway_name", "offset", "orderid", "price",
"symbol", "time", "tradeid", "volume",
"vt_orderid", "vt_symbol", "vt_tradeid"
],
csv_path=os.path.join(self.save_path, "trades.csv"))
self.trade_list = []
if len(self.output_list) != 0:
logger = get_file_logger(os.path.join(self.save_path,
"output.log"))
logger.setLevel(logging.INFO)
for output in self.output_list:
logger.info(output)
self.output_list = []
if len(self.daily_close_dict) != 0:
daily_close_file = os.path.join(self.save_path, "daily_close.json")
pre_close_dict = load_json(daily_close_file)
pre_close_dict.update(self.daily_close_dict)
save_json(daily_close_file, pre_close_dict)
list_dict = self.KLine_chart_dict.list_dict
if len(list_dict["datetime"]) != 0:
KLine_list = []
for i in range(len(list_dict["datetime"])):
row = []
for field in self.KLine_chart_dict.all_field:
row.append(list_dict[field][i])
KLine_list.append(row)
csv_add_rows(data_list=KLine_list,
header=self.KLine_chart_dict.all_field,
csv_path=os.path.join(self.save_path,
"KLineChart.csv"))
def run_child():
"""
Running in the child process.
"""
event_engine = EventEngine()
main_engine = MainEngine(event_engine)
main_engine.add_gateway(BinancesGateway)
# rpc_engine = main_engine.add_app(RpcServiceApp)
cta_engine = main_engine.add_app(CtaStrategyApp)
main_engine.add_app(RiskManagerApp)
main_engine.write_log("主引擎创建成功")
log_engine = main_engine.get_engine("log")
event_engine.register(EVENT_CTA_LOG, log_engine.process_log_event)
main_engine.write_log("注册日志事件监听")
binances_setting = load_json("connect_binances.json")
gateway_name = "BINANCES"
main_engine.connect(binances_setting, gateway_name)
# connect_data = load_json("proxy_connect_status.json")
# connect_data.update({gateway_name: True})
# save_json("proxy_connect_status.json", connect_data)
main_engine.write_log("连接BINANCES接口")
sleep(10)
# rpc_engine.start()
cta_engine.init_engine()
main_engine.write_log("CTA策略初始化完成")
cta_engine.init_all_strategies()
sleep(10) # Leave enough time to complete strategy initialization
main_engine.write_log("CTA策略全部初始化")
cta_engine.start_all_strategies()
main_engine.write_log("CTA策略全部启动")
try:
while True:
# connect_data = load_json("proxy_connect_status.json")
# if not connect_data.get(gateway_name):
# main_engine.connect(binances_setting, gateway_name)
# connect_data.update(gateway_name, True)
# save_json("proxy_connect_status.json", connect_data)
# print("重连接口")
sleep(10)
except KeyboardInterrupt:
main_engine.write_log("CTA策略正在退出")
cta_engine.close()
# rpc_engine.close()
main_engine.close()
def connect(self):
"""
Get setting value from line edits and connect the gateway.
获取配置从文本框，然后连接交易通道
"""
setting = {}
# 读取配置文件里的配置
setting = load_json(self.filename)
# 引入日志模块
self.main_engine.connect(setting, self.gateway_name)
def load_setting(self):
"""
从setting_filename里面加载，要存入数据库的交易对
:return:
"""
setting = load_json(self.setting_filename)
# 存入数据库的 tick 交易对
self.tick_recordings = setting.get("tick", {})
# 存入数据库的 bar 交易对
self.bar_recordings = setting.get("bar", {})
def load_strategy_setting(self):
"""
Load setting file.
"""
self.strategy_setting = load_json(self.setting_filename)
for strategy_name, strategy_config in self.strategy_setting.items():
self.add_strategy(strategy_config["class_name"], strategy_name,
strategy_config["spread_name"],
strategy_config["setting"])
def data_record(start, end, vt_symbol):
from vnpy.trader.database import database_manager
from vnpy.gateway.ib.ib_gateway import IbGateway
from vnpy.trader.utility import load_json
from vnpy.trader.object import HistoryRequest
from vnpy.trader.constant import Interval, Exchange
from dateutil import parser
from vnpy.event.engine import EventEngine
from vnpy.trader.event import EVENT_LOG
vt_symbol = vt_symbol
symbol, exchange = vt_symbol.split('.')
if not start and not end:
offset = 0 if dt.datetime.now().time() > dt.time(17, 0) else 1
start = (dt.datetime.today() - dt.timedelta(days=offset + 1)).replace(
hour=17, minute=0, second=0, microsecond=0)
end = (dt.datetime.today() - dt.timedelta(days=offset)).replace(
hour=17, minute=0, second=0, microsecond=0)
else:
start = parser.parse(start)
end = parser.parse(end) if end else end
ib_settings = load_json('connect_ib.json')
ib_settings["客户号"] += 4
recorder_engine = EventEngine()
def log(event):
data = event.data
print(data.level, data.msg)
recorder_engine.register(EVENT_LOG, log)
ib = IbGateway(recorder_engine)
try:
recorder_engine.start()
ib.connect(ib_settings)
if ib.api.client.isConnected():
req = HistoryRequest(symbol, Exchange(exchange), start, end,
Interval.MINUTE)
ib.write_log(f'发起请求#{vt_symbol}, {start}至{end}')
his_data = ib.query_history(req)
ib.write_log(
f'获得数据#{vt_symbol}， {his_data[0].datetime}至{his_data[-1].datetime}, 共{len(his_data)}条'
)
database_manager.save_bar_data(his_data)
ib.write_log(f'成功入库')
else:
ib.write_log('连接失败！请检查客户号是否被占用或IP是否正确')
except Exception as e:
raise e
finally:
ib.close()
recorder_engine.stop()
def load_strategy_setting(self):
"""
Load setting file.
"""
self.strategy_setting = load_json(self.setting_filename)
# turn to load_json in utility
for strategy_name, strategy_config in self.strategy_setting.items():
# setting is a dicionary，and value is also a dictionary，dic nest dict
self.add_strategy(strategy_config["class_name"], strategy_name,
strategy_config["vt_symbol"],
strategy_config["setting"])
def load_data(self) -> None:
""""""
position_data = load_json(self.data_filename)
for d in position_data:
vt_symbol = d["vt_symbol"]
direction = Direction(d["direction"])
position = self.get_position(vt_symbol, direction)
position.volume = d["volume"]
position.price = d["price"]
def load_daily_close_setting(self):
setting = load_json(self.daily_close_filename)
if 'time' in setting:
try:
self.daily_close_setting = datetime.now().replace(
hour=setting['time'][0],
minute=setting['time'][1],
second=0)
except Exception as e:
self.write_log(f"配置日内平仓错误：{e}")
else:
self.daily_close_setting = {}
def load_strategy_setting(self):
"""
Load setting file.
"""
self.strategy_setting = load_json(self.setting_filename)
for strategy_name, strategy_config in self.strategy_setting.items():
self.add_strategy(
strategy_config["class_name"],
strategy_name,
strategy_config["vt_symbol"],
strategy_config["setting"]
)
def reload_strategy_class(self):
""""""
self.backtester_engine.reload_strategy_class()
self.class_combo.clear()
self.init_strategy_settings()
setting = load_json(self.setting_filename)
if not setting:
return
self.class_combo.setCurrentIndex(
self.class_combo.findText(setting["class_name"]))
def __init__(self):
# 和交易系统连接成功将有log信息在控制台打印
SETTINGS["log.active"] = True
SETTINGS["log.level"] = INFO
SETTINGS["log.console"] = True
setting = load_json("connect_ctp.json")
self.main_engine = MainEngine()
self.main_engine.add_gateway(CtpGateway)
self.main_engine.connect(setting, "CTP")
self.filename = "contracts"
self.con_type_dict = {"主连": "L8", "指数": "L9"}
def load_setting(self) -> None:
""""""
fields = [
"price_spread", "volatility_spread", "max_pos", "target_pos",
"max_order_size", "direction"
]
setting = load_json(self.setting_filename)
for vt_symbol, cells in self.cells.items():
buf = setting.get(vt_symbol, None)
if buf:
for field in fields:
cells[field].set_value(buf[field])
def load_setting(self) -> None:
"""
加载差价模块的配置
:return:
"""
setting = load_json(self.setting_filename)
for spread_setting in setting:
self.add_spread(
# 差价交易名
spread_setting["name"],
# 每一条腿的详细配置
spread_setting["leg_settings"],
# 主动腿
spread_setting["active_symbol"],
save=False)
def load_strategy_data(self):
"""
Load strategy data from json file.
"""
self.strategy_data = load_json(self.data_filename)
