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 backtranslate(
text: Union[List[str], str],
n_langs: int = 1,
random_state: int = 42,
filter_out_identical=True,
):
langs = np.random.choice(list(LANGUAGES.keys()),
size=n_langs,
replace=False)
if isinstance(text, str):
ret = []
for lang in langs:
translated = translator.translate(text, dest=lang)
ret.append(
translator.translate(translated.text, src=lang,
dest="en").text)
else: # Then we have a list of strings
ret = []
for lang in langs:
to_append = []
for t in text:
translated = translator.translate(t, dest=lang)
to_append.append(
translator.translate(translated.text, src=lang,
dest="en").text)
ret.append(to_append)
return ret, langs
async def translate(self, ctx: commands.Context, *content: str):
def check_author(reaction):
return reaction.user_id == ctx.author.id and reaction.emoji.name == "\U0001f197"
if not content:
message_error = await ctx.send(f"Veuillez utiliser le format suivant pour cette commande: `{ctx.prefix}{ctx.command} {ctx.command.usage}`\nPour avoir la liste complète des langues disponibles, tapez la commande `{ctx.prefix}{ctx.command} lang` et je vous enverrai la liste en message privé.")
await message_error.add_reaction("\U0001f197")
try:
await self.client.wait_for("raw_reaction_add", check=check_author, timeout=120.0)
except asyncio.TimeoutError:
await message_error.delete()
else:
await message_error.delete()
return
lang = content[0]
if lang not in LANGUAGES.keys():
message_error = await ctx.send(f"Veuillez entrer une langue de destination valide. Par exemple pour traduire un message du Français à l'Anglais, écrivez `{ctx.prefix}{ctx.command} en <votre message>` ou inversement de l'Anglais au Français `{ctx.prefix}{ctx.command} fr <your message>`\nPour avoir la liste complète des langues disponibles, tapez la commande `{ctx.prefix}{ctx.command} lang` et je vous enverrai la liste en message privé.")
await message_error.add_reaction("\U0001f197")
try:
await self.client.wait_for("raw_reaction_add", check=check_author, timeout=120.0)
except asyncio.TimeoutError:
await message_error.delete()
else:
await message_error.delete()
return
message = " ".join(content[1:])
if not message:
message_error = await ctx.send(f"Veuillez entrer un message après avoir indiqué la langue. Par exemple pour traduire un message du Français à l'Anglais, écrivez `{ctx.prefix}{ctx.command} en <votre message>` ou inversement de l'Anglais au Français `{ctx.prefix}{ctx.command} fr <your message>`\nPour avoir la liste complète des langues disponibles, tapez la commande `{ctx.prefix}{ctx.command} lang` et je vous enverrai la liste en message privé.")
await message_error.add_reaction("\U0001f197")
try:
await self.client.wait_for("raw_reaction_add", check=check_author, timeout=120.0)
except asyncio.TimeoutError:
await message_error.delete()
else:
await message_error.delete()
return
try:
language = self.translator.detect(message)
except AttributeError as err:
write_file(set_file_logs(ctx.guild.id), err, is_log=True)
self.translator = Translator(
service_urls=["translate.google.com", "translate.google.fr"])
return await ctx.send("Une erreur est survenue. Veuillez réessayer.")
embed = Embed(color=ctx.author.top_role.color,
timestamp=datetime.utcnow())
embed.set_author(name=f"{ctx.author.display_name}#{ctx.author.discriminator}",
icon_url=ctx.author.avatar_url)
embed.add_field(
name="Say", value=f"{self.translator.translate(message, dest=lang.lower()).text}")
embed.set_footer(
text=f"{LANGUAGES[language.lang].title()} to {LANGUAGES[lang.lower()].title()}")
await ctx.send(embed=embed)
def display_languages():
lang_indexes = {}
i = 0
for Language in LANGUAGES.keys():
lang_indexes[str(i)] = Language
print("{:<3} : {:<10}".format(str(i), LANGUAGES[Language]))
i += 1
print("")
return lang_indexes
async def set_lang(event):
global DEST_LANG
args = event.pattern_match.group(1).split()
if len(args) != 1:
await event.edit(msgRep.MULT_ARGS)
return
args = args[0]
if args not in LANGUAGES.keys():
await event.edit(msgRep.INV_CT_CODE.format(build_supported_langs()))
return
DEST_LANG = args
await event.edit(msgRep.SUCCESS_LANG_CHANGE.format(LANGUAGES[args]))
return
def translate(phrase, n=20):
current_lang = ''
current_phrase = ''
for i in range(n-1):
dest = choice(list(LANGUAGES.keys()))
if i == 0:
translated = translator.translate(phrase, src="en", dest=dest)
current_lang = dest
current_phrase = translated.text
else:
translated = translator.translate(
current_phrase, src=current_lang, dest=dest)
current_lang = dest
current_phrase = translated.text
final = translator.translate(current_phrase, src=current_lang, dest="en")
return final.text
def __init__(self):
self.translation_client: Translator = Translator()
self.translation_cache: Dict[str, Dict[str, str]] = dict()
self.hyphenated_linebreak_regex = re.compile(r"\s*-\n\s*")
self.linebreak_in_the_midst_of_text_regex = re.compile(r"\n[ ]*(\S+)")
self.valid_languages = list(LANGCODES.keys()) + list(LANGUAGES.keys())
def build_supported_langs():
ret_val = ""
for i in LANGUAGES.keys():
ret_val += "`{}`: {}\n".format(i, LANGUAGES[i])
return ret_val
async def linguas(message, _):
msg = "```\n"
for k in LANGUAGES.keys():
msg += str(k) + ' - ' + str(LANGUAGES[k]) + '\n'
msg += "```"
await message.channel.send(msg)
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
from googletrans import LANGUAGES
if len(sys.argv) != 5:
print('Invalid arguments.')
print(' 1°: SRT file to translate.')
print(' 2°: Language of the SRT file.')
print(' 3°: Language in which the SRT file must be translated.')
print(' 4°: The translated SRT file.')
exit()
srt_to_translate = sys.argv[1]
original_language = sys.argv[2]
language_to_translate = sys.argv[3]
srt_translated = sys.argv[4]
if (original_language not in LANGUAGES.keys()
or language_to_translate not in LANGUAGES.keys()):
print('Invalid arguments.')
print(' The language of the SRT file or the language in which the '
'SRT file must be translated are invalid or language is '
'not supported.')
exit()
file = open(srt_to_translate, mode='r', encoding='utf-8')
subtitle = file.read()
file.close()
sub = srt.parse(subtitle)
sub_n = []
sub_content = ''
site_with_article = sys.argv[1]
original_language = sys.argv[2]
mp3_file = sys.argv[3]
if original_language not in lang.tts_langs().keys():
print('Invalid arguments.')
print(' Language to create audio is invalid.')
exit()
language_to_translate = original_language
mp3_audio_language = original_language
if len(sys.argv) == 5:
language_to_translate = sys.argv[4]
if language_to_translate not in LANGUAGES.keys():
print('Invalid arguments.')
print(' Language to translate text is invalid.')
exit()
if language_to_translate not in lang.tts_langs().keys():
print('Invalid arguments.')
print(' The language for translating text must also be one of the '
'languages available for creating audio, and this language is '
'not available for translating and creating audio.')
exit()
language_to_translate = language_to_translate
mp3_audio_language = language_to_translate
article = Article(site_with_article)