def test_trade_fee(self):
trade_client = TradeClient(api_key=g_api_key,
secret_key=g_secret_key,
performance_test=True)
# case get_feerate
tc = TimeCost(function_name=trade_client.get_feerate.__name__)
result, tc.server_req_cost, tc.server_api_cost = trade_client.get_feerate(
symbols="htusdt,btcusdt,eosusdt," + trade_symbol)
tc.run_status = RunStatus.SUCCESS if result and len(
result) else RunStatus.FAILED
tc.add_record()
# case get_transact_feerate
tc = TimeCost(function_name=trade_client.get_transact_feerate.__name__)
result, tc.server_req_cost, tc.server_api_cost = trade_client.get_transact_feerate(
symbols="htusdt,btcusdt,eosusdt," + trade_symbol)
tc.run_status = RunStatus.SUCCESS if result and len(
result) else RunStatus.FAILED
tc.add_record()
def get_orders(symbols):
try:
trade_client = TradeClient(api_key=g_api_key, secret_key=g_secret_key)
for symbol in symbols:
list_obj = trade_client.get_orders(
symbol=symbol,
order_state=OrderState.SUBMITTED,
order_type=None,
start_date=None,
end_date=None,
start_id=None,
size=None,
direct=QueryDirection.PREV)
LogInfo.output(" {symbol} {count} orders found".format(
symbol=symbol, count=len(list_obj)))
if len(list_obj):
LogInfo.output_list(list_obj)
except:
print("ExecuteError")
def get_orders_id_list(symbol):
try:
trade_client = TradeClient(api_key=g_api_key, secret_key=g_secret_key)
list_obj = trade_client.get_orders(symbol=symbol,
order_state=OrderState.SUBMITTED,
order_type=None,
start_date=None,
end_date=None,
start_id=None,
size=None,
direct=QueryDirection.PREV)
order_id_list = []
if len(list_obj):
a = __Autonomy__()
current = sys.stdout
sys.stdout = a
LogInfo.output_list(list_obj)
sys.stdout = current
order_id_list = get_value("Order Id", a._buff)
except:
print("ExecuteError")
return order_id_list
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
generic_client = GenericClient()
list_symbol = generic_client.get_exchange_symbols()
list_currency = generic_client.get_reference_currencies()
print(list_symbol[0])
print(list_currency[0].print_object())
a = c
access_key = " "
secret_key = " "
# Create generic client instance and get the timestamp
generic_client = GenericClient()
timestamp = generic_client.get_exchange_timestamp()
print(timestamp)
# Create the market client instance and get the latest btcusdt‘s candlestick
market_client = MarketClient()
list_obj = market_client.get_candlestick("btcusdt", CandlestickInterval.MIN5,
10)
LogInfo.output_list(list_obj)
# // Create an AccountClient instance with APIKey
account_client = AccountClient(api_key=access_key, secret_key=secret_key)
# // Create a TradeClient instance with API Key and customized host
trade_client = TradeClient(api_key=access_key,
secret_key=secret_key,
url="https://api-aws.huobi.pro")
def has_buy_order(symbol, buy_price, sell_price, check_partial):
try:
trade_client = TradeClient(api_key=g_api_key, secret_key=g_secret_key)
list_obj = trade_client.get_orders(symbol=symbol,
order_state=OrderState.SUBMITTED,
order_type=None,
start_date=None,
end_date=None,
start_id=None,
size=None,
direct=QueryDirection.PREV)
count = len(list_obj)
order_type = []
for obj in list_obj:
a = __Autonomy__()
current = sys.stdout
sys.stdout = a
obj.print_object()
sys.stdout = current
order_type = get_value("Order Type", a._buff)
price = get_value("Price", a._buff)
current_price = float(price[0])
if (order_type[0] == "buy-limit"):
if current_price == buy_price:
return True, True
else:
if current_price == sell_price:
return True, False
except:
print("ExecuteError")
if check_partial:
try:
list_obj = trade_client.get_orders(
symbol=symbol,
order_state=OrderState.PARTIAL_FILLED,
order_type=None,
start_date=None,
end_date=None,
start_id=None,
size=None,
direct=QueryDirection.PREV)
count = len(list_obj)
order_type = []
for obj in list_obj:
a = __Autonomy__()
current = sys.stdout
sys.stdout = a
obj.print_object()
sys.stdout = current
order_type = get_value("Order Type", a._buff)
price = get_value("Price", a._buff)
current_price = float(price[0])
if (order_type[0] == "buy-limit"):
if current_price == buy_price:
return True, True
else:
if current_price == sell_price:
return True, False
except:
print("ExecuteError")
return False, False
def batch_cancel_orders(symbol, order_id_list):
trade_client = TradeClient(api_key=g_api_key, secret_key=g_secret_key)
print("cancel order list:", order_id_list)
if len(order_id_list):
result = trade_client.cancel_orders(symbol, order_id_list)
result.print_object()
def run(self):
#trade_client = TradeClient(api_key=g_api_key, secret_key=g_secret_key, init_log=True)
trade_client = TradeClient(api_key=g_api_key,
secret_key=g_secret_key,
init_log=False)
trade_client.sub_order_update(symbol, handle_order_update)
from huobi.exception.huobi_api_exception import HuobiApiException
from my.lesscfg import LESS_SYMBOL, LESS_INTERVAL, LESS_BASE, LESS_MAX_COUNT, LESS_LEAST_PROFIT, LESS_ADD_DIFF, \
LESS_PEAK_DIFF
from my.lessdb import Lessdb, BTC_OPS_TABLE, Operation
from my.organized import Organized
from my.upath import UPath
from huobi.client.market import MarketClient
from huobi.client.account import AccountClient
from huobi.client.trade import TradeClient
from huobi.constant import *
from my.utils import Utils
account_client = AccountClient(api_key=g_api_key, secret_key=g_secret_key)
market_client = MarketClient(init_log=True)
trade_client = TradeClient(api_key=g_api_key, secret_key=g_secret_key)
class LessTradeDirection(IntEnum):
LONG = 0,
SHORT = 1,
INVALID = 2,
symbol = LESS_SYMBOL
interval = LESS_INTERVAL
LOG_THROTTLE_COUNT = 1
LESSDB_FILE = "less_{0}.db".format(symbol)
class Lessismore:
def test_trade_create_cancel_orders(self):
trade_client = TradeClient(api_key=g_api_key,
secret_key=g_secret_key,
performance_test=True)
client_order_id_header = "test_" + str(round(time.time())) + "_id"
client_order_id_eos_01 = client_order_id_header + "01"
client_order_id_eos_02 = client_order_id_header + "02"
client_order_id_eos_03 = client_order_id_header + "03"
buy_limit_eos_01 = {
"account_id": g_account_id,
"symbol": trade_symbol,
"order_type": OrderType.BUY_LIMIT,
"source": OrderSource.API,
"amount": 50,
"price": 0.12,
"client_order_id": client_order_id_eos_01
}
buy_limit_eos_02 = {
"account_id": g_account_id,
"symbol": trade_symbol,
"order_type": OrderType.BUY_LIMIT,
"source": OrderSource.API,
"amount": 7,
"price": 0.80,
"client_order_id": client_order_id_eos_02
}
buy_limit_eos_03 = {
"account_id": g_account_id,
"symbol": trade_symbol,
"order_type": OrderType.BUY_LIMIT,
"source": OrderSource.API,
"amount": 20,
"price": 0.252,
"client_order_id": client_order_id_eos_03
}
order_config_list = [
buy_limit_eos_01, buy_limit_eos_02, buy_limit_eos_03
]
# case batch_create_order
tc = TimeCost(function_name=trade_client.batch_create_order.__name__)
create_result, tc.server_req_cost, tc.server_api_cost = trade_client.batch_create_order(
order_config_list=order_config_list)
tc.run_status = RunStatus.SUCCESS if create_result else RunStatus.FAILED
tc.add_record()
# time.sleep(1) # need wait
order_id_list = []
if create_result and len(create_result):
for item in create_result:
order_id_list.append(item.order_id)
# case batch_create_order
tc = TimeCost(
function_name=trade_client.batch_create_order.__name__)
result, tc.server_req_cost, tc.server_api_cost = trade_client.cancel_orders(
symbol=trade_symbol, order_id_list=order_id_list)
tc.run_status = RunStatus.SUCCESS if result else RunStatus.FAILED
tc.add_record()
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()
def run(self):
#trade_client = TradeClient(api_key=g_api_key, secret_key=g_secret_key, init_log=True)
trade_client = TradeClient(api_key=g_api_key, secret_key=g_secret_key, init_log=False)
trade_client.sub_order_update("eth3lusdt,dogeusdt,ethusdt", handle_order_update)
from huobi.client.trade import TradeClient
from huobi.constant import *
def callback(obj_event: 'TradeClearingEvent'):
obj_event.print_object()
trade_client = TradeClient(api_key=g_api_key,
secret_key=g_secret_key,
init_log=True)
trade_client.sub_trade_clearing("eosusdt", callback)
from huobi.client.trade import TradeClient
from huobi.constant import *
from huobi.utils import *
from keys.py import *
symbol_test = "ftiusdt"
trade_client = TradeClient(g_api_key, g_secret_key)
order_id = trade_client.create_order(symbol=symbol_test, account_id=g_account_id, order_type=OrderType.SELL_LIMIT, source=OrderSource.API, amount=1.0, price=50000)
LogInfo.output("created order id : {id}".format(id=order_id))
orderObj = trade_client.get_order(order_id=order_id)
LogInfo.output("======= get order by order id : {order_id} =======".format(order_id=order_id))
orderObj.print_object()
#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))
from huobi.client.trade import TradeClient
from huobi.constant import *
from huobi.utils import *
order_id = 113717254174681
trade_client = TradeClient(api_key='ghxertfvbf-300cc64c-05cc3126-79874',
secret_key='30ca5dcd-48f1cceb-d770f579-92cec')
orderObj = trade_client.get_order(order_id=113717254174681)
LogInfo.output("======= get order by order id : {order_id} =======".format(
order_id=113717254174681))
orderObj.print_object()