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_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_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_get_order(self):
"""
获取委托单信息
"""
# 预设服务器端响应
dir_path = os.path.dirname(os.path.realpath(__file__))
self.mock.run(os.path.join(dir_path, "log_file", "test_td_basic_get_order_simulate.script.lzma"))
# 测试: 模拟账户下单
utils.RD = random.Random(4)
api = TqApi(_ins_url=self.ins_url_2019_07_03, _td_url=self.td_url, _md_url=self.md_url)
order1 = api.insert_order("DCE.jd2005", "BUY", "OPEN", 1)
order2 = api.insert_order("SHFE.cu2005", "SELL", "OPEN", 2, limit_price=40750)
while order1.status == "ALIVE" or order2.status == "ALIVE":
api.wait_update()
get_order1 = api.get_order(order1.order_id)
get_order2 = api.get_order(order2.order_id)
self.assertEqual(get_order1.order_id, "1710cf5327ac435a7a97c643656412a9")
self.assertEqual(get_order1.direction, "BUY")
self.assertEqual(get_order1.offset, "OPEN")
self.assertEqual(get_order1.volume_orign, 1)
self.assertEqual(get_order1.volume_left, 0)
self.assertNotEqual(get_order1.limit_price, get_order1.limit_price) # 判断nan
self.assertEqual(get_order1.price_type, "ANY")
self.assertEqual(get_order1.volume_condition, "ANY")
self.assertEqual(get_order1.time_condition, "IOC")
# 因为TqSim模拟交易的 insert_date_time 不是固定值，所以改为判断范围（前后100毫秒）
self.assertAlmostEqual(1586415071223454000 / 1e9, get_order1.insert_date_time / 1e9, places=1)
self.assertEqual(get_order1.last_msg, "全部成交")
self.assertEqual(get_order1.status, "FINISHED")
self.assertEqual(get_order1.frozen_margin, 0)
self.assertEqual(get_order2.order_id, "8ca5996666ceab360512bd1311072231")
self.assertEqual(get_order2.direction, "SELL")
self.assertEqual(get_order2.offset, "OPEN")
self.assertEqual(get_order2.volume_orign, 2)
self.assertEqual(get_order2.volume_left, 0)
self.assertEqual(get_order2.limit_price, 40750)
self.assertEqual(get_order2.price_type, "LIMIT")
self.assertEqual(get_order2.volume_condition, "ANY")
self.assertEqual(get_order2.time_condition, "GFD")
self.assertAlmostEqual(1586415071224110000 / 1e9, get_order2["insert_date_time"] / 1e9, places=1)
self.assertEqual(get_order2["last_msg"], "全部成交")
self.assertEqual(get_order2["status"], "FINISHED")
self.assertEqual(get_order2.frozen_margin, 0)
del get_order1["insert_date_time"]
del get_order2["insert_date_time"]
self.assertEqual(str(get_order1),
"{'order_id': '1710cf5327ac435a7a97c643656412a9', 'exchange_order_id': '1710cf5327ac435a7a97c643656412a9', 'exchange_id': 'DCE', 'instrument_id': 'jd2005', 'direction': 'BUY', 'offset': 'OPEN', 'volume_orign': 1, 'volume_left': 0, 'limit_price': nan, 'price_type': 'ANY', 'volume_condition': 'ANY', 'time_condition': 'IOC', 'last_msg': '全部成交', 'status': 'FINISHED', 'user_id': 'TQSIM', 'frozen_margin': 0.0, 'frozen_premium': 0.0}")
self.assertEqual(str(get_order2),
"{'order_id': '8ca5996666ceab360512bd1311072231', 'exchange_order_id': '8ca5996666ceab360512bd1311072231', 'exchange_id': 'SHFE', 'instrument_id': 'cu2005', 'direction': 'SELL', 'offset': 'OPEN', 'volume_orign': 2, 'volume_left': 0, 'limit_price': 40750.0, 'price_type': 'LIMIT', 'volume_condition': 'ANY', 'time_condition': 'GFD', 'last_msg': '全部成交', 'status': 'FINISHED', 'user_id': 'TQSIM', 'frozen_margin': 0.0, 'frozen_premium': 0.0}")
api.close()
def test_get_order(self):
"""
获取委托单信息
"""
# 预设服务器端响应
dir_path = os.path.dirname(os.path.realpath(__file__))
self.mock.run(os.path.join(dir_path, "log_file", "test_td_basic_get_order_simulate.script"))
# 测试: 模拟账户下单
TqApi.RD = random.Random(4)
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)
order2 = api.insert_order("SHFE.cu2001", "SELL", "OPEN", 2, limit_price=47040)
while order1.status == "ALIVE" or order2.status == "ALIVE":
api.wait_update()
get_order1 = api.get_order(order1.order_id)
get_order2 = api.get_order(order2.order_id)
self.assertEqual(str(get_order1),
"{'order_id': '1710cf5327ac435a7a97c643656412a9', 'exchange_order_id': '1710cf5327ac435a7a97c643656412a9', 'exchange_id': 'DCE', 'instrument_id': 'jd2001', 'direction': 'BUY', 'offset': 'OPEN', 'volume_orign': 1, 'volume_left': 0, 'limit_price': nan, 'price_type': 'ANY', 'volume_condition': 'ANY', 'time_condition': 'IOC', 'insert_date_time': 631123200000000000, 'last_msg': '全部成交', 'status': 'FINISHED', 'user_id': 'TQSIM', 'symbol': 'DCE.jd2001', 'frozen_margin': 0.0}")
self.assertEqual(str(get_order2),
"{'order_id': '8ca5996666ceab360512bd1311072231', 'exchange_order_id': '8ca5996666ceab360512bd1311072231', 'exchange_id': 'SHFE', 'instrument_id': 'cu2001', 'direction': 'SELL', 'offset': 'OPEN', 'volume_orign': 2, 'volume_left': 0, 'limit_price': 47040.0, 'price_type': 'LIMIT', 'volume_condition': 'ANY', 'time_condition': 'GFD', 'insert_date_time': 631123200000000000, 'last_msg': '全部成交', 'status': 'FINISHED', 'user_id': 'TQSIM', 'symbol': 'SHFE.cu2001', 'frozen_margin': 0.0}")
self.assertEqual(get_order1.order_id, "1710cf5327ac435a7a97c643656412a9")
self.assertEqual(get_order1.direction, "BUY")
self.assertEqual(get_order1.offset, "OPEN")
self.assertEqual(get_order1.volume_orign, 1)
self.assertEqual(get_order1.volume_left, 0)
self.assertEqual(get_order1.limit_price != get_order1.limit_price, True) # 判断nan
self.assertEqual(get_order1.price_type, "ANY")
self.assertEqual(get_order1.volume_condition, "ANY")
self.assertEqual(get_order1.time_condition, "IOC")
self.assertEqual(get_order1.insert_date_time, 631123200000000000)
self.assertEqual(get_order1.last_msg, "全部成交")
self.assertEqual(get_order1.status, "FINISHED")
self.assertEqual(get_order1.symbol, "DCE.jd2001")
self.assertEqual(get_order1.frozen_margin, 0)
self.assertEqual(get_order2.order_id, "8ca5996666ceab360512bd1311072231")
self.assertEqual(get_order2.direction, "SELL")
self.assertEqual(get_order2.offset, "OPEN")
self.assertEqual(get_order2.volume_orign, 2)
self.assertEqual(get_order2.volume_left, 0)
self.assertEqual(get_order2.limit_price, 47040)
self.assertEqual(get_order2.price_type, "LIMIT")
self.assertEqual(get_order2.volume_condition, "ANY")
self.assertEqual(get_order2.time_condition, "GFD")
self.assertEqual(get_order2["insert_date_time"], 631123200000000000)
self.assertEqual(get_order2["last_msg"], "全部成交")
self.assertEqual(get_order2["status"], "FINISHED")
self.assertEqual(get_order2.symbol, "SHFE.cu2001")
self.assertEqual(get_order2.frozen_margin, 0)
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()
trading_info = get_signal(res_n, aum, balance, EndDate, close_dict)
trading_info.to_csv(fold_path + 'position_hmm_' + EndDate + '.csv')
subject = date + strategy_id
send_email(trading_info, subject, receiver)
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)
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()
if api.is_changing(ticks):
now = time_to_datetime(ticks.iloc[-1].datetime)
if (now.hour >= 9 and now.hour < 15) or (now.hour >= 21 and now.hour < 23):
if is_clear_all1:
api.insert_order(symbol, "SELL", close, position.pos_long, quote.bid_price1 - 2)
is_clear_all1 = False
if is_clear_all2:
api.insert_order(symbol, "BUY", close, position.pos_short, quote.ask_price1 + 2)
is_clear_all2 = False
#################################################################################
if api.is_changing(quote):
df = pd.DataFrame(api.get_order().values())
if not df.empty:
df_long_open = df[
((df["exchange_id"] + "." + df["instrument_id"]) == symbol) & (df["direction"] == "BUY") & (
df["offset"] == "OPEN") & (df["volume_left"] == df["volume_orign"]) & (
df["status"] == "ALIVE")]
df_short_open = df[
((df["exchange_id"] + "." + df["instrument_id"]) == symbol) & (df["direction"] == "SELL") & (
df["offset"] == "OPEN") & (df["volume_left"] == df["volume_orign"]) & (
df["status"] == "ALIVE")]
df_long_close = df[
((df["exchange_id"] + "." + df["instrument_id"]) == symbol) & (df["direction"] == "SELL") & (
df["offset"] == close) & (df["volume_left"] == df["volume_orign"]) & (
df["status"] == "ALIVE")]
df_short_close = df[
((df["exchange_id"] + "." + df["instrument_id"]) == symbol) & (df["direction"] == "BUY") & (
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()
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()
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()
'''
下单
order = api.insert_order(symbol="SHFE.rb2005", direction="BUY", offset="OPEN", volume=1, limit_price=3570)
CFFEX: 中金所 SHFE: 上期所 DCE: 大商所 CZCE: 郑商所 INE: 能源交易所(原油)
'''
try:
# 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")#web_gui="0.0.0.0:9876"
account = api.get_account() # 获取用户账户资金信息
klines = api.get_kline_serial('SHFE.rb2005', 5 * 60,
data_length=500) #获取k线序列数据
position = api.get_position('SHFE.rb2005') #指定一个品种查看持仓相关信息
order = api.get_order('SHFE.rb2005') # 获取用户委托单信息
quote = api.get_quote('SHFE.rb2005') #获取指定合约的盘口行情.
api.is_changing(position, "pos_long_today") #判定obj最近是否有更新
# orderinsert = api.insert_order(symbol="SHFE.rb2005", direction="BUY", offset="OPEN", volume=1, limit_price=3570)
except Exception as e:
print("行情服务连不上, 或者期货公司服务器关了, 或者账号密码错了, 总之就是有问题")
# 监听下单后有没有成交
api.wait_update()
order = api.insert_order(symbol="SHFE.rb2005",
direction="BUY",
offset="CLOSE",
volume=5,
limit_price=3549)
print("单状态: %s, 已成交: %d 手" %
(order.status, order.volume_orign - order.volume_left))
else:
return 0
acc = TqSim()
try:
api = TqApi(acc,
backtest=TqBacktest(start_dt=date(2019, 10, 5),
end_dt=date(2019, 11, 15)))
klines = api.get_kline_serial("SHFE.rb2001", 300, 1000)
while True:
api.wait_update()
klines = api.get_kline_serial("SHFE.rb2001", 300, 1000)
if 判断是否符合开仓(klines):
当前多仓 = api.get_position("SHFE.rb2001")
当前委托 = api.get_order()
当前该品种未成交的 = sum([
当前委托[x]['volume_left'] for x in 当前委托
if 当前委托[x]['instrument_id'] == "SHFE.rb2001"
])
if 当前多仓['pos_long_his'] == 0 and 当前多仓[
'pos_long_tody'] == 0 and 当前该品种未成交的 == 0:
order = api.insert_order(symbol="SHFE.rb2001",
direction="BUY",
offset="OPEN",
volume=1000)
print('.......我开仓了.....')
q = api.get_quote("SHFE.rb2001")
print(q["datetime"])
if 判断是否符合平仓(klines):
当前多仓 = api.get_position("SHFE.rb2001")
