danigm's blog

He añadido soporte para twitter en sweetgtk y arreglado una serie de bugs.

Ahora Se puede seguir twitter y/o sweetter al mismo tiempo y escribir comentarios en sweetter y/o twitter. He añadido unos checkbox y dependiendo de si tienes seleccionado sweetter o twitter o ambos se reciben los comentarios y se postea en la plataforma adecuada.

Aquí un screenshot de la nueva versión:

Además he arreglado el script install que era una guarrería y ahora se hacen las cosas de buena manera, llevando todo a /usr/share/sweetgtk y la configuración y la cache a $HOME/.sweetgtk de cada usuario, copiandose un skel si este directorio no existe.

Así pues todo aquel que intentó instalarse sweetgtk sin exito debe ejecutar el script ./uninstall de la versión que intentó instalar y borrar todo archivo que quede por ahí suelto, incluso $HOME/.sweetgtk, bajarse la nueva versión y ejecutar el nuevo script install como root que hará todo lo pertinente.

El script install debería funcionar en la mayoría de las distros GNU/linux y por tanto en el openmoko. Las dependencias y demás cosas están en el post anterior

sweetgk2.tgz

Por otro lado lo he empaquetado para debian/ubuntu y aquí está el paquete:
sweetgtk_2.0_i386.deb

Gracias por vuestra atención y a disfrutar del microblogging.

Hacía ya tiempo que tenía pensado hacer una aplicación de escritorio para poder interactuar con sweetter, pero hasta hoy no me había puesto a hacer nada serio.

Consiste en una aplicación hecha en pygtk que tira del módulo que ya hice antes pysweetter (que se conecta a sweetter a través de xmlrpc de forma transparente).

El código se puede conseguir así:
bzr branch http://repo.danigm.net/sweetgtk

Está bajo el control de versiones bazaar

Aquí una captura de pantalla de la aplicación:

Y como es pygtk también funciona en el openmoko neo freerunner:

Todavía estoy desarrollandolo, estoy teniendo problemas con los threads porque me da "segmentation faults" de forma "aleatoria", tengo que arreglar eso :P

Edito (23/11/2008 21:40):

Creo que ya he solucionado el problema de los threads, y además he hecho algunos arreglos para que funcione también en windows.

Aquí un screenshot funcionando en windows:

Para que funciones en windows vista hay que instalar una serie de cosas:

1. Instalar python 2.5: http://www.python.org/download/
2. Instalar GTK-runtime: http://sourceforge.net/project/showfiles.php?group_id=98754
   http://sourceforge.net/project/showfiles.php?group_id=98754&package_id=1...
3. Instalar pygtk: http://ftp.gnome.org/pub/GNOME/binaries/win32/pygtk/2.12/
4. Instalar gobject: http://ftp.gnome.org/pub/GNOME/binaries/win32/pygobject/2.14/
5. Instalar pycairo: http://ftp.gnome.org/pub/GNOME/binaries/win32/pycairo/1.4/

Y por cierto, para que funcione en linux también es necesario tener instalado todo lo anterior, pero normalmente en un escritorio gnome estará instalado, los paquetes para debian son:

python, python-gtk2, python-gobject, python-cairo, python-notify

Tengo pensado hacer un paquete un día de estos, mientras tanto se puede conseguir el código del repositorio o de aquí:
http://danigm.net/files/sweetgtk.tgz

Hace ya algún tiempo se me planteó el problema de tener una serie de funciones que se tienen que ejecutar cuando ocurre algo (un evento) y me hice un pequeño modulo en python para cubrir ese asunto.

Me basé en lo que conocía de pygtk, señales y eventos, así pues el funcionamiento básico es que tú declaras un evento, asignas funciones a ese evento, y cuando lances una señal, todas las funciones asociadas a ese evento se lanzan.

Se puede instalar de forma simple así:

sudo easy_install events

Aquí un ejemplo de uso:

from events import EventManager, Event
 
def func1(*args):
    print "Im the func1 with args: " + str(args)
 
def func2(*args):
    print "Im the func2 with args: " + str(args)
 
def func3(*args):
    print "Im the func3 with args: " + str(args)
 
# Creating the eventManager
em = EventManager()
 
# Create some events
event1 = Event('event1')
event2 = Event('event2')
 
em.add_event(event1)
em.add_event(event2)
 
# Connecting functions with events
em.connect('event1', func3, [1,2])
em.connect('event1', func2)
em.connect('event2', func1)
 
# Sending signals
print "sending event1..."
em.signal('event1')
print "sending event2..."
em.signal('event2')
 
# sending signal with arguments
print "sending event1 with arguments..."
em.signal('event1', [1,2,3])

Aquí está el código del módulo:

class Event:
    def __init__(self, name):
        self.name = name
        self.listeners = {}
 
    def add(self, function, data=None):
        self.listeners[function] = data
 
    def delete(self, function):
        self.listeners.pop(function)
 
    def called(self, data=None):
        for function, d in self.listeners.items():
            if data is None:
                if d is None:
                    function()
                else:
                    if type(d) == type([]):
                        function(*d)
                    elif type(d) == type({}):
                        function(**d)
                    else:
                        function(d)
            else:
                if type(data) == type([]):
                    function(*data)
                elif type(data) == type({}):
                    function(**data)
                else:
                    function(data)
 
 
class EventManager:
    def __init__(self):
        self.events = {}
 
    def add_event(self, Event):
        self.events[Event.name] = Event
 
    def del_event(self, Event):
        self.events.pop(Event.name)
 
    def connect(self, event, function, data=None):
        self.events[event].add(function, data)
 
    def disconnect(self, event, function):
        self.events[event].delete(function)
 
    def signal(self, event, data=None):
        if data is None:
            self.events[event].called()
        else:
            self.events[event].called(data)

Como todo ser humano tengo una gran lista de cosas por hacer, también llamada TO-DO list. Hace algún tiempo empecé a utilizar tomboy para tomar notas y tener apuntado cosas por hacer, pero nunca me acuerdo de mirarlo, por lo tanto el otro día decidí hacer un sencillo script que cada cierto tiempo me recordara mi TO-DO list.

Para conseguirlo he utilizado pynotify para mostrar un mensajito en el escritorio cada 10 minutos, y he realizado consultas al servicio DBUS que ofrece tomboy para encontrar la nota con título TODO y coger el texto que hay en esta.

La idea es lanzar este script al iniciar el escritorio para así tenerlo en segundo plano mostrando mensajitos cada cierto tiempo.

Luego pensé que podía hacer lo mismo con los TODO de sweetter.net. Así que lo he integrado con el script utilizando el modulo pysweetter que tira del servicio XML-RPC. Por otra parte he tenido que implementar una función especifica para el servicio xmlrpc de sweetter.

Aquí una imagen del tema en acción:

Y para quien esté interesado, aquí está el código:

#!/usr/bin/python
 
import gtk, pygtk
pygtk.require('2.0')
 
import dbus
import gobject
import time
import pynotify
 
from pysweetter import Sweetter
 
session_bus = dbus.SessionBus()
uri = 'org.gnome.Tomboy'
path = '/org/gnome/Tomboy/RemoteControl'
sleep_time = 10 * 60
 
pynotify.init("Tomboy TODO notification")
USER = 'danigm'
 
while True:
    try:
        tomboy = session_bus.get_object(uri, path)
        note_uri = tomboy.FindNote('TODO')
        all_text = tomboy.GetNoteContents(note_uri)
        all_text = all_text.split('\n')
    except:
        all_text = []
 
    try:
        s = Sweetter()
        todo_list = s.get_TODO_list(USER)
        all_text.append('\nSweetter TODO\n')
 
        for i, sweet in enumerate(todo_list):
            todo = '%d <a href="http://sweetter.net/%s?todo=1">%s</a>' % (i+1, USER, sweet.sweet)
            all_text.append(todo)
    except:
        pass
 
    note = pynotify.Notification("TODO list", 
                            '\n'.join(all_text[1:]))
 
    helper = gtk.Button()
    icon = helper.render_icon(gtk.STOCK_FILE, 
                               gtk.ICON_SIZE_DIALOG)
    note.set_icon_from_pixbuf(icon)
 
    note.set_timeout(30000)
    note.show()
 
    time.sleep(sleep_time)

Y para los más curiosos todavía aquí un repositorio del código:
bzr branch http://repo.danigm.net/todo-reminder

Los parches y comentarios son bienvenidos.

Cuando se trabaja en una empresa es un tema recurrente el cálculo de tiempo dedicado a cada proyecto por parte del desarrollador.

Hay diferentes formas de hacerlo. La más simple sería mirando el reloj y haciendo un cálculo apróximado, el problema es que no tienes un registro de lo que has hecho.

Para el tracking de tiempo dedicado a un proyecto hay diferentes herramientas. Yo conocía gnotime que vale para lo que es, pero que no acaba de convencer.

Luego conocí Hamster, que es mucho más amigable, hace gráficas, informes y muchas polladas.

Yo en mi escritorio siempre tengo una terminal abierta, y últimamente me estoy dando cuenta de que las interfaces gráficas quitan mucho tiempo cuando no las necesitas, así que ayer decidí implementarme un time tracker de estos pero para terminal.

¿Cómo? Cojo python + vim, un poquito de sqlobject, se agita y aquí tenemos "Terminal Time Tracker".

En realidad son tres ficheros, aunque le he un instalador y desinstalador y polladas para que sea más simple de usar.

tttdb.py Una tabla para la base de datos.

# Author: Daniel Garcia <dani@danigm.net>
# License: GPLv3
 
from sqlobject import *
import os
 
class Tracker(SQLObject):
    project = StringCol()
    task = StringCol()
    ticket = IntCol()
    start = DateTimeCol()
    end = DateTimeCol()
 
def get_hub():
    connection_string = 'sqlite://%s/devdata.sqlite' % os.getcwd()
    connection = connectionForURI(connection_string)
    sqlhub.processConnection = connection
 
    return sqlhub
 
def create_db():
    # You need to create the database before.
    sqlhub = get_hub()
 
    Tracker.createTable()

ttt.py Toda la chicha

#!/usr/bin/python
 
# Author: Daniel Garcia <dani@danigm.net>
# License: GPLv3
 
import datetime
import time
import sys
import tttdb as db
from tttdb import Tracker
 
sqlhub = db.get_hub()
 
def parse_time(time_seconds):
    hour = 0
    min = 0
    sec = time_seconds
    while sec >= 60:
        min += 1
        sec -= 60
    while min >= 60:
        hour += 1
        min -= 60
    time_str = '%02d:%02d:%02d' % (hour, min, sec)
    return time_str
 
def track(task, project='', ticket=0):
    today = datetime.datetime.now()
    tick = time.time()
    time_pass = 0
    try:
        while True:
            tick2 = time.time()
            time_pass = tick2 - tick
            cadena = '\rtracking: %(task)s %(project)s %(ticket)s %(time)s' % \
                {'time':parse_time(time_pass),
                 'task':task,
                 'project':project,
                 'ticket':ticket}
            sys.stdout.write(cadena)
            sys.stdout.flush()
            time.sleep(0.5)
    except:
        print '\n', 'Finalizando'
        end = datetime.datetime.now()
        db.Tracker(project=project,
                task=task,
                ticket=ticket,
                start=today,
                end=end)
 
def show(trackers):
    grouped = {}
    total = 0
    prev = ''
    for i in trackers:
        diff = i.end - i.start
        total += diff.seconds
        time_passed = parse_time(diff.seconds)
 
        key = (i.task, i.project)
        if grouped.has_key(key):
            grouped[key] += diff.seconds
 
        else:
            grouped[key] = diff.seconds
 
        to_show = '%s | %-20s | %-40s | #%-6d | %s'
        to_show = to_show % (i.start.ctime(), i.project, i.task, i.ticket, time_passed)
        if prev != to_show[0:3]:
            prev = to_show[0:3]
            print ''
        print to_show
 
    print ''
    for k,v in grouped.items():
        task, project = k
        time_passed = parse_time(v)
        print 'Tiempo para %-40s %s' % ('"'+task+'":', time_passed)
 
    print '\nTotal: %s' % parse_time(total)
 
def show_today(delta=0):
    today = datetime.datetime.now() - datetime.timedelta(delta)
    yesterday = datetime.datetime(today.year, today.month, today.day)
    today_trackers = Tracker.select(Tracker.q.start > yesterday)
    show(today_trackers)
 
def show_project(project):
    project_trackers = Tracker.select(Tracker.q.project == project)
    sum = 0
    for i in project_trackers:
        sum += (i.end - i.start).seconds
 
    print 'Tiempo para "%s": %s' % (project, parse_time(sum))
 
def show_all():
    all = Tracker.select()
    show(all)
 
def show_week():
    show_today(6)
 
def show_week_grouped():
    show_today_grouped(6)
 
def show_today_grouped(delta=0):
    today = datetime.datetime.now() - datetime.timedelta(delta)
    yesterday = datetime.datetime(today.year, today.month, today.day)
    today_trackers = Tracker.select(Tracker.q.start > yesterday)
    show_grouped(today_trackers)
 
def show_grouped(trackers):
    projects = {}
    total = 0
    for i in trackers:
        diff = (i.end - i.start).seconds
        total += diff
        if projects.has_key(i.project):
            projects[i.project] += diff
        else:
            projects[i.project] = diff
 
    print ''
    for k,v in projects.items():
        p = '"' + k + '":'
        print 'Tiempo para %-20s %s' % (p, parse_time(v))
 
    print '\nTotal: %s' % parse_time(total)
 
if __name__ == '__main__':
    help = '''
    %s tarea [proyecto] [ticket]
    '''
 
    task, project, ticket = '','',0
    args = sys.argv[1:]
    if ('-h' in args) or ('--help' in args) or (len(args) == 0):
        print help % sys.argv[0]
        sys.exit()
    if len(args) >= 1:
        task = args[0]
    if len(args) >= 2:
        project = args[1]
    if len(args) >= 3:
        ticket = int(args[2])
 
    track(task, project, ticket)

show.py Para ver el registro

#!/usr/bin/python
 
# Author: Daniel Garcia <dani@danigm.net>
# License: GPLv3
 
import sys
import ttt
 
if __name__ == '__main__':
    help = '''
    %s [opcion]
 
    opciones:
     -g muestra agrupados por proyecto
     -w muestra la ultima semana
     -gw muestra la ultima semana agrupado por proyecto
     -a muestra todo
 
     si no se especifica opcion muestra las tareas de hoy
    '''
    args = sys.argv[1:]
    if ('-h' in args) or ('--help' in args):
        print help % sys.argv[0]
 
    elif '-g' in args:
        # show grouped by project
        ttt.show_today_grouped()
    elif '-w' in args:
        ttt.show_week()
    elif '-gw' in args:
        # show grouped by project
        ttt.show_week_grouped()
    elif '-a' in args:
        ttt.show_all()
    else:
        ttt.show_today()

El código se puede pillar de mi repositorio personal:

  bzr branch http://repo.danigm.net/ttt

O del fichero tar.gz que adjunto aquí.

Para usarlo, tienes que tener instalado sqlobject y se instalaría ejecutando el script install.sh (hace una llamada a un comando con sudo). Esto te crea un directorio en $HOME/.ttt donde mete la base de datos y los scripts en python, y además copia t3 y t3show a /usr/local/bin para que puedas ejecutar los comandos sin modificar tu path.

Se usa de la siguiente manera:

  t3 "Escribiendo un post"

Y en la terminal se muestra el tiempo que vas dedicando a esta tarea. Para terminar tan solo hay que pulsar ctrl+c.
Además de una tarea se puede especificar un proyecto y un número para referenciarlo en el sistema de tickets que uses.

sintaxis:
  t3 tarea [proyecto] [ticket]
  t3 -h
ejemplo:
  t3 "plugin para jisko" "sweetter" 235879

Y para mostrar el resultado se usa t3show

Wed Sep 24 20:34:01 2008 | ttt                  | publicando                               | #0      | 00:00:06
Wed Sep 24 20:34:04 2008 | sweetter             | plugin para jisko                        | #235879 | 00:00:08
Wed Sep 24 20:34:18 2008 | ttt                  | publicando                               | #0      | 00:00:05

Tiempo para "plugin para jisko":                     00:00:08
Tiempo para "publicando":                            00:00:11

Total: 00:00:19

Con las opciones -g -w -gw -a que muestran agrupado por proyecto, la última semana, por proyecto en la última semana y todo respectivamente. Además de mostrar el día actual si no se le pasa ningún parametro y la ayuda con el comando -h.

Para el que no lo sepa, soy el principal desarrollador de sweetter, que es un sistema de microbloggin al estilo de twitter pero mejor. No voy a entrar en detalles técnicos ahora que no es el tema.

El caso es que no se por qué razón (bueno sí, por su calidad, estabilidad y usabilidad) llegó a salir en el periódico "El País", en un artículo en el cual se decía poco sobre sweetter, siendo destacado por ser el servicio más geek.

Ahora a aparecido otra vez en el mismo periódico y aquí unas fotos que lo demuestran:

Pero esto no es nada comparado con lo próximo, que vendrá cuando sweetter de el gran salto y empiece a utilizarse en la empresa como herramienta interna para coordinación y otras cosas. Ya se están moviendo los hilos necesarios para motivar este camino hacia la dominación mundial.

El último libro que me he leido se llama "los propios dioses" y tras leerlo me ha venido a la mente un tema sobre el que tratan en el libro y que se puede aplicar al calentamiento global y lo que hacemos hoy en día con nuestro planeta.

[spoiler del libro, si te lo vas a leer lo mismo esto te molesta]

En el libro se relata la historia de un futuro en el cual se ha conseguido una máquina que genera energía sin coste alguno aparente. Pero un científico se da cuenta de que esta máquina está cambiando las reglas físicas de nuestro universo y por tanto lo está llevando a una destrucción inmediata.

Este científico "demuestra" que la "bomba de electrones" puede hacer que el sol explote en un plazo de tiempo corto, pero la gente está tan acomodada a la energía "gratis" que sus demostraciones son criticadas y puestas en duda.

Más tarde, otro científico, desde la Luna, retoma la investigación del anterior, pero se da cuenta de una cosa, no se puede convencer a la gente de que la "bomba de electrones" es mala y esperar que dejen de usarla, hay que ofrecerle una alternativa mejor y entonces todo el mundo aceptará el cambio.

Pues bien, comparando con lo que estamos viviendo hoy en día podemos darnos cuenta de que hay mucha gente intentando luchar contra todo lo que provoca el calentamiento global y estas cosas, pero nadie ha propuesto una alternativa mejor que permita reemplazar las energías actuales.

Esto me ha llevado a pensar que nos iremos autodestruyendo viviendo en la comodidad hasta que algún génio descubra algo que cambie todo nuestro sistema energético y entonces seguiremos viviendo en la comodidad, pero respetando algo más el entorno. Mientras tanto creo que no se puede esperar que nadie esté dispuesto a abandonar la comodidad a la que hemos llegado hoy en día, y se seguirá negando la posibilidad de que acabemos con el planeta, porque siempre es más fácil creer lo que se quiere creer y tachar de mentirosos o refutar de alguna forma a los que traten de arrebatarnos la comodidad.

Si es así como están las cosas es posible que nadie consiga algo realmente revolucionario que nos haga cambiar sin pensarlo, y acabemos autodestruyendonos por no haber sabido renunciar a una comodidad no merecida.

Asimov fue todo un visionario de comportamiento de masas

¿Qué es un "sistema de control de versiones" (vcs)? Pues es una herramienta que utilizan normalmente los programadores para versionar los cambios realizados sobre el código fuente y trabajar en equipo.

Básicamente funciona así:
Tú tienes una serie de ficheros en tu ordenador, modificas, añades, o haces algo, y haces "commit". Sigues trabajando tan normal y cada vez que te parezca que haces un cambio importante haces "commit". Con esto tienes varias ventajas, lo más importante es que puedes volver cualquier fichero a una revisión anterior. También puedes ver un log de los cambios realizados y otras operaciones.

¿Entonces qué tenemos? pues podemos modificar los ficheros sin miedo porque después de romper algo siempre se puede volver a una versión anterior.

Aparte de eso, los vcs, ofrecen una forma fácil de colaboración entre varias personas. Estos repositorios se pueden publicar, otras personas pueden descargarselos y actualizar su repositorio, e incluso subir cambios que se mezclarán con los tuyos de manera automática.

No lo he explicado muy bien, pero estos sistemas ofrecen la posibilidad de que varias personas trabajen modificando un mismo fichero y que con un par de comandos tengan la versión unificada sin necesidad de enviarse ficheros ni parches ni nada.

BZR

Pues bien, bazaar es un vcs distribuido, fácil de usar y multiplataforma (está en python).

Que sea distribuido quiere decir que cada usuario tendrá su repositorio local en el cual hace los commits, a diferencia de subversion que es centralizado, todos los commits se hacen sobre un repositorio central.

Pero aún siendo distribuido bzr ofrece la posibilidad de utilizarse de manera centralizada, prácticamente igual que svn.

Vamos a lo práctico:

• Crear un repositorio: crear el repositorio es tan fácil como ejecutar "bzr init" dentro del directorio
  
  
  
• Añadir/mover/etc ficheros: para añadir/mover/etc es tan fácil como "bzr add fichero" o "bzr mv fichero1 fichero2" y más comandos similares a los comandos unix.
  
  
  
• Hacer commits: para guardar los cambios en una revisión se utiliza el comando "bzr commit" o "bzr ci" y te abrirá tu editor favorito para que escribas lo que ha cambiado para el log.
  
  
  
• Ver el log: para ver el log "bzr log"
  
  
  
• Volver a una revisión anterior: "bzr revert -r2 fichero fichero2" esto devuelve la lista de ficheros a la revisión 2, si quieres volver completamente deberías usarlo sin los nombres de ficheros.
  
  
  
• Publicar un repositorio (ssh): "bzr push ssh://usuario@dominio/ruta". Esto modificará el repositorio en el dominio/ruta, o lo creará si no existe. Antes de hacer un push hay que hacer un commit de los cambios realizados.
  
  
  
• Descargar un repositorio: "bzr branch ruta destino". Donde ruta puede ser la ruta anterior, si vamos por ssh, y destino es la carpeta que creará para alojar el repositorio.
  
  
  
• Actualizar un repositorio: Una vez que tengamos el repositorio descargado con branch podemos actualizarlo a la última versión con "bzr pull" desde dentro del directorio del repositorio.
  
  
  
• Utilizar cómo subversion: Para poder utilizarlo de modo centralizado hay que utilizar el comando "bzr bind ruta" desde dentro del directorio. Una vez hecho esto se puede actualizar con "bzr update", y desde este momento cada commit no será local, sino que también se hará sobre el servidor.
  
  
  
• Y un montón de cosas más, para más información man bzr
  
  
  

Otra cosa chachi que tiene bzr es que es el sistema utilizado por defecto en launchpad, dónde puedes crear todas las ramas que quieres para tener tu código en un servidor. Algún proyecto tengo yo por ahí.

Y para finalizar decir que no sólo se utiliza para código, yo por ejemplo lo he utilizado para versionar la documentación de mi proyecto fin de carrera.

Viajando en estos aviones de hoy en día no se puede ni dormir, con lo apretado que se va, así que me dediqué en mi viaje a dibujar, y este es el resultado.

Hay que ver lo bonito y práctico que puede quedar un escritorio con esto de gnome+emerald+compiz+awn.

Los temas que tengo:

- gtk2 -> Aurora green peace
- emerald -> lucidity
- screenlets -> ringsensors
- avant-window-navigator es la barra tipo dock parecido a la de macosx