def sentence(request):
de, en = py_.at(request.GET, 'de', 'en')
data = dict(languages=['de', 'en', 'es', 'fr', 'ko'],
translations=dict(de=de, en=en),
query=dict(de=de, en=en))
translator = Translator()
if de:
text = translator.translate(de, src='de', dest='en').text
data['translations']['en'] = text
elif en:
text = translator.translate(en, src='en', dest='de').text
data['translations']['de'] = text
if de or en:
text = data['translations']['en']
results = run_async(
lambda l: translator.translate(text, src='en', dest=l),
data['languages'][2:])
for i, result in enumerate(results, 2):
lang = data['languages'][i]
data['translations'][lang] = result.text
return render(request, 'sentence.html', data)
def __find(self, timeout):
while not self.finder_pool.empty():
self.__loading()
proxy = self.finder_pool.get()
try:
translator = Translator(proxies=proxy, timeout=timeout)
translator.translate('Hello', dest='de')
except Exception:
pass
else:
if self.finder_pool.qsize():
self.done_proxies.put(proxy)
finally:
self.finder_pool.task_done()
self.__clear()
async def _(event):
if event.fwd_from:
return
input_str = event.pattern_match.group(1)
start = datetime.now()
if event.reply_to_msg_id:
previous_message = await event.get_reply_message()
text = previous_message.message
lan = input_str
elif "|" in input_str:
lan, text = input_str.split("|")
else:
await event.edit("Invalid Syntax. Module stopping.")
return
translator = Translator()
try:
translated = translator.translate(text, dest=lan)
src_lang = translated.src
translated_text = translated.text
end = datetime.now()
ms = (end - start).seconds
output_str = "Translated from {} to {} in {} seconds. \n {}".format(src_lang, lan, str(ms), translated_text)
await event.edit(output_str)
except exc:
await event.edit(str(exc))
def do_translate(bot: Bot, update: Update, args: List[str]):
short_name = "Created By @MidukkiBot 😬"
msg = update.effective_message # type: Optional[Message]
lan = " ".join(args)
to_translate_text = msg.reply_to_message.text
translator = Translator()
try:
translated = translator.translate(to_translate_text, dest=lan)
src_lang = translated.src
translated_text = translated.text
msg.reply_text("Translated from {} to {}.\n {}".format(src_lang, lan, translated_text))
except :
msg.reply_text("Error")
def translate(request):
print("translate!!!")
# 로그인 했을 경우
if 'userId' in request.session:
userId = request.session['userId']
print(userId)
user = User.objects.get(username=userId)
# 로그인 확인 후 원래 작업
spell = request.GET.get('spell')
print(spell)
#google translate 사용
'''cmd = ['python']
result = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=True).stdout
output = result.read().strip()
result.close()
print(output)'''
translator = Translator()
translated = translator.translate(spell, dest='ko')
print(spell + " : " + translated.text)
context = {'mean': translated.text}
return render(request, 'Vocabulary/translate.html', context)
# 로그인 안했을 경우
else:
redirect_to = reverse('Main')
return HttpResponseRedirect(redirect_to)
def __translate(self, line):
self.__progress()
curr_proxy = self.proxies.done_proxies.get()
tr = Translator(proxies=curr_proxy, timeout=10)
res = None
try:
res = tr.translate(line.msgid, dest=self.dest, src=self.src)
except Exception:
curr_proxy = self.proxies.done_proxies.get()
tr = Translator(proxies=curr_proxy, timeout=10)
res = tr.translate(line.msgid, dest=self.dest, src=self.src)
finally:
self.proxies.done_proxies.put(curr_proxy)
line.msgstr = res.text if res else ''
def message():
data = json.loads(request.data)
content = data["content"]
translator = Translator()
translated = translator.translate(content, dest="en")
response = {"message": {"text": translated.text}}
response = json.dumps(response, ensure_ascii=False)
return response
def google_translate(text, target='en'):
if not target:
target = 'en'
# Instantiates a client
translator = Translator()
try:
new = translator.translate(text, dest=target)
except AttributeError as e:
print(e)
return None
if new.extra_data['confidence'] and float(
new.extra_data['confidence']) > float(0.8) and new.text != text:
return new
return None
def translate_chinese(subs, dst="en"):
# try to translate to english
from py_translator import Translator
lst = [row[2] for row in subs]
trans = {}
for sublist in slice_iterator(lst):
translator = Translator()
try:
translations = translator.translate(sublist, dest=dst)
for translation in translations:
trans[translation.origin] = translation.text
except Exception as ex:
print(ex)
for row in subs:
if row[2] in trans:
row[2] = trans[row[2]]
dump_sbv(dst_file=f"subtitle_{dst}.sbv", subs=subs)
async def translateme(e):
if not e.text[0].isalpha() and e.text[0]!="!" and e.text[0]!="/" and e.text[0]!="#" and e.text[0]!="@":
global langi
translator=Translator()
textx=await e.get_reply_message()
message = e.text
if textx:
message = textx
text = str(message.message)
else:
text = str(message[4:])
reply_text=translator.translate(text, dest=langi).text
reply_text="`Source: `\n"+text+"`\n\nTranslation: `\n"+reply_text
await bot.send_message(e.chat_id,reply_text)
await e.delete()
if LOGGER:
await bot.send_message(LOGGER_GROUP,"Translate query "+message+" was executed successfully")
def main():
try:
filename = sys.argv[1]
except IndexError:
print('Use "python3 auto_translate.py %filename%"')
sys.exit()
translator = Translator()
document = Document(filename)
table = document.tables[0]
for row in tqdm(table.rows):
eng_cell = row.cells[0]
ru_cell = row.cells[1]
if eng_cell.text:
if not ru_cell.text:
text = translator.translate(eng_cell.text, src='en',
dest='ru').text
ru_cell.text = text
document.save('auto_translated__' + filename)
print('Done')
def translate(self, txt):
if self.fromLanguage == self.toLanguage:
return txt
else:
if not self.WarningDone:
self.WarningDone = True
print(
" !! Traduction en cours, soyez patient ... / translation ongoing, please be patient ..."
)
#translationChunks = txt.split('.')
translationChunks = [txt]
translatedTxt = ''
for chunk in translationChunks:
translatedChunk = Translator.translate(
self, chunk, dest=self.toLanguage,
src=self.fromLanguage).text
translatedTxt += translatedChunk
if DEBUG:
print("#DEBUG: text to translate : {}".format(
chunk.strip())) # .encode('utf-8')
print("#DEBUG: translated text : {}\n".format(
translatedTxt)) # .encode('utf-8')
return translatedTxt
ctr_df.reset_index(inplace=True)
ctr_df.columns = ['word', 'n']
# ctr(frequency) from corpus
news_text = gutenberg.words()
ctr_df['frequency'] = 0
fdist = nltk.FreqDist(w.lower() for w in news_text)
words = list(ctr_df['word'].get_values())
for word in words:
ctr_df.loc[ctr_df['word'] == word, 'frequency'] = fdist[word]
# names
file = open('names.txt', 'r')
names = file.read().split('\n')
names.extend(['Michael', 'Scott', 'Dwight', 'Schrute', 'Jim', 'Halpert', 'Pam', 'Beesly', 'Ryan', 'Howard',
'Andy', 'Bernard', 'Robert', 'California', 'Darryl', 'Philbin', 'Todd', 'Packer', 'Adolf', 'Hitler'])
file.close()
names = [x.lower() for x in names]
# short list of words
ctr_df_short = ctr_df[(ctr_df['frequency'] > 1) & (ctr_df['frequency'] < 10)
& (~ctr_df['word'].isin(names))]\
.sort_values(by='frequency')
#translation
ctr_df_short['translation'] = ' '
ctr_df_short['translation'] = ctr_df_short['word'].apply(lambda x: translator.translate(text=x,
dest='ru', src='en').text)
#save
ctr_df_short[['word', 'translation', 'frequency']].to_csv('words_got_s01e01.csv', encoding='utf-16', index=False,
sep='\t')
def translateSubtitles(subtitles):
translator = Translator()
translated = translator.translate(text=subtitles, dest='en', src='ru').text
return translated
# Optional library
# working library
# https://pypi.org/project/py-translator/
# pip3 install py_translator==2.1.8
from py_translator import Translator
#%% Create object from Translator
translator = Translator()
#%% Translate from string
print('-----------Translator from string --------------')
# English to Thai
translations = translator.translate(text='hello my friend',
src='en',
dest='th')
# Thai to English
translations = translator.translate(
text='ลมอ่อนพัดโชยมาน้ำตาก็ไหลรินเหลือเพียงกลิ่นหัวใจฟุ้งไปกับความเหงา',
src='th',
dest='en')
print('Original Text :')
print(translations.origin)
print('Translated Text :')
print(translations.text)
#%% language detection
def translate(words, languages=None):
languages = languages or ('ko', 'es', 'fr')
translator = Translator()
return run_async(lambda l: translator.translate(words, src='en', dest=l),
languages)
import time
r = requests.get('https://books.trinket.io/pfe/08-lists.html')
soup = BeautifulSoup(r.text, 'html.parser')
texto_markdown = tomd.convert(str(soup.body))
lista = texto_markdown.splitlines()
print(lista)
flag_entre_comillas = False
with open('./libro/08-lists.md', 'a') as file:
for item in lista[270:]:
translator = Translator()
if '```' in item:
file.writelines('```')
flag_entre_comillas = not flag_entre_comillas
continue
if not flag_entre_comillas:
try:
objeto_traducido = translator.translate(text=item,
dest='es').text
file.writelines(objeto_traducido + '\n')
print(objeto_traducido)
except:
print('out of range')
time.sleep(5)
else:
file.writelines(item.replace('>>>', '>>>') + '\n')
print('Hecho!')
def translateSubtitles(subtitles, dest, src):
if subtitles == None:
return ''
translator = Translator()
translated = translator.translate(text=subtitles, dest=dest, src=src).text
return translated
class DataTranslation:
def __init__(self) -> None:
self.translator = Translator()
def make_translation(self, word: str) -> Union[bool, str]:
"""
Translate a word using GoogleTrans library
The language might be indicate in the 2 first character
:param word: string
:param language: string
:return: word string, or False if the word can't be translated
"""
if word == 'en:spreads':
# better translation for the word spreads
return 'Pate à tartiner'
elif word == 'en:sweets-spreads':
return 'Pâte à tartiner sucrée'
elif word == 'en:plant-based-spreads':
return 'Pâte à tartiner végétal'
elif word == ' ':
return False
else:
# take the language indication
language = self.get_language(word)
if not language:
return False
else:
# remove language indicator
word = self.slice_language(word)
# translate word to french
word = self.translator.translate(word, src=language,
dest='fr').text
# remove any type of punctuation
return word.replace('-', ' ')
def detect_lang(self, word: str) -> Union[bool, str]:
"""Detect language with googletrans"""
# detect language
tr = self.translator.detect(word)
if tr.confidence < 0.5:
return False
else:
for l in LANGCODES.values():
if tr.lang == l:
return tr.lang
return False
def slice_language(self, word: str) -> str:
if len(word) > 3 and word[2] == ':':
return word[3:]
return word
def get_language(self, word: str) -> str:
"""
Return the language of the word if its has a language indicator.
If its has not googletrans library will detect its language
"""
if len(self.slice_language(word)) == len(word):
# the word has no language indicator
lang = self.detect_lang(word)
else:
lang = word[:2]
tr = self.translator.detect(word)
# if language detected is different
# the confidence of the translator is above 90 %
# take the language from the translator
if tr.confidence > 0.9 and tr.lang != lang:
lang = tr.lang
return lang
audio = r.listen(source) # , duration=4
print("Time's up")
print('Speech to text in progress')
#r.recognize_google(audio) # default language is english
InputText = r.recognize_google(audio, language="th")
print(InputText)
#%% Step-2: Translation
print('----- Step-2 Translating -----')
translator = Translator()
translations = translator.translate(text = InputText,
src = 'th',
dest = dest_lang)
OutputText = translations.text
print('Translated Text : ' + OutputText)
#%% Step-3: Text to speech
OutputAudioFileName = 'AudioTranslate.mp3'
# Text to speech
tts = gTTS(text= OutputText, lang = dest_lang)
# Save file as filename
tts.save(OutputAudioFileName)
# Play the file
import requests
from bs4 import BeautifulSoup
import re
from py_translator import Translator
r = requests.get('https://automatetheboringstuff.com/chapte16/')
soup = BeautifulSoup(r.text, 'html.parser')
numero = re.compile(r'^\d.*')
translator = Translator()
questions = soup.find_all('p')
for question in questions:
is_question = numero.search(question.text)
if is_question != None:
print(translator.translate(text=question.text[2:], dest='es').text)