def make_order(self, my_order_info):
logger.info(
'-----------------------------------------make order----------------------------------------------'
)
result = {}
try:
result = self.TradeApi.place_order(my_order_info.symbol, "cross",
my_order_info.orderType, "fok",
my_order_info.amount,
my_order_info.offset,
my_order_info.price)
except Exception as e:
logger.error("***trade:%s" % e)
if result is not None and result.get('code') == "0" and result.get(
'data'):
logger.info("Order {} {} {} {} {} {}".format(
result['data'][0]['ordId'], my_order_info.symbol,
my_order_info.orderType, my_order_info.price,
my_order_info.amount, from_time_stamp()))
return result['data'][0]['ordId']
else:
logger.error("order failed！{} {} {} {} {}".format(
my_order_info.symbol, my_order_info.orderType,
my_order_info.price, my_order_info.amount,
round(my_order_info.price * my_order_info.amount, 3)))
return -1
def make_order(self, my_order_info):
logger.info(
u'\n-------------------------------------------spot order------------------------------------------------'
)
try:
result = self.API.send_order(self.ACCOUNT_ID, my_order_info.amount,
my_order_info.symbol,
my_order_info.orderType,
my_order_info.price,
my_order_info.offset)
except Exception as e:
logger.error("***send_order:{}".format(e, traceback.format_exc()))
send_msg("%s:send_order failed:%s" % (my_order_info.symbol, e))
exit()
result = self.check_order_list(my_order_info)
if result is not None and result.get('status') == 'ok':
logger_join("OrderId", result['data'], my_order_info.symbol,
my_order_info.orderType, my_order_info.price,
my_order_info.amount, " ", from_time_stamp())
return result['data']
else:
logger_join("order failed！", my_order_info.symbol,
my_order_info.orderType, my_order_info.price,
my_order_info.amount)
return "-1"
def get_account_info(self):
logger.info(
u'---------------------------------------spot account info------------------------------------------------'
)
try:
accounts = self.API.get_accounts()
if accounts.get('status') == 'ok':
spot_account = list(
filter(lambda x: x["type"] == 'spot',
accounts.get("data")))
self.ACCOUNT_ID = spot_account[0].get('id')
my_account_info = self.API.get_balance(self.ACCOUNT_ID)
symbols = [self.BALANCE_E, self.BALANCE_T]
if my_account_info.get('status') == 'ok':
data = from_dict(my_account_info, "data", "list")
for symbol in symbols:
symbol_infos = list(
filter(lambda x: x["currency"] == symbol, data))
symbol_info = self.accountInfo[symbol]
symbol_info["available"] = float(
symbol_infos[0]["balance"])
symbol_info["freezed"] = float(
symbol_infos[1]["balance"])
symbol_info["total"] = symbol_info[
"available"] + symbol_info["freezed"]
logger_join(symbol.upper(), symbol_info["total"],
"available", symbol_info["available"],
"freezed", symbol_info["freezed"])
else:
self.get_account_info()
else:
self.get_account_info()
except Exception as err:
logger.error(err)
self.get_account_info()
def __init__(self):
self.last = ""
self.volume = 0
config.read("config.ini")
try:
self.last = config.get("security", "last")
self.volume = int(config.get("security", "count"))
except Exception as e:
if str(e).find("No section") > -1:
config.add_section("security")
self.reset()
finally:
logger.info(f"CURRENT CONTRACT TRADE COUNT:{self.volume}")
def get_latest_order(symbol):
latest_order = None
try:
with open(r'log.txt') as f:
line = f.readline()
while line and line.find("canceled") == -1:
order = MyOrderInfo()
order.from_log(line)
if order.symbol == symbol:
latest_order = order
break
line = f.readline()
except FileNotFoundError:
logger.info("LogNotFound!")
return latest_order
def wrapper(*args, **kw):
environ = args[0]
logger.info("require_auth")
cookies = environ.get('HTTP_COOKIE')
if cookies is None:
return auth_fail(*args)
index1 = cookies.find("code=") + 5
index2 = cookies.find(";")
if index2 < index1:
index2 = len(cookies)
auth_code_in = cookies[index1:index2].strip()
with open(r'auth', 'r') as f:
auth_code = f.read().strip()
if auth_code != auth_code_in:
return auth_fail(*args)
return func(*args, **kw)
def get_account_info(self):
logger.info(
'-----------------------------------spot account info--------------------------------------------'
)
try:
accounts = [self.BALANCE_E.upper(), self.BALANCE_T.upper()]
for symbol in accounts:
t_account = self.spotAPI.get_coin_account_info(symbol)
if t_account.get('currency') == symbol:
logger.info("%s:balance %s available %s frozen %s" %
(symbol, t_account["balance"],
t_account["available"], t_account["frozen"]))
else:
logger.warning("getAccountInfo Fail,Try again!")
self.get_account_info()
except Exception as err:
logger.error(err)
self.get_account_info()
def ws_connect(self):
if self.ws is None or not self.ws.connected:
try:
self.ws = create_connection("wss://real.okex.com:8443/ws/v3",
timeout=5)
logger.info('websocket connected!')
pair = self.SYMBOL_T.upper().replace("_", "-")
sub_param = {
"op": "subscribe",
"args": ["spot/depth5:{}".format(pair)]
}
sub_str = json.dumps(sub_param)
self.ws.send(sub_str)
result = self.inflate(self.ws.recv())
logger.info("{} subscribe:{}".format(pair, result))
except Exception as e:
logger.error('\nconnect ws error[{}],retry...'.format(e))
time.sleep(2)
self.ws_connect()
def cancel_my_order(self, my_order_info):
logger.info(
u'\n---------------------------------------spot cancel order--------------------------------------------')
result = {}
try:
result = self.API.cancel_order(my_order_info.orderId)
except Exception as e:
logger.info("***cancel_order:%s" % e)
if result is None or result.get('status') != 'ok':
logger_join(u"order", my_order_info.orderId, "not canceled or cancel failed！！！")
state = self.check_order_status(my_order_info)
if state == 'canceled' or state == 'partial-canceled':
write_log("order " + my_order_info.orderId + " canceled")
if "_type" in result and result["_type"] == "contract":
from api.HuobiContractAPI import security
security.close(my_order_info.amount)
elif state != self.FILLED_STATUS:
# not canceled or cancel failed(part dealed) and not complete continue cancelling
return self.cancel_my_order(my_order_info)
return state
def send_email(content, _subtype='plain', _subject="bitcoinrobot"):
# 第三方 SMTP 服务
mail_host = "smtp.gmail.com" # 设置服务器
mail_user = "******" # 用户名
mail_pass = "******" # 口令
message = MIMEText(content, _subtype, 'utf-8')
message['From'] = Header(mail_user)
message['To'] = Header(",".join(receivers))
message['Subject'] = Header(_subject)
try:
server = smtplib.SMTP_SSL(mail_host, 465)
server.ehlo()
server.login(mail_user, mail_pass)
server.sendmail(mail_user, receivers, message.as_string())
server.close()
logger.info("邮件发送成功")
return True
except smtplib.SMTPException as err:
logger.error("Error: 邮件发送失败,{}".format(err))
return False
def analyze_log():
yy_mm_dd = str(from_time_stamp())[0:10]
order_list = []
try:
with open(r'log.txt') as f:
line = f.readline()
while line and (line.find(yy_mm_dd) != -1
or line.find("canceled") != -1):
search_canceled = re.search("order ([0-9]+) canceled", line)
if search_canceled:
order_id_canceled = search_canceled.group(1)
for order in order_list:
if order.orderId == order_id_canceled:
order.canceled = 1
else:
order = MyOrderInfo()
order.from_log(line)
order_list.append(order)
line = f.readline()
order_list = order_list[::-1]
except FileNotFoundError:
logger.info("LogNotFound!")
return order_list
def make_order(self, my_order_info):
logger.info(
'-----------------------------------------spot order----------------------------------------------'
)
result = {}
try:
result = self.spotAPI.take_order(my_order_info.orderType,
my_order_info.symbol, 2,
my_order_info.price,
my_order_info.amount)
except Exception as e:
logger.error("***trade:%s" % e)
if result is not None and result.get('result'):
logger.info("Order {} {} {} {} {} {}".format(
result['order_id'], my_order_info.symbol,
my_order_info.orderType, my_order_info.price,
my_order_info.amount, from_time_stamp()))
return result['order_id']
else:
logger.error("order failed！{} {} {} {} {}".format(
my_order_info.symbol, my_order_info.orderType,
my_order_info.price, my_order_info.amount,
round(my_order_info.price * my_order_info.amount, 3)))
return -1
def check_order_status(self, my_order_info, wait_count=0):
order_id = my_order_info.orderId
order_result = {}
try:
order_result = self.API.order_info(order_id)
except Exception as e:
logger.info("***order_info:%s" % e)
if order_result is not None and order_result.get('status') == 'ok':
order = order_result["data"]
order_id = order["id"]
state = order["state"]
my_order_info.set_deal_amount(float(order["field-amount"]))
if my_order_info.dealAmount > 0:
if self.IS_SPOT:
my_order_info.set_avg_price(
float(order["field-cash-amount"]) /
float(order["field-amount"]))
else:
my_order_info.set_avg_price(float(order["price"]))
if state == 'canceled':
logger_join("order", order_id, "canceled")
elif state == 'partial-canceled':
logger_join("part dealed ", my_order_info.dealAmount,
" and canceled")
if my_order_info.dealAmount == 0.0:
logger.info("data error!check order status again!")
return self.check_order_status(my_order_info, wait_count)
elif state == 'partial-filled':
if wait_count == self.TRADE_WAIT_COUNT:
logger_join("part dealed ", my_order_info.dealAmount)
else:
logger_join("part dealed ", my_order_info.dealAmount)
sys.stdout.flush()
elif state == 'filled':
logger_join("order", order_id, "complete deal")
else:
if wait_count == self.TRADE_WAIT_COUNT:
logger.info("timeout no deal")
else:
logger.info("no deal")
sys.stdout.flush()
return state
else:
logger_join(order_id, "checkOrderStatus failed,try again.")
return self.check_order_status(my_order_info, wait_count)
def get_coin_price(self, symbol):
self.ws_connect()
self.socketData = None
gevent.spawn(self.socket_recv, self).join(15)
if not self.socketData:
self.ping = True
self.pong = False
t = 0
while not self.pong and t < 3:
try:
self.ws.send("ping")
logger.info("[{}]ping.........".format(symbol))
gevent.spawn(self.socket_recv, self).join(3)
except Exception as e:
logger.info("[{}]ping exception，{}".format(symbol, e))
if self.socketData:
self.pong = True
logger.info("[{}]pong!!!!!!!!!".format(symbol))
t += 1
if self.ping:
self.ping = False
if not self.pong:
logger.warning("[{}]no pong in 5s,reconnect!".format(symbol))
self.ws.close()
self.get_coin_price(symbol)
return
res = None
try:
res = json.loads(self.socketData)
except Exception as e:
logger.error("{} : {}".format(self.socketData, e))
if res and res.get("data") is not None:
data = res.get("data")[0]
price_info = self.priceInfo[symbol]
price_info["asks"] = list(
map(lambda x: list(map(lambda d: float(d), x)), data["asks"]))
price_info["bids"] = list(
map(lambda x: list(map(lambda d: float(d), x)), data["bids"]))
def get_account_info(self):
logger.info(
'-----------------------------------account info--------------------------------------------'
)
def send_order(acct_id, amount, symbol, _type, price=0, offset="close"):
"""
:param acct_id:
:param amount:
:param symbol:
:param _type: 可选值 {buy-market：市价买, sell-market：市价卖, buy-limit：限价买, sell-limit：限价卖}
:param price:
:param offset:
:return:
"""
# 合约下单
order_price_type = "limit"
direction = _type.split("-")[0]
contract_code = contract_info.get_contract_code(symbol)
contract_symbol = symbol.split("_")[0].upper()
contract_type = global_type
# sell_offset = "open" if price > 4 else "close"
# buy_offset = "close" if price > 4 else "open"
# offset = sell_offset if direction == "sell" else buy_offset
lever_rate = TRADE_LEVEL
def send_contract_order(symbol, contract_type, contract_code,
client_order_id, price, volume, direction, offset,
lever_rate, order_price_type):
"""
:symbol: "BTC","ETH"..
:contract_type: "this_week", "next_week", "next_quarter"
:contract_code: "BTC181228"
:client_order_id: 客户自己填写和维护，这次一定要大于上一次
:price 必填 价格
:volume 必填 委托数量（张）
:direction 必填 "buy" "sell"
:offset 必填 "open", "close"
:lever_rate 必填 杠杆倍数
:order_price_type 必填 "limit"限价， "opponent" 对手价
备注：如果contract_code填了值，那就按照contract_code去下单，如果contract_code没有填值，则按照symbol+contract_type去下单。
:
"""
params = {
"price": price,
"volume": volume,
"direction": direction,
"offset": offset,
"lever_rate": lever_rate,
"order_price_type": order_price_type
}
if symbol:
params["symbol"] = symbol
if contract_type:
params['contract_type'] = contract_type
if contract_code:
params['contract_code'] = contract_code
if client_order_id:
params['client_order_id'] = client_order_id
request_path = '/api/v1/contract_order'
return api_key_post(params, request_path, CONTRACT_URL)
# amount = math.ceil(amount * price / 10)
amount = math.ceil(amount)
if math.ceil(security.get_volume()) <= TRADE_LIMIT:
result = send_contract_order(contract_symbol, contract_type,
contract_code, "", price, amount,
direction, offset, lever_rate,
order_price_type)
logger.info(result)
order_symbol[str(result["data"]["order_id"])] = contract_symbol
if "ok" == result["status"]:
if direction == "buy":
security.open(amount)
else:
security.close(amount)
# order_ts[result["data"]["order_id"]] = result["ts"]
return {
"data": str(result["data"]["order_id"]),
"status": result["status"]
}
else:
from module.Notification import send_msg
send_msg("amount:{} volume:{} limit:{}".format(amount,
security.get_volume(),
TRADE_LIMIT))
exit()
return {"data": [], "status": "ok"}
def check_order_status(self, my_order_info, wait_count=0):
order_id = my_order_info.orderId
order_result = {}
try:
logger.info("check order status {}".format(wait_count))
order_result = self.spotAPI.get_order_info(my_order_info.orderId,
my_order_info.symbol)
except Exception as e:
logger.error("***orderinfo:%s" % e)
if order_result is not None and order_result.get(
'order_id') == my_order_info.orderId:
order = order_result
order_id = order["order_id"]
status = order["status"]
filled_size = float(order["filled_size"])
if filled_size > 0:
my_order_info.set_deal_amount(filled_size)
my_order_info.set_avg_price(
float(order["filled_notional"]) / filled_size)
if status == self.CANCELLED_STATUS:
logger.info("order {} canceled".format(order_id))
elif status == 'open':
if wait_count == self.TRADE_WAIT_COUNT:
logger.info("timeout no deal")
else:
logger.info("no deal")
elif status == 'part_filled':
if wait_count == self.TRADE_WAIT_COUNT:
logger.info("timeout part deal {}".format(
my_order_info.dealAmount))
else:
logger.info("part deal {}".format(
my_order_info.dealAmount))
elif status == self.FILLED_STATUS:
logger.info("order {} filled".format(order_id))
elif status == 'canceling':
logger.info("order {} canceling".format(order_id))
elif status == 'ordering':
logger.info("order {} ordering".format(order_id))
return status
else:
logger.warning(
"order {} checkOrderStatus failed,try again.".format(order_id))
return self.check_order_status(my_order_info, wait_count)
def send_msg(message, msg_type=MSG_TYPE_DEAL):
logger.info("send statistic message")
if notify_type == "telegram":
return send_telegram(message, msg_type == MSG_TYPE_REPORT)
else:
return send_email(message)
if __name__ == '__main__':
from module.Resty import PathDispatcher
from wsgiref.simple_server import make_server
# Create the dispatcher and register functions
dispatcher = PathDispatcher()
dispatcher.register('GET', '/', hello)
dispatcher.register('GET', '/auth', auth)
dispatcher.register('GET', '/pull', pull)
dispatcher.register('GET', '/cfg', cfg)
dispatcher.register('GET', '/edit', edit)
dispatcher.register('POST', '/save', save)
dispatcher.register('GET', '/modify', modify_val)
dispatcher.register('GET', '/restart', restart)
dispatcher.register('GET', '/shutdown', shutdown)
dispatcher.register('GET', '/log', log)
dispatcher.register('GET', '/log-run', running_log)
dispatcher.register('GET', '/log-eos', eos_log)
dispatcher.register('GET', '/control', control)
dispatcher.register('POST', '/accounts', accounts)
dispatcher.register('POST', '/transfer', transfer)
dispatcher.register('POST', '/get_currency', get_currency)
dispatcher.register('POST', '/withdraw', withdraw)
dispatcher.register('POST', '/order', order)
# Launch a basic server
httpd = make_server('', 7777, dispatcher)
logger.info('Serving on port 7777...')
httpd.serve_forever()
def check_order_status(self, my_order_info, wait_count=0):
order_id = my_order_info.orderId
order_result = {}
try:
logger.info("check order status {}".format(wait_count))
order_result = self.TradeApi.get_orders(my_order_info.symbol,
my_order_info.orderId)
except Exception as e:
logger.error("***orderinfo:%s" % e)
if order_result is not None and order_result.get(
'code') == "0" and order_result.get('data'):
order = order_result['data'][0]
order_id = order["ordId"]
status = order["state"]
filled_size = float(order["accFillSz"])
if filled_size > 0:
my_order_info.set_deal_amount(filled_size)
my_order_info.set_avg_price(float(order["avgPx"]))
if status == self.CANCELLED_STATUS:
logger.info("order {} canceled".format(order_id))
elif status == 'live':
if wait_count == self.TRADE_WAIT_COUNT:
logger.info("timeout no deal")
else:
logger.info("no deal")
elif status == 'partially_filled':
if wait_count == self.TRADE_WAIT_COUNT:
logger.info("timeout part deal {}".format(
my_order_info.dealAmount))
else:
logger.info("part deal {}".format(
my_order_info.dealAmount))
elif status == self.FILLED_STATUS:
logger.info("order {} filled".format(order_id))
return status
else:
logger.warning(
"order {} checkOrderStatus failed,try again.".format(order_id))
return self.check_order_status(my_order_info, wait_count)
# Create the dispatcher and register functions
dispatcher = PathDispatcher()
dispatcher.register('GET', '/', hello)
dispatcher.register('GET', '/auth', auth)
dispatcher.register('GET', '/pull', pull)
dispatcher.register('GET', '/cfg', cfg)
dispatcher.register('GET', '/cfg2', cfg2)
dispatcher.register('GET', '/edit', edit)
dispatcher.register('POST', '/save', save)
dispatcher.register('GET', '/modify', modify_val)
dispatcher.register('GET', '/restart', restart)
dispatcher.register('GET', '/shutdown', shutdown)
dispatcher.register('GET', '/log', log)
dispatcher.register('GET', '/log-run', running_log)
dispatcher.register('GET', '/restart-eosminer', eos_restart)
dispatcher.register('GET', '/log-eos', eos_log)
dispatcher.register('GET', '/control', control)
dispatcher.register('POST', '/accounts', accounts)
dispatcher.register('POST', '/transfer', transfer)
dispatcher.register('POST', '/get_currency', get_currency)
dispatcher.register('POST', '/withdraw', withdraw)
dispatcher.register('POST', '/order', order)
dispatcher.register('GET', '/miner', miner)
dispatcher.register('GET', '/miner-run', miner_log)
# Launch a basic server
httpd = make_server('', 8888, dispatcher)
logger.info('Serving on port 8888...')
httpd.serve_forever()
