PyCon Argentina 2011, Junín

Y pasó la tercer Conferencia Nacional de Python Argentina. Este año se hizo en Junín.

Junín no es al lado de casa pero tampoco es demasiado lejos... salimos con Lucio, Ricardo y Tatiana (disertante, que se vino desde Brasil) un rato antes de las seis de la tarde del jueves (más que nada para no agarrar el tráfico de toda la gente saliendo de trabajar), y a las diez de la noche ya estábamos cenando allá.

La conferencia propiamente dicha arrancó el viernes a la mañana; luego de una registración un poco complicada arrancó una keynote a la que asistí, estuve haciendo sociales un rato por los pasillos, y cerramos la mañana con un panel de programadores que trabajamos en Canonical, moderado por Nico César, con preguntas del público sobre qué hacíamos, cómo lo hacíamos, etc.

Almorzamos en un lugar cercano, algo liviano, y estuve un rato en otra plenaria que no me interesaba demasiado, luego un rato afuera charlando, y justo antes del break de la tarde di mi clásica "Entendiendo Unicode"... es que el público se renueva, ¿viste?

Después del break, Lightning Talks! Siempre están buenas! Gracias a Manu Quiñones me enteré de la existencia de MyPaint, que está buenísimo, y yo por mi parte mostré un truquito interesante para hacer ejecutables Python, que ya mostré acá. Para cerrar el primer día de conferencia, hubo una plenaria sobre PyPy que estuvo buena, por Maciej Fijalkowski.

Ni bien terminó todo, Nico César me pidió la revancha de unos partidos de pool que le había ganado el año pasado, y salimos corriendo a jugarnos unas fichas... pero estaba cerrado! Abría recién a las ocho y media, pero a esa hora ya íbamos a estar cenando, así que apuntamos directamente a donde nos íbamos a encontrar con la gente a comer.

Como Alecu había avisado a todos que nos encontrábamos ahí, invadimos el bar, ¡éramos 66 comensales de la conferencia! Las cervezas y las pizzas corrían con un ritmo vertiginoso, y todos la pasamos muy bien. El lugar, super recomendable: Tío Lucas (fue barato, nos atendieron bien, y aunque había tanta gente se podía charlar bien, no era todo un gran barullo).

Cena en Tio Lucas

Ni bien terminamos de pagar, nos escapamos con Perrito y Nico al pool antedicho, y jugamos unas fichas, tomamos unas cervezas, llegó más gente... parranda, bah. Lo bueno es que como cenamos temprano, terminamos también acostándonos temprano (o al menos no demasiado tarde), lo que estuvo muy bien porque nos quedaba la mitad de conferencia por delante.

Al otro día, dí mi segunda y última charla en el primer slot, "Python más rápido que C" (versión actualizada, con comparaciones con PyPy). Luego estuve un rato charlando con Lucio y Guillo sobre unos temas de laburo, y enseguida me metí en una charla de Ricardo Kirkner sobre fabric. Para cerrar la mañana, una buena plenaria de Ricardo Quesada sobre "Vivencias desarrollando un proyecto open source".

Riq en su plenaria

Ni bien terminó la charla nos fuimos todos corriendo a una plaza en la esquina de la universidad a sacarnos una foto grupal, y luego a almorzar... donde nos demoramos apena más de lo que debíamos y terminamos llegando a la plenaria de Wesley Chun (sobre Python 3) un poco tarde.

Lo mejor de la tarde fueron una charla sobre Python en Android por Tatiana Al-Chueyr, otra tanda de Lightning Talks, y la última plenaria: el chairman de la Python Software Foundation, Steve Holden, hablándonos de la PSF, historia, comunidad, e incluso diversidad dentro de la misma.

Y el cierre! Unas palabras de los organizadores, regalos para los asistentes, para los disertantes, y todos para casa. Bueno, no para casa... había una cena para disertantes, y luego nos fuimos nuevamente a jugar unos pools al bar de enfrente del hotel.

Ese bar está buenísimo: tiene música pero no demasiado alta, buenas mesas de pool, un ambiente copado... si tuviera uno así por acá jugaría mucho más seguido al pool :) Ahora que lo pienso, debería revisar un par de bares que ví por la zona donde vivo, que parece que son más chetos, pero habría que confirmarlo, a ver si alguno tiene un pool piola.

Anyway, luego del pool, ya siendo como las dos de la mañana, cruzamos la calle y nos fuimos a dormir. Y al otro día nos levantamos, desayunamos, al rato partimos, viajamos tranqui, llegamos a la tardecita... todo bien.

Foto grupal

(hagan click en la foto para verla grande)

En fin. Muy buena conferencia, con buena asistencia, buenas charlas, y bien organizada. Un lujo tener estos eventos en Argentina, al alcance de todos.

Comentarios Imprimir

Encapsulando Python en un binario

Este es un lindo truquito que no es de mi autoría, sino que es de John Lenton (él lo mostró en una reunión del laburo), pero como yo ya lo mostré en PyCon Brasil el año pasado, y en PyCon Argentina ayer, lo pongo acá para el que lo quiera mirar...

Arrancamos con nuestro programa o proyecto Python que queremos meter adentro del binario... para nuestro ejemplo acá, crearemos un directorio, lo hacemos paquete de Python, y adentro creamos lo que sería el programa principal de nuestro sistema, con una función adentro que es la que arrancaría todo:

[email protected]:~/prueba$ mkdir proyecto
[email protected]:~/prueba$ cd proyecto/
[email protected]:~/prueba/proyecto$ touch __init__.py
[email protected]:~/prueba/proyecto$ cat principal.py
def run():
    print "Arrancamos!"
[email protected]:~/prueba/proyecto$ cd ..
[email protected]:~/prueba$

Tenemos que probar que podamos arrancar nuestro sistema desde el directorio padre... a veces no es tan fácil, hay que jugar un poquito con los paths de dónde importamos cosas, pero en este ejemplo es sencillo. Pero podemos probarlo facilmente:

[email protected]:~/prueba$ python
Python 2.7.1+ (r271:86832, Apr 11 2011, 18:05:24)
...
>>> import proyecto.principal
>>> proyecto.principal.run()
Arrancamos!
>>>

Una vez que lo logremos ejecutar así, tenemos que poner ese mismo código en un archivo con nombre __main__.py en el directorio padre de nuestro proyecto:

[email protected]:~/prueba$ cat __main__.py
import proyecto.principal
proyecto.principal.run()

Volvemos a probar que nuestro sistema funciona correctamente:

[email protected]:~/prueba$ python __main__.py
Arrancamos!

El próximo paso es meter todo adentro de un archivo ZIP, aprovechando que Python es capaz de interpretar directamente este tipo de archivos comprimidos (por eso el nombre especial de antes, para que Python lo reconozca):

[email protected]:~/prueba$ zip -r proyecto.zip __main__.py proyecto/
 adding: __main__.py (deflated 27%)
 adding: proyecto/ (stored 0%)
 adding: proyecto/__init__.py (stored 0%)
 adding: proyecto/principal.pyc (deflated 45%)
 adding: proyecto/__init__.pyc (deflated 30%)
 adding: proyecto/principal.py (stored 0%)

Probamos nuevamente que, hasta acá, funcione todo correctamente:

[email protected]:~/prueba$ python proyecto.zip
Arrancamos!

Finalmente, metemos todo eso adentro de un binario, indicando que se va a interpretar con Python, y haciéndolo ejecutable:

[email protected]:~/prueba$ ( echo '#!/usr/bin/env python'; cat proyecto.zip ) > miproyecto
[email protected]:~/prueba$ chmod +x miproyecto

¡Ya está! Ahora podemos ejecutar ese binario, como cualquier otro binario, y realmente estaremos ejecutando nuestro proyecto Python:

[email protected]:~/prueba$ ./miproyecto
Arrancamos!

Genial, :)

Comentarios Imprimir

Felu pirata

¿Les conté que Moni es genial cosiendo ropa? Bueno, había que disfrazar a Felipe para un acto del jardín, en función de un personaje de algún cuento... salió pirata:

Felu disfrazado de pirata

Bonus track: hagan click en la imagen y verán un video de Felu tratando de tocar Humo sobre el agua con la guitarra...

Comentarios Imprimir

Primer versión de Encuentro

Encuentro es un simple programa que permite buscar, descargar y ver contenido del Canal Encuentro.

Notar que este programa no distribuye contenido de Canal Encuentro, sino que permite un mejor uso personal de esos contenidos. Por favor, referirse al sitio web de Canal Encuentro para saber qué se puede y qué no se puede hacer con los contenidos de ese sitio.

Logo

La versión 0.2 (que es la primera que anuncio) es una versión pre-alfa... se puede usar, descargar y ver videos, y debería funcionar todo correctamente, pero le falta mucha funcionalidad (por ejemplo, buscar).

  • Se pueden encolar descargas de episodios, que luego irán bajando uno por uno.
  • Permite una visualización directa de los episodios desde el programa.
  • Se mantiene y muestra el estado de cada episodio.
  • La lista e información de los episodios se descarga automáticamente del server, para un mejor arranque.
  • Tenemos un sitio web 3.0! Pasen y vean (con botón de Donaciones y todo)
  • Configuración de parámetros, con un wizard para realizar más fácilmente la configuración necesaria.
  • Descargable como tarball (multiplataforma), con un instalador para Debian/Ubuntu, e incluso con un PPA para suscribirse.

La forma más fácil de instalarlo, si tienen un Debian o Ubuntu, es usando este instalador:

http://launchpad.net/encuentro/trunk/0.2/+download/encuentro-0.2.deb

Si quieren obtener automaticamente las nuevas actualizaciones, pueden suscribirse al PPA; en una linea de comandos hagan:

sudo add-apt-repository ppa:facundo/encuentro

En cualquier otro caso, pueden usar el tarball para instalarlo:

http://edge.launchpad.net/encuentro/trunk/0.2/+download/encuentro-0.2.tar.gz

Recuerden revisar el archivo AYUDA.txt si tienen alguna duda de cómo usar el programa.

¡Que lo disfruten!

Comentarios Imprimir

Empaquetando un programa hecho en Python

Estos son los pasos genéricos para, desde un proyecto que tiene el setup.py funcionando (ver este post para ayuda con eso), armar un paquete .deb y publicarlo en un PPA. El .deb es un archivo instalable en Debian o Ubuntu, y el PPA es una forma de registrarse para que el programa se actualice automáticamente cuando hay nuevas versiones (obvio, preguntándole al usuario, como el resto del sistema).

Traté de ser conciso para que no se pierdan los pasos en un mar de palabras, pero explicar alguito de cada punto, y dar alguna referencia para seguir investigando. Esta guía está casi copiada de una menos genérica y en inglés que había preparado Naty Bidart en el laburo... la idea es que quede aquí en castellano y más explicada...

Quizás necesiten instalar algunas dependencias (por ejemplo: bzr, bzrtools, bzr-builddeb, ubuntu-dev-tools, libcrypt-ssleay-perl), y configurar algunas cosas:

  • En el archivo .bashrc configurar nombre y mail para lo que son los .deb:

    export DEBFULLNAME="Nombre Completo"
    export DEBEMAIL="[email protected]"
    
  • Crear en el home un archivo .devscripts con este contenido:

    DEBUILD_DPKG_BUILDPACKAGE_OPTS='-i -I'
    
  • Tener un entorno pbuilder configurado /para cada distro/ a la que quieran apuntar (en este ejemplo, usé 'maverick', reemplacen apropiadamente):

    • crear un symlink en algún lado de vuestro PATH llamado pbuilder-maverick, apuntando a /usr/bin/pbuilder-dist
    • en algún lado dentro del home (por ejemplo, en un directorio ~/pbuilder), ejecuten: pbuilder-maverick create
    • regularmente (o antes de armar un paquete), actualicen el entorno de pbuilder con: pbuilder-maverick update

Por último: sí, estos pasos están fuertemente orientados a usar bazaar en todo el proceso. Es lo que hay :)

Presten atención a los comandos que ejecutan, especialmente a los cambios de "." y "-" por "_", y a todo lo que use 'tuproyecto'. Cualquier duda, pregunten.

  • Arrancamos trabajando con trunk.

  • Revisar que el setup.py funcione correctamente (que arme, instalarlo, y generar un tarball). Luego de instalarlo en /tmp/test ir allí y ver que funcione correctamente. Luego de generar el tarball, ir a otro directorio que no tenga nada que ver, desarmarlo y ver qué esté todo bien:

    ./setup.py clean build
    ./setup.py clean install --prefix=/tmp/test
    ./setup.py clean sdist
    
  • Cambiar la versión en setup.py a la nueva (en este ejemplo, sería X.Y.Z). Marcar a nivel bazaar un nuevo release:

    bzr commit -m "[release] vX.Y.Z"
    bzr tag release_X_Y_Z
    bzr push
    
  • Hacer un "bzr log" y preparar el changelog y las release notes. El changelog es una lista exhaustiva de todos los cambios, y las release notes es un subconjunto de eso, normalmente lo que es más relevante, interesante, o útil a la persona que quiere saber qué tenemos de nuevo en esta versión de nuestro programa.

  • Generar y subir el tarball a Launchpad. El último paso setea EDITOR porque lp-project-upload va a abrir dos archivos para que escribamos el changelog y las release notes que preparamos antes (pueden usar el editor que más les guste):

    ./setup.py clean sdist
    cd dist
    EDITOR=vim lp-project-upload tuproyecto X.Y.Z tuproyecto-X.Y.Z.tar.gz
    
  • Copiar el tarball (con un nuevo nombre) y preparar un nuevo branch para empezar a empaquetar:

    cp dist/tuproyecto-X.Y.Z.tar.gz ../tuproyecto_X.Y.Z.orig.tar.gz
    cd ..
    bzr branch trunk/ tuproyecto-X.Y.Z
    cd tuproyecto-X.Y.Z/
    bzr dh-make --bzr-only tuproyecto X.Y.Z ../tuproyecto_X.Y.Z.orig.tar.gz
    python-mkdebian
    
  • Editar el changelog con: EDITOR=vim dch (yo tiendo a poner las release notes aquí)

    • Agregar lineas de changelog
    • Agregar un -0ubuntu1 al nro de versión entre paréntesis
  • Archivos necesarios para Debian (tocar como dice acá o traer intactos de otro packaging que se haya hecho antes):

    • agregar un directorio source adentro del dir debian, y poner en ese nuevo directorio un archivo format con el siguiente contenido:

      3.0 (quilt)\n
      
    • confirmar que las dependencias sean las correctas en el archivo debian/control

    • modificar debian/copyright como corresponda

    • crear un archivo debian/watch con el siguiente contenido:

      version=3
      http://launchpad.net/tuproyecto/+download .*/tuproyecto-([\d.]+)\.tar\.gz
      
  • Armar el paquete en si, y luego del tercer paso probar el .deb que quedó en ~/pbuilder/maverick_result (o en el directorio donde hayan puesto pbuilder ustedes):

    debuild -S -sa
    bzr add debian
    pbuilder-maverick build ../tuproyecto_X.Y.Z-0ubuntu1.dsc
    
  • Actualizar el PPA (se puede crear el PPA desde tu página personal de Launchpad):

    dput ppa:<nombre_de_ppa_que_corresponda> tuproyecto_X.Y.Z-0ubuntu1_source.changes
    
  • Luego de unos minutos, debería aparecer acá:

    https://launchpad.net/~tunombre/+archive/tuproyecto/
    
  • Esperar que se buildee la versión que subieron (puede tardar algunas horas, un par de días, normalmente no más), y luego si quieren publicar lo mismo para otras versiones de Ubuntu sólo alcanza con copiar los fuentes a la versión que corresponda, desde la siguiente página:

    https://launchpad.net/~tunombre/+archive/tuproyecto/+copy-packages

Comentarios Imprimir