def sendosereum(request):
allify = {}
data = {}
if request.method == 'POST':
senderprivatekey = request.POST.get('sprikey')
receiverwallet = request.POST.get('receiverwallet').strip()
amount = request.POST.get('amount').strip()
sender = generate_pubkey_from_prikey(senderprivatekey)
if not receiverwallet:
allify['response'] = "fail"
allify['explain'] = "Please fill the receiver box"
return HttpResponse(json.dumps(allify),
content_type="application/json")
try:
amount = int(request.POST.get('amount').strip())
except ValueError:
allify['response'] = "fail"
allify['explain'] = "Please fill the balance box"
return HttpResponse(json.dumps(allify),
content_type="application/json")
if int(amount) <= 0:
allify['response'] = "fail"
allify['explain'] = "insufficient balance"
return HttpResponse(json.dumps(allify),
content_type="application/json")
balance = getbalance(sender)
if balance is None:
balance = 0
if int(amount) > int(balance):
allify['response'] = "fail"
allify['explain'] = "insufficient balance"
return HttpResponse(json.dumps(allify),
content_type="application/json")
else:
utc = arrow.utcnow()
local = utc.to('GMT')
first_timestamp = local.timestamp
data['sender'] = str(sender) #1
data['receiver'] = str(receiverwallet) #2
data['previous_hash'] = str(
transaction.objects.all().last().blockhash) #3
data['amount'] = str(amount) #4
data['timestamp'] = str(first_timestamp) #5
perfect = miner(first_timestamp, sender, receiverwallet, amount)
data["nonce"] = str(perfect)
data = collections.OrderedDict(sorted(data.items()))
datashash = hashlib.sha256(
json.dumps(data).encode('utf-8')).hexdigest()
try:
sk = SigningKey.from_string(bytes.fromhex(senderprivatekey),
curve=SECP256k1)
vk = sk.get_verifying_key() #public_key
print(vk.to_string().hex())
except UnicodeDecodeError:
data["response"] = "Check your wallet details"
return HttpResponse(json.dumps(data),
content_type="application/json")
print("digital sign ishere", datashash.encode('utf-8'))
digitalSignature = sk.sign(datashash.encode('utf-8'))
digitalSignature = json.dumps(digitalSignature.hex())
wllt = generate_wallet_from_pkey(sender)
newtrans = transaction(
sender=sender,
senderwallet=wllt,
receiver=receiverwallet,
prevblockhash=transaction.objects.all().last().blockhash,
blockhash=datashash,
amount=amount,
nonce=perfect,
first_timestamp=first_timestamp,
P2PKH=digitalSignature,
verification=True)
newtrans.save()
ip = ni.ifaddresses('eth0')[ni.AF_INET][0]['addr']
geturl = "http://{}/api/vi/gettransaction/{}/".format(
ip, newtrans.id)
test = {
"server": False,
"sender": sender,
"receiver": receiverwallet,
"prevblockhash": transaction.objects.all().last().blockhash,
"blockhash": datashash,
"amount": amount,
"nonce": perfect,
"timestamp": first_timestamp,
"P2PKH": digitalSignature,
"verification": True,
"block": transaction.objects.all().last().id + 1,
"message": "new_transaction",
"url": geturl
}
payload = json.dumps(test)
ws = websocket.WebSocket()
wsip = "ws://{}:9000".format(ip)
ws.connect(wsip)
ws.send(payload)
allify['response'] = "ok"
allify['datashash'] = datashash
allify['datastring'] = json.dumps(allify)
return HttpResponse(json.dumps(allify),
content_type="application/json")
import time
import serial
from serial.tools import list_ports
import websocket
def on_open(ws):
print("Websocket connected")
def on_error(ws, error):
print("Websocket error:", error)
def on_close(ws):
print("Websocket closed")
def on_message(ws, msg):
print("Sending \"" + msg + "\" to arduino")
# Connect to websocket
ws = websocket.WebSocket()
ws.on_open = on_open
ws = websocket.WebSocketApp("ws://robot.halspals.co.uk/connect",
on_message = on_message,
on_error = on_error,
on_close = on_close)
ws.run_forever()
def listflow():
ws = websocket.WebSocket()
ws.connect("ws://127.0.0.1:8000/security/")
ws.send("refreshList")
ws.close()
class TestVoice():
ws = websocket.WebSocket()
# def teardown_class(self):
# self.ws.close()
@pytest.mark.parametrize("scenario, account, method, roomId, admin, adminList, expected", getTestData('admin'))
def testAdminOperate(self, createInit, scenario, account, method, roomId, admin, adminList, expected):
adList = []
for i in adminList:
adList.append(test_parameter[i]['id'])
header['X-Auth-Token'] = test_parameter[account]['token']
header['X-Auth-Nonce'] = test_parameter[account]['nonce']
if method == 'post':
apiName = '/api/v2/liveMaster/voiceChat/admin'
body = {
'roomId': roomId,
'userId': test_parameter[admin]['id']
}
elif method == 'delete':
apiName = '/api/v2/liveMaster/voiceChat/admin/' + str(roomId) + '/' + test_parameter[admin]['id']
body = None
res = api.apiFunction(test_parameter['prefix'], header, apiName, method, body)
resText = json.loads(res.text)
if expected == 200:
voicelib.wsConnect(self.ws, test_parameter['db'], test_parameter['track0010']['token'], test_parameter['track0010']['nonce'])
wsResult = voicelib.voiceOperator(self.ws, '1', 'vc_room:'+str(roomId), 'phx_join', {'password': '******'})
assert res.status_code == expected
assert resText['Status'] == Msg[expected]['Status']
assert resText['Message'] in Msg[expected]['Message']
assert len(adList) == len(wsResult['payload']['data']['admins'])
for i in adList:
assert i in wsResult['payload']['data']['admins'], i + '不在回傳的資料中' + str(wsResult['payload']['data']['admins'])
voicelib.voiceOperator(self.ws, '1', 'vc_room:'+str(roomId), 'phx_leave', {})
self.ws.close()
@pytest.mark.parametrize("scenario, account, roomId, key, value, payload, expected", getTestData('edit'))
def testEditVoiceRoomInfo(self, editInit, scenario, account, roomId, key, value, payload, expected):
body = {
"title": "直播間標題",
"description": "直播間簡介",
"password": ""
}
if value == None:
del body['password']
else:
body[key] = value
header['X-Auth-Token'] = test_parameter[account]['token']
header['X-Auth-Nonce'] = test_parameter[account]['nonce']
apiName = '/api/v2/liveMaster/voiceChat/' + str(roomId)
res = api.apiFunction(test_parameter['prefix'], header, apiName, 'patch', body)
resText = json.loads(res.text)
assert res.status_code == expected
assert resText['Status'] == Msg[expected]['Status']
assert resText['Message'] in Msg[expected]['Message']
if expected == 200:
time.sleep(3)
apiName = '/api/v2/identity/voiceChat/list'
res = api.apiFunction(test_parameter['prefix'], header, apiName, 'get', None)
resText = json.loads(res.text)
for i in resText['data']:
if i['id'] == roomId:
if key == 'password':
if value:
assert i['needPassword'] == True
else:
assert i['needPassword'] == False
else:
assert i[key] == value
break
voicelib.wsConnect(self.ws, test_parameter['db'], test_parameter['track0010']['token'], test_parameter['track0010']['nonce'])
wsResult = voicelib.voiceOperator(self.ws, '1', 'vc_room:'+str(roomId), 'phx_join', payload)
if key == 'password':
assert wsResult['event'] == 'voiceroom_in_bcst'
assert len(wsResult['payload']['data']['ownerUserId']) > 0
else:
assert wsResult['payload']['data'][key] == value
voicelib.voiceOperator(self.ws, '1', 'vc_room:'+str(roomId), 'phx_leave', payload)
self.ws.close()
def main(ssl_uri, to_url, login_info, pair, price_type):
try:
print('connect to {}'.format(ssl_uri))
ws = websocket.WebSocket(sslopt={"cert_reqs": ssl.CERT_NONE})
ws.connect(ssl_uri)
print(ws.recv())
req = {}
req["event"] = "subscribe"
req["channel"] = "ticker"
req["pair"] = pair
ws.send(json.dumps(req))
print(req)
print(ws.recv())
print('\n\trecv:\n\n')
global TMP
while True:
recv_list = eval(ws.recv())
if recv_list[1] != 'hb':
print("\nreceived from {}:\n{}".format(ssl_uri, recv_list))
# {"code":"код пары", "quote": актуальная цена}
payload = {}
payload["code"] = pair
if price_type == "BID":
payload["quote"] = recv_list[1]
elif price_type == "ASK":
payload["quote"] = recv_list[4]
elif price_type == "LAST_PRICE":
payload["quote"] = recv_list[7]
else:
print(
"[!] Error: unknown price_type: {}".format(price_type))
sys.exit(1)
if payload["quote"] != TMP:
print("\npost request to {}:\n{}\nprice_type: {}\n".format(
to_url, payload, price_type))
r = requests.post(to_url,
headers=HEADERS,
json=payload,
auth=login_info)
print("\nresponse from {}:".format(to_url))
print(r.status_code)
print(r.headers)
print(r.text)
else:
print("{} = {}".format(payload["quote"], TMP))
TMP = payload["quote"]
print("\n\n###")
except KeyboardInterrupt:
print("\nexit\n")
except Exception as err:
print('\nsome error:\n{}\n'.format(err))
def __init__(self):
# self.host = host
self.ws = websocket.WebSocket(sslopt={"cert_reqs": ssl.CERT_NONE},
sockopt=socket.setdefaulttimeout(20))
def _get_ws(self):
self._ws = websocket.WebSocket(sslopt={'cert_reqs': ssl.CERT_NONE})
self._ws.connect("wss://{0}:{1}/".format(*self.server_address))
return self._ws
def testRecvContFragmentation(self):
sock = ws.WebSocket()
s = sock.sock = SockMock()
# OPCODE=CONT, FIN=1, MSG="the soul of wit"
s.add_packet(six.b("\x80\x8fabcd\x15\n\x06D\x12\r\x16\x08A\r\x05D\x16\x0b\x17"))
self.assertRaises(ws.WebSocketException, sock.recv)
def _recv_thread_func(self):
reconnect_time = 1
while not self._terminating: #loop 0 (connect, reconnect)
try:
self.socket = websocket.WebSocket()
self.socket.connect(self.ws_url)
self._time_last_received = time.time()
self.connected = True
# send Login Message
loginMsg = {
'UserReqID': 'initial',
'MsgType': 'BE',
'Username': self.username,
'Password': self.password,
'UserReqTyp': '1'
}
self.send(dumps(loginMsg))
time.sleep(4)
while not self._terminating:
str_json = self.socket.recv()
self._time_last_received = time.time()
if not str_json:
continue
if str_json[0] != "{":
continue
msg = loads(str_json)
if msg['MsgType'] == 'BF':
self.signal_recv(self, msg)
if msg['UserStatus'] == 1:
self.logged = True
# send Market Data Subscribe
subscribe_msg = {
'MsgType': 'V',
'MDReqID': 'md_full_refresh',
'SubscriptionRequestType': '1',
'MarketDepth': 0,
'MDUpdateType': '1', #
'MDEntryTypes': ['0', '1',
'2'], # bid , offer, trade
'Instruments': self.symbols
}
self.send(dumps(subscribe_msg))
else:
self.logged = False
elif msg[
'MsgType'] == 'X': # Market Data Incremental Refresh
if msg['MDBkTyp'] == '3': # Order Depth
for entry in msg['MDIncGrp']:
if entry['MDEntryType'] == '0':
if entry['MDUpdateAction'] == '0':
self.signal_book_bid_new_order(
self, entry)
elif entry['MDUpdateAction'] == '1':
self.signal_book_bid_update_order(
self, entry)
elif entry['MDUpdateAction'] == '2':
self.signal_book_bid_delete_order(
self, entry)
elif entry['MDUpdateAction'] == '3':
self.signal_book_bid_delete_thru(
self, entry)
elif entry['MDEntryType'] == '1':
if entry['MDUpdateAction'] == '0':
self.signal_book_offer_new_order(
self, entry)
elif entry['MDUpdateAction'] == '1':
self.signal_book_offer_update_order(
self, entry)
elif entry['MDUpdateAction'] == '2':
self.signal_book_offer_delete_order(
self, entry)
elif entry['MDUpdateAction'] == '3':
self.signal_book_offer_delete_thru(
self, entry)
elif entry['MDEntryType'] == '2':
self.signal_trade(self, entry)
self.signal_recv(self, msg)
elif msg['MsgType'] == 'W': # Market Data Refresh
if msg['MarketDepth'] != 1: # Has Market Depth
self.signal_book_bid_clear(self, "")
self.signal_book_offer_clear(self, "")
self.signal_trade_clear(self, "")
for entry in msg['MDFullGrp']:
if entry['MDEntryType'] == '0':
self.signal_book_bid_new_order(self, entry)
elif entry['MDEntryType'] == '1':
self.signal_book_offer_new_order(
self, entry)
elif entry['MDEntryType'] == '2':
self.signal_trade(self, entry)
self.signal_recv(self, msg)
except Exception as exc:
self.connected = False
if not self._terminating:
if self.socket:
self.socket.close()
time.sleep(reconnect_time)
def _connect(self):
ws = websocket.WebSocket()
ws.connect(self.endpoint)
return ws
def __init__(self, ip, port):
self.port = port
self.ip = ip
self.ws = websocket.WebSocket()
def initEezy():
ws = websocket.WebSocket()
ws.connect("ws://" + eezyHost + ":" + eezyPort)
ws.send("init")
return (ws)
def connectBorder(client):
client.ws = websocket.WebSocket()
client.ws.connect(client.border + "/client")
#!/usr/bin/env python
import rospy
from std_msgs.msg import String
import websocket
s = websocket.WebSocket() #create socket
#bind socket to port & made it listen to commands
def callback(data):
rospy.loginfo(rospy.get_caller_id() + "I heard %s", data.data)
while True:
s.connect("ws://192.168.0.105/")
print("sending")
s.send(data.data)
s.close()
def listener():
rospy.init_node('listener', anonymous=True)
rospy.Subscriber("chatter", String, callback)
#s.connect("ws://192.168.0.105/")
rospy.spin()
if __name__ == '__main__':
listener()
async def connect():
ws = websocket.WebSocket()
ws.connect("ws://localhost:8000/ws")
def connect():
ws = websocket.WebSocket()
ws_address = "wss://real.okex.com"
ws_port = 10441
ws.connect(ws_address, http_proxy_host="websocket", http_proxy_port=ws_port)
def __init__(self):
ws = websocket.WebSocket()
ws.connect(url)
print 'ws 连接成功(Listening)'
def init_connection(self):
""" Open a websocket and connect to cortex. """
self.websocket = websocket.WebSocket(
sslopt={"cert_reqs": ssl.CERT_NONE})
self.websocket.connect(self.CORTEX_URL, timeout=60)
def _get_ws(self):
self._ws = websocket.WebSocket()
self._ws.connect("ws://{0}:{1}/".format(*self.server_address))
return self._ws
def _init_websocket(self, websocket_uri):
self.websocket = websocket.WebSocket()
self.websocket.connect(websocket_uri)
def test_ws_init(self):
ws = websocket.WebSocket()
ws.connect('ws://localhost:{0}/_client_ws_cont'.format(self.app_port))
ws.close()
def my_livecoin():
ws = websocket.WebSocket(sslopt={"cert_reqs": ssl.CERT_NONE
}) # python issue with comodo certs
ws.connect("wss://ws.api.livecoin.net/ws/beta2")
# ----------------------------------------------------------------------------------------------------------------------
# -------------------------------- Subscription handlers ---------------------------------------------------------------
# ----------------------------------------------------------------------------------------------------------------------
orderbooks = {}
orderbooksraw = {}
def onNewTickers(symbol, events):
for t in events:
print("ticker: %s/%s/%s" %
(symbol, datetime.datetime.fromtimestamp(
t.timestamp / 1000).strftime('%Y-%m-%d %H:%M:%S'),
str(events)))
def onNewCandles(symbol, interval, events):
for t in events:
print("candles: %s[%s]/%s/%s" %
(symbol, interval,
datetime.datetime.fromtimestamp(
t.timestamp / 1000).strftime('%Y-%m-%d %H:%M:%S'),
str(events)))
def onNewTrades(symbol, events):
for t in events:
print("trades: %s/%s/%s" %
(symbol, datetime.datetime.fromtimestamp(
t.timestamp / 1000).strftime('%Y-%m-%d %H:%M:%S'),
str(events)))
def orderTypeToStr(enumConstant):
return "bids" if enumConstant == LivecoinWSapi_pb2.OrderBookRawEvent.BID else "asks"
def printOrderBook(symbol):
book = orderbooks[symbol]
# print("MY BIDS :", book['bids'])
# print("MY ASKS :", book['asks'])
# for type in ["bids", "asks"]:
# str = type + "raw: "
# for b in sorted(book[type], reverse= (type=="bids")):
# str += ("%s->%s\n" % (b, book[type][b]))
# print (str)
if symbol == "PZM/USD":
print("MY ASKS :", book['asks'])
# a = book["asks"]
# b = book["bids"]
# for type in ["bids", "asks"]:
# str = type+"raw: "
# for b in sorted(book[type], key=lambda x: book[type][x][0], reverse=(type == "bids")):
# str += ("%d:%s->%s\n" % (b, book[type][b][0], book[type][b][1]))
#
# print(str)
# L_b2 = {}
# for b in sorted(book["bids"], key=lambda x: book["bids"][x][0], reverse=True):
# L_b2.update({book["bids"][b][0]: float(book["bids"][b][1])})
# print('######## \n',L_b2,'\n######')
L_b = {}
for b in sorted(book["bids"], reverse=True):
L_b.update({b: book["bids"][b][0]})
# L_b = {}
# for k,v in book["bids"].items():
# L_b.update({k: float(v[0])})
# L_a = {}
# for k,v in book["asks"].items():
# L_a.update({k: float(v[0])})
L_a = {}
for b in sorted(book["asks"], reverse=False):
L_a.update({b: book["asks"][b][0]})
Live_buy = {}
for k, v in L_b.items():
if not Live_buy:
if float(v) < 0.1:
pass
else:
Live_buy.update({k: float(v)})
else:
if float(v) < 0.1:
pass
else:
sump = float(v) + float(list(Live_buy.values())[-1])
Live_buy.update({k: float(sump)})
Live_sell = {}
for k, v in L_a.items():
if not Live_sell:
if float(v) < 0.1:
pass
else:
Live_sell.update({k: float(v)})
else:
if float(v) < 0.1:
pass
else:
sump = float(v) + float(list(Live_sell.values())[-1])
Live_sell.update({k: float(sump)})
Live_buy = list(Live_buy.items())[:5]
Live_sell = list(Live_sell.items())[:5]
# print('LB USD', Live_buy)
print('LA USD', Live_sell)
Live_PU = []
for i in Live_sell:
Live_PU.append(('live', 'USD', 'PZM', 'buy', i[0], i[1]))
for i in Live_buy:
Live_PU.append(('live', 'PZM', 'USD', 'sell', i[0], i[1]))
columns = [
'birga', 'valin', 'valout', 'direction', 'rates', 'volume'
]
df = pd.DataFrame(Live_PU, columns=columns)
try:
os.remove(main_path_data + "\\live_bd_PU.csv")
df.to_csv(main_path_data + "\\live_bd_PU.csv",
index=False,
mode="w")
except Exception as e:
print('##### OOOPsss .... DB ######')
os.remove(main_path_data + "\\live_bd_PU.csv")
df.to_csv(main_path_data + "\\live_bd_PU.csv",
index=False,
mode="w")
# import threading, queue
# to_write = queue.Queue()
#
# def writer():
# # Call to_write.get() until it returns None
# # for df in iter(to_write.get, None):
# with open(main_path_data + "\\live_bd_PU.csv", 'w') as f:
# df.to_csv(f, index=False)
#
# threading.Thread(target=writer).start()
# to_write.put(df)
# # enqueue None to instruct the writer thread to exit
# to_write.put(None)
elif symbol == "PZM/BTC":
L_b = {}
for k, v in book["bids"].items():
L_b.update({k: float(v[0])})
L_a = {}
for k, v in book["asks"].items():
L_a.update({k: float(v[0])})
Live_buy = {}
for k, v in L_b.items():
if not Live_buy:
if float(v) < 0.1:
pass
else:
Live_buy.update({k: float(v)})
else:
if float(v) < 0.1:
pass
else:
sump = float(v) + float(list(Live_buy.values())[-1])
Live_buy.update({k: float(sump)})
Live_sell = {}
for k, v in L_a.items():
if not Live_sell:
if float(v) < 0.1:
pass
else:
Live_sell.update({k: float(v)})
else:
if float(v) < 0.1:
pass
else:
sump = float(v) + float(list(Live_sell.values())[-1])
Live_sell.update({k: float(sump)})
Live_buy = list(Live_buy.items())[:5]
Live_sell = list(Live_sell.items())[:5]
# print('LB', Live_buy)
# print('LA', Live_sell)
Live_PU = []
for i in Live_sell:
Live_PU.append(('live', 'BTC', 'PZM', 'buy', i[0], i[1]))
for i in Live_buy:
Live_PU.append(('live', 'PZM', 'BTC', 'sell', i[0], i[1]))
columns = [
'birga', 'valin', 'valout', 'direction', 'rates', 'volume'
]
df = pd.DataFrame(Live_PU, columns=columns)
# print(df)
# df.to_csv(main_path_data + "\\live_bd_PB.csv", index=False)
try:
os.remove(main_path_data + "\\live_bd_PB.csv")
df.to_csv(main_path_data + "\\live_bd_PB.csv",
index=False,
mode="w")
except Exception as e:
print('##### OOOPsss .... DB BTC ######')
os.remove(main_path_data + "\\live_bd_PB.csv")
df.to_csv(main_path_data + "\\live_bd_PB.csv",
index=False,
mode="w")
else:
pass
def onNewOrders(symbol, orders, initial=False):
if (initial):
orderbooks[symbol] = {"asks": {}, "bids": {}}
for order in orders:
type = orderTypeToStr(order.order_type)
if order.quantity == 0:
if order.price in orderbooks[symbol][type]:
del orderbooks[symbol][type][order.price]
else:
orderbooks[symbol][type][order.price] = (order.quantity,
order.timestamp)
if (not initial):
printOrderBook(symbol)
def printOrderBookRaw(symbol):
book = orderbooksraw[symbol]
print("############## LIVE #################", symbol)
if symbol == "PZM/USD":
# a = book["asks"]
# b = book["bids"]
# for type in ["bids", "asks"]:
# str = type+"raw: "
# for b in sorted(book[type], key=lambda x: book[type][x][0], reverse=(type == "bids")):
# str += ("%d:%s->%s\n" % (b, book[type][b][0], book[type][b][1]))
#
# print(str)
L_b = {}
for b in sorted(book["bids"],
key=lambda x: book["bids"][x][0],
reverse=True):
L_b.update({book["bids"][b][0]: float(book["bids"][b][1])})
L_a = {}
for b in sorted(book["asks"],
key=lambda x: book["asks"][x][0],
reverse=False):
L_a.update({book["asks"][b][0]: float(book["asks"][b][1])})
Live_buy = {}
for k, v in L_b.items():
if not Live_buy:
if float(v) < 0.1:
pass
else:
Live_buy.update({k: float(v)})
else:
if float(v) < 0.1:
pass
else:
sump = float(v) + float(list(Live_buy.values())[-1])
Live_buy.update({k: float(sump)})
Live_sell = {}
for k, v in L_a.items():
if not Live_sell:
if float(v) < 0.1:
pass
else:
Live_sell.update({k: float(v)})
else:
if float(v) < 0.1:
pass
else:
sump = float(v) + float(list(Live_sell.values())[-1])
Live_sell.update({k: float(sump)})
Live_buy = list(Live_buy.items())[:5]
Live_sell = list(Live_sell.items())[:5]
print('LB USD', Live_buy)
print('LA USD', Live_sell)
Live_PU = []
for i in Live_sell:
Live_PU.append(('live', 'USD', 'PZM', 'buy', i[0], i[1]))
for i in Live_buy:
Live_PU.append(('live', 'PZM', 'USD', 'sell', i[0], i[1]))
columns = [
'birga', 'valin', 'valout', 'direction', 'rates', 'volume'
]
df = pd.DataFrame(Live_PU, columns=columns)
try:
os.remove(main_path_data + "\\live_bd_PU.csv")
df.to_csv(main_path_data + "\\live_bd_PU.csv",
index=False,
mode="w")
except Exception as e:
print('##### OOOPsss .... DB ######')
os.remove(main_path_data + "\\live_bd_PU.csv")
df.to_csv(main_path_data + "\\live_bd_PU.csv",
index=False,
mode="w")
# import threading, queue
# to_write = queue.Queue()
#
# def writer():
# # Call to_write.get() until it returns None
# # for df in iter(to_write.get, None):
# with open(main_path_data + "\\live_bd_PU.csv", 'w') as f:
# df.to_csv(f, index=False)
#
# threading.Thread(target=writer).start()
# to_write.put(df)
# # enqueue None to instruct the writer thread to exit
# to_write.put(None)
elif symbol == "PZM/BTC":
L_b = {}
for b in sorted(book["bids"],
key=lambda x: book["bids"][x][0],
reverse=True):
L_b.update({book["bids"][b][0]: float(book["bids"][b][1])})
L_a = {}
for b in sorted(book["asks"],
key=lambda x: book["asks"][x][0],
reverse=False):
L_a.update({book["asks"][b][0]: float(book["asks"][b][1])})
Live_buy = {}
for k, v in L_b.items():
if not Live_buy:
if float(v) < 0.1:
pass
else:
Live_buy.update({k: float(v)})
else:
if float(v) < 0.1:
pass
else:
sump = float(v) + float(list(Live_buy.values())[-1])
Live_buy.update({k: float(sump)})
Live_sell = {}
for k, v in L_a.items():
if not Live_sell:
if float(v) < 0.1:
pass
else:
Live_sell.update({k: float(v)})
else:
if float(v) < 0.1:
pass
else:
sump = float(v) + float(list(Live_sell.values())[-1])
Live_sell.update({k: float(sump)})
Live_buy = list(Live_buy.items())[:5]
Live_sell = list(Live_sell.items())[:5]
print('LB', Live_buy)
print('LA', Live_sell)
Live_PU = []
for i in Live_sell:
Live_PU.append(('live', 'BTC', 'PZM', 'buy', i[0], i[1]))
for i in Live_buy:
Live_PU.append(('live', 'PZM', 'BTC', 'sell', i[0], i[1]))
columns = [
'birga', 'valin', 'valout', 'direction', 'rates', 'volume'
]
df = pd.DataFrame(Live_PU, columns=columns)
# print(df)
# df.to_csv(main_path_data + "\\live_bd_PB.csv", index=False)
try:
os.remove(main_path_data + "\\live_bd_PB.csv")
df.to_csv(main_path_data + "\\live_bd_PB.csv",
index=False,
mode="w")
except Exception as e:
print('##### OOOPsss .... DB BTC ######')
os.remove(main_path_data + "\\live_bd_PB.csv")
df.to_csv(main_path_data + "\\live_bd_PB.csv",
index=False,
mode="w")
else:
pass
# for type in ["bids", "asks"]:
# str = type+"raw: "
# for b in sorted(book[type], key=lambda x: book[type][x][0], reverse=(type == "bids")):
# if float(book[type][b][1]) > 0:
# #
# # # print("###############################")
# # # print("symbol :", symbol)
# # # print("TYPE :", type)
# # # print("PRICE :", float(book[type][b][0]))
# # # print("AMOUNT:", float(book[type][b][1]))
# # # print("###############################")
# #
# # if type == 'asks':
# # direction = 'sell'
# # pass
# # else:
# # direction = 'buy'
# # pass
# #
# # if symbol == "PZM/USD":
# # elsym = "PZM/USD"
# # else:
# # elsym = "PZM/BTC"
# #
#
#
# # conn = sqlite3.connect("kurses.db")
# # cursor = conn.cursor()
# # cursor.execute(
# # "UPDATE kurses SET price=?, amount=? WHERE para_valut = ? AND birga = 'live' AND direction = ?",
# # (float(book[type][b][0]), float(book[type][b][1]), elsym, direction))
# # conn.commit()
# # conn.close()
#
#
#
#
# # a_file = open(main_path_data + "\\kurses.json", "r")
# # json_object = json.load(a_file)
# # a_file.close()
# # json_object["live"][elsym][direction]['price'] = float(book[type][b][0])
# # json_object["live"][elsym][direction]['amount'] = float(book[type][b][1])
# #
# # a_file = open(main_path_data + "\\kurses.json", "w")
# # json.dump(json_object, a_file)
# # a_file.close()
#
# str += ("%d:%s->%s\n" % (b, book[type][b][0], book[type][b][1]))
# break
# else:
# continue
# print ("THIS MY STR :",str)
def onNewRawOrders(symbol, orders, initial=False):
if (initial):
orderbooksraw[symbol] = {"asks": {}, "bids": {}}
for order in orders:
type = orderTypeToStr(order.order_type)
if order.quantity == 0:
if order.id in orderbooksraw[symbol][type]:
del orderbooksraw[symbol][type][order.id]
else:
orderbooksraw[symbol][type][order.id] = (order.price,
order.quantity,
order.timestamp)
if (not initial):
printOrderBookRaw(symbol)
def onUnsubscribe(channel_type, currency_pair):
print("Unsubscribed from %s for pair %s\n" %
(channel_type, currency_pair))
# ----------------------------------------------------------------------------------------------------------------------
# -------------------------------- Subscription control methods --------------------------------------------------------
# ----------------------------------------------------------------------------------------------------------------------
def sendUnsigned(msgtype, request, token):
msg = LivecoinWSapi_pb2.WsRequest()
msg.meta.SetInParent()
msg.meta.request_type = msgtype
if token is not None:
msg.meta.token = token
msg.msg = request.SerializeToString()
ws.send_binary(msg.SerializeToString())
def subscribeTicker(symbol, frequency=None, token=None):
request = LivecoinWSapi_pb2.SubscribeTickerChannelRequest()
request.currency_pair = symbol
request.frequency = frequency
sendUnsigned(LivecoinWSapi_pb2.WsRequestMetaData.SUBSCRIBE_TICKER,
request, token)
def unsubscribeTicker(symbol, token=None):
request = LivecoinWSapi_pb2.UnsubscribeRequest()
request.currency_pair = symbol
request.channel_type = LivecoinWSapi_pb2.UnsubscribeRequest.TICKER
sendUnsigned(LivecoinWSapi_pb2.WsRequestMetaData.UNSUBSCRIBE, request,
token)
def subscribeOrderbook(symbol, depth=None, token=None):
request = LivecoinWSapi_pb2.SubscribeOrderBookChannelRequest()
request.currency_pair = symbol
request.depth = depth
sendUnsigned(LivecoinWSapi_pb2.WsRequestMetaData.SUBSCRIBE_ORDER_BOOK,
request, token)
def unsubscribeOrderbook(symbol, token=None):
request = LivecoinWSapi_pb2.UnsubscribeRequest()
request.currency_pair = symbol
request.channel_type = LivecoinWSapi_pb2.UnsubscribeRequest.ORDER_BOOK
sendUnsigned(LivecoinWSapi_pb2.WsRequestMetaData.UNSUBSCRIBE, request,
token)
def subscribeOrderbookRaw(symbol, depth=None, token=None):
request = LivecoinWSapi_pb2.SubscribeOrderBookRawChannelRequest()
request.currency_pair = symbol
request.depth = depth
sendUnsigned(
LivecoinWSapi_pb2.WsRequestMetaData.SUBSCRIBE_ORDER_BOOK_RAW,
request, token)
def unsubscribeOrderbookRaw(symbol, token=None):
request = LivecoinWSapi_pb2.UnsubscribeRequest()
request.currency_pair = symbol
request.channel_type = LivecoinWSapi_pb2.UnsubscribeRequest.ORDER_BOOK_RAW
sendUnsigned(LivecoinWSapi_pb2.WsRequestMetaData.UNSUBSCRIBE, request,
token)
def subscribeTrades(symbol, token=None):
request = LivecoinWSapi_pb2.SubscribeTradeChannelRequest()
request.currency_pair = symbol
sendUnsigned(LivecoinWSapi_pb2.WsRequestMetaData.SUBSCRIBE_TRADE,
request, token)
def unsubscribeTrades(symbol, token=None):
request = LivecoinWSapi_pb2.UnsubscribeRequest()
request.currency_pair = symbol
request.channel_type = LivecoinWSapi_pb2.UnsubscribeRequest.TRADE
sendUnsigned(LivecoinWSapi_pb2.WsRequestMetaData.UNSUBSCRIBE, request,
token)
def subscribeCandle(symbol, interval, depth, token=None):
request = LivecoinWSapi_pb2.SubscribeCandleChannelRequest()
request.currency_pair = symbol
request.interval = interval
if depth is not None:
request.depth = depth
sendUnsigned(LivecoinWSapi_pb2.WsRequestMetaData.SUBSCRIBE_CANDLE,
request, token)
def unsubscribeCandle(symbol, token=None):
request = LivecoinWSapi_pb2.UnsubscribeRequest()
request.currency_pair = symbol
request.channel_type = LivecoinWSapi_pb2.UnsubscribeRequest.CANDLE
sendUnsigned(LivecoinWSapi_pb2.WsRequestMetaData.UNSUBSCRIBE, request,
token)
# ----------------------------------------------------------------------------------------------------------------------
# -------------------------------- Error handler------------ -----------------------------------------------------------
# ----------------------------------------------------------------------------------------------------------------------
def onError(token, code, message):
print("Error in message %s (code:%d, text:%s)\n" %
(token, code, message))
# ----------------------------------------------------------------------------------------------------------------------
# -------------------------------- Private api ------------- -----------------------------------------------------------
# ----------------------------------------------------------------------------------------------------------------------
def sendSigned(msgtype, request, token, ttl):
msg = LivecoinWSapi_pb2.WsRequest()
msg.meta.SetInParent()
msg.meta.request_type = msgtype
if token is not None:
msg.meta.token = token
request.expire_control.SetInParent()
request.expire_control.now = int(round(time.time() * 1000))
request.expire_control.ttl = ttl
msg.msg = request.SerializeToString()
# now sign message
msg.meta.sign = hmac.new(MY_SECRET_KEY,
msg=msg.msg,
digestmod=hashlib.sha256).digest()
# send it
ws.send_binary(msg.SerializeToString())
def login(token=None, ttl=10000): # ttl is in milliseconds
msg = LivecoinWSapi_pb2.LoginRequest()
msg.api_key = MY_API_KEY
sendSigned(LivecoinWSapi_pb2.WsRequestMetaData.LOGIN, msg, token, ttl)
def putLimitOrder(symbol,
isBuy,
amount,
price,
token=None,
ttl=10000): # ttl is in milliseconds
msg = LivecoinWSapi_pb2.PutLimitOrderRequest()
msg.currency_pair = symbol
msg.order_type = LivecoinWSapi_pb2.PutLimitOrderRequest.BID if isBuy else LivecoinWSapi_pb2.PutLimitOrderRequest.ASK
msg.amount = str(amount)
msg.price = str(price)
sendSigned(LivecoinWSapi_pb2.WsRequestMetaData.PUT_LIMIT_ORDER, msg,
token, ttl)
def cancelLimitOrder(symbol,
id,
token=None,
ttl=10000): # ttl is in milliseconds
msg = LivecoinWSapi_pb2.CancelLimitOrderRequest()
msg.currency_pair = symbol
msg.id = id
sendSigned(LivecoinWSapi_pb2.WsRequestMetaData.CANCEL_LIMIT_ORDER, msg,
token, ttl)
def getBalance(currency, token=None, ttl=10000): # ttl is in milliseconds
msg = LivecoinWSapi_pb2.BalanceRequest()
msg.currency = currency
sendSigned(LivecoinWSapi_pb2.WsRequestMetaData.BALANCE, msg, token,
ttl)
def getBalances(currency,
even_zero=False,
token=None,
ttl=10000): # ttl is in milliseconds
msg = LivecoinWSapi_pb2.BalancesRequest()
if currency is not None:
msg.currency = currency
msg.only_not_zero = not even_zero
sendSigned(LivecoinWSapi_pb2.WsRequestMetaData.BALANCES, msg, token,
ttl)
def getLastTrades(currency_pair,
onlyBuy,
forHour=False,
token=None,
ttl=10000): # ttl is in milliseconds
msg = LivecoinWSapi_pb2.LastTradesRequest()
if onlyBuy is not None:
if onlyBuy:
msg.trade_type = LivecoinWSapi_pb2.LastTradesRequest.BUY
else:
msg.trade_type = LivecoinWSapi_pb2.LastTradesRequest.SELL
if forHour:
msg.interval = LivecoinWSapi_pb2.LastTradesRequest.HOUR
else:
msg.interval = LivecoinWSapi_pb2.LastTradesRequest.MINUTE
msg.currency_pair = currency_pair
sendSigned(LivecoinWSapi_pb2.WsRequestMetaData.LAST_TRADES, msg, token,
ttl)
# ----------------------------------------------------------------------------------------------------------------------
# -------------------------------- Private api handlers ----------------------------------------------------------------
# ----------------------------------------------------------------------------------------------------------------------
def onSuccessfullLogin(token):
print("Successfully logged in\n")
doAuthenticatedTest()
def onSuccessfullOrderPut(token, order_id, amount_left):
print("We created new order with id %d, quantity left %s (token=%s)" %
(order_id, amount_left, token))
onTestOrderPut(token, order_id)
def onSuccessfullOrderCancel(token, order_id, amount_left):
print("We cancelled order with id %d, quantity left was %s" %
(order_id, amount_left))
def onBalances(token, balances):
print("fresh balances: " + str(balances))
def onLastTrades(token, trades):
print("fresh trades: " + str(trades))
# ----------------------------------------------------------------------------------------------------------------------
# -------------------------------- Incoming messages decoder -----------------------------------------------------------
# ----------------------------------------------------------------------------------------------------------------------
def handleIn(rawmsg):
response = LivecoinWSapi_pb2.WsResponse()
response.ParseFromString(rawmsg)
token = response.meta.token
msgtype = response.meta.response_type
msg = response.msg
doTestOnToken(token)
if msgtype == LivecoinWSapi_pb2.WsResponseMetaData.TICKER_CHANNEL_SUBSCRIBED:
event = LivecoinWSapi_pb2.TickerChannelSubscribedResponse()
event.ParseFromString(msg)
onNewTickers(event.currency_pair, event.data)
elif msgtype == LivecoinWSapi_pb2.WsResponseMetaData.TICKER_NOTIFY:
event = LivecoinWSapi_pb2.TickerNotification()
event.ParseFromString(msg)
onNewTickers(event.currency_pair, event.data)
elif msgtype == LivecoinWSapi_pb2.WsResponseMetaData.TRADE_CHANNEL_SUBSCRIBED:
event = LivecoinWSapi_pb2.TradeChannelSubscribedResponse()
event.ParseFromString(msg)
onNewTrades(event.currency_pair, event.data)
elif msgtype == LivecoinWSapi_pb2.WsResponseMetaData.TRADE_NOTIFY:
event = LivecoinWSapi_pb2.TradeNotification()
event.ParseFromString(msg)
onNewTrades(event.currency_pair, event.data)
elif msgtype == LivecoinWSapi_pb2.WsResponseMetaData.CANDLE_CHANNEL_SUBSCRIBED:
event = LivecoinWSapi_pb2.CandleChannelSubscribedResponse()
event.ParseFromString(msg)
onNewCandles(event.currency_pair, event.interval, event.data)
elif msgtype == LivecoinWSapi_pb2.WsResponseMetaData.CANDLE_NOTIFY:
event = LivecoinWSapi_pb2.CandleNotification()
event.ParseFromString(msg)
onNewCandles(event.currency_pair, event.interval, event.data)
elif msgtype == LivecoinWSapi_pb2.WsResponseMetaData.ORDER_BOOK_RAW_CHANNEL_SUBSCRIBED:
event = LivecoinWSapi_pb2.OrderBookRawChannelSubscribedResponse()
event.ParseFromString(msg)
onNewRawOrders(event.currency_pair, event.data, initial=True)
elif msgtype == LivecoinWSapi_pb2.WsResponseMetaData.ORDER_BOOK_RAW_NOTIFY:
event = LivecoinWSapi_pb2.OrderBookRawNotification()
event.ParseFromString(msg)
onNewRawOrders(event.currency_pair, event.data)
elif msgtype == LivecoinWSapi_pb2.WsResponseMetaData.ORDER_BOOK_CHANNEL_SUBSCRIBED:
event = LivecoinWSapi_pb2.OrderBookChannelSubscribedResponse()
event.ParseFromString(msg)
onNewOrders(event.currency_pair, event.data, initial=True)
elif msgtype == LivecoinWSapi_pb2.WsResponseMetaData.ORDER_BOOK_NOTIFY:
event = LivecoinWSapi_pb2.OrderBookNotification()
event.ParseFromString(msg)
onNewOrders(event.currency_pair, event.data)
elif msgtype == LivecoinWSapi_pb2.WsResponseMetaData.CHANNEL_UNSUBSCRIBED:
event = LivecoinWSapi_pb2.ChannelUnsubscribedResponse()
event.ParseFromString(msg)
onUnsubscribe(event.type, event.currency_pair)
elif msgtype == LivecoinWSapi_pb2.WsResponseMetaData.ERROR:
event = LivecoinWSapi_pb2.ErrorResponse()
event.ParseFromString(msg)
onError(token, event.code, event.message)
elif msgtype == LivecoinWSapi_pb2.WsResponseMetaData.LOGIN_RESPONSE:
onSuccessfullLogin(token)
elif msgtype == LivecoinWSapi_pb2.WsResponseMetaData.PUT_LIMIT_ORDER_RESPONSE:
event = LivecoinWSapi_pb2.PutLimitOrderResponse()
event.ParseFromString(msg)
onSuccessfullOrderPut(token, event.order_id, event.amount_left)
elif msgtype == LivecoinWSapi_pb2.WsResponseMetaData.CANCEL_LIMIT_ORDER_RESPONSE:
event = LivecoinWSapi_pb2.CancelLimitOrderResponse()
event.ParseFromString(msg)
onSuccessfullOrderCancel(token, event.order_id, event.amount_left)
elif msgtype == LivecoinWSapi_pb2.WsResponseMetaData.BALANCE_RESPONSE:
event = LivecoinWSapi_pb2.BalanceResponse()
event.ParseFromString(msg)
onBalances(token, [event])
elif msgtype == LivecoinWSapi_pb2.WsResponseMetaData.BALANCES_RESPONSE:
event = LivecoinWSapi_pb2.BalancesResponse()
event.ParseFromString(msg)
onBalances(token, event.balances)
elif msgtype == LivecoinWSapi_pb2.WsResponseMetaData.BALANCES_RESPONSE:
event = LivecoinWSapi_pb2.BalancesResponse()
event.ParseFromString(msg)
onBalances(token, event.balances)
elif msgtype == LivecoinWSapi_pb2.WsResponseMetaData.LAST_TRADES_RESPONSE:
event = LivecoinWSapi_pb2.LastTradesResponse()
event.ParseFromString(msg)
onLastTrades(token, event.trades)
# ----------------------------------------------------------------------------------------------------------------------
# -------------------------------- Test commands and subscriptions ----------------------------------------------------
# ----------------------------------------------------------------------------------------------------------------------
#test unsubscription
# subscribeTrades('BTC/RUR', token="s1")
subscribeOrderbook('PZM/USD', 5, token="s2")
subscribeOrderbook('PZM/BTC', 5, token="s2")
# # subscribeOrderbookRaw('BTC/RUR', 1, token="s3")
# # subscribeCandle('BTC/RUR', LivecoinWSapi_pb2.SubscribeCandleChannelRequest.CANDLE_1_MINUTE, 1, token="s4")
# # subscribeTicker('BTC/RUR', 1, token="s5")
#
# # #test channels
# subscribeOrderbookRaw('PZM/USD', NEED_TOP_ORDERS) # only NEED_TOP_ORDERS bids and asks in snapshot
# # subscribeTicker('BTC/USD', 2) #do not send me tickers too often (only one time in two seconds)
# subscribeOrderbook('PZM/USD', NEED_TOP_ORDERS) # only NEED_TOP_ORDERS bids and asks positions in snapshot
# subscribeTrades('BTC/USD')
# subscribeCandle('BTC/USD', LivecoinWSapi_pb2.SubscribeCandleChannelRequest.CANDLE_1_MINUTE, 10) # and give me 10 last candles
# subscribeOrderbookRaw('PZM/USD', 5, token="s1")
# subscribeOrderbookRaw('PZM/BTC', 5, token="s1")
# login("LOGIN")
def doTestOnToken(token):
if (token == "s1"):
unsubscribeTrades('BTC/RUR')
elif (token == "s2"):
unsubscribeOrderbook('BTC/RUR')
elif (token == "s3"):
unsubscribeOrderbookRaw('BTC/RUR')
elif (token == "s4"):
unsubscribeCandle('BTC/RUR')
elif (token == "s5"):
unsubscribeTicker('BTC/RUR')
def doAuthenticatedTest():
# getBalance("BTC")
# getBalances("BTC", True)
# getBalances("BTC", False)
# getBalances(None, True)
getBalances(None, False)
# getLastTrades("BTC/USD", onlyBuy=False)
# getLastTrades("BTC/USD", onlyBuy=True)
# getLastTrades("BTC/USD", onlyBuy=None)
# getLastTrades("BTC/USD", onlyBuy=True, forHour=True)
# putLimitOrder("BTC/EUR", isBuy=True, amount=0.1, price=10, token="badorder", ttl=10000) # WHY NOT?
# putLimitOrder("BTC/EUR", isBuy=True, amount=1, price=10, token="fakeorder", ttl=10000) # WHY NOT?
# putLimitOrder("BTC/USD", isBuy=True, amount=0.001, price=8300, token="myfirstbuy", ttl=10000)
# putLimitOrder("BTC/USD", isBuy=False, amount=0.001, price=8300, token="myfirstsell", ttl=10000)
def onTestOrderPut(token, id):
if (token == "fakeorder"):
cancelLimitOrder("BTC/EUR", id, "cancelfake", ttl=10000)
# ----------------------------------------------------------------------------------------------------------------------
# -------------------------------- Main running cycle ------------------------------------------------------------------
# ----------------------------------------------------------------------------------------------------------------------
# startedat = time.time()
#
# while time.time() - startedat < 180: # limit example running time to 3 minutes
#
#
#
# result = ws.recv()
# if result != "": # not keepalive
# handleIn(result)
#
# ws.close()
# if __name__ == "__main__":
while True:
result = ws.recv()
if result != "": # not keepalive
handleIn(result)
ws.close()
time.sleep(1)
def run(self):
while self.flag == "run":
try:
self.ws.connect(self.uri)
self.log_form.tx_tci("restart")
self.log_form.set_tci_stat('•TCI')
break
#time.sleep(3)
except Exception:
#self.log_form.set_tci_label_found()
#print("Tci_reciever: Except connection")
self.log_form.set_tci_stat('--', "#ff5555")
time.sleep(2)
continue
old_reciever = ""
while self.flag == "run":
try:
#print("Connect to ")
reciever = self.ws.recv()
if reciever != old_reciever:
print("Tci_reciever.run: from socket (esdr):_>", reciever)
tci_string = reciever.split(":")
# reciev vfo (freq)
if tci_string[0] == 'trx':
#self.tx = 'Enable'
values = tci_string[1].split(",")
#print("TRX:_>", values[1])
if values[1] == 'true;':
#print(values[1])
self.log_form.trx_enable('tx')
elif values[1] == 'false;':
#print(values[1])
self.log_form.trx_enable('rx')
if tci_string[0] == 'vfo':
values = tci_string[1].split(",")
if values[1] == '0' and values[0] == '0':
#print("set freq:")
self.log_form.set_freq(values[2].replace(';', ''))
# reciev protocol
#print("Частота:", values[2])
if tci_string[0] == 'protocol':
self.version_tci = tci_string[1].split(",")[1].replace(
";", "")
values = tci_string[1].replace(',', ' ')
values = values.replace(";", "")
#print("Version protocol:", self.version_tci)
self.log_form.set_tci_stat('•TCI: ' + values)
# reciev mode
if tci_string[0] == 'modulation':
values = tci_string[1].split(",")
if values[0] == '0':
#if self.version_tci == "1.4":
self.log_form.set_mode_tci(values[1].replace(
';', ''))
self.mode = values[1].replace(';', '')
#if self.version_tci == '1.5':
# self.log_form.set_mode_tci(values[1].replace(';', ''))
# self.mode = values[1].replace(';', '')
print(">", tci_string)
#if tci_string[0] == 'ready':
# print("server: ready;")
# self.log_form.sendMesageToTCI("ready;")
# reciev spot call
if tci_string[0] == 'clicked_on_spot':
print("clicked_on_spot:_>", tci_string)
values = tci_string[1].split(",")
print("clicked_on_spot:_>", values)
self.log_form.set_call(call=values[0].strip())
band = std.std().get_std_band(
values[1].strip().replace(";", ""))
print("band>", band)
mode = std.std().mode_band_plan(
band, values[1].strip().replace(";", ""))
print("mode>", mode)
self.log_form.set_mode_tci(mode.lower())
Tci_sender(self.settingsDict['tci-server'] + ":" +
self.settingsDict['tci-port']).set_mode(
"0", mode)
old_reciever = reciever
time.sleep(0.002)
except Exception:
#print("Tci_reciever: Exception in listen port loop", Exception)
self.log_form.set_tci_stat(' ')
#self.log_form.set_tci_label_found()
try:
self.ws.close()
self.ws = websocket.WebSocket()
self.ws.connect(self.uri)
self.log_form.set_tci_stat("•TCI")
self.log_form.tx_tci("restart")
except:
time.sleep(2)
self.log_form.set_tci_label_found()
#time.sleep(2)
continue
def ws_start(ws_uri,
on_open=ws_on_open,
on_message=ws_on_message,
on_error=ws_on_error,
on_close=ws_on_close):
""" WebSocket main loop """
self.ws = websocket.WebSocket()
# connect
try:
self.ws.connect(ws_uri)
except Exception as e:
on_error(self.ws, e)
return
on_open(self.ws)
buffer = b""
buffered_opcode = ABNF.OPCODE_TEXT
while not self._isQuit:
try:
frame = self.ws.recv_frame()
except WebSocketConnectionClosedException as e:
cmt_logger.debug('ws_start: WebSocket Closed')
break
except Exception as e:
on_error(self.ws, e)
break
"""
Fragmented frame example: For a text message sent as three fragments,
the 1st fragment: opcode = 0x1 (OPCODE_TEXT) and FIN bit = 0,
the 2nd fragment: opcode = 0x0 (OPCODE_CONT) and FIN bit = 0,
the last fragment: opcode = 0x0 (OPCODE_CONT) and FIN bit = 1.
"""
if frame.opcode in (ABNF.OPCODE_TEXT, ABNF.OPCODE_BINARY,
ABNF.OPCODE_CONT):
buffer += frame.data
if frame.opcode != ABNF.OPCODE_CONT:
buffered_opcode = frame.opcode
else:
cmt_logger.debug(
'ws_start: fragment message: {}'.format(
frame.data))
# it's either a last fragmented frame, or a non-fragmented single message frame
if frame.fin == 1:
data = buffer
buffer = b""
if buffered_opcode == ABNF.OPCODE_TEXT:
message = ""
try:
message = data.decode('utf-8')
except UnicodeDecodeError as e:
message = data.decode('latin-1')
cmt_logger.debug(
'ws_start: UnicodeDecodeError, decoded as latin-1: {}'
.format(message))
except Exception as e:
on_error(self.ws, e)
on_message(self.ws, message)
elif buffered_opcode == ABNF.OPCODE_BINARY:
cmt_logger.debug(
'ws_start: received unknown binary data: {}'.
format(data))
elif frame.opcode == ABNF.OPCODE_CLOSE:
# cmt_logger.debug('ws_start: received close opcode')
# self.ws.close() will try to send close frame, so we skip sending close frame here
break
elif frame.opcode == ABNF.OPCODE_PING:
cmt_logger.debug('ws_start: received ping, sending pong')
if len(frame.data) < 126:
self.ws.pong(frame.data)
else:
cmt_logger.debug(
'ws_start: ping message too big to send')
elif frame.opcode == ABNF.OPCODE_PONG:
cmt_logger.debug('ws_start: received pong')
else:
cmt_logger.error(
'ws_start: unknown frame opcode = {}'.format(
frame.opcode))
on_close(self.ws)
self.ws.close()
#!/usr/bin/env python
import ssl
import websocket
#from websocket import create_connection
from json import dumps, loads
from pprint import pprint
ws = websocket.WebSocket(sslopt={"cert_reqs": ssl.CERT_NONE})
ws.connect("wss://ws-feed.pro.coinbase.com")
print("Sending 'Hello, World'...")
params = {
"type": "subscribe",
"channels": [{
"name": "level2",
"product_ids": ["ETH-USD"]
}]
}
print(dumps(params))
ws.send(dumps(params))
x = range(0, 100000)
for y in x:
result = ws.recv()
if result:
print("Received '%s'" % pprint(loads(result)))
ws.close()
def acquire(sid, cookies):
# register
req = urllib2.Request(websocket_url +
"/socket.io/?EIO=3&transport=polling&t=%d-2&sid=%s" %
(time.time() * 1000, sid))
req.add_header('User-agent', user_agent)
req.add_header('Referer', 'http://key.gf.com.cn/')
req.add_header('Origin', 'http://key.gf.com.cn/')
req.add_header('Connection', 'keep-alive')
print 'clickeggsToken:', clickeggsToken
response = opener.open(
req,
'180:420["request",{"ver":2,"data":{"appId":"clickeggs.gf.com.cn","regId":"8d9e0f92393acb0a43e7f206ceeeec3220a2f145","token":"%s","event":"addRegId"}}]'
% (clickeggsToken))
html = response.read()
print html
req = urllib2.Request(websocket_url +
"/socket.io/?EIO=3&transport=polling&t=%d-2&sid=%s" %
(time.time() * 1000, sid))
req.add_header('User-agent', user_agent)
req.add_header('Referer', 'http://key.gf.com.cn/')
req.add_header('Origin', 'http://key.gf.com.cn/')
req.add_header('Connection', 'keep-alive')
response = opener.open(req)
html = response.read()
print html
req = urllib2.Request(websocket_url +
"/socket.io/?EIO=3&transport=polling&t=%d-2&sid=%s" %
(time.time() * 1000, sid))
req.add_header('User-agent', user_agent)
req.add_header('Referer', 'http://key.gf.com.cn/')
req.add_header('Origin', 'http://key.gf.com.cn/')
req.add_header('Connection', 'keep-alive')
print 'clickeggsToken:', clickeggsToken
response = opener.open(
req, '50:421["request",{"data":{"event":"getPrivateData"}}]')
html = response.read()
print html
##################################################################
ws = websocket.WebSocket()
#ws.connect("ws://clickeggs.hippo.gf.com.cn/socket.io/?EIO=3&transport=websocket&sid=%s" % (time.time() * 1000, jpkt['sid']), Cookie = cookies)
ws.connect(websocket_url2 +
"/socket.io/?EIO=3&transport=websocket&sid=%s" % (sid),
cookie=cookies,
header=["User-Agent: " + user_agent, 'Pragma: no-cache'],
origin=webreq_url
#, http_proxy_host="127.0.0.1", http_proxy_port=8080
)
ws.send('2probe')
print ws.recv()
ws.send('5')
# print ws.recv()
"""
ws.send('42["message",{"topic":"gmsv2.service.getuser","data":{"data":{"uid":"%s","version":"2.0"},"msgid":1}}]' % (userId))
ws.send('42["message",{"topic":"gmsv2.service.getuser","data":{"data":{"uid":"%s","version":"2.0"},"msgid":2}}]' % (userId))
# print ws.recv()
ws.send('42["message",{"topic":"pns","data":{"data":{"event":"addRegId","regIds":["8d9e0f92393acb0a43e7f206ceeeec3220a2f145","5977"],"uuid":"Mozilla/5.0 (Windows NT 6.1; WOW64; rv:43.0) Gecko/20100101 Firefox/43.0","seq":3}}}]')
ws.send('42["message",{"topic":"pns","data":{"data":{"event":"addRegId","regIds":["8d9e0f92393acb0a43e7f206ceeeec3220a2f145","5977"],"uuid":"Mozilla/5.0 (Windows NT 6.1; WOW64; rv:43.0) Gecko/20100101 Firefox/43.0","seq":4}}}]')
"""
while True:
msg = ws.recv()
if len(msg) == 0:
break
msg2 = msg[2:]
try:
jpkt = json.loads(msg2.decode('utf-8-sig'))
except:
print msg
ws.send('2')
print ws.recv()
continue
# print jpkt
if jpkt[1]['data']["messages"][0]['type'] == 'newOrders':
orderId = jpkt[1]['data']["messages"][0]['content'][0]['order_id']
clientName = jpkt[1]['data']["messages"][0]['content'][0][
'client_name']
desc = jpkt[1]['data']["messages"][0]['content'][0]['description']
print orderId, clientName, desc
req = urllib2.Request(webreq_url + "/v2/order/%s/snatchrequest" %
(orderId))
req.add_header('User-agent', user_agent)
response = opener.open(req, '')
html = response.read()
# jpkt = json.loads(html)
print html.decode('utf-8')
jpkt = json.loads(html)
if jpkt['status'] == '200':
break
"""
if jpkt[1]['topic'] == 'gmsv2.order.new':
data = jpkt[1]['data']['data']
jpkt = json.loads(data)
orderId = jpkt['data']['message'][0]['order_id']
clientName = jpkt['data']['message'][0]['client_name']
print orderId, clientName #, len(jpkt['data']['message'])
req = urllib2.Request(webreq_url + "/v2/order/%s/snatchrequest" % (orderId))
req.add_header('User-agent', user_agent)
response = opener.open(req, '')
html = response.read()
# jpkt = json.loads(html)
print html.decode('utf-8')
jpkt = json.loads(html)
if jpkt['status'] == '200':
break;
"""
ws.send('2')
print ws.recv()
#!/usr/bin/python
import sys, os, asyncore, websocket
if __name__ == '__main__':
if len(sys.argv) != 2:
sys.stderr.write('usage: %s <message>\n' % os.path.abspath(__file__))
sys.exit(1)
ws = websocket.WebSocket('ws://localhost:8080',
onopen=lambda: ws.send(sys.argv[1]),
onmessage=lambda m: sys.stdout.write('Echo: %s\n' % m),
onclose=lambda: sys.stdout.write('Connection closed.\n'))
try:
asyncore.loop()
except KeyboardInterrupt:
ws.close()
def __init__(self, server_url):
self.ws = websocket.WebSocket()
self.ws.connect(server_url)
def create_connection():
ws.connect("ws://example.com/websocket",
http_proxy_host="proxy_host_name",
http_proxy_port=3128)
ws = websocket.WebSocket()
class Etzelclient:
ws = websocket.WebSocket()
def __init__(self, host):
self.qbacks = {}
self.ws = create_connection(host)
self.opened = False
self.queue = []
# self.onopen = None
def connect(self, host):
pass
def isleep(self, qname):
content = {"qname": qname, "cmd": "ISLP"}
data = json.JSONEncoder().encode(content)
self.ws.send(data)
def worker(self):
evt = self.ws.recv()
d = json.JSONDecoder().decode(evt)
# if ("msg" in d):
#the variable is not defined
if (d["cmd"] == "awk"):
self.fetch(d["qname"])
#"self" is inside ws.worker scope. we need parent scope which is in the constructor :)
elif (d["cmd"] == "nomsg"):
self.isleep(d["qname"])
elif (d["cmd"] == "msg"):
self.qbacks[d["qname"]](d)
self.fetch(d["qname"])
def publish(self, queue, msg, options=None):
content = dict({
"qname": queue,
"msg": msg,
"cmd": "PUB",
"delay": 0,
"expires": 0
})
if ((options != None) and ("delay" in options)):
content["delay"] = options["delay"]
if ((options != None) and ("expires" in options)):
content["expires"] = options["expires"]
#print(content.dict());
data = json.JSONEncoder().encode(content)
# data = json.JSONEncoder().encode(content)
self.ws.send(data)
def sendSubCmd(self, queue):
content = {"qname": queue, "cmd": "SUB"}
data = json.JSONEncoder().encode(content)
self.ws.send(data)
def acknowledge(self, queue, uid):
content = {"qname": queue, "cmd": "ACK", "uid": uid}
data = json.JSONEncoder().encode(content)
self.ws.send(data)
def fetch(self, queue):
#print(queue)
content = {"qname": queue, "cmd": "FET"}
data = json.JSONEncoder().encode(content)
self.ws.send(data)
def subscribe(self, queue, callback):
self.sendSubCmd(
queue) #we have to notify the server that we are subscribing
self.qbacks[queue] = callback
self.fetch(queue)
def startwork(self):
while True:
self.worker()
# while True:
# time.sleep(10)
