Puesto que estaré haciendo un proyecto en Python, iré colocando aquellos tips útiles que he aprendido usando este maravilloso lenguaje de programación. En este caso, se trata de obtener la información del sistema que ejecuta el script; cosas como el PID del script, el directorio donde se está ejecutando, el nombre y versión del sistema operativo, etc.:

#!/usr/bin/python

import os
import time

numUsuario = os.getuid()
pidProceso = os.getpid()
donde = os.getcwd()
sistemaOperativo = os.uname()
tiempos = os.times()
horaRaw = time.time()
horaFormato = time.ctime(horaRaw)

print "Numero de usuario",numUsuario
print "PID",pidProceso
print "Directorio actual",donde
print "Informacion del sistema",sistemaOperativo
print "Informacion de tiempos del sistema",tiempos

print "\nLa hora/fecha actual es",horaRaw
print "Lo cual significa",horaFormato

Información extra: http://docs.python.org/library/os.html

He leído bastante información acerca de cómo debianizar paquetes de software, pero en la mayoría de los casos se parte de el hecho de tener un programa en C/C++, en donde es necesario preocuparse por las tareas de compilación.

Y puesto que no he visto ningún tutorial en español, he decidido escribir algo al respecto de la manera más clara posible. ¡Manos a la obra!

0. Preparativos

Lo único que necesitas son dos herramientas: dpkg-dev y dh-make, las cuales puedes instalar ejecutando este comando:

Ten en cuenta que en éste ejemplo vamos a empaquetar un programa simple llamado “pngcrushgtk“, y que debes cambiar todo lo que aparece con ése nombre con el nombre de tu programa.

1. Creando un espacio de trabajo

Puesto que mientras estemos realizando el empaquetado se van a crear varios archivos, lo ideal es tener un espacio de trabajo (una carpeta) totalmente vacío al comenzar. Así que crearemos una carpeta llamada sandbox, en donde realizaremos todo cómodamente:

Dentro, debemos crear una carpeta cuyo nombre sea del tipo: nombreprograma-version:

En la cual debemos copiar una versión empaquetada de nuestro programa dentro de un .tar.gz. Si aún no lo tienes, puedes hacer lo siguiente:

2. Debianizando nuestro paquete

Para ello utilizaremos el comando dh_make de la siguiente forma:

Nos preguntará qué tipo de paquete estamos creando, y seleccionamos “s” (simple). Permíteme explicarte cada parámetro:

• -e cristian@elhacker.net, indicamos el correo electrónico del autor del programa
• -f pngcrushgtk.tar-0.2.gz, indicamos el paquete comprimido que contiene nuestro programa
• -c GPL, indicamos el tipo de licencia de nuestro programa

Luego de ejecutar el comando se habrá creado una carpeta llamada debian dentro de pngcrushgtk-0.2; y un archivo llamado pngcrushgtk_0.2.orig.tar.gz dentro de la carpeta sandbox, el cual debes eliminar.

Continúa leyendo en la siguiente página, en donde comenzamos con la configuración del paquete…

Uno de los típicos problemas que se tienen al programar en PyGtk es que si necestamos ejecutar un comando externo, nuestra aplicación se bloquea hasta que el proceso termine. La solución a esto es usar threads, pero NO “de la manera normal“.

La cosa es que, cuando estamos desarrollando software en PyGtk, usar threads de la forma convencional tiene problemas: algunas veces, los widgets como botones que ejecutan threads no trabajan adecuadamente, o simplemente la aplicación se congela como si no estuvieramos usando hilos

La solución es usar los métodos gtk.gdk.threads_init(), gtk.gdk.threads_enter() y gtk.gdk.threads_leave(). Vamos con un ejemplo, y luego de ello paso a explicar las particualiaridades del programa:

#!/usr/bin/env python
import os, threading, locale, gtk
gtk.gdk.threads_init()

codificacion = locale.getpreferredencoding()
utf8conv = lambda x : unicode(x, codificacion).encode('utf8')

def clic_boton(boton, area_texto, buffer, comando):
 hilo = threading.Thread(target=leer_salida, args=(area_texto, buffer, comando))
 hilo.start()

def leer_salida(area_texto, buffer, comando):
 stdin, stdouterr = os.popen4(comando)
 while 1:
	 linea = stdouterr.readline()
	 if not linea:
		 break
	 gtk.gdk.threads_enter()
	 iter = buffer.get_end_iter()
	 buffer.place_cursor(iter)
	 buffer.insert(iter, utf8conv(linea))
	 area_texto.scroll_to_mark(buffer.get_insert(), 0.1)
	 gtk.gdk.threads_leave()

sw = gtk.ScrolledWindow()
sw.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
area_texto = gtk.TextView()
buffer_texto = area_texto.get_buffer()
sw.add(area_texto)
ventana = gtk.Window()
ventana.resize(300,300)
ventana.set_title("Hilos en PyGtk")
ventana.connect('delete-event', gtk.main_quit)
boton = gtk.Button("Haz clic!")
comando = 'ls -R $HOME'
boton.connect("clicked", clic_boton, area_texto, buffer_texto, comando)
vbox = gtk.VBox()
vbox.pack_start(boton, False)
vbox.pack_start(sw)
ventana.add(vbox)
ventana.show_all()

gtk.main()

1. Lo primero (línea 2) es importar el paquete threading, que nos permitirá usar threads
2. Ahora, es necesario invocar la función gtk.gdk.threads_init() al inicio del programa (línea 3), lo que le indica a la aplicación que se van a usar hilos en la interfaz gráfica
3. En tercer lugar, debemos identificar las líneas de nuestro programa que pueden congelar la aplicación, que por lo general son llamadas a comandos externos. Una vez indentificadas basta con invocar la función gtk.gdk.threads_enter() antes de dichas líneas (línea 18), y gtk.gdk.threads_leave() después de las mismas (línea 23).

El resultado del programa es el siguiente:

Descargar código fuente del ejemplo

Recientemente ando aprendiendo algo de Python, y por supuesto me he lanzado a la búsqueda de un bonito IDE para trabajar. Después de muchas vueltas probando diferentes opciones, al fin he seleccionado mis dos finalistas.

PyDev

Es sin duda el mejor de todos. Se trata de un plugin para Eclipse que tiene todo lo que pudiéramos necesitar de un IDE:

• Resaltado de código
• Sangrado automática
• Completado automático
• Ejecución de programas
• Depurador de soluciones
• Administrador de proyectos

OpenKomodo

Es muy bueno sin duda, y nace como resultado de la liberación de parte del código del editor de Komodo, pero es solo un editor, por lo que el proceso de ejecución y depuración de aplicaciones lo tenemos que hacer manualmente o usando otras herramientas. Aún así­ posee:

• Resaltado de código
• Sangrado automática
• Completado automático
• Administrador de proyectos
• Y utilidades para el código (des/comentar bloques de código, uso de bookmarks, etc.)

Otros IDEs

Existen por supuesto una gran variedad de alternativas muy buenas, cada una con sus pros y contras. Entre las que podemos encontrar (todos instalables usando apt-get en sistemas basados en Debian):

• Eric
• PIDA
• SPE
• WingIDE

Enlaces interesantes…

• Página oficial de Python
• Python para todos. Es un eBook escrito por Raúl González Duque que cubre a grandes rasgos las principales caracterí­sticas de Python, y aunque es algo básico estoy seguro que sirve de gran ayuda a los que se inician con este maravilloso lenguaje.
• Manual de referencia oficial de Python
• Página oficial del proyecto PyGtk, un conjunto de librerí­as que permiten desarrollar aplicaciones con interfaces gráficas Gtk, usando Python
• Tutorial oficial PyGtk en español, la guí­a más completa para aprender a usar PyGtk
• Página oficial del proyecto PyQt, un conjunto de librerí­as que permiten desarrollar aplicaciones con interfaces gráficas Qt (para KDE), usando Python
• Tutorial de introducción al uso de PyQt
• Listado de IDEs en Python