Tutorial: Programar un traductor de texto con interfaz grafica en Python (Código fuente)

En este nuevo tutorial les enseñare a programar un traductor de textos en el lenguaje de programación Python, el cual contara con una interfaz grafica para hacer esto más llamativo. El traductor permitirá el ingreso de texto, se podrá seleccionar el idioma en el que queremos traducirlo y mientras se traduce se mostrará una ventana de carga. Empecemos.

Lo primero que se tiene que hacer es instalar las librerías necesarias si no contamos con ellas, principalmente vamos a utilizar la librería googletrans la cual nos permitirá realizar las traducciones de texto.

Además, también utilizaremos PySimpleGUI para la creación de las interfaces gráficas, esta librería no es obligatorio instalarla, ya que en el código fuente incluiré la librería para importar directamente.

Ejecutamos la instalación de googletrans:

pip install googletrans

Una vez instalada la librería, vamos a importarla junto con las demás librerias necesarias que ya vienen incluidas en Python:

import PySimpleGUI as sg
import googletrans
from googletrans import Translator
import threading
import webbrowser
translator = Translator()

Ahora, sera necesario crear una clase llamada traductor, la cual tendrá los métodos para traducir el texto que ingresemos, pero primero debemos diseñar nuestra interfaz grafica con la ayuda de PySimpleGUI, definiremos los aspectos graficos y propiedades de la clase en el método __init__:

class traductor:
    def __init__(self):
        self.datos_lenguajes = googletrans.LANGUAGES
        self.frame_de = [
            [sg.Multiline(default_text='',size=(40, 20), key='-txt_a_traducir_')]
        ]
        frame_a = [
            [sg.Multiline(disabled=True, size=(40, 20), key= '-txt_traduccion_')]
        ]
        lenguajesA = ['Detectar idioma']
        lenguajesB = []
        for lenguaje in self.datos_lenguajes.values():
            lenguajesA.append(lenguaje)
            lenguajesB.append(lenguaje)
        #lenguajes= self.lenguajes.keys()
        #print(lenguajes)
        frame_lenguajes = [
            [sg.Text('De')],
            [sg.Combo(values= lenguajesA, key='-lenguaje_de-', default_value='Detectar idioma')],
            [sg.Text('A')],
            [sg.Combo(values=lenguajesB, key='-lenguaje_a-', default_value= 'english')],
            [sg.Button('Traducir', key='-traducir-')]
        ]

        self.layout_traductor = [[sg.Text('Traductor')],
                                 [sg.Frame('Texto a traducir', self.frame_de,  ),sg.Frame('Lenguajes', frame_lenguajes),  sg.Frame('Texto Traducido', frame_a)],

                                 ]
        self.frame_about = [
            [sg.Text('Contacto', font='Any 20', justification='c')],
            [sg.Text(
                'Si te gusto esta aplicacion, tienes alguna sugerencia, ocurrio un error, deseas apoyar el desarrollo o ponerte en contacto conmigo, te dejo mis redes sociales.\n'
                'Si quieres reportar un problema, por favor añade la siguiente informacion: Sistema operativo, Version de Python, Detalles del problema.\n'
                '', )],
            [sg.Button('Facebook', size=(15, 1)), sg.Button('Twitter', size=(15, 1)), sg.Button('Blog', size=(15, 1)),
             sg.Button('Correo', size=(15, 1)), sg.Button('Invitame un Cafe', size=(15, 1))]
        ]

        self.estado_traduccion =  False
        self.texto_traduccion = ''

Las primeras líneas de código nos ayudaran a obtener la lista de los lenguajes en los cuales podremos traducir nuestro texto, además definiremos un par de frames, los cuales servirán para contener un objeto de tipo MultilineTex que servirá para ingresar el texto a traducir y para mostrarlo una vez traducido.

Añadiremos un par de ComboBox, estos contendrán una lista de los lenguajes disponibles: uno será para el idioma origen del texto y el segundo será para el idioma destino de la traducción.

También crearemos un frame about, el cual contendrá información de contacto. Por último, declararemos dos propiedades más: estado_traduccion y texto_traduccion.

La variable ‘estado_traduccion’ nos servirá para identificar el estado actual de la operación de traducción, un True indica que se estará llevando la traducción a cabo, y un False todo lo contrario. ‘texto_traduccion’ contendrá el texto resultante de la traducción.

Ahora viene la parte interesante, crearemos algunos métodos que nos ayudaran en el proceso de traducción, el primero de ellos será ‘traducir’, el cual permitirá traducir el texto ingresado:

def traducir(self, texto, de, a):
    self.estado_traduccion =  True
    try:
        traduccion = translator.translate(text=texto, src=de, dest = a)
        self.estado_traduccion = False
        return traduccion.text
    except:
        self.estado_traduccion = False
        self.texto_traduccion = "Error en la traduccion"

Este método recibirá 3 parametros de entrada: el texto a traducir, el idioma de origen y el idioma destino. Añadiremos un try catch para evitar problemas de conexión, en ambos casos la variable texto_traduccion se actualizara con el texto resultante.

El siguiente método llamado ‘detectar_idioma’ nos ayudara a identificar el idioma de un texto en caso de no saber a cual pertenece además de poder traducirlo al idioma de nuestra preferencias:

def detectar_idioma(self, texto, a):
    self.estado_traduccion =  True
    try:
        traduccion =  translator.translate(text=texto, dest = a)
        self.estado_traduccion = False
        self.texto_traduccion = traduccion.text
    except:
        self.estado_traduccion = False
        self.texto_traduccion = "Error en la traduccion"

Este método solo recibirá 2 parametros: El texto a traducir y el idioma destino. El método automáticamente identificara el idioma origen del texto siempre y cuando sea posible.

El tercer método nos permitirá obtener los LANGCODES de un idioma seleccionado, esto es muy importante ya que son los valores que el traductor utiliza para llevar a cabo la traducción de un idioma a otro.

def getKeyIdioma(self, lenguaje):
    for valores in self.datos_lenguajes.items():
        if valores[1]==lenguaje:
            return valores[0]

Este método es algo sencillo , pero de suma importancia.

Finalmente, añadiremos un último método, el cual funcionará como una ventana de espera que aparecerá mientras estemos traduciendo un texto.

def ventana_espera(self):
    self.blue_dots = ‘’
    self.gif = self.blue_dots
    self.layout_espera = [
        [sg.Image(data=self.blue_dots, enable_events=True, background_color='white', key='_IMAGE_',
                  right_click_menu=['UNUSED', 'Exit'])],
        [sg.Button('Cancelar', key='-cancelar-')]]

    self.window_espera = sg.Window('My new window', no_titlebar=True, grab_anywhere=True, keep_on_top=True,
                                   background_color='white',
                                   alpha_channel=.8, margins=(0, 0)).Layout(self.layout_espera)

Este método es un diseño minimalista similar al de la interfaz principal, con la diferencia de que solo mostrara un gif animado y un botón de cancelar la operación. La variable blue_dots contiene un gif de carga en base64, no he podido colocarlo aquí debido a su gran longitud, pero esta disponible en los archivos fuentes.

El método mas importante es el que nos permitirá iniciar la ejecución de nuestro traductor, el cual  es el siguiente:

def iniciar_ejecucion(self):
    tab3 = sg.Tab('Traductor', self.layout_traductor, tooltip=Traductor, title_color='red')
    tab4 = sg.Tab('Acerca de', self.frame_about , tooltip="Acerca De", title_color='red')
    layout = [
        [sg.TabGroup([[tab3, tab4]], key='_TAB_GROUP_', )]
    ]
    window = sg.Window('Traductor Facialix', layout)
    traduccion = window['-txt_traduccion_']

    while True:
        event, value = window.read(10)
        #print(value)
        #print("dasdasd")
        if event in ('Exit', None):
            window.close()

        if self.texto_traduccion != '':
            #print("asdasd")
            traduccion.update(self.texto_traduccion)
            self.texto_traduccion = ''
        if event == '-traducir-':
            if value['-lenguaje_de-'] == 'Detectar idioma':
                a = self.getKeyIdioma(value['-lenguaje_a-'])
                #texto_traduccion = self.detectar_idioma(value['-txt_a_traducir_'], a = a)
                #traduccion.update(texto_traduccion)
                d = threading.Thread(target=self.detectar_idioma, args=(value['-txt_a_traducir_'], a,),
                                     daemon=True)
                d.start()
            else:
                de = self.getKeyIdioma(value['-lenguaje_de-'])
                a = self.getKeyIdioma(value['-lenguaje_a-'])
                #texto_traduccion = self.traducir(value['-txt_a_traducir_'], de = de, a = a)
                #traduccion.update(texto_traduccion)
                d = threading.Thread(target=self.traducir, args=(value['-txt_a_traducir_'],de, a,),
                                     daemon=True)
                d.start()

            self.ventana_espera()
            while True:
                if self.estado_traduccion == True:
                    event, values = self.window_espera.read(timeout=0)
                    self.window_espera.Element('_IMAGE_').UpdateAnimation(self.gif, time_between_frames=50)
                    if event == '-cancelar-':
                        self.window_espera.close()
                        break
                else:
                    self.window_espera.close()
                    break
        elif event == 'Facebook':
            webbrowser.open('https://www.facebook.com/facialix')
        elif event == 'Twitter':
            webbrowser.open('https://www.twitter.com/facialix')
        elif event == 'Blog':
            webbrowser.open('https://blog.facialix.com')
        elif  event == 'Correo':
            recipent = 'julio16101@facialix.com'
            webbrowser.open("mailto:?to=" + recipent)
        elif event == 'Invitame un Cafe':
            webbrowser.open('https://www.buymeacoffee.com/kUh9e5D')

Las primeras líneas de código nos permitirán “empaquetar” la interfaz grafica que definimos en nuestro init, además de poder ordenarlas en dos pestañas principales. La ejecución de la interfaz será en un ciclo while. 

Mientras el ciclo while se ejecute, estaremos leyendo los eventos de la interfaz grafica, uno de ellos será el del botón traducir, en caso de que se ejecute lanzaremos a llamar los métodos de traducción, además usaremos hilos los cuales nos ayudaran a mostrar la pantalla de carga mientras en segundo plano realizamos la traducción. La pantalla de carga solo desaparecerá si la traducción fue exitosa u ocurrió un error. En caso de ser exitosa mostraremos el texto traducido.

Los últimos eventos servirán para lanzar el navegador en caso de dar clic en alguno de los botones de la pestaña “acerca de”.

Con esto termina la explicación de su programación. Algo muy importante es que no estamos utilizando la API oficial de Google para traducir, sino una librería de terceros que realiza ese proceso por nosotros. Existe una limitante de 46 KB de tamaño del texto a traducir, además de que si se abusa del servicio podríamos sufrir un bloqueo de ip del servicio.

Pero no es algo de lo que preocuparse, para motivos de practica y aprendizaje es mas que suficiente, como siempre aquí te dejaremos el enlace para que puedas descargar el código fuente y practicar con el. Cualquier duda o sugerencia déjala en los comentarios.