def must_buy_sell(order_type,
symbol,
amount,
price,
amount_precision,
price_precision,
max_times=20,
loop_sleep_time=3):
trade_client = TradeClient(api_key=g_api_key, secret_key=g_secret_key)
print("START TO %s @Local_Time:" % order_type,
datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S.%f'))
while (max_times):
while (1):
try:
order_id = trade_client.create_order(symbol,
account_id=g_account_id,
order_type=order_type,
source=OrderSource.API,
amount=precision_cali(
amount,
amount_precision),
price=price)
break
except requests.exceptions.ProxyError as e:
print(e)
continue
except requests.exceptions.ConnectionError as e:
print(e)
continue
except requests.exceptions.ReadTimeout as e:
print(e)
continue
time.sleep(loop_sleep_time)
while (1):
try:
orderObj = trade_client.get_order(order_id=order_id)
break
except requests.exceptions.ProxyError as e:
print(e)
continue
except requests.exceptions.ConnectionError as e:
print(e)
continue
except requests.exceptions.ReadTimeout as e:
print(e)
continue
if orderObj.state == "filled":
filled_price = precision_cali((float(orderObj.filled_cash_amount) /
float(orderObj.filled_amount)),
price_precision)
filled_amount = precision_cali(float(orderObj.filled_amount),
amount_precision) - float(
orderObj.filled_fees)
print(
"No.%d Order %s state is %s @" %
(max_times, order_id, orderObj.state),
datetime.datetime.fromtimestamp(
orderObj.finished_at /
1000).strftime('%Y-%m-%d %H:%M:%S.%f'))
print("No.%d Order filled amount is %s @filled price: %.8f" %
(max_times, filled_amount, filled_price))
return [filled_price, filled_amount]
else:
while (1):
canceled_order_id = trade_client.cancel_order(symbol, order_id)
if canceled_order_id == order_id:
print("Canceled order %s done" % canceled_order_id)
break
else:
print("Canceled order %s fail" % canceled_order_id)
continue
while (1):
try:
canceled_orderObj = trade_client.get_order(
order_id=canceled_order_id)
print("No.%d Canceled order filled amount is %s" %
(max_times, canceled_orderObj.filled_amount))
break
except requests.exceptions.ProxyError as e:
print(e)
continue
except requests.exceptions.ConnectionError as e:
print(e)
continue
except requests.exceptions.ReadTimeout as e:
print(e)
continue
max_times -= 1
amount -= float(canceled_orderObj.filled_amount)
from huobi.client.trade import TradeClient
from huobi.constant import *
from huobi.utils import *
trade_client = TradeClient(api_key=g_api_key, secret_key=g_secret_key)
symbol_test = "eosusdt"
order_id = trade_client.create_order(symbol=symbol_test,
account_id=g_account_id,
order_type=OrderType.BUY_LIMIT,
source=OrderSource.API,
amount=18,
price=0.292)
LogInfo.output("created order id : {id}".format(id=order_id))
canceled_order_id = trade_client.cancel_order(symbol_test, order_id)
if canceled_order_id == order_id:
LogInfo.output("cancel order {id} done".format(id=canceled_order_id))
else:
LogInfo.output("cancel order {id} fail".format(id=canceled_order_id))
def test_trade_order(self):
trade_client = TradeClient(api_key=g_api_key,
secret_key=g_secret_key,
performance_test=True)
client_order_id = "test_" + str(round(time.time())) + "_id"
print("client order id : ", client_order_id)
# case create_order
tc = TimeCost(function_name=trade_client.create_order.__name__)
result, tc.server_req_cost, tc.server_api_cost = trade_client.order_id = trade_client.create_order(
symbol=trade_symbol,
account_id=g_account_id,
order_type=OrderType.BUY_LIMIT,
source=OrderSource.API,
amount=55,
price=0.1,
client_order_id=client_order_id,
stop_price=0.08,
operator="gte")
order_id_tmp = result
tc.run_status = RunStatus.SUCCESS if result else RunStatus.FAILED
tc.add_record()
# case get_order
tc = TimeCost(function_name=trade_client.get_order.__name__)
result, tc.server_req_cost, tc.server_api_cost = trade_client.order_id = trade_client.get_order(
order_id=order_id_tmp)
tc.run_status = RunStatus.SUCCESS if result else RunStatus.FAILED
tc.add_record()
# case get_order_by_client_order_id
tc = TimeCost(
function_name=trade_client.get_order_by_client_order_id.__name__)
result, tc.server_req_cost, tc.server_api_cost = trade_client.order_id = trade_client.get_order_by_client_order_id(
client_order_id=client_order_id)
tc.run_status = RunStatus.SUCCESS if 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.order_id = trade_client.get_open_orders(
symbol=trade_symbol, account_id=g_account_id)
tc.run_status = RunStatus.SUCCESS if result and len(
result) else RunStatus.FAILED
tc.add_record()
# case get_orders
tc = TimeCost(function_name=trade_client.get_orders.__name__)
result, tc.server_req_cost, tc.server_api_cost = trade_client.order_id = trade_client.get_orders(
symbol=trade_symbol,
order_type=OrderType.BUY_LIMIT,
order_state=OrderState.SUBMITTED)
tc.run_status = RunStatus.SUCCESS if result and len(
result) 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.order_id = trade_client.cancel_order(
symbol=trade_symbol, order_id=order_id_tmp)
tc.run_status = RunStatus.SUCCESS if result else RunStatus.FAILED
tc.add_record()
class TradeHandler:
def __init__(self):
self.api_key = "db8f342a-3540b528-hrf5gdfghe-5e793"
self.secret_key = "366684d9-94c5fdf7-ad3b02a0-446bf"
self.trade_client = TradeClient(api_key=self.api_key,
secret_key=self.secret_key)
self.algo_client = AlgoClient(api_key=self.api_key,
secret_key=self.secret_key)
self.trade_log = pd.DataFrame(
columns=['Time', 'Amount', 'Fee', 'Price', 'Symbol', 'OrderType'])
def get_feerate(self, symbol):
list_obj = self.trade_client.get_feerate(symbols=symbol)
LogInfo.output_list(list_obj)
def get_history_orders(self, symbol_list):
for symbol in symbol_list:
list_obj = self.trade_client.get_history_orders(symbol=symbol,
start_time=None,
end_time=None,
size=20,
direct=None)
LogInfo.output_list(list_obj)
def get_match_result(self, symbol):
list_obj = self.trade_client.get_match_result(symbol=symbol, size=100)
for obj in list_obj:
self.trade_log = self.trade_log.append(pd.Series(
[
obj.created_at, obj.filled_amount, obj.filled_fees,
obj.price, obj.symbol, obj.type
],
index=[
'Time', 'Amount', 'Fee', 'Price', 'Symbol', 'OrderType'
]),
ignore_index=True)
# LogInfo.output_list(list_obj)
self.trade_log = self.trade_log.drop_duplicates()
def get_open_orders(self, id, symbol):
list_obj = self.trade_client.get_open_orders(
symbol=symbol, account_id=id, direct=QueryDirection.NEXT)
LogInfo.output_list(list_obj)
# list_obj = self.trade_client.get_open_orders(symbol=symbol, account_id=id, direct=QueryDirection.PREV)
# LogInfo.output_list(list_obj)
def get_order(self, order_id):
order_obj = self.trade_client.get_order(order_id=order_id)
# LogInfo.output("======= get order by order id : {order_id} =======".format(order_id=order_id))
# order_obj.print_object()
return order_obj
def batch_cancel(self, account_id):
# cancel all the open orders under account
result = self.trade_client.cancel_open_orders(account_id=account_id)
def create_order_limit(self, symbol, account_id, order_type, amount,
price):
order_id = self.trade_client.create_order(symbol=symbol,
account_id=account_id,
order_type=order_type,
source=OrderSource.API,
amount=amount,
price=price)
LogInfo.output("created order id : {id}".format(id=order_id))
def create_order_market(self, symbol, account_id, order_type, value):
order_id = self.trade_client.create_order(symbol=symbol,
account_id=account_id,
order_type=order_type,
source=OrderSource.API,
amount=value,
price=None)
return order_id
def cancel_order(self, symbol, order_id):
canceled_order_id = self.trade_client.cancel_order(symbol, order_id)
if canceled_order_id == order_id:
LogInfo.output(
"cancel order {id} done".format(id=canceled_order_id))
else:
LogInfo.output(
"cancel order {id} fail".format(id=canceled_order_id))