vnpy源码阅读学习（9）回到OptionMaster
回到OptionMaster
根据我们对APP调用的代码阅读，我们基本上知道了一个APP是如何被调用，那么我们回到OptionMaster学习下这个APP的实现。
看看结构
class OptionManager(QtWidgets.QWidget):
""""""
signal_new_portfolio = QtCore.pyqtSignal(Event)
def __init__(self, main_engine: MainEngine, event_engine: EventEngine):
pass
def init_ui(self):
pass
def register_event(self):
pass
def process_new_portfolio_event(self, event: Event):
pass
def update_portfolio_combo(self):
pass
def open_portfolio_dialog(self):
pass
def init_widgets(self):
pass
def calculate_underlying_adjustment(self):
pass
通过结构和注释，我们基本上知道这是一个期权方面的APP。我们来对代码进行仔细学习
__init__
def __init__(self, main_engine: MainEngine, event_engine: EventEngine):
""""""
super().__init__()
self.main_engine = main_engine
self.event_engine = event_engine
self.option_engine = main_engine.get_engine(APP_NAME)
self.portfolio_name: str = ""
self.market_monitor: OptionMarketMonitor = None
self.greeks_monitor: OptionGreeksMonitor = None
self.docks: List[QtWidgets.QDockWidget] = []
self.init_ui()
self.register_event()
在init中我们看到和MainWindow不一样的地方出了main_engine和event_engin还加入了一个他自己的引擎，这个引擎是在app注册时候配置在engine_class中的。然后有两个报表：market_monitor和greeks_monitor
init_ui
def init_ui(self):
#具体实现
self.portfolio_button = QtWidgets.QPushButton("配置")
self.portfolio_button.clicked.connect(self.open_portfolio_dialog)
简单的界面配置我们通过运行程序看到实现的大概如下
我们只看到portfolio_button点击以后调用了self.open_portfolio_dialog
open_portfolio_dialog
def open_portfolio_dialog(self):
""""""
portfolio_name = self.portfolio_combo.currentText()
if not portfolio_name:
return
self.portfolio_name = portfolio_name
dialog = PortfolioDialog(self.option_engine, portfolio_name)
result = dialog.exec_()
if result == dialog.Accepted:
self.portfolio_combo.setEnabled(False)
self.portfolio_button.setEnabled(False)
self.init_widgets()
我们看到点击配置以后，如果有选择期权产品，则弹出 PortfolioDialog对话框。根据对话框的执行结果，如果点击了接受，则下拉框和配置按钮不可用，然后执行init_widgets
init_widgets
def init_widgets(self):
""""""
self.market_monitor = OptionMarketMonitor(self.option_engine, self.portfolio_name)
self.greeks_monitor = OptionGreeksMonitor(self.option_engine, self.portfolio_name)
self.manual_trader = OptionManualTrader(self.option_engine, self.portfolio_name)
self.market_monitor.itemDoubleClicked.connect(self.manual_trader.update_symbol)
self.market_button.clicked.connect(self.market_monitor.showMaximized)
self.greeks_button.clicked.connect(self.greeks_monitor.showMaximized)
self.manual_button.clicked.connect(self.manual_trader.show)
self.chain_button.clicked.connect(self.calculate_underlying_adjustment)
for button in [
self.market_button,
self.greeks_button,
self.chain_button,
self.manual_button
]:
button.setEnabled(True)
我们看到则是对market_monitor，greeks_monitor，manual_trader进行实例化，并且绑定了事件的信号插槽。同时对一些按钮进行了绑定，基本上都是窗体的显示。主要是以下按钮和窗体的显示的对应
self.market_button = QtWidgets.QPushButton("T型报价")
self.greeks_button = QtWidgets.QPushButton("持仓希腊值")
self.chain_button = QtWidgets.QPushButton("拟合升贴水")
self.manual_button = QtWidgets.QPushButton("快速交易")
而且每一个窗体都传入了该APP定义的engine
register_event
我们在__init__方法中同时看到了此方法的调用。
def register_event(self):
""""""
self.signal_new_portfolio.connect(self.process_new_portfolio_event)
self.event_engine.register(EVENT_OPTION_NEW_PORTFOLIO, self.signal_new_portfolio.emit)
我们看到该方法把 process_new_portfolio_event的Handler和register到了MainEngine中去。
process_new_portfolio_event
def process_new_portfolio_event(self, event: Event):
""""""
self.update_portfolio_combo()
def update_portfolio_combo(self):
""""""
if not self.portfolio_combo.isEnabled():
return
self.portfolio_combo.clear()
portfolio_names = self.option_engine.get_portfolio_names()
self.portfolio_combo.addItems(portfolio_names)
根据handler的调用来更新期权产品的列表
calculate_underlying_adjustment
self.chain_button.clicked.connect(self.calculate_underlying_adjustment)
def calculate_underlying_adjustment(self):
""""""
portfolio = self.option_engine.get_portfolio(self.portfolio_name)
for chain in portfolio.chains.values():
chain.calculate_underlying_adjustment()
我们看到 快速交易点击以后，会执行从引擎中获得期权产品的数据，然后执行calculate_underlying_adjustment（）方法，要继续深入下去，我们有几个方向：
- market_monitor
- greeks_monitor
- manual_trader
- option_engine
- calculate_underlying_adjustment
我们还是从周围向心脏的方式学习，先看看几个窗体，然后随后深入引擎的代码学习
market_monitor
class OptionMarketMonitor(MonitorTable):
def __init__(self, option_engine: OptionEngine, portfolio_name: str):
def init_ui(self):
def register_event(self):
def process_tick_event(self, event: Event):
def process_trade_event(self, event: Event):
def process_position_event(self, event: Event):
def update_pos(self, vt_symbol: str):
def update_price(self, vt_symbol: str):
def update_impv(self, vt_symbol: str):
def update_greeks(self, vt_symbol: str):
def scroll_to_middle(self):
def resizeEvent(self, event: QtGui.QResizeEvent):
我们看到 OptionMarketMonitor继承了MonitorTable，而MonitorTable基本上和框架里面的MonitorBase如出一辙。其实大量代码几乎可以重用。
我们先来看看这个类的具体代码，最值得琢磨的其实是这个
def register_event(self):
""""""
self.signal_tick.connect(self.process_tick_event)
self.signal_trade.connect(self.process_trade_event)
self.signal_position.connect(self.process_position_event)
self.event_engine.register(EVENT_TICK, self.signal_tick.emit)
self.event_engine.register(EVENT_TRADE, self.signal_trade.emit)
self.event_engine.register(EVENT_POSITION, self.signal_position.emit)
def __init__(self, option_engine: OptionEngine, portfolio_name: str):
""""""
super().__init__()
self.option_engine = option_engine
self.event_engine = option_engine.event_engine
self.portfolio_name = portfolio_name
把处理tick事件，交易事件，仓位事件都和OptionEngine连接起来。
而这些处理的Handler无非根据信息改变界面，就不一一研究。
其他窗体
class OptionManualTrader(QtWidgets.QWidget):
def __init__(self, option_engine: OptionEngine, portfolio_name: str):
""""""
super().__init__()
self.option_engine = option_engine
self.main_engine: MainEngine = option_engine.main_engine
self.event_engine: EventEngine = option_engine.event_engine
我们可以看到窗体不但对自己的引擎OptionEngine，而且也对mainEngin和EventEngine有所调用。
def send_order(self):
""""""
symbol = self.symbol_line.text()
contract = self.contracts.get(symbol, None)
if not contract:
return
price_text = self.price_line.text()
volume_text = self.volume_line.text()
if not price_text or not volume_text:
return
price = float(price_text)
volume = int(volume_text)
direction = Direction(self.direction_combo.currentText())
offset = Offset(self.offset_combo.currentText())
req = OrderRequest(
symbol=contract.symbol,
exchange=contract.exchange,
direction=direction,
type=OrderType.LIMIT,
offset=offset,
volume=volume,
price=price
)
self.main_engine.send_order(req, contract.gateway_name)
整个是通过main_engin来下单的。而在分析主引擎的时候我们知道send_order正是通过gateway_name来下单的。
而gateway_name来自contract合约
而合约来自main_engin
def init_contracts(self):
""""""
contracts = self.main_engine.get_all_contracts()
for contract in contracts:
self.contracts[contract.symbol] = contract
我们可以想象得到。而main_engine中合约的信息又来自OmsEngine 指定管理系统 (Order Manage System)
接下来我们要继续深入就必须深入到引擎的内容了。
