def vim_gtranslate():
to_lang = vim.eval('g:gtrans_output_language') or 'fr'
from_lang = vim.eval('g:gtrans_input_language') or 'en'
trans = translate.Translator(to_lang=to_lang, from_lang=from_lang)
encoding = vim.eval('&encoding') or 'utf-8'
buff = vim.current.buffer
cur = vim.current
cursor = cur.window.cursor
res = ''
if buff.mark('<') and buff.mark('>') and cursor[1] == 0 \
and buff.mark('<')[0] <= cursor[0] <= buff.mark('>')[0]:
# visual mode
res = __do_visual(buff, cur)
else:
# cursor mode
res = __do_cursor(cur)
translated = ''
try:
translated = trans.translate(res if res else '')
except urllib2.HTTPError:
pass
print translated.encode(encoding)
async def translate(cmd, message, args):
if not args:
embed = discord.Embed(color=0xDB0000, title='❗ No Arguments Given')
await message.channel.send(None, embed=embed)
return
trans_qry = args[0]
if '>' not in trans_qry:
embed = discord.Embed(color=0xDB0000,
title='❗ Invalid Translation Query')
await message.channel.send(None, embed=embed)
return
to_trans = ' '.join(args[1:])
from_lang, to_lang = trans_qry.split('>')
translator = trans.Translator(from_lang=from_lang, to_lang=to_lang)
transed = translator.translate(to_trans)
embed = discord.Embed(color=0x1abc9c, title='📚 Translated')
embed.add_field(name=f'From {from_lang.upper()}',
value=f'```\n{to_trans}\n```',
inline=False)
embed.add_field(name=f'To {to_lang.upper()}',
value=f'```\n{transed}\n```',
inline=False)
await message.channel.send(None, embed=embed)
def translate_list(wordlist, input_lang, output_lang, file_dest):
"""
Takes a list of words as a .csv file with 1 column and writes a new .csv file with the translation of
the words in the second column.
:param wordlist: path to a .csv file of words
:param input_lang: The language of the input file
:param output_lang: The language to which to translate the words
:param file_dest: The path to which to write the new .csv file
"""
# read input file
with open(wordlist, 'r') as csvfile:
reader = csv.reader(csvfile)
vocablist = list(reader)
# create translator
translator = translate.Translator(from_lang=input_lang,
to_lang=output_lang)
# translate
for row in vocablist:
row.append(translator.translate(row[0]))
# write resulting vocab list to .csv file
with open(file_dest + '/' +
os.path.splitext(os.path.basename(wordlist))[0] + '.csv',
'w+',
newline='',
encoding='utf-8') as csvfile:
writer = csv.writer(csvfile,
delimiter=' ',
quotechar='|',
quoting=csv.QUOTE_MINIMAL)
for row in vocablist:
writer.writerow(row)
def translateDict():
print '[+] Please input the location of dictionary'
loc =raw_input().replace("\'", "").replace("\"", "").strip()
while not(os.path.exists(loc.replace("\'", "".replace("\"", "")))):
print "[x] That doesn't seem to exist, try again."
loc = raw_input()
f = open('languages.data', 'r')
x = f.readlines()
choices = x[:]
f.close()
for i in range(len(x)):
print "\t{0}. {1}".format(i,x[i].split('\t')[0])
print "[+] Please select the language to translate to (e.g. 12):"
choice = int(raw_input())
lang = choices[choice].split('\t')[1]
t = translate.Translator(lang.strip())
f = open(loc, 'r')
x = f.read()
f.close()
translated = t.translate(x)
f = open(loc+"-{0}".format(lang.upper()).strip(), 'w')
f.write(translated.encode('utf8'))
f.close()
print "[+] Dictionary translated, saved to {0}...".format(loc+"-{0}".format(lang.upper()))
raw_input()
os.system("clear")
def translate_to_other_language():
tran = tk.Toplevel()
tran.title("Expert Potato")
tran.config(bg="white")
tran.geometry("700x540")
tran.minsize(700, 540)
def copy_tran_textbox_to_clipboard():
pyperclip.copy(tran_textbox.get(1.0, "end"))
def send_mail_in_hindi():
sender_email = os.environ.get(
"sender_email"
) # accessing the sender email from environment variable
sender_pass = os.environ.get(
"sender_pass"
) # accessing the sender password from environment variable
reciever_mail = simpledialog.askstring("input", "Enter e-mail address")
subject = simpledialog.askstring("input", "Subject of mail")
with smtplib.SMTP('smtp.gmail.com', 587) as server:
server.starttls(
) # It will encript the connection using tls (Transport Layer Security)
server.login(sender_email, sender_pass)
msg = MIMEText(f"Subject:{subject}\n\n{result}", "plain",
'utf-8').as_string()
server.sendmail(sender_email, reciever_mail, msg)
print("Mail sent successfully.")
copy_icon = ImageTk.PhotoImage(Image.open("icons/copy.png"), master=tran)
copy = tk.Button(tran,
borderwidth=0,
command=copy_tran_textbox_to_clipboard,
image=copy_icon)
copy.place(x=0, y=0)
mail_button = tk.Button(tran,
command=send_mail_in_hindi,
image=mail_icon,
text="mail")
mail_button.place(x=40, y=0)
text_box_font = tkFont.Font(size=18)
tran_textbox = tk.Text(tran, font=text_box_font)
tran_textbox.place(x=0, y=40, relheight=1, relwidth=1)
text = textbox.get(1.0, "end")
tobj = translate.Translator(to_lang='hi')
# It will create object of the class Translator present in translate module
result = tobj.translate(text)
# It will translate the given text to given language
tran_textbox.insert(tk.END, result)
print("Translation : ", result)
tran.mainloop()
def translate_to_hindi():
trans = translate.Translator(to_lang = 'hi')
# It will create object of the class Translator present in translate module
global result
result = trans.translate(text)
# It will translate the given text to given language
print("Translation : ",result)
return result
def traduzir(self, widget):
global tradutor
self._status.set_text('traduzindo..')
cache = [tradutor.to_lang, tradutor.from_lang]
if self.cache != cache:
self.cache = cache
tradutor = translate.Translator(*self.cache)
tradução = tradutor.translate(obter_texto_buffer(self._buffer))
self._buffer2.set_text(tradução)
self._status.set_text('traduzido')
def completexlate(cfdg2txt):
try:
with closing(translate.Translator(cfdg2txt)) as cfdgxlate:
cfdgxlate.translate()
return flask.json.jsonify({
u'cfdg3txt': cfdgxlate.output.getvalue(),
u'colortarget': cfdgxlate.colortarget,
u'discards': cfdgxlate.extraChars
})
except Exception as e:
flask.abort(400, text(e))
def trocar(self, widget):
global tradutor
cache = self._combobox.get_active()
self._combobox.set_active(self._combobox2.get_active())
self._combobox2.set_active(cache)
cache2 = (
self._combobox.get_model()[self._combobox.get_active_iter()][1])
cache3 = (
self._combobox2.get_model()[self._combobox2.get_active_iter()][1])
tradutor = translate.Translator(cache3, cache2)
self.cache = [cache3, cache2]
async def translation(_cmd, pld):
"""
:param _cmd: The command object referenced in the command.
:type _cmd: sigma.core.mechanics.command.SigmaCommand
:param pld: The payload with execution data and details.
:type pld: sigma.core.mechanics.payload.CommandPayload
"""
if pld.args:
trans_arg = pld.args[0].lower()
sentence = ' '.join(pld.args[1:])
if '\n' in trans_arg:
trans_arg, _, first_arg = trans_arg.partition('\n')
sentence = f'{first_arg} {sentence}'
if '>' in trans_arg:
trans_split = trans_arg.split('>')
from_lang = trans_split[0]
to_lang = trans_split[1]
else:
from_lang = trans_arg
to_lang = 'en'
if sentence:
translator = translate.Translator(to_lang=to_lang,
from_lang=from_lang)
trans_output = translator.translate(sentence)
if 'is an invalid' in trans_output.lower():
lang_iso = trans_output.split()[0].strip("'")
response = GenericResponse(
f'{lang_iso} is an invalid language code.').error()
response.description = f'[Click for a list of language ISO codes]({wiki_url})'
# 'excedeed' is misspelled intentionally
elif 'length limit excedeed' in trans_output.lower():
response = GenericResponse(
'Maximum query limit is 500 characters.').error()
elif 'mymemory warning' in trans_output.lower():
time_pieces = []
for word in trans_output.split(' '):
if word.isdigit():
time_pieces.append(word)
time = ':'.join(time_pieces)
response = GenericResponse(
'Unable to translate more due to rate limits.').error()
response.set_footer(
text=f'More translations available in {time}.')
else:
title = f'🔠Translated from {from_lang.upper()} to {to_lang.upper()}'
response = discord.Embed(color=0x3B88C3, title=title)
response.description = html.unescape(trans_output).replace(
'<@! ', '<@!')
else:
response = GenericResponse('Missing language or sentence.').error()
else:
response = GenericResponse('Nothing inputted.').error()
await pld.msg.channel.send(embed=response)
def initLanguage():
# os.path.dirname(os.path.abspath(file))
# (QtCore.QDir.currentPath() + "/session")
# directory = os.path.dirname(__file__)
# directory = (QtCore.QDir.currentPath() + "/yomi_base/japanese")
#directory = os.path.split(os.path.realpath(__file__))[0]
# fix for --onefile
directory = os.path.dirname(sys.executable) # + "/yomi_base/japanese"
if "Python27" == os.path.basename(directory):
directory = os.path.dirname(__file__)
else:
directory = os.path.dirname(sys.executable) + "/yomi_base/japanese"
return translate.Translator(
deinflect.Deinflector(os.path.join(directory, 'deinflect.json')),
dictionary.Dictionary(os.path.join(directory, 'dictionary.db')))
def translate2chinese(text, retry=10, cache=True):
'''Translate the text to simplified chinese text.'''
if not (text and len(text) > 0):
return None
result = None
cached_dict = {}
if os.path.exists(TRANSLATION_FILE):
with open(TRANSLATION_FILE, 'r') as f:
cached_dict = json.load(f)
result = cached_dict.get(text)
if result:
return result
translator = translate.Translator(to_lang="zh")
try:
result = translator.translate(text)
except (ProxyError, ConnectTimeout, ConnectionError) as e:
logger.error('Connection error!')
if retry >= 0:
time.sleep(5)
result = translate2chinese(text, retry=retry-1)
except AttributeError as e:
pass
except Exception as e:
logger.exception(e)
if cache and result and len(text) <= 100:
cached_dict[text] = result
with open(TRANSLATION_FILE, 'w') as f:
json.dump(cached_dict, f, sort_keys=True, indent=4)
logger.debug(f'translate [{text}] to [{result}]')
return result or text
async def translation(cmd: SigmaCommand, message: discord.Message, args: list):
if args:
if len(args) >= 2:
trans_arg = args[0]
sentence = ' '.join(args[1:])
if '>' in trans_arg:
trans_split = trans_arg.split('>')
from_lang = trans_split[0].lower()
to_lang = trans_split[1].lower()
else:
from_lang = trans_arg
to_lang = 'en'
translator = translate.Translator(to_lang=to_lang, from_lang=from_lang)
trans_output = translator.translate(sentence)
title = f'🔠 Translated from {from_lang.upper()} to {to_lang.upper()}'
response = discord.Embed(color=0x3B88C3, title=title)
response.description = trans_output
else:
response = discord.Embed(color=0xBE1931, title='❗ Missing language or sentence.')
else:
response = discord.Embed(color=0xBE1931, title='❗ Nothing inputted.')
await message.channel.send(embed=response)
async def translation(_cmd, pld):
"""
:param _cmd: The command object referenced in the command.
:type _cmd: sigma.core.mechanics.command.SigmaCommand
:param pld: The payload with execution data and details.
:type pld: sigma.core.mechanics.payload.CommandPayload
"""
if pld.args:
if len(pld.args) >= 2:
trans_arg = pld.args[0].lower()
sentence = ' '.join(pld.args[1:])
if '>' in trans_arg:
trans_split = trans_arg.split('>')
from_lang = trans_split[0]
to_lang = trans_split[1]
else:
from_lang = trans_arg
to_lang = 'en'
translator = translate.Translator(to_lang=to_lang, from_lang=from_lang)
trans_output = translator.translate(sentence)
if 'is an invalid' in trans_output.lower():
lang_iso = trans_output.split()[0].strip("'")
response = error(f'{lang_iso} is an invalid language code.')
response.description = f'[Click for a list of language ISO codes]({wiki_url})'
# 'excedeed' is misspelled intentionally
elif 'length limit excedeed' in trans_output.lower():
response = error('Maximum query limit is 500 characters.')
else:
title = f'🔠Translated from {from_lang.upper()} to {to_lang.upper()}'
response = discord.Embed(color=0x3B88C3, title=title)
response.description = trans_output
else:
response = error('Missing language or sentence.')
else:
response = error('Nothing inputted.')
await pld.msg.channel.send(embed=response)
def loen(update, context):
joke = dadJoke()
translator = translate.Translator(from_lang='en', to_lang='de')
translatedJoke = translator.translate(joke)
context.bot.send_message(chat_id=update.message.chat_id,
text=translatedJoke)
def initLanguage():
directory = os.path.dirname(__file__)
return translate.Translator(
deinflect.Deinflector(os.path.join(directory, u'deinflect.json')),
dictionary.Dictionary(os.path.join(directory, u'dictionary.db')))
#import expander
#import reddit
import translate
t = translate.Translator('jp')
print t.translate("Test Hitler over everything")
f = open('/home/matt/Documents/Code/wordhound/data/industries/Anime/Mangatraders/RedditDictionary.txt')
x = t.translate(f.read())
f.close()
f = open('/home/matt/Desktop/testtranslate.txt', 'w')
f.write(x)
f.close()
#e = expander.expand('/home/matt/Desktop/wordDictCat.txt', '/home/matt/Desktop/expanded.txt')
#e.expand()
#x = reddit.Reddit(["battlefield", "battlefield_4", "battlefield3" ])
#x.crawl()
import pandas as pd
from selenium import webdriver
import requests
from bs4 import BeautifulSoup
import googletrans
import datetime
import translate
translator_a = googletrans.Translator()
translator_b = translate.Translator(to_lang="zh-tw")
driver = webdriver.Chrome()
url1 = "https://news.google.com/search?q=coronavirus%20museum%20when%3A1d&hl=en-US&gl=US&ceid=US%3Aen"
url2 = "https://news.google.com/search?q=coronavirus%20art%20when%3A1d&hl=en-US&gl=US&ceid=US%3Aen"
url3 = "https://news.google.com/search?q=Coronavirus%20art%20industry%20when%3A1d&hl=en-US&gl=US&ceid=US%3Aen"
url4 = "https://news.google.com/search?q=Coronavirus%20cinema%20when%3A1d&hl=en-US&gl=US&ceid=US%3Aen"
url = [url1, url2, url3, url4]
title, publisher, link, translate = [], [], [], []
for i in url:
driver.get(i)
js = "var action=document.documentElement.scrollTop=10000"
driver.execute_script(js)
response = requests.get(i)
soup = BeautifulSoup(response.text, "lxml")
for j in soup.find_all("h3", class_="ipQwMb ekueJc gEATFF RD0gLb"):
title_ = j.text
if title_ not in title:
sub = j.find_next("span", class_="xBbh9")
subtitle = sub.text
title.append(title_ + "/" + subtitle)
try:
translate.append(
translator_a.translate(title_ + "/" + subtitle,
def __init__(self, source_lang, to_lang, **kwargs):
self.source_lang = source_lang
self.to_lang = to_lang
self.translator = translate.Translator(from_lang=source_lang,
to_lang=to_lang,
**kwargs)
def language():
trans = translate.Translator(to_lang='Hindi')
transitive = messagebox.showinfo('Messagebox',
trans.translate('mood is high'))
trans = tkinter.Toplevel(transitive)
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
# 翻译
self._translator = translate.Translator(from_lang='zh', to_lang='ja')
# TTS
self._tts = None
stderr=-1).communicate()[0].replace('\n', '')
if os.path.exists(os.path.join(curDir(), 'kakasi/')):
kakasipath = os.path.join(curDir(), 'kakasi/kakasi-2.3.4/src/kakasi')
def transliterate(text):
if kakasi:
iconv = subprocess.Popen(['iconv', '-f', 'utf8', '-t', 'eucjp'],
stdin=-1,
stdout=-1,
stderr=-1).communicate(text.encode('utf8'))
k = subprocess.Popen(
[kakasipath, '-i', 'euc', '-Ha', '-Ka', '-Ja', '-Ea', '-ka'],
stdin=-1,
stdout=-1).communicate(iconv[0])
return k[0]
else:
return JapaneseTransliterator(text).transliterate_from_hrkt_to_latn()
if len(sys.argv) == 1:
print c.warning + 'Usage: ' + c.default + sys.argv[0] + ' <moonrunes>'
else:
t = ' '.join(sys.argv[1:])
print c.header + 'Original: ' + c.default + ' '.join(t.decode('utf8'))
print c.header + 'Romaji: ' + c.default + transliterate(' '.join(
t.decode('utf8')))
translator = translate.Translator(to_lang='en', from_lang='jp')
print c.header + 'Translation: ' + c.default + translator.translate(t)
print ''
def extend_inputs_dict(inputs, probs, lng, trans_lng):
# if german return
# this language requires a special package
if lng == 'ge':
return inputs
# languages for stopwords
lang_dict = {
'en': 'english',
'fr': 'french',
'ge': 'german',
'it': 'italian'
}
# synsets use different labels for languages
lang_dict2 = {'en': 'eng', 'fr': 'fra', 'it': 'ita'}
# also remove stop words
# words & characters (punctuations) that will be removed
unwanted = list(set(stopwords.words(lang_dict[lng]))) + list(
string.punctuation)
# translate must be performed from english (resulting after synsets)
# into the language of the training dataset (trans_lng)
translator = translate.Translator(from_lng="en", to_lang=trans_lng)
# each input has its array of probabilities
# so we must iterate it for each input
new_inputs = []
for i in range(0, len(probs)):
dif = max(probs[i]) - min(probs[i])
# if difference is 0
# meaning no different probability for different classes
# this is why it usually results in a outcome that makes no sense
# such as for 'sécuritas' it assigns agriculture related code
# which basically has the same probability as any other of PCS
if dif == 0:
my_input = inputs[i]
my_input = my_input.replace("-", " ")
tokens = word_tokenize(my_input)
tokens = [token for token in tokens if token not in unwanted]
tokens = [token.strip() for token in tokens]
# definitions that will be used to replace my_input in inputs
definitions = []
# for each word (token) of input
for token in tokens:
synsets = wn.synsets(token, lang=lang_dict2[lng])
# a single token may have multiple synsets
for syn in synsets:
definition = syn.definition()
if lng != trans_lng:
trans_def = translator.translate(definition)
definitions.append(trans_def)
else:
definitions.append(definition)
new_inputs.append(' '.join(definitions))
new_inputs = prepare_input(new_inputs, trans_lng)
return new_inputs
def code(inputs, clsf, lng, level):
# UPDATE: 08 September 2020 --------------------------------------------
# Irina demanded that feedbacks should have priority in coding
# to allow "faster learning" (which is basically not true technically)
# this PACH is just to avoid further explanations
feedback_outputs = code_from_feedbacks(inputs, clsf, lng, level)
# ---------------------------------------------------------------------
# keep original entry without modifications
# needed for nltk dict fun later
inputs_original_lng = inputs
# training data file and training data
# detect in which language the data should be
try:
rules = CodingRules.objects.get(classification=clsf)
max_level = rules.max_level
# language of training data
languages = json.loads(rules.languages)
if 'any' in languages:
td_file_lng = languages['any']
else:
td_file_lng = languages[lng]
# transcode from another classification after coding
# or use training data available for original
if rules.recode_from != "this":
later_trans_to = clsf
clsf = rules.recode_from
# cannot go deeper than max_level
if level > max_level:
level = max_level
classification = Classification.objects.get(reference=clsf)
except:
# no given rule defined
# this will result in an error
return []
# list of codes corresponding to classification (in try)
codes = Code.objects.filter(parent=classification)
# loading only data that is in the requested language
tdf = TrainingDataFile.objects.filter(classification=clsf,
language=td_file_lng)
# well, its possible that their is no data
# for the selected classfication scheme :)
if len(tdf) == 0:
return []
# well, this is funny part
# if lng of inputs is not equal to td_file_lng
# defined in Coding_Rules, then it must be
# translated to td_file_lng
# this is how we avoid that coding for some
# language would not work because of lack of data
if lng != td_file_lng:
from_lng = lng
if lng == 'ge':
from_lng = 'de'
translator = translate.Translator(from_lang=from_lng,
to_lang=td_file_lng)
for i in range(0, len(inputs)):
inputs[i] = translator.translate(inputs[i])
# 1. tokenization
# 2. clean stop words
# 3. lemmatize
# all that defined in function prepare_input
# that takes inputs and lng args provided here
inputs = prepare_input(inputs, td_file_lng)
# vectorizer to transform data into td-idf
tf = TfidfVectorizer(analyzer="word",
ngram_range=(1, 2),
min_df=0,
sublinear_tf=True)
# filter data
train = TrainingData.objects.filter(parent__in=tdf, level=level)
train_text = [unidecode(t.text) for t in train]
train_codes = [t.code for t in train]
# training data collected through feedbacks
feedbacks = Feedback.objects.filter(classification=clsf,
language=td_file_lng,
level=level)
train_text = train_text + [fb.text for fb in feedbacks]
train_codes = train_codes + [fb.code for fb in feedbacks]
X = tf.fit_transform(train_text)
# finally, model
# complement naive bayes
model = ComplementNB()
model.fit(X, train_codes)
inputs = [unidecode(i) for i in inputs]
inputs_tf = tf.transform(inputs)
output = model.predict(inputs_tf)
# get probabilities of intput belonging to any class
# append other likely predictions
# then if necessary run dictionaries
# dictionary only if max(prob)-min(prob) == 0
probs = model.predict_proba(inputs_tf)
classes = model.classes_
inputs_retrial = extend_inputs_dict(inputs_original_lng, probs, lng,
td_file_lng)
if len(inputs_retrial) > 0:
inputs_retrial = [unidecode(i) for i in inputs_retrial]
inputs_retrial_tf = tf.transform(inputs_retrial)
# now return predictions for those for which prob == 0
outputs_retrial = model.predict(inputs_retrial_tf)
outputs_retrial = outputs_retrial.tolist()
# here we remove those with probs == 0
# if even dictionary has zero prob then no need to keep false code
probs_retrial = model.predict_proba(inputs_retrial_tf)
for i in range(0, len(probs_retrial)):
dif = max(probs_retrial[i]) - min(probs_retrial[i])
if dif == 0:
outputs_retrial[i] = None
for i in range(0, len(probs)):
dif = max(probs[i]) - min(probs[i])
if dif == 0:
output[i] = outputs_retrial.pop(0)
# now if the training dataset was not
# available for the classification against
# which the data was coded
# we must transcode it to that classification
if rules.recode_from != 'this':
try:
crosswalk_file = CrosswalkFile.objects.get(
classification_1=clsf, classification_2=later_trans_to)
crosswalk = Crosswalk.objects.filter(parent=crosswalk_file)
except:
return []
# recode
re_outputs = []
for code in output:
recodes = crosswalk.filter(code_1=code)
recodes = [recode.code_2 for recode in recodes]
re_outputs.append(recodes)
# add results obtained through coding from feedbacks (only! -> PATCH)
for i in range(0, len(re_outputs)):
re_outputs[i] = feedback_outputs[i] + re_outputs[i]
return re_outputs
output = [[out] for out in output]
for i in range(0, len(output)):
output[i] = feedback_outputs[i] + output[i]
return output
syntax_analyzer = syntax.SyntaxAnalyzer()
syntax_analyzer.parse_statements(ust)
syntax_analyzer.pre_process_statements()
syntax_analyzer.classify()
#syntax_analyzer.show()
###################### Syntax Analyzer ######################
######################## Translator ######################
# Declaring translator
translator = translate.Translator()
#print "Grammer:"
#translator.show_grammer()
output = translator.translate(syntax_analyzer.statements)
######################## Translator ######################
# Fetching Compulsary Includes
f = open("compulsary_includes", "r")
includes = f.read()
f.close()
f = open(f_name_output, "w")
import translate
langs = ["de"]
fname = "play.txt"
with open(fname) as f:
content = str(f.readlines())
for lang in langs:
trans = translate.Translator(to_lang=lang)
print trans.translate("child")
transcontent = trans.translate(content).encode("utf8", "ignore")
with open("out_" + lang + ".txt", "w") as text_file:
text_file.write(transcontent)
import translate
import re
import codecs
f_in = open('HeeksCAD.po')
#f_out = codecs.open('de/HeeksCAD.po', encoding='latin_1', mode='w')
#f_out = codecs.open('zh_CN/HeeksCAD.po', encoding='utf_8', mode='w')
#f_out = codecs.open('zh_TW/HeeksCAD.po', encoding='utf_8', mode='w')
# turkish not available yet f_out = codecs.open('tr/HeeksCAD.po', encoding='utf_8', mode='w')
#f_out = codecs.open('translations/es/HeeksCAD.po', encoding='utf_8', mode='w')
translate_str = ''
translator= translate.Translator('es', 'en')
count = 1
while (True):
line = f_in.readline();
if (len(line) == 0) : break;
if(line.find('msgid') != -1):
e = re.compile('msgid "(.*)"')
m = e.search(line)
if m:
translate_str = m.group(1).lower()
#translate_str = unicode(translate_str, encoding='latin_1')
#translate_str = translate.translate('en', 'de', translate_str)
translate_str = unicode(translate_str, encoding='utf_8')
#translate_str = translate.translate('en', 'zh-CN', translate_str)
#translate_str = translate.translate('en', 'zh-TW', translate_str)
elif(inp[0]=='#translate'):
query = ""
for i in range(len(inp)-2):
query+=inp[i+2]
if inp[1][0]== '-':
lang = inp[1][1:len(inp[1])]
if len(lang)==2:
print(lang)
pass
else:
for i in range(len(googletrans.LANGCODES)):
if googletrans.LANGCODES.keys == lang:
lang = googletrans.LANGCODES.items
print(lang)
a = translate.Translator(to_lang=lang).translate(query)
print(a)
# fetch Qoute from api
elif(inp[0].lower()=='#quote'):
url = 'https://quotes.rest/qod?category=management'
api_token = "AMANDEEP"
header = {'content-type': 'application/json','Access-Control-Allow-Headers': format(api_token)}
req = r.get(url,headers=header)
quote = req.json()['contents']['quotes'][0]['quote']
author =req.json()['contents']['quotes'][0]['author']
print(quote,'\n\t\t','BY',author)
# give detail about country and gives you short details
elif(inp[0].lower()=='#info'):
url ='https://restcountries.eu/rest/v2/name/{}'.format(inp[1])
import sys
import os
import translate
from pprint import pprint
ubersetzer = translate.Translator(to_lang="en", from_lang="de")
# TODO
# * NLTK wort seperazion
# * Nur das Deustch ubersetzen
# * autoFuller worter so das context die variablen nicht verendert
try:
if os.path.exists(sys.argv[1]):
with open(sys.argv[1]) as ff:
dasText = ff.readlines()
for eineLinie in dasText:
ubersetzed = ubersetzer.translate(eineLinie)
print(ubersetzed)
except Exception as e:
print(e)
from os import chdir
from pathlib import Path
gi.require_version('Gtk', '3.0')
from gi.repository import Gtk, Gdk # noqa
cb = Gtk.Clipboard.get(Gdk.SELECTION_CLIPBOARD)
def copy(texto: str):
global cb
cb.set_text(texto, -1)
cb.store()
tradutor = translate.Translator('pt-br', 'en')
def obter_texto_buffer(funcao):
"""
Função que retorna o texto do buffer.
"""
start = funcao.get_start_iter()
end = funcao.get_end_iter()
return funcao.get_text(start, end, True)
class Janela:
"""
Classe que inicializa a construção da janela.
"""
