reg3x's

Creacion de la interfaz gráfica de usuario (GUI) con ayuda de glade:

En mi caso prefiero usar la herramienta “glade” que me genera un xml posteriormente implementado en mi código python a través de una interfaz construida mendiante bien sea:

• El objeto gtk.Builder  con tan solo 3 lineas creamos el constructor, añadimos el archivo xml generado con glade y conectamos las señales:

constructor = gtk.Builder()
constructor.add_from_file("archivo.glade")
constructor.connect_signals()

Nota: (las señales se especifican con glade, es decir están definidas en el archivo XML generado)

• El objeto gtk.glade.XML  en este caso necesitaremos además de llamar al XML, crear un diccionario con los eventos y los métodos relacionados a los mismos, como se muestra a continuación:

constructor = gtk.glade.XML("archivo.glade")
dic = { "on_b1_clicked" : b1_clicked,
          "on_b2_clicked" : b2_clicked,
          "on_b3_clicked" : b3_clicked,
          "on_MainWindow_destroy" : gtk.main_quit }
constructor.signal_autoconnect(dic)

Con cualquiera de estas dos opciones agilizamos el proceso de generación de una interfaz gráfica de usuario (GUI).  En mi caso me gusta mas usar gtk.Builder debido a que no necesito crear un diccionario y ya esto es un paso menos.

LLamadas externas en GNOME:

Si deseamos enlazar un evento a una llamada externa debemos considerar que se puede congelar el GUI y este comportamiento es indeseado si se requiere por ejemplo mostrar una barra de progreso mediante la ejecución de la llamada, o cualquier otro proceso.

Para las llamadas externas recomiendo usar la libreria glib (GNOME Library). También existe la posibilidad de usar hebras con el submodulo de python subprocess (debemos tener cuidado de usar funciones obsoletas como os.popen)

Para realizar entonces las llamadas externas uso el siguiente arsenal:
glib.spawn_async()
glib.io_add_watch()
glib.timeout_add()
glib.child_watch_add()

el procedimiento es el siguiente:

1. crear gui
2. esperar evento
3. se ejecuta evento
4. la función asociada al evento ejecuta un spawn (glib.spawn_async)
5. glib.timeout_add() ejecuta periodicamente una función que será llamada en intervalos regulares (perfecto para mostrar una barra de progreso)
6. glib.child_watch_add() ejecuta una función cuando el spawn ejecutado en el paso 4 termina (esto es determinado por el PID de la llamada y nos permite por ejemplo completar la barra de progreso)

Si quisieramos leer data de una llamada externa podemos usar la función:

• glib.io_add_watch() Monitorea que un file-descriptor cumpla con una condición (que haya data para ser leida)

Ejemplo sencillo usando una barra de progreso y la libreria glib para hacer una llamada externa:

contenido del archivo ejemplo.py:

'''
Created on 17/01/2011
@author: reg3x
'''
import pygtk, gtk, gobject, glib, subprocess
pygtk.require('2.0')

class progress:
    def __init__(self):
        self.constructor= gtk.Builder()
        self.constructor.add_from_file("barraprogreso.glade")
        self.constructor.connect_signals(self)
        self.window1 = self.constructor.get_object("window1")
        self.barra = self.constructor.get_object("progressbar1")
        self.window1.connect('delete-event',gtk.main_quit)
        self.window1.show()

    def on_button1_clicked(self,widget):
        self.run_command(['/usr/bin/fdupes','-rS' ,'/home/'])
         #DEBEMOS COLOCAR UN DIRECTORIO CON LA PERMISOLOGIA ADECUADA

    def pulse(self):
        print "****************ejecutando pulse*************"
        self.barra.pulse() # progressbar variable
        return True

    def done(self, pid, condition, id):
        print "ejecutando done"
        glib.source_remove(id)
        self.barra.set_fraction(1)# progressbar variable

    def run_command(self,comando):
        pid, stdin, self.stdout, stderr = glib.spawn_async(comando , flags=glib.SPAWN_DO_NOT_REAP_CHILD)
        print "id del proceso es: "+str(pid)
        id = glib.timeout_add(50, self.pulse)
        glib.child_watch_add(pid, self.done, id)

if __name__ == '__main__':
    object =  progress()
    gtk.main()

Contenido del archivo barraprogreso.glade  (generado por glade):

Usar *args y **kwargs al definir funciones

Las sentencias especiales *args y **kwargs en las definiciones de funciones son usadas para pasar un número variable de argumentos a una función. La forma con un solo asterisco (*args) es usada para pasar como argumento una lista “keyworded” de longitud variable, mientras que la forma con doble asterisco es usada para pasar una lista “non-keyworded” de longitud variable.

A continuación se muestra un ejemplo de como usar la forma “non-keyworded”. En este ejemplo se pasa un argumento formal (posicional) y dos mas de longitud variable:

    def probar_argumentos(farg, *args):
        print "argumento formal:", farg
            for arg in args:
            print "otro argumento:", arg
    probar_argumentos(1, "dos", 3)

Resultados:

argumento formal: 1
otro argumento: dos
otro argumento: 3

A continuación un ejemplo de como usar la forma keyworded, nuevamente se pasa un argumento formal y dos keyworded de longitud variable

    def probar_var_kwargs(farg, **kwargs):
        print "argumento formal:", farg
        for key in kwargs:
            print "otro argumento keyworded: %s: %s" % (key, kwargs[key])

    probar_var_kwargs(farg=1, myarg2="dos", myarg3=3)

Resultados:

argumento formal: 1
otro argumento keyworded: myarg2: dos
otro argumento keyworded: myarg3: 3

Usar *args y **kwargs al llamar funciones

Esta sentencias especiales se pueden usar no solo en la definicion de funciones sino también al llamarlas. por ejemplo:

    def probar_var_args_call(arg1, arg2, arg3):
        print "argumento1:", arg1
        print "argumento2:", arg2
        print "argumento3:", arg3

    args = ("dos", 3)
    probar_var_args_call(1, *args)

Resultados:

argumento1: 1
argumento2: dos
argumento3: 3

Si queremos usar la forma keyworded al llamar una funcion lo hacemos de la siguiente forma:

    def probar_var_args_call(arg1, arg2, arg3):
        print "argumento1:", arg1
        print "argumento2:", arg2
        print "argumento3:", arg3

    kwargs = {"arg3": 3, "arg2": "dos"}
    probar_var_args_call(1, **kwargs)

Resultados:

argumento1: 1
argumento2: dos
argumento3: 3

Articulo parafraseado de:                        SaltyCrane Blog