Su primera Página Django: Hola Mundo

Como primer objetivo, vamos a crear una página Web que produzca el mensaje de ejemplo famoso: “Hola mundo”.

Con Django, el contenido de la página es producido por una vista, y la dirección se especifica en una URLconf.  En primer lugar, vamos a escribir la función de la vista “Hola Mundo”.

Una vista “Hola Mundo” es simple. Aquí está toda la función que debe escribir en el archivo views.py:

from django.http import HttpResponse

def hello(request):

return HttpResponse(“Hello world”)

Una vista en Python es sólo una función que toma un HttpRequest como su primer parámetro y devuelve una instancia de HttpResponse. Para que una función de Python sea una vista Django, tiene que hacer esas dos cosas. (Hay excepciones, pero las veremos más tarde.) Si en este momento ejecuta python manage.py runserver de nuevo, seguirás viendo el mensaje “Bienvenido a Django”, sin ningún rastro de “Hola mundo”.  Eso se debe a que el proyecto mysite no conoce la vista hello; se necesita ahora decirle a Django explícitamente que se va a activar esa vista en una determinada URL, usando URLconf. Un URLconf es como una tabla de contenidos para un sitio web Django. Básicamente, es un mapeo entre las URL y las funciones de vista que deben llamarse para esas direcciones URL. El URLconf por defecto incluye algunas características comentadas de uso común en Django, por lo que la activación de esas características es tan fácil como descomentar las líneas adecuadas. Si se ignora el código comentado, aquí está la esencia de un URLconf:

from django.conf.urls.defaults import *

urlpatterns = patterns(”,

)

Lo más importante a destacar es la variable urlpatterns, que Django espera encontrarla en el módulo URLconf. Esta variable define la asignación entre las direcciones URL y el código que controla las direcciones URL. Por defecto, el URLconf está vacío – la aplicación Django está en blanco. Para agregar una URL y una vista al URLconf, simplemente añadir una tupla Python que asigna un patrón de URL a la función de la vista. He aquí cómo conectarlo en la vista hello:

from django.conf.urls.defaults import *

from mysite.views import hello

urlpatterns = patterns(”,

(‘^hello/$’, hello),

)

En pocas palabras, se le dice a Django que cualquier petición a la URL /hello/ debería ser gestionada por la función de vista hello.

Para probar los cambios a la URLconf, inicie el servidor de desarrollo de Django con el comando python manage.py runserver. (Si usted lo dejó ejecutándose también está bien. El servidor de desarrollo detecta automáticamente los cambios en su código Python y vuelve a cargarlos cuando sea necesario, para que no tenga que reiniciar el servidor entre los cambios.) El servidor se está ejecutando en la dirección http://127.0.0.1:8000/, por lo que abra un navegador Web y vaya a http://127.0.0.1:8000/hello/. Usted debe ver el texto “Hola mundo”, la salida de su vista Django. Usted hizo su primera página web en Django.

Una nota rápida sobre errores 404

En este punto, el URLconf define sólo un único patrón de URL: el que trata las solicitudes de la dirección /hello/. ¿Qué sucede cuando usted solicita una dirección URL diferente?

Usted debe ver un mensaje de “Página no encontrada”. Django muestra este mensaje porque ha solicitado una URL que no está definida en su URLconf.

La utilidad de esta página va más allá del mensaje básico de error 404. También le dice, de forma precisa que URLconf Django es usada y cada patrón utilizado en el URLconf. De esa información, usted debe ser capaz de determinar por qué la dirección URL solicitada arrojó un error 404.

Naturalmente, esta información es confidencial y está destinada únicamente a usted, el desarrollador Web. Si esto fuese un sitio de desplegado en Internet, usted no desearía exponer esa información al público. Por esta razón, esta página “Página no encontrada”, se muestra sólo si su Proyecto de Django se encuentra en modo de depuración. Le explicaremos cómo desactivar el modo de depuración más tarde. Por ahora, sólo sepa que cada proyecto Django creado se encuentra en modo de depuración, y si el proyecto no está en modo de depuración, Django emite una respuesta 404 diferente.

Una nota rápida sobre la raíz del sitio

Como se explicó en la última sección, verá un mensaje de error 404 si usted va a la raíz del sitio: http://127.0.0.1:8000/. El patrón URL para que coincida con la raíz del sitio es un poco contradictorio, por lo que es digno de mención. Cuando esté listo para poner en práctica una vista de la raíz del sitio, utilice el patrón de URL ‘^$’, que coincide con una cadena vacía. He aquí un ejemplo:

from mysite.views import hello, my_homepage_view

urlpatterns = patterns(”,

(‘^$’, my_homepage_view),

# …

)

Cómo Django procesa una petición:

1. Una petición viene a /hello/.
2. Django determina el URLconf raíz en base a ROOT_URLCONF.
3. Django busca en todos los urlpatterns del URLconf por el primero que coincida con /hello/.
4. Si encuentra una coincidencia, llama a la función de vista asociada.
5. La función de vista devuelve un HttpResponse.
6. Django convierte el HttpResponse en la respuesta HTTP apropiada, que resulta en una página web.

Ahora que conoce los aspectos básicos de cómo hacer páginas Django. Es muy sencillo, en realidad: sólo escribir funciones de vista y mapearlas a URLs a través de URLconfs.

Segunda vista: contenido dinámico

Vamos a crear algo más dinámico: una página Web que muestre la fecha y hora actuales. Este es un paso agradable y simple, porque no se trata de una base de datos o cualquier entrada de usuario, sólo la salida del reloj interno del servidor. Es sólo un poco más emocionante que “Hola mundo”, pero se muestran un par de conceptos nuevos.

Para realizar una vista Django que muestre la fecha y hora actuales, sólo es necesario colocar la sentencia datetime.datetime.now() en una vista y devolver un HttpResponse.

from django.http import HttpResponse

import datetime

def current_datetime(request):

now = datetime.datetime.now()

html = “It is now %s.” % now

return HttpResponse(html)

Al igual que con la función de vista hello, esta debe residir en views.py.  Este es el aspecto completo de views.py:

from django.http import HttpResponse

import datetime

def hello(request):

return HttpResponse(“Hello world”)

def current_datetime(request):

now = datetime.datetime.now()

html = “It is now %s.” % now

return HttpResponse(html)

Después de añadir esto a views.py, agreguar el patrón URL a urls.py para decirle a Django que URL debe manejar esta vista. Algo como /time/ tendría sentido:

from django.conf.urls.defaults import *

from mysite.views import hello, current_datetime

urlpatterns = patterns(”,

(‘^hello/$’, hello),

(‘^time/$’, current_datetime),

)

Con la vista escrita y la URLconf actualizada, arrancar el runserver y visitar http://127.0.0.1:8000/time/ en el navegador. Usted debería ver la fecha y hora actuales.

URLconfs y acoplamiento débil

Ahora es un buen momento para destacar una filosofía clave detrás de URLconfs y detrás de Django en general: el principio de acoplamiento débil.  Si dos trozos de código están débilmente acoplados, los cambios realizados a uno de ellos tendrá poco o ningún efecto en el otro.

Las URLconfs de Django son un buen ejemplo de este principio en la práctica. En una aplicación Web Django, las definiciones de URL y las funciones de vista que ellas llaman están débilmente acopladas, es decir, la decisión de lo que la URL debe ser para una determinada función y la implementación de la función residen en dos lugares diferentes. Esto le permite intercambiar una pieza sin afectar a la otra.

Por ejemplo, considere la vista del current_datetime. Si usted quiere cambiar la dirección por ejemplo, para moverla de /time/ a /current-time/ podría hacer un cambio rápido en URLconf sin tener que preocuparse por la vista. Del mismo modo, si usted quisiera cambiar la función de vista que altera la lógica de alguna manera, podría hacerlo sin afectar a la URL a la que está vinculada la función.

Además, si usted quiere exponer a la actual funcionalidad de la fecha en varias URL, usted fácilmente podría hacerlo editando URLconf, sin tener que tocar el código de la vista. En este ejemplo, el current_datetime está disponible en dos URLs. Es un ejemplo artificial, pero esta técnica puede ser útil:

urlpatterns = patterns(”,

(‘^hello/$’, hello),

(‘^time/$’, current_datetime),

(‘^another-time-page/$’, current_datetime),

)

Las URLconfs y las vistas están débilmente acopladas en la acción.

Tercera vista: URLs dinámicas

En la vista current_datetime, el contenido de la página, la fecha/hora actual, es dinámica, pero la dirección (/time/) es estática. En la mayoría de aplicaciones Web dinámicas, sin embargo, una dirección URL contiene los parámetros que influyen en la salida de la página. Por ejemplo, una librería on-line podría dar a cada libro su propia URL.

Crearemos una tercera vista que muestre la fecha y hora actuales compensada por un cierto número de horas. El objetivo es diseñar un sitio para que la página /time/plus/1/ muestre la fecha y hora dentro de una hora, la página /time/plus/2/ muestra la fecha y hora dentro de dos horas, la página /time/plus/3/ muestre la fecha y hora dentrop de tres horas, y así sucesivamente.

Un principiante podría pensar en codificar una función de vista distinta para cada desplazamiento de hora, que podría dar lugar a una URLconf como:

urlpatterns = patterns(”,

(‘^time/$’, current_datetime),

(‘^time/plus/1/$’, one_hour_ahead),

(‘^time/plus/2/$’, two_hours_ahead),

(‘^time/plus/3/$’, three_hours_ahead),

(‘^time/plus/4/$’, four_hours_ahead),

)

Entonces, ¿cómo diseñar la aplicación para manejar los desplazamiento de hora arbitrarios? La clave es usar comodines de patrones URL. Como se mencionó anteriormente, un patrón URL es una expresión regular, por lo que puede utilizar el patrón de expresión regular \d+ para que coincida con uno o más dígitos:

urlpatterns = patterns(”,

# … (r’^time/plus/\d+/$’, hours_ahead),

# …

)

Este nuevo patrón URL casará con cualquier URL como /time/plus/2/, /time/plus/25/, o incluso /time/plus/100000000000/.
Ahora, vamos a limitarlo de forma que se permita un desplazamiento máximo de 99 horas. Esto significa que queremos permitir, números de uno o de dos dígitos, y en la sintaxis de la expresión regular, que se traduce en \d(1,2):

(r’^time/plus/\d{1,2}/$’, hours_ahead),

Un detalle importante que se introduce aquí es el carácter r al principio de la expresión regular. Este caracter le dice a Python que la cadena es una “raw string” – su contenido no debe interpretar barras invertidas. En las cadenas normales de Python, las barras invertidas son usadas para caracteres de escape especiales, como la cadena ‘\n’, que es una cadena de caracteres que contiene una nueva línea.

Cuando se agrega el r para que sea una raw string, Python, no aplica el escape de la barra invertida, por lo que r’\n’ es una cadena de dos caracteres que contiene una barra invertida literal y la n minúscula. Se recomienda fuertemente que utilice raw string en cualquier momento si está definiendo una expresión regular en Python. A partir de ahora, todos los urlpatterns en este libro serán raw string.

Ahora que se ha designado un comodín para la dirección, usted necesita una manera de pasar esos datos de comodín a la función de vista, de modo que usted pueda utilizar una función de vista única para cualquier desplazamiento de hora arbitrario. Usted puede hacer esto colocando entre paréntesis los datos de la URLpattern que desea guardar. En el caso del ejemplo, lo que desea guardar es cualquier número que se introduzca en la URL, así que ponga paréntesis alrededor de \d(1,2), de esta manera:

(r’^time/plus/(\d{1,2})/$’, hours_ahead),

Usted está utilizando paréntesis para capturar datos del texto concordante. El URLconf final, incluidos los últimos dos puntos de vista, se parece a esto:

from django.conf.urls.defaults import *

from mysite.views import hello, current_datetime, hours_ahead

urlpatterns = patterns(”,

(r’^hello/$’, hello),

(r’^time/$’, current_datetime),

(r’^time/plus/(\d{1,2})/$’, hours_ahead),

)

hours_ahead es muy similar a la vista current_datetime escrita antes, con una diferencia clave: que lleva un argumento extra que el número de horas de desplazamiento. Aquí está la vista de código:

from django.http import Http404, HttpResponse

import datetime

def hours_ahead(request, offset):

try:

offset = int(offset)

except ValueError:

raise Http404()

dt = datetime.datetime.now() + datetime.timedelta(hours=offset)

html = “In %s hour(s), it will be %s.” % (offset, dt)

return HttpResponse(html)

Con esta función de vista y el URLconf escrito, iniciar el servidor de desarrollo de Django (si no está ya en ejecución), y visitar http://127.0.0.1:8000/time/plus/3/ para verificar que funciona. A continuación, intentar http://127.0.0.1:8000/time/plus/5/. Luego http://127.0.0.1:8000/time/plus/24/. Por último, visitar http://127.0.0.1:8000/time/plus/100/ para comprobar que el patrón en el URLconf acepta números sólo de uno o dos dígitos; Django debería mostrar un error de “Página no encontrada” en este caso, tal y como vimos. La URL http://127.0.0.1:8000/time/plus/ (sin horas) también debería lanzar un error 404.

Páginas de error bonitas en Python

Vamos a introducir deliberadamente un error de Python comentando en el archivo views.py las líneas offset=int(offset) en la vista de hours_ahead:

def hours_ahead(request, offset):

# try:

# offset = int(offset)

# except ValueError:

# raise Http404()

dt = datetime.datetime.now() + datetime.timedelta(hours=offset)

html = “In %s hour(s), it will be %s.” % (offset, dt)

return HttpResponse(html)

Inicie el servidor de desarrollo y vaya a /time/plus/3/. Usted verá una página de error con mucha información, incluido un mensaje TypeError que aparece en la parte superior: “unsupported type for timedelta hours component: unicode”

¿Qué pasó? Pues bien, la función de datetime.timedelta espera que el parámetro de horas que se le pase sea un número entero, y el trozo de código que convierte el desplazamiento a un número entero fue comentado. Eso provoca que datetime.timedelta lance un TypeError. Es el típico pequeño fallo que todos los programadores han cometido en algún momento.

El objetivo de este ejemplo es mostrar las páginas de error de Django. Tómese su tiempo para explorar la página de error y conocer la distinta información que ofrece.

La página de error de Django es capaz de mostrar más información en ciertos casos especiales, como el caso de errores de sintaxis de plantilla. Los veremos más tarde, cuando hablemos del sistema de plantillas de Django. Por el momento, descomente las líneas del offset = int (offset) para obtener la función de vista funcionando correctamente de nuevo.

Enlaces Relacionados:

• Tutorial de Django I
• Tutorial de Django II

En ella puede ver los distintos tipos de apartamentos disponibles, una completa galería de imágenes, planos en formato PDF, el equipamiento de cada uno de ellos, así como la situación del complejo, el entorno, las actividades de ocio a realizar y los servicios que le ofrece Grenwich S.A. para realizar todos los trámites ya sea para la compra, alquiler, o alquiler con opción a compra.

Django es un framework de desarrollo web escrito en Python con el que usted puede construir y mantener aplicaciones web de alta calidad con un mínimo de esfuerzo.

Instalar Python

Django está escrito completamente en Python, por lo que el primer paso en la instalación del marco es el asegurarse de que tiene Python instalado.

http://www.python.org/download/

Instalar Django

http://www.djangoproject.com/download/

Linux:   sudo python setup.py install
Windows:   python setup.py install

Los archivos de Django se instalarán en el directorio site-packages de su instalación de Python, en donde Python busca las bibliotecas de terceros.

Prueba de la instalación de Django

En una shell de comandos, cambie a otro directorio (no el directorio que contiene el directorio de Django) e inicie el intérprete de Python interactivo escribiendo python. Si la instalación fue exitosa, usted debe ser capaz de importar el módulo de Django:

>>> import django
>>> django.VERSION
(1, 1, 0, ‘final’, 1)

Establecer una base de datos

En este punto, usted podría comenzar a escribir una aplicación Web con Django, porque el único requisito previo es una instalación de Python. Sin embargo, es probable que desarrolle un sitio web controlado por base de datos, en cuyo caso tendrá que configurar un servidor de base de datos.

Django es compatible con cuatro motores de base de datos:

• PostgreSQL (http://www.postgresql.org/)
• SQLite 3 (http://www.sqlite.org/)
• MySQL (http://www.mysql.com/)
• Oracle (http://www.oracle.com/)

La configuración de la base de datos es un proceso de dos pasos:

1. En primer lugar, tendrá que instalar y configurar el servidor de base de datos.
2. En segundo lugar, tendrá que instalar la librería Python para nuestra base de datos de back-end. Esto es código Python de terceros que permite interactuar con la base de datos.

Uso de Django con MySQL

Django requiere MySQL 4.0 o superior. Las versiones 3.x no soportan subconsultas anidadas y algunas otras sentencias SQL estándar .

También tendrá que instalar el paquete de MySQLdb desde http://www.djangoproject.com/r/python-mysql/.
En Linux, puede comprobar si su paquete de distribución del sistema de gestión ofrece un paquete llamado python-mysql, python-MySQLdb, mysql-python, o algo similar.

Iniciar un proyecto

Una vez que haya instalado Python, Django, y (opcionalmente) el servidor/librería de base de datos, puede dar el primer paso del desarrollo de una aplicación Django mediante la creación de un proyecto.

Un proyecto es una colección de ajustes de una instancia de Django, incluyendo la configuración de la base de datos, las opciones específicas de Django, y la configuración de la aplicación.

Si es la primera vez que usa Django, usted tendrá que tener cuidado con la configuración inicial. Cree un nuevo directorio para comenzar a trabajar, tal vez algo como /home/nombre de usuario/djcode/

Vaya al directorio que ha creado y ejecute el comando siguiente:

django-admin.py startproject mysite

Esto creará un directorio mysite en el directorio actual.

El comando startproject crea un directorio que contiene cuatro archivos:

mysite/

__init__.py
manage.py
settings.py
urls.py

• __init__.py: Un archivo necesario para que Python trate el directorio mysite como un paquete (un grupo de módulos de Python). Es un fichero vacío, y normalmente no se le añade nada.
• manage.py: Utilidad de línea de comandos que le permite interactuar con el proyecto Django de diversas maneras. Con python manage.py puede tener una idea de lo que puede hacer. Usted nunca tiene que editar este archivo, sino que se crea en el directorio por pura conveniencia.
• settings.py: Características de configuración de este proyecto Django. Echele un vistazo para tener una idea de los tipos de configuraciones disponibles, junto con sus valores predeterminados.
• urls.py: Las direcciones URL de este proyecto Django. Piense en ello como la “tabla de contenidos” de su sitio Django. Por el momento, está vacío.

A pesar de su pequeño tamaño, estos archivos ya constituyen una aplicación Django de trabajo.

Ejecutar el servidor de desarrollo (runserver)

El servidor de desarrollo de Django (también llamado runserver debido al comando que lanza) es un servidor web ligero que puede utilizar durante el desarrollo de su sitio. Está incluido con Django para que pueda desarrollar su sitio rápidamente, sin tener que lidiar con la configuración del servidor de producción (Apache, por ejemplo) hasta que esté listo para la producción.

El servidor de desarrollo rastrea su código y automáticamente vuelve a cargarlo, por lo que es fácil para usted cambiar el código sin necesidad de reiniciar nada.

Para iniciar el servidor, vaya al directorio del proyecto si no lo ha hecho, y ejecute este comando:

python manage.py runserver

Esto iniciará el servidor de forma local en el puerto 8000, accesible sólo para las conexiones de su propio equipo. Ahora que está en ejecución, visite http://127.0.0.1:8000/ con su navegador Web. Verá un “Welcome to Django”  ¡Funciona!

Enlaces relacionados:

• Tutorial de Django I
• Tutorial de Django II

Zimbra le permite a su organización implementar un sistema robusto y moderno de mensajería y colaboración a un COSTO RELATIVAMENTE BAJO con respectos a otros fabricantes. Solicite una demostración a Cibernatural para descubrir las ventajas que Zimbra puede proporcionarle

Zimbra Collaboration Suite es un servidor completo de mensajería y colaboración con la tecnología mas moderna. Incluye las funcionalidades de correo electrónico, contactos, calendario, documentos, mensajería instantánea, tareas y sincronización con otras aplicaciones y dispositivos.

Zimbra proporciona lo siguiente:

• Acceso a su correo y colaboración desde cualquier navegador (Internet Explorer, Firefox, Chrome, etc).
• Extensa Administración e interfaz gráfica
• Escritorio Zimbra. Robusto cliente de correo para gestionar todos sus correos
• Acceso desde cualquier otro cliente de correo.
• Sincronizacion nativa con móviles – Blackberry / Windows Mobile / Dispositivos Symbian / J2ME / Palm.

Además de mostrar la nueva instalación y el material disponible (todo tipo de hardware Dell), donde los invitados realizaron todo tipo de preguntas relacionadas con los servicios ofertados (software y hardware), se procedió al típico cocktel de bienvenida (taperío y bebidas) que se alargó hasta altas horas de la noche.

En resumen, una velada agradable en compañía de amigos como Alejandro (las fotos son cortesía de él y el grifo de cerveza también), Leo (el de la banderita, siempre animando el cotarro), Alejandro Córdoba (sirve igual para un roto que para un descosido), Guillermo, Vicente, Alexis, Javier, David, Sergio y Julián que pasó por allí.

No me gustaría dejar de nombrar igualmente al trío sacapuntas (va con cariño): Ana, Cintia y Mercedes, así como a Alicia y Mayte, y por supuesto a Tere y a mi mujer Mariate, sin las que nada hubiera salido igual.

Les dejo unas pocas imágenes del evento en cuestión (antes de que se acabara el Ron):

• Primero, instalamos Java 6 de Sun como administradores:
  sudo apt-get install sun-java6-jdk
• Descargar la versión 2.1 de GlassFish para Ubuntu (Linux):
  wget http://download.java.net/javaee5/v2.1_branch/promoted/Linux/glassfish-installer-v2.1-b60e-linux.jar
  Tarda un poco (59 Mb)
• Realizamos la instalación:
  sudo java -Xmx256M -jar glassfish-installer-v2.1-b60e-linux.jar
• Eliminamos el instalador y movemos la instalación a un lugar más adecuado como por ejemplo /opt:
  rm glassfish-installer-v2.1-b60e-linux.jar
  sudo mv glassfish /opt
• Creamos un usuario glassfish para ejecutar el servidor de aplicaciones:
  sudo adduser –home /opt/glassfish glassfish
• Cambiar los permisos del directorio para acceder sin ser superusuario:
  sudo chown -R glassfish /opt/glassfish
  sudo chgrp -R glassfish /opt/glassfish
• Dar permiso de ejecución a los scripts de Ant:
  cd /opt/glassfish/
  sudo chmod -R +x lib/ant/bin/
• Ejecutar la configuración:
  sudo -u glassfish lib/ant/bin/ant -f setup.xml
• Iniciar un dominio:
  sudo -u glassfish bin/asadmin start-domain domain1
• Probar en un navegador si carga la página de administración de GlassFish:
  http://servidor:4848
• Entrar mediante los valores por defecto; usuario admin y clave adminadmin

Ahora veamos los pasos para que se inicie GlassFish (dominio domain1) al arrancar la máquina servidor:

• Crear el fichero /etc/init.d/glassfish como administrador de esta forma:

  #! /bin/sh
  
  GLASSFISHPATH=/opt/glassfish/bin
  
  case "$1" in
      start)
         echo "starting glassfish from $GLASSFISHPATH"
         sudo -u glassfish $GLASSFISHPATH/asadmin start-domain domain1
      ;;
      restart)
          $0 stop
  	$0 start
      ;;
      stop)
          echo "stopping glassfish from $GLASSFISHPATH"
          sudo -u glassfish $GLASSFISHPATH/asadmin stop-domain domain1
      ;;
      *)
          echo "usage: $0 {start|stop|restart}"
  	exit 3
      ;;
  esac
  

• Darle permiso de ejecución al script:
  sudo chmod a+x /etc/init.d/glassfish
• Probar el script:
  sudo /etc/init.d/glassfish restart
• Crear los scripts para el inicio automático:
  sudo update-rc.d glassfish defaults 90 10
• Reiniciar la máquina para comprobar que el servidor de aplicaciones se inicia al arrancar el servidor

Sacado de http://tuxtraining.com/2008/11/14/installing-glassfish-2-on-ubuntu-710, aunque probado y actualizado para Ubuntu Server 9.10.

En principio, están disponible en los siguientes soportes:
http://www.lanzarote-webcam.com/
http://lanzarotetouristnetwork.com/

El objetivo es obtener un conjunto de clases C++ para un problema de programación dinámica paralelo desde una fórmula matemática del problema en Latex.

Como ya se posee un generador de las clases a partir de una especificación XML del problema y la fórmula en Latex puede ser especificada también mediante XML usando MathML, se necesita un traductor que transforme el XML que especifica la fórmula (MathML) al XML que especifica la entrada al generador de clases.

Cibernatural está desarrollando en Python dicho traductor XML.

El XML de salida de nuestro traductor debe corresponder a la definición de un problema de programación dinámica paralela, que servirá como entrada a un generador de clases C++ que cree los ficheros del código fuente correspondiente al problema para ejecutarlo.

El objetivo es generar estos ficheros XML de definición del problema a partir de las fórmulas matemáticas de definición del problema en Latex. Como se pueden generar ficheros XML (MathML) a partir de fórmulas en Latex, lo que faltaría para cerrar el círculo sería un traductor del XML de la fórmula (MathML) al XML de entrada al generador de clases del problema.

Lo primero que necesitamos es el fichero XML de entrada el cual podemos obtener, por ejemplo, con TtM, un traductor de TeX a MathML, (ttmL es su versión para Linux). Una vez ejecutado, ya tenemos el MathML.

Para comenzar a traducir el XML con Python, lo primero que debemos hacer es cargar el archivo XML de entrada en memoria. Para ello, usaremos lxml, una librería de procesamiento de XML y HTML en Pyhton, y en concreto la API ElementTree.

import sys, string
from lxml import etree

Definiendo un parser XML y usando el método parse ya tenemos nuestro XML (MathML) en memoria:

parser = etree.XMLParser(load_dtd=True, no_network=False, remove_blank_text=True, ns_clean=True, resolve_entities=True)
tree = etree.parse(’problemaMathML.xml’,parser)

Podemos mostrar el fichero cargado por pantalla para comprobar que todo ha ido bien:

fsalida.write(etree.tostring(tree, pretty_print=True))

En entradas siguientes, veremos como recorrer los nodos del árbol y las acciones de procesamiento a realizar en cada uno de ellos para conseguir la traducción correcta mediante ejemplos concretos.