client_google.py

Go to the documentation of this file.

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import urllib
import urllib2
import json
import socket
import logging
import traceback
import ssl
import rospy

# import library
from rospeex_core.validators import accepts, check_wave_data, check_language
from rospeex_core.exceptions import InvalidRequestException
from rospeex_core.exceptions import InvalidResponseException
from rospeex_core.exceptions import SpeechRecognitionException
from rospeex_core.exceptions import RequestTimeoutException
from rospeex_core.exceptions import ParameterException
from rospeex_core.sr.client_base import SpeechRecognitionClient
from rospeex_core.sr.client_nict import SpeechRecognitionClient_NICT

# create logger
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)


class SpeechRecognitionClient_Google(SpeechRecognitionClient):
    """ SpeechRecognitionClient_Google class """
    AUDIO_LENGTH = 16000
    FRAMERATE = 16000
    CHANNELS = 1
    SAMPWIDTH = 2
    LANGUAGES = ['ja', 'en']
    URL = 'https://www.google.com/speech-api/v2/recognize?'


    def __init__(self):
        """ initialize function """
        self._key = None
        self._load_parameter()


    @accepts(data=str, languate=str, timeout=int)
    def request(self, data, language='ja', timeout=socket._GLOBAL_DEFAULT_TIMEOUT):
        """
        send speech recognition request to server
        @param data: speech binary data
        @type  data: str
        @param language: speech data language
        @type  language: str
        @param timeout: time out time[ms]
        @type  timeout: int
        """
        check_wave_data(data, self.FRAMERATE, self.CHANNELS, self.SAMPWIDTH, self.AUDIO_LENGTH)
        check_language(language, self.LANGUAGES)
        self._check_api_key()

        # speech recognition by nict engine
        nict_result = ''
        try:
            nict_result = SpeechRecognitionClient_NICT().request(data, language, 10)
        except Exception as err:
            pass

        # speech recognition by google engine
        result_text = None
        try:
            result_text = self._request_google_server(self._key, language, data, timeout)
        except InvalidResponseException:
            logger.info('google speech api connection failed. thus use nict api.')
            result_text = nict_result

        return result_text


    def _load_parameter(self):
        """ load parameter from rospy """
        try:
            self._key = rospy.get_param('~google_api_key', None)
        except Exception as err:
            rospy.loginfo(err)


    def _check_api_key(self):
        """ check api key """
        if self._key == None:
            msg = 'argment failed. if you want to use google engine,'\
                  'you MUST set api key for google speech api v2.'
            raise ParameterException(msg)


    def _request_google_server(self, access_key, language, data, timeout):
        """
        speech recognition request to google server (use speech api v2)
        @param access_key: google speech api key
        @type  access_key: str
        @param language: speech data language
        @type  language: str
        @param data: speech binary data
        @type  data: str
        @param timeout: timeout time [s]
        @type  timeout: int
        @raise SpeechRecognitionException:
        """
        try:
            # リクエストを作成し、googleにデータを送信する
            req = self._create_request(access_key, language, data)
            res = urllib2.urlopen(req, timeout=timeout)
            res_read = res.read()
            google_result_text = self._process_data(res_read)

        except urllib2.URLError as err:
            if isinstance(err.reason, socket.timeout):
                raise RequestTimeoutException('request time out. Exception: %s' % str(err))
            raise InvalidRequestException('request url error. Exception:%s' % str(err))

        except urllib2.HTTPError as err:
            raise InvalidResponseException('http error. %s Exception:%s' % (err.code, err.msg))

        except (ssl.SSLError, socket.timeout) as err:
            raise RequestTimeoutException(str(err))

        except Exception as err:
            raise SpeechRecognitionException('unknown exception. Traceback: %s' % traceback.format_exc())

        return google_result_text


    def _create_request(self, access_key, language, data):
        """
        create http request data for google speech api v2
        @param access_key: google speech api key
        @type  access_key: str
        @param language: speech data language
        @type  language: str
        @param data: speech binary data
        @type  data: str
        """
        header = {'Content-Type' : 'audio/l16; rate=16000;'}
        values = {
            'output': 'json',
            'lang'  : language,
            'key': access_key
        }
        url_req = self.URL + urllib.urlencode(values)
        request = urllib2.Request(url_req, data, header)
        return request


    def _process_data(self, input_str):
        result_list = input_str.split('\n')
        json_result_list = []
        for result in result_list:
            try:
                json_result_list.append(json.loads(result))
            except:
                pass

        # データの抽出
        result_data = self._extract_result_key_data(json_result_list)
        if result_data != '':
            result_data = self._extract_alternative_final_key_data(result_data)
            result_data = self._extract_final_data(result_data)
            result_data = self._extract_transcript_data(result_data)

        # get data
        result_text = result_data[0] if len(result_data) else ''
        return result_text


    @classmethod
    def _extract_result_key_data(cls, input_data):
        """ extract result data from server response
        @param input_data:
        @type  input_data: dict()
        """
        # 必要なデータを取り出す
        result_data = [result['result'] for result in input_data if result.has_key('result')]
        if len(result_data) is 0:
            raise InvalidResponseException('result key is not found. Input: %s' % input_data)

        result_data = filter(lambda x: len(x), result_data)
        if len(result_data) is 0:
            return ''

        result_data = reduce(lambda a, b: a+b, result_data)
        return result_data


    @classmethod
    def _extract_alternative_final_key_data(cls, input_data):
        """ extract alternative key data
        @param input_data:
        @type  input_data: dict()
        """
        # key=>alternative と key=>final を持つ結果を取得する
        result_data = filter(lambda x: x.has_key('alternative') and x.has_key('final'), input_data)
        if len(result_data) is 0:
            raise InvalidResponseException('alternative key is not found. Input: %s' % input_data)
        return result_data


    @classmethod
    def _extract_final_data(cls, intput_data):
        """ extract final data from server response
        @param input_data:
        @type  input_data: dict()
        """
        # result['final'] is True のデータを取得する
        result_data = [result['alternative'] for result in intput_data if len(result['alternative']) > 0 and result['final'] is True]
        if len(result_data) is 0:
            raise InvalidResponseException('final key is not found. Input: %s' % intput_data)
        return result_data


    @classmethod
    def _extract_transcript_data(cls, input_data):
        """ extract transcript data from server response
        @param input_data:
        @type  input_data: dict()
        """
        # result['transcript'] を持つデータを取得する
        result_data = reduce(lambda a, b: a+b, input_data)
        result_data = [result['transcript'] for result in result_data if result.has_key('transcript')]
        if len(result_data) is 0:
            raise InvalidResponseException('transcript key is not found. Input: %s' % input_data)
        return result_data