list2form : gestion des erreurs et des petits fichiers (merci cgi.py…)

[progfou.git] / pygtranslator / pygtranslator.py

#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
PygTranslator - pas de doc cette fois-ci... :-P

Copyright : Agence universitaire de la Francophonie
Licence : GNU General Public Licence, version 2
Auteur : Jean Christophe André
Date de création : 28 septembre 2009
"""
import sys
from getpass import getpass
from threading import Thread
from Queue import Queue
try:
    import xmpp
    import pygtk
    pygtk.require('2.0')
    import gtk
    import gobject
except ImportError:
    modules = ['python-xmpp','python-gtk2','python-gobject']
    print u"Ce programme requiert l'installation des paquets Debian suivants :"
    print u"  " + u" ".join(modules)
    print u"Essayez ceci : sudo apt-get install " + u" ".join(modules)
    sys.exit(-1)

debug = False
def DEBUG(message):
    if debug:
        print "\x1b[31;1mDEBUG\x1b[m:", message
    return

class XmppTranslator(Thread):

    def __init__(self, jid, password):
        Thread.__init__(self)
        self.setDaemon(True)
        self._quit = False

        self._input_queue = Queue(0)
        self._output_queue = Queue(0)
        self._last_text_to_translate = {}

        self._jid = xmpp.JID(jid)
        self._password = password
        if self._jid.getResource() == '':
            self._jid.setResource('translator')

        self._client = xmpp.Client(self._jid.getDomain(), debug=[])

    def __del__(self):
        if self._client and not self._client.isConnected():
            return
        self._client.sendPresence(typ='unavailable')
        self._client.disconnect()

    def _connect(self):
        try:
            if not self._client.connect():
                raise IOError
        except IOError:
            raise IOError, "can't connect to '%s'" % self._jid.getDomain()
        self._client.RegisterHandler('message', self._messageHandler)

        auth = self._client.auth(self._jid.getNode(), self._password,
                                                self._jid.getResource())
        if not auth:
            raise IOError, "unable to authenticate '%s'" % self._jid.getNode()
        self._client.sendInitPresence(requestRoster=0)

    def _messageHandler(self, client, message):
        if message.getType() == 'error':
            return
        translation_path = message.getFrom().getNode()
        text = message.getBody()
        self._output_queue.put( (translation_path, text) )
        raise xmpp.NodeProcessed

    def _process_input_queue(self):
        if self._input_queue.empty():
            return
        # process pending translation job
        translation_path, text = self._input_queue.get()
        jid = '%s@bot.talk.google.com' % translation_path
        message = xmpp.Message(to=jid, typ='chat', body=text)
        self._client.send(message)
        DEBUG("sent [%s] to '%s'." % (text, jid))
        self._input_queue.task_done()

    def run(self):
        self._connect()
        self._client.Process(1)
        while not self._quit:
            self._process_input_queue()
            self._client.Process(1)

    def request_translation(self, translation_path, text):
        text = text.strip().replace('\r\n','\n')
        # skip consecutive identical requests
        if text == self._last_text_to_translate.get(translation_path):
            return
        self._last_text_to_translate[translation_path] = text
        # remove any pending translation job
        while not self._input_queue.empty():
            self._input_queue.get()
            DEBUG("removed a pending translation job")
            self._input_queue.task_done()
        # put a new translation job
        self._input_queue.put( (translation_path, text) )

    def translation_result(self):
        if self._output_queue.empty():
            return None
        translation_path, text = self._output_queue.get()
        return translation_path, text

    def translation_done(self):
        self._output_queue.task_done()

class GtkTranslator(object):

    def __init__(self, translator):
        self._translator = translator

        self._textbuf = {}

        self.window = gtk.Window(gtk.WINDOW_TOPLEVEL)
        self.window.set_title(u"PygTranslator")
        self.window.set_border_width(0)
        self.window.connect("destroy", lambda w: gtk.main_quit())
        self.window.connect("delete_event", self._delete_event)

        vbox = gtk.VBox(True, 0)
        vbox.show()

        textview = gtk.TextView()
        textview.set_size_request(400, 100)
        textview.set_wrap_mode(gtk.WRAP_WORD)
        textview.show()
        scroll = gtk.ScrolledWindow()
        scroll.add(textview)
        scroll.show()
        frame = gtk.Frame(u"Texte en français")
        frame.connect("key_release_event", self._text_change, 'fr')
        frame.connect("button_release_event", self._text_change, 'fr')
        frame.add(scroll)
        frame.show()
        vbox.pack_start(frame, True, True, 0)
        self._textbuf['fr'] = textview.get_buffer()

        textview = gtk.TextView()
        textview.set_size_request(400, 100)
        textview.set_wrap_mode(gtk.WRAP_WORD)
        textview.show()
        scroll = gtk.ScrolledWindow()
        scroll.add(textview)
        scroll.show()
        frame = gtk.Frame(u"Text in English")
        frame.connect("key_release_event", self._text_change, 'en')
        frame.connect("button_release_event", self._text_change, 'en')
        frame.add(scroll)
        frame.show()
        vbox.pack_start(frame, True, True, 0)
        self._textbuf['en'] = textview.get_buffer()

        self.window.add(vbox)
        self.window.show()

    def _delete_event(self, widget, event, data=None):
        DEBUG("caught delete event")
        gtk.main_quit()
        return False

    def _text_change(self, widget, event, lang):
        start, end = self._textbuf[lang].get_bounds()
        text = self._textbuf[lang].get_text(start, end)
        other_lang = (set(self._textbuf.keys()) - set((lang,))).pop()
        translation_path = lang + '2' + other_lang
        self._translator.request_translation(translation_path, text)

    def _process_translation_result(self):
        result = {}
        # FIXME: to transform into an iterator...
        while True:
            r = self._translator.translation_result()
            if r is None:
                break
            translation_path, text = r
            lang = translation_path[3:]
            if lang in self._textbuf:
                result[lang] = text
            else:
                DEBUG("unknown destination language '%s'" % lang)
            self._translator.translation_done()
        for lang, text in result.items():
            self._textbuf[lang].set_text(text)
        gobject.timeout_add(300, self._process_translation_result)

    def run(self):
        DEBUG("running graphic interface")
        gobject.timeout_add(300, self._process_translation_result)
        gtk.gdk.threads_init()
        gtk.main()

if __name__ == "__main__":
    if len(sys.argv) > 1 and sys.argv[1] == '-d':
        debug = True
        del(sys.argv[1])
    if len(sys.argv) > 1:
        jid = sys.argv[1]
        del(sys.argv[1])
    if len(sys.argv) > 1:
        password = sys.argv[1]
        del(sys.argv[1])
    else:
        password = getpass()
    if len(sys.argv) != 1:
        print "Usage: %s [-d] <jid> [<password>]" % sys.argv[0]
        sys.exit(1)

    translator = XmppTranslator(jid, password)
    translator.start()

    pygtranslator = GtkTranslator(translator)
    try:
        pygtranslator.run()
    except KeyboardInterrupt:
        pass

    translator._quit = True
    translator.join()

    sys.exit(0)