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')

We write lots of code in Python because it’s beautifully succinct. It lets us get things done, minimizing the time it takes to craft our ideas into reality.

We also write lots of code in Objective-C because of the beautiful user interfaces we can create with it. We want to make software that literally responds to your every touch.

Unlike a great painting, truly great software can not be made alone.

…

seen on the web

Ahora bien, sucede se tiene un fondo como el de la imagen anterior, la línea básica de estilo es:

 
body {
    background-image: url(bg_body.png);
}

.. y este es el resultado :

Bueno en realidad no es lo que se espera, y si…

 
body {
    background-image: url(bg_body.png);
    background-repeat: no-repeat;
    background-position: left top;
}

Parece que ese resultado tampoco es el requerido y seguro no va a descrestar al usuario, entonces se debe comenzar a pensar en soluciones como: hacer el fondo más grande o ajustes en algún programa de edición de imágenes, pero eso no siempre es muy conveniente, hay que tener varias cosas en cuenta como: el peso del archivo o la pixelación en caso de que sea un archivo demasiado pequeño.

La solución Bienvenido css3

Los nuevos atributos de css en su tercera versión y el diseño de sitios web sensibles traen la solución casi definitiva a este problema.

Bien a hacer lo básico:

 
body {
    background-image: url(bg_body.png);
    background-repeat: no-repeat;
    -moz-background-size: cover;
    -webkit-background-size: cover;
    background-size: cover;
}

El resultado :

El peso de la imagen es el mismo al igual que su tamaño en pixeles, pero ahora esta cubriendo el área total del body.
El background-size cover es una propiedad css3 que se ajusta al tamaño del contenedor sin necesidad de un alto o ancho especificado, para cualquier resolución de pantalla.
Listo ahora el fondo se auto ajusta a nuestras pantallas problemas resuelto . o no?

Bueno sucede que surge otro reto, dispositivos móviles,

Tomemos como referencia el iPad, el cual sirve como punto de partida para comenzar un proyecto que soporte responsive design. Las propiedades que se utilizan anteriormente solucionan muy bien los problemas que se generan en una pantalla de PC o un portátil sin tener que modificar las imágenes, pero ese tipo de pantallas no responden a la variación de ángulo (modos landscape o portrait). La imagen anterior muestra, haciendo uso de las propiedades mencionadas anteriormente, cómo responde un dispositivo como iPad, comportamiento muy similar en otros
dispositivos. Solución css3 y diseño sensible junto a la propiedad media query:

Hagamos el avanzado:

 
@media only screen
and (min-device-width : 768px)
and (max-device-width : 1024px) {
    body {
	background-image: url(bg_body.png);
	-moz-background-size: auto;
	-webkit-background-size: auto;
	background-size: auto;
    }
}

El media query reconoce el tamaño del dispositivo en el cual se renderiza el sitio y toma los tamaños definidos en el css para mostrar los atributos únicamente donde el tamaño o la posición se cumplan.

Este fue un tip ajustado para un fondo, pero las posibilidades de los media query permiten ajustar cualquier elemento del DOM, en un próximo post mostraremos otras posibilidades de esta poderosa herramienta.

Bueno para finalizar dejamos un listado de media query que hasta ahora se utilizan en cuanto a diseño sensible para los dispositivos más comunes:

/* Smartphones (portrait and landscape) ----------- */
@media only screen and (min-device-width : 320px) and (max-device-width : 480px) {
/* Styles */
}
 
/* Smartphones (landscape) ----------- */
@media only screen and (min-width : 321px) {
/* Styles */
}
 
/* Smartphones (portrait) ----------- */
@media only screen and (max-width : 320px) {
/* Styles */
}
 
/* iPads (portrait and landscape) ----------- */
@media only screen and (min-device-width : 768px) and (max-device-width : 1024px) {
/* Styles */
}
 
/* iPads (landscape) ----------- */
@media only screen and (min-device-width : 768px) and (max-device-width : 1024px) and (orientation : landscape) {
/* Styles */
}
 
/* iPads (portrait) ----------- */
@media only screen and (min-device-width : 768px) and (max-device-width : 1024px) and (orientation : portrait) {
/* Styles */
}
/* Ordenadores de escritorio y portatiles ----------- */
@media only screen and (min-width : 1224px) {
/* Styles */
}
/* Large screens ----------- */
@media only screen and (min-width : 1824px) {
/* Styles */
}
/* iPhone 4 and high pixel ratio devices ----------- */
@media
only screen and (-webkit-min-device-pixel-ratio : 1.5),
only screen and (min-device-pixel-ratio : 1.5) {
/* Styles */
}

Compatibilidad: IE9+ – Ffox 3+ – Chrome – Safari 2+

Enlaces relacionados:

• w3schools
• quirksmode
• css-tricks

Cuando tienes un sitio Django y no quieres torturar tu base de datos con búsquedas, pero quieres ofrecer a tus usuarios la posibilidad de tener una buena herramienta de búsqueda, puedes echarle un vistazo a haystack, esto es un motor de búsqueda configurable donde puedes tomar backends tales como xapian, solr y whoosh, entre otros. Si tienes buen hardware ve por solr, si no esperas muchas visitas, ve por whoosh, pero seguramente encontraras a xapian realmente bueno. Nosotros también preferimos xapian.

Espera, ya tienes una base de datos relacional, ahora estas añadiendo una base de datos documental, así en tu siguiente reunión geek podrías hablar fluidamente sobre esto; nota que tendrás una segunda base de datos especializada para búsquedas, así el proceso es más o menos así: añades o actualizas un registro en tu base de datos original, el sistema añade o actualiza un registro en la base de datos documental, el “índice” se actualiza y las búsquedas se efectúan solo en la base de datos documental dejando que tu base de datos relacional haga las cosas que tienen que ver con el la lógica del sitio sin sobrecargarla con solicitudes de las búsquedas de los usuarios.

Asumimos que estas trabajando con virtualenv, si no lo estas usando, ve por el primero , si estas usando Debian o Ubuntu, puedes seguir esa guía, en otros sabores o sistemas operativos debería funcionar, pero necesitarás trabajar en esto por ti mismo o actualizar a alguno de los sistemas operativos recomendados que usamos aquí. Asumimos que tienes python 2.7, si no, la técnica de copiar/pegar no funcionaría directamente.

Obteniendo las herramientas

En tu maquina instala xapian

apt-get install python-xapian

Asumiendo que tu virtualenv se llama tr, el siguiente script deberia funcionar ajustando tus variables acorde a tu instalación.

export MYENV=~/.virtualenvs/tr
export LOCALPYTHON=/usr/lib/python2.7
ln -s $LOCALPYTHON/dist-packages/xapian/__init__.py $MYENV/lib/python2.7/site-packages/xapian.py
ln -s $LOCALPYTHON/dist-packages/xapian/_xapian.so $MYENV/lib/python2.7/site-packages/
if [ ! -f $MYENV/lib/python2.7/site-packages/haystack/backends/xapian_backend.py ] 
then 
  ln -s $MYENV/lib/python2.7/site-packages/xapian_backend.py $MYENV/lib/python2.7/site-packages/haystack/backends/
fi

Interconectando Django con haystack

Añade a tu archivo requirements.txt las siguietes líneas. Si te preguntas que hace requierements.txt, échale un vistazo a virtualenv.

xapian-haystack==1.1.5beta
django-haystack==1.2.6
translitcodec==0.2

Como de costumbre, ejecutas

pip install -U requirements.txt

En tu setting.py añades ‘haystack’,

Y configuras las siguientes variables en tu settings.py , asegúrate de colocar tales variables ANTES de la configuración de las aplicaciones:

HAYSTACK_SITECONF = 'rt.search_sites'
HAYSTACK_SEARCH_ENGINE = 'xapian'
HAYSTACK_XAPIAN_PATH = '/var/lib/rtsearch/rtindex'

donde rt es tu proyecto, tienes un archivo search_sites.py en el interior,  más tarde comentaremos acerca de esto, y tienes el directorio /var/lib/rtsearch/rtindex con los permisos apropiados (www-data:www-data o todo lo que el usuario ejecuta en servidor web con el virtualenv).

Encender tu sitio django con haystack

Recuerdas que hablamos sobre la base de datos documental? en haystack hay un archivo search_indexes.py que es muy parecido a models.py, ahí especificamos como recogemos elementos de la base de datos relacional que se deben buscar, con este archivo haystack sabe qué debe comparar con lo que es buscado, en otras palabras, el índice se genera con este archivo, así, cuando alguien busque, la base documental se emplea y no tu base de datos relacional. En haystack hay un archivo donde queda la información que será usada para la búsqueda, es una plantilla, y puedes personalizar tu pagina de resultados y los aspectos usuales en los que estés interesado cuando ofrezcas una herramienta de búsqueda. Hay tres archivos importantes:  autodiscover, search_indexes.py, la plantilla y la configuraron de urls, y como un bono te mostraremos una aproximación que no tiene en cuenta los acentos.

Todavía estas leyendo? Iremos a el índice, esto esta en search_indexes.py, para motivarnos:

from haystack.indexes import RealTimeSearchIndex
from haystack.indexes import CharField

from haystack.indexes import RealTimeSearchIndex
from haystack.indexes import CharField
from haystack.indexes import MultiValueField
from haystack import site
from apps.informationgathering.models import RR


class RRIndex(RealTimeSearchIndex):
    """Index preparation, in production, when there is high write traffic
    we have to make sure we are using QueueSearchIndex and updating the index
    in a timely way
    """
    text = CharField(document=True, use_template=True)
    assignednumber = CharField(model_attr='assignednumber')
    people = MultiValueField()
    territory = CharField()

    def prepare_people(self,inst):
        return [o.indexsearch() for o in inst.relatedpeople.all()]
    
    def prepare_territory(self,inst):
        if inst.territory_for_restitutionrequest_set.count()>0:
            return inst.territory_for_restitutionrequest_set.all()[0].name
        return ""

site.register(RR,RRIndex)

Hay tres formas para actualizar el índice, en tiempo real, en lote o en una cola, para este ejemplo usaremos tiempo real, te sugerimos emplear el método de colas en un sitio en producción, este archivo se asemeja a models.py, estamos definiendo los campos que estamos usando para el índice en nuestras búsquedas, la mas sencilla es assignednumber, mapeando directamente a un campo de el modelo RR, para hacerte la vida más fácil incluímos un ManyToManyField representado por people donde definimos un método llamado indexsearch() que será usado como índice, por otra parte estamos mostrando en territorio una posible ForeignKey que puede ser nula donde estamos indexando por el campo name, y finalmente describimos el campo de texto que tiene el atributo use_template con el valor True, esto es de especial interés porque somos capaces de definir en una plantilla otros campos y aspectos usando el lenguaje de plantillas para iterar y seguir las relaciones para hacer que el índice esté un poco más completo. El siguiente código te muestra una plantilla ejemplo, esta plantilla deberías ubicarla en templates/search/indexes/informationgathering/restitutionrequest_text.txt

{{ object.assignednumber }}

{{ object.holderrightenterprise.nit }}

{{ object.territory }}

{{ object.people }}

Finalmente cuando definas tu índice, asegúrate de registrarlo con el modelo, a la interfaz de administración.

Puedes activar tu url con algo como

from haystack.views import SearchView

.
.
.

urlpatterns += patterns('haystack.views',
    url(r'^$', SearchView, name='haystack_search'),
)

Reconstruyendo el indice

si por cualquier razón necesitas reconstruir tu indice, tu shell django tiene ahora rebuild_index, asi puedes usar

./manage.py rebuild_index

En caso de ser necesario

Usando acentos

Dado que nosotros (AxiaCore) estamos en un país donde se habla español, necesitamos el control/evitar acentos, así ofrecemos urls complementarias, un formulario y un template.

A continuación un formulario sencillo usando translitcodec, si, viste esto antes en requierements.txt.

from haystack.forms import SearchForm

.
.

class RtSearchForm(SearchForm):
    def search(self):
        if hasattr(self,'cleaned_data') and self.cleaned_data['q']:
            self.cleaned_data['q']=self.cleaned_data['q'].encode('translit/one/ascii', 'replace')
        sqs = super(RtSearchForm, self).search()
        return sqs

y puedes personalizar tus resultados usando tus propias plantillas, al mostrar los resultados de la busqueda, deberias colocarlo en templates/search/search.html

from haystack.forms import SearchForm

.
.

class RtSearchForm(SearchForm):
    def search(self):
        if hasattr(self,'cleaned_data') and self.cleaned_data['q']:
            self.cleaned_data['q']=self.cleaned_data['q'].encode('translit/one/ascii', 'replace')
        sqs = super(RtSearchForm, self).search()
        return sqs

Finalmente tu urls.py deberían verse como

from haystack.views import SearchView
from django.contrib.auth.decorators import login_required
from apps.informationgathering.forms import RtSearchForm

.
.
.

urlpatterns += patterns('haystack.views',
    url(r'^$', login_required(SearchView(
            form_class=RtSearchForm
        )), name='haystack_search'),
)

Referencias

• django
• haystack
• xapian
• xapian-haystack
• another blog entry

Mas por hacer

Si, puedes conectar tu propio backend, puedes hacer búsquedas parciales y cosas avanzadas que tu documento favorito de la base de datos pueda hacer.

Wait, you have already a relational database, now you are adding a document database, so in your next geek party you would be able to speak fluently about it; note that you will have a second database specialized for searches, so the process is like this : you add or update a record to your original database, the system adds or updates a record to the document database, the “index” can be updated and the searches go only in the document database letting your relational database do the things it has to do in your deploy and not overwhelming it with the user search requests.

We assume you are working with a virtualenv, if you are not already using it, go for it first , if you are using Debian or Ubuntu, you can follow this guide straightforward, other flavors or oses should work, but you will need to work on it by yourself or upgrade to the recommended Oses we use here.  We assume you have python 2.7, if not, the copy/paste technique won’t work directly.

Getting the tools

in your host install xapian

apt-get install python-xapian

Assuming your virtualenv is called tr, the following script should work tweaking your vars according to your installation

export MYENV=~/.virtualenvs/tr
export LOCALPYTHON=/usr/lib/python2.7
ln -s $LOCALPYTHON/dist-packages/xapian/__init__.py $MYENV/lib/python2.7/site-packages/xapian.py
ln -s $LOCALPYTHON/dist-packages/xapian/_xapian.so $MYENV/lib/python2.7/site-packages/
if [ ! -f $MYENV/lib/python2.7/site-packages/haystack/backends/xapian_backend.py ] 
then 
  ln -s $MYENV/lib/python2.7/site-packages/xapian_backend.py $MYENV/lib/python2.7/site-packages/haystack/backends/
fi

Interfacing Django with haystack

Complement your requirements.txt with the following lines. If you are wondering what does requirements.txt is about, take a look at virtualenv

xapian-haystack==1.1.5beta
django-haystack==1.2.6
translitcodec==0.2

As usual, run your

pip install -r requirements.txt

In your settings.py add ‘haystack’ ,

And configure the following variables in your settings.py, make sure you have this variables defined BEFORE the apps configuration:

HAYSTACK_SITECONF = 'rt.search_sites'
HAYSTACK_SEARCH_ENGINE = 'xapian'
HAYSTACK_XAPIAN_PATH = '/var/lib/rtsearch/rtindex'

where rt is your project, you have a search_sites.py file inside it, more on this later, and you have the directory /var/lib/rtsearch/rtindex with the proper permissions (www-data:www-data or whatever user runs the webserver with the virtualenv).

Powering your django site with haystack

Do you recall we talked about a document database?  in haystack there is a file search_indexes.py that looks familiar to models.py, there we specify how we pick elements from the relational database to be searched, so with this file haystack knows what would be used to compare versus the searched thing, in other words, with this file the index is generated, so when someone searches, the document database is hit, but not your relational database.  In haystack there is a file where we can drop the information that will be used for the search, it’s a template and certainly you can customize your results page and the usual aspects you are interested when offering a search tool.  you will take a look at three files, the autodiscover, the search_indexes.py, the template and the configured urls, and as a bonus we will show you an approximation to search no matter if your users have accents or not.

Still reading? We’ll go for the index, this is a search_indexes.py, just for motivation we have the following:

from haystack.indexes import RealTimeSearchIndex
from haystack.indexes import CharField

from haystack.indexes import RealTimeSearchIndex
from haystack.indexes import CharField
from haystack.indexes import MultiValueField
from haystack import site
from apps.informationgathering.models import RR


class RRIndex(RealTimeSearchIndex):
    """Index preparation, in production, when there is high write traffic
    we have to make sure we are using QueueSearchIndex and updating the index
    in a timely way
    """
    text = CharField(document=True, use_template=True)
    assignednumber = CharField(model_attr='assignednumber')
    people = MultiValueField()
    territory = CharField()

    def prepare_people(self,inst):
        return [o.indexsearch() for o in inst.relatedpeople.all()]
    
    def prepare_territory(self,inst):
        if inst.territory_for_restitutionrequest_set.count()>0:
            return inst.territory_for_restitutionrequest_set.all()[0].name
        return ""

site.register(RR,RRIndex)

There are three ways to update the index, in real time, in batch and in a queue, for this sample we used realtime, you are warned to use queue on a production site, this file resembles models.py , we are defining the fields we are using to index our searches, the easiest one is assignednumber , mapping directly to a field of the model RR, for the sake of make yor life easier we considered a ManyToManyField represented by people where we defined a method called indexsearch() that will be used to index, in the other hand we are showing in territory a possible ForeignKey that can be nullable where we are indexing by the field name, and finally we describe the field text that has the attribute use_template set to True, this is special interest because we are able to define in a template many other fields and aspects using the template language to iterate and follow relations in order to make our index a little bit more complete.  The following code shows you a sample template, this template should be located at templates/search/indexes/informationgathering/restitutionrequest_text.txt

{{ object.assignednumber }}

{{ object.holderrightenterprise.nit }}

{{ object.territory }}

{{ object.people }}

Finally when you define your index, make sure you register it for the model, ala admin interface.

You can activate your url with something like

from haystack.views import SearchView

.
.
.

urlpatterns += patterns('haystack.views',
    url(r'^$', SearchView, name='haystack_search'),
)

Rebuilding the index

If for any reason you need to rebuild your index, your django shell has now rebuild_index , so you can use

./manage.py rebuild_index

If necessary

Using accents

Because we(Axiacore) are in spoken spanish country we need to control/avoid accents, so we offer a urls complement, a form and a template.

Follows a sample form using translitcodec, yes, you saw it earlier in requirements.txt.

from haystack.forms import SearchForm

.
.

class RtSearchForm(SearchForm):
    def search(self):
        if hasattr(self,'cleaned_data') and self.cleaned_data['q']:
            self.cleaned_data['q']=self.cleaned_data['q'].encode('translit/one/ascii', 'replace')
        sqs = super(RtSearchForm, self).search()
        return sqs

and you can customize your result using your own template to show the results of the search, it should be located at templates/search/search.html

{% extends "layout/base.html" %}
<div class="entry">
{% block body %}
    <div class="register_init">
        <div class="add_new">
            <a href="/recolecta/nuevo">Nueva Solicitud de Inscripción en el Registro</a>
        </div>
    <form method="get" action=".">
            {{ form.as_p }}
                    <input type="submit" value="Buscar">
    </form>
        {% if query %}
            <h3>Resultados</h3>

            {% for result in page.object_list %}
                <p>
                   <a href="/recolecta/1/{{ result.object.id }}">{{ result.object.assignednumber }}</a>: {{ result.object }}
                </p>
            {% empty %}
                <p>No se encontraron resultados.</p>
            {% endfor %}

            {% if page.has_previous or page.has_next %}
                <div>
                    {% if page.has_previous %}<a href="?q={{ query }}&amp;page={{ page.previous_page_number }}">{% endif %}&laquo; Previous{% if page.has_previous %}</a>{% endif %}
                    |
                    {% if page.has_next %}<a href="?q={{ query }}&amp;page={{ page.next_page_number }}">{% endif %}Next &raquo;{% if page.has_next %}</a>{% endif %}
                </div>
            {% endif %}
        {% else %}
            {# Show some example queries to run, maybe query syntax, something else? #}
        {% endif %}    
    </div>
{% endblock %}
</div>
{% block search %}
{% endblock %}

Finally your urls.py could look something like

from haystack.views import SearchView
from django.contrib.auth.decorators import login_required
from apps.informationgathering.forms import RtSearchForm

.
.
.

urlpatterns += patterns('haystack.views',
    url(r'^$', login_required(SearchView(
            form_class=RtSearchForm
        )), name='haystack_search'),
)

References

• django
• haystack
• xapian
• xapian-haystack
• another blog entry

 More to be done

Yes, you can plug your own backend, you can make partial searches and the advanced things that your favourite document database can do.

Traducción de Andrés Cárdenas Versión en español

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.

Primero que todo, Symfony incluye una serie de eventos (lista completa) genéricos que notifican varias tareas comúnes como: procesamiento de formularios y filtros, ejecución de tareas, etc. Para este caso particular, vamos a centrarnos en el evento: application.throw_exception el cual es notificado cuando se captura una excepción (por ejemplo de tipo sfFileException). Para poder capturar este evento, lo que debemos hacer es establecer un observador que se encargue de capturar el evento y procesarlo. Para ello simplemente agregamos en la clase de configuración del proyecto (o de la aplicación):

class miAplicacionConfiguration extends sfApplicationConfiguration
{
    public function configure()
    {
        $this->dispatcher->connect(
            'application.throw_exception', array(
            'MiClaseObservador','metodoObservador')
    }
}

Cada vez que ocurra una excepción, el método metodoObservador de la clase MiClaseObservador será llamado, cuyo parámetro será un objeto sfEvent. A continuación la implementación de la clase y el método:

class MiClaseObservador 
{
    public static function metodoObservador(sfEvent $event)
    {
	$mailer = sfContext::getInstance()->;getMailer();
        // Se obtiene la instancia del objeto que notifica el error, un ejemplar de una clase que extiende la clase
        // Exception de PHP
	$subject = $event->getSubject();
	$message = $subject->getMessage() . $subject->getTraceAsString();
	$mailer->composeAndSend('info@example.com', 'developers@example.com', 'An error has been occurred', $message);
     }
}

El código anterior envía un correo electrónico notificando del error, muy útil para entornos de prueba. El mensaje incluye el mensaje de error y el trace. Esperamos sea de utilidad.