def start(klass, address, pdid, realm='paradrop', start_reactor=False, debug=False, extra=None, reconnect=True): ''' Creates a new instance of this session and attaches it to the router at the given address and realm. reconnect: The session will attempt to reconnect on connection failure and continue trying indefinitely. ''' # Enable log messages of autobahn for debugging #import txaio #txaio.start_logging() dee = Deferred() component_config = ComponentConfig(realm=u''+realm, extra=u''+pdid) session_factory = BaseSessionFactory(config=component_config, deferred=dee) session_factory.session = klass transport_factory = BaseClientFactory(session_factory, url=address) if not reconnect: transport_factory.maxRetries = 0 transport_factory.setProtocolOptions(autoPingInterval=8., autoPingTimeout=4.,) context_factory = ClientContextFactory() websocket.connectWS(transport_factory, context_factory) if start_reactor: reactor.run() return dee
def main(): global command_library command_library = CommandLibrary() address = "ws://" + 'localhost' keyboard = Keyboard_Input() stdio.StandardIO(keyboard) multicast = reactor.listenMulticast(udpbport, MulticastProtocol(), listenMultiple=True) factory = WebSocketClientFactory(address + ":8084", debug = False) factory.setProtocolOptions(failByDrop=False) factory.protocol = MyClientProtocol #command_library.request_active_xtsm() try: connectWS(factory) command_library.factory = factory command_library.multicast = multicast factory.command_library = command_library print "........................WS Server Running......................." except twisted.internet.error.CannotListenError: print "Can't listen" #server_shutdown() global tcp tcp = PXI_Emulator_TCP() reactor.run()
def connect(self,addr): """connects to target server""" if self.client is not None: if self.client.did_handshake: raise UsageError("Already Connected!") try: self.factory=P22PClientFactory(self,addr) if self.factory.isSecure and (ssl is not None): context=ssl.ClientContextFactory() else: context=None #self.reactor.connectTCP(ip,port,self.factory,timeout=10) websocket.connectWS(self.factory,context,timeout=10) while self.client is None: #wait for self.client to be set pass if self.client is False: self.client=None raise ConnectionError("Cant connect to Server!") while not self.client.did_handshake: pass except: self.factory=None self.client=None raise
def connect(self, host, port): """ Make a connection to a server. """ url = 'ws://{0}:{1}/'.format(host, port) log.msg('pubsubclub: Connecting to %s' % url) websocket.connectWS(self.factory(url))
def StartPiCalcClient(echo_server_url, echo_server_port, picalcname="Raspi", debug=False): if debug: log.startLogging(sys.stdout) headers = {"PiClient": picalcname} factory = PiWebSocketFactory(u"ws://{}:{}/ws_pi?pi".format(echo_server_url, echo_server_port), headers=headers) connectWS(factory) reactor.run()
def agarWS(data, game): iphost, token = data.split() ip, port = iphost.split(':') port = int(port) factory = AgarClientFactory("ws://%s:%d" % (ip, port), headers={'Origin':'http://agar.io'}) factory.token = token factory.game = game connectWS(factory)
def connectDc(self, ws): self.log.info("the websocket address is %s" % ws) from autobahn.twisted.websocket import connectWS wsFactory = WsFactory(ws, self) self.f = wsFactory wsFactory.setProtocolOptions( perMessageCompressionOffers=None, perMessageCompressionAccept=None) connectWS(wsFactory)
def remove_client(self, ws_client): """Remove a websocket connection from the client registry""" processor = self._ws_clients.pop(ws_client, None) if not processor: # Possible failed connection, if we have waiting processors still # then try a new connection if len(self._connect_waiters): connectWS(self._factory, contextFactory=self._factory_context) return
def speech_to_text_ibm(file_path): # add audio files to the processing queue q = Queue.Queue() q.put((1,file_path)) hostname = "stream.watsonplatform.net" headers = {} credentials = ['c224d410-abd8-4783-97a7-02ff3feb6d3c','sVDa2MAL4gQU'] model = 'en-US_NarrowbandModel' contentType = 'audio/wav' threads = '10' # authentication header string = credentials[0] + ":" + credentials[1] headers["Authorization"] = "Basic " + base64.b64encode(string) # create a WS server factory with our protocol url = "wss://" + hostname + "/speech-to-text/api/v1/recognize?model=" + model summary = {} factory = WSInterfaceFactory(q, summary, contentType, model, url, headers, debug=False) factory.protocol = WSInterfaceProtocol print 'Transcribing...' for i in range(min(int(threads),q.qsize())): factory.prepareUtterance() # SSL client context: default if factory.isSecure: contextFactory = ssl.ClientContextFactory() else: contextFactory = None connectWS(factory, contextFactory) reactor.run() return summary[1]['hypothesis'] # Testing response time between services # from timeit import default_timer as timer # file_path = './converted/13635218_10209465570533683_1943824153_n.wav' # start = timer() # print speech_to_text_offline(file_path) # end = timer() # print('Offlines: ', end-start) # start = timer() # print speech_to_text_ibm_rest(file_path) # end = timer() # print('IBM: ', end-start) # start = timer() # print speech_to_text_google(file_path) # end = timer() # print('Google: ', end-start)
def gen_coinbase_source(): ret = CoinbaseSource() factory = WebSocketClientFactory("wss://ws-feed.exchange.coinbase.com") factory.queue = ret.queue factory.close_cb = reactor.stop factory.protocol = ExchangeProtocol connectWS(factory) Thread(target=reactor.run, args=(False,)).start() return ret
def connect(self): print "WEBSOCKET connecting", self.isSecure ## SSL client context: default ## if self.isSecure: contextFactory = ssl.ClientContextFactory() else: contextFactory = None connectWS(self, contextFactory)
def _create_websocket(self, queue, access_token, host): headers = { AUTHORIZATION: TOKEN % access_token } self.ws = WebSocketClientFactory(daemo.WEBSOCKET + host + daemo.WS_BOT_SUBSCRIBE_URL, headers=headers) self.ws.protocol = ClientProtocol self.ws.queue = queue connectWS(self.ws) reactor.run()
def connect(self): self.factory = PlywoodWebSocketClientFactory("ws://0.0.0.0:17998", debug = False, debugWamp = False) self.factory.protocol = PlywoodWebSocketClientProtocol self.factory.base_client = self connectWS(self.factory) self.reactor_thread = threading.Thread(target=reactor.run, args=(False,)) self.reactor_thread.daemon = True self.reactor_thread.start()
def __init__(self, app_key): self.app_key = app_key self.events = {} self.channels = {} self.factory = WebSocketClientFactory("ws://ws.pusherapp.com:80/app/%s?client=python-twisted?version=1.0&protocol=4" % app_key) self.factory.protocol = PusherProtocol self.factory.singleton = None self.factory.pusher = self self.on("pusher:ping", self.on_ping) connectWS(self.factory)
def setup_websocket(self): try: factory = WebSocketClientFactory("wss://ws-feed.exchange.coinbase.com") ClientProtocol.handler = self.handler factory.protocol = ClientProtocol connectWS(factory) reactor.run() except KeyboardInterrupt: factory.close() self.handler.close_client()
def start(klass, pdid, address=None, realm='crossbardemo', extra=None, start_reactor=False, debug=False, retry=True): ''' Creates a new instance of this session and attaches it to the router at the given address and realm. The pdid is set manually now since we trust clients. Excessively. For now the realm is automatically set as a demo realm since we are not using multiple realms. Optional values that can be passed through extra: authid: ID to use for authentication (login or key checking). This can be used when setting pdid to be a subdomain of one's domain. For example, the user "pd.damouse" can connect to the fabric as pdid="pd.damouse.aardvark" by supplying his credentials for authid="pd.damouse". ''' if not address: address = FABRIC_URL # Configuration if extra is None: extra = {} else: extra = dict.copy(extra) extra['pdid'] = u'' + pdid dee = Deferred() component_config = ComponentConfig(realm=pdid, extra=extra) session_factory = FabricSessionFactory(config=component_config, deferred=dee) session_factory.session = klass transport_factory = FabricClientFactory(session_factory, debug=debug, debug_wamp=debug) if not retry: transport_factory.maxRetries = 0 uri = urlparse.urlparse(address) transport_factory.host = uri.hostname transport_factory.port = uri.port transport_factory.isSecure = (uri.scheme == 'wss') context_factory = ClientContextFactory() websocket.connectWS(transport_factory, context_factory) if start_reactor: reactor.run() return dee
def start(self): ## the directory watcher ## self.watcher = DirWatcher(dir = self.directory) ## start directory watcher on _background_ thread ## reactor.callInThread(self.watcher.loop, self.onDirEvent) ## start WAMP client (on main reactor thread) ## self.client = DirWatchClientFactory(self) connectWS(self.client)
def _connect(self): if self.token is None or self.token == '': raise LoginError('Invalid token, try using fetch_token first.') if self._protocol: return defer.succeed(self._protocol) d = defer.Deferred() self.factory = DiscordClientFactory(self._gateway, token=self.token, deferred=d, reactor=self.reactor) websocket.connectWS(self.factory) d.addCallback(self.set_protocol) return d
def connect(uri): """ Constructs a MessageTestFactory, connects to the desired WebSocket endpoint URI, waits for the MessageTestProtocol to be constructed, and then returns the protocol instance. """ factory = MessageTestFactory(uri) factory.setProtocolOptions(failByDrop=False, openHandshakeTimeout=1) ws.connectWS(factory, timeout=1) protocol = pytest.blockon(factory.connected) pytest.blockon(protocol.opened) return protocol
def StreamPiData(echo_server_url='localhost', echo_server_port=8081, customcallback=None, statsonly=False): """ Connect to the Echo server to stream the digits of pi :param echo_server_url: 127.0.0.1 :param echo_server_port: 9000 :return:none """ url = "ws://{}:{}/ws_pi?pi".format(echo_server_url, echo_server_port) print "connecting to {}".format(url) client = ShowPiStreamFactory(url) client.protocol.showpi = not statsonly connectWS(client) client.protocol.customCalback = customcallback reactor.run()
def connectBunch(self): if self.currentCnt + self.batchsize < self.targetCnt: c = self.batchsize redo = True else: c = self.targetCnt - self.currentCnt redo = False for i in xrange(0, c): factory = MassConnectFactory(self.uri) factory.test = self factory.retrydelay = self.retrydelay connectWS(factory) self.currentCnt += 1 if redo: reactor.callLater(float(self.batchdelay)/1000., self.connectBunch)
def _stream(self): # pragma: no cover """Runs in a sub-process to perform stream consumption""" self.factory.protocol = LiveStream self.factory.datasift = { 'on_open': self._on_open, 'on_close': self._on_close, 'on_message': self._on_message, 'send_message': None } if self.config.ssl: from datasift.twisted_ssl import ClientContextFactory connectWS(self.factory, contextFactory=ClientContextFactory()) else: connectWS(self.factory) reactor.run()
def RegisterWampClient(wampconf): WSClientConf = LoadWampClientConf(wampconf) ## start logging to console # log.startLogging(sys.stdout) # create a WAMP application session factory component_config = types.ComponentConfig( realm = WSClientConf["realm"], extra = {"ID":WSClientConf["ID"]}) session_factory = wamp.ApplicationSessionFactory( config = component_config) session_factory.session = WampSession # create a WAMP-over-WebSocket transport client factory transport_factory = ReconnectingWampWebSocketClientFactory( session_factory, url = WSClientConf["url"], serializers = [MsgPackSerializer()], debug = False, debug_wamp = False) # start the client from a Twisted endpoint conn = connectWS(transport_factory) print "WAMP client connecting to :",WSClientConf["url"] return conn
def connect(self): """Connect the client factory to the WebSocket server Returns: An instance of twisted.internet.interfaces.IConnector """ return connectWS(self)
def RegisterWampClient(): ## start logging to console # log.startLogging(sys.stdout) # create a WAMP application session factory component_config = types.ComponentConfig( realm = realm, extra = {"ID":ID}) session_factory = wamp.ApplicationSessionFactory( config = component_config) session_factory.session = WampSession # create a WAMP-over-WebSocket transport client factory transport_factory = WampWebSocketClientFactory( session_factory, url = url, serializers = [MsgPackSerializer()], debug = False, debug_wamp = False) # start the client from a Twisted endpoint conn = connectWS(transport_factory) confnodesroot.logger.write(_("WAMP connecting to URL : %s\n")%url) return conn
def quote_stream(account, venue, protocol, debug=False): url = 'wss://api.stockfighter.io/ob/api/ws/%(account)s/venues/%(venue)s/tickertape' % locals() log.startLogging(sys.stdout) factory = WebSocketClientFactory(url, debug=debug) factory.protocol = protocol # SSL client context: default ## if factory.isSecure: contextFactory = ssl.ClientContextFactory() else: contextFactory = None connectWS(factory, contextFactory) reactor.run()
def onTicker(self, data): """ Called upon reception of the initial 'ticker' data, triggers WebSocket market data subscription """ self.log('onTicker, data[{0}'.format(data)) ticker = json.loads(data) self.log('received ticker from exchange {0}'.format(data)) price = ticker.get("price", None) if price is None: self.fatal("could not retrieve price") self.basePrice = Decimal(price) self.log('retrieved base price for {0}: {1}'.format(self.product, self.basePrice)) self.log('starting websocket connection') factory = WebSocketClientFactory(self.wsAddress) factory.protocol = CoinbaseWebSocketClient factory.coinbaseClient = self connectWS(factory)
def _connectClient(self, connected, opened, clientDisconnected): factory = WampClientFactory('ws://localhost:9000', debugWamp=True) factory.protocol = ClientProtocol factory.onConnectionMade = connected factory.onSessionOpen = opened factory.onConnectionLost = clientDisconnected self.factory = factory return connectWS(factory)
def run(self): """ run the server up if foreground or background mode """ server_url = "wss://%s:%d/ws" % (conf.HOST, conf.PORT) log.msg("Server>", server_url) transport = ComponentFactory(self.factory, server_url, debug=conf.DEBUG, debugCodePaths=conf.DEBUG) transport.setProtocolOptions(acceptMaskedServerFrames=True) websocket.connectWS(transport) if not self.isBackground: reactor.run() exit(0) # # In background mode we return here and twistd picks up the slack # application = service.Application(conf.APP_NAME) logfile = DailyLogFile(conf.LOGFILE, conf.LOGPATH) application.setComponent(ILogObserver, FileLogObserver(logfile).emit) return application
def operate_conn(serverAddr,pipe=None): ''' operate the conmunicate with server ''' globals()['PIPE'] = pipe # change the global variable PIPE print 'pipe is ',pipe if pipe : print 'monitor start' monitor = Thread(target = handlerMessage) monitor.daemon = True monitor.start() facotry = MyWebSocketClientFactory(serverAddr) facotry.protocol = ProbeWebsocketClientProtocol connectWS(facotry) arpUpdate() reactor.run()
def connect(self): """Establish WebSocket connection to the ROS server defined for this factory.""" self.connector = connectWS(self)
def connectCy(self, ws): self.log.info("the websocket address is %s" % ws) from autobahn.twisted.websocket import connectWS wsFactory = WsFactory(ws, self) self.f = wsFactory connectWS(wsFactory)
def connect(self): self.daemon = True connectWS(self.factory) self.start()
def get_text(audio_path, proxy): # parse command line parameters parser = argparse.ArgumentParser( description=('client to do speech recognition using the WebSocket ' 'interface to the Watson STT service')) parser.add_argument( '-type', action='store', dest='contentType', default='audio/mp3', help='audio content type, for example: \'audio/l16; rate=44100\'') # parser.add_argument( # '-model', action='store', dest='model', default='en-US_BroadbandModel', # help='STT model that will be used') parser.add_argument('-model', action='store', dest='model', default='ar-AR_BroadbandModel', help='STT model that will be used') parser.add_argument( '-amcustom', action='store', dest='am_custom_id', default=None, help='id of the acoustic model customization that will be used', required=False) parser.add_argument( '-lmcustom', action='store', dest='lm_custom_id', default=None, help='id of the language model customization that will be used', required=False) parser.add_argument('-threads', action='store', dest='threads', default='1', help='number of simultaneous STT sessions', type=check_positive_int) parser.add_argument( '-optout', action='store_true', dest='optOut', help=('specify opt-out header so user data, such as speech and ' 'hypotheses are not logged into the server')) parser.add_argument('-tokenauth', action='store_true', dest='tokenauth', help='use token based authentication') args = parser.parse_args() # logging log.startLogging(sys.stdout) # add audio files to the processing queue q = Queue.Queue() # fileName = '/Users/qiyue/myxuni/pngtree/speech_audio/3min/9647730104474_5b44b3a2ddd8e328.mp3' # j将任务加入队列 q.put((0, audio_path)) hostname = "stream.watsonplatform.net" headers = {'X-WDC-PL-OPT-OUT': '1'} if args.optOut else {} '''获取token''' token = Utils.getAuthenticationToken(proxy) if token: headers['X-Watson-Authorization-Token'] = token else: return False # create a WS server factory with our protocol fmt = "wss://{}/speech-to-text/api/v1/recognize?model={}" url = fmt.format(hostname, args.model) if args.am_custom_id != None: url += "&acoustic_customization_id=" + args.am_custom_id if args.lm_custom_id != None: url += "&customization_id=" + args.lm_custom_id summary = {} factory = WSInterfaceFactory(q, summary, args.contentType, args.model, url, headers, debug=False) factory.protocol = WSInterfaceProtocol for i in range(min(int(args.threads), q.qsize())): factory.prepareUtterance() # SSL client context: default if factory.isSecure: contextFactory = ssl.ClientContextFactory() else: contextFactory = None connectWS(factory, contextFactory) reactor.run() # dump the hypotheses to the output file for key, value in enumerate(sorted(summary.items())): value = value[1] print(type(value['hypothesis'])) try: text = value['hypothesis'].decode('unicode_escape')[:-1] # text = value['hypothesis'].encode('utf-8')[:-1] except UnicodeDecodeError: text = value['hypothesis'].encode('utf-8')[:-1] print('decode unicode faild....') except Exception as e: print('encode utf8 faild....') print(str(e)) text = value['hypothesis'][:-1] # if value['status']['code'] == 1000: # print('{}: {} {}'.format(key, value['status']['code'], # value['hypothesis'].encode('utf-8'))) # else: # fmt = '{}: {status[code]} REASON: {status[reason]}' # print(fmt.format(key, **status)) print(text) return text
def run(self): self.result.started = perf_counter() self.result.log.append( (self.result.started, None, None, "Test started.")) self.clients = [] peersready = [] peersgone = [] i = 1 for peerIndex in xrange(len(self.params.peers)): ready = Deferred() gone = Deferred() client = WampCase2_2_x_x_Factory(self, peerIndex, ready, gone) self.clients.append(client) peersready.append(ready) peersgone.append(gone) connectWS(client) i += 1 def shutdown(): for c in self.clients: c.proto.sendClose() self.result.log.append( (perf_counter(), c.peerIndex, c.proto.session_id, "Test client closing ...")) def test(): for c in self.clients: self.result.expected[c.proto.session_id] = [] self.result.observed[c.proto.session_id] = [] publisherPeerIndex = 0 publisher = self.clients[publisherPeerIndex] publisherSessionId = publisher.proto.session_id topic = self.params.publicationTopic + self._uriSuffix payloads = self.params.eventPayloads expectedReceivers = [ self.clients[i] for i in self.params.expectedReceivers ] for r in expectedReceivers: for p in payloads: self.result.expected[r.proto.session_id].append((topic, p)) args = {} if self.params.excludeMe is not None: args['excludeMe'] = self.params.excludeMe if self.params.exclude is not None: ## map exclude indices to session IDs args['exclude'] = [] for i in self.params.exclude: args['exclude'].append(self.clients[i].proto.session_id) if self.params.eligible is not None: ## map exclude indices to session IDs args['eligible'] = [] for i in self.params.eligible: args['eligible'].append(self.clients[i].proto.session_id) d_pl = [] for pl in payloads: if self.params.publicationMethod == 0: ## publish using standard WAMP event publication ## publisher.proto.publish(topic, pl, **args) elif self.params.publicationMethod == 1: ## publish indirectly by instructing the peer to ## dispatch an event ## args['me'] = publisherSessionId ENDPOINT = "http://api.testsuite.wamp.ws/testee/control#dispatch" #ENDPOINT = "http://api.testsuite.wamp.ws/autobahn/testee/control#dispatch" cd = publisher.proto.call(ENDPOINT, topic, pl, args) del args['me'] # don't show this in test log d_pl.append(cd) else: raise Exception("no such publication method: %s" % self.params.publicationMethod) s_args = ["%s=%s" % (k, v) for (k, v) in args.items()] if len(s_args) > 0: s_args = 'with options <pre>%s</pre> ' % ', '.join(s_args) else: s_args = '' if self.params.publicationMethod == 0: msg = "Published event to topic <pre>%s</pre> %sand payload <pre>%s</pre>" % ( topic, s_args, pl) elif self.params.publicationMethod == 1: msg = "Initiated server dispatched event to topic <pre>%s</pre> %sand payload <pre>%s</pre>" % ( topic, s_args, pl) else: msg = "" self.result.log.append((perf_counter(), publisherPeerIndex, publisher.proto.session_id, msg)) ## After having published everything the test had specified, ## we need to _wait_ to receive events on all our WAMP sessions ## to compare with our expectation. By default, we wait 3x the ## specified/default RTT. ## wait = 1.5 * self._rtt def afterwait(): self.result.log.append( (perf_counter(), None, None, "Continuing test ..")) shutdown() def beforewait(): self.result.log.append( (perf_counter(), None, None, "Sleeping for <strong>%s ms</strong> ..." % (1000. * wait))) reactor.callLater(wait, afterwait) if self.params.publicationMethod == 1 and len(d_pl) > 0: d = DeferredList(d_pl) def onres(res): self.result.log.append( (perf_counter(), None, None, "Event init call result: %s" % res)) beforewait() d.addCallback(onres) else: #reactor.callLater(0, beforewait) beforewait() def launch(_): ## After all our clients have signaled "peersready", these ## clients will just have sent their subscribe WAMP messages, ## and since with WAMPv1, there is no reply (to wait on), the ## clients immediately signal readiness and we need to _wait_ ## here to give the testee time to receive and actually subscribe ## the clients. When we don't wait, we might publish test events ## before the testee has subscribed all clients as needed. ## We need acknowledgement of subscribe for WAMPv2! ## wait = 2.5 * self._rtt def afterwait(): self.result.log.append( (perf_counter(), None, None, "Continuing test ..")) test() self.result.log.append( (perf_counter(), None, None, "Sleeping for <strong>%s ms</strong> ..." % (1000. * wait))) def beforewait(): reactor.callLater(wait, afterwait) reactor.callLater(0, beforewait) def error(err): ## FIXME print "ERROR", err shutdown() self.finished.errback(err) def done(res): self.result.ended = perf_counter() self.result.log.append( (self.result.ended, None, None, "Test ended.")) clientErrors = [] for r in res: if not r[0]: clientErrors.append(str(r[1].value)) if len(clientErrors) > 0: passed = False print "Client errors", clientErrors else: passed = json.dumps(self.result.observed) == json.dumps( self.result.expected) if False and not passed: print print "EXPECTED" print self.result.expected print "OBSERVED" print self.result.observed print self.result.passed = passed self.finished.callback(self.result) DeferredList(peersready).addCallbacks(launch, error) DeferredList(peersgone).addCallbacks(done, error) self.finished = Deferred() return self.finished
def recognize( self, file_input=None, dir_output=None, threads=None, log_type=None, content_type=None, #required interim_results=None, model=None, customization_id=None, inactivity_timeout=None, keywords=None, keywords_threshold=None, max_alternatives=None, word_alternatives_threshold=None, word_confidence=None, timestamps=None, profanity_filter=None, smart_formatting=None, speaker_labels=None): #validate list of file paths if isinstance(file_input, str): if os.path.isfile(file_input): file_input = [file_input] elif isinstance(file_input, list) and all( isinstance(item, str) for item in file_input): if all(os.path.isfile(item) for item in file_input): pass else: raise TypeError( "'file_input' requires a list of audio file paths in the form of ['my/path/audio1.wav', 'my/path/audio2.wav', 'my/path/audio3.wav']" ) if model is None: model = 'en-US_BroadbandModel' if threads is None: threads = 1 #set default logging to stdout, unless an output directory is specified if log_type is None: if dir_output is None: log_type = 'stdout' else: log_type = 'file' #set default output path to current working directory #i.e. directory in which interpreter was started if dir_output is None: dir_output = os.getcwd() print("Saving output to current working directory {0}".format( dir_output)) dir_output = os.getcwd() authstring = "{0}:{1}".format(self.username, self.password) encoded_auth = base64.b64encode( authstring.encode('utf-8')).decode('utf-8') headers = {'Authorization': 'Basic {0}'.format(encoded_auth)} now = dt.datetime.now().strftime("%Y-%m-%d_%H-%M-%S") # create output directory if necessary dir_output = os.path.join(dir_output, '') if not os.path.isdir(dir_output): try: os.makedirs(dir_output) except OSError: raise unfiltered_options = { 'content_type': content_type, 'inactivity_timeout': inactivity_timeout, 'interim_results': interim_results, 'inactivity_timeout': inactivity_timeout, 'word_confidence': word_confidence, 'timestamps': timestamps, 'max_alternatives': max_alternatives, 'word_alternatives_threshold': word_alternatives_threshold, 'profanity_filter': profanity_filter, 'smart_formatting': smart_formatting, 'keywords': keywords, 'keywords_threshold': keywords_threshold, 'max_alternatives': max_alternatives, 'speaker_labels': speaker_labels } options = dict([(k, unfiltered_options[k]) for k in unfiltered_options.keys() if unfiltered_options[k] is not None]) options['action'] = 'start' # logging from Twisted module if log_type == 'file': log.startLogging(open( dir_output + str(now) + "_" + "transcript.log", 'w'), setStdout=False) elif log_type == 'stdout': log.startLogging(sys.stdout) else: raise ValueError( "Please select a destination for the logging: 'file' or 'stdout'" ) # add audio files to the processing queue queue = Queue.Queue() fileNumber = 0 for fileName in file_input: log.msg(fileName) queue.put((fileNumber, fileName)) fileNumber += 1 # create a WS server factory with our protocol hostname = "stream.watsonplatform.net" #set base connection url url = "wss://" + hostname + "/speech-to-text/api/v1/recognize?model=" + model factory = self.WSInterfaceFactory(queue, dir_output, content_type, model, options, url, headers, debug=False) factory.protocol = self.WSInterfaceProtocol for i in range(min(int(threads), queue.qsize())): factory.prepareUtterance() # SSL client context: default if factory.isSecure: contextFactory = ssl.ClientContextFactory() else: contextFactory = None connectWS(factory, contextFactory) #reactors can be called only once per application try: reactor.run() except Exception as e: print(e)
def start_main(): global is_valit is_valit = False USER_AGENT = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/80.0.3987.132 Safari/537.36" url_auto = "wss://pshudws.365pushodds.com/zap/?uid=" + str( random.random())[2:] factory_auto = MyFactory(url_auto, useragent=USER_AGENT, protocols=['zap-protocol-v1']) # factory_auto = MyFactory( # url_auto, useragent=USER_AGENT, protocols=['zap-protocol-v1'], proxy={'host': "127.0.0.1", 'port': 8888}) factory_auto.protocol = SubClientProtocol factory_auto.headers = {} factory_auto.nst_token = get_nst_token() factory_auto.session_id = get_session_id() def accept(response): if isinstance(response, PerMessageDeflateResponse): return PerMessageDeflateResponseAccept(response) factory_auto.setProtocolOptions(perMessageCompressionAccept=accept) factory_auto.setProtocolOptions(perMessageCompressionOffers=[ PerMessageDeflateOffer( accept_max_window_bits=True, accept_no_context_takeover=True, request_max_window_bits=0, request_no_context_takeover=True, ) ]) if factory_auto.isSecure: contextFactory_auto = ssl.ClientContextFactory() else: contextFactory_auto = None url = "wss://premws-pt3.365pushodds.com/zap/?uid=" + str( random.random())[2:] factory = MyFactory(url, useragent=USER_AGENT, protocols=['zap-protocol-v1']) # factory = MyFactory( # url, useragent=USER_AGENT, protocols=['zap-protocol-v1'], proxy={'host': "127.0.0.1", 'port': 8888}) factory.protocol = MyClientProtocol factory.headers = {} factory.session_id = factory_auto.session_id factory.nst_token = factory_auto.nst_token # factory.session_id = '44263EAB3A86367F8DF053097CF36FBB000003' factory.setProtocolOptions(perMessageCompressionAccept=accept) factory.setProtocolOptions(perMessageCompressionOffers=[ PerMessageDeflateOffer( accept_max_window_bits=True, accept_no_context_takeover=True, request_max_window_bits=0, request_no_context_takeover=True, ) ]) # reactor.callFromThread(connectWS, factory) # reactor.run() if factory.isSecure: contextFactory = ssl.ClientContextFactory() else: contextFactory = None connectWS(factory, contextFactory) connectWS(factory_auto, contextFactory_auto) reactor.callLater(900, stopReactor) reactor.run()
def connect(self): connectWS(self)
def setUpClientServer( self, use_encryption=False, origin="https://site.shotgunstudio.com", host_aliases=None, ): if not host_aliases: host_aliases = ["site.shotgunstudio.com"] self._use_encryption = use_encryption # Create a mockgun instance and add support for the _call_rpc method which is used to get # the secret. sg_host = "https://127.0.0.1" Shotgun.set_schema_paths( os.path.join(fixtures_root, "mockgun", "schema.pickle"), os.path.join(fixtures_root, "mockgun", "schema_entity.pickle"), ) self._mockgun = Shotgun(sg_host) self._mockgun._call_rpc = self._call_rpc self._mockgun.server_info = { "shotgunlocalhost_browser_integration_enabled": True } # Set up an encryption key. self._ws_server_secret = base64.urlsafe_b64encode(os.urandom(32)) self._fernet = Fernet(self._ws_server_secret) # Create the user who will be making all the requests. self._user = self._mockgun.create("HumanUser", {"name": "Gilles Pomerleau"}) # Pretend there is a current bundle loaded. patched = patch("sgtk.platform.current_bundle", return_value=Mock(shotgun=self._mockgun)) patched.start() self.addCleanup(patched.stop) from tk_framework_desktopserver import Server, shotgun patched = patch.object(Server, "Notifier", new=Mock()) patched.start() self.addCleanup(patched.stop) port = find_free_port() # Initialize the websocket server. self.server = Server( keys_path=os.path.join(fixtures_root, "certificates"), encrypt=use_encryption, host="https://site.shotgunstudio.com", user_id=self._user["id"], host_aliases=host_aliases, port=port, uses_intermediate_certificate_chain=True, ) patched = patch.object( shotgun, "get_shotgun_api", new=lambda _, host, process_manager, wss_key: MockShotgunApi( host, process_manager, wss_key), ) patched.start() self.addCleanup(patched.stop) # Do not call server.start() as this will also launch the reactor, which was already # launched by twisted.trial self.server._start_server() # Create the client connection to the websocket server. context_factory = ssl.DefaultOpenSSLContextFactory( os.path.join(fixtures_root, "certificates", "server.key"), os.path.join(fixtures_root, "certificates", "server.crt"), ) # This will be returned by the setUp method to signify that we're done setuping the test. connection_ready_deferred = Deferred() test_case = self class ClientProtocol(WebSocketClientProtocol): """ This class will use Deferred instances to notify that the test is ready to start and to notify the test that a payload has arrived. """ def __init__(self): super(ClientProtocol, self).__init__() self._on_message_deferred = None def onConnect(self, response): """ Informs the unit test framework that we're connected to the server. """ test_case.client_protocol = self connection_ready_deferred.callback(None) def sendMessage(self, payload, is_binary): """ Sends a message to the websocket server. :returns: A deferred that will be called when the associated response comes back. .. note:: Only one message can be sent at a time at the moment. """ super(ClientProtocol, self).sendMessage(payload, isBinary=is_binary) self._on_message_deferred = Deferred() return self._on_message_deferred def _get_deferred(self): """ Retrieves the current deferred and clears it from the client. """ d = self._on_message_deferred self._on_message_deferred = None return d def onMessage(self, payload, is_binary): """ Invokes any callback attached to the last Deferred returned by sendMessage. """ self._get_deferred().callback(payload) def onClose(self, was_clean, code, reason): # Only report clean closure, since they are the ones initiated by the server. if was_clean: self._get_deferred().callback((code, reason)) # Create the websocket connection to the server. self._port = port client_factory = WebSocketClientFactory( "wss://shotgunlocalhost.com:%s" % self._port) client_factory.origin = origin client_factory.protocol = ClientProtocol self.client = connectWS(client_factory, context_factory, timeout=2) # When the test ends, we need to stop listening. self.addCleanup(lambda: self.client.disconnect()) self.addCleanup(lambda: self.server._observer.stop()) self.addCleanup(lambda: self.server.listener.stopListening()) # Return the deferred that will be called then the setup is completed. return connection_ready_deferred
def onClose(self, wasClean, code, reason): self.sendClose() if __name__ == '__main__': debug = True settings = termios.tcgetattr(sys.stdin) #factory = WebSocketClientFactory('ws://192.168.1.37:9000/v1/websocket/?feed_id=53dde5e6a52633d704000003&format=json&isFront=True', #factory = WebSocketClientFactory('ws://162.243.154.223:9000/v1/websocket/?feed_id=53dde5e6a52633d704000003&format=json&isFront=True', factory = WebSocketClientFactory( 'ws://143.89.46.81:8888/v1/websocket/?feed_id=53dde5e6a52633d704000003&format=json&isFront=True', debug=debug, debugCodePaths=debug) factory.protocol = EchoClientProtocol #factoryVideo=WebSocketClientFactory('ws://162.243.154.223:8888/v1/websocket/feed_id=53dde5e6a52633d704000003&format=video&isFront=False', #factoryVideo=WebSocketClientFactory('ws://192.168.1.37:9000/v1/websocket/?feed_id=53dde5e6a52633d704000003&format=video&isFront=False', factoryVideo = WebSocketClientFactory( 'ws://143.89.46.81:8888/v1/websocket/?feed_id=53dde5e6a52633d704000003&format=video&isFront=True', debug=debug, debugCodePaths=debug) factoryVideo.protocol = EchoClientVideoProtocol connectWS(factory) connectWS(factoryVideo) reactor.run()
def startClient(wsuri, ident = None, debug = False): factory = TesteeClientFactory(wsuri, ident = ident, debug = debug) connectWS(factory) return True
if opt.wamp != '': component_config = types.ComponentConfig(realm=opt.realm) session_factory = wamp.ApplicationSessionFactory( config=component_config) session_factory.session = MyFrontendComponent ## 2) create a WAMP-over-WebSocket transport client factory url = u"ws://" + opt.crossbar + "/ws" transport_factory = MyClientFactory(session_factory, url=url) ## 3) start the client from a Twisted endpoint isSecure, host, port, resource, path, params = parseWsUrl(url) transport_factory.host = host transport_factory.port = port websocket.connectWS(transport_factory) ## 4) now enter the Twisted reactor loop broadcasting = True wampThread = Thread(target=reactor.run, args=(False, )) wampThread.start() demo(opt) if opt.wamp != '': lock.acquire() broadcasting = False lock.release() outputQueue.empty() reactor.stop() wampThread.join(10) if wampThread.is_alive():
def connect_to_peer(self, url): client_factory = ClientFactory(url, self.engine, self.broadcaster) client_factory.protocol = ClientProtocol connectWS(client_factory) return url
#------------------------------------------------------------------------------# import settings from sqlalchemy import create_engine from sqlalchemy.orm import sessionmaker from sqlalchemy.engine.url import URL from starpy import fastagi import agi #start logging logFile = logfile.LogFile.fromFullPath('/var/log/qmlremis/agi.log') log.addObserver(log.FileLogObserver(logFile).emit) #connect mysql engine = create_engine(URL(**settings.DATABASE)) Session = sessionmaker(bind=engine) session = Session() #connect websocket ws = OperClientFactory("ws://localhost:9000/Oper") connectWS(ws) ragi = agi.RemisAgi(session, ws.protocol()) factory = fastagi.FastAGIFactory(ragi.main) log.msg("start QmlRemis AGI Server") application = Application("QmlRemis AGI Server") srv = TCPServer(4573, factory) srv.setServiceParent(application)
# Create a WS Server factory with our protocol fmt = "wss://{}/speech-to-text/api/v1/recognize?model={}" url = fmt.format(hostname, args.model) if args.am_custom_id != None: url += "&acoustic_customization_id=" + args.am_custom_id if args.lm_custom_id != None: url += "&customization_id=" + args.lm_custom_id summary = {} factory = WSInterfaceFactory(q, summary, args.dirOutput, args.contentType, args.model, url, headers, debug=False) factory.protocol = WSInterfaceFactory for i in range(min(int(args.threads), q.qsize())): factory.prepareUtterance() # SSL client context: default if factory.isSecure: contextFactory = ssl.ClientContextFactory() else: contextFactory = None connectWS(factory, contextFactory) reactor.run()
def get_text(audio_path, proxy): # parse command line parameters parser = argparse.ArgumentParser( description=('client to do speech recognition using the WebSocket ' 'interface to the Watson STT service')) parser.add_argument( '-type', action='store', dest='contentType', default='audio/mp3', help='audio content type, for example: \'audio/l16; rate=44100\'') parser.add_argument( '-model', action='store', dest='model', default='en-US_BroadbandModel', help='STT model that will be used') # parser.add_argument( # '-model', action='store', dest='model', default='ar-AR_BroadbandModel', # help='STT model that will be used') parser.add_argument( '-amcustom', action='store', dest='am_custom_id', default=None, help='id of the acoustic model customization that will be used', required=False) parser.add_argument( '-lmcustom', action='store', dest='lm_custom_id', default=None, help='id of the language model customization that will be used', required=False) parser.add_argument( '-threads', action='store', dest='threads', default='1', help='number of simultaneous STT sessions', type=check_positive_int) parser.add_argument( '-optout', action='store_true', dest='optOut', help=('specify opt-out header so user data, such as speech and ' 'hypotheses are not logged into the server')) parser.add_argument( '-tokenauth', action='store_true', dest='tokenauth', help='use token based authentication') args = parser.parse_args() # logging log.startLogging(sys.stdout) # add audio files to the processing queue q = Queue.Queue() # fileName = '/Users/qiyue/myxuni/pngtree/speech_audio/3min/9647730104474_5b44b3a2ddd8e328.mp3' # j将任务加入队列 q.put((0, audio_path)) hostname = "stream.watsonplatform.net" headers = {'X-WDC-PL-OPT-OUT': '1'} if args.optOut else {} '''获取token''' token = Utils.getAuthenticationToken(proxy) if token: headers['X-Watson-Authorization-Token'] = token else: return False # create a WS server factory with our protocol fmt = "wss://{}/speech-to-text/api/v1/recognize?model={}" url = fmt.format(hostname, args.model) if args.am_custom_id != None: url += "&acoustic_customization_id=" + args.am_custom_id if args.lm_custom_id != None: url += "&customization_id=" + args.lm_custom_id summary = {} factory = WSInterfaceFactory(q, summary, args.contentType, args.model, url, headers, debug=False) factory.protocol = WSInterfaceProtocol for i in range(min(int(args.threads), q.qsize())): factory.prepareUtterance() # SSL client context: default if factory.isSecure: contextFactory = ssl.ClientContextFactory() else: contextFactory = None connectWS(factory, contextFactory) reactor.run() # dump the hypotheses to the output file for key, value in enumerate(sorted(summary.items())): value = value[1] if value['status']['code'] == 1000: text = value['hypothesis'].encode('utf-8')[:-1].replace("'", "\\'") # print('{}: {} {}'.format(key, value['status']['code'], # value['hypothesis'].encode('utf-8'))) a = value if a['speaker_labels'] is not None: '''根据开始时间和可信度进行排序(加可信度是为了排除掉同样时间的两种speaker,留下可信度高的)''' a['speaker_labels'].sort(key=lambda x: x['from'] + x['confidence']) spaker = a['speaker_labels'] temp = a['timestamps'] '''组成起始时间:词语的键值对,字典,如{4.25: u'will', 9.75: u'and', 46.5: u'know'}''' new_temp = {i[1]: i[0] for i in temp} def delto(speak): lists = [] for i in range(len(speak) - 1): # print i if speak[i]['from'] == speak[i + 1]['from']: lists.append(speak[i]) for i in lists: speak.remove(i) delto(spaker) text_processed = [] for x in range(len(spaker)): i = spaker[x] if x == 0: text_processed.append('speaker' + ' ' + str(i['speaker']) + ':' + new_temp[i['from']]) elif x < len(spaker): if spaker[x]["speaker"] == spaker[x - 1]["speaker"]: text_processed.append(' ' + new_temp[i['from']]) else: text_processed.append('\n' + 'speaker' + ' ' + str(i['speaker']) + ':' + new_temp[i['from']]) text_processed = ''.join(text_processed).strip('\n').replace("'", "\\'") print(text_processed) else: text_processed = '' else: text = '' text_processed = '' return {'text':text,'text_processed':text_processed}
def start(self): notification_center = NotificationCenter() notification_center.add_observer(self, name='JanusBackendConnected') notification_center.add_observer(self, name='JanusBackendDisconnected') self.connector = connectWS(self.factory)
def startClient(wsuri, spec, debug=False): factory = WsPerfControlFactory(wsuri) factory.spec = spec factory.debugWsPerf = spec['options']['debug'] connectWS(factory) return True
def clientConnectionLost(self, connector, reason): print('Lost connection. Reason: {}'.format(reason)) ReconnectingClientFactory.clientConnectionLost(self, connector, reason) def clientConnectionFailed(self, connector, reason): print('Connection failed. Reason: {}'.format(reason)) ReconnectingClientFactory.clientConnectionFailed( self, connector, reason) if __name__ == '__main__': if len(sys.argv) < 2: print("Need the WebSocket server address, i.e. ws://127.0.0.1:9000") sys.exit(1) if len(sys.argv) > 2 and sys.argv[2] == 'debug': log.startLogging(sys.stdout) debug = True else: debug = False factory = EchoClientFactory(sys.argv[1], debug=debug, debugCodePaths=debug) # uncomment to use Hixie-76 protocol # factory.setProtocolOptions(allowHixie76 = True, version = 0) connectWS(factory) reactor.run()
""" __author__ = 'do' __mtime__ = '2018/1/2' __content__ = '' """ from twisted.internet import reactor from autobahn.twisted.websocket import WebSocketClientProtocol, WebSocketClientFactory, connectWS class MyClientProtocol(WebSocketClientProtocol): # 连接建立时调用的函数 def onOpen(self): # 发送消息 self.sendMessage("Hello, world!") # 收到消息后的处理函数,参数意义同上 def onMessage(self, msg, binary): print "Got: " + msg if __name__ == '__main__': websocket_factory = WebSocketClientFactory() websocket_factory.protocol = MyClientProtocol websocket_factory.port = 9000 connectWS(websocket_factory) # factory = WebSocketClientFactory("ws://localhost:9000") # factory.protocol = MyClientProtocol # connectWS(factory) reactor.run()
if account_state['balance'] < balance_threshold: # panic orders = [] for open_position in open_positions.values(): order_side = 'buy' if open_position[ 'side'] == 'short' else 'sell' orders.append({ 'type': 'place_order', 'instrument_id': open_position['instrument_ud'], 'client_order_id': get_order_id(), 'side': order_side, 'quantity': open_position['quantity'], 'limit_price': '0.00000001' if order_side == 'sell' else '100000', 'order_type': 'limit', }) # use batch whenever a number of orders is placed at once user_stream.batch(orders) user_stream.add_listener(SimpleUserListener()) connectWS(MarketStreamClientFactory(market_stream), ssl.ClientContextFactory()) connectWS(UserStreamClientFactory(user_stream), ssl.ClientContextFactory()) reactor.run()
def connect(ip): # Limit size of audio queue since it is only cleared when we receive a transcript input_data = { 'audio': None, 'audio_initial_message': {}, 'transcripts_initial_message': {}, 'pod_id': None } def on_transcript(payload, is_binary): if not is_binary: if input_data['pod_id'] == None: input_data['pod_id'] = getId(ip) transcript = json.loads(payload.decode('utf-8')) if 'op' in transcript: # op not a transcript so ignore return if (transcript['pod_id'] == input_data['pod_id']): # NOTE: we are assuming that the audio data has already been received before processing transcript process_transcript(input_data, transcript, input_data['pod_id']) else: raise Exception( 'invalid transcript message, expected JSON formatted string') def on_transcript_initial_message(payload, is_binary): if input_data['pod_id'] == None: input_data['pod_id'] = getId(ip) if not is_binary: transcript = json.loads(payload.decode('utf-8')) input_data['transcripts_initial_message'] = transcript else: raise Exception( 'invalid initial message (transcripts), expected JSON formatted string got binary data' ) def on_audio(payload, is_binary): if is_binary: input_data['audio'].append(payload) else: payload = payload.decode('utf-8') msg = json.loads(payload) if (msg['op'] == 'start_session'): input_data['audio'].clear() def on_audio_initial_message(payload, is_binary): if input_data['pod_id'] == None: input_data['pod_id'] = getId(ip) if not is_binary: input_data['audio_initial_message'] = json.loads( payload.decode('utf-8')) sample_rate = input_data['audio_initial_message']['audio_format'][ 'sample_rate'] samples_per_frame = input_data['audio_initial_message'][ 'audio_format']['samples_per_frame'] frames_per_second = sample_rate / samples_per_frame max_audio_secs = 120 input_data['audio'] = collections.deque( maxlen=int(max_audio_secs * frames_per_second)) else: raise Exception( 'invalid initial message (audio), expected JSON formatted string got binary data' ) # Connect to input streams connectWS( websockets.RoutingClientFactory(on_transcript, on_transcript_initial_message, 'ws://127.0.0.1:9000/transcripts')) connectWS( websockets.RoutingClientFactory(on_audio, on_audio_initial_message, 'ws://127.0.0.1:9000/audio/' + ip))
def connect(cls, uri, debug=False): client_factory = WampClientFactory(uri) client_factory.uri = uri client_factory.protocol = cls connectWS(client_factory) return client_factory
def run(username, password, out_dir, base_model, acoustic_id, language_id, num_threads, opt_out, watson_token, audio_files, names, combined_audio, contentType, customization_weight): sys.stderr.close( ) # Suppressing error messages from the WebSocket library (Internal library bugs) print(colored("Initiating transcription process..\n", 'blue')) # Removing files that do not exist audio_files = verifyFiles(audio_files) # Checking parameters for correctness (Checked runtime Errors) for k, v in out_dir.items(): if not os.path.exists(v): raise OSError("Output directory does not exist") check_positive_int(num_threads) if not [os.path.isfile(f) for f in audio_files]: print("ERROR: Audio file does not exist") return # Initializing Headers passed to Watson STT as part of request. headers = {opt_out_key: '1'} if opt_out else {} # Authenticating using Watson tokens. if watson_token == 1: headers[Watson_token_key] = (Utilities.getAuthenticationToken( 'https://' + IBM_host, STT_service, username, password)) else: # Authenticating using Access tokens tokens. auth = username + ":" + password headers[Access_token_key] = "Basic " + base64.urlsafe_b64encode( auth.encode('UTF-8')).decode('ascii') # Encoding token in base 64 # Creating and adding additional parameters to request url. fmt = "wss://{0}/{1}/api/v1/recognize?model={2}" url = fmt.format(IBM_host, STT_service, base_model) if language_id != None: url += '&language_customization_id={}'.format( language_id ) # Adding custom language model id. # Set if a custom language model for customization weight. if acoustic_id != None: url += '&acoustic_customization_id={}'.format( acoustic_id) # Adding custom acoustic model id. if language_id != None: custom = True # Indicating if custom weight used. else: custom = False # Setting up a queue for threading q = Queue.Queue() fileNumber = 0 for fileName in audio_files: print("Adding to queue\nFilename: {0}, FileNumber: {1}, " "Output Directory: {2}".format(fileName, fileNumber, out_dir[fileName])) print("Speaker names: {}".format(names[fileName])) q.put( (fileName, fileNumber, out_dir[fileName], contentType[fileName], names[fileName] )) # Adding File information as a tuple in the processing queue. fileNumber += 1 # Creating a WebSocket interface factory instance to produce instances of # the WebSocket protocol. factory = WSInterfaceFactory(queue=q, base_model=base_model, url=url, headers=headers, customization_weight=customization_weight, custom=custom, debug=False) factory.protocol = WSInterfaceProtocol # Setting the protocol for the factory. for i in range(min(int(num_threads), q.qsize( ))): # Using the smaller value out of queue size or threads specified. factory.prepareAudio() if factory.isSecure: contextFactory = ssl.ClientContextFactory( ) # Checking for secure or insecure websocket. else: contextFactory = None connectWS( factory, contextFactory ) # Connecting to the given url using a WebSocket Connection. # Moves the reactor to running state. # Twisted Reactor library python: https://twistedmatrix.com/documents/current/api/twisted.internet.interfaces.IReactorCore.html reactor.run() # Returning information dictionary print(colored("\nTranscription process completed\n", 'green')) return outputInfo
def openControl(self): factoryControl = MyClientFactory(wsurl + "/control", headers=headers) factoryControl.protocol = MyControlProtocol factoryControl.protocol.producer = self.producer connectWS(factoryControl)
def tryfunc(): with open('recordings.txt', 'w') as f: rootdir = os.getcwd() + '/recordings/' for subdir, dirs, files in os.walk(rootdir): subdirName = subdir[subdir.rfind('/') + 1:] # print "hi" # print subdirName for file in files: # print "yo" # print file f.write('./recordings/' + subdirName + '/' + file) f.write('\n') args = { 'contentType': 'audio/wav', 'credentials': ['45189e29-8725-4df0-8f94-0599fb8564e9', '1FlfCoi0F7tt'], 'dirOutput': './output', 'fileInput': './recordings.txt', 'model': 'en-GB_NarrowbandModel', 'optOut': False, 'threads': 10, 'tokenauth': False } # create output directory if necessary # if os.path.isdir(args['dirOutput']): # fmt = 'the output directory "{}" already exists, overwrite? (y/n)? ' # while True: # answer = raw_input(fmt.format(args['dirOutput'])).strip().lower() # if answer == "n": # sys.stderr.write("exiting...") # sys.exit() # elif answer == "y": # break # else: # os.makedirs(args['dirOutput']) if not os.path.isdir(args['dirOutput']): os.makedirs(args['dirOutput']) # logging log.startLogging(sys.stdout) # add audio files to the processing queue q = Queue.Queue() lines = [line.rstrip('\n') for line in open(args['fileInput'])] fileNumber = 0 finalDictionary = { '0001': [], '0002': [], '0003': [], '0004': [], '0021': [], '0022': [], '0023': [], '0045': [] } myDictionary = {} # finalDictionary = {} for fileName in lines: print(fileName) exceptFileName = fileName[:fileName.rfind('/')] # print "start" # print exceptFileName dirName = exceptFileName[exceptFileName.rfind('/') + 1:] # myDictionary[dirName] = myDictionary[dirName].append(fileNumber) # print dirName # print fileName myDictionary[fileNumber] = dirName q.put((fileNumber, fileName)) fileNumber += 1 hostname = "stream.watsonplatform.net" headers = {'X-WDC-PL-OPT-OUT': '1'} if args['optOut'] else {} # authentication header if args['tokenauth']: headers['X-Watson-Authorization-Token'] = ( Utils.getAuthenticationToken( 'https://' + hostname, 'speech-to-text', '45189e29-8725-4df0-8f94-0599fb8564e9', '1FlfCoi0F7tt')) else: auth = args['credentials'][0] + ":" + args['credentials'][1] data_bytes = auth.encode("utf-8") headers["Authorization"] = "Basic " + base64.b64encode( data_bytes).decode('ascii') print(headers) # create a WS server factory with our protocol fmt = "wss://{}/speech-to-text/api/v1/recognize?model={}" url = fmt.format(hostname, args['model']) summary = {} factory = WSInterfaceFactory(q, summary, args['dirOutput'], args['contentType'], args['model'], url, headers, debug=False) factory.protocol = WSInterfaceProtocol for i in range(min(int(args['threads']), q.qsize())): factory.prepareUtterance() # SSL client context: default if factory.isSecure: contextFactory = ssl.ClientContextFactory() else: contextFactory = None connectWS(factory, contextFactory) reactor.run() # dump the hypotheses to the output file fileHypotheses = args['dirOutput'] + "/hypotheses.txt" f = open(fileHypotheses, "w") successful = 0 emptyHypotheses = 0 # print sorted(summary.items()) counter = 0 for key, value in enumerate(sorted(summary.items())): value = value[1] if value['status']['code'] == 1000: print('{}: {} {}'.format(key, value['status']['code'], value['hypothesis'].encode('utf-8'))) # print "I am a key " direc = myDictionary[key] # print value['hypothesis'] finalDictionary[direc].append(value['hypothesis']) # print(fileName) # print "YELLOW" successful += 1 if value['hypothesis'][0] == "": emptyHypotheses += 1 else: fmt = '{}: {status[code]} REASON: {status[reason]}' print(fmt.format(key, **status)) f.write('{}: {}\n'.format(counter + 1, value['hypothesis'].encode('utf-8'))) counter += 1 f.close() fmt = "successful sessions: {} ({} errors) ({} empty hypotheses)" print(fmt.format(successful, len(summary) - successful, emptyHypotheses)) # print "YAYYYY" return (finalDictionary)
def __init__(self, address, observer, keystore, webserver=None, token=None, keyauth=None, appid=None): self.address = address self.token = token self.keyauth = keyauth self.keystore = keystore self.webserver = webserver # for looking up account when connecting back etc. indx_observer = observer appid = appid or "IndxWebSocketClient" if token is None and keyauth is None: raise Exception("Token or Keyauth must not be None.") logging.debug("IndxWebSocketClient opening to {0}".format( self.address)) class IndxClientProtocol(WebSocketClientProtocol): def onMessage(self, payload, isBinary): try: logging.debug( "IndxClientProtocol onMessage, payload {0}".format( payload)) #data = cjson.decode(payload, all_unicode=True) data = json.loads(payload) if data.get("sessionid"): # when server starts, do keys auth self.sessionid = data.get("sessionid") if keyauth: return self.do_key_auth() self.on_response(data) except Exception as e: logging.error( "IndxWebSocketClient Exception: {0}".format(e)) logging.error(traceback.format_exc()) logging.error( "IndxWebSocketClient can't decode JSON, ignoring message: {0}" .format(payload)) def onOpen(self): if token is not None: msg = {"action": "auth", "token": token} self.on_response = self.respond_to_auth self.sendMessage(json.loads(msg)) elif keyauth is not None: self.on_response = lambda x: logging.debug( "Waiting for sessionid before we can auth.") # manage state by setting a response function each time def send_to_observer(self, data): # manage connections coming back from server first.. # TODO imple if data.get("action") == "diff" and data.get( "operation") == "start": def store_cb(store): logging.debug( "WebSocketsHandler listen_diff, store_cb: {0}". format(store)) def observer_local(diff): """ Receive an update from the server. """ logging.debug( "WebSocketsHandler listen_diff observer notified: {0}" .format(diff)) self.sendMessage( json.loads({ "action": "diff", "operation": "update", "data": diff })) store.listen( observer_local) # no callbacks, nothing to do # self.token is set by 'login_keys' below self.token.get_store().addCallbacks( store_cb, lambda failure: self.sendMessage( json.loads({ "success": False, "error": "500 Internal Server Error" }))) elif data.get("action") == "login_keys": try: signature, key_hash, algo, method, appid, encpk2 = data[ 'signature'], data['key_hash'], data['algo'], data[ 'method'], data['appid'], data['encpk2'] except Exception as e: logging.error( "IndxClient/ASync login_keys error getting all parameters." ) return self.sendMessage( json.loads({ "success": False, "error": "400 Bad Request" })) def win(resp): # authenticated now - state of this isn't saved though, we get a token immediately instead username, password, boxid = resp origin = "/ws" # TODO double-check this # get token, return that def got_acct(acct): if acct == False: return self.send401() db_user, db_pass = acct def token_cb(new_token): self.token = new_token def store_cb(store): # success, send token back to user return self.sendMessage( json.loads({ "success": True, "token": new_token.id, "respond_to": "login_keys" })) new_token.get_store().addCallbacks( store_cb, lambda failure: json. loads({ "success": False, "error": "500 Internal Server Error" })) # TODO extract IP from 'address' above webserver.tokens.new( username, password, boxid, appid, origin, "::1", webserver.server_id).addCallbacks( token_cb, lambda failure: json. loads({ "success": False, "error": "500 Internal Server Error" })) webserver.database.lookup_best_acct( boxid, username, password).addCallbacks( got_acct, lambda conn: json.loads( { "success": False, "error": "500 Internal Server Error" })) def fail(empty): self.sendMessage( json.loads({ "success": False, "error": "401 Unauthorized" })) auth_keys(keystore, signature, key_hash, algo, method, self.sessionid, encpk2).addCallbacks(win, fail) else: # otherwise send diffs back to indx indx_observer(data) def respond_to_auth(self, data): if data['success']: if data.get("token"): self.token = data.get("token") self.on_response = self.send_to_observer msg = {"action": "diff", "operation": "start"} self.sendMessage(json.loads(msg)) else: logging.error( "IndxWebSocketClient WebSocket auth failure.") def do_key_auth(self): try: SSH_MSG_USERAUTH_REQUEST = "50" method = "publickey" algo = "SHA512" key_hash, private_key, encpk2 = keyauth[ 'key_hash'], keyauth['private_key'], keyauth['encpk2'] if not (type(encpk2) == type("") or type(encpk2) == type(u"")): encpk2 = json.dumps(encpk2) ordered_signature_text = '{0}\t{1}\t"{2}"\t{3}\t{4}'.format( SSH_MSG_USERAUTH_REQUEST, self.sessionid, method, algo, key_hash) signature = rsa_sign(private_key, ordered_signature_text) values = { "action": "login_keys", "signature": signature, "key_hash": key_hash, "algo": algo, "method": method, "appid": appid, "encpk2": encpk2 } self.on_response = self.respond_to_auth self.sendMessage(json.loads(values)) except Exception as e: logging.error(Failure(e)) self.factory = WebSocketClientFactory(self.address) self.factory.protocol = IndxClientProtocol connectWS(self.factory)
def add_connection(self, id_): factory = self.factories[id_] context_factory = ssl.ClientContextFactory() self._conns[id_] = connectWS(factory, context_factory)
def speech_to_text(audio_file): del_stopwords("{% static 'convert_pdf' %}/pdf_test.csv", "./model/corpus2.txt") dic_id = dictionary_customization("test custom model", "en-US_BroadbandModel", "test model", "./model/corpus2.txt", "test_corpus") credentials = '2dc8e7bd-8219-42cc-9913-cea7af948071:TVNKFLoJjeOv' dirOutput = './relecture/static/convert_rec' contentType = 'audio/mp3' model = 'en-US_BroadbandModel' am_custom_id = None lm_custom_id = dic_id threads = '1' optOut = False tokenauth = False credentials = check_credentials(credentials) threads = check_positive_int(threads) # create output directory if necessary if os.path.isdir(dirOutput): pass else: os.makedirs(dirOutput) # logging log.startLogging(sys.stdout) # add audio files to the processing queue q = Queue() fileNumber = 0 print(audio_file) q.put((fileNumber, audio_file)) fileNumber += 1 hostname = "stream.watsonplatform.net" headers = {'X-WDC-PL-OPT-OUT': '1'} if optOut else {} # authentication header if tokenauth: headers['X-Watson-Authorization-Token'] = ( Utils.getAuthenticationToken('https://' + hostname, 'speech-to-text', credentials[0], credentials[1])) else: auth = credentials[0] + ":" + credentials[1] headers["Authorization"] = "Basic " + base64.b64encode(auth.encode('UTF-8')).decode('ascii') print(headers) # create a WS server factory with our protocol fmt = "wss://{}/speech-to-text/api/v1/recognize?model={}" url = fmt.format(hostname, model) if am_custom_id != None: url += "&acoustic_customization_id=" + am_custom_id if lm_custom_id != None: url += "&customization_id=" + lm_custom_id print(url) summary = {} jsonlist = {} factory = WSInterfaceFactory(q, jsonlist, summary, dirOutput, contentType, model, url, headers, debug=False) factory.protocol = WSInterfaceProtocol for i in range(min(int(threads), q.qsize())): factory.prepareUtterance() # SSL client context: default if factory.isSecure: contextFactory = ssl.ClientContextFactory() else: contextFactory = None connectWS(factory, contextFactory) reactor.run() # dump the hypotheses to the output file fileHypotheses = dirOutput + "/hypotheses.txt" f = open(fileHypotheses, "w") successful = 0 emptyHypotheses = 0 print(sorted(summary.items())) counter = 0 for key, value in enumerate(sorted(summary.items())): value = value[1] if value['status']['code'] == 1000: print('{}: {} {}'.format(key, value['status']['code'], value['hypothesis'].encode('utf-8'))) successful += 1 if value['hypothesis'][0] == "": emptyHypotheses += 1 else: fmt = '{}: {status[code]} REASON: {status[reason]}' print(fmt.format(key, **status)) f.write('{}: {}\n'.format(counter + 1, value['hypothesis'].encode('utf-8'))) counter += 1 f.close() fmt = "successful sessions: {} ({} errors) ({} empty hypotheses)" print(fmt.format(successful, len(summary) - successful, emptyHypotheses)) with open("{}/script.json".format(dirOutput), "w") as f: f.write("[") for ele in jsonlist: f.write(json.dumps(jsonlist[ele], indent=4, sort_keys=True)) if len(jsonlist) - 1 != ele: f.write(",") f.write("]") f.close()
def startClient(wsuri, debug = False): factory = EchoClientFactory(wsuri, debug) connectWS(factory) return True