Calcifer » python

Alternativa al sistema de templates de Django, parte 1: Jinja2

lvidarte — Fri, 01 Oct 2010 19:46:17 +0000

Django es un gran framework web pero tiene un sistema de templates que a un programador puede resultarle un tanto limitado:

No es posible asignar variables ni cambiar sus valores.
No hay distinción entre métodos y propiedades.
No es posible pasar parámetros a los métodos.
No existe la sentencia elif ! :P

Hay varias alternativas entre las que elegir: Jinja2, Mako, Genshi, Cheetah. De todas, Jinja2 es el que tiene la sintáxis más compatible con Django, pero tiene otra filosofía y por lo tanto permite hacer más cosas. Empecemos entonces por la instalación.

Instalación de Jinja2

Jinja puede instalarse medianteeasy_install:

sudo easy_install jinja2

Y medianteapten debian y derivados:

sudo apt-get install python-jinja2

Integración con Django

El diseño de bajo acoplamiento de Django permite que usar otro sistema de templates sea sencillo. Para Jinja basta con definir una variable de ambiente y escribir los métodos alternativos pararender_to_stringyrender_to_response. A continuación muestro la forma más simple que encontré. Hay otras más sofisticadas por ahí (esta y esta) pero básicamente hacen lo mismo:

# jinja_helper.py

from django.conf import settings

from django.http import HttpResponse

from jinja2 import Environment, FileSystemLoader

jinja_env = Environment(

    loader=FileSystemLoader(getattr(settings, 'TEMPLATE_DIRS')))

def render_to_string(template_path, context=None, **kwargs):

    template = jinja_env.get_template(template_path)

    context = dict(context or {})

    return template.render(**context)

def render_to_response(template_path, context=None, **kwargs):

    return HttpResponse(render_to_string(template_path, context, **kwargs),

                        mimetype=None)

La vista entonces no difiere mucho de una vista tradicional:

# views.py

from jinja_helper import render_to_response

def index(request):

    title = "hello world."

    return render_to_response('index.html', locals())

<h1>{{ title }}</h1>

Escribir un libro filtro

Un filtro es una función de python que se agrega a la listafilters:

# filter.py

from jinja_helper import jinja_env

def toupper(s):

    return s.upper()

jinja_env.filters['toupper'] = toupper

Cuando el filtro recibe un sólo argumento la forma de uso es similar a Django:

<h1>{{ title|toupper }}</h1>

Para pasar más argumentos se usa la formaarg1|func(arg2, ...).

Para la asignación a jinja_env.filter pordemos usar un decorador:

# filter.py

from jinja_helper import register_filter

@register_filter()

def toupper(s):

    return s.upper()

# jinja_helper.py

def register_filter(name=None):

    def dec(func):

        if name:

            func.__name__ = name

        jinja_env.filters[func.__name__] = func

        return func

    return dec

Tags? no, funciones

Para emular un tag de inclusión de django hay que definir una función que retorne un render_to_string y agregarla a la listaglobals:

# blocks.py

from jinja_helper import jinja_env, render_to_string

def menu():

    items = ('about', 'contact')

    return render_to_string('menu.html', dict(items=items))

jinja_env.globals['menu'] = menu

El template podría ser algo así:

<ul>

{% for item in items %}

    <li>{{ item }}</li>

{% endfor %}

</ul>

{{ menu() }}

De nuevo, podríamos agregar un poco de azúcar a la sintáxis:

# blocks.py

from jinja_helper import register_block

@register_block('menu.html')

def menu():

    items = ('about', 'contact')

    return dict(items=items)

# jinja_helper.py

def register_block(template_path, name=None):

    def dec(func):

        def func2(*args, **kwargs):

            return render_to_string(template_path, func(*args, **kwargs))

        func2.__name__ = name if name else func.__name__

        jinja_env.globals[func2.__name__] = func2

        return func2

    return dec

Descarga

El ejemplo completo puede descargarse desde aquí: mysite-jinja2.tar

Vim scripting con Python

lvidarte — Thu, 25 Feb 2010 01:20:00 +0000

Vim permite agregar funcionalidades mediante varios lenguajes externos, entre ellos Perl, Python, Ruby y Tcl. Para poder hacer uso de esta característica es necesario haber compilado Vim con el soporte para el lenguaje necesario (con el flag-python, para soporte python). En debian existe un paquete llamado vim-nox (no X) que contiene una versión compilada con soporte para los cuatro lenguajes mencionados:

sudo apt-get install vim-nox

Para comprobar que efectivamente se encuentre habilitado el soporte para Python ejecutar Vim y en modo comando escribir:

:echo has("python")

Un 1 indica que Vim interpreta Python ;)

Es muy recomendable leer la ayuda en línea:

:help python

También se puede acceder vía web desde http://vimdoc.sourceforge.net/htmldoc/if_pyth.html

Ejecución de código Python

La ejecución de una línea de código Python se realiza según la sintaxis:

:[range]py[thon] {stmt}

Ejemplo:

:python print "hello world"

Aquí el prompt mostrará el mensaje “hello world”.

En cambio para escribir código en varias líneas hay que usar la siguiente forma:

[range]:py[thon] << {endmarker}

{script}

{endmarker}

Ejemplo:

:python << EOF

def get_user():

  import os

  return os.getenv('USER')

EOF

De esta manera la función queda guardada en la memoria de la sesión actual. Luego su uso podría ser el siguiente:

:py user = get_user()

Tambien es posible cargar y/o ejecutar código desde un archivo externo. La sintaxis es:

:[range]pyf[ile] {file}

Ejemplo:

:pyfile myscript.py

Simyscript.pynecesitara parámetros la forma de pasárselos es la siguiente:

:py import sys

:py sys.argv = ['foo', 'bar']

:pyf myscript.py

El módulo vim

La comunicación entre Python y Vim se realiza a través del módulo vim, el cual hay que importar antes de usar:

:python import vim

Como indica la ayuda de Vim, el módulo implementa dos métodos (vim.command(str)yvim.eval(str)), tres constantes (vim.buffers,vim.windowsyvim.current) y un objeto error (vim.error). Las tres constantes mencionadas no son realmente constantes sino variables que pueden ser reasignadas pero, como dice también la ayuda, esto sería absurdo ya que se perdería acceso a los objetos de Vim que referencian. Por otra parte cabe recordar que no existen constantes en Python. Como cita el libro “Inmersión en Python“:

Todo puede cambiar si lo intenta con ahínco. Esto se ajusta a uno de los principios básicos de Python: los comportamientos inadecuados sólo deben desaconsejarse, no prohibirse.

A continuación transcribo un detalle de cada una de las constantes mencionadas:

vim.buffers: Objeto de tipo secuencia que provee acceso al listado de buffers actuales. El objeto soporta las siguiente operaciones:

:py b = vim.buffers[i] # Indexación (Read-Only)
:py b in vim.buffers # Prueba de existencia
:py n = len(vim.buffers) # Número de elementos
:py for b in vim.buffers: # Acceso secuencial
vim.windows: Objeto de tipo secuencia que provee acceso al listado de ventanas actuales. El objeto soporta las mismas operaciones que vim.buffers:

:py w = vim.windows[i] # Indexación (RO)
:py w in vim.windows # Prueba de existencia
:py n = len(vim.windows) # Número de elementos
:py for w in vim.windows: # Acceso secuencial
vim.current: Objeto que provee acceso (vía atributos específicos) a distintos objetos actuales:

vim.current.line # (RW) String
vim.current.buffer # (RO) Buffer
vim.current.window # (RO) Window
vim.current.range # (RO) Range

Ejemplos básicos de uso del módulo vim

Usandovim.current.line:

:py from string import upper

:py vim.current.line = upper(vim.current.line)

Usandovim.current.buffer:

:py b = vim.current.buffer      # obtiene buffer actual

:py name = b.name               # nombre de archivo del buffer actual

:py num = len(b)                # total de líneas en el buffer

:py line = b[n]                 # obtiene la línea n+1

:py lines = b[n:m]              # obtiene una lista de líneas

:py b[n] = str                  # reemplaza la línea n+1

:py b[n:m] = [str1, str2, str3] # reemplaza varias líneas a la vez

:py b[0:0] = ["hola mundo"]     # inserta una línea al comienzo

:py b.append("fin")             # inserta una línea al final

:py del b[n]                    # borra la línea n+1

:py del b[n:m]                  # borra varias líneas a la vez

:py b[:] = None                 # borra el buffer completo

Usandovim.current.window:

:py cw = vim.current.window      # obtiene la ventana actual

:py cw.height = 30               # setea el alto de la ventana

:py cw.width = 80                # setea el ancho

:py pos = cw.cursor              # posicion del cursor (row, col)

Script para subrayado de títulos

El siguiente script (heading.vim) lo escribí para no tener que, manualmente, subrayar títulos y delimitar bloques de texto. Especialmente quería que reconociera cuando se tratara de texto dentro de comentarios de código fuente y que respetara los caracteres especiales al comienzo (y final) de los mismos.

El script tiene una función que decora la línea actual colocando él o los caracteres decoradores tanto arriba como debajo de la misma (comportamiento por defecto). El largo (también por defecto) es el largo de la línea, pero se puede fijar un límite (ejemplo 80 columnas) y pedirle que ocupe todo el espacio disponible. Esta opción funciona bien sólamente cuando el indentado es con espacios. La opción uppercase funciona como se espera.

El código es el siguiente:

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

" ============================================================================

" File:        heading.vim

" Version:     0.1

" Description: vim global plugin that provides a way to create headings.

" Maintainer:  Leonardo Vidarte 

" Last Change: 21 February, 2010

" ============================================================================

if has('python')

python << EOF

def heading(decorator='=', top=True, bottom=True, limit=0, uppercase=False):

    import vim

    from string import upper, rstrip, lstrip

    if not top and not bottom:

        return None # nothing to do

    (row, col) = vim.current.window.cursor

    line = vim.current.buffer[row-1].rstrip()

    line_length = len(line.decode('utf8'))

    title = line.lstrip()

    word_length = len(title.decode('utf8'))

    whitespace = line[0:line_length - word_length]

    if limit > 0:

        decorator *= limit

        total_length = limit

    else:

        decorator *= word_length

        total_length = line_length

    if title[0:3] in ('// ', '/* ', '-- '):

        decoline = whitespace + title[0:3] + decorator

    elif title[0:2] in ('//', '/*', '--', '# ', '* ', '" '):

        decoline = whitespace + title[0:2] + decorator

    elif title[0:1] in ('#', '*', '"'):

        decoline = whitespace + title[0:1] + decorator

    else:

        decoline = whitespace + decorator

    # Special case: comments like C /* hello world */

    cend = ''

    if title[0:2] == '/*':

        if title[-3:] == ' */':

            cend = ' */'

        elif title[-2:] == '*/':

            cend = '*/'

    decoline = decoline[0:total_length - len(cend)] + cend

    final_heading = []

    if top:

        final_heading.append(decoline)

    if uppercase:

        final_heading.append(line.upper())

    else:

        final_heading.append(line)

    if bottom:

        final_heading.append(decoline)

    del vim.current.buffer[row-1]

    vim.current.buffer[row-1:0] = final_heading

    # Set final cursor position

    if top and bottom:

        vim.current.window.cursor = (row + 2, 0)

    else:

        vim.current.window.cursor = (row + 1, 0)

H = heading # shortcut

EOF

" ============================================================================

" Vim maps (see :help leader)

" ============================================================================

nnoremap  hh :python heading()

nnoremap  h1 :python heading('#', uppercase=True)

nnoremap  h2 :python heading('*', uppercase=True)

nnoremap  h3 :python heading('=')

nnoremap  h4 :python heading('-')

nnoremap  h5 :python heading('~', top=False)

nnoremap  HH :python heading(limit=78)

nnoremap  Hb :python heading(limit=78, top=False)

nnoremap  Ht :python heading(limit=78, bottom=False)

endif

Para usarlo hay que colocar el archivo heading.vim en el directorio~/.vim/plugins.

Ejemplos de uso

1. Texto normal

Título

:py H()

======
Título
======

2. Comentario en línea (Python, Bash, Perl, PHP, Ruby)

    # Comment

:py H()

    # =======
    # Comment
    # =======

3. Comentario en bloque, estilo javadoc (C, C++, Java, Javascript, CSS, PHP, SQL)

    /**
     * Comment
     */

:py H('#', uppercase=True)

    /**
     * #######
     * COMMENT
     * #######
     */

4. Comentario en línea (C, C++, Java, Javascript, CSS, PHP, SQL)

/* Comment */

:py H('~+')

/* ~+~+~+~ */
/* Comment */
/* ~+~+~+~ */

5. Comentario en línea (C, Java, Javascript, PHP)

// Comment

:py H(limit=40)

// =====================================
// Comment
// =====================================

6. Comentario en línea (Vim script)

" Comment

:py H(top=None)

" Comment
" ======

7. Comentario en línea (Lua, SQL)

-- Comment

:py H()

-- =======
-- Comment
-- =======

Atajos de teclado

El script también define algunos atajos en modo normal para Vim. Para los mismos se usa la tecla especialque es definida por la variablemapleadery que generealmente es el caracter\.

Atajo	Comando
\hh	:python heading()
\h1	:python heading(‘#’, uppercase=True)
\h2	:python heading(‘*’, uppercase=True)
\h3	:python heading(‘=’)
\h4	:python heading(‘-’)
\h5	:python heading(‘~’, top=False)
\HH	:python heading(limit=78)
\Hb	:python heading(limit=78, top=False)
\Ht	:python heading(limit=78, bottom=False)

Lectura adicional

Accediendo a MySQL con Python y MySQLdb

lvidarte — Thu, 26 Mar 2009 15:00:27 +0000

MySQLdb es un módulo que implementa la API estándar (PEP249) para manejo de bases de datos, en este caso MySQL. MySQLdb es en realidad un wrapper del módulo _mysql que provee Python, el cual implementa la mayoría de las funciones definidas en la API C de MySQL. La idea de definir una API estándar es que uno debería poder cambiar a otra base de datos sin modificar demasiado el código.

This API has been defined to encourage similarity between the Python modules that are used to access databases.

Instalación MySQLdb

El paquete que nos provee el módulo se llama python-mysqldb. Podemos comprobar que lo tenemos instalado mediante

dpkg --get-selections | grep python-mysqldb

Si no existe lo instalamos

sudo apt-get install python-mysqldb

Para comprobar que efectivamente tenemos el módulo disponible y funcionando llamamos al intérprete de Python y escribimos

>>> import MySQLdb

Un silencioso retorno de carro indica que podemos el módulo ha sido cargado. Salimos del intérprete conC-d.

Creación de una DB de pruebas

Para nuestro ejemplo crearemos una base de datos con una única tabla. Entramos a la consola de MySQL y escribimos

mysql> CREATE database test;

Query OK, 1 row affected (0.01 sec)

mysql> USE test;

Database changed

mysql> CREATE TABLE users (

    -> id INT NOT NULL AUTO_INCREMENT PRIMARY KEY,

    -> name VARCHAR(100),

    -> lastname VARCHAR(100)

    -> );

Query OK, 0 rows affected (0.01 sec)

mysql> INSERT INTO users (name, lastname) VALUES

    -> ('Juan', 'Perez'),

    -> ('Ana Maria', 'Lopez'),

    -> ('Carlos L.', 'Gutierrez');

Query OK, 3 rows affected (0.00 sec)

Records: 3  Duplicates: 0  Warnings: 0

Nuestra tabla users quedó entonces

mysql> SELECT * FROM users;

+----+-----------+-----------+

| id | name      | lastname  |

+----+-----------+-----------+

|  1 | Juan      | Perez     | 

|  2 | Ana Maria | Lopez     | 

|  3 | Carlos L. | Gutierrez | 

+----+-----------+-----------+

3 rows in set (0.00 sec)

Creación del script mysqldb.py

Creamos el siguiente script que se conectará a la base de datos test y traerá todos los datos de los usuarios cargados en la tabla users. En el script es necesario reemplazar y por los datos requeridos para acceder a tu DB.

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

#!/usr/bin/python

import MySQLdb

# Conexion a la base de datos

conn = MySQLdb.connect (host="localhost",

    user="", passwd="", db="test")

# Creacion cursor

cursor = conn.cursor()

# Ejecucion query

cursor.execute("SELECT * FROM users")

# Manejo de datos devueltos por la consulta

while True:

    row = cursor.fetchone()

    if row is None:

        break

    else:

        print "id: %s\tname: %s %s" %

            (row[0], row[1], row[2])

# Finalizado cursor y objeto conexion

cursor.close()

conn.close()

La salida debería ser

id: 1   name: Juan Perez

id: 2   name: Ana Maria Lopez

id: 3   name: Carlos L. Gutierrez

Links recomendados para ampliar conocimientos

El Zen de Python

lvidarte — Tue, 03 Jul 2007 12:36:43 +0000

Vía Mundo Geek

Hace mucho tiempo el entusiasta de Python Tim Peters plasmó de forma concisa los principios de diseño por los que guiarse al escribir en Python según el BDFL (NT: Benevolent Dictator for Life o Dictador Benévolo de por Vida, en este caso Guido van Rossum, el creador de Python) en 20 aforismos, de los cuales sólo 19 han pasado a forma escrita.

Hermoso es mejor que feo.
Explícito es mejor que implícito.
Simple es mejor que complejo.
Complejo es mejor que complicado.
Plano es mejor que anidado.
Disperso es mejor que denso.
La legibilidad cuenta.
Los casos especiales no son suficientemente especiales como para romper las reglas.
Aunque lo pragmático gana a la pureza.
Los errores nunca deberían dejarse pasar silenciosamente.
A menos que se silencien explícitamente.
Cuando te enfrentes a la ambigüedad, rechaza la tentación de adivinar.
Debería haber una — y preferiblemente sólo una — manera obvia de hacerlo.
Aunque puede que no sea obvia a primera vista a menos que seas holandés. (NT: Guido van Rossum es holandés)
Ahora es mejor que nunca.
Aunque muchas veces nunca es mejor que *ahora mismo*.
Si la implementación es difícil de explicar, es una mala idea.
Si la implementación es sencilla de explicar, puede que sea una buena idea.
Los espacios de nombres son una gran idea — ¡tengamos más de esas!