async def translate(self, ctx, *, phrase):
translator = Translator()
phrase = phrase.split()
modifiers = [word for word in phrase if word[0] == '-']
for j, i in enumerate(modifiers):
phrase.remove(i)
modifiers[j] = i[1:]
phrase = " ".join(phrase)
try:
if not modifiers:
done = translator.translate(phrase)
elif len(modifiers) == 1:
done = translator.translate(phrase, dest=modifiers[0])
else:
done = translator.translate(phrase,
src=modifiers[0],
dest=modifiers[1])
except ValueError:
await ctx.send(
("Something failed while translating. Please ensure you are "
"using codes for indicating language, such as `en` or `ja`, "
"or use the full language name, such as `norwegian` or "
"`german`"))
return
fromlang = LANGUAGES.get(done.src, done.src)
tolang = LANGUAGES.get(done.dest, done.dest)
await ctx.send("{}:: translating {} -> {} ::\n{}\n{}".format(
"```asciidoc\n", fromlang, tolang, done.text, "\n```"))
async def tr_pls(client, message):
event = await edit_or_reply(message, "`Please Wait!`")
lang = get_text(message)
if not lang:
lang = "en"
if not message.reply_to_message and not message.reply_to_message.text:
await event.edit("`Reply To Message To Translate It!`")
return
text = message.reply_to_message.text
translator = google_translator()
source_lan = detect(text)
if not LANGUAGES.get(lang):
await event.edit("`Language Not Supported.`")
return
transl_lan = LANGUAGES.get(lang, 'English')
translated = translator.translate(text, lang_tgt=lang)
tr_text = f"""**Source ({source_lan.capitalize()})**:
`{text}`
**Translation ({transl_lan.capitalize()})**:
`{translated}`"""
if len(tr_text) >= 4096:
url = "https://del.dog/documents"
r = requests.post(url, data=tr_text.encode("UTF-8")).json()
url2 = f"https://del.dog/{r['key']}"
tr_text = (
f"Translated Text Was Too Big, Never Mind I Have Pasted It [Here]({url2})"
)
await event.edit(tr_text)
def tr(text, lang):
translator = Translator()
if not LANGUAGES.get(lang):
return None, None, None
translated = translator.translate(text, dest=lang, src='auto')
source_lan = LANGUAGES.get(translated.src.lower())
transl_lan = LANGUAGES.get(translated.dest.lower())
return source_lan, transl_lan, translated
def translate():
msg("Select source language")
src, source = menu(LANGUAGES.values())
clear_screen()
msg("Select destination language")
dest, destination = menu(LANGUAGES.values())
clear_screen()
text = input("Insert the text that will be translated: ")
translator = Translator()
response = translator.translate(text, src=source, dest=destination)
return response.text
def translate(self, text, dest_lang):
if dest_lang.lower() not in LANGUAGES.values():
raise ValueError("Selected language is not supported!")
dest_lang_tag = [
lang_tag for lang_tag, lang in LANGUAGES.items()
if lang == dest_lang
][0]
translation = self.translator.translate(text,
src='en',
dest=dest_lang_tag)
return translation
def getLangString(self, lang):
LANGCODES = dict(map(reversed, LANGUAGES.items()))
simbols = list(LANGCODES.values())
strings = list(LANGCODES.keys())
simbolIndex = simbols.index(lang)
langString = strings[simbolIndex]
return langString
def languages():
"""
create a list of code languages and languages like (en : english)
:return:
"""
for lan, cod in LANGUAGES.items():
print(f'{lan}: {cod} |')
def main():
auth = tweepy.OAuthHandler(consumer_key, consumer_secret)
auth.set_access_token(access_token, access_token_secret)
api = tweepy.API(auth)
last_id = ""
home = str(Path.home())
log_file = home + "/twittbot/log.txt"
while (True):
a = api.user_timeline(screen_name="realdonaldtrump",
tweet_mode='extended')
open(log_file, 'w').close()
print("Looking for new tweets", file=open(log_file, "a"))
if a and a[0].id_str != last_id:
translator = Translator()
tweet = a[0].full_text
print("Found Tweet: \n", tweet, file=open(log_file, "a"))
print("---------------------------", file=open(log_file, "a"))
# & seems to crash the translator
tweet = tweet.replace("&", "and ")
# Preserve the url if there is one
index = tweet.find("http")
url = ""
if index != -1:
url = tweet[index:]
tweet = tweet[:index]
if not tweet:
continue
# Translate 30 times (100 takes to long time and there is a limit on number of requests to the api)
# Idea still the same though
lang1, lang2 = "en", ""
for i in range(25):
lang2 = random.choice(list(
LANGUAGES.items()))[0] # choose a random language
tweet = translator.translate(text=tweet, src=lang1,
dest=lang2).text
lang1 = lang2
tweet = translator.translate(
text=tweet, src=lang1,
dest='en').text # translate back to english
tweet = tweet + " " + url # add back the url
print("tweated: " + tweet, file=open(log_file, "a"))
if len(tweet) + len("@realdonaldtrump ") < 280:
api.update_status(status="@realdonaldtrump " + tweet,
in_reply_to_status_id=a[0].id_str)
else:
api.update_status(status="@realdonaldtrump " + tweet[0:260],
in_reply_to_status_id=a[0].id_str)
last_id = a[0].id_str
print("---------------------------", file=open(log_file, "a"))
sleep(200)
def create(self, validated_data):
trans = Translator()
data = trans.detect(validated_data['original_sentc'])
validated_data['language'] = str(LANGUAGES.get(data.lang)).title()
transglish = trans.translate(validated_data['original_sentc'], dest='en')
validated_data['english_sentc'] = transglish.text
return Sentences.objects.create(**validated_data)
def backtranslate(
text: Union[List[str], str],
n_langs: int = 1,
random_state: int = 42,
filter_out_identical=True,
):
langs = np.random.choice(list(LANGUAGES.keys()),
size=n_langs,
replace=False)
if isinstance(text, str):
ret = []
for lang in langs:
translated = translator.translate(text, dest=lang)
ret.append(
translator.translate(translated.text, src=lang,
dest="en").text)
else: # Then we have a list of strings
ret = []
for lang in langs:
to_append = []
for t in text:
translated = translator.translate(t, dest=lang)
to_append.append(
translator.translate(translated.text, src=lang,
dest="en").text)
ret.append(to_append)
return ret, langs
async def translate(self, ctx: commands.Context, *content: str):
def check_author(reaction):
return reaction.user_id == ctx.author.id and reaction.emoji.name == "\U0001f197"
if not content:
message_error = await ctx.send(f"Veuillez utiliser le format suivant pour cette commande: `{ctx.prefix}{ctx.command} {ctx.command.usage}`\nPour avoir la liste complète des langues disponibles, tapez la commande `{ctx.prefix}{ctx.command} lang` et je vous enverrai la liste en message privé.")
await message_error.add_reaction("\U0001f197")
try:
await self.client.wait_for("raw_reaction_add", check=check_author, timeout=120.0)
except asyncio.TimeoutError:
await message_error.delete()
else:
await message_error.delete()
return
lang = content[0]
if lang not in LANGUAGES.keys():
message_error = await ctx.send(f"Veuillez entrer une langue de destination valide. Par exemple pour traduire un message du Français à l'Anglais, écrivez `{ctx.prefix}{ctx.command} en <votre message>` ou inversement de l'Anglais au Français `{ctx.prefix}{ctx.command} fr <your message>`\nPour avoir la liste complète des langues disponibles, tapez la commande `{ctx.prefix}{ctx.command} lang` et je vous enverrai la liste en message privé.")
await message_error.add_reaction("\U0001f197")
try:
await self.client.wait_for("raw_reaction_add", check=check_author, timeout=120.0)
except asyncio.TimeoutError:
await message_error.delete()
else:
await message_error.delete()
return
message = " ".join(content[1:])
if not message:
message_error = await ctx.send(f"Veuillez entrer un message après avoir indiqué la langue. Par exemple pour traduire un message du Français à l'Anglais, écrivez `{ctx.prefix}{ctx.command} en <votre message>` ou inversement de l'Anglais au Français `{ctx.prefix}{ctx.command} fr <your message>`\nPour avoir la liste complète des langues disponibles, tapez la commande `{ctx.prefix}{ctx.command} lang` et je vous enverrai la liste en message privé.")
await message_error.add_reaction("\U0001f197")
try:
await self.client.wait_for("raw_reaction_add", check=check_author, timeout=120.0)
except asyncio.TimeoutError:
await message_error.delete()
else:
await message_error.delete()
return
try:
language = self.translator.detect(message)
except AttributeError as err:
write_file(set_file_logs(ctx.guild.id), err, is_log=True)
self.translator = Translator(
service_urls=["translate.google.com", "translate.google.fr"])
return await ctx.send("Une erreur est survenue. Veuillez réessayer.")
embed = Embed(color=ctx.author.top_role.color,
timestamp=datetime.utcnow())
embed.set_author(name=f"{ctx.author.display_name}#{ctx.author.discriminator}",
icon_url=ctx.author.avatar_url)
embed.add_field(
name="Say", value=f"{self.translator.translate(message, dest=lang.lower()).text}")
embed.set_footer(
text=f"{LANGUAGES[language.lang].title()} to {LANGUAGES[lang.lower()].title()}")
await ctx.send(embed=embed)
async def tr(event, text):
kk = Config.LANG if LANGUAGES.get(Config.LANG) else 'en'
if kk == 'en':
await event.edit(text)
else:
translator = google_translator()
translated = translator.translate(text, lang_tgt=kk)
await event.edit(translated)
return
async def tr(event, text):
we = Config.LANG if LANGUAGES.get(Config.LANG) else "en"
if we == "en":
await event.edit(text)
else:
translator = google_translator()
translated = translator.translate(text, lang_tgt=we)
await event.edit(translated)
return
def display_languages():
lang_indexes = {}
i = 0
for Language in LANGUAGES.keys():
lang_indexes[str(i)] = Language
print("{:<3} : {:<10}".format(str(i), LANGUAGES[Language]))
i += 1
print("")
return lang_indexes
def show_langs():
"""
Retorna um texto formatado mostrando todas as linguas disponíveis para tradução
"""
texto = f"```\n{'Codigo':<8} {'Lingua'}\n" + '—' * 20 + '\n'
for keys, values in LANGUAGES.items():
texto += f"{keys:<8} {values}\n"
texto += "```"
return texto
def TranslateFunc(input_text):
lang = list(LANGUAGES.values())
try:
tra = Translator(service_urls=['translate.googleapis.com'])
result = tra.translate(str(input_text))
print(result.src)
return result.text
except:
print("Sorry This Language is not available to translate")
return None
def format_resp(self, *, resp: Translated, text: str) -> BetterEmbed:
"""Formats the response into an embed"""
src = LANGUAGES.get(resp.src) or resp.src
dest = LANGUAGES.get(resp.dest) or resp.dest
conf = round(resp.confidence * 100, 1)
f_confidence = str(conf) + "%"
if conf < 50.0:
f_confidence += " (might be innacurate)"
embed = BetterEmbed(title="Translated something !")
fields = (
("original", text, False),
("Translation", resp.text, False),
("Confidence", f_confidence, True),
("Languages", f"{src} -> {dest}", True),
)
return embed.add_fields(fields)
def initialiseWidgets(self):
self.labelSearchResult.setHidden(True)
self.textEditSearch.setAlignment(QtCore.Qt.AlignBottom)
self.isShownMainTable = True
self.buttonCheck.clicked.connect(self.buttonCheck_on_click)
self.buttonMemory.clicked.connect(self.buttonMemory_on_click)
self.buttonBack.clicked.connect(self.buttonBack_on_click)
self.buttonSave.clicked.connect(self.buttonSave_on_click)
self.buttonQuit1.clicked.connect(self.buttonQuit_on_click)
self.buttonQuit2.clicked.connect(self.buttonQuit_on_click)
self.textEditSearch.textChanged.connect(self.search_as_you_type)
self.buttonTranslate.clicked.connect(self.buttonTranslate_on_click)
self.tableWidget.itemChanged.connect(self.prepareForSaving)
self.buttonCheck.setHidden(True)
self.buttonSave.setHidden(True)
self.buttonBack.setHidden(True)
self.labelFrom.setHidden(True)
self.labelTo.setHidden(True)
self.comboBoxRangeStart.setHidden(True)
self.comboBoxRangeEnd.setHidden(True)
self.memoryMode = False
self.resetMode = False
self.searchMode = False
self.langDict = dict((v.capitalize(), k) for k, v in LANGUAGES.items())
self.comboBoxLang.addItems(self.langDict.keys())
self.comboBoxLang.currentIndexChanged.connect(
self.changeTranslationLang)
self.comboBoxLang.setCurrentText('English')
difficulties = [str(i + 1) for i in range(4)]
self.comboBoxDifficulty.addItems(difficulties)
self.comboBoxRangeType.addItems(['Alphabet', 'Number'])
self.comboBoxRangeType.currentIndexChanged.connect(
self.changeRangeType)
self.plainTextInput.installEventFilter(self)
self.plainTextInput.hasSelected = False
self.comboBoxRangeStart.currentIndexChanged.connect(
self.changeStartWord)
self.prepareForMemoryMode()
# note area
self.checkBox.toggled.connect(self.checkBox_on_stateChanged)
self.checkBox_on_stateChanged()
self.pushButtonNoteOpen.clicked.connect(self.buttonNoteOpen_on_click)
self.pushButtonNoteSave.clicked.connect(self.buttonNoteSave_on_click)
self.pushButtonNoteNew.clicked.connect(self.buttonNoteNew_on_click)
self.notePath = ''
openAction = QtWidgets.QAction('&Open', self)
openAction.setShortcut('Ctrl+O')
openAction.setStatusTip('Open document')
openAction.triggered.connect(self.fileMenuOpenAction)
# self.checkBox.checkStateSet()
logging.debug("intialise widgets done")
def tr_engine(text="Confused Bonking Face."):
kk = Config.LANG if LANGUAGES.get(Config.LANG) else 'en'
if kk == 'en':
hmm = text
else:
try:
translator = google_translator()
translated = translator.translate(text, lang_tgt=kk)
hmm = translated
except:
hmm = text
return hmm
async def translateme(trans):
"""For .trt command, translate the given text using Google Translate."""
if trans.is_reply and not trans.pattern_match.group(1):
message = await trans.get_reply_message()
message = str(message.message)
else:
message = str(trans.pattern_match.group(1))
if not message:
return await trans.edit(
"**Give some text or reply to a message to translate!**"
)
await trans.edit("**Processing...**")
translator = Translator()
try:
from userbot.modules.sql_helper.globals import gvarstatus
except AttributeError:
return await trans.edit("**Running on Non-SQL mode!**")
if gvarstatus("trt_lang") is not None:
target_lang = str(gvarstatus("trt_lang"))
else:
target_lang = "en"
try:
reply_text = translator.translate(deEmojify(message), dest=target_lang)
except ValueError:
return await trans.edit(
"**Invalid language selected, use **`.lang trt <language code>`**.**"
)
source_lang = LANGUAGES.get(reply_text.src).title() # type: ignore
target_lang = LANGUAGES.get(target_lang).title()
reply_text = f"From: **{source_lang}**\nTo: **{target_lang}**\n\n{reply_text.text}" # type: ignore
await trans.edit(reply_text)
async def traduz(message, _):
msg = message.content.strip().lower().split()
if len(msg) < 4:
return Exception
cod1 = msg[-1]
cod2 = msg[-2]
if (len(cod1) > 2 and cod1 in list(LANGUAGES.values())):
for k in LANGUAGES.keys():
if LANGUAGES[k] == cod1:
cod1 = k
elif (len(cod1) == 2 and cod1 not in list(LANGUAGES.keys())):
return Exception
if (len(cod2) > 2 and cod2 in list(LANGUAGES.values())):
for k in LANGUAGES.keys():
if LANGUAGES[k] == cod2:
cod2 = k
elif (len(cod2) == 2 and cod2 not in list(LANGUAGES.keys())):
return Exception
msg = ' '.join(msg[1:-2])
out = translator.translate(text=msg, dest=cod1, src=cod2).text
await message.channel.send(out)
async def translate(event):
if event.reply_to_msg_id:
msg = await event.get_reply_message()
msg = msg.message
else:
msg = event.pattern_match.group(1)
if not msg:
await event.edit(msgRep.NO_TEXT_OR_MSG)
return
await event.edit(msgRep.TRANSLATING)
try:
translator = Translator()
result = translator.translate(text=msg, dest=DEST_LANG, src="auto")
if result.src == result.dest:
await event.edit(msgRep.SAME_SRC_TARGET_LANG)
return
src_lang = LANGUAGES.get(result.src, "Unknown")
target_lang = LANGUAGES.get(result.dest, "Unknown")
text = f"{msgRep.DETECTED_LANG}: <b>{src_lang.title()}</b>\n"
text += f"{msgRep.TARGET_LANG}: <b>{target_lang.title()}</b>\n\n"
if not event.reply_to_msg_id:
text += f"<b>{msgRep.ORG_TEXT}:</b>\n"
text += msg + "\n\n"
text += f"<b>{msgRep.TRANS_TEXT}:</b>\n"
text += result.text
await event.edit(text, parse_mode="html")
except MessageTooLongError:
await event.edit(msgRep.MSG_TOO_LONG)
except Exception as e:
log.warning(e)
if event.reply_to_msg_id:
await event.edit(msgRep.FAIL_TRANS_MSG)
else:
await event.edit(msgRep.FAIL_TRANS_TEXT)
return
def translator_function():
from googletrans import Translator, LANGUAGES
translator = Translator()
final_language = session.attributes['language']
audio_string = session.attributes['message']
"""
Takes in audio and translates it into a new language
Parameters:
audio: The string which you wish to translate
final_language: The language which you wish to translate to
Returns:
Translated_string: Gives back the translated string for alexa to speak back
"""
#figures out what the origin language is
language_initial = translator.detect(audio_string)
#figure out the output language
language_codes = dict(map(reversed, LANGUAGES.items()))
final_language = final_language.lower()
translated_language = language_codes[final_language]
#translate the thing
final_translate = translator.translate(audio_string,
dest=translated_language,
src=language_initial.lang)
#back_language=translator.translate(final_translate.text)
if final_translate.dest == 'it':
output = final_translate.text
elif final_translate.dest == 'ja':
output = final_translate.text
elif final_translate.dest == 'de':
output = final_translate.text
elif final_translate.dest == 'fr':
output = final_translate.text
elif final_translate.dest == 'es':
output = final_translate.text
else:
translation = []
audio_string_list = audio_string.split()
for i in range(len(audio_string_list)):
final_translate = translator.translate(audio_string_list[i],
dest=translated_language,
src=language_initial.lang)
if final_translate.pronunciation is None:
translation.append(final_translate.text)
else:
translation.append(final_translate.pronunciation)
output = " ".join(translation)
return output
async def tr_engine(event, text, parse_mode='md'):
kk = Config.LANG if LANGUAGES.get(Config.LANG) else 'en'
if kk == 'en':
await event.edit(text, parse_mode=parse_mode)
else:
try:
translator = google_translator()
translated = translator.translate(text, lang_tgt=kk)
hmm = translated
except:
hmm = text
await event.edit(hmm, parse_mode=parse_mode)
return
async def set_lang(event):
global DEST_LANG
args = event.pattern_match.group(1).split()
if len(args) != 1:
await event.edit(msgRep.MULT_ARGS)
return
args = args[0]
if args not in LANGUAGES.keys():
await event.edit(msgRep.INV_CT_CODE.format(build_supported_langs()))
return
DEST_LANG = args
await event.edit(msgRep.SUCCESS_LANG_CHANGE.format(LANGUAGES[args]))
return
def LangTranslate(request):
language = list(LANGUAGES.values())
ajx = False
if request.method == 'POST':
if request.POST.get('text_up'):
text = request.POST.get('text')
elif request.POST.get('url_up'):
url_up = request.POST.get('text')
url = re.search("(?P<url>https?://[^\s]+)", url_up).group("url")
downloaded = trafilatura.fetch_url(url)
text = trafilatura.extract(downloaded)
elif request.POST.get('upld'):
text = upload(request.FILES['file'])
if request.is_ajax():
text = request.POST.get('text')
ajx = True
inputLanguage = str(request.POST.get('in_lang')).lower()
outputLanguage = str(request.POST.get('out_lang')).lower()
dataToTranslate = text
print(inputLanguage, outputLanguage)
translator = Translator(from_lang=inputLanguage,
to_lang=outputLanguage)
translation = translator.translate(dataToTranslate)
if ajx:
return JsonResponse(
{
'translation': translation,
'language': language,
'text': text
},
status=200)
else:
return render(
request, 'LangTranslate.html', {
'translation': translation,
'language': language,
'text': text,
'in_lang': inputLanguage,
'out_lang': outputLanguage
})
else:
if ajx:
return JsonResponse(None, status=200)
else:
return render(request, 'LangTranslate.html',
{'language': language})
def translate(phrase, n=20):
current_lang = ''
current_phrase = ''
for i in range(n-1):
dest = choice(list(LANGUAGES.keys()))
if i == 0:
translated = translator.translate(phrase, src="en", dest=dest)
current_lang = dest
current_phrase = translated.text
else:
translated = translator.translate(
current_phrase, src=current_lang, dest=dest)
current_lang = dest
current_phrase = translated.text
final = translator.translate(current_phrase, src=current_lang, dest="en")
return final.text
def qwerty_main(message):
text = utils.textparser(message)
if text is None:
logger.write_log("none", message)
return
logger.write_log(text, message)
arg1, arg2 = utils.extract_arg(message.text,
1), utils.extract_arg(message.text, 2)
if arg2 is None:
tab1 = utils.layouts.get(utils.extract_lang(text))
tab2 = utils.layouts.get(arg1)
else:
tab1 = utils.layouts.get(arg1)
tab2 = utils.layouts.get(arg2)
if tab1 is None and arg2 is None:
utils.bot.reply_to(
message,
"Исходный язык не распознан. Неправильный аргумент или неверно распознан "
"язык? (" + LANGUAGES.get(utils.extract_lang(text)) + ")\n"
"Попробуйте указать исходный язык вручную. Возможно, язык отсутствует в "
"словаре символов")
return
if tab1 is None or tab2 is None:
utils.bot.reply_to(
message,
"Неизвестная раскладка. Возможно, язык отсутствует в словаре символов"
)
return
try:
translated_text = text.translate(str.maketrans(tab1, tab2))
utils.bot.reply_to(message, translated_text)
except Exception as e:
logger.write_log("ERR: " + str(e) + "\n" + traceback.format_exc())
utils.bot.reply_to(
message,
"Ошибка смены раскладки текста. Обратитесь к авторам бота\n"
"Информация для отладки сохранена в логах бота.")
def list_of_langs():
output = "Список всех кодов и соответствующих им языков:\n"
for key, value in LANGUAGES.items():
output = output + key + " - " + value + "\n"
output = output + "\nСписок всех доступных раскладок клавиатуры: "
for key, value in layouts.items():
output = output + key + " "
try:
file = open("langlist.txt", "w")
file.write(output)
file.close()
logger.write_log("INFO: langlist updated successful")
except Exception as e:
logger.write_log("ERR: langlist file isn't available")
logger.write_log("ERR: " + str(e) + "\n" + traceback.format_exc())
async def lang(self, ctx: commands.Context):
langs = {}
i = 0
taille = 0
for key, value in LANGUAGES.items():
languages = f"**`{key}`**: *{value}*"
taille += len(languages)
if taille > 1300:
i += 1
taille = 0
if not i in langs:
langs[i] = []
langs[i].append(languages)
await ctx.author.send("**Voici la liste de toutes les langues disponibles:**")
for j in range(i+1):
await ctx.author.send("\n".join(langs[j]))
await ctx.author.send(f"__**Veuillez utiliser l'abréviation pour traduire une phrase dans le serveur.**__ Par exemple pour traduire 'Bonjour' en anglais je vais écrire `{ctx.prefix}{self.translate.name} en Bonjour` et la phrase sera traduite en anglais.")
