def translate_new_words(self):
if not os.path.isfile(self.yandex_translate_key_file):
print('put your api ket in {}\n'.format(
self.yandex_translate_key_file))
sys.exit(1)
with open(self.yandex_translate_key_file) as f:
api_key = f.read()
words_translation = {}
print('translate new words')
try:
YT = YandexTranslate(api_key)
for w in sorted(self.new_words):
words_translation[w] = ', '.join(
YT.translate(w, self.args.translate)['text'])
except YandexTranslateException as ex:
print(ex)
else:
tr_text = ''
for w, tr in words_translation.items():
tr_text += '{} = {}\n'.format(w, tr)
tr_file = self.new_words_translation_file.format(
self.args.translate.replace('-', '_'))
with open(tr_file, 'wt', encoding='utf-8') as f:
f.write(tr_text)
def get_translated_text_from_api(api, original_text, destination_language):
if api is 'google_translate':
translator = Translator()
return translator.translate(original_text, dest=destination_language).text
else:
translator = YandexTranslate(app.config['API_KEY'])
return translator.translate(original_text, destination_language)['text'][0]
def translate(text,source,dest):
# print("\n\n {0} {1} {2} \n\n".format(text,source,dest))
translate = YandexTranslate('trnsl.1.1.20190515T114153Z.33301c8ad79f95bd.69a1158dfac270a48213caaf9b6102a3115b8fe1')
if source =='Eng':
lang_source='en'
if source =='Ru':
lang_source='ru'
if dest =='Eng':
lang_dest='en'
if dest =='Ru':
lang_dest='ru'
if source == 'Fra':
lang_source='fr'
if dest =='Fra':
lang_dest='fr'
try:
check = translate.detect(text)
except:
print("Check Exception on text: {}".format(text))
return text
# print("\n\n check: {0} \n\n".format(check))
if not check.find(lang_dest):
empty = lang_dest + '-' + lang_source
#print("\n\n empty: {0} \n\n".format(empty))
rez=translate.translate(text, empty)
s = rez['text'][0].decode('utf8')
# print(u"\n\n rez: {0} \n\n".format(s))
return s
return text
def __init__(self, parent=None, api_key=None):
self.parent = parent
self.api_key = api_key
if not YandexTranslate:
raise GnrException(
'Missing YandexTranslate. hint: pip install yandex.translate')
self.translator = YandexTranslate(self.api_key)
def main(self):
log.info('run serve subcommand')
token = Core.config.telegram.api_token()
if type(token) is not str:
log.critical(
'Can not find "telegram:api_token" in config. Exiting.')
exit(1)
self._bot = Bot(token=Core.config.telegram.api_token())
dp = Dispatcher(self._bot)
self._processor = VolleyProcessor(
YandexTranslate(Core.config.yandex_translate.api_key()),
ChatScript(Core.config.chatscript.host(),
Core.config.chatscript.port(), 'botan'))
dp.register_message_handler(self.send_welcome,
commands=['start', 'help'])
dp.register_message_handler(self.everything)
start_polling(
dp,
skip_updates=True,
# on_startup=self.on_startup,
# on_shutdown=self.on_shutdown
)
def test_blocked_key(self):
translate = YandexTranslate(
"trnsl.1.1.20130723T112255Z.cfcd2b1ebae9f"
"ff1.86f3d1de3621e69b8c432fcdd6803bb87ef0e963")
with self.assertRaises(YandexTranslateException,
msg="ERR_KEY_BLOCKED"):
languages = translate.detect("Hello!")
def get_lyrics_translation():
translate = YandexTranslate('')
con = mdb.connect(ADDRESS, USERNAME, PASSWORD, SCHEMA)
con.set_character_set('utf8')
with con:
cur = con.cursor()
cur.execute('SET CHARACTER SET utf8')
cur.execute('SET character_set_connection=utf8')
dict_of_lyrics = dict()
try:
cur.execute("SELECT song_id, text, src_lang FROM lyrics WHERE text != '' AND translation IS NULL")
if cur.rowcount == 0:
exit(0)
for i in range(cur.rowcount):
row = cur.fetchone()
song_id = row[0]
text = row[1]
src_language = row[2]
if src_language == '':
src_language = 'en'
message = translate.translate(text, src_language + '-he')
if message.get('code') == 200:
translation = message.get('text')
dict_of_lyrics.update({song_id: translation})
else:
print message.get('code')
except Exception as e:
print "error occurred: "
print e.message
print "size of dict: " + str(len(dict_of_lyrics))
insert_into_lyrics_translation(cur, dict_of_lyrics)
def translate_corpus(api_key,
translation_pair,
path_in,
path_out,
max_sent=float('inf')):
translator = YandexTranslate(api_key)
fails = []
with open(path_out, "w") as fod:
with open(path_in) as fid:
for i, l in enumerate(fid):
if i > max_sent:
break
elif not i % 1000:
sys.stdout.write("\r> %d" % i)
sys.stdout.flush()
try:
tr = translator.translate(
l, translation_pair)['text'][0].strip("\n")
except:
fails.append(l)
fod.write(tr.encode("utf-8") + "\n")
print "\ntranslated corpus @ %s " % path_out
print "fails"
print fails
async def callback(data):
match = reg.match(data['body'])
convo = data['convo']
if match and (convo == from_convo or (from_convo is None)):
query = (match.group(1) or '').strip()
try:
if pass_data:
res = await func(data, query)
else:
res = await func(query)
except Exception as e:
import traceback
traceback.print_exc()
lang = data.get('country', 'US').split('-')[0].lower()
if lang == 'us':
lang = 'en'
if lang not in error_cache:
translator = YandexTranslate(config.yandex_translate_key)
error_cache[lang] = translator.translate(config.error_message, 'en-{}'.format(lang))['text'][0]
with open('errors.json', 'w') as f:
json.dump(error_cache, f)
res = error_cache[lang]
if not res:
return
elif type(res) in (str,):
body, file = res, None
else:
body, file = res
if not file and post_avatar:
file = os.path.join(config.avatar_folder, random.choice(os.listdir(config.avatar_folder)))
body = u'>>{}\n{}'.format(data['count'], body)
await post(body, config.bot_name, to_convo if to_convo else data['convo'], config.bot_trip, file)
return match
def __init__(self, file1, file2, lang1, lang2):
self.es = Elasticsearch()
self.translate = YandexTranslate(
'trnsl.1.1.20161120T092429Z.26536300f1fab524.bb5fcc81494303125cb46f52681dfdcf652477e0'
)
self.file1 = file1
self.file2 = file2
self.file1_lang = lang1
self.file2_lang = lang2
self.paragraphLinks = []
self.withoutWhiteChars = re.compile(r'[\n\t \r]+')
self.nonAlphaNumeric = re.compile(r'^\W+$')
self.endOfSetnence = re.compile(r'([\.\?\!:])')
self.sentences_pair = []
self.getNameWords = re.compile(r'([A-ZА-Я]\w+)')
self.onlyLetters = re.compile(r'[^a-zA-Zа-яА-Я ]+')
self.MIN_RATE = 75
self.synced_sentences = []
self.nonsynced_sentences = {'first': [], 'second': [], 'keywords': []}
def translationAugmentYandex(X, y, key, export_path, begin=0):
n_negative = np.sum(y)
X_ret = []
n_sentences_processed = 0
for ind in range(X.shape[0]):
if y[ind] == 1:
if n_sentences_processed >= begin:
try:
en = re.sub(r'[\\][tnrfv]', ' ', X[ind])
en = re.sub(r'[\\]xa0', ' ', en)
en = re.sub(r'[\\]+[^\w]', '', en)
en = re.sub(r'[^\w \'\\]',
lambda x: " " + x.group(0) + " ", en)
# en = re.sub(r'[.,?!:;=-]', lambda x: " " + x.group(0) + " ", en)
en = re.sub(r' +', ' ', en)
en = re.sub(r'[^\w \'<>]', '', en)
translator = YandexTranslate(key)
de_en = translator.translate(translator.translate(
en, lang="en-zh")["text"][0],
lang="zh-en")["text"][0]
es_en = translator.translate(translator.translate(
en, lang="en-ko")["text"][0],
lang="ko-en")["text"][0]
print(X[ind])
print(de_en)
print(es_en)
X_ret.append(de_en)
X_ret.append(es_en)
n_sentences_processed += 1
except YandexTranslateException:
y_ret = np.ones(shape=((n_sentences_processed - begin) *
2))
d = {"Comment": np.array(X_ret), "Insult": y_ret}
df = pd.DataFrame(data=d)
df.to_csv(path_or_buf=export_path, header=True, index=True)
if n_sentences_processed == begin:
print("Run out of characters available")
return np.array(X_ret)
else:
str_len = len(export_path)
file_name = export_path[0:str_len - 5]
n_csv = str(int(export_path[-5]) + 1)
translationAugmentYandex(X,
y,
key,
file_name + n_csv + ".csv",
begin=n_sentences_processed)
else:
n_sentences_processed += 1
y_ret = np.ones(shape=((n_sentences_processed - begin) * 2))
d = {"Comment": np.array(X_ret), "Insult": y_ret}
df = pd.DataFrame(data=d)
df.to_csv(path_or_buf=export_path)
return np.array(X_ret)
def get_translated_text_from_api(api, original_text, destination_language):
if api is "google_translate":
translator = Translator()
return translator.translate(original_text,
dest=destination_language).text
else:
translator = YandexTranslate(app.config["API_KEY"])
return translator.translate(original_text,
destination_language)["text"][0]
def translate_yandex(text, src="auto", dst="en"):
if src != "auto":
lang = "{src}-{dst}".format(src=src, dst=dst)
else:
lang = dst
langdex = YandexTranslate(yandex_key)
result = langdex.translate(text, lang)
assert result['code'] == 200
return result['text'][0]
def __init__(self):
self.__api_key = 'trnsl.1.1.20170419T213309Z.70ddc54f4fe2d025.fa23b8e218345631f11e83f28520ea417e7e44f9'
self.__ya_translator = YandexTranslate(self.__api_key)
self.__con = sqlite3.connect("translator/dictionary.db")
self.__cur = self.__con.cursor()
def translate(text: str) -> str:
"""
:text: --> The text in arabic
:return: --> return a translation of :text: in english
"""
DEBUG = False
if text == "":
return ""
self = FatabyyanoFactCheckingSiteExtractor
yandexAPI = self.YANDEX_API_KEY
yandex = YandexTranslate(yandexAPI)
responses = []
try:
response = yandex.translate(text, 'ar-en')
if DEBUG:
print("response : " + response, end='\n\n')
responses = [response]
text_too_long = False
except YandexTranslateException as e:
if e.args == 'ERR_TEXT_TOO_LONG' or 'ERR_TEXT_TOO_LONG' in e.args:
text_too_long = True
else:
print(text, end='\n\n')
print("Erreur API Yandex\nCode d'erreur : " + str(e.args))
sys.exit(1)
text_list = [text]
while text_too_long:
if DEBUG:
print("cutting : " + str(text_list), end='\n\n')
text_too_long = False
try:
text_list = self.cut_str(text_list)
except ValueError:
print("Erreur ")
sys.exit(1)
responses = []
for t in text_list:
try:
responses.append(yandex.translate(t, 'ar-en'))
except YandexTranslateException:
text_too_long = True
continue
text_list = []
for r in responses:
if int(r['code'] != 200):
print("Erreur lors de la traduction\nCode de l'erreur : " +
r['code'])
sys.exit(1)
else:
text_list.append(r['text'][0])
return self.concat_str(text_list)
def __init__(self):
print('Iniciando Classifier')
self.vocabulary = []
self.modules = {}
self.input_vector = []
self.output_vector = []
self.config = Config()
self.translator = YandexTranslate(self.config.get_token_yandex())
self.dao = Mongo_DAO('localhost', 27017, 'classifier')
def translate(text):
trans = YandexTranslate('trnsl.1.1.20190421T135944Z.7292abf1150a9315.88e1b4e89ec715ff8de021cc3eaf0ef1cae0259b')
if not russian(text):
resp = ''.join(trans.translate(text, 'en-ru')['text'])
else:
resp = ''.join(trans.translate(text, 'ru-en')['text'])
if resp:
return resp
return False
async def ytranslate(self, ctx, language: str, *, text: str):
"""Translate text via yandex
Language may be just "ru" (target language to translate)
or "en-ru" (original text's language - target language)"""
text = chat.escape(text, formatting=True)
apikeys = await self.bot.db.api_tokens.get_raw("yandex", default={"translate": None})
try:
translate = YandexTranslate(apikeys["translate"])
response = translate.translate(text, language)
except YandexTranslateException as e:
if str(e) == "ERR_LANG_NOT_SUPPORTED":
await ctx.send(chat.error("An error has been occurred: Language {} is not supported"
.format(chat.inline(language))))
elif str(e) == "ERR_TEXT_TOO_LONG":
# Discord will return BAD REQUEST (400) sooner than this happen, but whatever...
await ctx.send(chat.error("An error has been occurred: Text that you provided is too big to "
"translate"))
elif str(e) == "ERR_KEY_INVALID":
await ctx.send(chat.error("This command requires Yandex.Translate API key\n"
"You can set it via {}ytapikey".format(ctx.prefix)))
elif str(e) == "ERR_KEY_BLOCKED":
await ctx.send(chat.error("API key is blocked. You need to get new api key or unlock current."))
elif str(e) == "ERR_DAILY_REQ_LIMIT_EXCEEDED":
await ctx.send(chat.error("Daily requests limit reached. Try again later."))
elif str(e) == "ERR_DAILY_CHAR_LIMIT_EXCEEDED":
await ctx.send(chat.error("Daily char limit is exceeded. Try again later."))
elif str(e) == "ERR_UNPROCESSABLE_TEXT":
await ctx.send(chat.error("An error has been occurred: Text is unprocessable by translation server"))
elif str(e) == "ERR_SERVICE_NOT_AVAIBLE":
await ctx.send(chat.error("An error has been occurred: Service Unavailable. Try again later"))
else:
await ctx.send(chat.error("An error has been occurred: {}".format(e)))
return
input_lang = None
output_lang = None
if len(language) == 2:
try:
input_lang = translate.detect(text=text)
except YandexTranslateException as e:
if str(e) == "ERR_LANG_NOT_SUPPORTED":
await ctx.send(chat.error("This language is not supported"))
else:
await ctx.send(chat.error("Unable to detect language: {}".format(e)))
return
output_lang = language
elif len(language) == 5:
input_lang = language[:2]
output_lang = language[3:]
if response["code"] == 200:
await ctx.send("**[{}] Input:** {}".format(input_lang.upper(), chat.box(text)))
await ctx.send("**[{}] Translation:** {}".format(output_lang.upper(), chat.box(response["text"][0])))
else:
# According to yandex.translate source code this cannot happen too, but whatever...
await ctx.send("An error has been occurred. Translation server returned code {}"
.format(chat.inline(response["code"])))
def translate(text):
"""
:text: --> The text in arabic
:return: --> return a translation of :text: in english
"""
translate = YandexTranslate(
'trnsl.1.1.20200311T210815Z.796b747ff14857c9.2e7b856527d2689a26379ff56769f5b3c087f55b'
)
return translate.translate(text, 'ar-en')['text'][0]
def __yandex_translate__(self, text, lang_to, lang_from, formatt):
translator = YandexTranslate(self.yandex_api_key)
try:
if not lang_from:
lang_from = self.detect_lang(text)
lang = "{}-{}".format(lang_from, lang_to)
translated = translator.translate(text, lang, format=formatt)
return translated['text'][0]
except YandexTranslateException:
return text
def translate_language(sourcetext, translationfrom, translationTo):
translate = YandexTranslate(
'trnsl.1.1.20171108T161528Z.11fd5cf559085f7e.68f45fa90a6197a56fc8353410bec46f7386e419'
)
print('Languages:', translate.langs)
print('Translate directions:', translate.directions)
print('Detect language:', translate.detect(sourcetext))
translated_text = translate.translate(
sourcetext, translationfrom + '-' + translationTo)
arr = translated_text['text']
return arr
print(arr)
def translate(text, source_language, dest_language):
# Yandex doesn't require requests (implied?)
# Yandex doesn't require wrapping key in auth
# Yandex returns a dict of lists, the translation is found in ['text'][0]
if ("YANDEX_TRANSLATOR_KEY" not in current_app.config
or not current_app.config["YANDEX_TRANSLATOR_KEY"]):
return _("Error: the translation service is not configured.")
t = YandexTranslate(current_app.config["YANDEX_TRANSLATOR_KEY"])
r = t.translate(text, source_language + "-" + dest_language)
if r["code"] != 200:
return _("Error: the translation service failed. %r" % (r["code"]))
return r["text"][0]
def translate(text, source_language, dest_language):
# Yandex doesn't require requests (implied?)
# Yandex doesn't require wrapping key in auth
# Yandex returns a dict of lists, the translation is found in ['text'][0]
if 'TRANSLATOR_KEY' not in current_app.config or \
not current_app.config['TRANSLATOR_KEY']:
return _('Error: the translation service is not configured.')
t = YandexTranslate(current_app.config['TRANSLATOR_KEY'])
r = t.translate(text, source_language + '-' + dest_language)
if r['code'] != 200:
return "Error: the translation service failed. %r" % ( r['code'] )
return r['text'][0]
def yandex_translate():
translated_text = ""
if len(request.form['text']) > 0:
translator = YandexTranslate(
"trnsl.1.1.20170124T023923Z.db368f9b9c7a7f06.26bd8be0cf53946d203c786ae83d24c73ea5954d"
)
translated_text = translator.translate(request.form['text'],
request.form['dest'])['text'][0]
return jsonify({
'translation': translated_text,
'original_text': request.form['text']
})
def to_english(message):
# Detect language
english_set = set(w.lower()
for w in nltk.corpus.words.words())
text_set = set( w.lower() for w in
re.sub( '\W', ' ', message).split()
if w[0].isalpha() )
unusual = text_set.difference(english_set)
if len(unusual)*3 > len(text_set):
print("Translating...")
translate = YandexTranslate('trnsl.1.1.20170406T225123Z.cb036d7ebd624db9.8835c34234d938773f407ac77a601e10fc1e1771')
message = translate.translate(message, 'en')['text'][0]
return message
def mainTestInteractive(self, sess):
""" Try predicting the sentences that the user will enter in the console
Args:
sess: The current running session
"""
# TODO: If verbose mode, also show similar sentences from the training set with the same words (include in mainTest also)
# TODO: Also show the top 10 most likely predictions for each predicted output (when verbose mode)
# TODO: Log the questions asked for latter re-use (merge with test/samples.txt)
#print('Testing: Launch interactive mode:')
translate = YandexTranslate('trnsl.1.1.20180403T155201Z.58ec00a2b669a2cc.8e269003229f8e698616dad576839b9cf5335af8')
#print('')
#print('Welcome to the interactive mode, here you can ask to Deep Q&A the sentence you want. Don\'t have high '
# 'expectation. Type \'exit\' or just press ENTER to quit the program. Have fun.')
while True:
question = input(self.SENTENCES_PREFIX[0])
traduccion = translate.translate (question, 'en')
texto = str (traduccion['text'])
texto = texto.replace ("['", "")
texto = texto.replace ("[", "")
texto = texto.replace ("']", "")
texto = texto.replace ("]", "")
question=texto
if question == '' or question == 'exit':
break
questionSeq = [] # Will be contain the question as seen by the encoder
answer = self.singlePredict(question, questionSeq)
if not answer:
print('Oye baby, tu pregunta esta muy compleja, ¿podrías intentar algo más simple?')
continue # Back to the beginning, try again
respuesta=self.textData.sequence2str(answer, clean=True)
traduccion=translate.translate(respuesta, 'es')
texto=str(traduccion['text'])
texto=texto.replace("['", "")
texto=texto.replace("']", "")
print('{}{}'.format(self.SENTENCES_PREFIX[1],texto ))
if self.args.verbose:
print(self.textData.batchSeq2str(questionSeq, clean=True, reverse=True))
print(self.textData.sequence2str(answer))
print()
def __init__(self, yandex_key, src_lang=None, dest_lang=None, src_po_file=None):
"""
Конструктор
:param yandex_key: ключ для доступа к API яндекс-переводчика
:param src_lang: исходный язык
:param dest_lang: язык назначения
:param src_po_file: исходный po-файл
:return:
"""
self.yandex_key = yandex_key
self.src_lang = src_lang
self.dest_lang = dest_lang
self.yandex_translate = YandexTranslate(self.yandex_key)
if src_po_file is not None:
self.open_po_fle(src_po_file)
def __goodKeyYandex(self, key):
success = True
trans = YandexTranslate(key)
try:
trans.translate("hola", "en")["text"][0]
except:
success = False
return success
def main():
update_id = lastUpdate(getUpdates())['update_id']
while True:
if update_id == lastUpdate(getUpdates())['update_id']:
from yandex_translate import YandexTranslate
translate = YandexTranslate(
'trnsl.1.1.20181221T225719Z.e3a1a909c9a77883.918af8cc684b8477f891022c74cccc76ef2709b5'
)
c = (lastUpdate(getUpdates())['message']['text'])
w = translate.translate(c, 'ru-en')
trans = w['text']
sendMessage(getChatId(lastUpdate(getUpdates())), trans)
update_id += 1
sleep(1)
async def t(arg):
'translate'
translator = YandexTranslate(config.yandex_translate_key)
# lang = translator.detect(arg)
if arg.startswith('-'):
lang, text = arg.split(None, 1)
lang = lang[1:]
else:
text = arg
lang = translator.detect(text)
if lang != 'en':
translation = translator.translate(text, '{}-en'.format(lang))['text'][0]
answer = 'translated from {}\n{}'.format(lang, translation)
return answer
else:
return "That's already English"
