Python Transport.send方法代碼示例

# 需要導入模塊: from transport import Transport [as 別名]
# 或者: from transport.Transport import send [as 別名]
class Player(object):

    auth_timeout = 5

    def __init__(self, socket, address):
	self.transport = Transport(socket, address)
	self.host = address[0]
	self.port = address[1]
	self.health = 100

    def close(self):
	self.transport.send(Message.exit().pack())
	self.transport.close()

    def auth(self):
	recv = None
	with Timeout(Player.auth_timeout, PlayerError("Authentication timed out")):
	    try:
		msg = self.transport.receive()
	    except PlayerError as e:
		print("error on receive")
		print(e)
		return False

	try:
	    msg = Message.parse(msg)
	except MessageError:
	    print("bad message")
	    return False
	if msg.type == "nick":
	    self.name = msg.payload
	    self.transport.send(Message.auth_success().pack())
	    return True
	return False

    def listen(self):
	return self.transport.receive()

    def send(self, msg):
	self.transport.send(msg)

# 需要導入模塊: from transport import Transport [as 別名]
# 或者: from transport.Transport import send [as 別名]
class Client(Greenlet):

    def __init__(self, host, port, nick):
	Greenlet.__init__(self)
	self.host = host
	self.port = port
	self.name = nick

    def _run(self):
	self.connect()
	if not self.auth():
	    self.exit("Could not connect to server")
	print("Auth successful")
	self.opponent = self.opponent_wait()
	self.start_wait()
	self.play()
    
    def wait(self, msg_type):
	"""
	Waits for a specific message type, then returns the received message
    	"""
	while True:
	    rec = self.transport.receive()
	    try:
		msg = Message.parse(rec)
	    except MessageError:
		continue
	    if msg.type == msg_type:
		return msg

    def opponent_wait(self):
	msg = self.wait('opponent')
	return msg.payload

    def start_wait(self):
	while True:
	    msg = self.wait('game')
	    if msg.payload == 'start':
		break
	
    def play(self):
	sensor = gevent.spawn(self.handle_punch)	
	sensor.join()

    def handle_punch(self):
	while True:
	    gevent.sleep(7)
	    #print "sending punch"
	    self.transport.send(Message.punch().pack())

    def exit(self, msg):
	print(msg)
	raise GreenletExit

    def connect(self):
	sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
	sock.connect((self.host, self.port))
	print dir(sock)
	self.transport = Transport(sock, (self.host, self.port))

    def auth(self):
	self.transport.send(Message.nick(self.name).pack())
	data = self.transport.receive()
	try:
	    msg = Message.parse(data)
	except MessageError:
	    return False
	if msg.type == 'auth' and msg.payload == 'success':
	    return True
	else:
	    return False

# 需要導入模塊: from transport import Transport [as 別名]
# 或者: from transport.Transport import send [as 別名]
class ServerConnection(object):

    def __init__(self, host, port, key, app, service, topic, lang, format, logger=None, punctuation=True):
        self.host = host
        self.port = port
        self.key = key
        self.app = app
        self.topic = topic
        self.service = service
        self.lang = lang
        self.format = format
        self.uuid = randomUuid().hex
        self.logger = logger
        self.punctuation = punctuation

        self.log("uuid={0}".format(self.uuid))

        self.session_id = ""
        self.connect()


    def log(self, message):
        if self.logger is not None:
            self.logger.info(message)

    def connect(self):
        self.t = Transport(self.host, self.port, timeout=None, verbose=False)
        if not self.upgrade_connection():
            raise ServerError('Unable to upgrade connection')
        self.log("Connected to {0}:{1}.".format(self.host, self.port))

        response = self.send_init_request()
        if response.responseCode != 200:
            error_text = 'Wrong response from server, status_code={0}'.format(
                response.responseCode)
            if response.HasField("message"):
                error_text += ', message is "{0}"'.format(response.message)
            raise ServerError(error_text)

        self.session_id = response.sessionId
        self.log("session_id={0}".format(self.session_id))

        return self.session_id

    def send_init_request(self):
        request = ConnectionRequest(
            speechkitVersion='Not Speechkit',
            serviceName=self.service,
            uuid=self.uuid,
            apiKey=self.key,
            applicationName=self.app,
            device='desktop',
            coords='0, 0',
            topic=self.topic,
            lang=self.lang,
            format=self.format,
            punctuation=self.punctuation)

        self.t.sendProtobuf(request)
        return self.t.recvProtobuf(ConnectionResponse)

    def upgrade_connection(self):
        logger = logging.getLogger('arslib')
        request = ('GET /asr_partial_checked HTTP/1.1\r\n'
                   'User-Agent: {user_agent}\r\n'
                   'Host: {host}:{port}\r\n'
                   'Upgrade: {service}\r\n\r\n').format(
                       user_agent=self.app,
                       host=self.host,
                       port=self.port,
                       service=self.service)

        self.t.send(request)
        check = 'HTTP/1.1 101 Switching Protocols'
        buffer = ''

        # possible infinite loop here?
        while True:
            buffer += self.t.recv(1)
            if buffer.startswith(check) and buffer.endswith('\r\n\r\n'):
                return True
            if len(buffer) > 300:
                logger.warning(buffer)
                return False

    def close(self):
        self.session_id = ""
        self.t.close()

    def reconnect(self, delay=None):
        self.log('Reconnecting!')
        self.close()
        if delay is not None:
            self.log('Going to sleep for {0} seconds'.format(delay))
            time.sleep(delay)
        self.connect()

    def add_data(self, chunk):
        if chunk is None:
            self.t.sendProtobuf(AddData(lastChunk=True))
#.........這裏部分代碼省略.........

# 需要導入模塊: from transport import Transport [as 別名]
# 或者: from transport.Transport import send [as 別名]
class ServerConnection(object):

    def __init__(self, host, port, key, app, service, topic, lang, format, uuid, inter_utt_silence, cmn_latency, logger=None, punctuation=True, ipv4=False, capitalize=False, expected_num_count=0):
        self.host = host
        self.port = port
        self.key = key
        self.app = app
        self.topic = topic
        self.service = service
        self.lang = lang
        self.format = format
        self.uuid = uuid
        self.logger = logger
        self.punctuation = punctuation
        self.inter_utt_silence = inter_utt_silence
        self.cmn_latency = cmn_latency
        self.ipv4 = ipv4
        self.capitalize = capitalize
        self.expected_num_count = expected_num_count

        self.log("uuid={0}".format(self.uuid))

        self.session_id = "not-set"
        self.connect()


    def log(self, message):
        if self.logger is not None:
            self.logger.info(message)

    def connect(self):
        self.t = Transport(self.host, self.port, timeout=None, verbose=False, enable_ssl=(self.port==443), ipv4=self.ipv4)
        if not self.upgrade_connection():
            raise ServerError('Unable to upgrade connection')
        self.log("Connected to {0}:{1}.".format(self.host, self.port))

        response = self.send_init_request()
        if response.responseCode != 200:
            error_text = 'Wrong response from server, status_code={0}'.format(
                response.responseCode)
            if response.HasField("message"):
                error_text += ', message is "{0}"'.format(response.message)
            raise ServerError(error_text)

        self.session_id = response.sessionId
        self.log("session_id={0}".format(self.session_id))

        return self.session_id

    def send_init_request(self):
        request = ConnectionRequest(
            speechkitVersion='',
            serviceName=self.service,
            uuid=self.uuid,
            apiKey=self.key,
            applicationName=self.app,
            device='desktop',
            coords='0, 0',
            topic=self.topic,
            lang=self.lang,
            format=self.format,
            punctuation=self.punctuation,
            advancedASROptions=AdvancedASROptions(
                                  utterance_silence=int(self.inter_utt_silence),
                                  cmn_latency=self.cmn_latency,
                                  capitalize=self.capitalize,
                                  expected_num_count=self.expected_num_count,
                                  biometry="children",
                               )
            )

        self.t.sendProtobuf(request)
        return self.t.recvProtobuf(ConnectionResponse)

    def upgrade_connection(self):
        logger = logging.getLogger('arslib')
        request = ('GET /asr_partial_checked HTTP/1.1\r\n'
                   'User-Agent: {user_agent}\r\n'
                   'Host: {host}:{port}\r\n'
                   'Upgrade: {service}\r\n\r\n').format(
                       user_agent=self.app,
                       host=self.host,
                       port=self.port,
                       service=self.service)

        self.t.send(request)
        check = 'HTTP/1.1 101 Switching Protocols'
        buffer = ''

        # possible infinite loop here?
        while True:
            buffer += self.t.recv(1)
            if buffer.startswith(check) and buffer.endswith('\r\n\r\n'):
                return True
            if len(buffer) > 300:
                logger.warning(buffer)
                return False

    def close(self):
        self.session_id = ""
#.........這裏部分代碼省略.........

# 需要導入模塊: from transport import Transport [as 別名]
# 或者: from transport.Transport import send [as 別名]

#.........這裏部分代碼省略.........
                sum = 0.
                # @50 22000, 25000
                # @5 2200, 2500
                # @4 1300, 1500
                #print f[1300]
                #print f[1500]
                #print f[1800]
                #print f[2200]
                #print f[2500]
                sum_d = 0.
            
                for i in range(2200, 2500):
                    sum += mgft[i]
                    if i > 2300:
                        sum_d += mgft[i]
            
                hitstr="""
#     #  ###  #######  
#     #   #      #     
#     #   #      #     
#######   #      #     
#     #   #      #     
#     #   #      #     
#     #  ###     #     
            
                """
                ratio = sum_d/sum
                #print sum
                if sum > 200:
                    #print "ratio: %f, sum: %f" % (ratio * 100 , sum)
                    last = ratio * 100
                    delta = last - last2
                    print "%f" % (delta)
                    last2 = last
                    #delta = ratio - last
                    
                    if abs(delta) > 6:
                        hit = hit + 1
                        print hitstr
                        print "Hits = %d" % (hit)
                        print "Sending punch"
                        self.transport.send(Message.punch().pack())
            
                    #if ratio > 7:
                    #print sum
                    #delta = last - sum;
                    #if len(cal) < 21:
                    #    cal.append(sum)
                    #    print "Calibrating Delta = %f..." %(delta)
                    #    if len(cal) == 21:
                    #        mean = np.average(cal)
                    #        std = np.std(cal)
                    #        print "Done calibrating! STD=%f, MEAN=%f" % (std, mean)
                    #        print cal
                    #else:
                    #    print "STD: %f" % (float(sum - mean)/std)
                    #print "Delta (%f%%) : %f" % (sum/last * 100, delta);
                    #if sum > 60000000:
            
                #last = sum
                #print sum
                #print sum2
                #print "stability: %f, delta: %f, sum: %f" % (ratio * 100, ratio_d * 100, sum)
            
            
            
            stream.close()
            p.terminate()
    





	    print "sending punch"


#	    self.transport.send(Message.punch().pack())

    def exit(self, msg):
	print(msg)
	raise GreenletExit

    def connect(self):
	sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
	sock.connect((self.host, self.port))
	print dir(sock)
	self.transport = Transport(sock, (self.host, self.port))

    def auth(self):
	self.transport.send(Message.nick(self.name).pack())
	data = self.transport.receive()
	try:
	    msg = Message.parse(data)
	except MessageError:
	    return False
	if msg.type == 'auth' and msg.payload == 'success':
	    return True
	else:
	    return False