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)