Python Bytecode Disassembler ( dis )

El artículo que sigue es una traducción de un artículo escrito en la página web Python Module of the Week, que es una especie de recopilatorio de artículos sobre módulos de Python escritos por Doug Hellman. Sus textos se publican bajo la licencia Creative Commons By-Nc-Sa ( como los míos, por si alguien no lo había notado todavía con el logo de la página ).

Python Bytecode Disassembler ( dis )

El módulo que trataremos se llama dis y su principal utilidad es convertir código objeto a una representación de bytecode que sea entendible para los seres humanos (o almenos para aquellos que hayan perdido un poco de su tiempo en intentar entender éstas cosas). Éste texto está indicado para versiones de Python iguales o superiores a la versión 1.4, por lo que no tendréis ningún problema (ahora todo el casi mundo usa versiones iguales o superiores a la 2.4).

El módulo dis incluye funciones para desensamblar bytecode de Python (que se genera durante la interpretación del código para acelerar el funcionamiento de los scripts).Observar el código bytecode ejecutado por el intérprete es una buena forma de optimizar a mano bucles y otras secuencias de código. También es útil para encontrar condiciones de carrera en aplicaciones multihilo ya que mirando el bytecode se puede ver en qué "momento" es más probable que haya un cambio de hilo.

Desensamblado básico

La función dis.dis() muestra por pantalla la representación del desensamblado de código fuente Python (módulo, clase, método, función, o código objeto). Podemos desensamblar código como el siguiente:

1
2
3
4

#!/usr/bin/env python
# encoding: utf-8
 
my_dict = { 'a':1 }

ejecutando dis desde la línea de comandos. La salida está organizada en columnas con el número de línea original del código fuente, la “dirección” dentro del código objeto, el nombre de opcode y los argumentos pasados al opcode.

1
2
3
4
5
6
7
8

$ python -m dis codigo.py
  4           0 BUILD_MAP                1
              3 LOAD_CONST               0 (1)
              6 LOAD_CONST               1 ('a')
              9 STORE_MAP
             10 STORE_NAME               0 (my_dict)
             13 LOAD_CONST               2 (None)
             16 RETURN_VALUE

En este caso el código se traduce a 5 operaciones para inicializar el diccionario (crearlo y llenarlo), luego guarda los resultados en una variable global. Como el intérprete de Python está basado en un esquema de pila, los primeros pasos consisten en poner las constantes en la pila siguiendo el orden correcto con la operación LOAD_CONST, y luego usar STORE_MAP para sacar la clave y el valor que se añadirán al diccionario (no nos olvidemos de que antes se ha hecho la operación BUILD_MAP, los valores añadidos entre la ejecución de BUILD_MAP y STORE_MAP serán las claves y los valores del diccionario que estamos creando). El objeto resultante se enlaza con el nombre "my_dict" con la operación STORE_NAME.

Desensamblando funciones

Desafortunadamente desensamblar el módulo entero no lo hace con las funciones que hay en él automáticamente. Por ejemplo, si desensamblamos éste módulo:

1
2
3
4
5
6
7
8
9
10

#!/usr/bin/env python
# encoding: utf-8
 
def f(*args):
    nargs = len(args)
    print nargs, args
 
if __name__ == '__main__':
    import dis
    dis.dis(f)

los resultados muestran como se carga el código objeto en la pila y luego se salta dentro de la función (LOAD_CONST, MAKE_FUNCTION), pero el cuerpo de la función no está.

1
2

$ python -m dis dis_function.py
  4           0 LOAD_CONST               0 (<code>) 3 MAKE_FUNCTION 0 6 STORE_NAME 0 (f) 8 9 LOAD_NAME 1 (__name__) 12 LOAD_CONST 1 ('__main__') 15 COMPARE_OP 2 (==) 18 JUMP_IF_FALSE 29 (to 50) 21 POP_TOP 9 22 LOAD_CONST 2 (-1) 25 LOAD_CONST 3 (None) 28 IMPORT_NAME 2 (dis) 31 STORE_NAME 2 (dis) 10 34 LOAD_NAME 2 (dis) 37 LOAD_ATTR 2 (dis) 40 LOAD_NAME 0 (f) 43 CALL_FUNCTION 1 46 POP_TOP 47 JUMP_FORWARD 1 (to 51) >> 50 POP_TOP >> 51 LOAD_CONST 3 (None) 54 RETURN_VALUE </code>

Para ver dentro de la función tenemos que pasarla como argumento a dis.dis().

1
2
3
4
5
6
7
8
9
10
11
12
13

$ python dis_function.py
  5           0 LOAD_GLOBAL              0 (len)
              3 LOAD_FAST                0 (args)
              6 CALL_FUNCTION            1
              9 STORE_FAST               1 (nargs)
 
  6          12 LOAD_FAST                1 (nargs)
             15 PRINT_ITEM
             16 LOAD_FAST                0 (args)
             19 PRINT_ITEM
             20 PRINT_NEWLINE
             21 LOAD_CONST               0 (None)
             24 RETURN_VALUE

Clases

Se pueden pasar también clases a la función dis, en este caso todos sus métodos son desensamblados a la vez.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

#!/usr/bin/env python
# encoding: utf-8
 
import dis
 
class MyObject(object):
    """Example for dis."""
 
    CLASS_ATTRIBUTE = 'some value'
 
    def __init__(self, name):
        self.name = name
 
    def __str__(self):
        return 'MyObject(%s)' % self.name
 
dis.dis(MyObject)
1
2
3
4
5
6
7
8
9
10
11
12
13
14

$ python dis_class.py
Disassembly of __init__:
 12           0 LOAD_FAST                1 (name)
              3 LOAD_FAST                0 (self)
              6 STORE_ATTR               0 (name)
              9 LOAD_CONST               0 (None)
             12 RETURN_VALUE
 
Disassembly of __str__:
 15           0 LOAD_CONST               1 ('MyObject(%s)')
              3 LOAD_FAST                0 (self)
              6 LOAD_ATTR                0 (name)
              9 BINARY_MODULO
             10 RETURN_VALUE

Desensamblando para debuggear

A veces puede ser útil ver qué bytecode causó el problema cuando se está debuggeando una excepción.  Hay un par de formas de desensamblar el código que encierra el error.

La primera forma consiste en usar dis.dis() dentro del intérprete interactivo para que analize la última excepción ocurrida. Si no se le pasa ningún argumento a dis, ésta busca la última excepción ocurrida y muestra el desensamblado de la parte "más alta" de la pila que la causó.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

$ python
Python 2.6.2 (r262:71600, Apr 16 2009, 09:17:39)
[GCC 4.0.1 (Apple Computer, Inc. build 5250)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
>>> import dis
>>> j = 4
>>> i = i + 4
Traceback (most recent call last):
  File "", line 1, in
NameError: name 'i' is not defined
>>> dis.distb()
  1 -->       0 LOAD_NAME                0 (i)
              3 LOAD_CONST               0 (4)
              6 BINARY_ADD
              7 STORE_NAME               0 (i)
             10 LOAD_CONST               1 (None)
             13 RETURN_VALUE
>>>

Notad la flecha --> indicando el opcode que causó el error. La variable “i” no está definida, por lo que el valor asociado con el nombre no puede ser cargado en la pila.

Desde tu propio código puedes mostrar por pantalla información sobre el traceback pasándolodirectamente como argumento a dis.distb(). En este ejemplo hay una excepción DivideByZero, pero como la fórmula tiene dos partes, no está claro cual de los elementos es el cero.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

#!/usr/bin/env python
# encoding: utf-8
 
i = 1
j = 0
k = 3
 
# ... many lines removed ...
 
try:
    result = k * (i / j) + (i / k)
except:
    import dis
    import sys
    exc_type, exc_value, exc_tb = sys.exc_info()
    dis.distb(exc_tb)

El valor incorrecto es fácil de detectar cuando está cargado en la pila dentro del desensamblado. La operación incorrecta está remarcada con la flecha -->, y sólo tenemos que mirar unas cuantas líneas hacia arriba para encontrar dónde se ha cargado el valor 0 en la pila.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56

$ python dis_traceback.py
  4           0 LOAD_CONST               0 (1)
              3 STORE_NAME               0 (i)
 
  5           6 LOAD_CONST               1 (0)
              9 STORE_NAME               1 (j)
 
  6          12 LOAD_CONST               2 (3)
             15 STORE_NAME               2 (k)
 
 10          18 SETUP_EXCEPT            26 (to 47)
 
 11          21 LOAD_NAME                2 (k)
             24 LOAD_NAME                0 (i)
             27 LOAD_NAME                1 (j)
    -->      30 BINARY_DIVIDE
             31 BINARY_MULTIPLY
             32 LOAD_NAME                0 (i)
             35 LOAD_NAME                2 (k)
             38 BINARY_DIVIDE
             39 BINARY_ADD
             40 STORE_NAME               3 (result)
             43 POP_BLOCK
             44 JUMP_FORWARD            65 (to 112)
 
 12     >>   47 POP_TOP
             48 POP_TOP
             49 POP_TOP
 
 13          50 LOAD_CONST               3 (-1)
             53 LOAD_CONST               4 (None)
             56 IMPORT_NAME              4 (dis)
             59 STORE_NAME               4 (dis)
 
 14          62 LOAD_CONST               3 (-1)
             65 LOAD_CONST               4 (None)
             68 IMPORT_NAME              5 (sys)
             71 STORE_NAME               5 (sys)
 
 15          74 LOAD_NAME                5 (sys)
             77 LOAD_ATTR                6 (exc_info)
             80 CALL_FUNCTION            0
             83 UNPACK_SEQUENCE          3
             86 STORE_NAME               7 (exc_type)
             89 STORE_NAME               8 (exc_value)
             92 STORE_NAME               9 (exc_tb)
 
 16          95 LOAD_NAME                4 (dis)
             98 LOAD_ATTR               10 (distb)
            101 LOAD_NAME                9 (exc_tb)
            104 CALL_FUNCTION            1
            107 POP_TOP
            108 JUMP_FORWARD             1 (to 112)
            111 END_FINALLY
        >>  112 LOAD_CONST               4 (None)
            115 RETURN_VALUE

Análisis de rendimiento en bucles

Además de para localizar errores, dis también puede ayudar a encontrar problemas de rendimiento en nuestro código. Examinar el código desensamblado es especialmente útil con pequeños bucles en los que el número de líneas de código Python es pequeño pero éstas se  ejecutan lentamente ya que se traducen a un conjunto ineficiente de bytecodes. Veremos como el desensamblado nos ayuda a examinar unas pocas implementaciones de una clase, Dictionary, que lee un conjunto de palabras y las agrupa por su primera letra.

Antes de nada, la aplicación que usaremos para hacer los tests:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

import dis
import sys
import timeit
 
module_name = sys.argv[1]
module = __import__(module_name)
Dictionary = module.Dictionary
 
dis.dis(Dictionary.load_data)
print
t = timeit.Timer(
    'd = Dictionary(words)',
    """from %(module_name)s import Dictionary
words = [l.strip() for l in open('/usr/share/dict/words', 'rt')]
    """ % locals()
    )
iterations = 10
print 'TIME: %0.4f' % (t.timeit(iterations)/iterations)

Podemos usar dis_test_loop.py para ejecutar cada versión de la clase Dictionary que hagamos.

Una implementación sencilla de la classe Dictionary puede ser algo así:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

#!/usr/bin/env python
# encoding: utf-8
 
class Dictionary(object):
 
    def __init__(self, words):
        self.by_letter = {}
        self.load_data(words)
 
    def load_data(self, words):
        for word in words:
            try:
                self.by_letter[word[0]].append(word)
            except KeyError:
                self.by_letter[word[0]] = [word]

La salida muestra que esta versión ha tomado 0.1074 segundos para cargar las 234936 palabras en mi copia de  /usr/share/dict/words en OS X [Recordad que es una traducción y no lo hice directamente yo ésto]. No está demasiado mal, pero como podemos ver en el desensamblado de abajo, el bucle. está haciendo más trabajo del necesario. Tal como entra en el bucle en el opcode 13, se instala el contexto de una excepción (SETUP_EXCEPT). Entonces usa 6 opcodes para encontrar self.by_letter[word[0]] antes de añadir la palabra a la lista. Si se lanza una excepción porque word[0] todavía no está en el diccionario, el manejador de excepciones hace otra vez el mismo trabajo para  determinar word[0] (3 opcodes) y inicializa self.by_letter[word[0]] como una nueva lista que contiene la palabra.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

$ python dis_test_loop.py dis_slow_loop
 11           0 SETUP_LOOP              84 (to 87)
              3 LOAD_FAST                1 (words)
              6 GET_ITER
        >>    7 FOR_ITER                76 (to 86)
             10 STORE_FAST               2 (word)
 
 12          13 SETUP_EXCEPT            28 (to 44)
 
 13          16 LOAD_FAST                0 (self)
             19 LOAD_ATTR                0 (by_letter)
             22 LOAD_FAST                2 (word)
             25 LOAD_CONST               1 (0)
             28 BINARY_SUBSCR
             29 BINARY_SUBSCR
             30 LOAD_ATTR                1 (append)
             33 LOAD_FAST                2 (word)
             36 CALL_FUNCTION            1
             39 POP_TOP
             40 POP_BLOCK
             41 JUMP_ABSOLUTE            7
 
 14     >>   44 DUP_TOP
             45 LOAD_GLOBAL              2 (KeyError)
             48 COMPARE_OP              10 (exception match)
             51 JUMP_IF_FALSE           27 (to 81)
             54 POP_TOP
             55 POP_TOP
             56 POP_TOP
             57 POP_TOP
 
 15          58 LOAD_FAST                2 (word)
             61 BUILD_LIST               1
             64 LOAD_FAST                0 (self)
             67 LOAD_ATTR                0 (by_letter)
             70 LOAD_FAST                2 (word)
             73 LOAD_CONST               1 (0)
             76 BINARY_SUBSCR
             77 STORE_SUBSCR
             78 JUMP_ABSOLUTE            7
        >>   81 POP_TOP
             82 END_FINALLY
             83 JUMP_ABSOLUTE            7
        >>   86 POP_BLOCK
        >>   87 LOAD_CONST               0 (None)
             90 RETURN_VALUE
 
TIME: 0.1074

Una técnica para elimnar la excepción es rellenar self.by_letter con una lista para cada letra del alfabeto antes de empezar a llenar el diccionario. Esto significa que siempre podremos hacer la operación append satisfactoriamente sin necesidad de manejar ninguna excepción.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

#!/usr/bin/env python
# encoding: utf-8
 
import string
 
class Dictionary(object):
 
    def __init__(self, words):
        self.by_letter = dict( (letter, [])
                                for letter in string.letters)
        self.load_data(words)
 
    def load_data(self, words):
        for word in words:
            self.by_letter[word[0]].append(word)

El cambio reduce el número de opcodes aproximadamente a la mitad, pero solo se reduce el tiempo a 0.0984 segundos. Obviamente el manejo de la excepción añadía un cierto overhead pero tampoco demasiado.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

$ python dis_test_loop.py dis_faster_loop
 14           0 SETUP_LOOP              38 (to 41)
              3 LOAD_FAST                1 (words)
              6 GET_ITER
        >>    7 FOR_ITER                30 (to 40)
             10 STORE_FAST               2 (word)
 
 15          13 LOAD_FAST                0 (self)
             16 LOAD_ATTR                0 (by_letter)
             19 LOAD_FAST                2 (word)
             22 LOAD_CONST               1 (0)
             25 BINARY_SUBSCR
             26 BINARY_SUBSCR
             27 LOAD_ATTR                1 (append)
             30 LOAD_FAST                2 (word)
             33 CALL_FUNCTION            1
             36 POP_TOP
             37 JUMP_ABSOLUTE            7
        >>   40 POP_BLOCK
        >>   41 LOAD_CONST               0 (None)
             44 RETURN_VALUE
 
TIME: 0.0984

Podemos optimizar aún más el rendimiento moviendo el acceso a self.by_letter fuera del bucle (dado que el valor no cambia en ningún momento).

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

#!/usr/bin/env python
# encoding: utf-8
 
import collections
 
class Dictionary(object):
 
    def __init__(self, words):
        self.by_letter = collections.defaultdict(list)
        self.load_data(words)
 
    def load_data(self, words):
        by_letter = self.by_letter
        for word in words:
            by_letter[word[0]].append(word)

Los opcodes 0-6 ahora encuentran el valor de self.by_letter y lo guardan como la variable local by_letter. Usar variables locales solo requiere un opcode en vez de 2 (en la posición 22 se usa LOAD_FAST para almacenar dictionary en la pila). Después de este cambio el tiempo de ejecución se reduce a 0.0842 segundos.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

$ python dis_test_loop.py dis_fastest_loop
 13           0 LOAD_FAST                0 (self)
              3 LOAD_ATTR                0 (by_letter)
              6 STORE_FAST               2 (by_letter)
 
 14           9 SETUP_LOOP              35 (to 47)
             12 LOAD_FAST                1 (words)
             15 GET_ITER
        >>   16 FOR_ITER                27 (to 46)
             19 STORE_FAST               3 (word)
 
 15          22 LOAD_FAST                2 (by_letter)
             25 LOAD_FAST                3 (word)
             28 LOAD_CONST               1 (0)
             31 BINARY_SUBSCR
             32 BINARY_SUBSCR
             33 LOAD_ATTR                1 (append)
             36 LOAD_FAST                3 (word)
             39 CALL_FUNCTION            1
             42 POP_TOP
             43 JUMP_ABSOLUTE           16
        >>   46 POP_BLOCK
        >>   47 LOAD_CONST               0 (None)
             50 RETURN_VALUE
 
TIME: 0.0842

Una mayor optimización sugerida por Brandon Rhodes es eliminar la versión Python del bucle por completo. Si usamos groupby() del módulo itertools para agrupar la entrada, la iteración es movida a código C. Podemos hacer ésto porque sabemos que la entrada está ordenada. En caso de no saber si está ordenada o no, deberíamos ordenarla por si acaso.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

#!/usr/bin/env python
# encoding: utf-8
 
import operator
import itertools
 
class Dictionary(object):
 
    def __init__(self, words):
        self.by_letter = {}
        self.load_data(words)
 
    def load_data(self, words):
        # Arrange by letter
        grouped = itertools.groupby(words, key=operator.itemgetter(0))
        # Save arranged sets of words
        self.by_letter = dict((group[0][0], group) for group in grouped)

La versión con itertools solo tarda 0.0543 segundos en ejecutarse, más o menos la mitad del tiempo original.

1
2
3
4
5
6
7
8
9
10
11
12
13
14

$ python dis_test_loop.py dis_eliminate_loop
 15           0 LOAD_GLOBAL              0 (itertools)
              3 LOAD_ATTR                1 (groupby)
              6 LOAD_FAST                1 (words)
              9 LOAD_CONST               1 ('key')
             12 LOAD_GLOBAL              2 (operator)
             15 LOAD_ATTR                3 (itemgetter)
             18 LOAD_CONST               2 (0)
             21 CALL_FUNCTION            1
             24 CALL_FUNCTION          257
             27 STORE_FAST               2 (grouped)
 
 17          30 LOAD_GLOBAL              4 (dict)
             33 LOAD_CONST               3 (<code> at 0x7e7b8, file "/Users/dhellmann/Documents/PyMOTW/dis/PyMOTW/dis/dis_eliminate_loop.py", line 17>) 36 MAKE_FUNCTION 0 39 LOAD_FAST 2 (grouped) 42 GET_ITER 43 CALL_FUNCTION 1 46 CALL_FUNCTION 1 49 LOAD_FAST 0 (self) 52 STORE_ATTR 5 (by_letter) 55 LOAD_CONST 0 (None) 58 RETURN_VALUE TIME: 0.0543 </code>

Referencias:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

$ python dis_test_loop.py dis_eliminate_loop
 15           0 LOAD_GLOBAL              0 (itertools)
              3 LOAD_ATTR                1 (groupby)
              6 LOAD_FAST                1 (words)
              9 LOAD_CONST               1 ('key')
             12 LOAD_GLOBAL              2 (operator)
             15 LOAD_ATTR                3 (itemgetter)
             18 LOAD_CONST               2 (0)
             21 CALL_FUNCTION            1
             24 CALL_FUNCTION          257
             27 STORE_FAST               2 (grouped)
 
 17          30 LOAD_GLOBAL              4 (dict)
             33 LOAD_CONST               3 (<code object <genexpr> at 0x7e7b8, file "/Users/dhellmann/Documents/PyMOTW/dis/PyMOTW/dis/dis_eliminate_loop.py", line 17>)
             36 MAKE_FUNCTION            0
             39 LOAD_FAST                2 (grouped)
             42 GET_ITER
             43 CALL_FUNCTION            1
             46 CALL_FUNCTION            1
             49 LOAD_FAST                0 (self)
             52 STORE_ATTR               5 (by_letter)
             55 LOAD_CONST               0 (None)
             58 RETURN_VALUE
 
TIME: 0.0543

Novedades en CMD Twitt

No hay mucho que decir pero ha habido algunos avances significativos desde que escribí el primer post. He añadido algunas opciones más para que el programa sea más útil, he corregido dos pequeños bugs relativos a la gestión de errores y he simplificado la gestión de la codificación de texto gracias a una característica de la librería python-twitter que me había pasado desapercibida. También he creado alguna función más que me ha permitido simplificar un poco más el código.

Lo que me queda por hacer:

  1. Añadir un modo interactivo, lo programaré con la librería curses
  2. Aprovechar la capacidad de internacionalización del programa y traducirlo al castellano y al catalán
  3. Empaquetarlo para Debian
  4. Si a alguien se le ocurre algo más, tiene todo el derecho del mundo a decirlo :) .

Algunas cosillas más :) :

Añadí el proyecto a Launchpad ( CMD Twitt ) ya que gracias a ésto ahora tengo un bug tracker donde todo el mundo puede indicar los bugs que encuentre en el programa :) y también dejar sugerencias de mejora en los Blue Prints.

Saludos!

Cmd Twitt

Hace tres días empecé a programar Cmd Twitt (y lo acabé ayer, bueno, supongo que todavía se puede mejorar pero no le voy a dedicar mucho más tiempo a no ser que se reporten bugs alguien tenga buenas ideas para mejorarlo). Éste programa es un simple programa de consola que permite acceder a los servicios de la popular red social Twitter.

Lo programé en Python usando la librería python-twitter, que se puede instalar mediante aptitude o apt-get en sistemas Debian o Ubuntu. Hay algunos detalles interesantes del programa sobre los que me gustaría escribir porque aprendí algunas cosillas mientras lo estaba haciendo, entre otras cosas las siguientes:

  • Internacionalización de aplicaciones Python
  • Correcto funcionamiento con diferentes codificaciones de texto
  • Gestión sencilla de ficheros de configuración
  • Poner colorines en la consola, jeje
  • Esto tiene poco que ver con la programación en sí, pero es interesante también: Trabajar con git y gitorious

Os cuelgo el código y acto seguido vamos con la explicación:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315

#!/usr/bin/env python
# encoding: utf-8
# -*- coding: utf-8 -*-
 
############################################################################
#                     --- cmd-twitt 2009.08.16 ---                         #
#                                                                          #
#   Copyright (C) 2009 by Andreu Correa Casablanca  (Original Author)      #
#                                                                          #
#   Email: castarco@gmail.com (Andreu Correa Casablanca)                   #
#                                                                          #
#   This program is free software; you can redistribute it and/or modify   #
#   it under the terms of the GNU General Public License as published by   #
#   the Free Software Foundation; either version 3 of the License, or      #
#   (at your option) any later version.                                    #
#                                                                          #
#   This program is distributed in the hope that it will be useful,        #
#   but WITHOUT ANY WARRANTY; without even the implied warranty of         #
#   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the          #
#   GNU General Public License for more details.                           #
#                                                                          #
#   You should have received a copy of the GNU General Public License      #
#   along with this program; if not, write to the                          #
#   Free Software Foundation, Inc.,                                        #
#   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.              #
############################################################################
 
import ConfigParser
import getpass
import gettext
import locale
import optparse
import os
import sys
import twitter
import urllib2
 
# An alias that allows us to imitate the touch command
touch = lambda file: open(file, "w").close()
 
cmd_usage   = 'usage: %prog [option] [num_of_twits_per_timeline]'
cmd_version = '2009.08.16'
 
conf_dir  = os.environ["HOME"] + "/.cmdtwitt/"
conf_file = conf_dir + "user.conf"
 
encoding  = locale.getpreferredencoding().lower()
 
user = ''
pswd = ''
 
color = {}
color['green']   = '\33[1;32m'
color['nocolor'] = '\33[1;0m'
color['red']     = '\33[1;31m'
color['white']   = '\33[1;37m'
color['yellow']  = '\33[1;33m'
 
# Translate some global vars
def init_vars():
        global cmd_usage
 
        cmd_usage   = _(cmd_usage)
 
# Load the account settings
def load_config():
        global user, pswd
 
        cfg = ConfigParser.ConfigParser()
 
        try:
                cfg.readfp(file(conf_file))
        except:
              raise
 
        user = cfg.get ('TWIT_ACCOUNT', 'User')
        pswd = cfg.get ('TWIT_ACCOUNT', 'Pswd')
 
#Set the account settings
def set_config():
        global conf_dir, conf_file
 
        print _("Settings:")
 
        cfg = ConfigParser.ConfigParser()
        cfg.add_section('TWIT_ACCOUNT')
 
        cfg.set('TWIT_ACCOUNT', 'User', raw_input(_('tUser: ')) )
 
        pswd_not_set = True
        while pswd_not_set:
                pswd1 = getpass.getpass(_('tPassword       : '))
                pswd2 = getpass.getpass(_('tRepeat password: '))
 
                if pswd1 == pswd2:
                        pswd_not_set = False
                else:
                        print _('The passwords don't match. Please try to write it again.')
 
        cfg.set('TWIT_ACCOUNT', 'Pswd', pswd1)
 
        if os.access(conf_file, os.F_OK) == False:
                try:
                        touch(conf_file)
                except IOError:
                        try:
                                os.mkdir(conf_dir, 0700)
                        except IOError:
                                print _('It was impossible to create the config dir.')
                                raise
 
                        try:
                                touch(conf_file)
                        except:
                                print _('It was impossible to create the config file.')
                                raise
 
        try:
                cfg.write(file(conf_file, 'w'))
        except:
                raise
 
# Manage connection errors
def manage_connection_error(e, code):
        if e.getcode() == code:
                print _('tUnauthorized acces, you should set a correct username and password.')
        else:
                print _('It seems twitter is down. Try it later.')
 
# Sends a message to a user
def send_msg_to_user(_user):
        global user, pswd, cmd_version
 
        api = twitter.Api(username=user, password=pswd)
 
        msg = unicode(raw_input( _('Type your message:nt') ), encoding)[:140]
 
        try:
                api.PostDirectMessage(_user, msg)
 
        except urllib2.HTTPError, e:
                print _('Error sending the message:')
 
                manage_connection_error(e, 401)
 
# Show the user status
def show_status():
        global user, pswd
 
        api = twitter.Api(username=user, password=pswd)
 
        try:
                status = api.GetUserTimeline(user)[0].text
 
                print _('Your status is:nt' + status)
        except urllib2.HTTPError, e:
                print _('Error reading your status:')
 
                manage_connection_error(e, 404)
 
# Format the timeline to show in the console
def show_timeline(num_msgs, statuses):
        global color
 
        _status = statuses[0]
        print color['green']+_status.user.name + ' :n' + color['yellow'] + _status.GetRelativeCreatedAt() + ' > ' + color['nocolor'] + _status.text + 'n'
 
        for status in statuses[1:num_msgs]:
                if status.user.name == _status.user.name:
                        name = color['yellow'] + status.GetRelativeCreatedAt()+' > ' + color['nocolor']
                else:
                        name = color['green']+status.user.name + ' :n' + color['yellow'] + status.GetRelativeCreatedAt() + ' > ' + color['nocolor']
 
                print name + status.text + 'n'
                _status = status
 
# Shows the timeline of a specific twitter user
def show_usertimeline(_user, num_msgs):
        global user, pswd, color
 
        api = twitter.Api(username=user, password=pswd)
 
        try:
                statuses = api.GetUserTimeline(_user)
 
                print color['red'] + _user + _(' Timeline:n') + color['nocolor']
 
                show_timeline(num_msgs, statuses)
 
        except urllib2.HTTPError, e:
                print _('Error reading the timeline:')
 
                manage_connection_error(e, 401)
 
# Shows the Home timeline
def show_friendstimeline(num_msgs):
        global user, pswd, color
 
        api = twitter.Api(username=user, password=pswd)
 
        try:
                statuses = api.GetFriendsTimeline(user)
 
                print color['red'] +_('Home Timeline:n') + color['nocolor']
 
                show_timeline(num_msgs, statuses)
 
        except urllib2.HTTPError, e:
                print _('Error reading the timeline:')
 
                manage_connection_error(e, 401)
 
# Shows the Home timeline
def show_publictimeline(num_msgs):
        global user, pswd
 
        api = twitter.Api(username=user, password=pswd)
 
        try:
                statuses = api.GetPublicTimeline()
 
                print color['red'] + _('Public Timeline:n') + color['nocolor']
 
                show_timeline(num_msgs, statuses)
 
        except urllib2.HTTPError, e:
                print _('Error reading the timeline:')
 
                manage_connection_error(e, 401)
 
# Send a message to twitter
def send_msg(_user):
        global user, pswd, cmd_version
 
        api = twitter.Api(username=user, password=pswd)
 
        try:
                if _user != '':
                        _user = '@'+_user+' '
 
                api.PostUpdate( ( _user + unicode(raw_input( _('Write your message and press Enter:nt') ), encoding) )[:140] )
 
        except urllib2.HTTPError, e:
                print _('Error sending the message:')
 
                manage_connection_error(e, 401)
 
# The main program
def main(argv=None):
        global user, pswd
 
        if argv == None:
                argv = sys.argv
 
        # Internationalization
        gettext.install('cmd-twitt')
 
        init_vars()
 
        cmd_parser = optparse.OptionParser(usage=cmd_usage, version=cmd_version, conflict_handler='resolve')
 
        cmd_parser.add_option('-h', '--help',    action='help',    help=_('print this help text and exit'))
        cmd_parser.add_option('-v', '--version', action='version', help=_('print program version and exit'))
 
        cmd_parser.add_option('-c', '--config', dest='config', action='store_true', help=_('Configure your twitter account'))
        cmd_parser.add_option('-s', '--status', dest='status', action='store_true', help=_('Shows your status'))
 
        cmd_parser.add_option('-p', '--publictimeline',  dest='publictimeline',  action='store_true', help=_('Shows the public timeline'))
        cmd_parser.add_option('-u', '--usertimeline',    dest='usertimeline',    action='store_true', help=_('Shows the user timeline'))
        cmd_parser.add_option('-F', '--friendtimeline',  dest='friendtimeline',  metavar='FRIEND',    help=_('Shows the timeline of a friend'))
        cmd_parser.add_option('-f', '--friendstimeline', dest='friendstimeline', action='store_true', help=_('Shows the friends timeline'))
 
        cmd_parser.add_option('-m', '--private-message', dest='private_msg', metavar='USER', help=_('Sends a private message to a twitter user'))
        cmd_parser.add_option('-M', '--public-message',  dest='public_msg',  metavar='USER', help=_('Sends a public message to a twitter user'))
 
        (cmd_opts, cmd_args) = cmd_parser.parse_args()
 
        if cmd_opts.config:
                try:
                        set_config()
                except:
                        print _("It was impossible to set the settings.")
                        return 1
        else:
                try:
                        load_config()
                except:
                        print _('There is not a config file, you should set your user and password in the settings option.n')
                        cmd_parser.print_help()
                        return 1
 
                try:
                        num_msgs = int(cmd_args[0])
                except:
                        num_msgs = 10
 
                if cmd_opts.private_msg:
                        send_msg_to_user(cmd_opts.private_msg)
                elif cmd_opts.public_msg:
                        send_msg(cmd_opts.public_msg)
                elif cmd_opts.status:
                        show_status()
                elif cmd_opts.usertimeline:
                        show_usertimeline(user, num_msgs)
                elif cmd_opts.friendtimeline:
                        show_usertimeline(cmd_opts.friendtimeline, num_msgs)
                elif cmd_opts.friendstimeline:
                        show_friendstimeline(num_msgs)
                elif cmd_opts.publictimeline:
                        show_publictimeline (num_msgs)
                else:
                        send_msg('')
 
if __name__ == "__main__":
        sys.exit(main())

Internacionalización

Lo primero que se tiene que hacer es escribir la linia import gettext para cargar el módulo que nos ayudará en nuestro quehacer. La segunda línea (no del texto, sino referente a la internacionalización, la podemos encontrar en la función main) gettext.install('cmd-twitt') se dedica a cargar la traducción al idioma por defecto del sistema para las cadenas de texto que usa el programa. La traducción se cargará desde el directorio /usr/share/locale/[abreviatura para el lenguaje por defecto del sistema]/LC_MESSAGES/cmd-twitt.mo.

Por último (en cuanto se refiere al código) lo que se tiene que hacer para que todas las cadenas que queramos sean susceptibles de traducción a través del módulo gettext es escribirlas de ésta forma _('cadena'). La función _() es un alias para gettext.gettext().

Quedan otros pasos que no tienen mucho que ver con el código, sinó con la traducción en sí. Para empezar a traducir el programa lo primero que debemos hacer es obtener un fichero especial sobre el que se basarán las traducciones. Lo haremos así:

gettext cmd-twitt.py

Ésto generará un fichero llamado messages.po que contendrá parejas de cadenas, las originales junto con sus traducciones. Para empezar la traducción al castellano generamos un nuevo fichero a partir de messages.po que será el que contendrá la traducción en sí (messages.po lo guardamos como base para traducciones a otros lenguajes). Lo haremos como se sigue:

msginit --locale=es -i messages.po

Éste programa nos pedirá algunos datos acerca de nosotros (para que quede constancia de quienes son los traductores,  está bien que se sepa de quien es la autoría) y finalmente creará un fichero llamado es.po , que es el que nos dedicaremos a modificar.

Finalmente el fichero puede ser editado por herramientas tales como gtranslator o ktranslator para luego ser compilado a un fichero con extensión .mo que será el que irá al directorio de traducciones que mencionamos anteriormente. (Cambiando su nombre es.mo a cmd-twitt.mo)

Codificaciones de texto

Éste es un tema que ha dado mucho por saco, la verdad sea dicha. De hecho la librería python-twitter no funciona demasiado bien en este aspecto, falta que la pulan un poco (y no solo por lo de la codificación de texto, yo ya he tenido que corregir algunos bugs en la versión de mi sistema, tengo que ver ahora si es la versión de Ubuntu o la del repositorio oficial de código tiene los mismos errores).

Percibí el problema en cuanto intenté enviar mensajes con acentos a través de Cmd Twitt a Twitter, ¿Cual era el problema? El programa reventaba. Mi primer logro consistió en hacer que funcionara para mi sistema, pero luego ajusté un poco mejor el funcionamiento.. y CREO (no estoy del todo seguro) que funcionará en sistemas con diferentes codificaciones de texto.

Primera solución:

Supongamos que str es una cadena que hemos obtenido a través de la función raw_input() , la solución consistía en usar la cadena resultantde de aplicar la función unicode() a str, de la siguiente forma: unicode(str, 'utf-8') . Si no se añade el segundo argumento la función unicode() intenta leer str como si fuera ASCII y el programa revienta igualmente (que es justo lo que se hace en la librería python-twitter, un error un poco burdo, se nota que no deben hablar otras lenguas los creadores de la librería).

Ésta solución funciona en mi sistema porque usa UTF-8 para la codificación de las cadenas... pero eso no es necesariamente así en todos los sistemas.

Segunda solución:

La segunda solución pasa por el uso del módulo locale, así que tenemos que hacer un import de éste. Simplemente tenemos que sustituir la cadena 'utf-8' por el resultado de locale.getpreferredencoding().lower() .

Ficheros de configuración

No me extenderé mucho con ésto. He usado el módulo ConfigParser , y en cuanto a la introducción de la contraseña de usuario para twitter he utilizado un módulo llamado getpass que permite introducir caracteres sin tener que mostrarlos por pantalla. És fácil de aprender viendo el código como ejemplo.

Colorines

Lo reconozco, hay que estar un poco zumbado para dedicar una sección entera de la explicación ssólo para los colorines, qué le vamos a hacer, soy así. Aunque se reduce a algo tan simple como añadir al principio de la cadena que queremos colorear ciertas cadenas características que harán cambiar el color del texto de la consola (incluso después de haberse cerrado el programa). Ésto solo funciona para algunas consolas concretas.. no las he provado, pero aseguro que funciona con Bash, y también aseguro que no funciona en MS Windows.

Las cadenas son de la forma '\33[1;32m' en la que para escoger el color sólo se tienen que cambiar los dos números del final, ésta en particular es para el color verde. Al final del artículo encontraréis un enlace para ver la tabla de códigos y sus colores correspondientes.

Git y Gitorious

Me da pereza seguir explicándolo todo como si fuera un cuento, voy al grano:

  • Crear una cuenta en gitorious.org
  • Subir una clave pública de ssh a Gitorious, si ya existe en vuestro sistema la tendréis en el fichero /home/usuario/.ssh/id_rsa.pub . En caso de no tenerla, lo podéis hacer mediante el comando ssh-keygen -t rsa .
  • Crear un proyecto y un repositorio, es todo guiado así que resulta muy sencillo.
  • Ahora toca la parte de configurar el repositorio en nuestro ordenador de trabajo. Tendremos que tener instalados ssh y git antes que nada. Los pasos que seguiremos son:
    • cd directorio_proyecto
    • git init  # Creamos el repositorio local
    • git add . # Ésto añade el directorio a la lista de ficheros del repositorio git
    • git commit -a -m "Y se hizo la luz"  # El comentario no es realmente importante (almenos en el primer commit, vamos)
    • git remote add origin git@gitorious.org:miproyecto/mainline.git # Esto nos servirá para "conectar" nuestro repositorio local con el remoto de Gitorious.org, en la documentación que encontré ponían origen en vez de origin pero luego el siguiente paso no se podía hacer de la manera "corta" que seguidamente indico
    • git push origin master # Con ésto subimos los cambios que hemos hecho al repositorio remoto, las próximas veces sólo tendremos que escribir git push

Ahora os dejo las fuentes que me han servido para informarme un poco:

Internacionalización:

Ficheros de configuración en Python:

Colorines:

Configuración de Git y Gitorious:

Hasta otra :) .

Pdf Mod

Hace una semana descubrí en el agregador de blogs Monologue (de Mono-Project) un proyecto iniciado por Gabriel Burt llamado Pdf Mod que parece avanzar a pasos agigantados y puede resultar muy útil.

Se trata de un programa diseñado para modificar PDFs escrito en C# para la plataforma Mono. Utiliza las librerías Poppler, PdfSharp, Gtk#, Cairo, y la librería Hyena de Banshee, y es precisamente ésto lo que ha permitido el rápido desarrollo que ha tenido.

Sus características actuales son:

  • Abrir documentos arrastrándolos desde Nautilus y soltándolos sobre Pdf Mod.
  • Soporta ficheros Pdf protegidos por contraseña.
  • Rotar, extraer y eliminar páginas.
  • Añadir páginas arrastrándolas desde otro documento abierto.
  • Cambiar el orden de las páginas mediante "Arrastrar y soltar"
  • Leer y cambiar las propiedades del documento.
  • Exportar imágenes.
  • Traducido a un porrón de idiomas (yo lo he traducido a castellano, y lo voy a traducir al catalán a no ser que se adelante alguien)
  • Y supongo que algunas más, ahora van por la versión 0.5 y me parece que han ido aumentando el número de versión aproximadamente cada 3 días.

Yo por mi parte lo utilizaré para unificar los Pdfs de Linux Magazine, que ofrecen todas sus revistas digitales separadas en artículos individuales... creo que será más sencillo tener sólo tantos pdfs como revistas y no tantos como artículos (ah, y podré quitar la publi para reducir peso, jeje).

Saludos :) .