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 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)