async def on_message(message):
msg = str(message.content).strip()
msg = msg.replace('https://', '').replace('http://', '')
users_to_replace = set()
for ma_user in re_user.finditer(msg):
uid = int(ma_user.group(1))
user = message.guild.get_member(uid)
users_to_replace.add((uid, user.name))
if msg.startswith('TTTS'):
ttts = True
msg = msg[4:].strip()
else:
ttts = False
if not message.author.bot and len(msg) > 4:
try:
msg_en = googletrans.Translator().translate(msg, dest='en').text
msg_no = googletrans.Translator().translate(msg, dest='no').text
for uid, name in users_to_replace:
msg = re.sub(f'[<][@][!]? *{uid} *[>]', name, msg)
msg_en = re.sub(f'[<][@][!]? *{uid} *[>]', name, msg_en)
msg_no = re.sub(f'[<][@][!]? *{uid} *[>]', name, msg_no)
logging.info(f'{msg=} {msg_no=} {msg_en=}')
if msg_no.lower().strip() != msg.lower().strip():
await message.channel.send(f"{message.author.name}: {msg_no}",
delete_after=60 * 60,
tts=ttts)
elif msg_en.lower().strip() != msg.lower().strip():
await message.channel.send(f"{message.author.name}: {msg_en}",
delete_after=60 * 60,
tts=ttts)
except Exception as err:
logging.exception('Could not translate the message!')
async def translate(ctx, *phrase):
phrase = " ".join(phrase[:])
detect = googletrans.Translator().detect(phrase)
if (detect.lang == nativeLang):
await ctx.send("Message was already in English.")
return
else:
print(detect.lang)
translated = googletrans.Translator().translate(phrase,
dest=nativeLang,
src=detect.lang)
await ctx.channel.trigger_typing()
await ctx.channel.send(ctx.author.name + ' said: ' + translated.text +
'\n' + str(languages.get(detect.lang)))
def translate_twice(
x
): # Use Random Language Codes to Recycle English To Slightly Alter Syntax/Diction
lang = choose_lang1()
lang2 = choose_lang2()
first = googletrans.Translator().translate(text=x, dest=lang,
src='en').text
second = googletrans.Translator().translate(first, dest='en',
src=lang).text
third = googletrans.Translator().translate(second, dest=lang2,
src='en').text
english_cycled = googletrans.Translator().translate(third,
dest='en',
src=lang2).text
return english_cycled
def translate_unified_text2(df):
for row in range(len(df)):
translator = googletrans.Translator()
text = str(df['unified_text'].get_value(row))
text1 = emoji.demojize(text)
trans = translator.translate(text1, dest='en')
df['unified_text'][row]= trans.text
def trans_late_literate(input_word):
translator = googletrans.Translator()
for language in language_list:
if language in ('bg', 'el', 'hy', 'ka', 'l1', 'mk', 'mn', 'ru', 'sr',
'uk'):
result = translator.translate(word, dest=language,
src='en').text.lower()
result_transliterated = translit(result, language, reversed=True)
d[language] = result_transliterated
d[language + '.t'] = result
elif language == 'be':
result = translator.translate(word, dest=language,
src='en').text.lower()
result_transliterated = translit(result, 'ru', reversed=True)
result_transliterated = result_transliterated.replace('ў', 'u')
d[language] = result_transliterated
d[language + '.t'] = result
else:
result = translator.translate(word, dest=language,
src='en').text.lower()
d[language] = result
def translateTitle(oldTitle):
try:
translator = googletrans.Translator()
newTitle = translator.translate(oldTitle).text
except:
return oldTitle
return newTitle
def send_message():
#socketId = request.form['socketId']
trans = googletrans.Translator()
message = request.form['message']
global lang_flag
lang = nlp(message)
print(lang._.languages)
if 'hi' in lang._.languages or 'bh' in lang._.languages:
lang_flag = 1
# print(doc._.language_scores['bh'])
message = trans.translate(message ,src='hi', dest='en').text
elif 'en' in lang._.languages or not lang._.languages:
lang_flag = 0
print('i am eng')
print(message)
project_id = os.getenv('DIALOGFLOW_PROJECT_ID')
fulfillment_text, fulfillment_msg = detect_intent_texts(project_id, "unique", message, 'en')
response_text = { "message": fulfillment_text }
print(fulfillment_text)
print(fulfillment_text != "undefined")
if(fulfillment_text != "undefined"):
pusher_client.trigger('movie_bot', 'new_message',
{'human_message': message, 'bot_message': fulfillment_msg})
return jsonify(response_text)
async def translate(client: AsyncClient, room_id: str, message: str):
try:
roomsdb = pickle.load(open(roomsfile, "rb"))
except FileNotFoundError:
roomsdb = {}
if room_id in allowed_rooms and room_id in roomsdb.keys():
# Remove special characters before translation
message = sub('[^A-z0-9\-\.\?!:\sÄäÜüÖö]+', '', message)
trans = googletrans.Translator()
logger.debug(f"Detecting language for message: {message}")
message_source_lang = trans.detect(message).lang
if roomsdb[room_id]["bidirectional"]:
languages = [roomsdb[room_id]["source_langs"][0], roomsdb[room_id["dest_lang"]]]
if message_source_lang in languages:
# there has to be a simpler way, but my brain is tired
dest_lang = set(languages).difference([message_source_lang])
if len(dest_lang) == 1:
dest_lang = dest_lang.pop()
translated = trans.translate(message, dest=dest_lang).text
await send_text_to_room(client, room_id, translated)
else:
if message_source_lang != roomsdb[room_id]["dest_lang"] and (roomsdb[room_id]["source_langs"] == ['any'] or message_source_lang in roomsdb[room_id]["source_langs"]):
translated = trans.translate(message, dest=roomsdb[room_id]["dest_lang"]).text
await send_text_to_room(client, room_id, translated)
def trans(fC="Ok", src="en", dest="ru", translator=googletrans.Translator()):
"""fC - строка для перевода
src = "en" - язык источника
dest = "ru" - язык назначения
translator = googletrans.Translator() - объект библиотеки переводчика
"""
isMistake = False
translation = "n/a"
mistakeValue = [""]
notTranslated = ""
tr = translator.translate(fC, src="en", dest=dest)
if tr.extra_data["possible-mistakes"] != None:
isMistake = True
mistakeValue = tr.extra_data
elif tr.origin == tr.text:
if tr.extra_data["all-translations"] != None:
#Библиотека не смогла определиться с вариантом перевода, берем первый из предложенных
translation = tr.extra_data["all-translations"][0][1][
0] + " <-> " + tr.origin + "\n"
else:
#Здесь какая-то фича библиотеки. То что вываливается здесь, вполне корректно переводится, если лежит в урезанном файле. Отправляем на доработку
notTranslated = fC
else:
#Все перевелось без ошибок
translation = tr.origin + " <-> " + tr.text + "\n"
return isMistake, translation, notTranslated, mistakeValue
def translate_strings(data,
source_language='en_EN.UTF-8',
destination_language='de_DE.UTF-8',
translator=None):
"""
automatic translation of strings in a dict
Args:
data (dict or str): data to translate
source_language (str, optional): source language. Defaults to 'en_EN.UTF-8'.
destination_language (str, optional): destination language. Defaults to 'de_DE.UTF-8'.
translator (googletrans.Translator, optional): for caching of the instance. Defaults to None.
Returns:
dict or str: translated object
"""
if not translator:
try:
import googletrans
translator = googletrans.Translator()
except ImportError:
logger.warning(
'Failed to load googletans module during automatic string translation'
)
return data
if type(data) == str:
return translator.translate(data,
src=source_language,
dest=destination_language).text
elif type(data) == dict:
for k, v in data.items():
data[k] = translate_strings(v, source_language,
destination_language)
return data
def __init__(
self,
# Default destination language
dest_lang,
nlp_download_dir = None
):
# 바보 nltk is broken, https://stackoverflow.com/questions/38916452/nltk-download-ssl-certificate-verify-failed
# TODO Write our own translator
Ssl.disable_ssl_check()
try:
import nltk
import googletrans
# Default destination language
self.dest_lang = Translator.map_to_correct_nltk_lang_localisation_code(
lang_code = dest_lang
)
# The model data required for translation
nltk.download('punkt', download_dir=nlp_download_dir)
# Need to add path otherwise nltk will not find it
nltk.data.path.append(nlp_download_dir)
self.translator = googletrans.Translator()
except Exception as ex:
errmsg =\
str(self.__class__) + ' ' + str(getframeinfo(currentframe()).lineno)\
+ ': Exception instantiating Translator object for destination language "'\
+ str(self.dest_lang) + '": ' + str(ex) + '.'
lg.Log.error(errmsg)
raise Exception(errmsg)
def __init__(self, **kwargs):
model_name = kwargs['model']
seed = kwargs['seed']
self.length = kwargs['len']
top_k = kwargs['top_k']
self.lang_target = kwargs['language']
self.enc = encoder.get_encoder(model_name)
self.translator = googletrans.Translator()
hparams = model.default_hparams()
with open(os.path.join('./data/models', model_name, 'hparams.json')) as f:
hparams.override_from_dict(json.load(f))
self.lang_model = hparams.n_lang #get the language of the model from Hyperparameter
# start session
self.sess = tf.Session()
self.context = tf.placeholder(tf.int32, [1, None])
np.random.seed(seed)
tf.set_random_seed(seed)
self.output = sample.sample_sequence(
hparams=hparams, length=self.length,
context=self.context,
batch_size=1,
temperature=1,
top_k=top_k, top_p=0
)
# restore transformer model from last checkpoint
saver = tf.train.Saver()
ckpt = tf.train.latest_checkpoint(os.path.join('./data/models', model_name))
saver.restore(self.sess, ckpt)
def path_schwurbel(path, text):
"""
Feeds the given text through the given path of languages. The resulting
translation is returned.
Args:
path (list): List of languages to translate through.
text (str): The text to translate.
Returns:
The resulting translated text as a string.
Examples:
Translate "My hovercraft is full of eels." from English to Japanese and
back to English:
.. code-block:: python
path = 'en,ja,en'
text = 'My hovercraft is full of eels.'
translated = path_schwurbel(path, text)
"""
trans = googletrans.Translator()
translated = text
for src, dest in zip(path, path[1:]):
translated = trans.translate(translated, src=src, dest=dest)
assert translated.src == src
assert translated.dest == dest
translated = translated.text
sleep(COOLDOWN)
return translated
def run_fizzbuzz(i):
'''
This function runs Kwame's fizzbuzz, which prints out numbers from 1 to i,
except for each third number it prints a partying face emoji,
every fifth number it prints a cowboy hat face emoji,
every fifteenth number it prints a face screaming in fear emoji,
and every other number prints as the Spanish translation of its English word.
'''
fizzbuzz = emojize(':face_screaming_in_fear:')
fizz = emojize(':partying_face:')
buzz = emojize(':cowboy_hat_face:')
translator = googletrans.Translator()
p = inflect.engine()
for i in range(1, i + 1):
if i % 3 == 0 and i % 5 == 0:
print(fizzbuzz)
elif i % 3 == 0:
print(fizz)
elif i % 5 == 0:
print(buzz)
else:
numword = p.number_to_words(i)
result = translator.translate(numword, dest='es')
print(result.text)
def show(node):
trans = googletrans.Translator()
result2 = trans.translate(" ".join(node.leaves()),
dest="zh-cn",
src='en')
# result2 = trans.translate("post ", dest="zh-cn", src='en')
print(result2.get_text())
def __init__(self, sentence):
en_parser = StanfordParser(
path_to_jar=
'../stanford-parser-full-2018-02-27/stanford-parser.jar',
path_to_models_jar=
'../stanford-parser-full-2018-02-27/stanford-parser-3.9.1-models.jar',
model_path=
'../stanford-parser-full-2018-02-27/stanford-parser-3.9.1-models/edu/stanford/nlp/models/lexparser/englishPCFG.ser.gz'
)
sg = StanfordTokenizer(
path_to_jar='../stanford-parser-full-2018-02-27/stanford-parser.jar'
)
self.status = 0
self.trans = googletrans.Translator()
self.sentence = sentence.strip("\n").replace(" ", "")
en_trans = self.trans.translate(sentence).text
en_trans = sg.tokenize(en_trans)
try:
tree = list(en_parser.parse(en_trans))
self.tree = tree[0]
# print(self.tree)
self.rel = []
except:
self.status = 1
async def _traduzir(self, ctx, dest=None, *, frase=''):
if dest and frase:
from googletrans.constants import LANGUAGES
dests = []
for lang in LANGUAGES.items():
# vai pegar o dicionario de todas as linguas que o módulo aceita
# e transformar em uma lista, apenas com a abreviação
dests.append(lang[0])
if not dest in dests: # se o "dest" que a pessoa passou não for válido:
return await ctx.send(
f'Não encontrei nenhuma lingua chamada ``{dest}``!\n' +
'Por favor, verifique se você digitou a abreviação certa!\n'
+ '<a:sad:755774681008832623>')
# anti mention:
if ctx.message.mentions: # se tiver alguma menção na mensagem
for mention in ctx.message.mentions:
frase = frase.replace(f'<@{mention.id}>', '')
frase = frase.replace(f'<@!{mention.id}>', '')
frase = frase.replace(f'@',
'@\uFEFF') # quebra o @everyone e o @here
# se após a remoção das menções, não sobrar nada, para a execução
if len(frase.replace(' ', '')) == 0:
return await self.bot.send_help(ctx)
msg = googletrans.Translator().translate(frase, dest=dest).text
await ctx.send(content=f'{ctx.author.mention} {msg}')
else:
await self.bot.send_help(ctx)
def test_translateChelbesOneWordENGPL():
sentence = "England"
translator = googletrans.Translator()
lang_from = 'en'
lang_to = 'pl'
result = translateChelbes(translator, sentence, lang_from, lang_to)
assert result.lower() == "anglia"
async def transchat(self, ctx, lang1, lang2, member: discord.Member):
'''
Lets you have a real-time translated chat
Required arguments: <lang_of_the_user> <lang_of_other_user> <mention_of_other_user>
'''
translator = googletrans.Translator()
while True:
await ctx.send(f"{translator.translate('It is your turn', dest=lang1, src='en').text} {ctx.author.mention}")
reply1 = await self.bot.wait_for('message', check=lambda message: message.author == ctx.author)
reply1 = reply1.content
if reply1 == "STOPPY":
break
await ctx.send(translator.translate(text=reply1, dest=lang2, src=lang1).text)
await ctx.send(f"{translator.translate('It is your turn', dest=lang2, src='en').text} {member.mention}")
reply2 = await self.bot.wait_for('message', check=lambda message: message.author == member)
reply2 = reply2.content
if reply2 == "STOPPY":
break
await ctx.send(translator.translate(text=reply2, dest=lang1, src=lang2).text)
def test_translateChelbesSentencePLENG():
sentence = "To jest mój kot"
translator = googletrans.Translator()
lang_from = 'pl'
lang_to = 'en'
result = translateChelbes(translator, sentence, lang_from, lang_to)
assert result.lower() == "this is my cat"
def test_translateChelbesSentenceENGPL():
sentence = "I have a dog"
translator = googletrans.Translator()
lang_from = 'en'
lang_to = 'pl'
result = translateChelbes(translator, sentence, lang_from, lang_to)
assert result.lower() == "mam psa"
def test_translateChelbesOneWordPLENG():
sentence = "Polska"
translator = googletrans.Translator()
lang_from = 'pl'
lang_to = 'en'
result = translateChelbes(translator, sentence, lang_from, lang_to)
assert result.lower() == "poland"
def __init__(self, service, testing=False):
super().__init__(service)
self.translator = googletrans.Translator()
self.LANGUAGES = googletrans.LANGUAGES
self.LANGCODES = googletrans.LANGCODES
self.default = self.LANGCODES[service['params']
['default_language'].lower()]
def _translate():
while True:
try:
# https://github.com/ssut/py-googletrans/issues/234#issuecomment-736314530
return googletrans.Translator(service_urls=['translate.googleapis.com']).translate(text, src=src_lang, dest=dest_lang)
except AttributeError:
time.sleep(0.5)
async def _translate(self, ctx, text, *, langs=""):
""": Translate things you don't understand
"""
def convert(s: str) -> dict:
a = s.lower().split()
res = {
a[i]: a[i + 1]
for i in range(len(a)) if a[i] in ("from", "to")
}
res["from"] = res.get("from") or "auto"
res["to"] = res.get("to") or "en"
return res
try:
langdict = convert(langs)
except IndexError:
raise commands.BadArgument("Invalid language format.")
translator = googletrans.Translator()
tmp = functools.partial(translator.translate,
text,
src=langdict["from"],
dest=langdict["to"])
try:
async with ctx.typing():
res = await self.bot.loop.run_in_executor(None, tmp)
except ValueError as e:
raise commands.BadArgument(e.args[0].capitalize())
await ctx.send(res.text.replace("@", "@\u200b"))
def main():
ARXIV_URL = get_arxiv_url_from_envvar()
DEST_LANG = get_dest_lang_from_envvar()
ARXIV_VANITY_BASE_URL = get_arxiv_vanity_base_url_from_envvar()
SLACK_WEBHOOK_URL = get_slack_webhook_url_from_envvar()
slack_user_info = get_slack_user_info_from_envvar()
translator = googletrans.Translator()
updated = ''
while True:
feed = feedparser.parse(ARXIV_URL)
handling_feed_error(feed)
if feed['updated'] == updated:
time.sleep(10 * 60)
continue
updated = feed['updated']
print(f'updated at {updated}')
datas_to_send_to_slack = []
for entry in feed['entries']:
paper_info = get_paper_info_from_entry(entry, translator, DEST_LANG, ARXIV_VANITY_BASE_URL)
if paper_info == False:
continue
paper_info_text = combine_paper_info_to_text(paper_info)
data_to_send_to_slack = {'text': paper_info_text, **slack_user_info}
datas_to_send_to_slack.append(json.dumps(data_to_send_to_slack))
for data_to_send_to_slack in datas_to_send_to_slack:
requests.post(SLACK_WEBHOOK_URL, data=data_to_send_to_slack)
time.sleep(10 * 60)
def qr_gxlate(self, s):
self.gbeg_t = time.time()
translator = googletrans.Translator()
res = translator.translate(s).text
self.gend_t = time.time()
return res
def __init__(self, **kwargs):
self.kwargs = kwargs
self.translator = None
if self.kwargs.get('translate') in ('1', 'true'):
self.translator = googletrans.Translator(
service_urls=['translate.google.cn', 'translate.google.cn']
)
def get_diner() -> Diner:
menu = Diner()
translator = googletrans.Translator()
with requests.Session() as session:
reset_session(session)
start_new_command(session)
for category, url in [("plats", url_diner_meals),
("desserts", url_diner_desserts)]:
print("Looking for %s..." % category)
res = session.get(url) # Get menu
soup_diner = make_soup(res)
dish_diner_selects = soup_diner.find_all(
"select", {"class": "js-item-quantity"})
for dish_select in dish_diner_selects:
quantity = int(dish_select.find_all("option")[-1].get_text())
dish_diner_div = dish_select.parent.parent.parent
dish_diner = dish_diner_div.find("h3").get_text().strip()
dish_diner = sanitize_and_spellcheck(dish_diner)
menu[category].append(
(dish_diner, translator.translate(dish_diner,
src="fr").text,
quantity))
return menu
def _do_translate(text: List[str], to_lang: str) -> List[googletrans.models.Translated]:
"""
Call google translate API to translate given text
:param **kwargs:
:param text: The source text(s) to be translated. Batch translation is supported via sequence input.
:type text: UTF-8 :class:`str`; :class:`unicode`; string sequence (list, tuple, iterator, generator)
:return: translated text in the same form it was provided
"""
# Google API provider should allow new access every 1h, but if more translations need to be done,
# a number of different country providers are given
# E.g. from here https://sites.google.com/site/tech4teachlearn/googleapps/google-country-codes
# But have to make sure the site actually loads first :)
ending_formula = re.compile(r'translate\..*?\.(.+)$') # for for com, co.uk, lt or others
provider_endings = (ending_formula.search(url).group(1) for url in googletrans.constants.DEFAULT_SERVICE_URLS)
provider_base = 'translate.googleapis'
for ending in provider_endings:
provider = f'{provider_base}.{ending}'
translator = googletrans.Translator(service_urls=[provider])
try:
return translator.translate(text, dest=to_lang)
except AttributeError:
logging.info(f'Provider "{provider}" got blocked, trying another one...')
exit('No more providers left to try, try updating the provider list or wait 1h until you get unblocked.')
