xlwt es una librería de python creada por John Machin, que permite generar hojas de cálculo flexibles. compatibles con Office, OpenOffice, Calc, Gnumeric y con total soporte para Unicode, y a la vez permite personalizar los archivos generados. En este articulo enumeraremos algunas de las herramientas que nos brinda xlwt e iremos paso a paso, detallando el código para obtener un informe final con  nuestras preferencias de personalización.

1. GENERANDO LIBRO

La clase WorkBook() nos permite asignar a una variable las características de un archivo xls. Todo libro o archivo xls debe contar con al menos una hoja de cálculo. Las hojas de cálculo se crean por medio del método  add_sheet(‘nombre_de_la_hoja’). A continuación, se describe el código básico para generar un libro de trabajo llamado first_book.xls, con dos hojas de calculo vacías(first_sheet y second_sheet).

from xlwt import Workbook
 
def first_book():
    # Workbook asing
    first_book=Workbook()
 
    # Sheets definition
    first_book.add_sheet('first_sheet')
    first_book.add_sheet('second_sheet')
 
    # Saving file
    first_book.save('first_book.xls')

Para manipular las distintas hojas de cálculo y así definir los contenidos deseados para cada una de ellas, asignamos variables a estas, de la siguiente forma:

from xlwt import Workbook
 
def first_book():
    # Workbook asing
    first_book=Workbook()
 
    # Sheets definition
    ws1 = first_book.add_sheet('first_sheet')
    ws2 = first_book.add_sheet('second_sheet')
 
    # Saving file
    first_book.save('first_book.xls')

2. IMPRIMIENDO DATOS

Las hojas de cálculo cuentan con el método write, que nos permite introducir contenido en las celdas. Los parámetros que recibe son la posición (celda) y contenido. La posición se introduce de la forma (fila, columna), empezando por la posición (0, 0), equivalente en nuestra hoja a la celda A1.

En la siguiente modificación a nuestra función, se introduce, en la hoja de trabajo first_sheet, en la posición A1, el texto “Content 1, sheet 1″, y en la posición B1, el texto “Content 2, sheet 1″. De la misma forma, en la hoja de cálculo second_sheet, se introduce, en la posición A2, el texto “Content 1, sheet 2“, y en la posición B2, el texto ”Content 2, sheet 2″.

from xlwt import Workbook
 
def first_book():
    # Workbook asing
    first_book=Workbook()
 
    # Sheets definition
    ws1 = first_book.add_sheet('first_sheet')
    ws2 = first_book.add_sheet('second_sheet')
 
    # content per sheets
    ws1.write(0, 0, 'Content 1, sheet 1')
    ws1.write(0, 1, 'Content 2, sheet 1')
    ws2.write(1, 0, 'Content 1, sheet 2')
    ws2.write(1, 1, 'Content 2, sheet 2')
 
    # Saving file
    first_book.save('first_book.xls')

Pero introducir uno a uno el contenido de cada una de las celdas resultaría ser el proceso mas ineficiente posible a la hora de generar un informe xls. Por tal razón, utilizaremos los bucles de python para imprimir estos contenidos de forma automática.
Ahora generaremos una sola hoja de cálculo, en la cual imprimiremos una tabla que relaciona nombre y edad de una sería de personas que se han definido previamente en un diccionario llamado ages.

from xlwt import Workbook
 
ages={
        'Peter': 20,
        'Karen': 19,
        'Jessie': 43,
        'Leonard': 56,
        'Robert': 30,
        'Nina': 23,
    }
 
number_of_elements = len(ages)
 
def first_book():
    first_book=Workbook()
 
    # Sheet definition
    ws1 = first_book.add_sheet('first_sheet')
 
    # Header definition
    ws1.write(0, 0, 'Name')
    ws1.write(0, 1, 'Years old')
 
    # Represents the first row in the iteration
    i = 1 
 
    for name, years in ages.items():
        ws1.write(i, 0, name)
        ws1.write(i, 1, years)
        i += 1
        if i == number_of_elements+1: # For display the latest element
            break
 
    # Saving file
    first_book.save('first_book.xls')

Primero definimos el header de la tabla. Asignamos como contenido a la celda A1 (posición 0, 0) el texto “Name”, y a la celda B1 (posición 0, 1) el texto “Years old”. A continuación definimos la variable i, que representa el número de la fila desde la cual vamos a empezar a imprimir la información de las personas de nuestro diccionario. En este caso, como la fila 1 se encuentra ocupada con el header de la tabla, debemos empezar a introducir los datos desde la fila 2, es decir, desde la posición (1, #-columna).

Con un bucle for en el que iteramos el diccionario ages, introducimos de forma ordenada los datos de las personas en nuestra tabla. Por cada ciclo aumentamos el valor de i en 1, y de esta forma imprimimos los datos de cada persona del diccionario en una fila distinta.
Previamente habíamos definido la variable number_of_elements, asignándole como valor el número equivalente a la cantidad de elementos del diccionario ages. Esta variable es de gran importancia en este ejemplo, ya que es la clave para salir del bucle y evitar errores de sobre-escritura en las celdas de nuestro archivo first_book.xls.

Rompemos el bucle cuando la variable i sea igual a number_of_elements + 1.¿Porque?… La cantidad de elementos en nuestro diccionario es 6 y el valor inicial de la variable i es 1. Por lo tanto, si rompemos el bucle cuando la variable i sea igual a 6, solo estaríamos repitiendo el ciclo 5 veces, es decir, perderíamos el último elemento de nuestro diccionario.

3. PERSONALIZANDO LA PRESENTACIÓN

haciendo uso de las clases Font, XFStyle y Borders, podemos añadir preferencias de visualización para nuestras celdas y sus contenidos. A continuación se muestra como personalizar nuestra hoja de cálculo mediante el uso de solo unas pocas de las muchas opciones que brinda xlwt.

from xlwt import Workbook
from xlwt import Font
from xlwt import XFStyle
from xlwt import Borders
 
ages={
        'Peter': 20,
        'Karen': 19,
        'Jessie': 43,
        'Leonard': 56,
        'Robert': 30,
        'Nina': 23,
    }
 
number_of_elements = len(ages)
 
def first_book():
    first_book=Workbook()
 
    # Sheet definition
    ws1 = first_book.add_sheet('first_sheet')
 
    header_font = Font()
    body_font = Font()
 
    # Header font preferences
    header_font.name = 'Times New Roman'
    header_font.height = 20 * 15
    header_font.bold = True
 
    # Body font preferences
    body_font.name = 'Arial'
    body_font.italic = True
 
    # Header Cells style definition
    header_style = XFStyle()
    header_style.font = header_font 
 
    borders = Borders()
    borders.left = 1
    borders.right = 1
    borders.top = 1
    borders.bottom = 1
    header_style.borders = borders
 
    # body cell name style definition
    body_style = XFStyle()
    body_style.font = body_font 
 
    # Header definition
    ws1.write(0, 0, 'Name', header_style )
    ws1.write(0, 1, 'Years old', header_style )
 
    # Represents the first row in the iteration
    i = 1 
 
    for name, years in ages.items():
        ws1.write(i, 0, name, body_style)
        ws1.write(i, 1, years)
        i += 1
        if i == number_of_elements+1: # For display the latest element
            break
 
    # Saving file
    first_book.save('first_book.xls')

El parámetro height que representa el tamaño de la fuente, se debe incluir multiplicado por un factor de 20. Es decir, si el tamaño de fuente deseado es 15, entonces se debe incluir el valor 300, o si el tamaño deseado es 20, entonces se debe introducir el valor 400.

Una vez definidas nuestras preferencias de personalización, el resultado se envía como el tercer parámetro en el constructor de la celda. Así, en este caso, para las celdas del header enviamos el parámetro header_style, y para las celdas que contienen los nombres de nuestro diccionario enviamos el parámetro body_style

4. COMBINANDO CELDAS

Otra funcionalidad muy común a la hora de trabajar con hojas de cálculo, es la posibilidad de combinar celdas. xlwt permite hacer esto de una forma muy simple. A continuación, insertaremos una imagen en el encabezado de la tabla. Para hacer esto, combinaremos una serie de celdas. La forma de hacerlo es sheet_name.write_merge(fila_inicial, fila_final, columna_inicial, columna_final,). Así, se combinarán las celdas comprendidas en el rango indicado. En este caso, combinaremos las celdas comprendidas entre la posición A1 a la B11.  El rango de celdas combinadas y el ancho de las columnas los ajustamos según el tamañ de la imagén a insertar (Este ejemplo esta ajustado para una imagen de 273×180 px ). Este cambio implica mover nuestros datos tantas filas hacia abajo como filas se combinaron para el encabezado. Así, las celdas del header, (Name y years old), se deben ubicar en la fila 12. Nuestra función first_book quedará de la siguiente manera:

def first_book():
    first_book=Workbook()
 
    # Sheet definition
    ws1 = first_book.add_sheet('first_sheet')
 
    header_font = Font()
    body_font = Font()
 
    # Header font preferences
    header_font.name = 'Times New Roman'
    header_font.height = 20 * 15
    header_font.bold = True
 
    # Body font preferences
    body_font.name = 'Arial'
    body_font.italic = True
 
    # Header Cells style definition
    header_style = XFStyle()
    header_style.font = header_font 
 
    borders = Borders()
    borders.left = 1
    borders.right = 1
    borders.top = 1
    borders.bottom = 1
    header_style.borders = borders
 
    # body cell name style definition
    body_style = XFStyle()
    body_style.font = body_font 
 
    # Header definition
    ws1.write_merge(0, 10, 0, 1,)
 
    # # Adjust columns width acording to the image size
 
    ws1.col(0).width = 8 * 625
    ws1.col(1).width = 8 * 625
 
    # Insert image
    ws1.insert_bitmap('logo.bmp', 0, 0)
 
    ws1.write(11, 0, 'Name', header_style )
    ws1.write(11, 1, 'Years old', header_style )
 
    # Represents the first row in the iteration
    i = 12
 
    for name, years in ages.items():
        ws1.write(i, 0, name, body_style)
        ws1.write(i, 1, years)
        i += 1
        if i == number_of_elements+12: # For display the latest element
            break
 
    # Saving file
    first_book.save('first_book.xls')

5. INSERTANDO FORMULAS

Ahora, introduciremos el código para implementar una formula que calcule la suma total de las edades de las personas en nuestra tabla. Debemos exportar la clase “Formula” y definir las celdas que se van a operar.

En este caso, se muestra el código para explicar el funcionamiento de las formulas en xlwt, aunque en realidad sería mas sencillo hacer el cálculo en nuestro código y enviar el resultado como parámetro de contenido a una celda determinada. Se deben introducir las celdas a operar por su posición en el formato como se identifican las celdas en los archivos xls (ej:A1, B1).
El código quedaría como sigue:

from xlwt import Workbook
from xlwt import Font
from xlwt import XFStyle
from xlwt import Borders
from xlwt impor Formula
 
ages={
        'Peter': 20,
        'Karen': 19,
        'Jessie': 43,
        'Leonard': 56,
        'Robert': 30,
        'Nina': 23,
    }
 
number_of_elements = len(ages)
 
def first_book():
    first_book=Workbook()
 
    # Sheet definition
    ws1 = first_book.add_sheet('first_sheet')
 
    header_font = Font()
    body_font = Font()
 
    # Header font preferences
    header_font.name = 'Times New Roman'
    header_font.height = 20 * 15
    header_font.bold = True
 
    # Body font preferences
    body_font.name = 'Arial'
    body_font.italic = True
 
    # Header Cells style definition
    header_style = XFStyle()
    header_style.font = header_font 
 
    borders = Borders()
    borders.left = 1
    borders.right = 1
    borders.top = 1
    borders.bottom = 1
    header_style.borders = borders
 
    # body cell name style definition
    body_style = XFStyle()
    body_style.font = body_font 
 
    # Header definition
    ws1.write_merge(0, 10, 0, 1,)
 
    # # Adjust columns width acording to the image size
 
    ws1.col(0).width = 8 * 625
    ws1.col(1).width = 8 * 625
 
    # Insert image
    ws1.insert_bitmap('logo.bmp', 0, 0)
 
    ws1.write(11, 0, 'Name', header_style )
    ws1.write(11, 1, 'Years old', header_style )
 
    # Represents the first row in the iteration
    i = 12
 
    for name, years in ages.items():
        ws1.write(i, 0, name, body_style)
        ws1.write(i, 1, years)
        i += 1
        if i == number_of_elements+12: # For display the latest element
            break
 
    # Total cell style
    total_font = Font()
    total_font.bold = True
    total_style = XFStyle()
    total_style.font = total_font 
 
    ws1.write(i, 0, 'Total', total_style)
 
    # Formula
    ws1.write(i, 1, Formula("SUM(B13:B18)"))
 
    # Saving file
    first_book.save('first_book.xls')

PIL al ser compilado intenta obtener las librerías necesarias desde el sistema y para eso es necesario instalarlas, en el caso de OSX lion solo hace falta la libreria para los archivos jpeg, las demás ya vienen pre-instaladas.

Haciendo uso de homebrew:

1

brew install jpeg

Tendremos la libreria faltante, así cuando instalemos PIL tendremos pleno soporte:

1
2
3
4
5

pip install pil
...
    --- TKINTER support available
    --- JPEG support available
    --- ZLIB (PNG/ZIP) support available

Espero les sea de ayuda.

Pues bien, como lo mencioné anteriormente esta situación está directamente relacionada con el sistema de archivos, dado que las operaciones que nos interesan capturar se realizan sobre los archivos mismos (creación. modificación, cambio de atributos, etc). Desde la versión 2.6.13 del kernel Linux se integró una característica muy interesante llamada inotify el cual es un sistema que notifica cambios en los archivos (una descripción más detallada de la implementación y uso (desde C) se encuentra en un artículo muy interesante de los autores en Linux Journal). Con inotify tenemos un sistema que permite capturar eventos sobre los archivos y directorios como: acceso, modificación, modificación y cierre, borrado, renombrado entre otros. Al ser un componente del kernel Linux su extensión se realiza a través de C (incluyendo la cabeceras inotify.h y inotify-syscalls.h) y compilando …. cóooomo compilar ? dirán algunos para los que desarrollar en C como compilar es una labor un tanto tediosa y de hecho lo es. Afortunadamente existe un wrapper desarrollado en python que nos facilita mucho la vida se llama: pyinotify (un nombre muy original). Con este wrapper es posible en pocas líneas de código monitorear un directorio de archivos de forma muy sencilla, escribiendo a un log todos los eventos que ocurren o notificando a una aplicación.

¿ Cómo usar pyinotify ?

Primero que todo se deben seguir las instrucciones de instalación que se pueden encontrar en la página del proyecto o en github.   Una vez se haya instalado correctamente el módulo podemos empezar a realizar pequeños ensayos para conocer un poco más. Aquí va un pequeño ejemplo (basado en los de la página de pyinotify):

# -*- coding: utf-8 -*-
# Archivo example1.py
import pyinotify
 
class EventHandler(pyinotify.ProcessEvent):
 
    def process_IN_CREATE(self, event):
    	print "Creacion del archivo :", event.pathname
 
wm = pyinotify.WatchManager()
mask = pyinotify.IN_CREATE
 
handler = EventHandler()
notifier = pyinotify.Notifier(wm, handler)
wdd = wm.add_watch('/tmp', mask, rec=True)
notifier.loop()

Si ejecutamos este script desde la terminal de comandos:

$ python example1.py

Cada vez que se agregue un nuevo archivo al directorio /tmp se imprimirá la cadena “Creación del archivo …” junto con la ruta absoluta del archivo creado. De esa misma forma se pueden escuchar otro tipo de eventos (ver listado completo) y ejecutar la acción requerida (escribir a un log, enviar una notificación, un llamado a sistema, etc). En el wiki del proyecto en github hay numerosos ejemplos de como utilizar pyinotify, desde cuestiones sencillas hasta como construir un pequeño servicio de notificación. En AxiaCore hemos usado pyinotify en conjunto con rsync para la sincronización de archivos y monitoreo y registro de acciones sobre sistemas de archivos (usando el módulo logging) con buenos resultados y facilidad de implementación.

Es importante mencionar que el monitoreo solamente esta disponible para sistemas de archivos nativos en Linux como la familia ext2-3-4. Los sistemas de archivos como ntfs o vfat (fat32) no se encuentran soportados.

Bien, hasta aquí con esta corta introducción al uso de pyinotify. Espero que haya sido de utilidad.

La manera en que lo hice funcionar fue con el siguiente script hecho en casa:

1
2
3
4
5

#!/bin/bash
 
export PYTHONPATH=$PYTHONPATH:${PWD%/*/*}:${PWD%/*}
export DJANGO_SETTINGS_MODULE=miproyecto.settings
make html SPHINXBUILD='../../bin/sphinx-build'

Para mi configuración, yo tengo una carpeta doc en la raíz del proyecto donde reside mis archivos de sphinx, allí debe haber un archivo Makefile, allí debes crear el script y al correrlo, el utilizará el sphinx de virtualenv y habilitará las variables necesarias para obtener la documentación del código fuente.

Espero les sea de ayuda.

Gracias a la excelente documentación podemos encontrar toda la información aquí: http://docs.djangoproject.com/en/1.1/topics/pagination/#topics-pagination

Sin embargo, cuando se trabajan volúmenes grandes de información, digamos mas de 50 paginas, se hace dispendioso pasar entre paginas hasta llegar a la que buscamos, por eso es muy útil tener una paginación al estilo Digg que muestra algunas paginas adicionales y no solo el enlace a la anterior y la siguiente.

Tomando como base este excelente trabajo: http://krisje8.com/blog/2009/jul/02/django-pagination-template-tag-digg-style/ realice algunas modificaciones para que muestre ‘…’ entre las paginas iniciales y la pagina actual, para darle una mejor ubicación al usuario sobre donde se encuentra.

Tenemos el siguiente template_tag:

#! /usr/bin/env python
# -*- coding: utf8 -*-
# render_paginator.py
from django.template import Library
 
register = Library()
 
def render_paginator(context, first_last_amount=2, before_after_amount=4):
    page_obj = context['page_obj']
    paginator = context['paginator']
    page_numbers = []
 
    # Pages before current page
    if page_obj.number > first_last_amount + before_after_amount:
        for i in range(1, first_last_amount + 1):
            page_numbers.append(i)
 
        page_numbers.append(None)
 
        for i in range(page_obj.number - before_after_amount, page_obj.number):
            page_numbers.append(i)
 
    else:
        for i in range(1, page_obj.number):
            page_numbers.append(i)
 
    # Current page and pages after current page
    if page_obj.number + first_last_amount + before_after_amount < paginator.num_pages:
        for i in range(page_obj.number, page_obj.number + before_after_amount + 1):
            page_numbers.append(i)
 
        page_numbers.append(None)
 
        for i in range(paginator.num_pages - first_last_amount + 1, paginator.num_pages + 1):
            page_numbers.append(i)
 
    else:
        for i in range(page_obj.number, paginator.num_pages + 1):
            page_numbers.append(i)
 
    return {
        'paginator': paginator,
        'page_obj': page_obj,
        'page_numbers': page_numbers
    }
 
register.inclusion_tag('layout/pagination.html', takes_context=True)(render_paginator)

Con la siguiente plantilla:

{% if page_obj.has_previous %}
  <a href="?page={{ page_obj.previous_page_number }}">Previous</a>
{% endif %}
{% for page in page_numbers %}
  {% if page %}
    {% ifequal page page_obj.number %}
      <strong>{{ page }}</strong>
    {% else %}
      <a href="?page={{ page }}">{{ page }}</a>
    {% endifequal %}
  {% else %}
    ...
  {% endif %}
{% endfor %}
{% if page_obj.has_next %}
  <a href="?page={{ page_obj.next_page_number }}">Next</a>
{% endif %}

Para usarlo se coloca el siguiente codigo en cualquiera de las plantillas que queramos paginar:

    {% if is_paginated %}
      {% load render_paginator %}
      {% render_paginator 2 3 %}
    {% endif %}

Lo que genera un código como:

Previous  1  2  ... 5  6  7  8  9  10  11  ... 25  26  Next

Lo mejor de todo es que no necesita ningún componente adicional ni interfiere con la paginación por defecto que traen las vistas genéricas en django.

Desde luego, todo esto es gracias a la interfaz en línea de comandos del ínterprete php (más conocido como php-cli), que en algunos casos se queda corto para ejecutar algunas pruebas: ver el estado de un objeto, insertar datos en la base de datos,  probar métodos de manera interactiva, etc,. Sé que algunos dirán que php-cli tiene un modo interactivo, pero en realidad desde mi punto de vista es muy limitado.  Sería muy interesante contar con algo similar a la terminal interactiva de python y desde luego que se pueda trabajar con nuestros proyectos en Symfony.

Lo mejor de todo, es que la gente de facebook liberó bajo licencia BSD una shell interactiva para php y como sus mismos credadores dicen: “… irónicamente escrita en python ….”; se llama phpsh y realmente es un gran trabajo. He realizado algunas pruebas de integración con Symfony y creo que puede ser de gran apoyo para pruebas y aún más para las personas que están aprendiendo a trabajar con el framework.

A continuación van algunos de los sencillos experimentos realizados:

Una vez se haya instalado phpsh (leer el README), podemos trabajar  con sentencias de php y usar las funciones:

test$ phpsh
Starting php
type 'h' or 'help' to see instructions & features
php> echo "Hola mundo"
Hola mundo
php> $a = 2+3; echo $a
5

php> $f = array('uno' => 1, 'dos' => 2, 'tres' => 3);
php> foreach ($f as $n) { echo $n; }
123
php> foreach ($f as $n) { echo $n."\n"; }
1
2
3

php> foreach ($f as $n) {
... echo $n."\n";
... }
1
2
3
php> echo count($f);
3

Bien, pero ahora viene algo un poco más interesante: usar a través del shell interactivo nuestra aplicación hecha en Symfony.

No requiere ninguna configuración especial, simplemente cargar un archivo y listo; se trata del controlador frontal de nuestra aplicación (alguno de los que se encuentra en web), así:

test$ phpsh web/index.php
Starting php with extra includes: ['web/index.php']
 
  .......................
 
php>

Para obviar la salida html, podemos crear una copia de ese archivo y evitar la llamada al método dispatch(), así:

require_once(dirname(__FILE__).'/config/ProjectConfiguration.class.php');
 
$configuration = ProjectConfiguration::getApplicationConfiguration('frontend','prod', false);
sfContext::createInstance($configuration);

Ahora, de nuevo lo cargamos (ese archivo lo he llamado shell.php):

test$ phpsh shell.php
Starting php with extra includes: ['shell.php']
type 'h' or 'help' to see instructions & features
php> $c = CiudadPeer::doSelect(new Criteria);
 
php> foreach ($c as $ciudad) {
 ... echo $ciudad."\n";
 ... }
Barranquilla
Bogota
Constantinopla
Medellin
 
php>

Como se puede ver, puedo acceder a las clases de mi modelo (disculpas a los usuarios de Doctrine) y desde luego a las clases que nos proporciona Symfony, por ejemplo si mi archivo apps/frontend/config/app.yml es:

all:
 resultados_por_pagina: 15
 sf_phpmailer:
   mailer:                    true
   smtp_auth:                 true
   smtp_secure:               "ssl"
   host:                      "smtp.mihost"
   port:                      600
   username:                  "miusuario"
   password:                  "miclave"
   from:                      "nosesabe@example.com"
   from_name:                 "Anonimo"

test$ phpsh shell.php
Starting php with extra includes: ['shell.php']
type 'h' or 'help' to see instructions & features
php> $conf = sfConfig::get('app_sf_phpmailer_port');
 
php> echo $conf;
600
php> echo sfConfig::get('app_resultados_por_pagina');
15
php>

Bueno, esos han sido los experimentos que he alcanzado a realizar. Espero trabajar más en detalle y publicar los resultados. Hasta una próxima.

La aproximación inicial es tener un parámetro donde se indique un numero de versión de la aplicación, pero esta fue rápidamente descartada porque no es flexible y se tendría que cambiar la versión manualmente en cada nuevo cambio, así que decidimos manejar el numero de revisión del repositorio como el indicador de la versión. Ahora bien, se necesita una manera automática de obtener dicho numero y publicarlo en una plantilla HTML para verlo en la interfaz de usuario.

Lo resolvimos así:

Partimos de la plantilla donde básicamente django nos permite lo siguiente:

{% load version_tag %}
 
Version: {% get_version %}

Entonces cargamos un ‘custom tag’ que nos retorna la versión actual de la aplicación, el cual es:

#! /usr/bin/env python
# -*- coding: utf8 -*-
import subprocess
from django import template
from django.core.cache import cache
 
register = template.Library()
 
@register.simple_tag
def get_version():
    """
    Retorna el numero de version para la aplicacion y lo almacena en
    cache para evitar ser llamado multiples veces y mejorar el rendimiento
    de la aplicacion.
    """
    if not cache.get('version'):
        comando = 'svn info | grep Rev | head -1'
        try:
            proc = subprocess.Popen(comando, shell=True,
                stdout=subprocess.PIPE, stderr=subprocess.PIPE
            )
            line = proc.communicate()[0]
            version = line[line.find(" ")+1:].rstrip("\n")
        except:
            version = '---'
 
        tiempo = 24 * 60 * 60   #Tiempo en segundos de un dia
        cache.set('version', version, tiempo)
 
    return cache.get('version')

Este archivo (version_tag.py) debe estar dentro de una carpeta llamada ‘templatetags’ de alguna aplicación del proyecto.

Lo interesante de esta solución es:

1. Obtiene el numero de versión por el comando ‘svn info’
2. Reduce las llamadas al comando ubicando la información en cache durante un día
3. Es totalmente desacoplado del proyecto y se puede reutilizar fácilmente
4. Se puede adaptar para otros sistemas de control de versiones

Que les parece?

1
2
3
4

class MyModelForm(forms.Form):
    def __init__(self, *args, **kwargs):
        super(MyModelForm, self).__init__(*args, **kwargs)
        self.fields["myFKField"].queryset = MyModel.objects.all()

Esto permite cambiar los datos que son mostrados por el campo en el Form por unos filtrados que nosotros queramos, existe tambien la posibilidad de trabajar con limit_choices_to de ForeignKey pero esta solución me funciono de inmediato.

1
2
3
4
5

from datetime import date, timedelta
#Agregar
d=date.today()+timedelta(days=dias)
#Sustraer
d=date.today()-timedelta(days=dias)

La operación respeta los días al cambiar de mes y funciona perfecto.

Hoy en dia los frameworks son mas agiles y permiten una produccion mucho mayor de funcionalidad con menos codigo fuente, esta tendencia provoca que los desarrollos tomen mucho menos tiempo y recursos, lo que implica a su vez que los costos sean menores y que esta industria cada vez sea mas agil.

Yo sigo sorprendido con django, es muy poco el codigo que se debe escribir, basicamente la tarea es de arquitectura y no de codificación, por ahora estoy desarrollando una aplicacion muy sencilla y me ha tomado una tercera parte de lo que me hubiera costado realizarlo en java, creo que he acertado en la tendencia de lenguajes de programacion y esta vez python sigue ganando la batalla.