.:::Joaclandia:::.

Zafá del xml con Tryton Builder!

2013-06-05T14:23:00.001-03:00

Hay cosas que no me gustan, y hay cosas que detesto. En esa escala de valores, en el primer lugar está PHP y en el segundo los XMLs. Como conté en el post anterior, estoy desarrollando algunos módulos para Tryton, que define sus vistas, y elementos de interacción usando ese lenguaje de markup.

Hay varios artículos que hablan que uno tiene que ser un programador vago, yo estoy totalmente de acuerdo con que hay que ser un programador que automatiza al máximo el trabajo que no le gusta hacer, para poder dedicar el tiempo a problemas mas complicados o atractivos, o a mirar por la ventana.

En mi intento por zafar de escribir varios cientos de '<',' /', y '>' a mano nació Tryton Builder (Que tiene logo y todo!)

Por el momento, para generar un módulo, hay que escribir un pequeño archivo de código (Si, es código python, porque me gusta programar, no parametrizar, yamls, csv, y ese tipo de cosas) de este estilo:

En el ejemplo, estoy realizando todos los pasos para generar el modulo de ejemplo del wiki de tryton

Solo para comparar la diferencia de caracteres escritos versus generados:

El proximo paso, es armar una interfaz de consola como la de los scaffolders de Ruby On Rails

Monkey Patcheando Element tree para soportar cdata

2013-06-04T14:04:00.000-03:00

Hace un tiempo que estoy trabajando con Tryton, el ERP libre, escrito en python, y como me gustan los scaffolders de Rails, decidí escribir uno para armar los esqueletos de los módulos. Tryton, no se bien por que motivo, utiliza mucho xml, para definir vistas, y fixtures de datos. Como me gusta programar en python, me empezé a escribir una especie de DSL para definirlos de una manera mas amigable:
https://github.com/joac/tryton_builder

Python permite trabajar con xml con un montón de bibliotecas distintas, pero las mas amigable de usar, para mi es ElementTree

Cuando empece a escribir el codigo, y hacer pruebas, me encontré con varios problemas, el primero, ElementTree no tiene "Pritty Print"
para que el xml generado sea mas cómodo de leer, por suerte encontré esta receta:

en http://effbot.org/zone/element-lib.htm#prettyprint que resolvió correctamente el problema

Avanzando en el diseño de los scaffolders me encontré con otra limitación ElementTree no soporta el tag CDATA. Usted podria preguntarse "¿Que es el tag CDATA?", Básicamente un tag que le dice al parser "Lo que esta aca adentro es un conjunto de caracteres, no lo parsees"
Si bien se puede evitar el uso del tag, ingresando el texto escapado (por ejemplo, en lugar de '>' escribir '&gt' ) el objetivo es que el XML no deje de ser legible, encontré otras recetas en StackOverflow:
http://stackoverflow.com/questions/174890/how-to-output-cdata-using-elementtree

Pero finalmente, decidí escribir mi propia versión basada en algunos de los comentarios (la receta con mas votos no funciona en python 2.7+)

Up things

2011-09-30T16:09:00.000-03:00

Después de la charla de Kragen Javier Sitaker en Pyconar 2011 me puse a trabajar en algunas obras de arte electrónico.

Así nació Up things (no pregunten el porque del nombre ), un repositorio en github donde voy poniendo las cosas que se me ocurren.

El primer proyecto es el lanzador de partículas. Les dejo unos screenshots:

Puertos Serie Virtuales en Gnu/Linux

2010-10-03T20:12:00.000-03:00

Hoy estaba preparando mi charla para la PyCon2010 y me vi con la necesidad de crear puertos serie virtuales, para unos ejemplos que quiero dar...

La solución fue utilizar socat:

"Socat is a command line based utility that establishes two bidirectional byte streams and transfers data between them. Because the streams can be constructed from
a large set of different types of data sinks and sources (see address types), and because lots of address options may be applied to the streams, socat can be used
for many different purposes."

La linea en cuestión:

joac@pepino ~ $ socat PTY,link=vserial1 PTY,link=vserial2

Despues, desde pyserial, por ejemplo nos conectamos con:

import serial

ser = serial.Serial("/home/joac/vserial1")

Grupos vs Individuos

2010-09-23T08:45:00.000-03:00

Ahora que empezó la primavera, y el sol pega directo en la ventana de mi pieza, ayudándome notablemente a despertar, voy a tratar de resucitar mi blog.

Grupos vs Individuos

Me gusta programar, me gustan los desafíos, y me gusta aprender cosas nuevas. Tengo una especie de lema que dice "Si lo hizo un ser humano entonces puedo entender como esta echo", quizás demasiado abarcativo (notar que dije puedo entender). Esto es un arma de doble filo, por un lado, porque aprendo cosas nuevas, pero por el otro, desvaloriza los conocimientos de los demás.

Desde que trabajo en gcoop (ver posts anteriores) no trabajo mas solo, trabajo con un grupo. Este es un fuerte cambio en el paradigma que traigo desde (el autor no logra recordar, quizás se remonte a estados fetales pre-parto), y me hizo reflexionar bastante sobre esta forma de encarar los problemas.

Cuando uno trabaja solo, la comunicación sobre las tareas es básicamente con uno mismo. Pero cuando uno trabaja en grupo, la comunicación es distinta (Pensaba hacer una analogía con una Red pero es muy de ñoño), la toma de decisiones tiene mas posturas, y es ahí donde esta la verdadera riqueza.

Creo, que no existen dos personas que piensen parecido, todos tenemos nuestras propias estructuras mentales, y reaccionamos de distintas formas, a veces muy sutiles, frente a los estímulos externos. Es común que se encuentren diferentes formas de resolver un mismo problema.

Pero no todo es color de rosa...

Creo que uno de los principales problemas mundiales, después de los realmente importantes (como que miles de niños muren de hambre día a día), es la falta de comunicación.

Y en los grupos pequeños también pasa.

Quizás la cuestión importante es que desarrollar software no es solamente uno con las manos sobre el teclado, sino, que requiere de comunicación en su mayor parte.

(Este post va a ser editado, es un boceto)

Jueguito v2

2010-07-17T13:01:00.003-03:00

Ayer empecé el proyecto de un minijuego, clón de uno de blackberry.
Me di cuenta que sin colores era injugable, así que me puse a investigar como agregar colores a los prints de python, y me encontré con [1] en Stack Overflow, que explica como hacerlo.

Es muy fácil, con la salvedad que yo aproveche y cambié el color de fondo, en lugar del color del texto.

Ahora es mas cómodo de jugar.

La ultima versión (Provisoria) la encuentran en [2]

[1] http://stackoverflow.com/questions/287871/print-in-terminal-with-colors-using-python

[2] http://github.com/joac/joac-python/blob/master/minigame/minigame.py

Dejo unas capturas que hice:

El inicio del juego

Un par de jugadas despues

Ganamos!

Si no alcanzan los movimientos... Nos espera la derrota

Jueguito

2010-07-16T22:12:00.002-03:00

El otro día, me prestaron un blackberry que tenia un jueguito que me gusto, asi que hice una versión, para la consola, del juego, he aquí el código:

import random
import os

class Square:
    """This is the abstraction of one Square"""
    def __init__(self, x, y, attrib, root):
        self.x = x
        self.y = y
        self.attrib = attrib
        self.root = root
        self.rep = attrib

class Screen:
    """The Screen Array of the game"""
    def __init__(self, x_size, y_size, tokens):
        self.x_size = x_size
        self.y_size = y_size
        self.tokens = tokens
        self.childs = []
        self.squares = []
        self.populate()
        self.childs.append(self.squares[0][0])
        self.childs[0].rep = '#'

    def get_near_to(self, child):
        vecinos = []
        if child.x - 1 >= 0:
            vecinos.append(self.get_square(child.x - 1, child.y))
        if child.y - 1 >= 0:
            vecinos.append(self.get_square(child.x, child.y - 1))
        if child.x + 1 < self.x_size:
            vecinos.append(self.get_square(child.x +1, child.y))
        if child.y + 1 < self.y_size:
            vecinos.append(self.get_square(child.x, child.y + 1))
        
        return [vecino for vecino in vecinos if(not vecino in self.childs)]


    def get_square(self, x, y):
        return self.squares[y][x]

    def populate(self):
        for y in xrange(0, self.y_size):
            self.squares.append([self.random_square(x, y) for x in xrange(0, self.x_size)])

    def random_square(self, x, y):
        
        attrib = random.choice(self.tokens)
        square = Square(x, y, attrib, self)
        
        return square
    
    def check_arround(self, child):
        """We check the attrib of the near squares"""
        vecinos = self.get_near_to(child)
        if vecinos:
            for vecino in vecinos:
                if (vecino.attrib == child.attrib):
                    vecino.rep = '#'
                    self.childs.append(vecino)

    def __repr__(self):
        output = ''
        for row in self.squares:
            output += ''.join(['%s ' % str(a.rep) for a in row])
            output += '\n'
        return output
    
    def update(self, attrib):
        for child in self.childs:
            child.attrib = attrib[0]
            self.check_arround(child)
            

if __name__ == '__main__':
    screen = Screen(10, 10, ['1', '2', '3', '4', '5'])
    print screen
    screen.update(screen.childs[0].attrib) #dirty Hack
    limit = 18 
    win = False
    for b in xrange(1, limit):
        a = raw_input('_ ')
        screen.update(a)
        os.system('clear')
        print screen
        print "%4d moves of %4d" % (b, limit)
        if len(screen.childs) == screen.x_size*screen.y_size:
            win = True
            break
    if win:
        print "You Win"
    else:
        print "You loose"

Mandando el contenido de un directorio como archivos adjuntos

2009-12-01T17:03:00.007-03:00

Hoy necesitaba mandar un archivo dividido en 18 partes de 400kB, debido a las limitaciones del proveedor de correo de un colega cubano. La opción de hacerlo a mano es realmente engorrosa, asi que con la ayuda de la documentación de python me mande este script:

import smtplib
import os
from email.mime.text import MIMEText
from email.mime.base import MIMEBase
from email.mime.multipart import MIMEMultipart
from email import encoders
import getpass
directorio = 'Directorio de donde Sacamos los Archivos'
asunto = 'Aca va el asunto'
destinatarios = ['complete aqui con sus destinatarios',]
sender = 'Aca va Nuestra Direccion'
contenido = 'Texto que queremos que se lea en los mensajes'
host = 'servidor SMTP que vamos a usar'
login = 'nuestro usuario'
#creamos el contenedor
listademails = []
numeroParte = 1
listadoArchivos = os.listdir(directorio)
listadoArchivos.sort()
for archivo in listadoArchivos:
    path = os.path.join(directorio, archivo)
    msg = MIMEMultipart()
    msg['Subject'] = asunto + ' %d de %d' % (numeroParte, len(listadoArchivos)))
    numeroParte += 1
    msg['From']= sender
    msg['To']=', '.join(destinatarios)
    #msg.preamble = ''
    texto = MIMEText(contenido, 'plain')
    msg.attach(texto)
    #Adjuntamos el Archivo
    fp = open(path, 'rb')
    adjunto = MIMEBase('application', 'octet-stream')
    adjunto.set_payload(fp.read())
    fp.close()
    encoders.encode_base64(adjunto)
    adjunto.add_header('Content-Disposition', 'attachment', filename = archivo)
    msg.attach(adjunto)
    listademails.append(msg.as_string())

server = smtplib.SMTP(host)
server.login(login, getpass.getpass())
for mail in listademails:
    server.sendmail(sender, destinatarios, mail)
server.quit()

Dejo en el lector las criticas pertinentes a esta 'Belleza'(ironicmode =True) que sorprende por su extrema pythonicidad :P