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
