def connect(self): is_ready = False options = {'exit_event': self._exit_event, 'poll': 0.1, 'ping_rate': 0} for event in persist(self._websocket, **options): if is_ready: try: message = self._messages.get(False) #print 'SEND %s' % message self._websocket.send_text( unicode(json.dumps(message), 'utf-8')) except Queue.Empty: pass if event.name == 'ready': is_ready = True if event.name == 'text': body = json.loads(event.text) if 'id' in body: #print 'RECV %s' % (body,) self._results[body['id']] = body self._locks.pop(body['id']).release() elif body.get('method') == 'Target.receivedMessageFromTarget': result = json.loads(body['params']['message']) if 'id' in result: #print 'RECV %s' % (body,) self._results[result['id']] = result self._locks.pop(result['id']).release()
def monitor(self): for event in persist(self.ws): try: if not self.running: self.thread_stopped = True return if event.name == 'connecting': print('connecting...') elif event.name == 'connected': print('connected') self.connected = True elif event.name == 'pong': print('received pong') elif event.name == 'poll': print('received poll') elif event.name == 'text': json_str = event.text data = json.loads(json_str) if data['op'] == 'publish': topic_id = data['topic'] if topic_id in self.pub_callbacks: self.pub_callbacks[topic_id](data['msg']) elif data['op'] == 'service_response': service_id = data['service'] if service_id in self.srv_callbacks: self.srv_callbacks[service_id](data['result']) else: print('unknown data: ', data) else: print('unhandled event: ', event.name) print(event) except: logging.exception('error handling %r', event)
def run(self): """ Thread loop Listens for WS messages, and adds them the q_rx Queue. Monitors the q_tx, and sends any messages it finds. Handles PING, PONG, and POLL messages. :return: """ for event in persist(self.ws): logging.info('RX-EVENT: ' + event.name) logging.debug(event) if self.stop: logging.info('STOP REQUESTED') break # WS reporting session is established if event.name == 'ready': self.ready = True # Service has sent us a text message elif event.name == 'text': logging.debug(event.text) self.q_rx.put(event.text) elif event.name not in self.ignore_events: logging.error('UNKNOWN RX-EVENT: ' + event.name) while self.ready: if not self.q_tx.empty(): send_msg = self.q_tx.get() logging.info('TX-EVENT: ' + send_msg) self.ws.send_text(send_msg) self.q_tx.task_done() else: break logging.info('CLOSING') self.ws.close()
def requests(self, persistent=True, **persist_args): """Return an interator""" events = persist(self, **persist_args) if persistent else self for event in events: request = self.get_request(event) if request is not None: yield request
def run(self): """Main websocket handling loop.""" try: with self.websocket: for event in persist(self.websocket): log.debug('WS %r', event) try: self.on_event(event) except Exception as error: log.exception('error handling websocket event') except (SystemExit, KeyboardInterrupt): log.info('exit requested') except Exception: log.exception('unhandled error from websocket') self.on_close()
def websocket_task(self) -> None: """ Runs the websocket task. """ ws = WebSocket(self.url, agent=USER_AGENT) self._ws = ws # generate poll events every 0.5 seconds to see if we can cancel websocket = persist(ws, ping_rate=0, poll=1, exit_event=self._cancelled) for event in websocket: self._portal.run(self._queue.put, event) # signal the end of the queue self._portal.run(self._queue.put, self._done)
def websocket_handler(self) -> None: """ The actual websocket handler. This wraps the Lomond reconnecting websocket, putting data on the queue. """ ws = WebSocket(self.url, agent=USER_AGENT) self._ws = ws # generate poll events every 0.5 seconds to see if we can cancel websocket = persist(ws, ping_rate=0, poll=1, exit_event=self._cancelled) for event in websocket: self._queue.put(event) # signal the end of the queue self._queue.put(self._done)
def persist_testing_helper(mocker, validate_function, websocket_connect=None): # ok. First, we start off by calling .spy on our fake function, so that # we could verify that it was called mocker.spy(FakeEvent, 'wait') # now, we patch the import path to threading.Event and replace it with # our own FakeEvent. Therefore, whenever persist.py will try to import # threading.Event, it will actually import FakeEvent mocker.patch('lomond.persist.threading.Event', FakeEvent) # great, now a simple websocket imposter websocket = FakeWebSocket() if websocket_connect: websocket.connect = websocket_connect yielded_events = list(persist(websocket)) # the sole fact that we ended up in this line means that the event # method was called, but we can nevertheless check it assert FakeEvent.wait.call_count == 1 # and now we can validate the events. validate_function(yielded_events)
def connect(self): is_ready = False options = {'exit_event': self._exit_event, 'poll': 0.1, 'ping_rate': 0} for event in persist(self._websocket, **options): print event.name if is_ready: try: message = self._messages.get(False) self._websocket.send_text( unicode(json.dumps(message), 'utf-8')) except Queue.Empty: pass if event.name == 'ready': is_ready = True if event.name == 'text': body = json.loads(event.text) if 'id' in body: self._results[body['id']] = body self._locks.pop(body['id']).release()
def start_websocket(self): self.websocket = WebSocket(f'ws://{self.address}/') for event in persist(self.websocket): if event.name == 'ready': self.websocket.send_json(command='join_group', data=dict(key=self.key)) if event.name == 'text': if event.json['command'] == 'new_id': self.websocket_id = event.json['id'] if event.json['command'] == 'new_view': print('New view') print(event.json['source']) print(self.websocket_id) if event.json['source'] != self.websocket_id: flare.invoke_later(target=self.set_camera, args=(event.json['view'], )) if self.thread_exit: self.thread_exit = False break
def ws(): nicknames = {} file_names = {} headers = {} trades = {} opened_files = {} old_ob = {} send_ob = {} global deri_ob deri_ob = {} high = {} low = {} time_now = datetime.datetime.utcnow() fut_sym, back_sym = contract_sym(time_now) instruments = ["BTC-PERPETUAL", fut_sym, back_sym] short = ["_btc_perpetual_", "_btc_front_quarter_", "_btc_back_quarter_"] channels = ["quote", "trade"] directory = arb_algo_path + "\data\deri_data\\" m1_directory = arb_algo_path + "\data\deri_1min\\" for chan in channels: nicknames[chan] = {} headers[chan] = {} file_names[chan] = {} opened_files[chan] = {} for idx in range(len(instruments)): nicknames[chan][instruments[idx]] = short[idx] + chan for chan in channels: for inst in instruments: file_names[chan][inst] = directory + str( time_now.date()) + nicknames[chan][inst] + ".csv" if os.path.isfile(file_names[chan][inst]) == False: headers[chan][inst] = True else: headers[chan][inst] = False ### open all files, creating any new files names for those that dont exist opened_files[chan][inst] = open(file_names[chan][inst], 'a+', newline='') for inst in instruments: ### create data stores ### #deri_ob[inst] = [] dont create as it creates itself old_ob[inst] = {} high[inst] = -np.inf low[inst] = np.inf spread_high = -np.inf spread_low = np.inf ### files just for 1min quote ### file_name_min = m1_directory + "week_" + str( time_now.isocalendar()[1]) + "_1min" + ".csv" headers_min = False save_min = False ws_fund = False heartbeat1h = False old_date = datetime.datetime(2008, 1, 1) ### Start websocket ### while True: ws_delay = False websocket = WebSocket('wss://www.deribit.com/ws/api/v1') now_time = datetime.datetime.utcnow() for event in persist(websocket): time_now = datetime.datetime.utcnow() ### check if file exisits (either because you run the ws for the first time, or its a new date) #### if time_now.date() != old_date: for chan in channels: for inst, nickname in nicknames[chan].items(): file_names[chan][inst] = directory + str( time_now.date()) + nickname + ".csv" if os.path.isfile(file_names[chan][inst]) == False: ## only creates a new file if one doenst exist opened_files[chan][inst] = open( file_names[chan][inst], 'a+', newline='') headers[chan][inst] = True file_name_min = m1_directory + "week_" + str( time_now.isocalendar()[1]) + "_1min" + ".csv" if os.path.isfile(file_name_min) == False: headers_min = True old_date = time_now.date() #################################################################################################### if event.name == "ready": ############ need to code up way to auto subscribe when instruments change ############## #fut_sym, back_sym = contract_sym(time_now) ################################ ws_args = { "instrument": instruments, "event": ["order_book", "trade"] } signature = generate_signature(key, secret, "/api/v1/private/subscribe", ws_args) print("connecting", datetime.datetime.now(), signature) websocket.send_json(id=5533, action="/api/v1/private/subscribe", arguments=ws_args, sig=signature) ws_args = {"instrument": "BTC-PERPETUAL"} signature = generate_signature(key, secret, "/api/v1/public/getsummary", ws_args) ws_funding = websocket.send_json( id=62, action="/api/v1/public/getsummary", arguments=ws_args, sig=signature) elif event.name == "text": now_time = datetime.datetime.utcnow() result = event.json #print("actual new websocket object coming through") ############################################################### ######### funding if requested #### if "id" in result: if result["id"] == 62: current_funding = result["result"]["currentFunding"] funding_8h = result["result"]["funding8h"] ###################################### if "notifications" in result: if result["notifications"][0][ "message"] == "order_book_event": inst = result["notifications"][0]["result"][ "instrument"] chan = "quote" deri_ob[inst] = [] for lev in range( len(result["notifications"][0]["result"] ["bids"])): ob = {} ob["instrument"] = inst ob["level"] = lev + 1 ob["bid_price"] = result["notifications"][0][ "result"]["bids"][lev]["price"] ob["bid_size"] = result["notifications"][0][ "result"]["bids"][lev]["quantity"] ob["ask_price"] = result["notifications"][0][ "result"]["asks"][lev]["price"] ob["ask_size"] = result["notifications"][0][ "result"]["asks"][lev]["quantity"] deri_ob[inst].append(ob) if lev == 0: if ob["ask_price"] > high[inst]: high[inst] = ob["ask_price"] if ob["bid_price"] < low[inst]: low[inst] = ob["bid_price"] #for m1,m2 in [("BTC-PERPETUAL",fut_sym),("BTC-PERPETUAL",back_sym),(fut_sym,back_sym)] #perp = deri_ob.get("BTC-PERPETUAL",[{"bid_price":np.nan}])[0]["bid_price"] #fut = deri_ob.get(fut_sym,[{"bid_price":np.nan}])[0]["bid_price"] #spread = perp-fut #if spread > spread_high: # spread_high = spread #if spread < spread_low: # spread_low = spread if inst in instruments: if deri_ob[inst] != old_ob[inst]: old_ob[inst] = deri_ob[inst].copy() send_ob[inst] = deri_ob[inst].copy() for level in send_ob[inst]: level["timestamp"] = str( pd.to_datetime(result["notifications"] [0]["result"]["tstamp"], unit="ms")) level["my_utc_time"] = str(now_time) if pd.to_datetime( level["my_utc_time"] ) > pd.to_datetime( level["timestamp"] ) + datetime.timedelta(seconds=60): print( "websocket is delayed, restarting", "deribit time", pd.to_datetime(level["timestamp"]), "my_time", level["my_utc_time"]) ws_delay = True break # breaks from websocket loop to restart if ws_delay == True: break write(send_ob[inst], "fast", file_names[chan][inst], opened_files[chan][inst], headers[chan][inst], rows="multi") headers[chan][inst] = False if now_time.second >= 30: save_min = True if now_time.second < 30: ws_fund = True if now_time.second > 45 and ws_fund == True: ### quickly send a ws request and loop to collect it, should be very quick and you are back here## if ws_fund == True: ws_args = {"instrument": "BTC-PERPETUAL"} signature = generate_signature( key, secret, "/api/v1/public/getsummary", ws_args) ws_funding = websocket.send_json( id=62, action="/api/v1/public/getsummary", arguments=ws_args, sig=signature) ws_fund = False if now_time.second < 30 and save_min == True: min_data = [] for inst in instruments: send_ob_min = deri_ob[inst][0].copy() send_ob_min["high"] = high[inst] send_ob_min["low"] = low[inst] high[inst] = -np.inf low[inst] = np.inf send_ob_min["timestamp"] = str( pd.to_datetime(result["notifications"][0] ["result"]["tstamp"], unit="ms")) min_data.append(send_ob_min) ## add in 8h funding ## dummy = min_data[0] dummy = { key: np.nan for key, value in dummy.items() } dummy["instrument"] = "8h_funding" dummy["bid_price"] = funding_8h dummy["ask_price"] = current_funding dummy["timestamp"] = str( pd.to_datetime(result["notifications"][0] ["result"]["tstamp"], unit="ms")) min_data.append(dummy) ## write write(min_data, "slow", file_name_min, rows="multi") headers_min = False save_min = False if now_time.minute == 0 and now_time.second == 0: heartbeat1h = True elif now_time.minute == 0 and now_time.second > 0 and heartbeat1h == True: print("ws full alive", now_time) heartbeat1h = False if result["notifications"][0]["message"] == "trade_event": inst = result["notifications"][0]["result"][0][ "instrument"] chan = "trade" trades[inst] = [] for trade in result["notifications"][0]["result"]: trades_dict = {} trades_dict["instrument"] = trade["instrument"] trades_dict["qty"] = trade["quantity"] trades_dict["timestamp"] = str( pd.to_datetime(trade["timeStamp"], unit="ms")) trades_dict["my_utc_time"] = str(now_time) trades_dict["price"] = trade["price"] trades_dict["direction"] = trade["direction"] trades[inst].append(trades_dict) write(trades[inst], "fast", file_names[chan][inst], opened_files[chan][inst], headers[chan][inst], rows="multi") headers[chan][inst] = False ############################################################### elif event.name == "pong": continue elif event.name == "poll": # happens every 5 seconds new_fut, new_back = contract_sym(now_time) if (fut_sym, back_sym) != (new_fut, new_back): ## break websocket so it can change contracts print("breaking websocket to change contracts") break if now_time + datetime.timedelta( seconds=5) < datetime.datetime.utcnow(): print("websocket has been stale for 5 seconds", "ws_time", now_time, "now", datetime.datetime.utcnow()) break
def poll(logintoken): websocket = WebSocket("wss://{apic_address}/socket{token}".format( apic_address=apic_address, token=logintoken)) subscribed = False count = 0 for event in persist(websocket): if event.name not in ['poll', 'pong']: log("event received " + event.name) count += 1 if event.name in ['ready', 'poll', 'pong'] and (not subscribed or count > 20): #2019-01-10T00:14:24 from_time = datetime.fromtimestamp( int(not_connected[apic_address])).strftime( '%Y-%m-%dT%H:%M:%S') #from_time = datetime.fromtimestamp(int(time.time())).strftime('%Y-%m-%dT%H:%M:%S') log("subscribing from %s" % (from_time)) r = requests.get( 'https://' + apic_address + "/api/node/class/aaaModLR.json?subscription=yes&page=0&page-size=10000&query-target-filter=and(gt(aaaModLR.created,\"%s\"))" % (from_time), headers={ 'Content-type': 'application/json', 'Cookie': "APIC-cookie=%s" % (logintoken) }, verify=False, proxies=proxies) log("subscribe request returned (%s)" % (r.status_code)) result = json.loads(r.text) #dump previus events for aci_event in result.setdefault("imdata", []): if "aaaModLR" in aci_event: message = aci_event["aaaModLR"]["attributes"] dump_message(message) count = 0 if r.ok: subscribed = True log("subscribed") #we won't ever need events before this not_connected[apic_address] = time.time() else: log(r.text) result = json.loads(r.text) subscribed = False log("not subscribed (request was not ok)") if (re.match( r'Token was invalid', result["imdata"][0]["error"] ["attributes"]["text"])): log("Token was invalid; reconnecting") break if event.name == 'text': #websocket.send_text(event.text) aci_event = json.loads(event.text) message = aci_event["imdata"][0]["aaaModLR"]["attributes"] dump_message(message) #we won't ever need events before this not_connected[apic_address] = time.time() websocket.close() init()
import json import re from lomond.persist import persist from HQApi import HQApi, HQWebSocket bearer = "Bearer" api = HQApi(bearer) ws = HQWebSocket(api, demo=True, log_new_methods=True) websocket = ws.get() for msg in persist(websocket): if msg.name == "text": data = json.loads(re.sub(r"[\x00-\x1f\x7f-\x9f]", "", msg.text)) print(data)
def run(self): for msg in persist(self.new.ws): if msg.name == "text": data = json.loads(re.sub(r"[\x00-\x1f\x7f-\x9f]", "", msg.text)) self.new.call({"type": data["type"], "data": data})
"change": get_change_flag(data_array[5]), "sequence": int(data_array[6]), "price": float(data_array[7]), "quantity": float(data_array[8]) } return data_obj cryptocompare_ws = WebSocket('wss://streaming.cryptocompare.com') subs = { "action": "SubAdd", "subs": ["8~bitfinex~BTC~USD"], "api_key": "YOUR-API-KEY", "format": "streamer" } for event in persist(cryptocompare_ws): if event.name == "ready": print('ready') cryptocompare_ws.send_json(subs) if event.name == "text": print(event.text) messages = event.text.split("|") messages = messages[:-1] #Last element is empty string for message in messages: if message == "999~HEARTBEAT|": print(message) elif message.split("~")[0] == "9": print(parse_snapshot(message)) continue else: print(parse_level_2(message))
pen = servomotor.ServoPen() eyes = eyematrix.RobotEyes(i2c, 0x70, 0x74) # Create the robot robot = Turtle(axle, pen, eyes) # Set up the WebSocket connection ws = JSONRPCWebSocket("wss://arch7210-fall2019.coditect.com/pablo") ws.set_basic_auth("pablo", "*************") # Counter for eyes blink_count = 0 tired_count = 0 angry_count = 0 try: for event in persist(ws): request = ws.get_request(event) print(event) if request is not None: blink_count = 0 tired_count += 1 angry_count = 0 if request == False or request.exec(robot, ws) == False: angry_count += 1 print(angry_count) if angry_count > 5: eyes.angry()
def run(self): cnt_deadman = 0 # recommended is 15 seconds, but 30 should do for dev cnt2 = 0 # ghetto reducing spamm subs_args = build_requests(self.subs, self.symbol_list) ws = self._prep_connection() for event in persist(ws): if isinstance(event, events.Rejected): self.logger.warning(str(event.response)) self.warn(event.response) if isinstance(event, events.BackOff): self.warn("backing off for {} s".format(str(event.delay))) sleep(event.delay) ws.close() self.run() # regen nonce and stuff if event.name == "ready": # send deadman switch ws.send_json({"op": "cancelAllAfter", "args": 60000}) self._subscribe(ws=ws) if isinstance(event, events.Text): msg = (json.loads(event.text)) # print(msg) # now we get the limit value from welcome message (or rate limit, later)#TODO MED test it rough!!! if 'info' in msg.keys() and 'limit' in msg.keys(): self.rem_limit = msg['limit'] # we check and ack subscriptions if 'success' in msg.keys() and 'subscribe' in msg.keys(): try: subs_args.remove(msg['subscribe']) except: self.warn( "that's weird : {} was not to be sub'd".format( msg['subscribe'])) if len(subs_args) == 0: self.debug("all subs good to go") # # now we deal with L2 if 'table' in msg.keys() and msg['table'] == 'orderBookL2_25': self.book.getmsg(msg) if self.book.partial: # waiting for the order book # self.toy_mm() self.agent.on_l2() # # orders if 'table' in msg.keys() and msg['table'] == 'order': # print(msg) self.ord_keep.ws_update( msg) # TODO this needs to be threadsafe if 'table' in msg.keys() and msg['table'] in [ 'trade', 'margin' ]: self.message_data_updater(msg, event.received_time) if msg['table'] == 'trade': # we calculate state (trade ratio might change as a result) self.agent.on_trade() if isinstance(event, events.Poll): cnt_deadman += 1 print(self.ord_keep.exec_report()) if cnt_deadman == self.deadman_renew: # send deadman switch self.debug("deadman re-activate") ws.send_json({"op": "cancelAllAfter", "args": 60000}) cnt_deadman = 0 try: self.debug(self.book.bbo(lvl=5)) except: pass self.debug(self.ord_keep.ord_report()) print("current inventory: {}".format( sum([x['orderQty'] for x in self.ord_keep.transactions]))) avg_price = avg_price_inv(self.symbol_list[0], self.ord_keep.transactions) if avg_price: print("holding at avg price {}".format(str(avg_price)))
def _run_socketio_thread(self): self._running = True # Back off for Error restarting min_wait = 5 max_wait = 30 retries = 0 random_wait = max_wait - min_wait while self._running is True: _LOGGER.info("Attempting to connect to SocketIO server...") try: retries += 1 self._handle_event(STARTED, None) self._websocket = WebSocket(self._url) self._exit_event = threading.Event() if self._cookie: self._websocket.add_header(COOKIE_HEADER, self._cookie) if self._origin: self._websocket.add_header(ORIGIN_HEADER, self._origin) for event in persist(self._websocket, ping_rate=0, poll=5.0, exit_event=self._exit_event): if isinstance(event, events.Connected): retries = 0 self._on_websocket_connected(event) elif isinstance(event, events.Disconnected): self._on_websocket_disconnected(event) elif isinstance(event, events.Text): self._on_websocket_text(event) elif isinstance(event, events.Poll): self._on_websocket_poll(event) elif isinstance(event, events.BackOff): self._on_websocket_backoff(event) if self._running is False: self._websocket.close() except SocketIOException as exc: _LOGGER.warning("SocketIO Error: %s", exc.details) except WebSocketError as exc: _LOGGER.warning("Websocket Error: %s", exc) if self._running: wait_for = min_wait + random() * min(random_wait, 2**retries) _LOGGER.info("Waiting %f seconds before reconnecting...", wait_for) if self._exit_event.wait(wait_for): break self._handle_event(STOPPED, None)
def run(self): for msg in persist(self.new.ws): if msg.name == "text": data = json.loads(msg.text) self.new.call({"type": data["type"], "data": data})
def constellation(token_info, f_refresh): ws = WebSocket('wss://constellation.mixer.com') ws.add_header(str.encode('authorization'), str.encode('Bearer {}'.format(token_info["access_token"]))) ws.add_header(str.encode('client-id'), str.encode(token_info["client_id"])) ws.add_header(str.encode('x-is-bot'), str.encode('true')) while 1: for event in persist(ws, ping_rate=30, poll=5, exit_event=f_refresh): if event.name == "ready": Method = { 'type': 'method', 'method': 'livesubscribe', 'params': { 'events': [ 'channel:{}:followed'.format( token_info["channel_id"]), 'channel:{}:hosted'.format( token_info["channel_id"]), 'channel:{}:subscribed'.format( token_info["channel_id"]), 'channel:{}:resubShared'.format( token_info["channel_id"]), # 'channel:{}:update'.format(token_info["channel_id"]), 'channel:{}:subscriptionGifted'.format( token_info["channel_id"]), 'channel:{}:skill'.format( token_info["channel_id"]), ] }, 'id': token_info["nonce"] } ws.send_json(Method) elif event.name == "text": print(event.json) if event.json['type'] == 'reply': print('The Server replies to you') if event.json['error'] != None: print('Something to see here') print(event.json['error']) sys.exit() elif event.json['id'] != token_info["nonce"]: print('Nonce Mismatch') sys.exit() if event.json['type'] == 'event': if event.json['event'] == 'hello': print(' The Server greets you back') elif event.json['event'] == 'live': print('Something happened') if event.json['data'][ 'channel'] == 'channel:{}:followed'.format( token_info["channel_id"]): if event.json['data']['payload'][ 'following'] == True: print('Someone is following you') username = event.json['data']['payload'][ 'user']['username'] print("Username: {}".format(username)) avatar_url = event.json['data']['payload'][ 'user']['avatarUrl'] sparks = event.json['data']['payload']['user'][ 'sparks'] print("Sparks: {}".format(sparks)) if event.json['data']['payload'][ 'following'] == False: print('Someone stopped following you') username = event.json['data']['payload'][ 'user']['username'] print(username) elif event.json['data'][ 'channel'] == 'channel:{}:hosted'.format( token_info["channel_id"]): print('Someone is hosting you') elif event.json['data'][ 'channel'] == 'channel:{}:subscribed'.format( token_info["channel_id"]): print('Someone has subscribed to you') elif event.json['data'][ 'channel'] == 'channel:{}:resubShared'.format( token_info["channel_id"]): print('Someone has resubscribed to you') elif event.json['data'][ 'channel'] == 'channel:{}:subscriptionGifted'.format( token_info["channel_id"]): print('Someone has gifted a subscription to you') elif event.json['data'][ 'channel'] == 'channel:{}:skill'.format( token_info["channel_id"]): print('Someone has used a skill on you') elif event.name == 'pong' or event.name == 'ping' or event.name == 'poll': continue else: continue print(event.name) if f_refresh.is_set(): print("Closing Websocket") ws.close() f_refresh.clear() continue
from lomond import WebSocket from lomond.persist import persist from cloud_service import CloudService from datetime import datetime from voice_codes_constants import * import simplejson as json from configuration_service import ConfigurationService from subprocess import Popen, PIPE import time import requests websocket = WebSocket('http://116.203.129.161:80/chat') cloud_service = CloudService() configuration_service = ConfigurationService.getInstance() for event in persist(websocket): if event.name == "ready": print("ready") elif event.name == "text": text = event.text print(text) if (text.startswith("__SPEAK__")): text = text.replace("__SPEAK__", "") parts = text.split("_#_#_") cloud_service.speak(parts[1], parts[0]) configuration_service.set_vision_language(parts[0], False) now = datetime.now() date_string = now.strftime("%d/%m/%Y %H:%M:%S") with open("remote_speech_log.txt", "a") as myfile: myfile.write(date_string + ": " + event.text + "\r\n") myfile.close()
import json import re from lomond.persist import persist from HQApi import HQApi, HQWebSocket bearer = "Bearer" api = HQApi(bearer) ws = HQWebSocket(api) websocket = ws.get() for msg in persist(websocket.connect): if msg.name == "text": data = json.loads(re.sub(r"[\x00-\x1f\x7f-\x9f]", "", msg.text)) if data["type"] != "interaction": print(str(data))
msgsec = 0.2 rsec = 5 instruments = json_data['instruments'] botname = json_data['botname'] version = json_data['version'] log = json_data['log'] trade = json_data['trade'] nonce = json_data['nonce'] json_file.close() print("T: " + str(int(round(time.time() * 1000))) + " - Configuration successfully read, starting strategy: " + botname + " " + version + "...") websocket = WebSocket(server) for event in persist(websocket, poll=msgsec): #### On Connect handler #### if event.name == "ready": print("T: " + str(int(round(time.time() * 1000))) + " - Bot Connecting....") datapool = {} websocket.send_json({"jsonrpc":"2.0","id":0,"method":"public/auth","params":{"grant_type":"client_credentials","client_id":user,"client_secret":password,"nonce": nonce}}) websocket.send_json({"jsonrpc":"2.0","id":1,"method":"public/disable_heartbeat","params":{}}) websocket.send_json({"jsonrpc":"2.0","id":2,"method":"public/hello","params":{"client_name":botname,"client_version":version}}) websocket.send_json({"jsonrpc":"2.0","method":"public/subscribe","id":3,"params":{"channels": ["platform_state"]}}) authend = time.time() poller = 0 botready = 0 logready = 0 logheader = 0