def __init__(self, url, key): print("Connecting to " + url) WebSocketClient.__init__(self, url) self._sending_lock = threading.RLock() self._send_next_bin = None self._key = key
def __init__(self, url, supported_protocols): WebSocketClient.__init__(self, url) self.supported_protocols = supported_protocols self.logger = logging.getLogger(__name__) self.handlers = {} self._weakref = weakref.ref(self)
def __init__(self, url, debug=False): WebSocketClient.__init__(self, url) EventEmitter.__init__(self) self.debug = debug self._session = None self._uniq_id = 0 self._callbacks = {}
def __init__(self, uri, decoder_pipeline, post_processor, full_post_processor=None): self.uri = uri self.decoder_pipeline = decoder_pipeline self.post_processor = post_processor self.full_post_processor = full_post_processor WebSocketClient.__init__(self, url=uri, heartbeat_freq=10) self.pipeline_initialized = False self.partial_transcript = "" if USE_NNET2: self.decoder_pipeline.set_result_handler(self._on_result) self.decoder_pipeline.set_full_result_handler(self._on_full_result) self.decoder_pipeline.set_error_handler(self._on_error) else: self.decoder_pipeline.set_word_handler(self._on_word) self.decoder_pipeline.set_error_handler(self._on_error) self.decoder_pipeline.set_eos_handler(self._on_eos) self.state = self.STATE_CREATED self.last_decoder_message = time.time() self.request_id = "<undefined>" self.timeout_decoder = 5 self.num_segments = 0 self.last_partial_result = "" self.post_processor_lock = threading.Lock() self.processing_condition = threading.Condition() self.num_processing_threads = 0
def __init__(self, url, defaultCallback): self.connected = False # check ws4py version env = pkg_resources.Environment() v = env['ws4py'][0].version.split(".") if (int(v[0]) * 100 + int(v[1]) * 10 + int(v[2])) < 35: raise RuntimeError("please use ws4py version 0.3.5 or higher") self.conUUid = uuid.uuid1() # make uuid for connection self.conUrl = ( url + "/websocket/data/" + str(self.conUUid.clock_seq_hi_variant) + "/" + str(self.conUUid) + "/websocket" ) self.defaultCallback = defaultCallback self.functionCallbacks = {} logging.info("initialized " + self.conUrl) try: WebSocketClient.__init__(self, self.conUrl) self.connect() self.connected = True logging.info("connected: " + str(self.connected)) threading.Thread(target=self.run_forever).start() except KeyboardInterrupt: self.disconnect() logging.error("KeyboardInterrupt") except Exception as e: self.disconnect() raise e
def __init__(self,token,most_recent=0,most_recent_callback=None): self.mostRecent = most_recent self.mostRecentUpdated = most_recent_callback or self.mostRecentUpdated self.lastPing = time.time() self.client = Client(token) self.devices = {} WebSocketClient.__init__(self,STREAM_BASE_URL.format(token))
def __init__(self, url, print_raw): WebSocketClient.__init__(self, url) self.print_raw = print_raw # We keep track of methods and subs that have been sent from the # client so that we only return to the prompt or quit the app # once we get back all the results from the server. # # `id` # # The operation id, informed by the client and returned by the # server to make sure both are talking about the same thing. # # `result_acked` # # Flag to make sure we were answered. # # `data_acked` # # Flag to make sure we received the correct data from the # message we were waiting for. self.pending_condition = threading.Condition() self.pending = {} self.brick = init_nxt() self.mrt, self.mlft, self.bm = init_drive_motors(self.brick) self.us = nxt.get_sensor(self.brick, nxt.PORT_4)
def __init__(self, url, config, statesworker): # init WS WebSocketClient.__init__(self, url) # variables self.__config = config self.__connected = False self.__run = True # recv sync self.recv_event_e.set() # actions map self.__actions = { codes.APP_NOT_EXIST: self.__act_retry_hs, codes.AGENT_UPDATE: self.__act_update, codes.RECIPE_DATA: self.__act_recipe, codes.WAIT_DATA: self.__act_wait, } # init self.__error_dir = self.__init_dir() self.__error_proc = self.__mount_proc() self.__update_ud() self.__config['init'] = self.__get_id() # states worker self.__states_worker = statesworker
def __init__(self, uri, decoder_pipeline, post_processor, full_post_processor=None): self.uri = uri self.decoder_pipeline = decoder_pipeline self.post_processor = post_processor self.full_post_processor = full_post_processor WebSocketClient.__init__(self, url=uri, heartbeat_freq=10) self.pipeline_initialized = False self.partial_transcript = "" if USE_NNET2: # for DecoderPipeline2 self.decoder_pipeline.set_result_handler(self._on_result) self.decoder_pipeline.set_full_result_handler(self._on_full_result) self.decoder_pipeline.set_error_handler(self._on_error) else: self.decoder_pipeline.set_word_handler(self._on_word) self.decoder_pipeline.set_error_handler(self._on_error) self.decoder_pipeline.set_eos_handler(self._on_eos) self.state = self.STATE_CREATED self.last_decoder_message = time.time() self.request_id = "<undefined>" self.timeout_decoder = 5 # not used? self.num_segments = 0 self.last_partial_result = "" self.post_processor_lock = tornado.locks.Lock() # lock for coroutines self.processing_condition = tornado.locks.Condition( ) # condition allows one or more coroutines to wait until notified self.num_processing_threads = 0
def __init__(self, token, most_recent=0, most_recent_callback=None): self.mostRecent = most_recent self.mostRecentUpdated = most_recent_callback or self.mostRecentUpdated self.lastPing = time.time() self.client = Client(token) self.devices = {} WebSocketClient.__init__(self, STREAM_BASE_URL.format(token))
def __init__(self, url, config, statesworker): # init WS WebSocketClient.__init__(self, url) # variables self.__config = config self.__connected = False self.__run = True # recv sync self.recv_event_e.set() # actions map self.__actions = { codes.APP_NOT_EXIST : self.__act_retry_hs, codes.AGENT_UPDATE : self.__act_update, codes.RECIPE_DATA : self.__act_recipe, codes.WAIT_DATA : self.__act_wait, } # init self.__error_dir = self.__init_dir() self.__error_proc = self.__mount_proc() self.__update_ud() self.__config['init'] = self.__get_id() # states worker self.__states_worker = statesworker
def __init__(self, host=_my_localhost, channel=None): """initialize a 'FireflyClient' object and build websocket. Parameters ---------- host : str Firefly host. channel : str WebSocket channel id. """ if host.startswith('http://'): host = host[7:] self.this_host = host url = 'ws://%s/firefly/sticky/firefly/events' % host # web socket url if channel: url += '?channelID=%s' % channel WebSocketClient.__init__(self, url) self.url_root = 'http://' + host + self._fftools_cmd self.url_bw = 'http://' + self.this_host + '/firefly/firefly.html;wsch=' self.listeners = {} self.channel = channel self.session = requests.Session() # print 'websocket url:%s' % url self.connect()
def connectDDP(self, timeout=3, isReconnect=False): if isReconnect: self._dbPrint("Attempting reconnect with timeout: %i seconds. . ." % timeout) self.close_connection() # try to free up some OS resources time.sleep(timeout) WebSocketClient.__init__(self, self.urlArg) else: self._dbPrint("Starting DDP connection. . .") try: self._attemptConnection() # except (DDPError, ConnectionRefusedError) as e: except Exception as e: self._dbPrint("ddpClient._attemptConnection() raised an exception:") print(e) timeoutExponent = 1.2 if not self.attemptReconnect: raise e self.connectDDP(isReconnect=True, timeout=timeout * timeoutExponent) else: if isReconnect: self._dbPrint("Reconnect successful!") [cb() for cb in self.reconnectCallbacks] self.run_forever() else: self._dbPrint("DDP connection established!")
def inner(self): while True: self.logger.info("Connecting ...") try: self.setup() self.connect() func(self) except KeyboardInterrupt: self.close() return except WebSocketException as e: self.logger.exception("WebSocketException") except ConnectionError as e: self.logger.error("Could not connect to server!") except Exception: self.logger.exception("Exception") finally: self.terminate_outgoing_thread() self.logger.info("Trying to reconnect in %d seconds (%d attempt) ..." % (self.reconnect_delay, self.reconnect_attempt)) time.sleep(self.reconnect_delay) if self.reconnect_delay < 120: self.reconnect_delay *= 2 self.reconnect_attempt += 1 WebSocketClient.__init__(self, self.url)
def __init__(self, url, debugPrint=False, printDDP=False, raiseDDPErrors=False, printDDPErrors=True, attemptReconnect=True): # Call the ws init functions self.urlArg = url WebSocketClient.__init__(self, url) self._dbPrint = Printer(debugPrint=debugPrint) self._printDDPError = Printer(debugPrint=printDDPErrors) self._printDDP = Printer(debugPrint=printDDP) # Record the outstanding method calls to link wrt requests self.requestsToTrack = [] self.requestReplies = {} self.subNameToID = {} # Place to collect collections self.collections = CollectionCollection() # Store the flags for what to do in various scenarios self.debugPrint = debugPrint self.raiseDDPErrors = raiseDDPErrors self.printDDP = printDDP self.printDDPErrors = printDDPErrors self.attemptReconnect = attemptReconnect self.closeCallbacks = [] self.reconnectCallbacks = [] # Set the connected flag to False self.DDP_Connected = False # Flag to see if we requested a close connection self.closeRequested = False
def __init__(self, url, defaultCallback): self.connected = False # check ws4py version env = pkg_resources.Environment() v = env['ws4py'][0].version.split(".") if (int(v[0]) * 100 + int(v[1]) * 10 + int(v[2])) < 35: raise RuntimeError("please use ws4py version 0.3.5 or higher") self.conUUid = uuid.uuid1() # make uuid for connection self.conUrl = (url + "/websocket/data/" + str(self.conUUid.clock_seq_hi_variant) + "/" + str(self.conUUid) + "/websocket") self.defaultCallback = defaultCallback self.functionCallbacks = {} logging.info("initialized " + self.conUrl) try: WebSocketClient.__init__(self, self.conUrl) self.connect() self.connected = True logging.info("connected: " + str(self.connected)) threading.Thread(target=self.run_forever).start() except KeyboardInterrupt: self.disconnect() logging.error("KeyboardInterrupt") except Exception as e: self.disconnect() raise e
def __init__(self, url, debug=False): self.debug = debug # by default socket connections don't timeout. this causes issues # where reconnects can get stuck # TODO: make this configurable? socket.setdefaulttimeout(10) WebSocketClient.__init__(self, url) EventEmitter.__init__(self)
def __init__(self, info, serveraddress='wss://broadcastlv.chat.bilibili.com/sub'): self.serveraddress = serveraddress WebSocketClient.__init__(self, serveraddress) DanmuWebSocket.event = event DanmuWebSocket.headerLength = 16 self.Info = info
def __init__(self, headers={}): if not _quiet: print("Connecting to " + _url) WebSocketClient.__init__(self, _url, headers=headers) self._ready_notify = threading.Condition() self._ready = False self._sending_lock = threading.RLock()
def reconnect(self): WebSocketClient.__init__(self, self.urlstring) self._connected = False self.connect() self.client_thread = threading.Thread(target=self.run_forever) self.client_thread.start() while not self._connected: time.sleep(0.1)
def __init__(self, webSocketDebuggerUrl, onload=None): WebSocketClient.__init__(self, webSocketDebuggerUrl) self.onload = onload self.pendingCallbacks = {} self.freeIds = [] self.connect()
def __init__(self, url, account, password, character, client_name="Python FChat Library"): WebSocketClient.__init__(self, url) self.account = account self.password = password self.character = character self.client_name = client_name self.reconnect_delay = 1 self.reconnect_attempt = 0
def __init__(self): ws_url = 'wss://stream.watsonplatform.net/speech-to-text/api/v1/recognize' self.listening = False try: WebSocketClient.__init__(self, ws_url, headers=[("X-Watson-Authorization-Token",auth_token)]) self.connect() except: print "Failed to open WebSocket."
def __init__(self, ri, trans_url): url = trans_url + '/websocket' if url[0:5] == "https": url = 'wss' + url[5:] else: url = 'ws' + url[4:] self.ri = ri self.url = url WebSocketClient.__init__(self, url)
def __init__(self, host='127.0.0.1', port=50637, endpoint='wsreload', protocols=None, extensions=None, default_query=None, open_query=None): WebSocketClient.__init__( self, 'ws://%s:%s/%s' % (host, port, endpoint), protocols, extensions) self.default_query = default_query self.open_query = open_query self.connect()
def __init__(self, url, headers, chunkIterator, responseQueue, contentType, config): self.chunkIterator = chunkIterator self.responseQueue = responseQueue self.contentType = contentType self.listeningMessages = 0 self.config = config WebSocketClient.__init__(self, url, headers=headers.items()) logger.debug("IBM initialized")
def __init__(self, botfriend, botfriendData, *args, **kwargs): self.botfriend = botfriend self.botfriendData = BotfriendData self.args = args self.kwargs = kwargs self.url = self.botfriendData.serverURL WebSocketClient.__init__(self, self.url, *args, **kwargs)
def __init__(self, ri, trans_url): url = trans_url + '/websocket' if url[0:5] == "https": url = 'wss' + url[5:] else: url = 'ws' + url[4:] self.ri = ri self.url = url WebSocketClient.__init__(self,url)
def __init__(self, url): if ssl: WebSocketClient.__init__( self, url, ssl_options={'ssl_version': ssl.PROTOCOL_TLSv1}) else: WebSocketClient.__init__(self, url) self.data = [] self.partialdata = [] self.partialdatanumber = 1
def __init__(self, url, protocols=None, version='13'): sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM, 0) ThreadedClient.__init__(self, url, protocols=protocols, version=version, sock=sock) self._lock = Semaphore() self._th = Greenlet(self._receive) self._messages = Queue() self.extensions = []
def __init__(self, url, protocols=None, version='8'): sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM, 0) ThreadedClient.__init__(self, url, protocols=protocols, version=version, sock=sock) self._lock = Semaphore() self._th = Greenlet(self._receive) self._messages = Queue() self.extensions = []
def __init__(self, hostname, router): #it needs to be imported here because on the main body 'printer' is None from octoprint.server import printer self._router = router self._printer = printer self._printerListener = None self._subscribers = 0 WebSocketClient.__init__(self, hostname)
def __init__(self, address_port): WebSocketClient.__init__(self, address_port) self.robot_position_x = None self.robot_position_y = None self.waypoint_coordinates_x = None self.waypoint_coordinates_y = None self.coordinates_message_received = False self.move_to_waypoint_when_coordinates_received = False self.navigation_finished = False self.navigation_succeeded = False
def __init__(self): ws_url = "wss://stream.watsonplatform.net/speech-to-text/api/v1/recognize" environment = getEnv() base64string = base64.encodestring(environment).replace("\n", "") self.listening = False try: WebSocketClient.__init__(self, ws_url, headers=[("Authorization", "Basic %s" % base64string)]) self.connect() except: print "Failed to open WebSocket."
def __init__(self, url, protocols=['https-only'], extensions=None, ssl_options=None, headers=None, start_reqid=1): WebSocketClient.__init__(self, url, protocols, extensions, ssl_options=ssl_options, headers=headers) self.open_done = threading.Event() self.rid_lock = threading.RLock() self.msglock = threading.RLock() self.messages = {} self._cur_request_id = start_reqid
def __init__(self, mode): print "--------------", mode self.mode = mode self.point = mode % 20 self.proxyId = "vote-" + ("%d" % (self.point)) self.name = u"心電計-" + ("%d" % (self.point)) self.xurl = _Url + self.proxyId print(_Url) WebSocketClient.__init__(self, self.xurl, protocols=['http-only', 'chat'])
def __init__(self, ip="127.0.0.1", port=9090): """Constructor. Warning: there is a know issue regarding resolving localhost to IPv6 address. Args: ip (str, optional): Rosbridge instance IPv4/Host address. Defaults to 'localhost'. port (int, optional): Rosbridge instance listening port number. Defaults to 9090. """ ExecutorBase.__init__(self, ip=ip, port=port) ThreadedWebSocketClient.__init__(self, self._uri)
def __init__(self): username = "******" password = "******" ws_url = "wss://stream.watsonplatform.net/speech-to-text/api/v1/recognize" auth_string = "%s:%s" % (username, password) base64string = base64.encodestring(auth_string).replace("\n", "") self.listening = False try: WebSocketClient.__init__(self, ws_url,headers=[("Authorization", "Basic %s" % base64string)]) self.connect() except: print "Failed to open WebSocket."
def __init__(self): ws_url = 'wss://stream.watsonplatform.net/speech-to-text/api/v1/recognize' self.listening = False try: WebSocketClient.__init__(self, ws_url, headers=[("X-Watson-Authorization-Token", auth_token)]) self.connect() except: print "Failed to open WebSocket."
def __init__(self, url, key): print("Connecting to " + url) WebSocketClient.__init__(self, url) self._sending_lock = threading.RLock() self._send_next_bin = None self._key = key self._last_keepalive_reply = time.time() self._last_activity = time.time() threading.Timer(30, self.check_keepalives).start()
def __init__(self, hostname, router): #it needs to be imported here because on the main body 'printer' is None from octoprint.server import printer self._router = router self._printer = printer self._printerListener = None self._subscribers = 0 self._cameraManager = cameraManager() self._logger = logging.getLogger(__name__) WebSocketClient.__init__(self, hostname)
def __init__(self, url, on_open=None, on_close=None, on_message=None, on_error=None, **kwargs): self.callbacks = dict(on_open=on_open, on_close=on_close, on_message=on_message, on_error=on_error) WS4PyWebSocketClient.__init__(self, url, **kwargs)
def __init__(self, socket_address): WebSocketClient.__init__(self, socket_address) self.create_time = datetime.datetime.now() self.__update_task__ = None self.__manage_connection_task__ = None self.last_message_received_time = None self.is_connected = False self.is_connecting = False self.connect() self.hb = ws4py.websocket.Heartbeat(self) self.hb.start()
def __init__(self, watsonSTTUsername, watsonSTTPassword, rate=16000, bits=16, buflen=1024, model="en-US_BroadbandModel", timeout=-1, audioFilename=None, progressPipe=None): # Store parameters to instance vars self.rate = rate self.bits = bits self.buflen = buflen self.model = model # default is en-US_BroadbandModel self.audioFilename = os.path.splitext( audioFilename) if audioFilename else None self.timeout = timeout # Will cause self.progressPipe = progressPipe # Handles self.arecordproc = None self.audioF = None # state variables self.listening = False self.suspended = False self.info("WatsonSTTWebSocketClient VERSION {0}".format( WatsonSTTWebSocketClient_VERSION)) try: ws_url = WatsonSTTWebSocketClient_URL if self.model: ws_url = ws_url + ("?model={0}".format(self.model)) # Make the basic authentication header string import base64 authString = "%s:%s" % (watsonSTTUsername, watsonSTTPassword) base64Auth = base64.encodestring(authString).replace("\n", "") self.info("Init WebSocketClient to {0} with {1}".format( ws_url, authString)) WebSocketClient.__init__(self, ws_url, headers=[("Authorization", "Basic %s" % base64Auth), ("model", self.model)]) self.connect() except: self.info("Failed to open WebSocketClient.") raise
def _send(self, request): with self._connection_cv: if not self._connected: # Clear any previous error state before attempting to # reconnect. self._error = None WebSocketClient.__init__(self, self._endpoint, heartbeat_freq=None) self.connect() while not self._connected and not self._error: self._connection_cv.wait() if not self._connected: raise self._error self.send(json.dumps(request))
def __init__(self, host=myLocalhost, channel=None): if host.startswith("http://"): host = host[7:] self.thisHost = host url = "ws://%s/fftools/sticky/firefly/events" % host # web socket url if channel: url += "?channelID=%s" % channel WebSocketClient.__init__(self, url) self.urlRoot = "http://" + host + self.fftoolsCmd self.urlBW = "http://" + self.thisHost + "/fftools/app.html?id=Loader&channelID=" self.listeners = {} self.channel = channel self.session = requests.Session() self.connect()
def __init__(self): username = os.environ['WTTSusername'] password = os.environ['WTTSpassword'] ws_url = os.environ['WTTSurl'] auth_string = "%s:%s" % (username, password) base64string = base64.encodestring(auth_string).replace("\n", "") self.listening = False print "def_init_(self), self.listening = False" try: WebSocketClient.__init__(self, ws_url, headers=[("Authorization", "Basic %s" % base64string)]) self.connect() print "self.connect()" except: print "Failed to open WebSocket."
def __init__(self, serverUrl, protocols, connectionEstablishedHandler, dataReceivedEventHandler): ''' Initializes the state of the client. Keyword arguments: serverURL -- the URL of the websocket server. protocols -- a list containing the websocket protocols supported by the websockets client. connectionEstablishedHandler -- a function that will be invoked after establishing the websocket connection. dataReceivedHandler -- a function that will be invoked after receiving data from the websocket. ''' WebSocketClient.__init__(self, serverUrl, protocols) self.__logger = LogFactory.configureLogger(self, logging.INFO, LogFactory.DEFAULT_LOG_FILE) self.__connectionEstablishedHandler = connectionEstablishedHandler self.__dataReceivedEventHandler = dataReceivedEventHandler
def __init__(self, manager, server, port=80): url = self.WS_URL.format(server, str(port)) WebSocketClient.__init__(self, url) self.connected = False self.subs = {} self.collections = {} self.pending_msg = [] self.completed_msg = [] self.current_errors = [] self.logged_in = False self.manager = manager self.dispatcher = {"added": self.on_added, "error": self.on_error, "result": self.on_result, "changed": self.on_changed, "ready": self.on_ready}
def __init__(self, host=myLocalhost, channel=None): if host.startswith('http://'): host = host[7:] self.thisHost = host url = 'ws://%s/fftools/sticky/firefly/events' % host #web socket url if channel: url+= '?channelID=%s' % channel WebSocketClient.__init__(self, url) self.urlRoot = 'http://' + host + self.fftoolsCmd self.urlBW = 'http://' + self.thisHost + '/fftools/app.html?id=Loader&channelID=' self.listeners = {} self.channel = channel self.session = requests.Session() print 'websocket url:%s' % url self.connect()
def __init__(self, token, endpoint=constants.DEFAULT_STREAM_ENDPOINT, timeout=constants.DEFAULT_TIMEOUT): ws_endpoint = '{0}/{1}'.format( endpoint.replace('http', 'ws', 1), WebSocketTransport._SIGNALFLOW_WEBSOCKET_ENDPOINT) transport._SignalFlowTransport.__init__(self, token, ws_endpoint, timeout) WebSocketClient.__init__(self, self._endpoint, heartbeat_freq=None) self._server_time = None self._connected = False self._error = None self._connection_cv = threading.Condition() self._channels = {}
def __init__(self, url, debugPrint = False, raiseErrors = False, printErrors = True): WebSocketClient.__init__(self, url) self.debugPrint = debugPrint self.outstandingRequests = {} self.subNameToID = {} # Place to collect collections self.collections = CollectionCollection() self.raiseErrors = raiseErrors self.printErrors = printErrors self.DDP_Connected = False self.nrecieved = 0