Ahora que he decidido implementar TBO con C me han surgido problemas que no había tenido en cuenta, como por ejemplo la compilación. Con python no es necesario compilar nada, así que puedes escribir tu código modularizado sin ninguna precupación, pero cuando comienzas a escribir códgio en C y separas funcionalidad en diferentes ficheros comienzas a necesitar herramientas que faciliten la compilación, como son los makefiles, que compila solo las partes modificadas no teniendo así que compilar todo el proyecto siempre que se haga una modificación, sino que simplemente se compila lo modificado.

Los makefiles ofrecen una gran potencia, pero escribir un makefile completo con soporte multiplataforma es muy complejo, así que existen herramientas que te facilitan la vida como las autotools o cmake.

Para estas herramientas tú escribes un fichero donode especificas qué quieres compilar (e instalar con make install) y qué librerías necesitas, con número de versión incluso, y con un simple comando comprueban que todas las librerías necesarias están instaladas y generan un makefile para poder compilar e instalar.

La mayoría de los usuarios avanzados de linux habrá utilizado alguna vez las autotools para compilar, ejecutar un ./autogen.sh, un ./configure, etc. Yo me he decidido por utilizar cmake. Por qué cmake, pues porque me lo recomendó Alex (del proyecto robodo), es lo que usan en kde para compilar todo, me lo explicó por encima y me pasó un tutorial básico.

Hice unas cuantas pruebas y me gustó. Una de las cosas buenas de cmake es que puedes compilar en un directorio de compilación para no tener que ensuciar tu directorio de código, por ejemplo creas un directorio build dentro de src y dessde ahí ejecutas cmake ../ y te mete todo el código compilado y demás ficheros dentro del directorio build. También ofrece una salida en la compilación coloreada, que aunque parezca que no es una funcionalidad importante :P

Aquí está mi fichero CMakeList.txt dentro de src:

project(TBO)
 
cmake_minimum_required(VERSION 2.8)
 
set(DATA_DIR ${CMAKE_INSTALL_PREFIX}/share/tbo-data CACHE string "Shared directory")
 
CONFIGURE_FILE(${CMAKE_CURRENT_SOURCE_DIR}/config.h.cmake 
${CMAKE_CURRENT_SOURCE_DIR}/config.h)
 
FIND_PACKAGE(GTK2)
 
set(SRCS
tbo.c
ui-drawing.c
ui-menu.c
ui-toolbar.c
)
 
INCLUDE_DIRECTORIES(${GTK2_INCLUDE_DIRS})
 
add_executable(tbo ${SRCS})
 
target_link_libraries(tbo ${GTK2_LIBRARIES})

Además de compilarte de forma fácil todos los ficheros .c cmake/autotools te permite generar ficheros (config.h) definiendo variables. Esto lo utilizo yo para definir el directorio donde están los datos, imágenes y demás. Es la variable DATA_DIR definida en el fichero de cmake. En este fichero config.h.cmake defino DATA_DIR con la variable del cmake:

 #cmakdefine DATA_DIR "${DATA_DIR}"

Y si le paso la opción -DDATA_DIR=... puedo cambiar el directorio de dónde el código pillará las imágenes y los ficheros de datos. El cmake generará un fichero config.h con #define DATA_DIR "..."

En definitiva, que cmake facilita mucho el proceso de compilación y la búqueda de dependencias en diferentes plataformas.

Lo he estado pensando bien, y me he decidido por implementar TBO con C, con GTK+Cairo, en lugar de usar python.

La razón por la cual prefiero usar C es porque con python ya he realizado algunas aplicaciones de escritorio, y aunque esta añade elementos con los que no he tratado, como el uso de cairo, la mayor parte de la aplicación será en pygtk, y creo que esa tecnología ya la conozco suficiente.

Por otra parte está el lenguaje C, siempre me ha gustado. Es simple a la vez que potente y elegante, y desde que programo en python, C lo tengo más que abandonado, por eso estoy perdiendo soltura.

Así pues prefiero usar C que será más divertido e instructivo, y además como sigo usando gtk y cairo no implicará mucha más complicación que si lo hiciera con python.

Hoy edulix me ha pedido que le haga un logo para su nuevo proyecto en el CUSL4. El proyecto en concreto se llama RoboDo, y pretende acercar la potencia de los scripts a usuarios no programadores, presentando una interfaz gráfica y una manerá más o menos simple para generar "scripts" que actúen con el escritorio Plasma KDE :P

El proyecto se describe así:

RoboDo es una aplicación de KDE que permite crear flujos de trabajo gráficamente para automatizar tareas repetitivas.

Y este es el logo que he hecho:

Con el proyecto TBO pretendo hacer un editor fácil de usar para poder crear cómics, presentaciones guías de programas, etc.

La idea del proyecto es presentar una interfaz (hecha con gtk) más o menos sencilla que ofrezca un editor para que quién no sepa dibujar pueda hacer un cómic en cinco minutos para hacer una presentación de algo, un tutorial de cómo funciona algo o para dibujar un cómic gracioso.

Para ello el editor dispondrá de diferentes modelos prediseñados para ir añadiendo a las viñetas y el usuario tan sólo tendrá que colocar los personajes y escribir los bocadillos correspondientes para tener un cómic.

Quiero desarrollar el proyecto con python, gtk y cairo. Y tengo intención de que se pueda exportar a png y pdf y además quiero que añadir nuevos sets de personajes a añadir.

El otro día un amigo me preguntó como hacer consultas a una base de datos mysql desde python y le comenté que con sqlalchemy se podía hacer. Yo ya había hecho algunas cosas con sqlalchemy, pero no había tratado con bases de datos ya creadas, sino que siempre las creaba con sqlalchemy.

He estado mirando un poco en la web de sqlalchemy y me he encontrado SqlSoup (SqlAlchemy).

SqlSoup mapea una base de datos ya creada a objetos python, así que no es necesario crear las clases o declarar las tablas en código python, se infieren directamente de la base de datos ya creada.

Veamos como funciona con un simple ejemplo con sqlite.

1. Creamos la base de datos sqlite para las pruebas

$ sqlite3 testdb.sqlite
sqlite> create table users (name varchar(50), email varchar(100), primary key (name));
sqlite> create table posts (id integer not_null auto_increment, user_id varchar(50),
     ...> text varchar, primary key (id), foreign key (user_id) references users(name));

2. Aquí un script de prueba para ejecutar

# <a href="http://www.sqlalchemy.org/docs/05/reference/ext/sqlsoup.html<br />
#" title="http://www.sqlalchemy.org/docs/05/reference/ext/sqlsoup.html<br />
#">http://www.sqlalchemy.org/docs/05/reference/ext/sqlsoup.html<br />
#</a> Mapeando una base de datos ya creada para usar desde python de
# manera simple y rapida.
 
# creamos la base de datos con sqlite3
# sqlite3 testdb.sqlite
# sqlite> create table users (name varchar(50), email varchar(100), primary key (name));
# sqlite> create table posts (id integer not_null auto_increment, user_id varchar(50),
#    ...> text varchar, primary key (id), foreign key (user_id) references users(name));
 
from sqlalchemy.ext.sqlsoup import SqlSoup, Session
from sqlalchemy import or_, and_, desc
 
#db = SqlSoup('mysql://scott:tiger@localhost/mydatabase')
db = SqlSoup('sqlite:///testdb.sqlite')
 
def add_users():
    user = db.users.insert(name='danigm', email='dani@exp.com')
    user2 = db.users.insert(name='dani', email='danigm@exp.com')
    user3 = db.users.insert(name='pepe', email='pepe@exp.com')
    user4 = db.users.insert(name='juan', email='juan@exp.com')
 
    db.flush()
    Session.commit()
 
def add_posts():
    post1 = db.posts.insert(id=1, user_id='danigm', text='comentario1')
    post2 = db.posts.insert(id=2, user_id='danigm', text='comentario2')
    post3 = db.posts.insert(id=3, user_id='pepe', text='comentario3')
    post4 = db.posts.insert(id=4, user_id='juan', text='comentario4')
    db.flush()
    Session.commit()
 
try:
    add_users()
except:
    Session.rollback()
try:
    add_posts()
except:
    Session.rollback()
 
print db.users.filter(db.users.name=='danigm').first().name
 
where = or_(db.users.name=='danigm',
            db.users.email=='danigm@exp.com')
 
users = db.users.filter(where).order_by(desc(db.users.name)).all()
print users
 
user = users[0]
for post in db.posts.filter(db.posts.user_id == user.name):
    print user.name, post.text

3. Veamoslo paso a paso

db = SqlSoup('sqlite:///testdb.sqlite')


Con esta simple línea tenemos el objeto db que está conectado con la base de datos y ya podemos empezar a hacer consultas u otras cosas.

user = db.users.insert(name='danigm', email='dani@danigm.net')
db.flush()
Session.commit()


Podemos acceder a las tablas por su nombre directamente, db.users, db.posts y estos objetos tienen métodos para insertar, borrar o filtrar de tal forma que podamos hacer la consulta deseada, en este ejemplo añadimos un usuario. Hay que tener en cuenta que para que los cambios se vean reflejados hay que ejecutar el commit().

print db.users.filter(db.users.name=='danigm').first().name


se puede filtrar como en cualquier objeto de sqlite, en este ejemplo filtramos por nombre de usuario, nos quedamos con el primero y mostramos el nombre del mismo.

where = or_(db.users.name=='danigm',
            db.users.email=='danigm@exp.com')
 
users = db.users.filter(where).order_by(desc(db.users.name)).all()
print users
 
user = users[0]
for post in db.posts.filter(db.posts.user_id == user.name):
    print user.name, post.text


Y una vez dominado el uso de sqlalchemy se pueden hacer filtros más complejos con otras directivas. combinando filtros y usando toda la potencia que te da sqlalchemy.

Con este ejemplo vemos que acceder a bases de datos desde python es muy fácil con sqlalchemy y además puedes hacerlo independiente del motor de base de datos gracias a que sqlalchemy soporta mysql, postgresql, sqlite, oracle, firebird, MS-SQL, MSAccess.

Los libros de Terry Pratchett esconden muchísimas perlas, aquí dejo una que acabo de leer:

Al fin y al cabo, nunca se puede hacer planes para cada eventualidad, porque eso requeriría saber lo que va a ocurrir, y si uno supiera lo que va a ocurrir, probablemente podría asegurarse de que no ocurriera, o por lo menos de que le ocurriera a otro. Así que el patricio nunca hacía planes. Los planes a menudo se convertían en un estorbo.

"- ¿Por qué está yendo allí nuestra gente? - dijo el señor Boggis del Gremio de Ladrones.
- Porque están haciendo gala de un brioso espíritu de pioneros y buscando riquezas y ... más riquezas en una tierra nueva - dijo Lord Vetinari.
- ¿Y qué buscan los klatchianos? - preguntó Lord Downey.
- Oh, han ido allí porque son una panda de oportunistas sin principios y siempre están dispuestos a hacerse con algo a cambio de nada - dijo Lord Vetirani."

Allá por 1690 los piratas se dedicaban a abordar barcos llenos de oro y como todo el mundo sabe los piratas se dedicaban a enterrar grandes cofres llenos de oro escribiendo un mapa indescifrable (ya que los piratas no sabían escribir) para no volver a encontrarlos nunca.

Por lo visto hoy en día a los piratas no les interesa demasiado el oro y se dedican a abordar barcos de atún (atuneros).

Esta mañana se me ha ocurrido la idea de hacer una aplicación para gestionar qué tengo que comprar y qué no. La idea era tener una lista de cosas con la fecha de la última compra y otra lista de cosas por comprar, y poder cambiar de una lista a otra fácilmente.

Me he puesto a ello con web.py y ya la estoy usando.

La aplicación es simple, muestra dos listas de articulos, una de artículos para comprar y otra con artículos que tenemos en casa.

Pasar de una lista a otra es tan fácil como marcar la casilla correspondiente y pulsar actualizar. Se pueden añadir nuevos artículos fácilmente desde la misma página.

Para realizar esta aplicación en un par de horas he utilizado webpysample, que es un ejemplo que hice hace un par de semanas de aplicación web básica con web.py. Este ejemplo ofrece una aplicación básica usando como orm sqlalchemy, con autenticación, uso de sesiones, etc.

¿Futuras mejoras?

Esta aplicación es realmente básica, pero se le podrían añadir una serie de mejoras para adaptarla a las necesidades de los pisos de estudiantes para gestionar todo lo necesario.

Una posible mejora sería la posibilidad de introducir el coste de la compra y que la propia aplicación divida el importe entre los usuarios y envíe un correo informando de lo que le debe y a quién se lo debe.

Otra posible mejora sería que la aplicación mostrara más información a cerca de qué se compra, frecuencia de compras, estadísticas, que sugiera por correo cuando determine un patrón de compra.

Bueno, a cada cual se le puede ocurrir una nueva mejora que estaría bien. Si usas esta aplicación para gestionar las compras de tu piso de estudiantes y te implementas alguna mejora hazmelas llegar para que las añada.

Esta aplicación se puede encontrar en mi repo, cualquier colaboración será bienvenida.

El tren es un buen sitio para sacar el ultraportátil y aprovechar el tiempo haciendo algo. Hoy me ha dado por dibujar un nuevo fondo para mi portátil.

Dejo tanto el png como el svg por si a alguien le interesa para adpatarlo a su resolución o lo que sea.

svg