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())