Django: El framework para perfeccionistas con tiempos límite

Django Reinhardt es considerado uno de los mejores guitarristas de todos los tiempos. Tuvo un accidente que lo dejó con dos dedos paralizados, sin embargo con sólo dos dedos podía tocar mejor que muchos y hacer música simplemente maravillosa. Django también es el nombre de un framework para desarrollo web escrito en Python, con el que podemos tener sitios web funcionando en muy poco tiempo; el código simple y elegante de las aplicaciones web hechas con Django nos hace recordar la música de Reinhardt.Originalmente Django fue creado para funcionar en un ambiente periodístico donde los tiempos límite son cruciales para una publicación periódica, así que los desarrolladores tuvieron que adaptarse al ritmo de los reporteros y editores para poder sacar el contenido a tiempo en el sitio web del periódico. Adrian Holovaty, Simon Willison y Jacob Kaplan-Moss son el equipo de desarrolladores detrás de Django. En el 2005 después de asistir al PyCon, decidieron liberar el código de Django bajo licencia BSD y ahora muchos voluntarios ayudan en su desarrollo.

Django sigue el modelo MVC (Model View Controller - Modelo Vista Controlador), bueno realmente es MTV (Model Template View – Modelo Plantilla Vista ), separando la programación del diseño con lo que podemos tener trabajando en paralelo a programadores y diseñadores, ahorrando mucho tiempo. Esto también permite cambiar en cualquier momento el diseño del sitio sin preocuparse porque la aplicación pueda resultar dañada. La arquitectura de Django también se apega al principio DRY (Don’t Repeat Yourself - No te repitas a ti mismo), de tal forma que si se tiene que realizar un cambio en la aplicación, éste se haga solamente en un lugar, en vez de estarlo replicando por toda la aplicación.

Para empezar a desarrollar nuestra aplicación web necesitamos Python (versión 2.3 a 2.6), algún manejador de base de datos (sqlite3, PostgreSQL, MySQL, Oracle), el adaptador para el manejador de base de datos correspondiente (pysqlite[3], psycopg, MySQLdb, cx_Oracle), un servidor web (Apache, cherokee, lighttp ) y finalmente Django. Los detalles de la instalación pueden consultarse en el sitio oficial del proyecto.

Creando nuestro proyecto
Django incluye el script django-admin.py que facilita significativa-mente la creación de proyectos y aplicaciones. Durante la instalación django-admin.py debió ser copiado en algún lugar donde pueda ser
invocado (por ejemplo en /usr/local/bin/ en sistemas Linux) así que desde la línea de comandos tecleamos:

$django-admin.py startproject prueba

Esto creará el directorio “prueba” y copiará a él varios archivos que nos ayudarán en la creación de nuestras aplicaciones. El directorio contendrá los archivos: __init__.py, manage.py, settings.py, y urls.py.
A partir de este momento ya podemos visualizar nuestro sitio web. A estas alturas solo veremos la página default, pero es buen ejercicio validar que funciona. Corremos el servidor de desarrollo de Django
con el comando:

$python manage.py runserver

y abrimos nuestro navegador en http://localhost:8000

Configuración de la base de datos
Django puede usarse con distintos manejadores de base de datos y oficialmente soporta PostgreSQL, MySQL, Oracle y SQLite. También es posible usarlo con otros manejadores como SQL Server, DB2 y Sybase, pero es posible que la funcionalidad que se pueda obtener no sea la misma que con los manejadores soportados oficialmente.

Si tienes disponible algún servidor de base de datos, solo es cuestión de que edites el archivo de configuración settings.py indicando la información correspondiente. Por ejemplo, para utilizar una
base de datos en PostgreSQL en localhost, simplemente habría que indicar:

DATABASE_ENGINE = ‘postgresql_psycopg2’
DATABASE_USER = ‘[nombre del usuario para conexión]’
DATABASE_PASSWORD = ‘[contraseña]’

Obviamente, la base de datos debe tener ese usuario creado y estar configurada para aceptar conexiones.

Eso es todo lo que tenemos que hacer con respecto a la base de datos.

Django se encargará de crear las tablas y generar las sentencias SQL gracias a su Object-Relational Mapper (ORM). Nosotros no tendremos que meternos con SQL a menos que quisieramos realizar alguna sentencia
específica que no se pueda manejar por medio del ORM.

Creando nuestra aplicación de blogs
Ya que tenemos creado y configurado nuestro proyecto y base de datos, podemos crear nuestra aplicación. Vamos a crear una aplicación llamada “blogs” que será un manejador de blogs.

$django-admin.py startapp blog

Aquí empieza lo divertido. Vamos a definir nuestro modelos de datos. Para esto abrimos models.py en cualquier editor de texto y agregamos lo siguiente:

class Post(models.Model):
title = models.CharField(max_length=50)
date = models.DateTimeField(‘published on’)
body = models.TextField(‘Body’, blank=True)

Como podrán imaginar, definimos el modelo o entidad de información “Post” con los atributos title, date y body.

Uno de los elementos más poderosos de Django es la interfaz de administración automática. Esta se encarga de leer los metadatos de nuestro modelo y automáticamente provee una interfaz a través de la cual se puede agregar información a nuestra aplicación. Para habilitar la manipulación de información de nuestros modelos desde la interfaz de administración de Django debemos registrar nuestras clases en un archivo llamado admin.py. Creamos este archivo dentro del directorio de nuestra aplicación y le agregamos lo siguiente:

from prueba.blog.models import Post
from django.contrib import admin
admin.site.register(Post)

Con esto habilitamos la interfaz de administración para la clase Post. Ahora vamos a modificar una vez mas nuestro archivo settings.py para agregar la aplicación que hemos creado y habilitar la aplicación de administración. Abrimos el archivo settings.py y buscamos la sección de INSTALLED_APPS, agregando ‘prueba.blog’ y ‘django.contrib.admin’. Esta sección deber quedar así:

INSTALLED_APPS = (
‘django.contrib.auth’,
‘django.contrib.contenttypes’,
‘django.contrib.sessions’,
‘django.contrib.sites’,
‘prueba.blog’,
‘django.contrib.admin’,
)

Para crear las tablas en la base de datos que correspondan al modelo que definimos, basta con que invoquemos el comando:

$python manage.py syncdb

De manera instantánea ya tenemos nuestro esquema en la base de datos y nos pregunta si queremos definir un superusuario, elegimos que sí. Si tienes curiosidad, puedes conectarte a tu base de datos y verificar que se hayan creado las tablas correspondientes. Si esto no sucedió, verifica que hayas indicado correctamente los datos de conexión a la BD en settings.py y que el usuario tenga privilegios para crear bases de datos y tablas.

Diseñando urls
Diseñar urls tal vez no sea lo más divertido del mundo, pero las ventajas de tener urls bonitas permite a los usuarios encontrar las páginas más fácilmente y a los buscadores la indexación. El diseño de urls se hace a través de expresiones regulares que se indican en el archivo urls.py. Encontramos este archivo y lo editamos para que contenga lo siguiente:

from django.conf.urls.defaults import *
from django.contrib import admin
admin.autodiscover()
urlpatterns = patterns(‘’,
(r‘^admin/(.*)’, admin.site.root),
(r‘^blog/’, include(‘prueba.blog.urls’)),
)

Lo que hicimos con esto fue indicar que el patrón de urls admin/* apuntan a la interfaz de administración, mientras que los urls debajo de blog/ serán manejados por el archivo urls.py que está dentro del directorio prueba/blogs.

Así que ahora debemos crear el archivo urls.py dentro del directorio blog y agregarle el siguiente código:

from django.conf.urls.defaults import *
urlpatterns = patterns(‘’,
(r‘^$’, ‘blog.views.front’),)

Views y templates
Las vistas (views) son funciones que reciben peticiones y devuelven respuestas de cualquier tipo, como puede ser HTML, XML, imágenes, PDF, etc. En la configuración de nuestros urls en blogs/urls.py definimos que cuando se acceda /blog/ debemos invocar una vista llamada “front”. Vamos entonces a definir esta vista en blog/views.py. Lo que queremos es que despliegue los últimos 5 posts:

from django.shortcuts import render_to_response
from django.http import HttpResponseRedirect
from models import Post
def front(request):
entries = Post.objects.all().order_by(‘-date’)[:5]
return render_to_response(“blog.html”, dict(entries=entries))

A continuación tenemos que crear nuestros templates, uno para el sitio en general y otro para nuestro blog. Vamos a crear un directorio ‘templates’ dentro de nuestro directorio prueba para almacenar estos archivos. Creemos el archivo templates/base.html con el siguiente código:


En este template podremos añadir más adelante hojas de estilo o JavaScript para que luzca mejor. Incluso podemos crear una aplicación AJAX ligando la aplicación con la vista y utilizando una de las tantas bibliotecas que existen como jQuery, Mochikit, Dojo o Prototype, por mencionar algunas.

Django tiene su propio lenguaje de templates, fijémonos en los bloques {% %} dentro de los cuales podemos manipular el comportamiento de nuestra vista por medio de comandos como for o if. El lenguaje de templates es limitado y se debe utilizar únicamente para mostrar el contenido que se desea presentar al usuario (capa de presentación) y no para la lógica de negocio. El siguiente template es el homepage de nuestro blog. Por medio del comando ‘extends’ podemos reutilizar el template base.html para no volver a escribir el mismo html y solo agregar el comportamiento específico para este caso. Creemos entonces el archivo templates/
blog.html con el siguiente código:

Por supuesto que para que Django sepa dónde encontrar nuestros templates tenemos que indicarle la ruta. Esto lo hacemos en settings.py

TEMPLATE_DIRS = (
“/home/usuario/django_projects/prueba/templates”
)

Probando nuestro blog
Para comprobar que todo marche bien corremos el servidor de desarrollo de Django

$python manage.py runserver

al ir a http://localhost:8000/admin ya podemos acceder la aplicación de administración de Django con el nombre de usuario y contraseña que asignamos al crear el administrador. Incluso podremos registrar
nuevos posts ahi. ¿Pero cómo sucede eso si no hemos definido ninguna forma para capturar posts? Precisamente eso es lo que hace la interfaz de administración automática. En base a los tipos de datos de nuestra entidad Post, nos ha generado automáticamente una forma para dar de
alta instancias de esta entidad.

En http://localhost:8000/blog vemos el homepage de nuestro blog como habíamos indicado en urls.py.

Formas
Desde la interfaz de administración de Django podemos manejar nuestros sitios, crear usuarios, modificar permisos y agregar contenido. Pero se hace necesario agregar formularios personalizados desde los cuales los usuarios puedan agregar contenido, hacer consultas o simplemente ponerse en contacto con nosotros. Para todo esto podemos echar mano de la biblioteca incluida en Django y ahorrarnos bastante trabajo al generar los formularios automáticamente.

Comenzamos creando un archivo forms.py dentro del directorio de nuestra aplicación que contenga lo siguiente:

from django import forms
from django.forms import ModelForm
from models import *
class PostForm(ModelForm):
title = forms.CharField(max_length=50, label=’Título’)
date = forms.DateTimeField(required=True,
help_text = ‘mm/dd/aaaa 24:00’)
label = ‘Fecha y hora’
body = forms.CharField(widget=forms.Textarea)
class Meta:
model = Post

Ahora vamos a modificar blog/urls.py para definir un patrón que apunte al formulario de registro:

urlpatterns = patterns(‘’,
(r‘^$’, ‘blog.views.front’),
(r‘newpost/’, ‘blog.views.main’),
)

Luego editamos views.py para registrar este formulario en la función main (que es la que definimos en urls.py):

from django.shortcuts import render_to_response
from django.http import HttpResponseRedirect
from models import Post
from forms import PostForm

def front(request):
entries = Post.objects.all().order_by(‘-date’)[:5]
return render_to_response(“blog.html”,
dict(entries=entries))

def main(request):
if request.method == ‘POST’:
form = PostForm(request.POST)
if form.is_valid:
form.save()
return HttpResponseRedirect(‘/blog’)
else:
form = PostForm()
return render_to_response(‘main.html’, { form:‘form’})

Creamos el template main.html que solo requiere tener lo siguiente:

Lo último que faltaría sería modificar nuestro template blog.html para agregar una hiperliga que apunte a la forma de registro:

Con esto ya tenemos un formulario para registrar nuevos Posts, que es accesible por el usuario. Podemos probar nuevamente nuestra aplicación y verificar que así sea.

Conclusión
Como pudieron apreciar, la creación de aplicaciones web con Django es muy rápida y sencilla. Claro que este ejemplo es muy simple y muchas de las características de este framework no se pudieron ver aquí como lo son las formas en detalle y su validación, o las pruebas unitarias. Sin embargo espero haber dado un buen
vistazo a este gran framework que ha ganado merecidamente su reputación dentro de la comunidad
pythonista y fuera de ella por su rapidez y eficiencia frente a otros frameworks de desarrollo web.

Archivos con el código fuente

• Formato zip
• Formato tar.gz

Referencias
[1] Sitio oficial de Django: www.djangoproject.com
[2] Libro sobre Django con licencia libre: www.djangobook.com
[3] Django en español: www.django.es

Acerca del Autor

Julio Acuña estudió en la Facultad de Química de la UNAM y es un apasionado del software libre. Ha trabajado tanto en el gobierno como en la iniciativa privada y ha participado en varios congresos de software libre a nivel nacional impartiendo conferencias y talleres. Julio es colaborador y editor de
revista-sl.org