def remove_strategy_setting(self, strategy_name: str):
"""
Update setting file.
"""
if strategy_name not in self.strategy_setting:
return
self.strategy_setting.pop(strategy_name)
save_json(self.setting_filename, self.strategy_setting)
def remove_strategy_setting(self, strategy_name: str):
"""
Update setting file.
"""
if strategy_name not in self.strategy_setting:
return
self.strategy_setting.pop(strategy_name)
save_json(self.setting_filename, self.strategy_setting)
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 sync_strategy_data(self, strategy: CtaTemplate):
"""
Sync strategy data into json file.
"""
data = strategy.get_variables()
data.pop("inited") # Strategy status (inited, trading) should not be synced.
data.pop("trading")
self.strategy_data[strategy.strategy_name] = data
save_json(self.data_filename, self.strategy_data)
def sync_strategy_data(self, strategy: CtaTemplate):
"""
Sync strategy data into json file.
"""
data = strategy.get_variables()
data.pop("inited") # Strategy status (inited, trading) should not be synced.
data.pop("trading")
self.strategy_data[strategy.strategy_name] = data
save_json(self.data_filename, self.strategy_data)
def save_setting(self):
"""
保存 setting_filename = "data_recorder_setting.json"
:return:
"""
setting = {
"tick": self.tick_recordings,
"bar": self.bar_recordings
}
save_json(self.setting_filename, setting)
def update_strategy_setting(self, strategy_name: str, setting: dict):
"""
Update setting file.
"""
strategy = self.strategies[strategy_name]
self.strategy_setting[strategy_name] = {
"class_name": strategy.__class__.__name__,
"vt_symbol": strategy.vt_symbol,
"setting": setting,
}
save_json(self.setting_filename, self.strategy_setting)
def save_data(self) -> None:
""""""
data = {"date": datetime.now().strftime("%Y-%m-%d")}
for contract_result in self.contract_results.values():
key = f"{contract_result.reference},{contract_result.vt_symbol}"
data[key] = {
"open_pos": contract_result.open_pos,
"last_pos": contract_result.last_pos
}
save_json(self.data_filename, data)
def update_strategy_setting(self, strategy_name: str, setting: dict):
"""
Update setting file.
"""
strategy = self.strategies[strategy_name]
self.strategy_setting[strategy_name] = {
"class_name": strategy.__class__.__name__,
"spread_name": strategy.spread_name,
"setting": setting,
}
save_json(self.setting_filename, self.strategy_setting)
def update_strategy_setting(self, strategy_name: str, setting: dict):
"""
Update setting file.
更新配置文件
"""
strategy = self.strategies[strategy_name]
self.strategy_setting[strategy_name] = {
"class_name": strategy.__class__.__name__,
"vt_symbol": strategy.vt_symbol,
"setting": setting,
}
save_json(self.setting_filename, self.strategy_setting)
def update_strategy_setting(self, strategy_name: str, setting: dict):
"""
Update setting file.
把策略的参数传入到参数文件夹保存
"""
strategy = self.strategies[strategy_name]
# 根据策略名称获取策略实例
self.strategy_setting[strategy_name] = {
"class_name": strategy.__class__.__name__,
"vt_symbol": strategy.vt_symbol,
"setting": setting,
}
# 配置策略参数
save_json(self.setting_filename, self.strategy_setting)
def save_strategy_setting(self):
"""
Save setting file.
"""
strategy_setting = {}
for name, strategy in self.strategies.items():
strategy_setting[name] = {
"class_name": strategy.__class__.__name__,
"vt_symbols": strategy.vt_symbols,
"setting": strategy.get_parameters()
}
save_json(self.setting_filename, strategy_setting)
def save_setting(self) -> None:
""""""
setting = []
for rule in self.rules.values():
d = {
"name": rule.name,
"formula": rule.formula,
"params": rule.params,
"ndigits": rule.ndigits
}
setting.append(d)
save_json(self.setting_filename, setting)
def save_setting(self):
""""""
# Save underlying adjustment
adjustment_settings = {}
for portfolio in self.active_portfolios.values():
adjustment_setting = {}
for chain in portfolio.chains.values():
adjustment_setting[chain.chain_symbol] = chain.underlying_adjustment
adjustment_settings[portfolio.name] = adjustment_setting
self.setting["underlying_adjustments"] = adjustment_settings
save_json(self.setting_filename, self.setting)
def add_tick_recording(vt_symbol: str):
if vt_symbol in tick_recordings:
print(f"已在Tick记录列表中：{vt_symbol}")
return
else:
symbol, exchange = vt_symbol.split(".")
tick_recordings[vt_symbol] = {
"symbol": symbol,
"exchange": exchange,
"gateway_name": gateway_name
}
save_json("data_recorder_setting.json", {"tick":tick_recordings, "bar":bar_recordings})
print(f"添加Tick记录成功：{vt_symbol}")
def save_setting(self) -> None:
""""""
fields = [
"price_spread", "volatility_spread", "max_pos", "target_pos",
"max_order_size", "direction"
]
setting = {}
for vt_symbol, cells in self.cells.items():
buf = {}
for field in fields:
buf[field] = cells[field].get_value()
setting[vt_symbol] = buf
save_json(self.setting_filename, setting)
def save_data(self) -> None:
""""""
position_data = []
for position in self.positions.values():
if not position.volume:
continue
d = {
"vt_symbol": position.vt_symbol,
"volume": position.volume,
"price": position.price,
"direction": position.direction.value
}
position_data.append(d)
save_json(self.data_filename, position_data)
from vnpy.trader.utility import load_json, save_json
# 更新使用的数据库名称
database_name = "JQDATA.db"
setting = load_json("vt_setting.json")
setting.update({"database.database": database_name})
save_json("vt_setting.json", setting)
# 加载回测品种信息
product_info = load_json("回测品种信息.json")
import sys
sys.path.append(r"C:\Users\Administrator\Desktop\VNPY\My_Strategies")
# import warnings
# warnings.filterwarnings("ignore")
from datetime import date
from vnpy.trader.constant import Interval
from vnpy.app.cta_strategy.base import BacktestingMode
from vnpy.app.cta_strategy.backtesting import BacktestingEngine, OptimizationSetting
def run_optimization(strategy, product, setting, ga=False):
engine = BacktestingEngine()
engine.set_parameters(vt_symbol=product_info[product]["vt_symbol"],
rate_type=product_info[product]["rate_type"],
rate=product_info[product]["rate"],
slippage=product_info[product]["slippage"],
size=product_info[product]["size"],
def save_cache_ip(best_ip: dict):
"""保存本地缓存的最快IP地址信息"""
config_file_name = os.path.abspath(
os.path.join(os.path.dirname(__file__), 'tdx_config.json'))
save_json(filename=config_file_name, data=best_ip)
def save_setting(self) -> None:
""""""
setting = {"timer_interval": self.timer_interval}
save_json(self.setting_filename, setting)
if(b_found == True) and (vt_symbol not in vt_symbols ) :
# 将文件夹内文件整理到file_names中
#if file_name not in file_names:
file_names.append(f"{file_path}\\{file_name}")
vt_symbols.append(vt_symbol)
pass
print("过滤处理后的合约文件数量: %d" % len(vt_symbols))
pool = multiprocessing.Pool(multiprocessing.cpu_count(), maxtasksperchild=1)
print("multiprocessing.cpu_count(): %d" % multiprocessing.cpu_count())
for setting in list(zip(file_names,vt_symbols)):
if setting[1].strip()=='':
continue
setting += (future_download,)
#pool.apply_async(save_tdx_data, setting)
pool.apply(save_tdx_data, setting)
pool.close()
pool.join()
#保存股票列表
if not future_download:
stock_vt_symbols = load_json("stock_vt_symbols.json")
for vt_symbol in vt_symbols:
if vt_symbol not in stock_vt_symbols:
stock_vt_symbols.append(vt_symbol)
save_json("stock_vt_symbols.json",stock_vt_symbols)
print("程序运行结束...自动退出")
def start_backtesting(self):
""""""
class_name = self.class_combo.currentText()
vt_symbol = self.symbol_line.text()
interval = self.interval_combo.currentText()
start = self.start_date_edit.dateTime().toPyDateTime()
end = self.end_date_edit.dateTime().toPyDateTime()
rate = float(self.rate_line.text())
slippage = float(self.slippage_line.text())
size = float(self.size_line.text())
pricetick = float(self.pricetick_line.text())
capital = float(self.capital_line.text())
if self.inverse_combo.currentText() == "正向":
inverse = False
else:
inverse = True
# Check validity of vt_symbol
if "." not in vt_symbol:
self.write_log("本地代码缺失交易所后缀，请检查")
return
_, exchange_str = vt_symbol.split(".")
if exchange_str not in Exchange.__members__:
self.write_log("本地代码的交易所后缀不正确，请检查")
return
# Save backtesting parameters
backtesting_setting = {
"class_name": class_name,
"vt_symbol": vt_symbol,
"interval": interval,
"start": start.isoformat(),
"rate": rate,
"slippage": slippage,
"size": size,
"pricetick": pricetick,
"capital": capital,
"inverse": inverse,
}
save_json(self.setting_filename, backtesting_setting)
# Get strategy setting
old_setting = self.settings[class_name]
dialog = BacktestingSettingEditor(class_name, old_setting)
i = dialog.exec()
if i != dialog.Accepted:
return
new_setting = dialog.get_setting()
self.settings[class_name] = new_setting
result = self.backtester_engine.start_backtesting(
class_name,
vt_symbol,
interval,
start,
end,
rate,
slippage,
size,
pricetick,
capital,
inverse,
new_setting
)
if result:
self.statistics_monitor.clear_data()
self.chart.clear_data()
self.trade_button.setEnabled(False)
self.order_button.setEnabled(False)
self.daily_button.setEnabled(False)
self.candle_button.setEnabled(False)
self.trade_dialog.clear_data()
self.order_dialog.clear_data()
self.daily_dialog.clear_data()
self.candle_dialog.clear_data()
def save_setting(self):
""""""
setting = self.get_setting()
save_json(self.setting_filename, setting)
def save_setting(self) -> None:
"""
Save underlying adjustment.
"""
save_json(self.setting_filename, self.setting)
def run_backtest(handler, submit_data_dict, strategy_setting_dict):
""""""
setting_filename = "cta_backtester_setting.json"
class_name = submit_data_dict['strategy']
vt_symbol = f"{submit_data_dict['symbol']}.{submit_data_dict['exchange']}"
interval = submit_data_dict['period']
start = datetime.strptime(
submit_data_dict['start_datetime'],
DATE_FORMAT
).date()
end = datetime.strptime(
submit_data_dict['end_datetime'],
DATE_FORMAT
).date()
rate = float(submit_data_dict['rate'])
slippage = float(submit_data_dict['slippage'])
size = float(submit_data_dict['size'])
pricetick = float(submit_data_dict['pricetick'])
capital = float(submit_data_dict['capital'])
if submit_data_dict['inverse_mode_selected'] == "正向":
inverse = False
else:
inverse = True
# fangyang add
if submit_data_dict['backtest_mode_selected'] == "Thread 运行回测": # "Debug 运行回测"
backtesting_debug_mode = False
else:
backtesting_debug_mode = True
#######################
# Save backtesting parameters
backtesting_setting = {
"class_name": class_name,
"vt_symbol": vt_symbol,
"interval": interval,
"rate": rate,
"slippage": slippage,
"size": size,
"pricetick": pricetick,
"capital": capital,
"inverse": inverse,
}
save_json(setting_filename, backtesting_setting)
# Get strategy setting
handler.multi_strategy_settings[class_name] = strategy_setting_dict
result = backtester.start_backtesting(
class_name,
vt_symbol,
interval,
start,
end,
rate,
slippage,
size,
pricetick,
capital,
inverse,
backtesting_debug_mode, # fangyang add
strategy_setting_dict
)
re_data_dict = {}
if result:
statistic_table_dict = get_statistic_result_dict()
balance_curve_dict = get_balance_curve_dict()
drawdown_curve_dict = get_drawdown_curve_dict()
pnl_bar_dict = get_pnl_bar_dict()
distribution_curve_dict = get_distribution_curve_dict()
daily_table_dict = get_backtesting_record_data(record_type="daily")
trade_table_dict = get_backtesting_record_data(record_type="trade")
order_table_dict = get_backtesting_record_data(record_type="order")
kline_dict = get_kline_dict()
re_data_dict = {
"statistics": statistic_table_dict,
"balance": balance_curve_dict,
"drawdown": drawdown_curve_dict,
"pnl": pnl_bar_dict,
"pnl_dist": distribution_curve_dict,
"kline": kline_dict,
"daily": daily_table_dict,
"trade": trade_table_dict,
"order": order_table_dict,
}
else:
re_data_dict["backtest_result"] = "Backtest Error !"
return re_data_dict
def calculate_statistics_and_save(df, save_path, capital):
"""计算策略监控参数"""
df["balance"] = df["net_pnl"].cumsum() + capital
df["return"] = np.log(df["balance"] / df["balance"].shift(1)).fillna(0)
df["highlevel"] = (df["balance"].rolling(min_periods=1,
window=len(df),
center=False).max())
df["drawdown"] = df["balance"] - df["highlevel"]
df["ddpercent"] = df["drawdown"] / df["highlevel"] * 100
start_date = df.index[0]
end_date = df.index[-1]
total_days = len(df)
profit_days = len(df[df["net_pnl"] > 0])
loss_days = len(df[df["net_pnl"] < 0])
end_balance = df["balance"].iloc[-1]
max_drawdown = df["drawdown"].min()
max_ddpercent = df["ddpercent"].min()
max_drawdown_end = df["drawdown"].idxmin()
if isinstance(max_drawdown_end, date):
max_drawdown_start = df["balance"][:max_drawdown_end].idxmax()
max_drawdown_duration = (max_drawdown_end -
max_drawdown_start).days
else:
max_drawdown_duration = 0
total_net_pnl = df["net_pnl"].sum()
daily_net_pnl = total_net_pnl / total_days
total_commission = df["commission"].sum()
daily_commission = total_commission / total_days
total_slippage = df["slippage"].sum()
daily_slippage = total_slippage / total_days
total_turnover = df["turnover"].sum()
daily_turnover = total_turnover / total_days
total_trade_count = df["trade_count"].sum()
daily_trade_count = total_trade_count / total_days
total_return = (end_balance / capital - 1) * 100
annual_return = total_return / total_days * 240
daily_return = df["return"].mean() * 100
return_std = df["return"].std() * 100
if return_std:
sharpe_ratio = daily_return / return_std * np.sqrt(240)
else:
sharpe_ratio = 0
return_drawdown_ratio = -total_return / max_ddpercent
statistics = {
"start_date": start_date,
"end_date": end_date,
"total_days": total_days,
"profit_days": profit_days,
"loss_days": loss_days,
"capital": capital,
"end_balance": end_balance,
"max_drawdown": max_drawdown,
"max_ddpercent": max_ddpercent,
"max_drawdown_duration": max_drawdown_duration,
"total_net_pnl": total_net_pnl,
"daily_net_pnl": daily_net_pnl,
"total_commission": total_commission,
"daily_commission": daily_commission,
"total_slippage": total_slippage,
"daily_slippage": daily_slippage,
"total_turnover": total_turnover,
"daily_turnover": daily_turnover,
"total_trade_count": total_trade_count,
"daily_trade_count": daily_trade_count,
"total_return": total_return,
"annual_return": annual_return,
"daily_return": daily_return,
"return_std": return_std,
"sharpe_ratio": sharpe_ratio,
"return_drawdown_ratio": return_drawdown_ratio,
}
for key, value in statistics.items():
if type(value) is int or type(value) is np.int64:
statistics[key] = float(value)
elif type(value) is np.float64:
statistics[key] = float('%.2f' % value)
save_json(os.path.join(save_path, "statistics.json"), statistics)
return statistics
def start_backtesting(self):
""""""
class_name = self.class_combo.currentText()
vt_symbol = f"{self.symbol_combo.currentText()}.{self.exchange_combo.currentText()}"
interval = self.interval_combo.currentText()
start = self.start_date_edit.date().toPyDate()
end = self.end_date_edit.date().toPyDate()
rate = float(self.rate_line.text())
slippage = float(self.slippage_line.text())
size = float(self.size_line.text())
pricetick = float(self.pricetick_line.text())
capital = float(self.capital_line.text())
if self.inverse_combo.currentText() == "正向":
inverse = False
else:
inverse = True
# fangyang add
if self.debug_combo.currentText() == "Thread 运行回测": # "Debug 运行回测"
backtesting_debug_mode = False
else:
backtesting_debug_mode = True
#######################
# Save backtesting parameters
backtesting_setting = {
"class_name": class_name,
"vt_symbol": vt_symbol,
"interval": interval,
"rate": rate,
"slippage": slippage,
"size": size,
"pricetick": pricetick,
"capital": capital,
"inverse": inverse,
}
save_json(self.setting_filename, backtesting_setting)
# Get strategy setting
old_setting = self.settings[class_name]
dialog = BacktestingSettingEditor(class_name, old_setting)
i = dialog.exec()
if i != dialog.Accepted:
return
new_setting = dialog.get_setting()
self.settings[class_name] = new_setting
result = self.backtester_engine.start_backtesting(
class_name,
vt_symbol,
interval,
start,
end,
rate,
slippage,
size,
pricetick,
capital,
inverse,
backtesting_debug_mode, # fangyang add
new_setting
)
if result:
self.statistics_monitor.clear_data()
self.chart.clear_data()
self.trade_button.setEnabled(False)
self.order_button.setEnabled(False)
self.daily_button.setEnabled(False)
self.candle_button.setEnabled(False)
self.trade_dialog.clear_data()
self.order_dialog.clear_data()
self.daily_dialog.clear_data()
self.candle_dialog.clear_data()
def close(self):
""""""
self.stop_all_strategies()
# 保存引擎配置
save_json(self.engine_filename, self.engine_config)
def remove_all():
tick_recordings = {}
bar_recordings = {}
save_json("data_recorder_setting.json", {"tick":tick_recordings, "bar":bar_recordings})
print(f"清除Tick和K线行情记录！")
def save_setting(self) -> None:
""""""
# For normal spread
setting = []
for spread in self.spreads.values():
if isinstance(spread, AdvancedSpreadData):
continue
leg_settings = []
for leg in spread.legs.values():
price_multiplier = spread.price_multipliers[leg.vt_symbol]
trading_multiplier = spread.trading_multipliers[leg.vt_symbol]
inverse_contract = spread.inverse_contracts[leg.vt_symbol]
leg_setting = {
"vt_symbol": leg.vt_symbol,
"price_multiplier": price_multiplier,
"trading_multiplier": trading_multiplier,
"inverse_contract": inverse_contract
}
leg_settings.append(leg_setting)
spread_setting = {
"name": spread.name,
"leg_settings": leg_settings,
"active_symbol": spread.active_leg.vt_symbol,
"min_volume": spread.min_volume
}
setting.append(spread_setting)
save_json(self.setting_filename, setting)
# For advanced spread
setting = []
for spread in self.spreads.values():
if not isinstance(spread, AdvancedSpreadData):
continue
leg_settings = []
for variable, vt_symbol in spread.variable_symbols.items():
trading_direction = spread.variable_directions[variable]
price_multiplier = spread.price_multipliers[vt_symbol]
trading_multiplier = spread.trading_multipliers[vt_symbol]
inverse_contract = spread.inverse_contracts[vt_symbol]
leg_setting = {
"variable": variable,
"vt_symbol": vt_symbol,
"trading_direction": trading_direction,
"trading_multiplier": trading_multiplier,
"inverse_contract": inverse_contract
}
leg_settings.append(leg_setting)
spread_setting = {
"name": spread.name,
"leg_settings": leg_settings,
"price_formula": spread.price_formula,
"active_symbol": spread.active_leg.vt_symbol,
"min_volume": spread.min_volume
}
setting.append(spread_setting)
save_json(self.advanced_filename, setting)
def save_algo_setting(self):
""""""
save_json(self.setting_filename, self.algo_settings)
def save_setting(self):
""""""
setting = {"tick": self.tick_recordings, "bar": self.bar_recordings}
save_json(self.setting_filename, setting)
def save_cache_json(data_dict: dict, json_file_name: str):
"""保存本地缓存的JSON配置信息"""
config_file_name = os.path.abspath(
os.path.join(os.path.dirname(__file__), json_file_name))
save_json(filename=config_file_name, data=data_dict)
