def link_tq(api):
"""
处理py进程到天勤的连接
根据天勤提供的命令行参数, 决定 TqApi 工作方式
* 直接调整api的参数
TqApi运行过程中的一批信息主动发送到天勤显示
* 进程启动和停止
* set_chart_data 指令全部发往天勤绘图
* 所有 log / print 信息传递一份
* exception 发送一份
* 所有报单/成交记录抄送一份
:return: (account, backtest, md_url)
"""
from tqsdk.api import TqChan, TqAccount
from tqsdk.sim import TqSim
# 解析命令行参数
parser = argparse.ArgumentParser()
# 天勤连接基本参数
parser.add_argument('--_action', type=str, required=False)
parser.add_argument('--_tq_pid', type=int, required=False)
parser.add_argument('--_tq_url', type=str, required=False)
# action==run时需要这几个
parser.add_argument('--_broker_id', type=str, required=False)
parser.add_argument('--_account_id', type=str, required=False)
parser.add_argument('--_password', type=str, required=False)
# action==backtest时需要这几个
parser.add_argument('--_start_dt', type=str, required=False)
parser.add_argument('--_end_dt', type=str, required=False)
# action==mdreplay时需要这几个
parser.add_argument('--_ins_url', type=str, required=False)
parser.add_argument('--_md_url', type=str, required=False)
args, unknown = parser.parse_known_args()
# 非天勤启动时直接返回
if args._action is None:
return None, None
if args._tq_pid is None:
raise Exception("_tq_pid 参数缺失")
if args._tq_url is None:
raise Exception("_tq_url 参数缺失")
if args._action == "run" and (not args._broker_id or not args._account_id
or not args._password):
raise Exception("run 必要参数缺失")
if args._action == "backtest" and (not args._start_dt or not args._end_dt):
raise Exception("backtest 必要参数缺失")
if args._action == "mdreplay" and (not args._ins_url or not args._md_url):
raise Exception("mdreplay 必要参数缺失")
# 监控天勤进程存活情况
TqMonitorThread(args._tq_pid).start()
# 建立到天勤进程的连接
tq_send_chan, tq_recv_chan = TqChan(api), TqChan(api) # 连接到天勤的channel
api.create_task(api._connect(args._tq_url, tq_send_chan,
tq_recv_chan)) # 启动到天勤客户端的连接
# 根据运行模式分别执行不同的初始化任务
if args._action == "run":
instance = SingleInstance(args._account_id)
api._account = TqAccount(args._broker_id, args._account_id,
args._password)
api._backtest = None
dt_func = lambda: int(datetime.datetime.now().timestamp() * 1e9)
tq_send_chan.send_nowait({
"aid": "register_instance",
"instance_id": instance.instance_id,
"full_path": get_self_full_name(),
"instance_pid": os.getpid(),
"instance_type": "RUN",
"broker_id": args._broker_id,
"account_id": args._account_id,
"password": args._password,
})
elif args._action == "backtest":
instance = SingleInstance("%s-%s" % (args._start_dt, args._end_dt))
if not isinstance(api._account, TqSim):
api._account = TqSim()
from tqsdk.backtest import TqBacktest
start_date = datetime.datetime.strptime(args._start_dt, '%Y%m%d')
end_date = datetime.datetime.strptime(args._end_dt, '%Y%m%d')
api._backtest = TqBacktest(start_dt=start_date, end_dt=end_date)
dt_func = lambda: api._account._get_current_timestamp()
tq_send_chan.send_nowait({
"aid": "register_instance",
"instance_id": instance.instance_id,
"full_path": get_self_full_name(),
"instance_pid": os.getpid(),
"instance_type": "BACKTEST",
"start_dt": args._start_dt,
"end_dt": args._end_dt,
})
elif args._action == "mdreplay":
instance = SingleInstance(args._account_id)
api._account = TqSim(account_id=args._account_id)
api._backtest = None
api._md_url = args._md_url
api._ins_url = args._ins_url
dt_func = lambda: api._account._get_current_timestamp()
tq_send_chan.send_nowait({
"aid": "register_instance",
"instance_id": instance.instance_id,
"full_path": get_self_full_name(),
"instance_pid": os.getpid(),
"instance_type": "RUN",
"account_id": "SIM",
})
else:
raise Exception("_action 参数异常")
# print输出, exception信息转发到天勤
logger = logging.getLogger("TQ")
logger.setLevel(logging.INFO)
logger.addHandler(LogHandlerChan(tq_send_chan,
dt_func=dt_func)) # log输出到天勤接口
sys.stdout = PrintWriterToLog(logger) # print信息转向log输出
sys.excepthook = partial(exception_handler, api,
sys.excepthook) # exception信息转向log输出
# 向api注入监控任务, 将账户交易信息主动推送到天勤
api.create_task(account_watcher(api, dt_func, tq_send_chan))
return tq_send_chan, tq_recv_chan
class TargetPosTask(object):
"""目标持仓 task, 该 task 可以将指定合约调整到目标头寸"""
def __init__(self,
api,
symbol,
price="ACTIVE",
init_pos=None,
offset_priority="今昨,开",
trade_chan=None):
"""
创建目标持仓task实例，负责调整归属于该task的持仓(默认为整个账户的该合约净持仓)
Args:
api (TqApi): TqApi实例，该task依托于指定api下单/撤单
symbol (str): 负责调整的合约代码
price (str): [可选]下单方式, ACTIVE=对价下单, PASSIVE=挂价下单
init_pos (int): [可选]初始持仓，默认整个账户的该合净持仓
offset_priority (str): [可选]开平仓顺序，昨=平昨仓，今=平今仓，开=开仓，逗号=等待之前操作完成
对于下单指令区分平今/昨的交易所(如上期所)，按照今/昨仓的数量计算是否能平今/昨仓
对于下单指令不区分平今/昨的交易所(如中金所)，按照“先平当日新开仓，再平历史仓”的规则计算是否能平今/昨仓
* "今昨,开" 表示先平今仓，再平昨仓，等待平仓完成后开仓，对于没有单向大边的品种避免了开仓保证金不足
* "今昨开" 表示先平今仓，再平昨仓，并开仓，所有指令同时发出，适合有单向大边的品种
* "昨开" 表示先平昨仓，再开仓，禁止平今仓，适合股指这样平今手续费较高的品种
trade_chan (TqChan): [可选]成交通知channel, 当有成交发生时会将成交手数(多头为正数，空头为负数)发到该channel上
"""
super(TargetPosTask, self).__init__()
self.api = api
self.symbol = symbol
self.exchange = symbol.split(".")[0]
self.price = price
self.pos = self.api.get_position(self.symbol)
self.current_pos = init_pos
self.offset_priority = offset_priority
self.pos_chan = TqChan(self.api, last_only=True)
self.trade_chan = trade_chan if trade_chan is not None else TqChan(
self.api)
self.task = self.api.create_task(self._target_pos_task())
def set_target_volume(self, volume):
"""
设置目标持仓手数
Args:
volume (int): 目标持仓手数，正数表示多头，负数表示空头，0表示空仓
Example::
# 设置 rb1810 持仓为多头5手
from tqsdk import TqApi, TqSim, TargetPosTask
api = TqApi(TqSim())
target_pos = TargetPosTask(api, "SHFE.rb1810")
while True:
api.wait_update()
target_pos.set_target_volume(5)
"""
self.pos_chan.send_nowait(volume)
def _init_position(self):
"""初始化当前持仓"""
if self.current_pos is None:
self.current_pos = self.pos["volume_long_today"] + self.pos[
"volume_long_his"] - self.pos["volume_short_today"] - self.pos[
"volume_short_his"]
def _get_order(self, offset, vol, pos):
"""获得可平手数"""
if vol > 0: # 买单(增加净持仓)
order_dir = "BUY"
ydAvailable = pos["volume_short_his"] - (
pos["volume_short_frozen"] - pos["volume_short_frozen_today"]
) # 昨空可用
tdAvailable = pos["volume_short_today"] - pos[
"volume_short_frozen_today"] # 今空可用
else: # 卖单
order_dir = "SELL"
ydAvailable = pos["volume_long_his"] - (
pos["volume_long_frozen"] - pos["volume_long_frozen_today"]
) # 昨多可用
tdAvailable = pos["volume_long_today"] - pos[
"volume_long_frozen_today"] # 今多可用
if offset == "昨":
order_offset = "CLOSE"
order_volume = min(
abs(vol), ydAvailable if self.exchange == "SHFE"
or self.exchange == "INE" or tdAvailable == 0 else 0)
if vol > 0:
pos["volume_short_frozen"] += order_volume
pos["volume_short_frozen_his"] += order_volume
else:
pos["volume_long_frozen"] += order_volume
pos["volume_long_frozen_his"] += order_volume
elif offset == "今":
order_offset = "CLOSETODAY" if self.exchange == "SHFE" or self.exchange == "INE" else "CLOSE"
order_volume = min(
abs(vol), tdAvailable if self.exchange == "SHFE"
or self.exchange == "INE" else tdAvailable + ydAvailable)
if vol > 0:
pos["volume_short_frozen"] += order_volume
pos["volume_short_frozen_today"] += order_volume
pos["volume_short_frozen_his"] += max(
0, pos["volume_short_frozen_today"] -
pos["volume_short_today"])
pos["volume_short_frozen_today"] = min(
pos["volume_short_frozen_today"],
pos["volume_short_today"])
else:
pos["volume_long_frozen"] += order_volume
pos["volume_long_frozen_today"] += order_volume
pos["volume_long_frozen_his"] += max(
0,
pos["volume_long_frozen_today"] - pos["volume_long_today"])
pos["volume_long_frozen_today"] = min(
pos["volume_long_frozen_today"], pos["volume_long_today"])
elif offset == "开":
order_offset = "OPEN"
order_volume = abs(vol)
else:
order_offset = ""
order_volume = 0
return order_offset, order_dir, order_volume
async def _target_pos_task(self):
"""负责调整目标持仓的task"""
self._init_position()
async for target_pos in self.pos_chan:
# 确定调仓增减方向
delta_volume = target_pos - self.current_pos
all_tasks = []
pos = self.pos.copy()
for each_priority in self.offset_priority + ",": # 按不同模式的优先级顺序报出不同的offset单，股指(“昨开”)平昨优先从不平今就先报平昨，原油平今优先("今昨开")就报平今
if each_priority == ",":
await gather(*[each.task for each in all_tasks])
all_tasks = []
pos = self.pos.copy()
continue
order_offset, order_dir, order_volume = self._get_order(
each_priority, delta_volume, pos)
if order_volume == 0: # 如果没有则直接到下一种offset
continue
order_task = InsertOrderUntilAllTradedTask(
self.api,
self.symbol,
order_dir,
offset=order_offset,
volume=order_volume,
price=self.price,
trade_chan=self.trade_chan)
all_tasks.append(order_task)
delta_volume -= order_volume if order_dir == "BUY" else -order_volume
self.current_pos = target_pos
class TargetPosTask(object):
"""目标持仓 task, 该 task 可以将指定合约调整到目标头寸"""
def __init__(self,
api,
symbol,
price="ACTIVE",
offset_priority="今昨,开",
trade_chan=None):
"""
创建目标持仓task实例，负责调整归属于该task的持仓(默认为整个账户的该合约净持仓)
Args:
api (TqApi): TqApi实例，该task依托于指定api下单/撤单
symbol (str): 负责调整的合约代码
price (str): [可选]下单方式, ACTIVE=对价下单, PASSIVE=挂价下单
init_pos (int): [可选]初始持仓，默认整个账户的该合净持仓
offset_priority (str): [可选]开平仓顺序，昨=平昨仓，今=平今仓，开=开仓，逗号=等待之前操作完成
对于下单指令区分平今/昨的交易所(如上期所)，按照今/昨仓的数量计算是否能平今/昨仓
对于下单指令不区分平今/昨的交易所(如中金所)，按照“先平当日新开仓，再平历史仓”的规则计算是否能平今/昨仓
* "今昨,开" 表示先平今仓，再平昨仓，等待平仓完成后开仓，对于没有单向大边的品种避免了开仓保证金不足
* "今昨开" 表示先平今仓，再平昨仓，并开仓，所有指令同时发出，适合有单向大边的品种
* "昨开" 表示先平昨仓，再开仓，禁止平今仓，适合股指这样平今手续费较高的品种
trade_chan (TqChan): [可选]成交通知channel, 当有成交发生时会将成交手数(多头为正数，空头为负数)发到该channel上
"""
super(TargetPosTask, self).__init__()
self.api = api
self.symbol = symbol
self.exchange = symbol.split(".")[0]
self.price = price
self.pos = self.api.get_position(self.symbol)
self.offset_priority = offset_priority
self.pos_chan = TqChan(self.api, last_only=True)
self.trade_chan = trade_chan if trade_chan is not None else TqChan(
self.api)
self.task = self.api.create_task(self._target_pos_task())
def set_target_volume(self, volume):
"""
设置目标持仓手数
Args:
volume (int): 目标持仓手数，正数表示多头，负数表示空头，0表示空仓
Example::
# 设置 rb1810 持仓为多头5手
from tqsdk import TqApi, TqSim, TargetPosTask
api = TqApi(TqSim())
target_pos = TargetPosTask(api, "SHFE.rb1810")
target_pos.set_target_volume(5)
while True:
api.wait_update()
"""
self.pos_chan.send_nowait(volume)
def _get_order(self, offset, vol):
"""
根据指定的offset和预期下单手数vol, 返回符合要求的委托单最大报单手数
:param offset: "昨" / "今" / "开"
:param vol: int, <0表示SELL, >0表示BUY
:return: order_offset: "CLOSE"/"CLOSETODAY"/"OPEN"; order_dir: "BUY"/"SELL"; "order_volume": >=0, 报单手数
"""
if vol > 0: # 买单(增加净持仓)
order_dir = "BUY"
pos_all = self.pos.pos_short
else: # 卖单
order_dir = "SELL"
pos_all = self.pos.pos_long
if offset == "昨":
order_offset = "CLOSE"
if self.exchange == "SHFE" or self.exchange == "INE":
if vol > 0:
pos_all = self.pos.pos_short_his
else:
pos_all = self.pos.pos_long_his
frozen_volume = sum([
order.volume_left for order in self.pos.orders.values()
if not order.is_dead() and order.offset == order_offset
and order.direction == order_dir
])
else:
frozen_volume = sum([
order.volume_left for order in self.pos.orders.values()
if not order.is_dead() and order.offset != "OPEN"
and order.direction == order_dir
])
order_volume = max(0, pos_all - frozen_volume)
elif offset == "今":
if self.exchange == "SHFE" or self.exchange == "INE":
order_offset = "CLOSETODAY"
if vol > 0:
pos_all = self.pos.pos_short_today
else:
pos_all = self.pos.pos_long_today
frozen_volume = sum([
order.volume_left for order in self.pos.orders.values()
if not order.is_dead() and order.offset == order_offset
and order.direction == order_dir
])
else:
order_offset = "CLOSE"
frozen_volume = sum([
order.volume_left for order in self.pos.orders.values()
if not order.is_dead() and order.offset != "OPEN"
and order.direction == order_dir
])
order_volume = max(0, pos_all - frozen_volume)
elif offset == "开":
order_offset = "OPEN"
order_volume = abs(vol)
else:
order_offset = ""
order_volume = 0
return order_offset, order_dir, order_volume
async def _target_pos_task(self):
"""负责调整目标持仓的task"""
async for target_pos in self.pos_chan:
# 确定调仓增减方向
delta_volume = target_pos - self.pos.pos
all_tasks = []
for each_priority in self.offset_priority + ",": # 按不同模式的优先级顺序报出不同的offset单，股指(“昨开”)平昨优先从不平今就先报平昨，原油平今优先("今昨开")就报平今
if each_priority == ",":
await gather(*[each.task for each in all_tasks])
all_tasks = []
continue
order_offset, order_dir, order_volume = self._get_order(
each_priority, delta_volume)
if order_volume == 0: # 如果没有则直接到下一种offset
continue
order_task = InsertOrderUntilAllTradedTask(
self.api,
self.symbol,
order_dir,
offset=order_offset,
volume=order_volume,
price=self.price,
trade_chan=self.trade_chan)
all_tasks.append(order_task)
delta_volume -= order_volume if order_dir == "BUY" else -order_volume
self.current_pos = target_pos
class TargetPosTask(object, metaclass=TargetPosTaskSingleton):
"""目标持仓 task, 该 task 可以将指定合约调整到目标头寸"""
def __init__(self,
api: TqApi,
symbol: str,
price: str = "ACTIVE",
offset_priority: str = "今昨,开",
trade_chan: Optional[TqChan] = None) -> None:
"""
创建目标持仓task实例，负责调整归属于该task的持仓 **(默认为整个账户的该合约净持仓)**.
**注意:** TargetPosTask 在 set_target_volume 时并不下单或撤单, 它的下单和撤单动作, 是在之后的每次 wait_update 时执行的. 因此, **需保证 set_target_volume 后还会继续调用wait_update()**
Args:
api (TqApi): TqApi实例，该task依托于指定api下单/撤单
symbol (str): 负责调整的合约代码
price (str): [可选]下单方式, ACTIVE=对价下单, PASSIVE=挂价下单.
* 在持仓调整过程中,若下单方向为买: 对价为卖一价, 挂价为买一价
* 在持仓调整过程中,若下单方向为卖: 对价为买一价, 挂价为卖一价
offset_priority (str): [可选]开平仓顺序，昨=平昨仓，今=平今仓，开=开仓，逗号=等待之前操作完成
对于下单指令区分平今/昨的交易所(如上期所)，按照今/昨仓的数量计算是否能平今/昨仓
对于下单指令不区分平今/昨的交易所(如中金所)，按照“先平当日新开仓，再平历史仓”的规则计算是否能平今/昨仓
* "今昨,开" 表示先平今仓，再平昨仓，等待平仓完成后开仓，对于没有单向大边的品种避免了开仓保证金不足
* "今昨开" 表示先平今仓，再平昨仓，并开仓，所有指令同时发出，适合有单向大边的品种
* "昨开" 表示先平昨仓，再开仓，禁止平今仓，适合股指这样平今手续费较高的品种
trade_chan (TqChan): [可选]成交通知channel, 当有成交发生时会将成交手数(多头为正数，空头为负数)发到该channel上
"""
super(TargetPosTask, self).__init__()
self._api = api
if symbol not in api._data.get("quotes", {}):
raise Exception("代码 %s 不存在, 请检查合约代码是否填写正确" % (symbol))
self._symbol = symbol
self._exchange = symbol.split(".")[0]
if price not in ("ACTIVE", "PASSIVE"):
raise Exception("下单方式(price) %s 错误, 请检查 price 参数是否填写正确" % (price))
self._price = price
if len(
offset_priority.replace(",", "").replace("今", "", 1).replace(
"昨", "", 1).replace("开", "", 1)) > 0:
raise Exception(
"开平仓顺序(offset_priority) %s 错误, 请检查 offset_priority 参数是否填写正确" %
(offset_priority))
self._offset_priority = offset_priority
self._pos = self._api.get_position(self._symbol)
self._pos_chan = TqChan(self._api, last_only=True)
self._trade_chan = trade_chan if trade_chan is not None else TqChan(
self._api)
self._task = self._api.create_task(self._target_pos_task())
def set_target_volume(self, volume: int) -> None:
"""
设置目标持仓手数
Args:
volume (int): 目标持仓手数，正数表示多头，负数表示空头，0表示空仓
Example::
# 设置 rb1810 持仓为多头5手
from tqsdk import TqApi, TargetPosTask
api = TqApi()
target_pos = TargetPosTask(api, "SHFE.rb1810")
target_pos.set_target_volume(5)
while True:
# 需在 set_target_volume 后调用wait_update()以发出指令
api.wait_update()
"""
self._pos_chan.send_nowait(int(volume))
def _get_order(self, offset, vol, pending_frozen):
"""
根据指定的offset和预期下单手数vol, 返回符合要求的委托单最大报单手数
:param offset: "昨" / "今" / "开"
:param vol: int, <0表示SELL, >0表示BUY
:return: order_offset: "CLOSE"/"CLOSETODAY"/"OPEN"; order_dir: "BUY"/"SELL"; "order_volume": >=0, 报单手数
"""
if vol > 0: # 买单(增加净持仓)
order_dir = "BUY"
pos_all = self._pos.pos_short
else: # 卖单
order_dir = "SELL"
pos_all = self._pos.pos_long
if offset == "昨":
order_offset = "CLOSE"
if self._exchange == "SHFE" or self._exchange == "INE":
if vol > 0:
pos_all = self._pos.pos_short_his
else:
pos_all = self._pos.pos_long_his
frozen_volume = sum([
order.volume_left for order in self._pos.orders.values()
if not order.is_dead and order.offset == order_offset
and order.direction == order_dir
])
else:
frozen_volume = pending_frozen + sum([
order.volume_left
for order in self._pos.orders.values() if not order.is_dead
and order.offset != "OPEN" and order.direction == order_dir
])
# 判断是否有未冻结的今仓手数: 若有则不平昨仓
if (self._pos.pos_short_today if vol > 0 else
self._pos.pos_long_today) - frozen_volume > 0:
pos_all = frozen_volume
order_volume = min(abs(vol), max(0, pos_all - frozen_volume))
elif offset == "今":
if self._exchange == "SHFE" or self._exchange == "INE":
order_offset = "CLOSETODAY"
if vol > 0:
pos_all = self._pos.pos_short_today
else:
pos_all = self._pos.pos_long_today
frozen_volume = sum([
order.volume_left for order in self._pos.orders.values()
if not order.is_dead and order.offset == order_offset
and order.direction == order_dir
])
else:
order_offset = "CLOSE"
frozen_volume = pending_frozen + sum([
order.volume_left
for order in self._pos.orders.values() if not order.is_dead
and order.offset != "OPEN" and order.direction == order_dir
])
pos_all = self._pos.pos_short_today if vol > 0 else self._pos.pos_long_today
order_volume = min(abs(vol), max(0, pos_all - frozen_volume))
elif offset == "开":
order_offset = "OPEN"
order_volume = abs(vol)
else:
order_offset = ""
order_volume = 0
return order_offset, order_dir, order_volume
async def _target_pos_task(self):
"""负责调整目标持仓的task"""
async for target_pos in self._pos_chan:
# 确定调仓增减方向
delta_volume = target_pos - self._pos.pos
pending_forzen = 0
all_tasks = []
for each_priority in self._offset_priority + ",": # 按不同模式的优先级顺序报出不同的offset单，股指(“昨开”)平昨优先从不平今就先报平昨，原油平今优先("今昨开")就报平今
if each_priority == ",":
await gather(*[each._task for each in all_tasks])
pending_forzen = 0
all_tasks = []
continue
order_offset, order_dir, order_volume = self._get_order(
each_priority, delta_volume, pending_forzen)
if order_volume == 0: # 如果没有则直接到下一种offset
continue
elif order_offset != "OPEN":
pending_forzen += order_volume
order_task = InsertOrderUntilAllTradedTask(
self._api,
self._symbol,
order_dir,
offset=order_offset,
volume=order_volume,
price=self._price,
trade_chan=self._trade_chan)
all_tasks.append(order_task)
delta_volume -= order_volume if order_dir == "BUY" else -order_volume
