def __init__(self, text, lang='en', slow=False, lang_check=True): # Text assert text, 'No text to speak' self.text = text # Language if lang_check: try: langs = tts_langs() if lang.lower() not in langs: raise ValueError("Language not supported: %s" % lang) except RuntimeError as e: log.debug(str(e), exc_info=True) log.warning(str(e)) self.lang_check = lang_check self.lang = lang.lower() # Read speed if slow: self.speed = Speed.SLOW else: self.speed = Speed.NORMAL # Google Translate token self.token = gtts_token.Token()
def __init__( self, text, tld='com', lang='en', slow=False, lang_check=True, pre_processor_funcs=[ pre_processors.tone_marks, pre_processors.end_of_line, pre_processors.abbreviations, pre_processors.word_sub ], tokenizer_func=Tokenizer([ tokenizer_cases.tone_marks, tokenizer_cases.period_comma, tokenizer_cases.colon, tokenizer_cases.other_punctuation ]).run ): # Debug for k, v in dict(locals()).items(): if k == 'self': continue log.debug("%s: %s", k, v) # Text assert text, 'No text to speak' self.text = text # Translate URL top-level domain self.tld = tld # Language if lang_check: try: langs = tts_langs(self.tld) if lang.lower() not in langs: raise ValueError("Language not supported: %s" % lang) except RuntimeError as e: log.debug(str(e), exc_info=True) log.warning(str(e)) self.lang_check = lang_check self.lang = lang.lower() # Read speed if slow: self.speed = Speed.SLOW else: self.speed = Speed.NORMAL # Pre-processors and tokenizer self.pre_processor_funcs = pre_processor_funcs self.tokenizer_func = tokenizer_func # Google Translate token self.token = gtts_token.Token()
def translate(target, source, text): tokenizer = gtts_token.Token() token = tokenizer.calculate_token(text) payload = {'q': text, 'tl': target, "sl": source, 'client': 't', 'tk': token, "dt": "t", "ie": "UTF-8", "oe": "UTF-8"} r = requests.get('https://translate.google.com/translate_a/single', params=payload, timeout=10).json() res = r[0][0][0] return res
def __init__(self, bot): self.voice_states = {} self.tokenizer = gtts_token.Token() self.servers_recording = set() self.recording_data = {} if Decoder: self.opus_decoder = Decoder(48000, 2) else: self.opus_decoder = None super().__init__(bot) self.logger = self.logger.getChild('voice') self.disconnect_task = self.loop.create_task(self.disconnect_bg_task())
def async_get_tts_audio(self, message, language=None): """Load TTS from google.""" from gtts_token import gtts_token token = gtts_token.Token() websession = async_get_clientsession(self.hass) message_parts = self._split_message_to_parts(message) # If language is not specified or is not supported - use the language # from the config. if language not in SUPPORT_LANGUAGES: language = self.language data = b'' for idx, part in enumerate(message_parts): part_token = yield from self.hass.loop.run_in_executor( None, token.calculate_token, part) url_param = { 'ie': 'UTF-8', 'tl': language, 'q': yarl.quote(part), 'tk': part_token, 'total': len(message_parts), 'idx': idx, 'client': 'tw-ob', 'textlen': len(part), } request = None try: with async_timeout.timeout(10, loop=self.hass.loop): request = yield from websession.get(GOOGLE_SPEECH_URL, params=url_param, headers=self.headers) if request.status != 200: _LOGGER.error("Error %d on load url %s", request.status, request.url) return (None, None) data += yield from request.read() except (asyncio.TimeoutError, aiohttp.errors.ClientError): _LOGGER.error("Timeout for google speech.") return (None, None) finally: if request is not None: yield from request.release() return ("mp3", data)
async def async_get_tts_audio(self, message, language, options=None): """Load TTS from google.""" token = gtts_token.Token() websession = async_get_clientsession(self.hass) message_parts = self._split_message_to_parts(message) data = b"" for idx, part in enumerate(message_parts): try: part_token = await self.hass.async_add_executor_job( token.calculate_token, part) except ValueError as err: # If token seed fetching fails. _LOGGER.warning(err) return None, None url_param = { "ie": "UTF-8", "tl": language, "q": part, "tk": part_token, "total": len(message_parts), "idx": idx, "client": "tw-ob", "textlen": len(part), } try: with async_timeout.timeout(10): request = await websession.get(GOOGLE_SPEECH_URL, params=url_param, headers=self.headers) if request.status != HTTP_OK: _LOGGER.error("Error %d on load URL %s", request.status, request.url) return None, None data += await request.read() except (asyncio.TimeoutError, aiohttp.ClientError): _LOGGER.error("Timeout for google speech") return None, None return "mp3", data
def __init__(self, session=None, service_urls=None, user_agent=DEFAULT_USER_AGENT, proxies=None, loop=asyncio.get_event_loop()): self.headers = { 'User-Agent': user_agent, } self.session = session self.proxies = proxies or [None] self.service_urls = service_urls or ['translate.google.com'] self.loop = loop self.token = gtts_token.Token()
def async_get_tts_audio(self, message, language, options=None): """Load TTS from google.""" from gtts_token import gtts_token token = gtts_token.Token() websession = async_get_clientsession(self.hass) message_parts = self._split_message_to_parts(message) data = b'' for idx, part in enumerate(message_parts): part_token = yield from self.hass.async_add_job( token.calculate_token, part) url_param = { 'ie': 'UTF-8', 'tl': language, 'q': yarl.URL(part).raw_path, 'tk': part_token, 'total': len(message_parts), 'idx': idx, 'client': 'tw-ob', 'textlen': len(part), } try: with async_timeout.timeout(10, loop=self.hass.loop): request = yield from websession.get( GOOGLE_SPEECH_URL, params=url_param, headers=self.headers ) if request.status != 200: _LOGGER.error("Error %d on load url %s", request.status, request.url) return (None, None) data += yield from request.read() except (asyncio.TimeoutError, aiohttp.ClientError): _LOGGER.error("Timeout for google speech.") return (None, None) return ("mp3", data)
def say(self, text, lang='ja'): token = gtts_token.Token() tk = token.calculate_token(text) payload = { 'ie': 'UTF-8', 'q': text, 'tl': lang, 'total': 1, 'idx': 0, 'textlen': len(text), 'tk': tk, 'client': 't', 'ttsspeed': 1.0 } params = urllib.parse.urlencode(payload, quote_via=urllib.parse.quote) url = 'https://translate.google.com/translate_tts?{}'.format(params) self.cast.wait() mc = self.cast.media_controller mc.play_media(url, 'audio/mp3')
def __init__(self, text, lang='en', slow=False, lang_check=True, pre_processor_funcs=[ pre_processors.tone_marks, pre_processors.end_of_line, pre_processors.abbreviations, pre_processors.word_sub ], tokenizer_func=Tokenizer([ tokenizer_cases.tone_marks, tokenizer_cases.period_comma, tokenizer_cases.colon, tokenizer_cases.other_punctuation ]).run): # Debug for k, v in locals().items(): if k == 'self': continue log.debug("%s: %s", k, v) # Text assert text, 'No text to speak' self.text = text self.lang = 'en' # Read speed if slow: self.speed = Speed.SLOW else: self.speed = Speed.NORMAL # Pre-processors and tokenizer self.pre_processor_funcs = pre_processor_funcs self.tokenizer_func = tokenizer_func # Google Translate token self.token = gtts_token.Token()
def setUp(self): self.tokenizer = gtts_token.Token()
async def async_get_tts_audio(self, message, language, options=None): """Load TTS from google or FPT.""" from gtts_token import gtts_token token = gtts_token.Token() websession = async_get_clientsession(self.hass) message_parts = self._split_message_to_parts(message) data = b'' for idx, part in enumerate(message_parts): part_token = await self.hass.async_add_job(token.calculate_token, part) url_param = { 'ie': 'UTF-8', 'tl': language, 'q': yarl.URL(part).raw_path, 'tk': part_token, 'total': len(message_parts), 'idx': idx, 'client': 'tw-ob', 'textlen': len(part), } try: with async_timeout.timeout(10): if self._lang == "vi" and self.api_key != '': url_mp3 = requests.post( FPT_SPEECH_URL, data=part.encode('utf-8'), headers=self.headers).json()['async'] # time sleep in seconds time_sleep = 0.5 # time_wait = 10 seconds/time_sleep time_wait = 20 tcount = 0 #check status request res_response = requests.get(url_mp3) res_status = res_response.status_code # Wait for hass request FPT Speech Synthesis to complete while (res_status == 404 and tcount < time_wait): time.sleep(time_sleep) res_response = requests.get(url_mp3) res_status = res_response.status_code tcount += 1 # if error => msgbox_error if tcount == time_wait: msgbox_error = "Đã xảy ra lỗi. Vui lòng kiểm tra lại." msgbox_error = msgbox_error.encode('utf-8') url_error = requests.post( FPT_SPEECH_URL, data=msgbox_error, headers=self.headers).json()['async'] res_response = requests.get(url_error) data += res_response.content else: request = await websession.get(GOOGLE_SPEECH_URL, params=url_param, headers=self.headers) if request.status != 200: _LOGGER.error("Error %d on load URL %s", request.status, request.url) return None, None data += await request.read() except (asyncio.TimeoutError, aiohttp.ClientError): _LOGGER.error("Timeout for google speech") return None, None return 'mp3', data