Esempio n. 1
0
    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
Esempio n. 2
0
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()
Esempio n. 3
0
	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
Esempio n. 4
0
    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))
Esempio n. 5
0
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()
Esempio n. 6
0
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)
Esempio n. 7
0
 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)
Esempio n. 8
0
 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
Esempio n. 9
0
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)
Esempio n. 10
0
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
Esempio n. 11
0
 def connect(self):
     print "WEBSOCKET connecting", self.isSecure
     ## SSL client context: default
     ##
     if self.isSecure:
         contextFactory = ssl.ClientContextFactory()
     else:
         contextFactory = None
     connectWS(self, contextFactory)
Esempio n. 12
0
    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()
Esempio n. 13
0
   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)
Esempio n. 15
0
 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()
Esempio n. 16
0
    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
Esempio n. 17
0
   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)
Esempio n. 18
0
    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
Esempio n. 20
0
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)
Esempio n. 22
0
 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()
Esempio n. 23
0
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
Esempio n. 24
0
    def connect(self):
        """Connect the client factory to the WebSocket server

        Returns:
        An instance of twisted.internet.interfaces.IConnector
        """
        return connectWS(self)
Esempio n. 25
0
    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
Esempio n. 26
0
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()
Esempio n. 27
0
 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)
Esempio n. 28
0
 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)
Esempio n. 29
0
    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
Esempio n. 30
0
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()
Esempio n. 31
0
 def connect(self):
     """Establish WebSocket connection to the ROS server defined for this factory."""
     self.connector = connectWS(self)
Esempio n. 32
0
 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)
Esempio n. 33
0
 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
Esempio n. 36
0
    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)
Esempio n. 39
0
    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
Esempio n. 40
0
    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()
Esempio n. 41
0
def startClient(wsuri, ident = None, debug = False):
   factory = TesteeClientFactory(wsuri, ident = ident, debug = debug)
   connectWS(factory)
   return True
Esempio n. 42
0
    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():
Esempio n. 43
0
File: p2p.py Progetto: mrtj/pyncoin
 def connect_to_peer(self, url):
     client_factory = ClientFactory(url, self.engine, self.broadcaster)
     client_factory.protocol = ClientProtocol
     connectWS(client_factory)
     return url
Esempio n. 44
0
#------------------------------------------------------------------------------#

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)
Esempio n. 45
0
    # 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()
Esempio n. 46
0
    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}
Esempio n. 47
0
 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)
Esempio n. 48
0
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()
Esempio n. 50
0
"""
__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()
Esempio n. 51
0
        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()
Esempio n. 52
0
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))
Esempio n. 53
0
 def connect(cls, uri, debug=False):
     client_factory = WampClientFactory(uri)
     client_factory.uri = uri
     client_factory.protocol = cls
     connectWS(client_factory)
     return client_factory
Esempio n. 54
0
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
Esempio n. 55
0
 def openControl(self):
     factoryControl = MyClientFactory(wsurl + "/control", headers=headers)
     factoryControl.protocol = MyControlProtocol
     factoryControl.protocol.producer = self.producer
     connectWS(factoryControl)
Esempio n. 56
0
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)
Esempio n. 57
0
    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)
Esempio n. 58
0
 def add_connection(self, id_):
     factory = self.factories[id_]
     context_factory = ssl.ClientContextFactory()
     self._conns[id_] = connectWS(factory, context_factory)
Esempio n. 59
0
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()
Esempio n. 60
0
def startClient(wsuri, debug = False):
   factory = EchoClientFactory(wsuri, debug)
   connectWS(factory)
   return True