Más adelante, si los proyectos web se vuelven muy complejos y se requiere de elementos prefabricados y avanzados (como objetos persistentes a bases de datos, encriptación, modelo vista controlador, etc.), recomiendo utilizar los otros frameworks citados anteriormente (hay muchos más, pero éstos son más populares y potentes).
Se asume que el lector tiene conocimientos básicos de Python y que previamente tiene instalado el intérprete de Python en su máquina:
Configuración del servidor Web
WebPy, a diferencia de otros frameworks, no posee un servidor de aplicaciones potente propio, y por ello, es mejor apoyarse en uno que ya esté funcionando. Entre los posibles candidatos se encuentran Apache, Lighttpd y nginx. Para este artículo he optado por Apache, dada su gran popularidad.
Una vez instalado Apache en nuestra máquina, es necesario agregar el módulo mod_wsgi, que permite hacer uso de Apache como servidor para aplicaciones escritas en Python. Este proyecto está alojado en: http://code.google.com/p/modwsgi
Una vez descargado, si estamos usando Windows, renombrar el archivo a
mod_wsgi.so y copiarlo al directorio modules de Apache. En el caso de Linux, compilar el módulo mod_wsgi (consultar: http://code.google.com/p/modwsgi/wiki/QuickInstallationGuide)Una vez instalado el módulo, hay que configurar Apache para que reconozca dicho módulo. Para ello, editar el archivo
httpd.conf (en el directorio conf de Apache), y agregar la siguiente línea en la misma parte en que Apache utiliza otras cargas LoadModule wsgi_module modules/mod_wsgi.soAl arrancar Apache desde la terminal debería dar un mensaje similar a éste:
Apache/2.2.2 (Unix) mod_wsgi/1.0 Python/2.3 configuredSi se lanzó desde Windows, el Apache Service Monitor, debería dar el mensaje en la parte inferior:
Instalación de WebPy
Hay varias maneras de instalar WebPy (consultar http://webpy.org/download).
Se puede descargar directamente la última versión desde la siguiente URL (consultar http://webpy.org/download para conocer cuál es la última versión):
http://webpy.org/static/web.py-0.34.tar.gz
También se puede descargar desde el repositorio en github:
http://github.com/webpy/webpy
Una vez descargado, descomprimir el archivo
tar.gz, y ejecutar la siguiente sentencia para instalarlo como librería en Python:python setup.py installPrimera aplicación Web
Para ilustrar la sencillez de desarrollo de una página Web con WebPy, vamos a crear la típica aplicación “Hola, Mundo”.
import web
urls = (
'/', 'index'
)
app = web.application(urls, globals())
class index:
def GET(self):
return "Hola, Mundo"
if __name__ == "__main__":
app.run()
La variable
urls es una tupla que contiene pares de direccionamientos URL y nombres de clase. En este ejemplo, el direccionamiento “/” (root), estará asociado a la clase index. Se pueden definir tantos pares como sean necesarios para la aplicación Web.El objeto
app contendrá la definición de la aplicación Web. En este ejemplo se asocian las URL’s de la aplicación a namespace global.La clase
index contiene un método GET, el cual se lanzará cuando se invoque a la página, pudiendo recibir parámetros. En su interior, retornará el literal “Hola, Mundo”, el cual se imprimirá en el navegador. Existe también un método POST, que funciona como GET, pero ofuscando los parámetros. Estos dos métodos son los medios habituales de invocar a una página Web pasando (o no) parámetros.Por último, las dos últimas líneas indican a WebPy que comience a servir páginas web con la configuración indicada.
Una vez se ejecuta este programa, el intérprete de
Python se queda en modo de espera. El servicio Web está en marcha, esperando peticiones. Para probarlo, abrimos un navegador web e introducimos la URL:http://localhost:8080Debería aparecer nuestro bien conocido mensaje “Hola, Mundo”.
Parámetros y HTML
En una aplicación Web introduciremos elementos HTML para formatear el aspecto de las páginas. Además, añadiremos dinamismo permitiendo que las páginas muestren datos parametrizados (por ejemplo, recogidos de un formulario, o capturados de una base de datos).
Vamos a añadir más funcionalidad a nuestra aplicación anterior:
import web
urls = (
'/hola', 'Saludo'
)
app = web.application(urls, globals())
class Saludo:
def GET(self):
data = web.input()
return """
<html>
<head></head>
<body background='#AAAAFF'>
<h1>Hola, %s %s %s</h1>
</body>
</html>""" % (data.nombre, data.apellido1, data.apellido2)
if __name__ == "__main__":
app.run()El primer cambio lo hemos realizado en la sección de
urls, donde ahora, el mapeo a la página Web será el siguiente:http://localhost:8080/holaCuando se apunta a
/hola, se invocará a la clase Saludo, concretamente a su método GET, en donde hemos agregado varios cambios. El primero de ellos ha sido definir una variable data, la cual recogerá los parámetros que se pasen por URL, lo que se consigue mediante la función input() del módulo web. Estos parámetros se recogerán en formato de diccionario, y son pares de parámetro y valor.A la hora de retornar la salida, se retornará HTML, en donde hemos añadido un mensaje con formato de título (
<h1>), un saludo con nombre y apellidos (extraídos de los parámetros pasados), los cuales se formatean mediante %s, e indicando después qué parámetros extraer.Para invocar a la nueva página se pasan los parámetros en la misma URL, tal y como haría una llamada desde un formulario:
http://localhost:8080/hola?nombre=Carmen&apellido1=Martinez&apellido2=SalgueroEl resultado es el siguiente:
Plantillas
En el último ejemplo comenzamos a utilizar HTML, que, al fin y al cabo, es el medio por el cual presentaremos la información en el navegador. El problema que tenemos es que se mezcla el código de Python y de HTML, y a la hora de depurar o realizar modificaciones, se vuelve enfarragoso y complejo. La forma ideal de trabajar sería separando la presentación (HTML) del código de negocio (el que procesa la información (Python)). Por un lado estarían las etiquetas HTML que ponen la información, y por otro el código Python que accede a la base de datos y la prepara en estructuras de datos (por ejemplo).
WebPy posee la característica de utilizar plantillas, que son directivas especiales embebidas en un código HTML, y que permiten conmutar valores que se pasan desde la capa de negocio o interactuar directamente con código Python.
Para estructurar nuestro código, vamos a crear un directorio donde se van a guardar las plantillas que vamos a necesitar. En nuestro caso la llamaremos
plantillas. Dentro de este directorio crearemos un fichero llamado (por ejemplo) plantilla.html, y cuyo contenido será el siguiente:$def with (nombre, apellido)
<HTML>
<HEAD></HEAD>
<BODY>
$if (nombre!='' and apellido!=''):
<H1>Hola, $nombre $apellido</H1>
$else:
<b>ERROR:</b> No ha facilitado el nombre y el apellido
</BODY>
</HTML>
La primera línea
$def with (nombre, apellido)debe ser la primera de la plantilla, y se encarga de recoger los parámetros enviados desde el código de negocio, los cuales serán presentados en la página HTML.
A continuación se crea el código HTML. Cuando es necesario presentar la información, hemos creado una estructura de control
if para comprobar los datos pasados. En nuestro caso comprobamos si nombre y apellido contienen datos, en cuyo caso imprimirá en un título el mensaje “Hola, “ seguido del nombre y del apellido. Si uno de los dos datos no se ha facilitado, entonces (else) se mostrará un mensaje de error.Ha de notarse que anteponiendo el símbolo
$ (dólar) a una línea en Python, esta se procesará como código Python. Asimismo, este símbolo también se utiliza dentro del HTML para sustituir una variable por su valor.Esta plantilla, por sí misma no hace nada. Debe ser asociada a la capa de negocio. Para ello crearemos el código en un fichero situado fuera del directorio
plantillas, justo en el nivel anterior. El código será el siguiente:import web
urls = (
'/hola', 'Saludo'
)
render = web.template.render('plantillas')
app = web.application(urls, globals())
class Saludo:
def GET(self):
data = web.input()
nombre = data.nombre if 'nombre' in data else ''
apellido = data.apellido if 'apellido' in data else ''
return render.plantilla(nombre, apellido)
if __name__ == "__main__":
app.run()El objeto
render apuntará al directorio donde se encuentran nuestras plantillas, creando internamente un objeto por cada plantilla encontrada.En el método
GET de la clase Saludo, hemos reforzado el código (a prueba de errores) en cuanto a los parámetros. Si se pasa el parámetro especificado, recogerá su valor. Si no se pasa, le asignará una cadena vacía. Los parámetros pasados están en formato diccionario, por lo que es posible averiguar si el parámetro (clave) está dentro del mismo (‘clave’ in diccionario).Por último, se retorna lo generado por la plantilla. Para ello se invoca a la plantilla:
render.plantilla(nombre, apellido)Como se comentó anteriormente, internamente, WebPy toma las plantillas dentro del directorio al que apuntaba, y generará un objeto accesible por cada una de ellas. A la plantilla le facilitará los parámetros
nombre y apellido, que serán recogidos por la primera línea de éste ($def with).
Un ejemplo más complejo
Los ejemplos anteriores han sido muy básicos. Vamos a ver un poco más a fondo cómo podemos aprovechar todo lo anterior. Imaginemos que queremos hacer una consulta a un catálogo de productos. Esta consulta puede ser general (muestra todos los productos), o bien específica (muestra un producto determinado). La solución pasaría por implementar un acceso a base de datos. Pero para no extender demasiado este artículo, vamos a tenerlo completamente en memoria (para más información sobre cómo acceder a bases de datos desde Python, recomiendo ver mi anterior artículo: http://rafinguer.blogspot.com/2010/10/conceptos-basicos-de-python-y-sqlite.html.
El código de negocio quedaría como sigue:
import web
urls = (
'/ejemplo', 'Consulta'
)
render = web.template.render('plantillas')
app = web.application(urls, globals())
class Consulta:
def GET(self):
criterio = web.input()
# Tuplas de diccionaris con datos de consulta.
# Puede ser una carga de datos de una bbdd
datos = (
{'producto':'Tornillo', 'precio':0.45, 'marca':'Acme'},
{'producto':'Tuerca', 'precio':0.55, 'marca':'Solme'},
{'producto':'Clavo', 'precio':0.30, 'marca':'Calme'},
{'producto':'Remache', 'precio':0.60, 'marca':'Acme'},
{'producto':'Clavija', 'precio':0.95, 'marca':'Acme'},
{'producto':'Grapa', 'precio':0.25, 'marca':'Tecme'}
)
registro=''
if criterio:
for i in range(0,len(datos)):
if datos[i]['producto'] == criterio.producto:
registro = datos[i]
break
if registro =='':
registro = datos
return render.productos(registro)
if __name__ == "__main__":
app.run()La llamada a la página puede hacerse sin parámetros (mostraría todos los productos), o bien pasando el parámetro
producto, especificando cuál queremos consultar.En ambos casos, a la hora de invocar a la plantilla, se pasaría la lista de productos o un único producto, que se almacena en la variable
registro.El código de la plantilla (
productos.html) sería el siguiente:$def with (registro)
<HTML>
<HEAD></HEAD>
<BODY>
<TABLE BORDER='1'><TR BGCOLOR='#AAAAFF'>
<TD><B>PRODUCTO<B></TD>
<TD><B>PRECIO<B></TD>
<TD><B>MARCA<B></TD></TR>
$if 'producto' in registro:
<TR>
$for i in range(0,len(registro)):
<TD> $registro.values()[i] </TD>
</TR>
$else:
$for i in registro:
<TR>
<TD> $i['producto'] </TD>
<TD> $i['precio'] </TD>
<TD> $i['marca'] </TD>
</TR>
</TABLE>
</BODY>
</HTML>En el caso de que se pase un único registro (la consulta se hizo por un único producto), éste será en sí un diccionario, por lo que al consultar si tiene una clave llamada
producto, retornará el valor True. En tal caso, la función len() retorna el número de pares clave/valor del diccionario. Conociendo este valor, se recorre cada campo del diccionario en el bucle for y se extrae su valor, visualizándolo en una columna. En el caso de pasar el catálogo completo, la función
len() retornaría el número de filas (diccionarios) que contiene la lista. El acceso a la lista debe realizarse mediante un iterador (i), el cual recoge, una a una, cada fila (diccionario). El valor se extrae invocando el nombre de su clave.El resultado final sería el siguiente:
Conclusiones
Este breve tutorial cubre los aspectos más básicos, pero, a la vez, más potentes y flexibles, para comenzar a desarrollar aplicaciones Web mediante Python. A partir de las nociones vistas anteriormente, podremos empezar a desarrollar complejas web dinámicas de una forma sencilla y eficaz.
Referencias
Lenguaje Python: http://www.python.org
mod_wsgi: http://code.google.com/p/modwsgi
WebPy: http://webpy.org
Apache: http://httpd.apache.org
