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)
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 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 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 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 dash(request):
source=list(LANGUAGES.values())
translator=Translator()
if(request.method=='POST'):
data=request.POST.get('source')
fsrc=request.POST.get('options')
fdest=request.POST.get('desti')
# if(len(fsrc)<1):
# fsrc='hindi'
if(len(data)<1):
fl=request.FILES['document']
content=fl.read()
record=translator.translate(content,dest=fdest)
return render(request,'index.html',{'src':source,'data':record.text})
else:
record=translator.translate(text=data,src=fsrc,dest=fdest)
return render(request,'index.html',{'src':source,'data':record.text})
else:
return render(request,'index.html',{'src':source})
Input_text.place(x=20, y=100)
Label(root, text="Output", font='arial 15 bold', bg="#fffef9").place(x=780,
y=60)
# Output text box
Output_text = Text(root,
font='arial 12',
bg="#f2ece6",
height=15,
wrap=WORD,
pady=5,
width=50)
Output_text.place(x=480, y=100)
# create text box for getting input
language = list(LANGUAGES.values())
src_lang = ttk.Combobox(root, values=language, width=22)
src_lang.place(x=20, y=60)
src_lang.set('Select Input Language')
dest_lang = ttk.Combobox(root, values=language, width=22)
dest_lang.place(x=480, y=60)
dest_lang.set('Select Output Language')
# here is Translator
def Translate():
translator = Translator()
translated = translator.translate(text=Input_text.get(1.0, END),
src=src_lang.get(),
dest=dest_lang.get())
Output_text.delete(1.0, END)
def reactDrop(request):
if(request.method=='GET'):
source=list(LANGUAGES.values())
data={}
data['store']=source
return HttpResponse(json.dumps(source))
def __init__(self):
self.lang = list(LANGUAGES.values())
def __init__(self):
root = Tk(className=" ALTRANSLATOR ")
root.geometry("1080x400+820+615")
root.resizable(0, 0)
root.iconbitmap(os.path.join(cwd + '\\UI\\icons', 'altranslator.ico'))
root.config(bg='#ffffff')
root.overrideredirect(1)
def callback(event):
root.geometry("400x130+1510+885")
def showScreen(event):
root.deiconify()
root.overrideredirect(1)
def screenAppear(event):
root.overrideredirect(1)
def hideScreen():
root.overrideredirect(0)
root.iconify()
appHighlightFont = font.Font(family='OnePlus Sans Display',
size=12,
weight='bold')
titleBar = Frame(root, bg='#141414', relief=SUNKEN, bd=0)
icon = Image.open(os.path.join(cwd + '\\UI\\icons',
'altranslator.ico'))
icon = icon.resize((30, 30), Image.ANTIALIAS)
icon = ImageTk.PhotoImage(icon)
iconLabel = Label(titleBar, image=icon)
iconLabel.photo = icon
iconLabel.config(bg='#141414')
iconLabel.grid(row=0, column=0, sticky="nsew")
titleLabel = Label(titleBar,
text='ALTRANSLATOR',
fg='#909090',
bg='#141414',
font=appHighlightFont)
titleLabel.grid(row=0, column=1, sticky="nsew")
closeButton = Button(titleBar,
text="x",
bg='#141414',
fg="#909090",
borderwidth=0,
command=root.destroy,
font=appHighlightFont)
closeButton.grid(row=0, column=3, sticky="nsew")
minimizeButton = Button(titleBar,
text="-",
bg='#141414',
fg="#909090",
borderwidth=0,
command=hideScreen,
font=appHighlightFont)
minimizeButton.grid(row=0, column=2, sticky="nsew")
titleBar.grid_columnconfigure(0, weight=1)
titleBar.grid_columnconfigure(1, weight=20)
titleBar.grid_columnconfigure(2, weight=1)
titleBar.grid_columnconfigure(3, weight=1)
titleBar.pack(fill=X)
inputText = Text(root,
font=appHighlightFont,
height=11,
wrap=WORD,
padx=5,
pady=5,
width=40,
fg='#4877bc')
inputText.place(x=20, y=100)
outputText = Text(root,
font=appHighlightFont,
height=11,
wrap=WORD,
padx=5,
pady=5,
width=40,
bg='#f8f9fb',
fg='#4877bc')
outputText.place(x=610, y=100)
language = list(LANGUAGES.values())
srcLang = ttk.Combobox(root,
values=language,
width=22,
font=appHighlightFont)
srcLang.place(x=20, y=60)
srcLang.set('Source language')
destLang = ttk.Combobox(root,
values=language,
width=22,
font=appHighlightFont)
destLang.place(x=800, y=60)
destLang.set('Destination language')
def gTranslate():
translator = Translator()
translated = translator.translate(text=inputText.get(1.0, END),
src=srcLang.get().capitalize(),
dest=destLang.get().capitalize())
outputText.delete(1.0, END)
outputText.insert(END, translated.text)
trans_btn = Button(root,
text='Translate',
font=appHighlightFont,
pady=5,
command=gTranslate,
fg='#8e8d91',
width=9,
bg='#ffffff',
bd=0)
trans_btn.place(x=500, y=180)
titleBar.bind("<B1-Motion>", callback)
titleBar.bind("<Button-3>", showScreen)
titleBar.bind("<Map>", screenAppear)
root.mainloop()
#pip install googletrans==4.0.0-rc1
#convert text from one language to another using google translate and python
from googletrans import Translator, LANGUAGES
from googletrans.models import Translated
lang = list(LANGUAGES.values())
print("Welcome to Py_Guy Translate")
input_text = input("Please Enter Your Text in english:\n")
out_lang = input(
"Please enter output language name (ex.-hindi,gujarati,japanese:\n "
).lower()
if out_lang not in lang:
print("Sorry This Language is not available to translate")
else:
translator = Translator()
translated = translator.translate(text=input_text,
src="english",
dest=out_lang)
translated = str(translated).split(", ")
converted = translated[2]
pro = translated[3]
print(converted)
print(pro)
#To understand this code watch the video tutorial on my youtube channel
#Here - https://www.youtube.com/channel/UCmOBuijDvNgUMlqpzrwEBcw
word_list = json.load(file)
# Load list of top 10000 english words to be used to generate guesses
with open("static/modifiedTop10000asDict.txt", "r") as file:
top_word_list = json.load(file)
# Load list of languages for which word frequency is available
with open("static/langcodes_frequency.json", "r") as file:
langcodes_frequency = json.load(file)
# dictionary of language name as key and language code as value
langcodes_frequency_reverse = dict(map(reversed, langcodes_frequency.items()))
# Authenticate twitter credentials and create api object
auth = tweepy.OAuthHandler(creds['CONSUMER_KEY'], creds['CONSUMER_SECRET'])
auth.set_access_token(creds['ACCESS_TOKEN'], creds['ACCESS_SECRET'])
api = tweepy.API(auth, wait_on_rate_limit=True, wait_on_rate_limit_notify=True)
language_list = LANGUAGES.values()
language_frequency_list = langcodes_frequency.values()
# Function to translate given word into target language
def translated(word, dest_lang):
translated = translate(word, dest_lang)
if word != translated:
return translated
else:
return None
# Function to translate given word into target language
def translatedEnglish(word, dest_lang):
translated = translate(word, dest_lang, "auto")
def __init__(self):
self.languageoptions = list(LANGUAGES.values())
class DialectWindow(Handy.ApplicationWindow):
__gtype_name__ = 'DialectWindow'
# Get widgets
main_stack = Gtk.Template.Child()
translator_box = Gtk.Template.Child()
title_stack = Gtk.Template.Child()
langs_button_box = Gtk.Template.Child()
switch_btn = Gtk.Template.Child()
src_lang_btn = Gtk.Template.Child()
src_lang_label = Gtk.Template.Child()
dest_lang_btn = Gtk.Template.Child()
dest_lang_label = Gtk.Template.Child()
return_btn = Gtk.Template.Child()
forward_btn = Gtk.Template.Child()
menu_btn = Gtk.Template.Child()
char_counter = Gtk.Template.Child()
src_text = Gtk.Template.Child()
clear_btn = Gtk.Template.Child()
paste_btn = Gtk.Template.Child()
translate_btn = Gtk.Template.Child()
dest_box = Gtk.Template.Child()
dest_text = Gtk.Template.Child()
trans_spinner = Gtk.Template.Child()
trans_warning = Gtk.Template.Child()
copy_btn = Gtk.Template.Child()
voice_btn = Gtk.Template.Child()
actionbar = Gtk.Template.Child()
src_lang_btn2 = Gtk.Template.Child()
switch_btn2 = Gtk.Template.Child()
dest_lang_btn2 = Gtk.Template.Child()
notification_revealer = Gtk.Template.Child()
notification_label = Gtk.Template.Child()
# Language values
lang_codes = list(LANGUAGES.keys())
lang_names = list(LANGUAGES.values())
lang_speech = None
# Current input Text
current_input_text = ''
current_history = 0
history = []
type_time = 0
trans_queue = []
active_thread = None
# These are for being able to go backspace
first_key = 0
second_key = 0
mobile_mode = False
# Connectivity issues monitoring
trans_failed = False
voice_loading = False
def __init__(self, **kwargs):
super().__init__(**kwargs)
# GSettings object
self.settings = Gio.Settings.new(APP_ID)
# Get saved languages
self.src_langs = list(self.settings.get_value('src-langs'))
self.dest_langs = list(self.settings.get_value('dest-langs'))
# Google Translate object
self.translator = Translator()
# GStreamer playbin object and related setup
self.player = Gst.ElementFactory.make('playbin', 'player')
bus = self.player.get_bus()
bus.add_signal_watch()
bus.connect('message', self.on_gst_message)
self.player_event = threading.Event(
) # An event for letting us know when Gst is done playing
# Clipboard
self.clipboard = Gtk.Clipboard.get(
Gdk.SELECTION_CLIPBOARD) # This is only for the Clipboard button
# Setup window
self.setup()
def setup(self):
self.set_default_icon_name(APP_ID)
# Load saved dark mode
gtk_settings = Gtk.Settings.get_default()
dark_mode = self.settings.get_boolean('dark-mode')
gtk_settings.set_property('gtk-application-prefer-dark-theme',
dark_mode)
# Connect responsive design function
self.connect('check-resize', self.responsive_listener)
self.connect('destroy', self.on_destroy)
self.setup_headerbar()
self.setup_actionbar()
self.setup_translation()
self.toggle_mobile_mode()
# Get languages available for speech
threading.Thread(target=self.load_lang_speech).start()
# Load saved src lang
self.src_lang_selector.set_property('selected', 'auto')
# Load saved dest lang
self.dest_lang_selector.set_property('selected', self.dest_langs[0])
def on_listen_failed(self):
self.voice_btn.set_image(self.voice_warning)
self.voice_spinner.stop()
self.voice_btn.set_tooltip_text(
_('A network issue has occured. Retry?'))
self.send_notification(
_('A network issue has occured.\nPlease try again.'))
dest_text = self.dest_buffer.get_text(
self.dest_buffer.get_start_iter(), self.dest_buffer.get_end_iter(),
True)
if self.lang_speech:
self.voice_btn.set_sensitive(
self.dest_lang_selector.get_property('selected')
in self.lang_speech and dest_text != '')
else:
self.voice_btn.set_sensitive(dest_text != '')
def load_lang_speech(self, listen=False, text=None, language=None):
"""
Load the language list for gTTS.
text and language parameters are only needed with listen parameter.
"""
try:
self.voice_loading = True
self.lang_speech = list(lang.tts_langs(tld='com').keys())
if not listen:
GLib.idle_add(self.toggle_voice_spinner, False)
elif language in self.lang_speech and text != '':
self.voice_download(text, language)
except RuntimeError as exc:
GLib.idle_add(self.on_listen_failed)
print('Error: ' + str(exc))
finally:
if not listen:
self.voice_loading = False
def setup_headerbar(self):
# Connect history buttons
self.return_btn.connect('clicked', self.ui_return)
self.forward_btn.connect('clicked', self.ui_forward)
# Left lang selector
self.src_lang_selector = DialectLangSelector()
self.src_lang_selector.connect('notify::selected',
self.on_src_lang_changed)
# Set popover selector to button
self.src_lang_btn.set_popover(self.src_lang_selector)
self.src_lang_selector.set_relative_to(self.src_lang_btn)
# Right lang selector
self.dest_lang_selector = DialectLangSelector()
self.dest_lang_selector.connect('notify::selected',
self.on_dest_lang_changed)
# Set popover selector to button
self.dest_lang_btn.set_popover(self.dest_lang_selector)
self.dest_lang_selector.set_relative_to(self.dest_lang_btn)
# Add languages to both list
for code, name in LANGUAGES.items():
self.src_lang_selector.insert(code, name.capitalize())
self.dest_lang_selector.insert(code, name.capitalize())
self.langs_button_box.set_homogeneous(False)
# Switch button
self.switch_btn.connect('clicked', self.ui_switch)
# Add menu to menu button
builder = Gtk.Builder.new_from_resource(f'{RES_PATH}/menu.ui')
menu = builder.get_object('app-menu')
menu_popover = Gtk.Popover.new_from_model(self.menu_btn, menu)
self.menu_btn.set_popover(menu_popover)
def setup_actionbar(self):
# Set popovers to lang buttons
self.src_lang_btn2.set_popover(self.src_lang_selector)
self.dest_lang_btn2.set_popover(self.dest_lang_selector)
# Switch button
self.switch_btn2.connect('clicked', self.ui_switch)
def setup_translation(self):
# Left buffer
self.src_buffer = self.src_text.get_buffer()
self.src_buffer.set_text('')
self.src_buffer.connect('changed', self.on_src_text_changed)
self.src_buffer.connect('end-user-action', self.user_action_ended)
self.connect('key-press-event', self.update_trans_button)
# Clear button
self.clear_btn.connect('clicked', self.ui_clear)
# Paste button
self.paste_btn.connect('clicked', self.ui_paste)
# Translate button
self.translate_btn.connect('clicked', self.translation)
# Right buffer
self.dest_buffer = self.dest_text.get_buffer()
self.dest_buffer.set_text('')
self.dest_buffer.connect('changed', self.on_dest_text_changed)
# Clipboard button
self.copy_btn.connect('clicked', self.ui_copy)
# Translation progress spinner
self.trans_spinner.hide()
self.trans_warning.hide()
# Voice button prep-work
self.voice_warning = Gtk.Image.new_from_icon_name(
'dialog-warning-symbolic', Gtk.IconSize.BUTTON)
self.voice_btn.connect('clicked', self.ui_voice)
self.voice_image = Gtk.Image.new_from_icon_name(
'audio-speakers-symbolic', Gtk.IconSize.BUTTON)
self.voice_spinner = Gtk.Spinner(
) # For use while audio is running or still loading.
self.toggle_voice_spinner(True)
def responsive_listener(self, _window):
size = self.get_size()
if size.width < 600:
if self.mobile_mode is False:
self.mobile_mode = True
self.toggle_mobile_mode()
else:
if self.mobile_mode is True:
self.mobile_mode = False
self.toggle_mobile_mode()
def toggle_mobile_mode(self):
if self.mobile_mode:
# Show actionbar
self.actionbar.set_reveal_child(True)
# Change headerbar title
self.title_stack.set_visible_child_name('label')
# Change translation box orientation
self.translator_box.set_orientation(Gtk.Orientation.VERTICAL)
# Change lang selectors position
self.src_lang_selector.set_relative_to(self.src_lang_btn2)
self.dest_lang_selector.set_relative_to(self.dest_lang_btn2)
else:
# Hide actionbar
self.actionbar.set_reveal_child(False)
# Reset headerbar title
self.title_stack.set_visible_child_name('selector')
# Reset translation box orientation
self.translator_box.set_orientation(Gtk.Orientation.HORIZONTAL)
# Reset lang selectors position
self.src_lang_selector.set_relative_to(self.src_lang_btn)
self.dest_lang_selector.set_relative_to(self.dest_lang_btn)
def on_destroy(self, _window):
self.settings.set_value('src-langs',
GLib.Variant('as', self.src_langs))
self.settings.set_value('dest-langs',
GLib.Variant('as', self.dest_langs))
def send_notification(self, text, timeout=5):
"""
Display an in-app notification.
Args:
text (str): The text or message of the notification.
timeout (int, optional): The time before the notification disappears. Defaults to 5.
"""
self.notification_label.set_text(text)
self.notification_revealer.set_reveal_child(True)
timer = threading.Timer(
timeout,
GLib.idle_add,
args=[self.notification_revealer.set_reveal_child, False])
timer.start()
def toggle_voice_spinner(self, active=True):
if active:
self.voice_btn.set_sensitive(False)
self.voice_btn.set_image(self.voice_spinner)
self.voice_spinner.start()
else:
dest_text = self.dest_buffer.get_text(
self.dest_buffer.get_start_iter(),
self.dest_buffer.get_end_iter(), True)
self.voice_btn.set_sensitive(
self.dest_lang_selector.get_property('selected')
in self.lang_speech and dest_text != '')
self.voice_btn.set_image(self.voice_image)
self.voice_spinner.stop()
def on_src_lang_changed(self, _obj, _param):
code = self.src_lang_selector.get_property('selected')
dest_code = self.dest_lang_selector.get_property('selected')
if code == dest_code:
code = self.dest_langs[1] if code == self.src_langs[
0] else dest_code
self.dest_lang_selector.set_property('selected', self.src_langs[0])
if code in LANGUAGES:
self.src_lang_label.set_label(LANGUAGES[code].capitalize())
# Updated saved left langs list
if code in self.src_langs:
# Bring lang to the top
index = self.src_langs.index(code)
self.src_langs.insert(0, self.src_langs.pop(index))
else:
self.src_langs.pop()
self.src_langs.insert(0, code)
else:
self.src_lang_label.set_label(_('Auto'))
# Rewrite recent langs
self.src_lang_selector.clear_recent()
self.src_lang_selector.insert_recent('auto', _('Auto'))
for code in self.src_langs:
name = LANGUAGES[code].capitalize()
self.src_lang_selector.insert_recent(code, name)
# Refresh list
self.src_lang_selector.refresh_selected()
# Translate again
self.translation(None)
def on_dest_lang_changed(self, _obj, _param):
code = self.dest_lang_selector.get_property('selected')
src_code = self.src_lang_selector.get_property('selected')
dest_text = self.dest_buffer.get_text(
self.dest_buffer.get_start_iter(), self.dest_buffer.get_end_iter(),
True)
if code == src_code:
code = src_code
self.src_lang_selector.set_property('selected', self.dest_langs[0])
# Disable or enable listen function.
if self.lang_speech:
self.voice_btn.set_sensitive(code in self.lang_speech
and dest_text != '')
name = LANGUAGES[code].capitalize()
self.dest_lang_label.set_label(name)
# Updated saved right langs list
if code in self.dest_langs:
# Bring lang to the top
index = self.dest_langs.index(code)
self.dest_langs.insert(0, self.dest_langs.pop(index))
else:
self.dest_langs.pop()
self.dest_langs.insert(0, code)
# Rewrite recent langs
self.dest_lang_selector.clear_recent()
for code in self.dest_langs:
name = LANGUAGES[code].capitalize()
self.dest_lang_selector.insert_recent(code, name)
# Refresh list
self.dest_lang_selector.refresh_selected()
# Translate again
self.translation(None)
"""
User interface functions
"""
def ui_return(self, _button):
"""Go back one step in history."""
if self.current_history != TRANS_NUMBER:
self.current_history += 1
self.history_update()
def ui_forward(self, _button):
"""Go forward one step in history."""
if self.current_history != 0:
self.current_history -= 1
self.history_update()
def add_history_entry(self, src_language, dest_language, src_text,
dest_text):
"""Add a history entry to the history list."""
new_history_trans = {
'Languages': [src_language, dest_language],
'Text': [src_text, dest_text]
}
if self.current_history > 0:
del self.history[:self.current_history]
self.current_history = 0
if len(self.history) > 0:
self.return_btn.set_sensitive(True)
if len(self.history) == TRANS_NUMBER:
self.history.pop()
self.history.insert(0, new_history_trans)
GLib.idle_add(self.reset_return_forward_btns)
def switch_all(self, src_language, dest_language, src_text, dest_text):
self.src_lang_selector.set_property('selected', dest_language)
self.dest_lang_selector.set_property('selected', src_language)
self.src_buffer.set_text(dest_text)
self.dest_buffer.set_text(src_text)
self.add_history_entry(src_language, dest_language, src_text,
dest_text)
# Re-enable widgets
self.langs_button_box.set_sensitive(True)
self.translate_btn.set_sensitive(self.src_buffer.get_char_count() != 0)
def switch_auto_lang(self, dest_language, src_text, dest_text):
src_language = str(self.translator.detect(src_text).lang)
# Switch all
GLib.idle_add(self.switch_all, src_language, dest_language, src_text,
dest_text)
def ui_switch(self, _button):
# Get variables
self.langs_button_box.set_sensitive(False)
self.translate_btn.set_sensitive(False)
src_language = self.src_lang_selector.get_property('selected')
dest_language = self.dest_lang_selector.get_property('selected')
src_text = self.src_buffer.get_text(self.src_buffer.get_start_iter(),
self.src_buffer.get_end_iter(),
True)
dest_text = self.dest_buffer.get_text(
self.dest_buffer.get_start_iter(), self.dest_buffer.get_end_iter(),
True)
if src_language == 'auto':
if src_text == '':
src_language = self.src_langs[0]
else:
threading.Thread(target=self.switch_auto_lang,
args=(dest_language, src_text,
dest_text)).start()
return
# Switch all
self.switch_all(src_language, dest_language, src_text, dest_text)
def ui_clear(self, _button):
self.src_buffer.set_text('')
self.src_buffer.emit('end-user-action')
def ui_copy(self, _button):
dest_text = self.dest_buffer.get_text(
self.dest_buffer.get_start_iter(), self.dest_buffer.get_end_iter(),
True)
self.clipboard.set_text(dest_text, -1)
self.clipboard.store()
def ui_paste(self, _button):
text = self.clipboard.wait_for_text()
if text is not None:
end_iter = self.src_buffer.get_end_iter()
self.src_buffer.insert(end_iter, text)
def ui_voice(self, _button):
dest_text = self.dest_buffer.get_text(
self.dest_buffer.get_start_iter(), self.dest_buffer.get_end_iter(),
True)
dest_language = self.dest_lang_selector.get_property('selected')
# Add here code that changes voice button behavior
if dest_text != '':
self.toggle_voice_spinner(True)
if self.lang_speech:
threading.Thread(target=self.voice_download,
args=(dest_text, dest_language)).start()
else:
threading.Thread(target=self.load_lang_speech,
args=(True, dest_text,
dest_language)).start()
def on_gst_message(self, _bus, message):
if message.type == Gst.MessageType.EOS:
self.player.set_state(Gst.State.NULL)
self.player_event.set()
elif message.type == Gst.MessageType.ERROR:
self.player.set_state(Gst.State.NULL)
self.player_event.set()
print('Some error occured while trying to play.')
def voice_download(self, text, language):
try:
self.voice_loading = True
tts = gTTS(text, lang=language, lang_check=False)
with NamedTemporaryFile() as file_to_play:
tts.write_to_fp(file_to_play)
file_to_play.seek(0)
self.player.set_property('uri', 'file://' + file_to_play.name)
self.player.set_state(Gst.State.PLAYING)
self.player_event.wait()
except Exception as exc:
print(exc)
print('Audio download failed.')
GLib.idle_add(self.on_listen_failed)
else:
GLib.idle_add(self.toggle_voice_spinner, False)
finally:
self.voice_loading = False
# This starts the translation if Ctrl+Enter button is pressed
def update_trans_button(self, button, keyboard):
modifiers = keyboard.get_state(
) & Gtk.accelerator_get_default_mod_mask()
control_mask = Gdk.ModifierType.CONTROL_MASK
shift_mask = Gdk.ModifierType.SHIFT_MASK
unicode_key_val = Gdk.keyval_to_unicode(keyboard.keyval)
if (GLib.unichar_isgraph(chr(unicode_key_val))
and modifiers in (shift_mask, 0)
and not self.src_text.is_focus()):
self.src_text.grab_focus()
if not self.settings.get_boolean('live-translation'):
if control_mask == modifiers:
if keyboard.keyval == Gdk.KEY_Return:
if not self.settings.get_value('translate-accel'):
self.translation(button)
return Gdk.EVENT_STOP
return Gdk.EVENT_PROPAGATE
elif keyboard.keyval == Gdk.KEY_Return:
if self.settings.get_value('translate-accel'):
self.translation(button)
return Gdk.EVENT_STOP
return Gdk.EVENT_PROPAGATE
return Gdk.EVENT_PROPAGATE
def on_src_text_changed(self, buffer):
sensitive = buffer.get_char_count() != 0
self.translate_btn.set_sensitive(sensitive)
self.clear_btn.set_sensitive(sensitive)
def on_dest_text_changed(self, buffer):
sensitive = buffer.get_char_count() != 0
self.copy_btn.set_sensitive(sensitive)
if not self.voice_loading and self.lang_speech:
self.voice_btn.set_sensitive(
self.dest_lang_selector.get_property('selected')
in self.lang_speech and sensitive)
elif not self.voice_loading and not self.lang_speech:
self.voice_btn.set_sensitive(sensitive)
def user_action_ended(self, buffer):
# If the text is over the highest number of characters allowed, it is truncated.
# This is done for avoiding exceeding the limit imposed by Google.
if buffer.get_char_count() >= MAX_LENGTH:
self.send_notification(_('5000 characters limit reached!'))
src_text = buffer.get_text(buffer.get_start_iter(),
buffer.get_end_iter(), True)
self.src_buffer.set_text(src_text[:MAX_LENGTH])
self.char_counter.set_text(
f'{str(buffer.get_char_count())}/{MAX_LENGTH}')
if self.settings.get_boolean('live-translation'):
self.translation(None)
# The history part
def reset_return_forward_btns(self):
self.return_btn.set_sensitive(
self.current_history < len(self.history) - 1)
self.forward_btn.set_sensitive(self.current_history > 0)
# Retrieve translation history
def history_update(self):
self.reset_return_forward_btns()
lang_hist = self.history[self.current_history]
self.src_lang_selector.set_property('selected',
lang_hist['Languages'][0])
self.dest_lang_selector.set_property('selected',
lang_hist['Languages'][1])
self.src_buffer.set_text(lang_hist['Text'][0])
self.dest_buffer.set_text(lang_hist['Text'][1])
# THE TRANSLATION AND SAVING TO HISTORY PART
def appeared_before(self):
src_language = self.src_lang_selector.get_property('selected')
dest_language = self.dest_lang_selector.get_property('selected')
src_text = self.src_buffer.get_text(self.src_buffer.get_start_iter(),
self.src_buffer.get_end_iter(),
True)
if (self.history[self.current_history]['Languages'][0] == src_language
and self.history[self.current_history]['Languages'][1]
== dest_language
and self.history[self.current_history]['Text'][0] == src_text
and not self.trans_failed):
return True
return False
def translation(self, _button):
# If it's like the last translation then it's useless to continue
if len(self.history) == 0 or not self.appeared_before():
src_text = self.src_buffer.get_text(
self.src_buffer.get_start_iter(),
self.src_buffer.get_end_iter(), True)
src_language = self.src_lang_selector.get_property('selected')
dest_language = self.dest_lang_selector.get_property('selected')
if self.trans_queue:
self.trans_queue.pop(0)
self.trans_queue.append({
'src_text': src_text,
'src_language': src_language,
'dest_language': dest_language
})
# Check if there are any active threads.
if self.active_thread is None:
# Show feedback for start of translation.
self.trans_spinner.show()
self.trans_spinner.start()
self.dest_box.set_sensitive(False)
self.langs_button_box.set_sensitive(False)
# If there is no active thread, create one and start it.
self.active_thread = threading.Thread(
target=self.run_translation)
self.active_thread.start()
def run_translation(self):
def on_trans_failed():
self.trans_warning.show()
self.send_notification(
_('Translation failed.\nPlease check for network issues.'))
self.copy_btn.set_sensitive(False)
self.voice_btn.set_sensitive(False)
def on_trans_success():
self.trans_warning.hide()
def on_trans_done():
self.trans_spinner.stop()
self.trans_spinner.hide()
self.dest_box.set_sensitive(True)
self.langs_button_box.set_sensitive(True)
while self.trans_queue:
# If the first language is revealed automatically, let's set it
trans_dict = self.trans_queue.pop(0)
src_text = trans_dict['src_text']
src_language = trans_dict['src_language']
dest_language = trans_dict['dest_language']
if src_language == 'auto' and src_text != '':
try:
src_language = str(self.translator.detect(src_text).lang)
GLib.idle_add(self.src_lang_selector.set_property,
'selected', src_language)
if not src_language in src_langs:
self.src_langs[0] = src_language
except Exception:
self.trans_failed = True
# If the two languages are the same, nothing is done
if src_language != dest_language:
dest_text = ''
# THIS IS WHERE THE TRANSLATION HAPPENS. The try is necessary to circumvent a bug of the used API
if src_text != '':
try:
dest_text = self.translator.translate(
src_text, src=src_language,
dest=dest_language).text
self.trans_failed = False
except Exception:
self.trans_failed = True
# Finally, everything is saved in history
self.add_history_entry(src_language, dest_language,
src_text, dest_text)
else:
self.trans_failed = False
GLib.idle_add(self.dest_buffer.set_text, dest_text)
if self.trans_failed:
GLib.idle_add(on_trans_failed)
else:
GLib.idle_add(on_trans_success)
GLib.idle_add(on_trans_done)
self.active_thread = None
#Translator Heading label
lab_txt = Label(root,text="Translator",font=("Time New Roman",20,"bold"),bg="white") #Label
lab_txt.place(x=100, y=40, height=50, width=300) #Translator label size
frame = Frame(root).pack(side=BOTTOM)
#Source Text Heading label
lab_txt = Label(root,text="Source Text",font=("Time New Roman",15,"bold"),fg="Black",bg="yellow") #Label
lab_txt.place(x=100, y=100, height=30, width=300)
#Source Text writing label code
Sor_txt = Text(frame,font=("Time New Roman",15,"bold"),wrap=WORD)
Sor_txt.place(x=10,y=150,height=150,width=480)
list_text = list(LANGUAGES.values())
comb_sor = ttk.Combobox(frame,value=list_text)
comb_sor.place(x=50,y=320,height=40,width=65)
comb_sor.set("Hindi")
button_change = Button(frame,text="Translate",relief=RAISED,command=data)
button_change.place(x=200,y=320,height=40,width=65)
comb_dest = ttk.Combobox(frame,value=list_text)
comb_dest.place(x=350,y=320,height=40,width=65)
comb_dest.set("English")
#Dest Label Heading
lab_txt = Label(root,text="Dest Text",font=("Time New Roman",15,"bold"),fg="Black",bg="yellow")
lab_txt.place(x=100, y=430, height=30, width=300)
def __init__(self):
#getting all languages and convert it into list
self.langs = list(LANGUAGES.values())
