from hopex.constant.definition import OrderSide
from hopex.client.trade import TradeClient
from hopex.constant.test import t_api_key, t_secret_key
from hopex.utils.log_info import LogInfo
import time
trade_client = TradeClient(api_key=t_api_key, secret_key=t_secret_key)
"""
The history orders information
:params
contract_code_list: Contract List, Being blank to search all contracts
type_list: 1.Limit Price to Open 2.Market Price to Open 3.Limit Price to Close 4.Market Price to Close
5.Limit Price Close Partially Complete 6.Market Price Close Partially Complete
side: 1:Sell 2Buy,0:search all
start_time: 0:search all,Start Time Stamp(Unit microsecond)
end_time: 0:search all,End Time Stamp(Unit microsecond)
"""
# case query history orders all
contract_code_list = ['BTCUSDT', 'ETHUSDT']
type_list = []
side = 0 # 0:no limit
start_time = 0
end_time = 0
page = 1
limit = 10
list_obj = trade_client.req_history_orders(
contract_code_list=contract_code_list,
type_list=type_list,
side=side,
from hopex.constant.definition import OrderTradeType, OrderType
from hopex.client.trade import TradeClient
from hopex.constant.test import t_api_key, t_secret_key
from hopex.utils.log_info import LogInfo
trade_client = TradeClient(api_key=t_api_key, secret_key=t_secret_key)
"""
create condition order information
:params
side: 1:Buy Long, 2:Sell Short, 3:Buy to Close Short, 4:Sell to Close Long
type: Limit:limit order Market:market order
trig_price: Trigger price
expected_quantity: Preset quantity
expected_price: Preset price
"""
contract_code = 'BTCUSDT'
# # case condition limit order
res = trade_client.create_condition_order(contract_code=contract_code,
side=OrderTradeType.BUY_LONG,
type=OrderType.LIMIT,
trig_price=55000,
expected_quantity=10,
expected_price=54500)
if res and len(res) and res.get('ret', -1) == 0 and res.get('data', False):
LogInfo.output("create condition limit order success")
else:
LogInfo.output("create condition limit order fail:{res}".format(res=res))
from hopex.client.trade import TradeClient
from hopex.constant.test import t_api_key, t_secret_key
from hopex.constant.definition import OrderTradeType
from hopex.utils.log_info import LogInfo
trade_client = TradeClient(api_key=t_api_key, secret_key=t_secret_key)
contract_code = 'BTCUSDT'
res = trade_client.create_order(contract_code=contract_code, side=OrderTradeType.BUY_LONG, order_quantity=10,
order_price=40000)
if res and len(res) and res.get('ret', -1) == 0:
order_id = res.get('data', 0)
LogInfo.output("created order id : {id}".format(id=order_id))
cancel_res = trade_client.cancel_order(contract_code=contract_code, order_id=order_id)
if cancel_res and len(cancel_res) and res.get('ret', -1) == 0 and res.get('data', False):
LogInfo.output("cancel order {id} done".format(id=order_id))
else:
LogInfo.output_list("cancel order fail: {res}".format(res=cancel_res))
else:
LogInfo.output_list("create order fail: {res}".format(res=res))
from hopex.client.trade import TradeClient
from hopex.constant.test import t_api_key, t_secret_key
from hopex.utils.log_info import LogInfo
trade_client = TradeClient(api_key=t_api_key, secret_key=t_secret_key)
"""
The condition orders information
:params
contract_code_list: Contract List, Being blank to search all contracts
task_type_list: 1:Buy Long, 2:Sell Short, 3:Buy to Close Short, 4:Sell to Close Long, Being blank to search all
trig_type_list: 1:Market Price 2:Faire Price,Being blank to search all
task_status_list: 1: Untriggered 2.Canceled 3.Order Submitted 4.Trigger failed, Being blank to search all
direct: 1 LONG,2 SHORT,0:search all
side: 1:Sell 2Buy,0:search all
start_time: 0:search all,Start Time Stamp(Unit microsecond)
end_time: 0:search all,End Time Stamp(Unit microsecond)
"""
# case query condition orders all
contract_code_list = ['BTCUSDT', 'ETHUSDT']
task_type_list = []
trig_type_list = []
task_status_list = []
direct = 0
side = 0
start_time = 0
end_time = 0
list_obj = trade_client.req_condition_orders(contract_code_list=contract_code_list, task_type_list=task_type_list,
from hopex.client.trade import TradeClient from hopex.constant.test import t_api_key, t_secret_key from hopex.utils.log_info import LogInfo trade_client = TradeClient(api_key=t_api_key, secret_key=t_secret_key) contract_code = 'BTCUSDT' obj = trade_client.req_order_paras(contract_code=contract_code) LogInfo.output(obj)
def test_trade(self):
trade_client = TradeClient(api_key=t_api_key,
secret_key=t_secret_key,
performance_test=True)
# case req_order_paras
tc = TimeCost(function_name=trade_client.req_order_paras.__name__)
result, tc.server_req_cost, tc.server_api_cost = trade_client.req_order_paras(
contract_code)
print("req_order_paras:", result)
tc.run_status = RunStatus.SUCCESS if result and len(
result) else RunStatus.FAILED
tc.add_record()
# case req_liquidation_history
tc = TimeCost(
function_name=trade_client.req_liquidation_history.__name__)
contract_code_list = [contract_code]
side = 0
result, tc.server_req_cost, tc.server_api_cost = trade_client.req_liquidation_history(
contract_code_list, side)
print("req_liquidation_history:", result)
tc.run_status = RunStatus.SUCCESS if result and len(
result) else RunStatus.FAILED
tc.add_record()
# case req_history_orders
tc = TimeCost(function_name=trade_client.req_history_orders.__name__)
contract_code_list = list()
type_list = list()
side = 0
start_time = 0
end_time = 0
result, tc.server_req_cost, tc.server_api_cost = trade_client.req_history_orders(
contract_code_list, type_list, side, start_time, end_time)
print("req_history_orders:", result)
tc.run_status = RunStatus.SUCCESS if result and len(
result) else RunStatus.FAILED
tc.add_record()
# case get_positions
tc = TimeCost(function_name=trade_client.get_positions.__name__)
result, tc.server_req_cost, tc.server_api_cost = trade_client.get_positions(
)
print("get_positions:", result)
tc.run_status = RunStatus.SUCCESS if result and len(
result) else RunStatus.FAILED
tc.add_record()
# case get_open_orders
tc = TimeCost(function_name=trade_client.get_open_orders.__name__)
result, tc.server_req_cost, tc.server_api_cost = trade_client.get_open_orders(
contract_code)
print("get_open_orders:", result)
tc.run_status = RunStatus.SUCCESS if result and len(
result) else RunStatus.FAILED
tc.add_record()
# case set_leverage
tc = TimeCost(function_name=trade_client.set_leverage.__name__)
direct = Direct.LONG
leverage = 20
result, tc.server_req_cost, tc.server_api_cost = trade_client.set_leverage(
contract_code, direct, leverage)
print("set_leverage:", result)
tc.run_status = RunStatus.SUCCESS if result and len(
result) else RunStatus.FAILED
tc.add_record()
# case create_order
tc = TimeCost(function_name=trade_client.create_order.__name__)
side = OrderTradeType.BUY_LONG
order_quantity = 10
order_price = 48000
result, tc.server_req_cost, tc.server_api_cost = trade_client.create_order(
contract_code, side, order_quantity, order_price)
print("create_order:", result)
order_id_tmp = result['data'] if result and result.get('ret',
-1) == 0 else 0
tc.run_status = RunStatus.SUCCESS if result and result.get(
'ret', -1) == 0 else RunStatus.FAILED
tc.add_record()
# case cancel_order
tc = TimeCost(function_name=trade_client.cancel_order.__name__)
result, tc.server_req_cost, tc.server_api_cost = trade_client.cancel_order(
contract_code, order_id_tmp)
print("cancel_order:", result)
tc.run_status = RunStatus.SUCCESS if result and result.get(
'ret', -1) == 0 else RunStatus.FAILED
tc.add_record()
# case create_condition_order
tc = TimeCost(
function_name=trade_client.create_condition_order.__name__)
side = OrderTradeType.BUY_LONG
trig_price = 50000
expected_quantity = 10
expected_price = 48000
result, tc.server_req_cost, tc.server_api_cost = trade_client.create_condition_order(
contract_code, side, OrderType.LIMIT, trig_price,
expected_quantity, expected_price)
print("create_condition_order:", result)
tc.run_status = RunStatus.SUCCESS if result and result.get(
'ret', -1) == 0 else RunStatus.FAILED
tc.add_record()
# case req_condition_orders
tc = TimeCost(function_name=trade_client.req_condition_orders.__name__)
contract_code_list = [contract_code]
task_type_list = list()
trig_type_list = list()
task_status_list = list()
direct = 0
side = 0
start_time = 0
end_time = 0
result, tc.server_req_cost, tc.server_api_cost = trade_client.req_condition_orders(
contract_code_list, task_type_list, trig_type_list,
task_status_list, direct, side, start_time, end_time)
print("req_condition_orders:", result)
task_data = result.get(
'data', {}) if result and result.get('ret', -1) == 0 else {}
task_list = task_data.get('result', list())
task_list = list(
filter(
lambda x: x['taskStatus'] == 1
if x.get('taskStatus') else False, task_list))
print(task_list)
task_id_tmp = task_list[0].get('taskId', 0) if len(task_list) else 0
tc.run_status = RunStatus.SUCCESS if result and result.get(
'ret', -1) == 0 else RunStatus.FAILED
tc.add_record()
# case cancel_condition_order
tc = TimeCost(
function_name=trade_client.cancel_condition_order.__name__)
print(task_id_tmp)
result, tc.server_req_cost, tc.server_api_cost = trade_client.cancel_condition_order(
contract_code, task_id_tmp)
print("cancel_condition_order:", result)
tc.run_status = RunStatus.SUCCESS if result and result.get(
'ret', -1) == 0 else RunStatus.FAILED
tc.add_record()
from hopex.client.trade import TradeClient
from hopex.constant.definition import OrderSide
from hopex.constant.test import t_api_key, t_secret_key
from hopex.utils.log_info import LogInfo
trade_client = TradeClient(api_key=t_api_key, secret_key=t_secret_key)
"""
The liquidation_history information
:params
contract_code_list: Contract List, Being blank to search all contracts
side: 1:Sell 2Buy,0:search all
"""
contract_code_list = ['BTCUSDT', 'ETHUSDT']
page = 1
limit = 10
list_obj = trade_client.req_liquidation_history(
contract_code_list=contract_code_list, side=0, page=page, limit=limit)
# list_obj = trade_client.req_liquidation_history(contract_code_list=contract_code, OrderSide.BUY, page, limit)
# list_obj = trade_client.req_liquidation_history(contract_code_list=contract_code, OrderSide.SELL, page, limit)
LogInfo.output_list(list_obj)
from hopex.client.trade import TradeClient from hopex.constant.test import t_api_key, t_secret_key from hopex.utils.log_info import LogInfo trade_client = TradeClient(api_key=t_api_key, secret_key=t_secret_key) list_obj = trade_client.get_positions() LogInfo.output_list(list_obj)
from hopex.client.trade import TradeClient from hopex.constant.test import t_api_key, t_secret_key from hopex.utils.log_info import LogInfo trade_client = TradeClient(api_key=t_api_key, secret_key=t_secret_key) contract_code = 'BTCUSDT' list_obj = trade_client.get_open_orders(contract_code=contract_code) LogInfo.output_list(list_obj)