在上篇文章期限利差怎么看文章中详细介绍了期限利差策略的内容，本次将介绍代码实现，重要的是理解整个交易的逻辑，为什么要这样去做？对以后写代码会有很大帮助。
首先导入相关库：
from typing import List, Dict
import numpy as np
import datetime
from base.constant import Direction, Offset, BusinessType
from bond.base.utility import ArrayManager
from base.constant import Direction, Offset, BusinessType
from bond.base.object import TickData, OrderData, TradeData, BarData, QuoteRequest, FactorData
from bond.base.template import StrategyTemplate
from bond.base.inter_base import BaseInterface
from bond.data.data_http import HttpDataHandler
from bond.base.inter_kslib import KSLibInterface, KSQuoteType
from util.common_exception import CommonException导入typing、numpy、datetime库，导入内部债券相关基本库做准备。
接下来定义好相关变量，所有都有说明：
class PairTradingStrategy(StrategyTemplate):
#合约1为长期债券，合约2为短期债券
variety_list = ['leg1_symbol', 'leg2_symbol']#用于套利的两个合约的参数名称
parameters = ['up_threshold', 'up_threshold_sell','down_threshold','down_threshold_sell', 'spread_length']#可变输入参数
variables = []
up_threshold = 0.8#利差突破债券上限的分位数，买入债券1，卖出债券2
up_threshold_sell=0.6#利差从债券上限回落的分位数，平仓
down_threshold = 0.2#利差突破债券下限的分位数，买入债券2，卖出债券1
down_threshold_sell=0.45#利差从债券下限回升的分位数，平仓
spread_length = 50#至少需要累积的利差数据长度
market_1 = []#存放债券1的行情数据————是一个object,key为leg1_symbol，value为price、yield等
market_2 = []#存放债券2的行情数据————是一个object,key为leg1_symbol，value为price、yield等
close_diff_list = []#存贮利差的list
time_list_filter = []# 过滤重复的时间戳
target_pos = {}#记录目标手数，防止因为债券行情导致的成交不到而不停发单
order_mess = QuoteRequest()
hdh = HttpDataHandler()
kslib = KSLibInterface()
# -------------------分隔线--------------------
leg1_symbol = '200210.BOND' #下单腿，用于成交的腿，20年国开10年期债券
leg2_symbol = '220305.BOND' #用于计算价差的另一腿,22年进出口5年期债券
start_date = '2023-02-25' # %Y-%m-%d
end_date = '2023-08-25' # %Y-%m-%d相关的输入界面如图：（注意：输入界面的所有参数都是可变的，输入会覆盖原定义的值）
定义含参数后，进行初始化：
def __init__(self, strategy_engine, strategy_name: str, vt_symbols: List[str], setting: dict = None,factors: List[str] = None):#注意：因子的初始化因为后面有接触因子回测这里就先初始化
#父类初始化，策略引擎、合约初始化
super().__init__(strategy_engine, strategy_name, vt_symbols,setting)
# Obtain contract info
self.leg1_symbol, self.leg2_symbol = vt_symbols
def on_init(self):
"""
时间戳、利差、仓位、行情数据初始化，输出日志
"""
self.write_log("策略初始化")
self.load_bars(0)
self.close_diff_list.clear()
self.time_list_filter.clear()
for s in self.vt_symbols:
self.target_pos[s] = 0
def on_start(self):
"""
Callback when strategy is started.
"""
self.write_log("策略启动")
self.put_event()
def on_stop(self):
"""
Callback when strategy is stopped.
"""
self.write_log("策略停止")
self.put_event()
def on_tick(self, tick: TickData):
pass
"""
Callback of new tick data update, 实时数据
"""下面获取行情数据进行数据处理：
def on_bars(self, bars: Dict[str, BarData]):
self.cancel_all()#取消所有订单
if self.leg1_symbol not in bars or self.leg2_symbol not in bars:
return
# bar_trade = bars[self.leg1_symbol]
# bar_base = bars[self.leg2_symbol]
"""
注意：必须要在前面先定义market_1和market_2两个对象 =[]，
原因：如果这里没有获取到行情，后续对market_1 or market_2处理时报错没找到对象
{也就是说：所有后续用到的变量最好是先定义}
"""
#获取bar线数据
for key in bars:
if key == self.leg1_symbol and bars[key].close_price > 80:
self.market_1.append(bars[key])
self.write_log("执行on_bars: %s - %s" % (key, str(bars[key])))
elif key == self.leg2_symbol and bars[key].close_price > 80:
self.market_2.append(bars[key])
self.write_log("执行on_bars: %s - %s" % (key, str(bars[key])))
"""
注意：bar里面是两个合约，每次获取一条行情，所以说下面的if与for对齐，
如果合约1或合约2没获取到行情就返回，并且上面for里面的每个if和else对应，为一组，上面是if和elif，不能是两个if，因为每次只能进一个选项，不是if就是elif
下面的if若也在for里面，每次获取两个合约中任意一个后就会判断是否为空，不可置疑，肯定有一个为空（每次对合约1或合约2获取一条行情数据），这样就导致永远无法继续执行下去，到这里就退出来行情函数
"""
if len(self.market_1) == 0 or len(self.market_2) == 0:
return
"""
注意：两个合约获取的日期必须是在同一天，同一天的行情才能进行比较
所以后续的所有交易买卖都在这个前提下进行
而且要注意market_1和market_2是对象，里面存储大量的行情，所以是对获取到的最新行情进行处理，也就是market_1[-1],如果是market_1就每次是对其第一条行情进行处理
"""
if self.market_1[-1].datetime == self.market_2[-1].datetime:
bar_close_trade = self.market_1[-1].yield_rate
self.write_log("%s ytm: %s" % (self.leg1_symbol,str(bar_close_trade)))
bar_close_base = self.market_2[-1].yield_rate
self.write_log("%s ytm: %s" % (self.leg2_symbol,str(bar_close_base)))
close_diff = bar_close_trade - bar_close_base
self.write_log("%s - %s 利差ytm: %s" % (self.leg1_symbol,self.leg2_symbol,str(close_diff)))
if len(self.close_diff_list) < self.spread_length: # 当利差保存数量小于最小值，则保存利差并跳过
self.close_diff_list.append(close_diff) # 保存利差
return
else:
spread_up = np.quantile(np.array(self.close_diff_list), self.up_threshold) # 上分位数
spread_up_sell = np.quantile(np.array(self.close_diff_list), self.up_threshold_sell) # 平仓的回落下分位数
spread_down = np.quantile(np.array(self.close_diff_list), self.down_threshold) # 下分位数
spread_down_sell = np.quantile(np.array(self.close_diff_list),self.down_threshold_sell) # 平仓的回升上分位数
self.write_log("利差动态上下限: %s - %s - %s - %s" % (spread_up,spread_up_sell,spread_down,spread_down_sell))
self.close_diff_list.pop(0) # 利差滚动存放
self.close_diff_list.append(close_diff)
"""
定义了一个计算利差所处分位数的函数，计算分位数时就会调用
"""
def calculate_percentile(current_value, spread_list):
sorted_spread = sorted(spread_list)
index = sorted_spread.index(current_value)
percentile = (index / len(spread_list)) * 100
return percentile
percentile = calculate_percentile(close_diff, self.close_diff_list)
self.write_log("当前利差所处分位数: %s" % (str(percentile)))进行好上述操作后，下面就要判断买卖操作逻辑了，具体逻辑如下：
"""
策略逻辑如下：
如果利差(10年-1年) > 以往利差的0.8上分位数,此时利率处在高位,预计未来向均值回归,利差缩小,要买入长期限债,就买入1手10年期债券,做空1手1年期短期债,
利差数据序列继续读利差数据,如果利差继续保持0.8分位数以上就继续买入，仓位不做限制，原本有仓位也买入，
若未来有一天利差缩小向均值回归，利差 < 0.6分位数，此时只要利差读到的数据满足该条件就一次性卖出全部仓位,加了个条件leg1_pos > 0有仓位才平仓,没仓位的话不会做空,
不用担心影响到接下来的利差骤降, < spread_down(0.2),不能做空合约1,从0.8分位数到0.2分位数必然会先被利差<0.6分位数逻辑识别到先对合约1平仓,再运行利差<0.2开空仓,
因为4个if是平齐的,假设运行了rate_diff > spread_up0.8分位数,势必会运行到rate_diff > spread_down_sell 0.45分位数,但后者的前提是合约1的仓位 < 0,
运行> spread_up0.8分位数后合约1的仓位肯定 >0,所以不用担心它们之间会有影响,做多1次合约1又做多一次合约1的错误逻辑
"""代码如下：
bar_trade_price =self.market_1[-1].close_price
bar_base_price =self.market_2[-1].close_price
#利率上行周期，买长卖短
if close_diff > spread_up: # 当价差大于布林带上界，买价差，买trade，卖base
leg1_pos = self.get_pos(self.leg1_symbol)
self.write_log("准备报单,1买2卖时,当前合约1价格: %s" % (str(bar_trade_price)))
self.write_log("准备报单,1买2卖时,当前合约2价格: %s" % (str(bar_base_price)))
if leg1_pos == 0 or leg1_pos > 0 : # 当前无论有无仓位，对合约1开多仓
self.write_log("准备报单了,1买2卖")
self.order_mess.clear()#清理报单
self.order_mess.vt_symbol = self.leg1_symbol#选择合约对象
self.order_mess.bid_price = bar_trade_price #报单价格
self.order_mess.bid_volume = 100#报单量
self.order_mess.settle_type = '2'#确定结算类型
self.order_mess.quote_type = '2'#确定报单类型
self.quote(BusinessType.XBOND, self.order_mess)#这里是债券报单，所以是双向报单，对于API接口中buy、sell、short、cover等报单类型不适用，这些都是对期货合约定义的，债券只需要quote即可
self.write_log("合约1仓位: %s" % (str(self.get_pos(self.leg1_symbol))))
self.order_mess.clear()
self.order_mess.vt_symbol = self.leg2_symbol
self.order_mess.ask_price = bar_base_price
self.order_mess.ask_volume = 100
self.order_mess.settle_type = '2'
self.order_mess.quote_type = '2'
self.quote(BusinessType.XBOND, self.order_mess)#买1同时也要卖2，同时操作，调参数时调整成交委托比来实现成交量的改变
self.write_log("合约2仓位: %s" % (str(self.get_pos(self.leg2_symbol))))
if close_diff < spread_up_sell:
leg1_pos = self.get_pos(self.leg1_symbol)
self.write_log("1买2卖,平仓,当前合约1价格: %s" % (str(bar_trade_price)))
self.write_log("1买2卖,平仓,当前合约2价格: %s" % (str(bar_base_price)))
if leg1_pos > 0 : # 当前有仓位，就先平仓
self.write_log("准备报单了,1买2卖,平仓")
self.order_mess.clear()
self.order_mess.vt_symbol = self.leg1_symbol
self.order_mess.ask_price = bar_trade_price
self.order_mess.ask_volume = abs(self.get_pos(self.leg1_symbol))
self.order_mess.settle_type = '2'
self.order_mess.quote_type = '2'
self.quote(BusinessType.XBOND, self.order_mess)
self.write_log("合约1仓位: %s" % (str(self.get_pos(self.leg1_symbol))))
self.order_mess.clear()
self.order_mess.vt_symbol = self.leg2_symbol
self.order_mess.bid_price = bar_base_price
self.order_mess.bid_volume = abs(self.get_pos(self.leg2_symbol))
self.order_mess.settle_type = '2'
self.order_mess.quote_type = '2'
self.quote(BusinessType.XBOND, self.order_mess)
self.write_log("合约2仓位: %s" % (str(self.get_pos(self.leg2_symbol))))
#利率下行周期，卖长买短
if close_diff < spread_down: # 当价差小于布林带下界，卖价差，卖trade买base
leg1_pos = self.get_pos(self.leg1_symbol)
self.write_log("准备报单,1卖2买,当前合约1价格: %s" % (str(bar_trade_price)))
self.write_log("准备报单,1卖2买,当前合约2价格: %s" % (str(bar_base_price)))
if leg1_pos == 0 or leg1_pos < 0 :
self.write_log("准备报单了,1卖2买")
self.order_mess.clear()
self.order_mess.vt_symbol = self.leg1_symbol
self.order_mess.ask_price = bar_trade_price
self.order_mess.ask_volume = 100
self.order_mess.settle_type = '2'
self.order_mess.quote_type = '2'
self.quote(BusinessType.XBOND, self.order_mess)
self.write_log("合约1仓位: %s" % (str(self.get_pos(self.leg1_symbol))))
self.order_mess.clear()
self.order_mess.vt_symbol = self.leg2_symbol
self.order_mess.bid_price = bar_base_price
self.order_mess.bid_volume = 100
self.order_mess.settle_type = '2'
self.order_mess.quote_type = '2'
self.quote(BusinessType.XBOND, self.order_mess)
self.write_log("合约2仓位: %s" % (str(self.get_pos(self.leg2_symbol))))
if close_diff > spread_down_sell:
leg1_pos = self.get_pos(self.leg1_symbol)
self.write_log("1卖2买,平仓,当前合约1价格: %s" % (str(bar_trade_price)))
self.write_log("1卖2买,平仓,当前合约2价格: %s" % (str(bar_base_price)))
if leg1_pos < 0: # 当前空仓位，就平仓
self.write_log("准备报单了,1卖2买,平仓")
self.order_mess.clear()
self.order_mess.vt_symbol = self.leg1_symbol
self.order_mess.bid_price = bar_trade_price
self.order_mess.bid_volume =abs(self.get_pos(self.leg1_symbol))
self.order_mess.settle_type = '2'
self.order_mess.quote_type = '2'
self.quote(BusinessType.XBOND, self.order_mess)
self.write_log("合约1仓位: %s" % (str(self.get_pos(self.leg1_symbol))))
self.order_mess.clear()
self.order_mess.vt_symbol = self.leg2_symbol
self.order_mess.ask_price = bar_base_price
self.order_mess.ask_volume = abs(self.get_pos(self.leg2_symbol))
self.order_mess.settle_type = '2'
self.order_mess.quote_type = '2'
self.quote(BusinessType.XBOND, self.order_mess)
self.write_log("合约2仓位: %s" % (str(self.get_pos(self.leg2_symbol))))
#self.sell(BusinessType.XBOND, self.order_mess)
self.put_event()整个策略的交易逻辑就体现在上述代码里面了。
策略回测结果如图：
国开债-进出口到期收益率图示2022.02-2023.08
国开债-进出口收益率利差图示2022.02-2023.08
回测参数
品种：220205.BOND（22附息国开债05）；220305.BOND（22附息进出口债05）
回测区间：2022年2月10日-2023年8月30日
起始资金：1000000
粒度：每天策略参数
up_threshold = 0.8
up_threshold_sell=0.6
down_threshold = 0.2
down_threshold_sell=0.45
spread_length = 50回测结果
| 统计指标 | 值 |
| 年化收益（%） | 5.8582 |
| 总收益率（%） | 9.5366 |
| 最大回撤（%） | -8.6538 |
| 期初资金 | 1000000 |
| 期末资金 | 1095366.35 |
| 总盈亏 | 95366.35 |
| 总成交笔数 | 323 |
| 买次数 | |
| 卖次数 | |
| 收益回撤比 | 1.1 |
| 夏普比率 | 0.13 |
收益概览
收益概览图示2022.02.10-2023.8.30
结果解析
2022-05-10至2022-05-23成交记录
操作记录
这部分是所有获取行情数据里面该有的对象：
#!/usr/bin/python3
# -*- coding: UTF-8 -*-
# add by gaolong.liu
"""
基础数据对象
"""
from dataclasses import dataclass, field
from datetime import datetime
from logging import INFO
from base.constant import Direction, Exchange, Interval, Offset, Product, OptionType, OrderType, \
StopOrderStatus, Side, BusinessType, QuoteStatus, QuotationType
# ACTIVE_STATUSES = set([Status.SUBMITTING, Status.NOTTRADED, Status.PARTTRADED])
ACTIVE_STATUSES = set([QuoteStatus.NORMAL, QuoteStatus.NEW, QuoteStatus.TRADED])
@dataclass
class BaseData:
"""
Any data object needs a gateway_name as source
and should inherit base data.
"""
gateway_name: str
@dataclass
class MarketFuture():
"""
Tick data contains information about:
* last trade in market
* orderbook snapshot
* intraday market statistics.
"""
symbol: str
exchange: Exchange
datetime: datetime
name: str = ""
volume: int = 0
turnover: float = 0
open_interest: float = 0
last_price: float = 0
last_volume: int = 0
limit_up: float = 0
limit_down: float = 0
open_price: float = 0
high_price: float = 0
low_price: float = 0
pre_close: float = 0
bid_price_1: float = 0
bid_price_2: float = 0
bid_price_3: float = 0
bid_price_4: float = 0
bid_price_5: float = 0
bid_price_6: float = 0
bid_price_7: float = 0
bid_price_8: float = 0
bid_price_9: float = 0
bid_price_10: float = 0
ask_price_1: float = 0
ask_price_2: float = 0
ask_price_3: float = 0
ask_price_4: float = 0
ask_price_5: float = 0
ask_price_6: float = 0
ask_price_7: float = 0
ask_price_8: float = 0
ask_price_9: float = 0
ask_price_10: float = 0
bid_volume_1: int = 0
bid_volume_2: int = 0
bid_volume_3: int = 0
bid_volume_4: int = 0
bid_volume_5: int = 0
bid_volume_6: int = 0
bid_volume_7: int = 0
bid_volume_8: int = 0
bid_volume_9: int = 0
bid_volume_10: int = 0
ask_volume_1: int = 0
ask_volume_2: int = 0
ask_volume_3: int = 0
ask_volume_4: int = 0
ask_volume_5: int = 0
ask_volume_6: int = 0
ask_volume_7: int = 0
ask_volume_8: int = 0
ask_volume_9: int = 0
ask_volume_10: int = 0
@dataclass
class MarketLevelBond():
swap_trade_volume: int = 0
swap_entry_px: float = 0
bond_yield_type: str = ""
bond_yield: float = 0
bond_entry_price: float = 0
bond_settle_type: str = ""
bond_quote_type: str = ""
bond_delivery_type: str = ""
bond_clear_method: str = ""
bond_quote_id: str = ""
bond_maker_six_code: str = ""
bond_maker_trader_code: str = ""
bond_mdEntryDate: str = ""
bond_mdEntryTime: str = ""
md_entry_size: int = 0
@dataclass
class MarketBond():
msg_type: str = ""
market_indicator: str = ""
book_type: str = ""
book_type_sub: str = ""
security_type: str = ""
security_id: str = ""
symbol: str = ""
bond_code_val: str = ""
market_depth: int = 0
message_id: str = ""
message_source: str = ""
create_time_ms: str = ""
create_time: str = ""
transact_time: str = ""
sender_comp_id: str = ""
sender_sub_id: str = ""
#行情类型（报价类型）
quotation_type: QuotationType = None
# 档位行情信息
bid_1: MarketLevelBond = None
ask_1: MarketLevelBond = None
bid_2: MarketLevelBond = None
ask_2: MarketLevelBond = None
bid_3: MarketLevelBond = None
ask_3: MarketLevelBond = None
bid_4: MarketLevelBond = None
ask_4: MarketLevelBond = None
bid_5: MarketLevelBond = None
ask_5: MarketLevelBond = None
bid_6: MarketLevelBond = None
ask_6: MarketLevelBond = None
bid_7: MarketLevelBond = None
ask_7: MarketLevelBond = None
bid_8: MarketLevelBond = None
ask_8: MarketLevelBond = None
bid_9: MarketLevelBond = None
ask_9: MarketLevelBond = None
bid_10: MarketLevelBond = None
ask_10: MarketLevelBond = None
@dataclass
class TickData(BaseData):
"""
Tick data contains information about:
* 通用字段
* 债券部分字段
* 期货、贵金属部分字典
"""
symbol: str
exchange: Exchange
name: str = ""
datetime: datetime = None
market_bond: MarketBond = None
market_future: MarketFuture = None
localtime: datetime = None
def __post_init__(self):
""""""
self.vt_symbol = f"{self.symbol}.{self.exchange.value}"
@dataclass
class BarData(BaseData):
"""
Candlestick bar data of a certain trading period.
"""
symbol: str
exchange: Exchange
datetime: datetime
interval: Interval = None
volume: int = 0
turnover: float = 0
open_interest: float = 0
# 开盘价
open_price: float = 0
# 最高价
high_price: float = 0
# 最低价
low_price: float = 0
# 收盘价
close_price: float = 0
# 收益率
yield_rate: float = 0
# 全价
full_price: float = 0
def __post_init__(self):
""""""
self.vt_symbol = f"{self.symbol}.{self.exchange.value}"
@dataclass
class FactorData(BaseData):
"""
Candlestick factor data of a certain trading period.
"""
factor_schedule: str
factor_class: str
datetime: datetime
factor_value: str = None
@dataclass
class TradeData(BaseData):
"""
Trade data contains information of a fill of an order. One order
can have several trade fills.
"""
# 债券代码
symbol: str
# 交易所
exchange: Exchange
# 委托单ID
orderid: str
# 成交单ID
tradeid: str
# 方向（期货）
direction: Direction = None
# 方向（债券）
side: Side = None
# 开平
offset: Offset = Offset.NONE
# 成交价格
price: float = 0
# 成交收益率
yield_rate: float = 0
# 成交量（手）
volume: int = 0
# 成交日期
datetime: datetime = None
# 面值（元）
face_value: float = 1.0
def __post_init__(self):
""""""
self.vt_symbol = f"{self.symbol}.{self.exchange.value}"
self.vt_orderid = f"{self.gateway_name}.{self.orderid}"
self.vt_tradeid = f"{self.gateway_name}.{self.tradeid}"
@dataclass
class StopOrder:
vt_symbol: str
direction: Direction
offset: Offset
price: float
volume: int
stop_orderid: str
strategy_name: str
datetime: datetime
lock: bool = False
net: bool = False
vt_orderids: list = field(default_factory=list)
status: StopOrderStatus = StopOrderStatus.WAITING
@dataclass
class PositionData(BaseData):
"""
Positon data is used for tracking each individual position holding.
"""
symbol: str
exchange: Exchange
direction: Direction
volume: int = 0
frozen: float = 0
price: float = 0
pnl: float = 0
yd_volume: int = 0
def __post_init__(self):
""""""
self.vt_symbol = f"{self.symbol}.{self.exchange.value}"
self.vt_positionid = f"{self.vt_symbol}.{self.direction.value}"
@dataclass
class AccountData(BaseData):
"""
Account data contains information about balance, frozen and
available.
"""
accountid: str
balance: float = 0
frozen: float = 0
def __post_init__(self):
""""""
self.available = self.balance - self.frozen
self.vt_accountid = f"{self.gateway_name}.{self.accountid}"
@dataclass
class LogData(BaseData):
"""
Log data is used for recording log messages on GUI or in log files.
"""
msg: str
level: int = INFO
def __post_init__(self):
""""""
self.time = datetime.now()
@dataclass
class ContractData(BaseData):
"""
Contract data contains basic information about each contract traded.
"""
symbol: str
exchange: Exchange
name: str
product: Product
size: float
pricetick: float
min_volume: int = 1 # minimum trading volume of the contract
stop_supported: bool = False # whether server supports stop order
net_position: bool = False # whether gateway uses net position volume
history_data: bool = False # whether gateway provides bar history data
option_strike: float = 0
option_underlying: str = "" # vt_symbol of underlying contract
option_type: OptionType = None
option_listed: datetime = None
option_expiry: datetime = None
option_portfolio: str = ""
option_index: str = "" # for identifying options with same strike price
def __post_init__(self):
""""""
self.vt_symbol = f"{self.symbol}.{self.exchange.value}"
@dataclass
class OrderData(BaseData):
"""
Order data contains information for tracking lastest status
of a specific order.
"""
symbol: str
exchange: Exchange
orderid: str
ordertype: BusinessType
data: BaseData
tradeid: str = ""
time: str = ""
datetime: datetime = None
updatetime: str = ""
status: QuoteStatus = QuoteStatus.NEW
orderrejectreason: str = ""
SysLocalOrderID: str = ""
# 触发委托的场景序号（bar\tick\factor）
scene_sn: str = ""
def __post_init__(self):
""""""
self.vt_symbol = f"{self.symbol}.{self.exchange.value}"
self.vt_orderid = f"{self.gateway_name}.{self.orderid}"
def is_active(self) -> bool:
"""
Check if the order is active.
"""
if self.status in ACTIVE_STATUSES:
return True
else:
return False
def create_cancel_request(self) -> "CancelRequest":
"""
Create cancel request object from order.
"""
req = CancelRequest(
orderid=self.orderid, symbol=self.symbol, exchange=self.exchange
)
return req
def addTradeQty(self,tradeQty:int=0, lastQty:int=0, side:Side=None):
self.data.update_last_qty(tradeQty,lastQty,side)
def getTradeQty(self, side:Side=None):
return self.data.get_last_qty(side)
def isTraded_All(self):
return self.data.isTraded_All()
@dataclass
class QuoteData(BaseData):
"""
Quote data contains information for tracking lastest status
of a specific quote.
"""
symbol: str
exchange: Exchange
quoteid: str
bid_price: float = 0.0
bid_volume: int = 0
ask_price: float = 0.0
ask_volume: int = 0
bid_offset: Offset = Offset.NONE
ask_offset: Offset = Offset.NONE
status: QuoteStatus = QuoteStatus.NEW
datetime: datetime = None
reference: str = ""
def __post_init__(self):
""""""
self.vt_symbol = f"{self.symbol}.{self.exchange.value}"
self.vt_quoteid = f"{self.gateway_name}.{self.quoteid}"
def is_active(self) -> bool:
"""
Check if the quote is active.
"""
return self.status in ACTIVE_STATUSES
def create_cancel_request(self) -> "CancelRequest":
"""
Create cancel request object from quote.
"""
req = CancelRequest(
orderid=self.quoteid, symbol=self.symbol, exchange=self.exchange
)
return req
@dataclass
class SubscribeRequest:
"""
Request sending to specific gateway for subscribing tick data update.
"""
symbol: str
exchange: Exchange
def __post_init__(self):
""""""
self.vt_symbol = f"{self.symbol}.{self.exchange.value}"
@dataclass
class CancelRequest:
"""
Request sending to specific gateway for canceling an existing order.
"""
orderid: str
symbol: str
exchange: Exchange
def __post_init__(self):
""""""
self.vt_symbol = f"{self.symbol}.{self.exchange.value}"
@dataclass
class QuoteRequest:
"""
Request sending to specific gateway for creating a new quote.
"""
vt_symbol: str = ""
bid_yield: float = 0
bid_price: float = 0
bid_volume: int = 0
ask_yield: float = 0
ask_price: float = 0
ask_volume: int = 0
settle_type: str = ""
valid_unit_time: str = ""
clear_method: str = ""
delivery_type: str = ""
# 报价方式，字典：1-集中匹配，2-连续匹配
quote_type: str = ""
# 订单类型，字典：2-限价订单，b-FAK（点击成交）
order_type: str = ""
real_time_flag: str = ""
direction: Direction = None
offset: Offset = Offset.NONE
reference: str = ""
# 当前行情ID（现券做市FAK点击时填写）
md_quote_id: str = ""
# 当前行情的业务发生时间
transact_time: str = ""
# 面值（元）
face_value: float = 0.0
# def __post_init__(self):
# """"""
# self.vt_symbol = f"{self.symbol}.{self.exchange.value}"
def clear(self):
self.vt_symbol: str = ""
self.bid_yield: float = 0
self.bid_price: float = 0
self.bid_volume: int = 0
self.ask_yield: float = 0
self.ask_price: float = 0
self.ask_volume: int = 0
self.settle_type: str = ""
self.valid_unit_time: str = ""
self.clear_method: str = ""
self.delivery_type: str = ""
self.quote_type: str = ""
self.order_type: str = ""
self.real_time_flag: str = ""
self.direction: Direction = None
self.offset: Offset = Offset.NONE
self.reference: str = ""
self.md_quote_id = ""
self.transact_time = ""
# def create_quote_data(self, quoteid: str, gateway_name: str) -> QuoteData:
# """
# Create quote data from request.
# """
# quote = QuoteData(
# symbol=self.symbol,
# exchange=self.exchange,
# quoteid=quoteid,
# bid_price=self.bid_price,
# bid_volume=self.bid_volume,
# ask_price=self.ask_price,
# ask_volume=self.ask_volume,
# bid_offset=self.bid_offset,
# ask_offset=self.ask_offset,
# reference=self.reference,
# gateway_name=gateway_name,
# )
# return quote
@dataclass
class BarOverview:
"""
Overview of bar data stored in database.
"""
symbol: str = ""
exchange: str = ""
interval: str = ""
count: int = 0
start: datetime = None
end: datetime = None
@dataclass
class QuoteBondMaker(BaseData):
"""
现券做市报价
"""
orderid: str
symbol: str
yield_bid: float = 0
yield_offer: float = 0
order_qty_bid: int = 0
order_qty_offer: int = 0
price_bid: float = 0
price_offer: float = 0
strategy_id: str = ""
invest_group_name: str = ""
trader_code: str = ""
valid_unit_time: str = ""
clear_method: str = ""
settle_type: str = ""
delivery_type: str = ""
# 订单类型，字典：2-限价订单，b-FAK（点击成交）
order_type: str = ""
run_id: str = ""
run_unit_id: str = ""
exchange: Exchange = Exchange.NONE
last_qty_bid: int = 0
last_qty_offer: int = 0
# 当前行情ID（现券做市FAK点击时填写）
md_quote_id: str = ""
# 对应行情的业务发生时间
transact_time: str = ""
# 面值(元)
face_value: float = 100.0
def __post_init__(self):
""""""
self.vt_symbol = f"{self.symbol}.{self.exchange.value}"
self.vt_orderid = f"{self.gateway_name}.{self.orderid}"
# 更新已成交量
def update_last_qty(self, trade_qty: int = 0, last_qty: int = 0, side: Side = None):
# 依据成交量计算总成交量
if trade_qty != 0:
if side == Side.DOUBLE_BUY or side == Side.SINGLE_BUY:
self.last_qty_bid += trade_qty
elif side == Side.DOUBLE_SELL or side == Side.SINGLE_SELL:
self.last_qty_offer += trade_qty
# 更新总成交量为已成交量
if last_qty != 0:
if side == Side.DOUBLE_BUY or side == Side.SINGLE_BUY:
self.last_qty_bid = last_qty
elif side == Side.DOUBLE_SELL or side == Side.SINGLE_SELL:
self.last_qty_offer = last_qty
# 获得成交量
def get_last_qty(self, side: Side = None):
if side == Side.DOUBLE_BUY or side == Side.SINGLE_BUY:
return self.last_qty_bid
elif side == Side.DOUBLE_SELL or side == Side.SINGLE_SELL:
return self.last_qty_offer
def isTraded_All(self):
return self.last_qty_offer == self.order_qty_offer and self.last_qty_bid == self.order_qty_bid
def toJson(self):
data = {
"api_id": self.orderid,
"symbol": self.symbol,
"exchange": self.exchange.value,
"vt_symbol": self.vt_symbol,
"yield_bid": self.yield_bid,
"yield_offer": self.yield_offer,
"order_qty_bid": self.order_qty_bid,
"order_qty_offer": self.order_qty_offer,
"price_bid": self.price_bid,
"price_offer": self.price_offer,
"strategy_id": self.strategy_id,
"invest_group_name": self.invest_group_name,
"trader_code": self.trader_code,
"valid_unit_time": self.valid_unit_time,
"clear_method": self.clear_method,
"settle_type": self.settle_type,
"order_type": self.order_type,
"run_id": self.run_id,
"run_unit_id": self.run_unit_id,
"delivery_type": self.delivery_type,
"md_quote_id": self.md_quote_id,
"transact_time": self.transact_time,
"face_value": self.face_value
}
return data
@dataclass
class QuoteXBond(BaseData):
"""
现券匿名报价
"""
orderid: str
symbol: str
side: Side = None
yield_rate: float = 0
order_qty: int = 0
price: float = 0
strategy_id: str = ""
invest_group_name: str = ""
trader_code: str = ""
settle_type: str = ""
# 报价方式，字典：1-集中匹配，2-连续匹配
match_type: str = ""
# 订单类型，字典：2-限价订单，b-FAK（点击成交）
order_type: str = ""
run_id: str = ""
run_unit_id: str = ""
side_id: str = ""
exchange: Exchange = Exchange.NONE
last_qty: int = 0
# 面值(元)
face_value: float = 100.0
def __post_init__(self):
""""""
self.vt_symbol = f"{self.symbol}.{self.exchange.value}"
self.vt_orderid = f"{self.gateway_name}.{self.orderid}"
# 更新已成交量
def update_last_qty(self, trade_qty: int = 0, last_qty: int = 0, side: Side = None):
# 依据成交量计算总成交量
if trade_qty != 0:
self.last_qty += trade_qty
# 更新总成交量为已成交量
if last_qty != 0:
self.last_qty = last_qty
# 获得成交量
def get_last_qty(self, side: Side = None):
return self.last_qty
def isTraded_All(self):
return self.last_qty == self.order_qty
def toJson(self):
data = {
"api_id": self.orderid,
"symbol": self.symbol,
"exchange": self.exchange.value,
"vt_symbol": self.vt_symbol,
"side": self.side.value,
"yield_rate": self.yield_rate,
"order_qty": self.order_qty,
"price": self.price,
"strategy_id": self.strategy_id,
"invest_group_name": self.invest_group_name,
"trader_code": self.trader_code,
"side_id": self.side_id,
"settle_type": self.settle_type,
"run_id": self.run_id,
"run_unit_id": self.run_unit_id,
"match_type": self.match_type,
"order_type": self.order_type,
"face_value": self.face_value
}
return data
@dataclass
class QuoteXSwap(BaseData):
"""
利率互换匿名报价
"""
orderid: str
symbol: str
side: Side = None
order_qty: int = 0
price: float = 0
strategy_id: str = ""
invest_group_name: str = ""
trader_code: str = ""
valid_unit_time: str = ""
# 报价方式，字典：1-集中匹配，2-连续匹配
match_type: str = ""
real_time_flag: str = ""
run_id: str = ""
run_unit_id: str = ""
side_id: str = ""
expire_time: str = ""
exchange: Exchange = Exchange.NONE
last_qty: int = 0
def __post_init__(self):
""""""
self.vt_symbol = f"{self.symbol}.{self.exchange.value}"
self.vt_orderid = f"{self.gateway_name}.{self.orderid}"
# 更新已成交量
def update_last_qty(self, trade_qty:int=0, last_qty:int=0, side:Side=None):
# 依据成交量计算总成交量
if trade_qty != 0:
self.last_qty += trade_qty
# 更新总成交量为已成交量
if last_qty != 0:
self.last_qty = last_qty
# 获得成交量
def get_last_qty(self, side: Side = None):
return self.last_qty
def isTraded_All(self):
return self.last_qty == self.order_qty
def toJson(self):
data = {
"api_id": self.orderid,
"symbol": self.symbol,
"exchange": self.exchange.value,
"vt_symbol": self.vt_symbol,
"real_time_flag": self.real_time_flag,
"side": self.side.value,
"order_qty": self.order_qty,
"price": self.price,
"expire_time": self.expire_time,
"strategy_id": self.strategy_id,
"invest_group_name": self.invest_group_name,
"trader_code": self.trader_code,
"side_id": self.side_id,
"valid_unit_time": self.valid_unit_time,
"run_id": self.run_id,
"run_unit_id": self.run_unit_id,
"match_type": self.match_type
}
return data
@dataclass
class QuoteFuture(BaseData):
"""
期货报价
"""
orderid: str
symbol: str
type: OrderType = OrderType.LIMIT
direction: Direction = None
offset: Offset = Offset.NONE
price: float = 0
volume: int = 0
traded: int = 0
exchange: Exchange = Exchange.NONE
def __post_init__(self):
""""""
self.vt_symbol = f"{self.symbol}.{self.exchange.value}"
self.vt_orderid = f"{self.gateway_name}.{self.orderid}"
# 更新已成交量
def update_last_qty(self, trade_qty:int=0, last_qty:int=0, side:Side=None):
# 依据成交量计算总成交量
if trade_qty != 0:
self.traded += trade_qty
# 更新总成交量为已成交量
if last_qty !=0:
self.traded = last_qty
# 获得成交量
def get_last_qty(self, side: Side = None):
return self.traded
def isTraded_All(self):
return self.traded == self.volume
def toJson(self):
data = {
"type": self.type.value,
"direction": self.direction.value,
"offset": self.offset.value,
"price": self.price,
"volume": self.volume,
"traded": self.traded
}
return data
@dataclass
class BondInfo:
"""
债券基本信息
"""
# 债券代码
security_id: str
# 债券名称
name: str
# 债券类型
bond_type: str
# 面值(元)
face_value: float
# 债券起息日
dated_date: datetime
# 到期兑付日
maturity_date: datetime
# 付息频率(0-半年，1-年，2-到期，3-月，4-季)
frequency: str
# 息票类型(0-固定,1-浮动,2-零息,3-贴现)
coupon_rate_type: str
# 票面利率
coupon: float
# 计息基准(0-实际/实际,1-实际/360,2-30/360,3-实际/365,5-实际/365F)
day_count: str
# 到期期限
term_to_maturity: str = None
9022
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
