senset/vnpy
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

[Mod] change RiskManager to use QDialog

Browse Source
This commit is contained in:
vn.py 2019-06-02 14:51:15 +08:00
parent 6311bb510e
commit 41bcf7b605
7 changed files with 152 additions and 176 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
tests/trader/run.py
View File

@ -25,6 +25,7 @@ from vnpy.app.csv_loader import CsvLoaderApp
from vnpy.app.algo_trading import AlgoTradingApp
from vnpy.app.cta_backtester import CtaBacktesterApp
from vnpy.app.data_recorder import DataRecorderApp
from vnpy.app.risk_manager import RiskManagerApp
def main():
@ -55,6 +56,7 @@ def main():
main_engine.add_app(CsvLoaderApp)
main_engine.add_app(AlgoTradingApp)
main_engine.add_app(DataRecorderApp)
main_engine.add_app(RiskManagerApp)
main_window = MainWindow(main_engine, event_engine)
main_window.showMaximized()

4
vnpy/app/risk_manager/__init__.py
View File

@ -8,7 +8,7 @@ class RiskManagerApp(BaseApp):
app_name = APP_NAME
app_module = __module__
app_path = Path(__file__).parent
display_name = "风险控制"
display_name = "交易风控"
engine_class = RiskManagerEngine
widget_name = "RiskManager"
icon_name = "risk_manager.ico"
icon_name = "rm.ico"

123
vnpy/app/risk_manager/engine.py
View File

@ -24,23 +24,33 @@ class RiskManagerEngine(BaseEngine):
self.event_engine = event_engine
self.active = False
self.order_flow_count = 0
self.order_flow_limit = 50
self.order_flow_clear = 1
self.order_flow_timer = 0
self.order_size_limit = 100
self.trade_count = 0
self.trade_limit = 1000
self.order_cancel_limit = 10
self.order_cancel_counts = defaultdict(int)
self.active_order_limit = 20
# Patch send order function of MainEngine
self._send_order = self.main_engine.send_order
self.main_engine.send_order = self.send_order
self.order_cancel_limit = 500
self.order_cancel_counts = defaultdict(int)
self.active_order_limit = 50
self.load_setting()
self.register_event()
self.patch_send_order()
def patch_send_order(self):
"""
Patch send order function of MainEngine.
"""
self._send_order = self.main_engine.send_order
self.main_engine.send_order = self.send_order
def send_order(self, req: OrderRequest, gateway_name: str):
""""""
@ -50,19 +60,22 @@ class RiskManagerEngine(BaseEngine):
return self._send_order(req, gateway_name)
def load_setting(self):
def update_setting(self, setting: dict):
""""""
setting = load_json(self.setting_filename)
self.active = setting["active"]
self.order_flow_limit = setting["order_flow_limit"]
self.order_flow_clear = setting["order_flow_clear"]
self.order_size_limit = setting["order_size_limit"]
self.trade_limit = setting["trade_limit"]
self.active_order_limit = setting["active_order_limit"]
self.order_cancel_limit = setting["order_cancel_limit"]
self.active = setting.get("active", self.active)
self.order_flow_limit = setting.get("order_flow_limit", self.order_flow_count)
self.order_flow_clear = setting.get("order_flow_clear", self.order_flow_clear)
self.order_size_limit = setting.get("order_size_limit", self.order_size_limit)
self.trade_limit = setting.get("trade_limit", self.trade_limit)
self.active_order_limit = setting.get("active_order_limit", self.active_order_limit)
self.order_cancel_limit = setting.get("order_cancel_limit", self.order_cancel_limit)
if self.active:
self.write_log("交易风控功能启动")
else:
self.write_log("交易风控功能停止")
def save_setting(self):
def get_setting(self):
""""""
setting = {
"active": self.active,
@ -73,7 +86,19 @@ class RiskManagerEngine(BaseEngine):
"active_order_limit": self.active_order_limit,
"order_cancel_limit": self.order_cancel_limit,
}
return setting
def load_setting(self):
""""""
setting = load_json(self.setting_filename)
if not setting:
return
self.update_setting(setting)
def save_setting(self):
""""""
setting = self.get_setting()
save_json(self.setting_filename, setting)
def register_event(self):
@ -102,7 +127,7 @@ class RiskManagerEngine(BaseEngine):
self.order_flow_count = 0
self.order_flow_timer = 0
def write_risk_log(self, msg: str):
def write_log(self, msg: str):
""""""
log = LogData(msg=msg, gateway_name="RiskManager")
event = Event(type=EVENT_LOG, data=log)
@ -115,81 +140,39 @@ class RiskManagerEngine(BaseEngine):
# Check order volume
if req.volume <= 0:
self.write_risk_log("委托数量必须大于0")
self.write_log("委托数量必须大于0")
return False
if req.volume > self.order_size_limit:
self.write_risk_log(f"单笔委托数量{req.volume}，超过限制{self.order_size_limit}")
self.write_log(
f"单笔委托数量{req.volume}，超过限制{self.order_size_limit}")
return False
# Check trade volume
if self.trade_count >= self.trade_limit:
self.write_risk_log(f"今日总成交合约数量{self.trade_count}，超过限制{self.trade_limit}")
self.write_log(
f"今日总成交合约数量{self.trade_count}，超过限制{self.trade_limit}")
return False
# Check flow count
if self.order_flow_count >= self.order_flow_limit:
self.write_risk_log(f"委托流数量{self.order_flow_count}，超过限制每{self.order_flow_clear}秒{self.order_flow_limit}次")
self.write_log(
f"委托流数量{self.order_flow_count}，超过限制每{self.order_flow_clear}秒{self.order_flow_limit}次")
return False
# Check all active orders
active_order_count = len(self.main_engine.get_all_active_orders())
if active_order_count >= self.active_order_limit:
self.write_risk_log(f"当前活动委托次数{active_order_count}，超过限制{self.active_order_limit}")
self.write_log(
f"当前活动委托次数{active_order_count}，超过限制{self.active_order_limit}")
return False
# Check order cancel counts
if req.symbol in self.order_cancel_counts and self.order_cancel_counts[req.symbol] >= self.order_cancel_limit:
self.write_risk_log(f"当日{req.symbol}撤单次数{self.order_cancel_counts[req.symbol]}，超过限制{self.order_cancel_limit}")
self.write_log(
f"当日{req.symbol}撤单次数{self.order_cancel_counts[req.symbol]}，超过限制{self.order_cancel_limit}")
return False
# Add flow count if pass all checks
self.order_flow_count += 1
return True
def clear_order_flow_count(self):
""""""
self.order_flow_count = 0
self.write_risk_log("清空流控计数")
def clear_trade_count(self):
""""""
self.trade_count = 0
self.write_risk_log("清空总成交计数")
def set_order_flow_limit(self, n):
""""""
self.order_flow_limit = n
def set_order_flow_clear(self, n):
""""""
self.order_flow_clear = n
def set_order_size_limit(self, n):
""""""
self.order_size_limit = n
def set_trade_limit(self, n):
""""""
self.trade_limit = n
def set_active_order_limit(self, n):
""""""
self.active_order_limit = n
def set_order_cancel_limit(self, n):
""""""
self.order_cancel_limit = n
def switch_engine_status(self):
""""""
self.active = not self.active
if self.active:
self.write_risk_log("风险管理功能启动")
else:
self.write_risk_log("风险管理功能停止")
def stop(self):
""""""
self.save_setting()

BIN
vnpy/app/risk_manager/ui/risk_manager.ico
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 66 KiB

BIN
vnpy/app/risk_manager/ui/rm.ico Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 59 KiB

145
vnpy/app/risk_manager/ui/widget.py
View File

@ -4,7 +4,7 @@ from vnpy.trader.ui import QtWidgets
from ..engine import APP_NAME
class RiskManager(QtWidgets.QWidget):
class RiskManager(QtWidgets.QDialog):
""""""
def __init__(self, main_engine: MainEngine, event_engine: EventEngine):
@ -13,104 +13,95 @@ class RiskManager(QtWidgets.QWidget):
self.main_engine = main_engine
self.event_engine = event_engine
self.risk_manager_engine = main_engine.get_engine(APP_NAME)
self.rm_engine = main_engine.get_engine(APP_NAME)
self.init_ui()
self.update_engine_status()
def init_ui(self):
""""""
self.setWindowTitle("风险控制")
self.setWindowTitle("交易风控")
# SpinBox
self.order_flow_limit = RiskManagerSpinBox(0)
self.order_flow_clear = RiskManagerSpinBox(0)
self.order_size_limit = RiskManagerSpinBox(0)
self.trade_limit = RiskManagerSpinBox(0)
self.active_order_limit = RiskManagerSpinBox(0)
self.order_cancel_limit = RiskManagerSpinBox(0)
# Create widgets
self.active_combo = QtWidgets.QComboBox()
self.active_combo.addItems(["停止", "启动"])
# Button
self.switch_button = QtWidgets.QPushButton("风控模块未启动")
clear_order_count_button = QtWidgets.QPushButton("清空流控计数")
clear_trade_count_button = QtWidgets.QPushButton("清空总成交计数")
save_setting_button = QtWidgets.QPushButton("保存设置")
self.flow_limit_spin = RiskManagerSpinBox()
self.flow_clear_spin = RiskManagerSpinBox()
self.size_limit_spin = RiskManagerSpinBox()
self.trade_limit_spin = RiskManagerSpinBox()
self.active_limit_spin = RiskManagerSpinBox()
self.cancel_limit_spin = RiskManagerSpinBox()
# Grid layout
Label = QtWidgets.QLabel
grid = QtWidgets.QGridLayout()
grid.addWidget(Label("工作状态"), 0, 0)
grid.addWidget(self.switch_button, 0, 1)
grid.addWidget(Label("流控上限"), 1, 0)
grid.addWidget(self.order_flow_limit, 1, 1)
grid.addWidget(Label("流控清空（秒）"), 2, 0)
grid.addWidget(self.order_flow_clear, 2, 1)
grid.addWidget(Label("单笔委托上限"), 3, 0)
grid.addWidget(self.order_size_limit, 3, 1)
grid.addWidget(Label("总成交上限"), 4, 0)
grid.addWidget(self.trade_limit, 4, 1)
grid.addWidget(Label("活动订单上限"), 5, 0)
grid.addWidget(self.active_order_limit, 5, 1)
grid.addWidget(Label("单合约撤单上限"), 6, 0)
grid.addWidget(self.order_cancel_limit, 6, 1)
save_button = QtWidgets.QPushButton("保存")
save_button.clicked.connect(self.save_setting)
# Horizontal box layout
hbox = QtWidgets.QHBoxLayout()
hbox.addWidget(clear_order_count_button)
hbox.addWidget(clear_trade_count_button)
hbox.addWidget(save_setting_button)
# Form layout
form = QtWidgets.QFormLayout()
form.addRow("风控运行状态", self.active_combo)
form.addRow("委托流控上限（笔）", self.flow_limit_spin)
form.addRow("委托流控清空（秒）", self.flow_clear_spin)
form.addRow("单笔委托上限（数量）", self.size_limit_spin)
form.addRow("总成交上限（笔）", self.trade_limit_spin)
form.addRow("活动委托上限（笔）", self.active_limit_spin)
form.addRow("合约撤单上限（笔）", self.cancel_limit_spin)
form.addRow(save_button)
# Vertical box layout
vbox = QtWidgets.QVBoxLayout()
vbox.addLayout(grid)
vbox.addLayout(hbox)
self.setLayout(vbox)
# Connect signal to SpinBox
self.order_flow_limit.valueChanged.connect(self.risk_manager_engine.set_order_flow_limit)
self.order_flow_clear.valueChanged.connect(self.risk_manager_engine.set_order_flow_clear)
self.order_size_limit.valueChanged.connect(self.risk_manager_engine.set_order_size_limit)
self.trade_limit.valueChanged.connect(self.risk_manager_engine.set_trade_limit)
self.active_order_limit.valueChanged.connect(self.risk_manager_engine.set_active_order_limit)
self.order_cancel_limit.valueChanged.connect(self.risk_manager_engine.set_order_cancel_limit)
# Connect signal to button
self.switch_button.clicked.connect(self.switch_engine_status)
clear_order_count_button.clicked.connect(self.risk_manager_engine.clear_order_flow_count)
clear_trade_count_button.clicked.connect(self.risk_manager_engine.clear_trade_count)
save_setting_button.clicked.connect(self.risk_manager_engine.save_setting)
self.setLayout(form)
# Set Fix Size
self.setFixedSize(self.sizeHint())
hint = self.sizeHint()
self.setFixedSize(hint.width() * 1.2, hint.height())
def switch_engine_status(self):
def save_setting(self):
""""""
self.risk_manager_engine.switch_engine_status()
self.update_engine_status()
def update_engine_status(self):
""""""
if self.risk_manager_engine.active:
self.switch_button.setText("风控模块运行中")
self.order_flow_limit.setValue(self.risk_manager_engine.order_flow_limit)
self.order_flow_clear.setValue(self.risk_manager_engine.order_flow_clear)
self.order_size_limit.setValue(self.risk_manager_engine.order_size_limit)
self.trade_limit.setValue(self.risk_manager_engine.trade_limit)
self.active_order_limit.setValue(self.risk_manager_engine.active_order_limit)
self.order_cancel_limit.setValue(self.risk_manager_engine.order_cancel_limit)
active_text = self.active_combo.currentText()
if active_text == "启动":
active = True
else:
self.switch_button.setText("风控模块未启动")
active = False
self.risk_manager_engine.save_setting()
setting = {
"active": active,
"order_flow_limit": self.flow_limit_spin.value(),
"order_flow_clear": self.flow_clear_spin.value(),
"order_size_limit": self.size_limit_spin.value(),
"trade_limit": self.trade_limit_spin.value(),
"active_order_limit": self.active_limit_spin.value(),
"order_cancel_limit": self.cancel_limit_spin.value(),
}
self.rm_engine.update_setting(setting)
self.rm_engine.save_setting()
self.close()
def update_setting(self):
""""""
setting = self.rm_engine.get_setting()
if setting["active"]:
self.active_combo.setCurrentIndex(1)
else:
self.active_combo.setCurrentIndex(0)
self.flow_limit_spin.setValue(setting["order_flow_limit"])
self.flow_clear_spin.setValue(setting["order_flow_clear"])
self.size_limit_spin.setValue(setting["order_size_limit"])
self.trade_limit_spin.setValue(setting["trade_limit"])
self.active_limit_spin.setValue(setting["active_order_limit"])
self.cancel_limit_spin.setValue(setting["order_cancel_limit"])
def exec_(self):
""""""
self.update_setting()
super().exec_()
class RiskManagerSpinBox(QtWidgets.QSpinBox):
""""""
def __init__(self, value):
def __init__(self, value: int = 0):
""""""
super(RiskManagerSpinBox, self).__init__()
super().__init__()
self.setMinimum(0)
self.setMaximum(1000000)
self.setValue(value)

4
vnpy/trader/ui/mainwindow.py
View File

@ -187,7 +187,7 @@ class MainWindow(QtWidgets.QMainWindow):
if not dialog:
dialog = ConnectDialog(self.main_engine, gateway_name)
dialog.exec()
dialog.exec_()
def closeEvent(self, event):
"""
@ -222,7 +222,7 @@ class MainWindow(QtWidgets.QMainWindow):
self.widgets[name] = widget
if isinstance(widget, QtWidgets.QDialog):
widget.exec()
widget.exec_()
else:
widget.show()