def test_lib_insert_order_time_check_7(self):
"""
lib下单时间判断测试7
订阅合约：
订阅周六有行情的和周六无行情的
测试：
(测试:回测从周六开始时 可交易时间段的计算、判断)
1 回测刚开始:current_datetime 为 0:00 , 只有cu能下单，另外两个合约直到白盘9点下单
"""
# 预设服务器端响应
dir_path = os.path.dirname(os.path.realpath(__file__))
self.mock.run(os.path.join(dir_path, "log_file", "test_lib_insert_order_time_check_7.script.lzma.lzma"))
TqApi.RD = random.Random(4)
api = TqApi(
backtest=TqBacktest(datetime.datetime(2019, 11, 30, 0, 0, 0), datetime.datetime(2019, 12, 2, 9, 30)),
_ins_url=self.ins_url_2019_12_04)
symbol1 = "SHFE.cu2002" # 有夜盘,凌晨1点结束夜盘
symbol2 = "SHFE.rb2002" # 夜盘23点结束
symbol3 = "DCE.jd2002" # 无夜盘
quote1 = api.get_quote(symbol1)
quote2 = api.get_quote(symbol2)
quote3 = api.get_quote(symbol3)
position1 = api.get_position(symbol1)
position2 = api.get_position(symbol2)
position3 = api.get_position(symbol3)
target_pos1 = TargetPosTask(api, symbol1)
target_pos2 = TargetPosTask(api, symbol2)
target_pos3 = TargetPosTask(api, symbol3)
orders = api.get_order()
try:
# 1 回测刚开始:current_datetime 为 0:00 , 只有cu能下单，另外两个合约直到白盘9点下单
target_pos1.set_target_volume(1)
target_pos2.set_target_volume(2)
target_pos3.set_target_volume(3)
while max(quote1.datetime, quote2.datetime, quote3.datetime) < "2019-11-30 00:02:00.000000":
api.wait_update()
self.assertEqual(len(orders), 1)
while max(quote1.datetime, quote2.datetime, quote3.datetime) < "2019-11-30 00:15:00.000000":
api.wait_update()
self.assertEqual(len(orders), 1)
self.assertEqual(position1.pos, 1)
self.assertEqual(position2.pos, 0)
self.assertEqual(position3.pos, 0)
while max(quote1.datetime, quote2.datetime, quote3.datetime) < "2019-12-02 09:05:00.000000":
api.wait_update()
self.assertEqual(len(orders), 3)
self.assertEqual(position1.pos, 1)
self.assertEqual(position2.pos, 2)
self.assertEqual(position3.pos, 3)
while True:
api.wait_update()
except BacktestFinished:
self.assertEqual(position1.pos, 1)
self.assertEqual(position2.pos, 2)
self.assertEqual(position3.pos, 3)
api.close()
def test_lib_insert_order_time_check_5(self):
'''
lib下单时间判断测试5
回测时间：
起始交易日（datetime.date）在非周一
订阅:
cu（有夜盘,凌晨1点结束夜盘）,rb（夜盘23点结束）,jd（无夜盘）
测试：
1 起始回测在21点后rb、cu下单，到第二日9点后jd下单
2 本交易日白盘9：00后jd下单
'''
# 预设服务器端响应
dir_path = os.path.dirname(os.path.realpath(__file__))
self.mock.run(
os.path.join(dir_path, "log_file",
"test_lib_insert_order_time_check_5.script.lzma"))
utils.RD = random.Random(4)
api = TqApi(backtest=TqBacktest(datetime.date(2019, 12, 3),
datetime.date(2019, 12, 4)),
_ins_url=self.ins_url_2019_12_04) # 2019, 12, 3:周二
symbol1 = "SHFE.cu2002" # 有夜盘,凌晨1点结束夜盘
symbol2 = "SHFE.rb2002" # 夜盘23点结束
symbol3 = "DCE.jd2002" # 无夜盘
quote1 = api.get_quote(symbol1)
quote2 = api.get_quote(symbol2)
quote3 = api.get_quote(symbol3)
position1 = api.get_position(symbol1)
position2 = api.get_position(symbol2)
position3 = api.get_position(symbol3)
target_pos1 = TargetPosTask(api, symbol1)
target_pos2 = TargetPosTask(api, symbol2)
target_pos3 = TargetPosTask(api, symbol3)
orders = api.get_order()
try:
# 1 起始回测在21点后rb、cu下单，到第二日9点后jd下单
target_pos1.set_target_volume(1)
target_pos2.set_target_volume(2)
target_pos3.set_target_volume(3)
while max(quote1.datetime, quote2.datetime,
quote3.datetime) < "2019-12-02 21:05:00.000000":
api.wait_update()
self.assertEqual(len(orders), 2)
self.assertEqual(position1.pos, 1)
self.assertEqual(position2.pos, 2)
self.assertEqual(position3.pos, 0)
# 2 本交易日白盘9：00后jd下单
while max(quote1.datetime, quote2.datetime,
quote3.datetime) < "2019-12-03 09:02:00.000000":
api.wait_update()
self.assertEqual(len(orders), 3)
while True:
api.wait_update()
except BacktestFinished:
self.assertEqual(len(orders), 3)
self.assertEqual(position1.pos, 1)
self.assertEqual(position2.pos, 2)
self.assertEqual(position3.pos, 3)
api.close()
def test_lib_insert_order_time_check_2(self):
"""
lib下单时间判断测试2
回测时间：
10：15 - 10：45
订阅合约：
IF、T（无盘中休息时间）,cu（有盘中休息时间）
测试：
10:15 - 10:30期间IF和T能立即下单，cu等到10：30以后下单；
"""
# 预设服务器端响应
dir_path = os.path.dirname(os.path.realpath(__file__))
self.mock.run(
os.path.join(dir_path, "log_file",
"test_lib_insert_order_time_check_2.script.lzma"))
utils.RD = random.Random(4)
api = TqApi(backtest=TqBacktest(
datetime.datetime(2020, 2, 17, 10, 15, 0),
datetime.datetime(2020, 2, 17, 10, 45, 0)),
_ins_url=self.ins_url_2020_02_18,
_td_url=self.td_url,
_md_url=self.md_url)
symbol1 = "SHFE.cu2003"
symbol2 = "CFFEX.T2003"
symbol3 = "CFFEX.IF2003"
quote3 = api.get_quote(symbol3)
position1 = api.get_position(symbol1)
position2 = api.get_position(symbol2)
position3 = api.get_position(symbol3)
target_pos1 = TargetPosTask(api, symbol1)
target_pos2 = TargetPosTask(api, symbol2)
target_pos3 = TargetPosTask(api, symbol3)
orders = api.get_order()
try:
# 1 10:15 - 10:30期间IF和T能立即下单，cu等到10：30以后下单；
target_pos1.set_target_volume(1)
target_pos2.set_target_volume(2)
target_pos3.set_target_volume(3)
while datetime.datetime.strptime(
quote3.datetime,
"%Y-%m-%d %H:%M:%S.%f") < datetime.datetime(
2020, 2, 17, 10, 25):
api.wait_update()
self.assertEqual(len(orders), 2)
self.assertEqual(position1.pos, 0)
self.assertEqual(position2.pos, 2)
self.assertEqual(position3.pos, 3)
while True:
api.wait_update()
except BacktestFinished:
# 验证下單情況
self.assertEqual(len(orders), 3)
self.assertEqual(position1.pos, 1)
self.assertEqual(position2.pos, 2)
self.assertEqual(position3.pos, 3)
print("回测结束")
api.close()
def test_is_changing(self):
"""
is_changing() 测试
注：本函数不是回测，重新生成测试用例script文件时更改为当前可交易的合约代码,在盘中生成,且_ins_url可能需修改。
"""
# 预设服务器端响应
dir_path = os.path.dirname(os.path.realpath(__file__))
self.mock.run(
os.path.join(dir_path, "log_file",
"test_func_basic_is_changing.script.lzma"))
# 测试: 模拟账户下单
utils.RD = random.Random(4)
api = TqApi(_ins_url=self.ins_url_2020_04_02,
_td_url=self.td_url,
_md_url=self.md_url)
quote = api.get_quote("SHFE.rb2010")
position = api.get_position("SHFE.rb2010")
order1 = api.insert_order("DCE.m2009", "BUY", "OPEN", 1)
api.wait_update()
order2 = api.insert_order("SHFE.rb2010", "SELL", "OPEN", 2)
api.wait_update()
self.assertTrue(api.is_changing(order2, "status"))
self.assertTrue(api.is_changing(position, "volume_short"))
self.assertFalse(api.is_changing(position, "volume_long"))
order3 = api.insert_order("SHFE.rb2010", "BUY", "CLOSETODAY", 1)
while order3.status == "ALIVE":
api.wait_update()
self.assertTrue(api.is_changing(order3, "status"))
self.assertTrue(api.is_changing(position, "volume_short"))
self.assertFalse(api.is_changing(quote, "last_price"))
api.close()
def test_various_combinations_of_order_2(self):
"""
测试 能在回测时正常使用开、平顺序的多种组合方式下单
1 单次开平 * n次
2 多次开 一次全平完 (本测试函数)
3 多次开 分多次平完
4 单次开 分多次平完
related commit: a2623aed0fd1d5e5e01c7d2452e7f7f7de999c6e
"""
# 预设服务器端响应
dir_path = os.path.dirname(os.path.realpath(__file__))
self.mock.run(os.path.join(dir_path, "log_file", "test_various_combinations_of_order_2.script.lzma"))
# 测试2：多次开,一次全平完
utils.RD = random.Random(4)
api = TqApi(
backtest=TqBacktest(start_dt=datetime.datetime(2019, 12, 10, 9), end_dt=datetime.datetime(2019, 12, 11)),
_ins_url=self.ins_url_2019_07_03, _td_url=self.td_url, _md_url=self.md_url)
symbol = "DCE.m2005"
position = api.get_position(symbol)
order_open1 = api.insert_order(symbol, "BUY", "OPEN", 1)
order_open2 = api.insert_order(symbol, "BUY", "OPEN", 1)
order_open3 = api.insert_order(symbol, "BUY", "OPEN", 1)
while order_open1.status != "FINISHED" or order_open2.status != "FINISHED" or order_open3.status != "FINISHED":
api.wait_update()
self.assertEqual(position.pos, 3)
order_close1 = api.insert_order(symbol, "SELL", "CLOSE", 3)
while order_close1.status != "FINISHED":
api.wait_update()
self.assertEqual(position.pos, 0)
api.close()
def test_various_combinations_of_order_3(self):
"""
测试 能在回测时正常使用开、平顺序的多种组合方式下单
1 单次开平 * n次
2 多次开 一次全平完
3 多次开 分多次平完 (本测试函数)
4 单次开 分多次平完
related commit: a2623aed0fd1d5e5e01c7d2452e7f7f7de999c6e
"""
# 预设服务器端响应
dir_path = os.path.dirname(os.path.realpath(__file__))
self.mock.run(os.path.join(dir_path, "log_file", "test_various_combinations_of_order_3.script"))
# 测试3：多次开 分多次平完
TqApi.RD = random.Random(4)
api = TqApi(backtest=TqBacktest(start_dt=datetime(2019, 12, 10, 9), end_dt=datetime(2019, 12, 11)))
symbol = "DCE.m2005"
position = api.get_position(symbol)
t = 3
for i in range(t):
order_open = api.insert_order(symbol, "BUY", "OPEN", 1)
while order_open.status != "FINISHED":
api.wait_update()
self.assertEqual(position.pos, i + 1)
for i in range(t):
order_close = api.insert_order(symbol, "SELL", "CLOSE", 1)
while order_close.status != "FINISHED":
api.wait_update()
self.assertEqual(position.pos, t - 1 - i)
api.close()
def test_is_changing(self):
"""is_changing() 测试"""
# 预设服务器端响应
dir_path = os.path.dirname(os.path.realpath(__file__))
self.mock.run(os.path.join(dir_path, "log_file", "test_func_basic_is_changing.script.lzma"))
# 测试: 模拟账户下单
TqApi.RD = random.Random(4)
api = TqApi(_ins_url=self.ins_url, _td_url=self.td_url, _md_url=self.md_url)
quote = api.get_quote("SHFE.rb2001")
position = api.get_position("SHFE.rb2001")
order1 = api.insert_order("DCE.m2001", "BUY", "OPEN", 1)
api.wait_update()
order2 = api.insert_order("SHFE.rb2001", "SELL", "OPEN", 2)
api.wait_update()
self.assertEqual(api.is_changing(order2, "status"), True)
self.assertEqual(api.is_changing(position, "volume_short"), True)
self.assertEqual(api.is_changing(position, "volume_long"), False)
order3 = api.insert_order("SHFE.rb2001", "BUY", "CLOSETODAY", 1)
while order3.status == "ALIVE":
api.wait_update()
self.assertEqual(api.is_changing(order3, "status"), True)
self.assertEqual(api.is_changing(position, "volume_short"), True)
self.assertEqual(api.is_changing(quote, "last_price"), False)
api.close()
def test_lib_insert_order_time_check_6(self):
'''
lib下单时间判断测试6
测试：
设置目标持仓后在TargetPosTask未下单前调整目标持仓， lib等到10：30有行情之后调整到的是最新目标持仓
'''
# 预设服务器端响应
dir_path = os.path.dirname(os.path.realpath(__file__))
self.mock.run(
os.path.join(dir_path, "log_file",
"test_lib_insert_order_time_check_6.script.lzma"))
utils.RD = random.Random(4)
api = TqApi(backtest=TqBacktest(start_dt=datetime.datetime(
2019, 7, 11, 10, 15),
end_dt=datetime.date(2019, 7, 12)),
_ins_url=self.ins_url_2019_12_04,
_td_url=self.td_url,
_md_url=self.md_url)
symbol1 = "SHFE.cu1908"
symbol2 = "CFFEX.IF1908" # 用于行情推进，到10：20
quote2 = api.get_quote(symbol2)
target_pos = TargetPosTask(api, symbol1)
orders = api.get_order()
position = api.get_position(symbol1)
try:
target_pos.set_target_volume(5)
while quote2.datetime < "2019-07-11 10:20:00.000000":
api.wait_update()
self.assertEqual(len(api.get_order()), 0)
target_pos.set_target_volume(2)
while quote2.datetime < "2019-07-11 10:25:00.000000":
api.wait_update()
self.assertEqual(len(api.get_order()), 0)
while True:
api.wait_update()
except BacktestFinished:
self.assertEqual(len(orders), 1)
self.assertEqual(position.pos, 2)
api.close()
def test_is_changing(self):
# 预设服务器端响应
self.mock.run("test_func_basic_is_changing.script")
# 测试: 模拟账户下单
TqApi.RD = random.Random(4)
api = TqApi(_ins_url=self.ins_url,
_td_url=self.td_url,
_md_url=self.md_url)
quote = api.get_quote("SHFE.rb2001")
position = api.get_position("SHFE.rb2001")
order1 = api.insert_order("DCE.m2001", "BUY", "OPEN", 1)
api.wait_update()
order2 = api.insert_order("SHFE.rb2001", "SELL", "OPEN", 2)
api.wait_update()
self.assertEqual(api.is_changing(order2, "status"), True)
self.assertEqual(api.is_changing(position, "volume_short"), True)
self.assertEqual(api.is_changing(position, "volume_long"), False)
order3 = api.insert_order("SHFE.rb2001", "BUY", "CLOSETODAY", 1)
while order3.status == "ALIVE":
api.wait_update()
self.assertEqual(api.is_changing(order3, "status"), True)
self.assertEqual(api.is_changing(position, "volume_short"), True)
self.assertEqual(api.is_changing(quote, "last_price"), False)
def test_get_position_option(self):
"""
获取持仓
"""
# 预设服务器端响应
dir_path = os.path.dirname(os.path.realpath(__file__))
self.mock.run(
os.path.join(
dir_path, "log_file",
"test_td_basic_get_position_simulate_option.script.lzma"))
# 测试: 获取数据
api = TqApi(_ins_url=self.ins_url_2020_04_02,
_td_url=self.td_url,
_md_url=self.md_url)
order1 = api.insert_order("CZCE.SR007C5600",
"BUY",
"OPEN",
2,
limit_price=55)
order2 = api.insert_order("CZCE.SR007C5600",
"BUY",
"OPEN",
3,
limit_price=55)
order3 = api.insert_order("CZCE.SR007C5600",
"SELL",
"OPEN",
3,
limit_price=10)
order4 = api.insert_order("CZCE.SR007C5600", "SELL", "OPEN",
3) # 只有郑商所支持期权市价单
order5 = api.insert_order("DCE.m2007-P-2900", "BUY", "OPEN",
1) # 只有郑商所支持期权市价单
while order1.status == "ALIVE" or order2.status == "ALIVE" or order3.status == "ALIVE" or order4.status == "ALIVE" or order5.status == "ALIVE":
api.wait_update()
self.assertEqual(order4.volume_left, 0)
self.assertEqual(order5.volume_left, 1)
position = api.get_position("CZCE.SR007C5600")
position2 = api.get_position("DCE.m2007-P-2900")
self.assertEqual(0, position2.pos_long)
self.assertEqual(0, position2.pos_short)
# 测试脚本重新生成后，数据根据实际情况有变化
self.assertEqual(
"{'exchange_id': 'CZCE', 'instrument_id': 'SR007C5600', 'pos_long_his': 0, 'pos_long_today': 5, 'pos_short_his': 0, 'pos_short_today': 6, 'volume_long_today': 5, 'volume_long_his': 0, 'volume_long': 5, 'volume_long_frozen_today': 0, 'volume_long_frozen_his': 0, 'volume_long_frozen': 0, 'volume_short_today': 6, 'volume_short_his': 0, 'volume_short': 6, 'volume_short_frozen_today': 0, 'volume_short_frozen_his': 0, 'volume_short_frozen': 0, 'open_price_long': 55.0, 'open_price_short': 22.5, 'open_cost_long': 2750.0, 'open_cost_short': 1350.0, 'position_price_long': 55.0, 'position_price_short': 22.5, 'position_cost_long': 2750.0, 'position_cost_short': 1350.0, 'float_profit_long': -1000.0, 'float_profit_short': -750.0, 'float_profit': -1750.0, 'position_profit_long': 0.0, 'position_profit_short': 0.0, 'position_profit': 0.0, 'margin_long': 0.0, 'margin_short': 8156.4000000000015, 'margin': 8156.4000000000015, 'market_value_long': 1750.0, 'market_value_short': -2100.0, 'market_value': -350.0, 'last_price': 35.0}",
str(position))
self.assertEqual(-1, position.pos)
self.assertEqual(5, position.pos_long)
self.assertEqual(6, position.pos_short)
self.assertEqual(position.exchange_id, "CZCE")
self.assertEqual(position.instrument_id, "SR007C5600")
self.assertEqual(position.pos_long_his, 0)
self.assertEqual(position.pos_long_today, 5)
self.assertEqual(position.pos_short_his, 0)
self.assertEqual(position.pos_short_today, 6)
self.assertEqual(position.volume_long_today, 5)
self.assertEqual(position.volume_long_his, 0)
self.assertEqual(position.volume_long, 5)
self.assertEqual(position.volume_long_frozen_today, 0)
self.assertEqual(position.volume_long_frozen_his, 0)
self.assertEqual(position.volume_long_frozen, 0)
self.assertEqual(position.volume_short_today, 6)
self.assertEqual(position.volume_short_his, 0)
self.assertEqual(position.volume_short, 6)
self.assertEqual(position.volume_short_frozen_today, 0)
self.assertEqual(position.volume_short_frozen_his, 0)
self.assertEqual(position.volume_short_frozen, 0)
self.assertEqual(position.open_price_long, 55.0)
self.assertEqual(position.open_price_short, 22.5)
self.assertEqual(position.open_cost_long, 2750.0)
self.assertEqual(position.open_cost_short, 1350.0)
self.assertEqual(position.position_price_long, 55.0)
self.assertEqual(position.position_price_short, 22.5)
self.assertEqual(position.position_cost_long, 2750.0)
self.assertEqual(position.position_cost_short, 1350.0)
self.assertEqual(position.float_profit_long, -1000.0)
self.assertEqual(position.float_profit_short, -750.0)
self.assertEqual(position.float_profit, -1750.0)
self.assertEqual(position.position_profit_long, 0.0)
self.assertEqual(position.position_profit_short, 0.0)
self.assertEqual(position.position_profit, 0.0)
self.assertEqual(position.margin_long, 0.0)
self.assertEqual(position.margin_short, 8156.4000000000015)
self.assertEqual(position.margin, 8156.4000000000015)
self.assertEqual(position.market_value_long, 1750.0)
self.assertEqual(position.market_value_short, -2100.0)
self.assertEqual(position.market_value, -350.0)
self.assertEqual(position.last_price, 35.0)
# 其他取值方式测试
self.assertEqual(position["pos_long_today"], 5)
self.assertEqual(position["pos_short_today"], 6)
self.assertEqual(position["volume_long_his"], 0)
self.assertEqual(position["volume_long"], 5)
api.close()
api = TqApi(TqAccount(para['FUT_BROKER'], para['FUT_USER'],
para["FUT_PWD"]),
auth=TqAuth(para['ACCT_ID'], para['ACCT_PWD']))
account = api.get_account()
log.logger.info('初始账户权益：{0}'.format(account.balance))
log.logger.info('初始浮动盈亏：{0}'.format(account.float_profit))
SEC_LIST = []
for g_sec in g_security:
ls = api.get_quote('KQ.m@%s' % g_sec)
SEC_LIST.append(ls.underlying_symbol)
log.logger.info('品种集合：{0}'.format(SEC_LIST))
# 获取主力合约
# domain = api.get_quote("[email protected]")
# 获取主力合约的K线引用
for sec in SEC_LIST:
positions[sec] = api.get_position(sec)
klines_dict[sec] = api.get_kline_serial(sec, para['BAR_UNIT'],
para['BAR_NUM'])
quotes[sec] = api.get_quote(sec)
ticks[sec] = api.get_tick_serial(sec)
un_buy_open[sec] = []
un_sell_open[sec] = []
un_buy_close[sec] = []
un_sell_close[sec] = []
g_HS[sec] = []
g_LS[sec] = []
g_ZS[sec] = []
OPEN_DICT[sec] = open_num_list[SEC_LIST.index(sec)]
orders = api.get_order()
for order_id, val in orders.items():
secid = val['exchange_id'] + '.' + val['instrument_id']
time1 = time.ctime(klines2.iloc[-1].datetime / (10**9))
if api.is_changing(klines1):
diff = klines1['close'].iloc[-1] - klines2['close'].iloc[-1]
print(diff, klines1['close'].iloc[-1], klines2['close'].iloc[-1])
# print(time1, ' diff:%.3f' % diff)
if up_limit >= diff >= up:
# print(klines1['close'].iloc[-1], klines2['close'].iloc[-1])
while now1 == now2:
api.wait_update()
now2 = datetime.datetime.strptime(
quote1.datetime, "%Y-%m-%d %H:%M:%S.%f") # 当前quote的时间
# print(now1, now2)
# print(klines1['close'].iloc[-1], klines1['open'].iloc[-1])
if api.get_position('SHFE.zn2005').pos == 0:
target_pos1.set_target_volume(-1)
target_pos2.set_target_volume(1)
elif down_limit <= diff <= down:
# print(klines1['close'].iloc[-1], klines2['close'].iloc[-1])
while now1 == now2:
api.wait_update()
now2 = datetime.datetime.strptime(
quote1.datetime, "%Y-%m-%d %H:%M:%S.%f") # 当前quote的时间
# print(now1, now2)
# print(klines1['close'].iloc[-1], klines2['close'].iloc[-1])
# print(klines1['open'].iloc[-1], klines2['open'].iloc[-1])
if api.get_position('SHFE.zn2005').pos == 0:
target_pos1.set_target_volume(1)
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import time
from tqsdk import TqApi, TqAccount
api = TqApi(TqAccount('快期模拟', 'yhlz714', '86888196'), web_gui=True)
# 获得 m2005 的持仓引用，当持仓有变化时 position 中的字段会对应更新
position = api.get_position("SHFE.rb2010")
# 获得资金账户引用，当账户有变化时 account 中的字段会对应更新
account = api.get_account()
# 下单并返回委托单的引用，当该委托单有变化时 order 中的字段会对应更新
# order = api.insert_order(symbol="SHFE.rb2010", direction="BUY", offset="OPEN", volume=5, limit_price=3575)
orders = api.get_order()
for i in orders:
api.cancel_order(orders[i])
count = 0
while True:
api.wait_update()
# if api.is_changing(order, ["status", "volume_orign", "volume_left"]):
# print("单状态: %s, 已成交: %d 手" % (order.status, order.volume_orign - order.volume_left))
# print(order.status)
if api.is_changing(position, "pos_long_today"):
print("今多头: %d 手" % (position.pos_long_today))
if api.is_changing(account, "available"):
print("可用资金: %.2f" % (account.available))
count += 1
if 50 < count < 52:
pass
# api.cancel_order(order)
def test_get_position_option(self):
"""
获取持仓
"""
# 预设服务器端响应
dir_path = os.path.dirname(os.path.realpath(__file__))
self.mock.run(
os.path.join(
dir_path, "log_file",
"test_td_basic_get_position_simulate_option.script.lzma"))
# 测试: 获取数据
api = TqApi(_ins_url=self.ins_url_2020_04_02,
_td_url=self.td_url,
_md_url=self.md_url)
order1 = api.insert_order("CZCE.SR007C5600",
"BUY",
"OPEN",
2,
limit_price=55)
order2 = api.insert_order("CZCE.SR007C5600",
"BUY",
"OPEN",
3,
limit_price=55)
order3 = api.insert_order("CZCE.SR007C5600",
"SELL",
"OPEN",
3,
limit_price=52)
order4 = api.insert_order("CZCE.SR007C5600", "SELL", "OPEN", 3)
while order1.status == "ALIVE" or order2.status == "ALIVE" or order3.status == "ALIVE" or order4.status == "ALIVE":
api.wait_update()
self.assertEqual(order4.volume_left, 3)
position = api.get_position("CZCE.SR007C5600")
# 测试脚本重新生成后，数据根据实际情况有变化
self.assertEqual(
"{'exchange_id': 'CZCE', 'instrument_id': 'SR007C5600', 'pos_long_his': 0, 'pos_long_today': 5, 'pos_short_his': 0, 'pos_short_today': 3, 'volume_long_today': 5, 'volume_long_his': 0, 'volume_long': 5, 'volume_long_frozen_today': 0, 'volume_long_frozen_his': 0, 'volume_long_frozen': 0, 'volume_short_today': 3, 'volume_short_his': 0, 'volume_short': 3, 'volume_short_frozen_today': 0, 'volume_short_frozen_his': 0, 'volume_short_frozen': 0, 'open_price_long': 55.0, 'open_price_short': 52.0, 'open_cost_long': 2750.0, 'open_cost_short': 1560.0, 'position_price_long': 55.0, 'position_price_short': 52.0, 'position_cost_long': 2750.0, 'position_cost_short': 1560.0, 'float_profit_long': -100.0, 'float_profit_short': -30.0, 'float_profit': -130.0, 'position_profit_long': 0.0, 'position_profit_short': 0.0, 'position_profit': 0.0, 'margin_long': 0.0, 'margin_short': 4797.200000000001, 'margin': 4797.200000000001, 'market_value_long': 2650.0, 'market_value_short': -1590.0, 'market_value': 1060.0, 'last_price': 53.0}",
str(position))
self.assertEqual(2, position.pos)
self.assertEqual(5, position.pos_long)
self.assertEqual(3, position.pos_short)
self.assertEqual(position.exchange_id, "CZCE")
self.assertEqual(position.instrument_id, "SR007C5600")
self.assertEqual(position.pos_long_his, 0)
self.assertEqual(position.pos_long_today, 5)
self.assertEqual(position.pos_short_his, 0)
self.assertEqual(position.pos_short_today, 3)
self.assertEqual(position.volume_long_today, 5)
self.assertEqual(position.volume_long_his, 0)
self.assertEqual(position.volume_long, 5)
self.assertEqual(position.volume_long_frozen_today, 0)
self.assertEqual(position.volume_long_frozen_his, 0)
self.assertEqual(position.volume_long_frozen, 0)
self.assertEqual(position.volume_short_today, 3)
self.assertEqual(position.volume_short_his, 0)
self.assertEqual(position.volume_short, 3)
self.assertEqual(position.volume_short_frozen_today, 0)
self.assertEqual(position.volume_short_frozen_his, 0)
self.assertEqual(position.volume_short_frozen, 0)
self.assertEqual(position.open_price_long, 55.0)
self.assertEqual(position.open_price_short, 52.0)
self.assertEqual(position.open_cost_long, 2750.0)
self.assertEqual(position.open_cost_short, 1560.0)
self.assertEqual(position.position_price_long, 55.0)
self.assertEqual(position.position_price_short, 52.0)
self.assertEqual(position.position_cost_long, 2750.0)
self.assertEqual(position.position_cost_short, 1560.0)
self.assertEqual(position.float_profit_long, -100.0)
self.assertEqual(position.float_profit_short, -30.0)
self.assertEqual(position.float_profit, -130.0)
self.assertEqual(position.position_profit_long, 0.0)
self.assertEqual(position.position_profit_short, 0.0)
self.assertEqual(position.position_profit, 0.0)
self.assertEqual(position.margin_long, 0.0)
self.assertEqual(position.margin_short, 4797.200000000001)
self.assertEqual(position.margin, 4797.200000000001)
self.assertEqual(position.market_value_long, 2650.0)
self.assertEqual(position.market_value_short, -1590.0)
self.assertEqual(position.market_value, 1060.0)
self.assertEqual(position.last_price, 53.0)
# 其他取值方式测试
self.assertEqual(position["pos_long_today"], 5)
self.assertEqual(position["pos_short_today"], 3)
self.assertEqual(position["volume_long_his"], 0)
self.assertEqual(position["volume_long"], 5)
api.close()
def test_get_position(self):
"""
获取持仓
"""
# 预设服务器端响应
dir_path = os.path.dirname(os.path.realpath(__file__))
self.mock.run(
os.path.join(dir_path, "log_file",
"test_td_basic_get_position_simulate.script.lzma"))
# 测试: 获取数据
api = TqApi(_ins_url=self.ins_url,
_td_url=self.td_url,
_md_url=self.md_url)
order1 = api.insert_order("DCE.jd2001",
"BUY",
"OPEN",
1,
limit_price=4592)
order2 = api.insert_order("DCE.jd2001", "BUY", "OPEN", 3)
order3 = api.insert_order("DCE.jd2001", "SELL", "OPEN", 3)
while order1.status == "ALIVE" or order2.status == "ALIVE" or order3.status == "ALIVE":
api.wait_update()
position = api.get_position("DCE.jd2001")
# 测试脚本重新生成后，数据根据实际情况有变化
self.assertEqual(
"{'exchange_id': 'DCE', 'instrument_id': 'jd2001', 'pos_long_his': 0, 'pos_long_today': 4, 'pos_short_his': 0, 'pos_short_today': 3, 'volume_long_today': 4, 'volume_long_his': 0, 'volume_long': 4, 'volume_long_frozen_today': 0, 'volume_long_frozen_his': 0, 'volume_long_frozen': 0, 'volume_short_today': 3, 'volume_short_his': 0, 'volume_short': 3, 'volume_short_frozen_today': 0, 'volume_short_frozen_his': 0, 'volume_short_frozen': 0, 'open_price_long': 4193.0, 'open_price_short': 4059.0, 'open_cost_long': 167720.0, 'open_cost_short': 121770.0, 'position_price_long': 4193.0, 'position_price_short': 4059.0, 'position_cost_long': 167720.0, 'position_cost_short': 121770.0, 'float_profit_long': -5320.0, 'float_profit_short': -30.0, 'float_profit': -5350.0, 'position_profit_long': -5320.0, 'position_profit_short': -30.0, 'position_profit': -5350.0, 'margin_long': 11429.6, 'margin_short': 8572.2, 'margin': 20001.800000000003, 'symbol': 'DCE.jd2001', 'last_price': 4060.0}",
str(position))
self.assertEqual(1, position.pos)
self.assertEqual(4, position.pos_long)
self.assertEqual(3, position.pos_short)
self.assertEqual(position.exchange_id, "DCE")
self.assertEqual(position.instrument_id, "jd2001")
self.assertEqual(position.pos_long_his, 0)
self.assertEqual(position.pos_long_today, 4)
self.assertEqual(position.pos_short_his, 0)
self.assertEqual(position.pos_short_today, 3)
self.assertEqual(position.volume_long_today, 4)
self.assertEqual(position.volume_long_his, 0)
self.assertEqual(position.volume_long, 4)
self.assertEqual(position.volume_long_frozen_today, 0)
self.assertEqual(position.volume_long_frozen_his, 0)
self.assertEqual(position.volume_long_frozen, 0)
self.assertEqual(position.volume_short_today, 3)
self.assertEqual(position.volume_short_his, 0)
self.assertEqual(position.volume_short, 3)
self.assertEqual(position.volume_short_frozen_today, 0)
self.assertEqual(position.volume_short_frozen_his, 0)
self.assertEqual(position.volume_short_frozen, 0)
self.assertEqual(position.open_price_long, 4193.0)
self.assertEqual(position.open_price_short, 4059.0)
self.assertEqual(position.open_cost_long, 167720.0)
self.assertEqual(position.open_cost_short, 121770.0)
self.assertEqual(position.position_price_long, 4193.0)
self.assertEqual(position.position_price_short, 4059.0)
self.assertEqual(position.position_cost_long, 167720.0)
self.assertEqual(position.position_cost_short, 121770.0)
self.assertEqual(position.float_profit_long, -5320.0)
self.assertEqual(position.float_profit_short, -30.0)
self.assertEqual(position.float_profit, -5350.0)
self.assertEqual(position.position_profit_long, -5320.0)
self.assertEqual(position.position_profit_short, -30.0)
self.assertEqual(position.position_profit, -5350.0)
self.assertEqual(position.margin_long, 11429.6)
self.assertEqual(position.margin_short, 8572.2)
self.assertEqual(position.margin, 20001.800000000003)
self.assertEqual(position.symbol, "DCE.jd2001")
self.assertEqual(position.last_price, 4060.0)
# 其他取值方式测试
self.assertEqual(position["pos_long_today"], 4)
self.assertEqual(position["pos_short_today"], 3)
self.assertEqual(position["volume_long_his"], 0)
self.assertEqual(position["volume_long"], 4)
api.close()
ch.setLevel(logging.DEBUG) # 输出到console的log等级的开关
# 第三步，定义handler的输出格式
formatter = logging.Formatter("%(asctime)s - %(filename)s[line:%(lineno)d] - %(levelname)s: %(message)s")
fh.setFormatter(formatter)
ch.setFormatter(formatter)
# 第四步，将logger添加到handler里面
logger.addHandler(fh)
logger.addHandler(ch)
api = TqApi(TqSim())
#time_slot_start = datetime.time(START_HOUR, START_MINUTE) # 计划交易时段起始时间点
#time_slot_end = datetime.time(END_HOUR, END_MINUTE) # 计划交易时段终点时间点
klines = api.get_kline_serial(SYMBOL, TIME_CELL, data_length=int(10 * 60 * 60 / TIME_CELL))
target_pos = TargetPosTask(api, SYMBOL)
position = api.get_position(SYMBOL) # 持仓信息
quote = api.get_quote(SYMBOL)
logger.info("start %s daily strategy for %s!"%(c, SYMBOL))
current_volume = 0 # 记录持仓量
traded_volume = 0
cur_trading_date = ''
# 交易预警参数
k_count = 0
signal_interval = 10
short_price = 0.0
sum_profit = 0.0
last_kong_index = 0
#!/usr/bin/env python
# -*- coding: utf-8 -*-
__author__ = 'chengzhi'
from tqsdk import TqApi
api = TqApi()
# 获得 m2005 的持仓引用，当持仓有变化时 position 中的字段会对应更新
position = api.get_position("DCE.m2005")
# 获得资金账户引用，当账户有变化时 account 中的字段会对应更新
account = api.get_account()
# 下单并返回委托单的引用，当该委托单有变化时 order 中的字段会对应更新
order = api.insert_order(symbol="DCE.m2005", direction="BUY", offset="OPEN", volume=5)
while True:
api.wait_update()
if api.is_changing(order, ["status", "volume_orign", "volume_left"]):
print("单状态: %s, 已成交: %d 手" % (order.status, order.volume_orign - order.volume_left))
if api.is_changing(position, "pos_long_today"):
print("今多头: %d 手" % (position.pos_long_today))
if api.is_changing(account, "available"):
print("可用资金: %.2f" % (account.available))
def double_moving_average(api: TqApi,
symbol: str,
max_position: int = 10,
fast: int = 5,
slow: int = 20):
strategy_name: str = 'DoubleMovingAverage'
api: TqApi = api
symbol: str = symbol
timeout: int = 5
max_position: int = max_position
fast: int = fast
slow: int = slow
ma: DataFrame = DataFrame()
tq_account: Account = api.get_account()
tq_position: Position = api.get_position(symbol)
tq_candlestick: DataFrame = api.get_kline_serial(symbol=symbol,
duration_seconds=24 * 60 *
60)
tq_target_pos = TargetPosTask(api, symbol)
deadline: float
try:
while True:
deadline = time.time() + timeout
if not api.wait_update(deadline=deadline):
raise RuntimeError('没有在规定时间内获得数据！')
# api.wait_update()
if api.is_changing(tq_candlestick):
ma['fast'] = tafunc.ma(tq_candlestick.close, fast)
ma['slow'] = tafunc.ma(tq_candlestick.close, slow)
tq_candlestick['ma_fast'] = ma['fast']
tq_candlestick['ma_fast.color'] = 'green'
tq_candlestick['ma_slow'] = ma['slow']
tq_candlestick['ma_slow.color'] = 0xFF9933CC
# 最新的快均线数值 > 最新的慢均线数值，且 前一根快均线数值 < 前一根慢均线数值
# 即快均线从下向上穿过慢均线
if (ma['fast'].iloc[-1] > ma['slow'].iloc[-1]
and ma['fast'].iloc[-2] < ma['slow'].iloc[-2]):
# # 如果有空仓，平空仓
# if tq_position.pos_short > 0:
# api.insert_order(symbol=symbol,
# direction='BUY',
# offset='CLOSE',
# limit_price=tq_candlestick.close.iloc[-1],
# volume=tq_position.pos_short
# )
# # 开多仓
# api.insert_order(symbol=symbol,
# direction='BUY',
# offset='OPEN',
# limit_price=tq_candlestick.close.iloc[-1],
# volume=max_position
# )
tq_target_pos.set_target_volume(max_position)
# 最新的快均线数值 < 最新的慢均线数值，且 前一根快均线数值 > 前一根慢均线数值
# 即快均线从上向下穿过慢均线
if (ma['fast'].iloc[-1] < ma['slow'].iloc[-1]
and ma['fast'].iloc[-2] > ma['slow'].iloc[-2]):
# # 如果有多仓，平多仓
# if tq_position.pos_short > 0:
# api.insert_order(symbol=symbol,
# direction='SELL',
# offset='CLOSE',
# limit_price=tq_candlestick.close.iloc[-1],
# volume=tq_position.pos_short
# )
# # 开空仓
# api.insert_order(symbol=symbol,
# direction='SELL',
# offset='OPEN',
# limit_price=tq_candlestick.close.iloc[-1],
# volume=max_position
# )
tq_target_pos.set_target_volume(-max_position)
except BacktestFinished:
api.close()
print(f'参数: fast={fast}, slow={slow}, 最终权益={tq_account["balance"]}')
continue
while True:
if flag:
api.wait_update()
now_time_ = datetime.datetime.strptime(quote1.datetime,
"%Y-%m-%d %H:%M:%S.%f")
# print(datetime.datetime.strptime(quote1.datetime, "%Y-%m-%d %H:%M:%S.%f"))
# 进行做多或者做空操作
if pd.Timedelta(seconds=-15) < trade_date - now_time_ < pd.Timedelta(
seconds=15):
for kind, prob, tmp_close_time in zip(trade_kind, trade_prob,
close_time):
target_pos = TargetPosTask(api, kind)
hold_pos = api.get_position(kind).pos
if prob > buying_prob:
target_pos.set_target_volume(hold_pos + 1)
direction.append(1)
else:
target_pos.set_target_volume(hold_pos - 1)
direction.append(-1)
hold_kind.append(kind)
close_datetime.append(tmp_close_time)
# set_kind.add(kind)
print(kind, direction[-1], now_time_)
api.wait_update()
flag = True
trade_kind = []
trade_prob = []
# break
#!/usr/bin/env python
# -*- coding: utf-8 -*-
__author__ = 'chengzhi'
from tqsdk import TqApi, TqSim
api = TqApi(TqSim())
# 获得 m1909 的持仓引用，当持仓有变化时 position 中的字段会对应更新
position = api.get_position("DCE.m1909")
# 获得资金账户引用，当账户有变化时 account 中的字段会对应更新
account = api.get_account()
# 下单并返回委托单的引用，当该委托单有变化时 order 中的字段会对应更新
order = api.insert_order(symbol="DCE.m1909",
direction="BUY",
offset="OPEN",
volume=5)
while True:
api.wait_update()
if api.is_changing(order, ["status", "volume_orign", "volume_left"]):
print("单状态: %s, 已成交: %d 手" %
(order["status"], order["volume_orign"] - order["volume_left"]))
if api.is_changing(position, "volume_long_today"):
print("今多头: %d 手" % (position["volume_long_today"]))
if api.is_changing(account, "available"):
print("可用资金: %.2f" % (account["available"]))
class CuatroStrategy(Process):
''''''
author = 'XIAO LI'
boll_window = 20
boll_dev = 1.8
rsi_window = 14
rsi_signal = 20
fast_window = 4
slow_window = 26
trailing_long = 0.5
trailing_short = 0.3
vol = 1
boll_up = float('nan')
boll_down = float('nan')
rsi_value = float('nan')
rsi_long = float('nan')
rsi_short = float('nan')
fast_ma = float('nan')
slow_ma = float('nan')
ma_trend = float('nan')
intra_trade_high = float('nan')
intra_trade_low = float('nan')
long_stop = float('nan')
short_stop = float('nan')
parameters = [
'boll_window'
'boll_dev'
'rsi_window'
'rsi_signal'
'fast_window'
'slow_window'
'trailing_long'
'trailing_short'
'vol'
]
variables = [
'boll_up'
'boll_down'
'rsi_value'
'rsi_long'
'rsi_short'
'fast_ma'
'slow_ma'
'ma_trend'
'intra_trade_high'
'intra_trade_low '
'long_stop'
'short_stop'
]
def __init__(self, symbol):
Process.__init__(self)
self.symbol = symbol
self.rsi_long = 50 + self.rsi_signal
self.rsi_short = 50 - self.rsi_signal
self.api = TqApi(TqSim(init_balance=50000))
self.now = datetime.now()
self.target_pos = TargetPosTask(self.api, self.symbol)
self.ticks = self.api.get_tick_serial(self.symbol)
self.klines5 = self.api.get_kline_serial(self.symbol, 60 * 5)
self.klines15 = self.api.get_kline_serial(self.symbol, 60 * 15)
self.position = self.api.get_position(self.symbol)
def on_init(self):
print(self.now, '策略初始化')
def on_start(self):
print(self.now, '策略启动')
def on_stop(self):
print(self.now, '策略停止')
def on_tick(self, ticks):
if self.api.is_changing(ticks, 'datetime'):
if self.position.pos_long == 0 and self.position.pos_short == 0:
if self.ma_trend > 0 and self.rsi_value >= self.rsi_long and ticks.iloc[-1].last_price > self.boll_up:
self.target_pos.set_target_volume(self.vol)
self.intra_trade_high = ticks.iloc[-1].last_price
if self.ma_trend < 0 and self.rsi_value <= self.rsi_short and ticks.iloc[
-1].last_price < self.boll_down:
self.target_pos.set_target_volume(-self.vol)
self.intra_trade_low = ticks.iloc[-1].last_price
elif self.position.pos_long > 0:
self.intra_trade_high = max(self.intra_trade_high, ticks.iloc[-1].last_price)
self.long_stop = (self.intra_trade_high - self.trailing_long * (self.boll_up - self.boll_down))
if ticks.iloc[-1].last_price < self.long_stop:
self.target_pos.set_target_volume(0)
self.intra_trade_high = float('nan')
else:
self.intra_trade_low = min(self.intra_trade_low, ticks.iloc[-1].last_price)
self.short_stop = (self.intra_trade_low + self.trailing_short * (self.boll_up - self.boll_down))
if ticks.iloc[-1].last_price > self.short_stop:
self.target_pos.set_target_volume(0)
self.intra_trade_low = float('nan')
def on_5minbar(self, klines5):
if self.api.is_changing(klines5, 'datetime'):
boll = ta.BOLL(klines5.iloc[:-1], self.boll_window, self.boll_dev).iloc[-1]
self.boll_up = boll['top']
self.boll_down = boll['bottom']
self.rsi_value = ta.RSI(klines5.iloc[:-1], self.rsi_window).iloc[-1]['rsi']
def on_15minbar(self, klines15):
if self.api.is_changing(klines15, 'datetime'):
self.fast_ma = ta.SMA(klines15.iloc[:-1], self.fast_window, 2)
self.slow_ma = ta.SMA(klines15.iloc[:-1], self.slow_window, 2)
if self.fast_ma > self.slow_ma:
self.ma_trend = 1
elif self.fast_ma < self.slow_ma:
self.ma_trend = -1
else:
self.ma_trend = 0
def on_order(self):
if self.api.is_changing(self.api.get_order()):
pass
def on_trade(self):
if self.api.is_changing(self.api.get_trade()):
pass
def run(self):
self.on_init()
self.on_start()
while True:
self.api.wait_update()
self.on_tick(self.ticks)
self.on_5minbar(self.klines5)
self.on_15minbar(self.klines15)
self.on_order()
self.on_trade()
self.on_stop()
__author__ = 'chengzhi'
import subprocess
from tqsdk import TqApi, TqAccount
import nest_asyncio
nest_asyncio.apply()
# api = TqApi(TqAccount("H华安期货", "117889998", "262010",front_broker='6020',front_url='tcp://183.11.217.235:41207'),web_gui="0.0.0.0:9876")
# api = TqApi(TqAccount("快期模拟", "cjj208", "Chenjj1230"))
api = TqApi(TqAccount("simnow",
"090828",
"jimc1230",
front_broker='9999',
front_url='tcp://180.168.146.187:10100'),
web_gui="0.0.0.0:9876")
# 获得 m2005 的持仓引用，当持仓有变化时 position 中的字段会对应更新
position = api.get_position("SHFE.rb2005")
# 获得资金账户引用，当账户有变化时 account 中的字段会对应更新
account = api.get_account()
# 下单并返回委托单的引用，当该委托单有变化时 order 中的字段会对应更新
order = api.insert_order(symbol="SHFE.rb2005",
direction="BUY",
offset="OPEN",
volume=2,
limit_price=3521)
#canorder = api.cancel_order(order)
while True:
api.wait_update()
if api.is_changing(order, ["status", "volume_orign", "volume_left"]):
#subprocess.call("cls",shell=True)
print("单状态: %s, 已成交: %d 手" %
from tqsdk.tafunc import ma
data_length = 200 # k线数据长度
SYMBOL = "SHFE.rb2005" # 合约代码
api = TqApi(TqAccount("simnow", "090828", "jimc1230",front_broker='9999',front_url='tcp://180.168.146.187:10100'),web_gui="0.0.0.0:9876")#web_gui="0.0.0.0:9876"
# api = TqApi(backtest=TqBacktest(start_dt=date(2020, 3,10), end_dt=date(2020, 3, 19)),web_gui="0.0.0.0:9876")#"0.0.0.0:9876"#回测模式
# api = TqApi(backtest = TqReplay(date(2020,3,18)),web_gui="0.0.0.0:9876")#复盘模式
print("策略开始运行")
# "duration_seconds=60"为一分钟线, 日线的duration_seconds参数为: 24*60*60
klines = api.get_kline_serial(SYMBOL, duration_seconds=1*60, data_length=data_length)
#收盘后不可查
target_pos = TargetPosTask(api, SYMBOL)
position = api.get_position(SYMBOL)#指定一个品种查看持仓相关信息
account = api.get_account()#获取用户账户资金信息
while True:
api.wait_update()
if api.is_changing(klines.iloc[-1], "datetime"): # 产生新k线:重新计算SMA
klines["ma5"]=ma(klines["close"], 5)
klines["ma10"]=ma(klines["close"], 10)
klines["ma89"]=ma(klines["close"], 89)
klines["ma144"]=ma(klines["close"], 144)
sar=SAR(klines, 4, 0.02, 0.2)
if api.is_changing(klines.iloc[-1], "datetime"): # 产生新k线:重新计算SMA
except Exception as e:
logger.info('problem with sign in!')
exit(1)
f = open('strategytorun.txt')
temp = f.readlines()
f.close()
'---------------------------------------------------初始化数据------------------------------------------------------'
strategys = {}
allTick = {}
allKline = RealFeed()
# 初始化策略
pos = api.get_position()
orders = api.get_order()
broker = RealBroker(api, pos)
allStg = []
# 设置所有策略的基策略的交易模式。
stg.YhlzStreategy.realTrade = True
stg.YhlzStreategy.realBroker = broker
realAccount = pd.read_csv('currentAccount.csv')
for item in temp:
item = eval(item)
# !!! 策略不可重名， 如需同策略不同参数，可以继承一个，然后换个名字。
strategys[item[0]] = item[1:] # 将strategy to run 中的策略对应的 名字和合约记录下来。
for dataNeeded in item[1:]:
if str(dataNeeded[0]) not in allKline:
trading_info['position'] = trading_info['position'].apply(
lambda x: int(np.around(x, 0)))
trading_info.index = trading_info['trading_code']
print(trading_info)
code_lst = trading_info.trading_code.tolist()
while datetime.datetime.now().hour < 15:
print(
'=========================================================================================='
)
orders = api.get_order()
for oid, order in orders.items():
if order.status == 'ALIVE':
print(order.status)
api.cancel_order(order)
positions = api.get_position()
for symbol, order in positions.items():
if symbol not in code_lst:
if order.pos_long > 0:
Trd.insert_order_sp_limit(symbol)
if order.pos_short > 0:
Trd.insert_order_bp_limit(symbol)
for code in code_lst:
position_account = api.get_position(code)
position_long = position_account.pos_long
position_short = position_account.pos_short
position = trading_info.loc[code]['position']
if code == 'DCE.y2009':
a = 0
if position == 0 and position_short == 0 and position_long == 0:
def test_lib_insert_order_time_check_3(self):
'''
lib下单时间判断测试3
回测时间：
第一日白盘11:30 - 第二日白盘9：40
订阅合约：
IF、T（无盘中休息时间）,cu（有盘中休息时间）
测试：
1 T、IF在13：00后下单，cu到13：30后下单
2 15:00 - 15:15 : T能下单，IF、cu不能下单
3 2020.2.18 交易所通知cu这段时间没有夜盘，因此之前set的手数到第二个交易日开盘后下单
4 cu在9点开盘下单，IF在9:30开盘下单
'''
# 预设服务器端响应
dir_path = os.path.dirname(os.path.realpath(__file__))
self.mock.run(
os.path.join(dir_path, "log_file",
"test_lib_insert_order_time_check_3.script.lzma"))
utils.RD = random.Random(4)
api = TqApi(backtest=TqBacktest(datetime.datetime(2020, 2, 17, 11, 30),
datetime.datetime(2020, 2, 18, 9, 40)),
_ins_url=self.ins_url_2020_02_18)
symbol1 = "SHFE.cu2003"
symbol2 = "CFFEX.T2003"
symbol3 = "CFFEX.IF2003"
quote1 = api.get_quote(symbol1)
quote2 = api.get_quote(symbol2)
quote3 = api.get_quote(symbol3)
position1 = api.get_position(symbol1)
position2 = api.get_position(symbol2)
position3 = api.get_position(symbol3)
target_pos1 = TargetPosTask(api, symbol1)
target_pos2 = TargetPosTask(api, symbol2)
target_pos3 = TargetPosTask(api, symbol3)
orders = api.get_order()
try:
# 1 T、IF在13：00后下单，cu到13：30后下单
target_pos1.set_target_volume(1)
target_pos2.set_target_volume(2)
target_pos3.set_target_volume(3)
while max(quote1.datetime, quote2.datetime,
quote3.datetime) < "2020-02-17 13:15:00.000000":
api.wait_update()
self.assertEqual(len(orders), 2)
self.assertEqual(position1.pos, 0)
self.assertEqual(position2.pos, 2)
self.assertEqual(position3.pos, 3)
while max(quote1.datetime, quote2.datetime,
quote3.datetime) < "2020-02-17 13:31:00.000000":
api.wait_update()
self.assertEqual(len(orders), 3)
while max(quote1.datetime, quote2.datetime,
quote3.datetime) < "2020-02-17 13:40:00.000000":
api.wait_update()
self.assertEqual(position1.pos, 1)
self.assertEqual(position2.pos, 2)
self.assertEqual(position3.pos, 3)
while max(quote1.datetime, quote2.datetime,
quote3.datetime) < "2020-02-17 15:00:00.000000":
api.wait_update()
# 2 15:00 - 15:15 : T能下单，IF、cu不能下单
target_pos1.set_target_volume(4)
target_pos2.set_target_volume(5)
target_pos3.set_target_volume(6)
while max(quote1.datetime, quote2.datetime,
quote3.datetime) < "2020-02-17 15:13:59.000000":
api.wait_update()
self.assertEqual(len(orders), 4)
self.assertEqual(position1.pos, 1)
self.assertEqual(position2.pos, 5)
self.assertEqual(position3.pos, 3)
# 3 2020.2.18 交易所通知cu这段时间没有夜盘，因此之前set的手数到第二个交易日开盘后下单
while max(quote1.datetime, quote2.datetime,
quote3.datetime) < "2020-02-18 09:00:00.0000":
api.wait_update()
self.assertEqual(len(orders), 4)
self.assertEqual(position1.pos, 1)
self.assertEqual(position2.pos, 5)
self.assertEqual(position3.pos, 3)
# 4 cu在9点开盘下单，IF在9:30开盘下单
while max(quote1.datetime, quote2.datetime,
quote3.datetime) < "2020-02-18 09:20:00.0000":
api.wait_update()
self.assertEqual(len(orders), 5)
self.assertEqual(position1.pos, 4)
self.assertEqual(position2.pos, 5)
self.assertEqual(position3.pos, 3)
while max(quote1.datetime, quote2.datetime,
quote3.datetime) < "2020-02-18 09:35:00.0000":
api.wait_update()
self.assertEqual(len(orders), 6)
self.assertEqual(position1.pos, 4)
self.assertEqual(position2.pos, 5)
self.assertEqual(position3.pos, 6)
while True:
api.wait_update()
except BacktestFinished:
self.assertEqual(len(orders), 6)
self.assertEqual(position1.pos, 4)
self.assertEqual(position2.pos, 5)
self.assertEqual(position3.pos, 6)
api.close()
ls_symbols = ['SHFE.rb1910', 'SHFE.hc1910', 'CZCE.MA909', 'CZCE.TA909', 'DCE.i1909']
# ls_symbols = ['SHFE.fu1909', 'SHFE.bu1912', 'DCE.jd1909']
api = TqApi('SIM')
# api = TqApi(TqSim(), backtest=TqBacktest(start_dt=dt.date(2019,1,2), end_dt=dt.date(2019,1,10)))
dict_quotes = {}
dict_klines = {}
dict_positions = {}
dict_target_pos = {}
dict_update_kline_chan = {}
dict_update_quote_chan = {}
for SYMBOL in ls_symbols:
dict_quotes[SYMBOL] = api.get_quote(SYMBOL) # 行情数据
dict_klines[SYMBOL] = api.get_kline_serial(SYMBOL, duration_seconds=15 * 60)
dict_positions[SYMBOL] = api.get_position(SYMBOL)
dict_target_pos[SYMBOL] = TargetPosTask(api, SYMBOL)
dict_update_kline_chan[SYMBOL] = api.register_update_notify(dict_klines[SYMBOL])
dict_update_quote_chan[SYMBOL] = api.register_update_notify(dict_quotes[SYMBOL])
async def signal_generator(SYMBOL, strategy):
"""该task应用策略在价格触发时开仓，出发平仓条件时平仓"""
klines = dict_klines[SYMBOL]
position = dict_positions[SYMBOL]
target_pos = dict_target_pos[SYMBOL]
update_kline_chan = dict_update_kline_chan[SYMBOL]
while True:
target_pos_value = 0
async for _ in update_kline_chan:
def test_lib_insert_order_time_check_4(self):
'''
lib下单时间判断测试4
回测时间：
起始交易日（datetime.date）为周一
订阅合约：
cu（有夜盘,凌晨1点结束夜盘）,rb（夜盘23点结束）,jd（无夜盘）
测试：
(测试周五夜盘21点到周六凌晨1点及周一夜盘、周二白盘)
1 周五晚21：00之后: cu、rb能下单, jd到周一的9点后下单
2 周六凌晨1点前：cu能下单
3 周一早9点后都能下单
4 周一晚21点后cu、rb能下单
5 周二白盘开始后，jd能下单
'''
# 预设服务器端响应
dir_path = os.path.dirname(os.path.realpath(__file__))
self.mock.run(
os.path.join(dir_path, "log_file",
"test_lib_insert_order_time_check_4.script.lzma"))
utils.RD = random.Random(4)
api = TqApi(backtest=TqBacktest(datetime.date(2019, 12, 2),
datetime.date(2019, 12, 3)),
_ins_url=self.ins_url_2019_12_04) # 2019.12.2:周一
symbol1 = "SHFE.cu2002" # 有夜盘,凌晨1点结束夜盘
symbol2 = "SHFE.rb2002" # 夜盘23点结束
symbol3 = "DCE.jd2002" # 无夜盘
quote1 = api.get_quote(symbol1)
quote2 = api.get_quote(symbol2)
quote3 = api.get_quote(symbol3)
position1 = api.get_position(symbol1)
position2 = api.get_position(symbol2)
position3 = api.get_position(symbol3)
target_pos1 = TargetPosTask(api, symbol1)
target_pos2 = TargetPosTask(api, symbol2)
target_pos3 = TargetPosTask(api, symbol3)
orders = api.get_order()
try:
# 1 周五晚21：00之后: cu、rb能下单, jd到周一的9点后下单
target_pos1.set_target_volume(1)
target_pos2.set_target_volume(2)
target_pos3.set_target_volume(3)
while max(quote1.datetime, quote2.datetime,
quote3.datetime) < "2019-11-29 21:05:00.000000":
api.wait_update()
self.assertEqual(len(orders), 2)
self.assertEqual(position1.pos, 1)
self.assertEqual(position2.pos, 2)
self.assertEqual(position3.pos, 0)
# 2 周五23点后到周六凌晨1点前：cu能下单
while max(quote1.datetime, quote2.datetime,
quote3.datetime) < "2019-11-29 23:00:00.000000":
api.wait_update()
target_pos1.set_target_volume(4)
target_pos2.set_target_volume(5)
target_pos3.set_target_volume(6)
while max(quote1.datetime, quote2.datetime,
quote3.datetime) < "2019-11-29 23:05:00.000000":
api.wait_update()
self.assertEqual(len(orders), 3)
self.assertEqual(position1.pos, 4)
self.assertEqual(position2.pos, 2)
self.assertEqual(position3.pos, 0)
# 3 周一早9点后都能下单
while max(quote1.datetime, quote2.datetime,
quote3.datetime) < "2019-12-02 09:05:00.000000":
api.wait_update()
self.assertEqual(len(orders), 5)
self.assertEqual(position1.pos, 4)
self.assertEqual(position2.pos, 5)
self.assertEqual(position3.pos, 6)
# 4 周一晚21点后cu、rb能下单
while max(quote1.datetime, quote2.datetime,
quote3.datetime) < "2019-12-02 21:00:00.000000":
api.wait_update()
target_pos1.set_target_volume(0)
target_pos2.set_target_volume(0)
target_pos3.set_target_volume(0)
while max(quote1.datetime, quote2.datetime,
quote3.datetime) < "2019-12-02 21:15:00.000000":
api.wait_update()
self.assertEqual(len(orders), 7)
self.assertEqual(position1.pos, 0)
self.assertEqual(position2.pos, 0)
self.assertEqual(position3.pos, 6)
# 5 周二白盘开始后，jd能下单
while max(quote1.datetime, quote2.datetime,
quote3.datetime) < "2019-12-03 09:02:00.000000":
api.wait_update()
self.assertEqual(len(orders), 8)
while True:
api.wait_update()
except BacktestFinished:
self.assertEqual(len(orders), 8)
self.assertEqual(position1.pos, 0)
self.assertEqual(position2.pos, 0)
self.assertEqual(position3.pos, 0)
api.close()
菲阿里四价 策略(日内突破策略, 在每日收盘前对所持合约进行平仓)
参考: https://www.shinnytech.com/blog/fairy-four-price/
注: 该示例策略仅用于功能示范, 实盘时请根据自己的策略/经验进行修改
'''
from tqsdk import TqApi, TargetPosTask
from datetime import datetime
import time
symbol = "SHFE.cu2002" # 合约代码
close_hour, close_minute = 14, 50 # 平仓时间
api = TqApi() # 使用模拟帐号直连行情和交易服务器
quote = api.get_quote(symbol) # 获取指定合约的盘口行情
klines = api.get_kline_serial(symbol, 24 * 60 * 60) # 获取日线
position = api.get_position(symbol) # 持仓信息
target_pos = TargetPosTask(api, symbol) # 目标持仓
top_rail = klines.high.iloc[-2] # 上轨: 昨日高点
bottom_rail = klines.low.iloc[-2] # 下轨: 昨日低点
print("上轨:", top_rail, ",下轨:", bottom_rail, ",昨日收盘价:", klines.close.iloc[-2], ",今日开盘价:", klines.open.iloc[-1])
while True:
api.wait_update()
if api.is_changing(klines.iloc[-1], "datetime"): # 如果产生一根新日线 (即到达下一个交易日): 重新获取上下轨
top_rail = klines.high.iloc[-2]
bottom_rail = klines.low.iloc[-2]
print("上轨:", top_rail, ",下轨:", bottom_rail, ",昨日收盘价:", klines.close.iloc[-2], ",今日开盘价:", klines.open.iloc[-1])
if api.is_changing(quote, "last_price"): # 如果行情最新价发生变化
print("当前最新价", quote.last_price)
def test_lib_insert_order_time_check_1(self):
"""
lib下单时间判断测试1
回测时间:
周一21:00 - 周二10:00
合约订阅：
无夜盘; 有夜盘24：00结束; 有夜盘25：00结束
测试：
21：00起始时刻两个有夜盘合约立即下單，无夜盘合约第二日白盘下单；
23：00某一夜盘合约停止交易后不能下單，另一合约能下單；
"""
# 预设服务器端响应
dir_path = os.path.dirname(os.path.realpath(__file__))
self.mock.run(
os.path.join(dir_path, "log_file",
"test_lib_insert_order_time_check_1.script.lzma"))
utils.RD = random.Random(4)
api = TqApi(backtest=TqBacktest(
datetime.datetime(2019, 12, 2, 21, 0, 0),
datetime.datetime(2019, 12, 3, 10, 0, 0)),
_ins_url=self.ins_url_2019_12_04) # 2019.12.2周一
symbol1 = "DCE.jd2002" # 无夜盘
symbol2 = "SHFE.rb2002" # 夜盘23点结束
symbol3 = "SHFE.cu2002" # 夜盘凌晨1点结束
quote3 = api.get_quote(symbol3)
target_pos1 = TargetPosTask(api, symbol1)
target_pos2 = TargetPosTask(api, symbol2)
target_pos3 = TargetPosTask(api, symbol3)
position1 = api.get_position(symbol1)
position2 = api.get_position(symbol2)
position3 = api.get_position(symbol3)
orders = api.get_order()
try:
# 1 21：00起始时刻有夜盘合约立即下單，无夜盘合约第二日白盘下单；
target_pos1.set_target_volume(1)
target_pos2.set_target_volume(2)
target_pos3.set_target_volume(3)
while datetime.datetime.strptime(
quote3.datetime,
"%Y-%m-%d %H:%M:%S.%f") < datetime.datetime(
2019, 12, 2, 21, 2):
api.wait_update()
self.assertEqual(len(orders), 2)
self.assertEqual(position1.pos, 0)
self.assertEqual(position2.pos, 2)
self.assertEqual(position3.pos, 3)
# 2 23：00某一夜盘合约停止交易后不能下單，另一合约能下單；
while datetime.datetime.strptime(
quote3.datetime,
"%Y-%m-%d %H:%M:%S.%f") < datetime.datetime(
2019, 12, 3, 0, 0):
api.wait_update()
target_pos1.set_target_volume(4)
target_pos2.set_target_volume(5)
target_pos3.set_target_volume(6)
while datetime.datetime.strptime(
quote3.datetime,
"%Y-%m-%d %H:%M:%S.%f") < datetime.datetime(
2019, 12, 3, 0, 30):
api.wait_update()
self.assertEqual(len(orders), 3)
self.assertEqual(position1.pos, 0)
self.assertEqual(position2.pos, 2)
self.assertEqual(position3.pos, 6)
while True:
api.wait_update()
except BacktestFinished:
# 验证下單情況
# 第二个交易日白盘，将所有合约调整到目标手数
self.assertEqual(len(orders), 5)
self.assertEqual(position1.pos, 4)
self.assertEqual(position2.pos, 5)
self.assertEqual(position3.pos, 6)
print("回测结束")
api.close()
