Mostrando entradas con la etiqueta django. Mostrar todas las entradas
Mostrando entradas con la etiqueta django. Mostrar todas las entradas

miércoles, 28 de julio de 2010

Notas. Algunos trucos de django

He encontrado algunos trucos en Stack Overflow. Pongo dos que me han gustado. El primero ya lo usaba, pero aun así lo pongo porque me parece básico. El segundo, es más bien de relleno. De los que había es el que más me gustaba. El post me vale más que nada de recordatorio. Iré échando un ojo al hilo de para ver si ponen alguno más que esté bien.

Direcciones relativas en el fichero settings.py:

import os.path
PROJECT_DIR = os.path.dirname(__file__)
...
STATIC_DOC_ROOT = os.path.join(PROJECT_DIR, "static")
...
TEMPLATE_DIRS = (
    os.path.join(PROJECT_DIR, "templates"),
)



Un decorador para los templates:

@render_to('template.html')
def foo(request):
    bar = Bar.object.all()
    return {'bar': bar}

# equals to
def foo(request):
    bar = Bar.object.all()
    return render_to_response('template.html', {'bar': bar}, context_instance=RequestContext(request))

lunes, 26 de julio de 2010

Nota: Añadiendo south a un projecto existente de django

Hace poco tiempo, miré por encima como funcionaba south, pero no lo había usado hasta ahora. Simplemente había traducido y resumido el tutorial oficial para hacer un mini tutorial, pero sin incluirlo en ningún proyecto.

Ahora se ha añadido al proyecto sobre el que estoy trabajando el módulo south y por lo tanto tenía que añadir las migraciones correspondientes a la base de datos de mi ordenador de desarrollo.

No he sido capaz de añadir south sin borrar los datos que había previamente en las tablas. Me imagino que se podrá, pero como no me ha salido a la primera y los datos que tenía, eran de prueba, simplemente me he cargado las tablas de la base de datos.

El orden que he seguido es el siguiente:

Borrar las tablas de la base de datos se las aplicaciones que vaya a gestionar South.

Eliminar las aplicaciones de INSTALLED_APPS.

Sincronizar la base de datos.

Añadimos de nuevo las aplicaciones a INSTALLED_APPS.

Creamos la primera migración de las aplicaciones que vaya a gestionar South.

python manage.py schemamigration app_name –-initial

Donde app_name es el nombre de la aplicación que gestiona South. Hay que repetir este proceso para cada aplicación que gestionemos con South.

Ahora aplicamos la migración.

python manage.py migrate app_name

A partir de este momento, cada vez que se realice un cambio en los modelos, es necesario crear una nueva migración con:

manage.py schemamigration app_name –-auto


Para aplicar los cambios realizados hay que volver a usar:


python manage.py migrate app_name

jueves, 24 de junio de 2010

Nota: Script en Django

Puede ser una buena idea, para un proyecto de django, tener scripts externos que realicen tareas concretas. Para generar estos scripts, vamos a usar la opción, que tiene django a partir de la versión 1.0, de crear subcomandos para "manage.py". Una vez creado el subcomando, para ejecutar el script, simplemente habrá que ejecutar el fichero "manage.py" pasándole como parámetro nuestro subcomando.

En la página de django, nos muestran como se crean los subcomandos.
Writing custom django-admin commands.


La metodología para crear los subcomandos es muy fácil, en el directorio de una app de django, hay que crear unos directorios y unos ficheros. El fichero que contiene el código del subcomando, tendrá el nombre del subcomando con la extensión "py". Veamos como quedaría el directorio de la app si el nombre del subcomando fuese "my_subcommand":

app/
    __init__.py
    models.py
    management/
        __init__.py
        commands/
            __init__.py
            my_subcommand.py
    tests.py
    views.py


Por los tanto los ficheros que hay que crear son:
  • management/__init__.py
  • management/commands/__init__.py
  • management/commands/my_subcommand.py

Es importante crear los ficheros __init__.py. Estos ficheros están en blanco, pero indican que los directorios son módulos de python.

En el fichero "management/commands/my_subcommand.py", es donde hay que escribir el código del subcomando.

Como ejemplo, voy a poner un subcomando de "manage.py" que muestre el texto "Hello world!".

Dentro del directorio de cualquier aplicación del proyecto, tiene que estar añadida la aplicación a INSTALLED_APPS, creamos los siguientes ficheros:

  • management/__init__.py
  • management/commands/__init__.py
  • management/commands/hello_world.py


Los ficheros __init__.py están vacíos, y en "management/commands/hello_world.py" copiamos el siguiente código.


from django.core.management.base import BaseCommand

class Command(BaseCommand):
    help = 'check unchecked votes'

    def handle(self, *args, **options):
        print "Hello world!"

Para ejecutar el script, hay que ir al directorio principal del proyecto y ejecutar en el terminal:
python manage.py hello_world


Este ejemplo es muy simple, y no usa los modelos de django, pero vale para ver como es la estructura de un subcomando. En el fichero que contiene el código del subcomando, se pueden importar los modelos como en cualquier otro fichero del proyecto.

from myproject.myapp.models import Model


Lo que nos permite generar scripts que interactúen con los modelos creados en nuestro proyecto y usar la metodología de django para trabajar con la base de datos.

Nota: Tutoriales oficiales de django

En la página web de django hay una gran variedad de tutoriales.

http://code.djangoproject.com/wiki/Tutorials

miércoles, 9 de junio de 2010

Usando path relativos para los templates de Django

En el archivo settings.py, es necesario indicar donde se encuentran los templates con su path absoluto:
TEMPLATE_DIRS = (
    # Put strings here, like "/home/html/django_templates" or "C:/www/django/templates".
    # Always use forward slashes, even on Windows.
    # Don't forget to use absolute paths, not relative paths.
)

Teniendo en cuenta que es código python, podemos hacer que esos paths se calculen a partir de paths relativos. Veamos como.


Es necesario incluir el siguiente código en el fichero settings.py
import os
PROJECT_PATH = os.path.abspath(os.path.dirname(__file__))

Una vez añadido este código al fichero, ya podemos indicar el template de forma relativa.

TEMPLATE_DIRS = (
os.path.join(PROJECT_PATH, 'templates')

)

martes, 1 de junio de 2010

Notas: Mini tutorial Django South

South permite hacer migraciones de aplicaciones Django. El principal objetivo de este mini tutorial, es mostrar como south nos proporciona una capa que nos permite cambiar los modelos en las aplicaciones django y mantener la informanción introducida anteriormente.

Página oficial del módulo:
http://south.aeracode.org/


Para instalar el módulo, yo lo he hecho, a través de easy_install.

Si no tienes instalado la herramienta de instalción, se instala con:

sudo apt-get install python-setuptools

y para instalar el módulo de south:

sudo easy_install South


Este mini tutorial, está basado en el tutorial oficial que se puede encontrar en la página de South. Es muy importante seguir el orden en que se sincroniza la base de datos. Si no se hace en el orden correcto, pueden aparecer errores.

http://south.aeracode.org/docs/tutorial/index.html


Creamos un proyecto nuevo:

django-admin startproject demosouth


Ahora, hay que configurar la base de datos que va a usar django. Yo he usado sqlite, ya que para estos ejemplos sencillos, me parece la opción más simple. (Ver como hacerlo aquí). También incluimos la applicacion 'south' en INSTALLED_APPS. He comentado el resto de aplicaciones que vienen por defecto.


A continuación se sincroniza la base de datos.

./manage.py syncdb

Ahorar creamos una aplicación sobre la que trabajar.


./manage.py startapp southtut

Editamos el fichero southtut/models.py y añadimos la siguiente clase:


class Knight(models.Model):
    name = models.CharField(max_length=100)
    of_the_round_table = models.BooleanField()



Añadimos la aplicación southtut a INSTALLES_APPS. Ahora no sincronizamos la base de datos, en vez de eso, creamos una migración,

./manage.py schemamigration southtut –-initial

y la aplicamos.

./manage.py migrate southtut

Al aplicar la migración, se ha generado la tabla correspondiente.


Para ver como no afecta los cambios en modelos de django en la la información introducida con anterioridad, es necesario que las tablas de la base de datos contengan información. Se puede hacer mediante "./manage.py shell" o directamente en la base de datos. Al haber usado sqlite, se puede usar la herramienta sqlitemanager para introducir datos en la tabla.

A continuación se va a modificar el modelo. El principal objetivo de este tutorial, es aprender a modificar un modelo de django y que los datos que estaban almacenados con anterioridad, no se pierdan. Editamos southtut/models.py.

class Knight(models.Model):
    name = models.CharField(max_length=100)
    of_the_round_table = models.BooleanField()
    dances_whenever_able = models.BooleanField()


Ahora creamos una migración nueva. Esta migración contiene las modificaciones que se han hecho en los modelos, pero todavía no se han visto reflejadas en las tablas de la base de datos.

./manage.py schemamigration southtut –-auto

y la aplicamos

./manage.py migrate southtut

Al aplicar la migración, la tabla referente al modelo que se ha cambiado reflejará dichos cambios. Si ahora comprobamos los valores de la base de datos, mediante sqlitemanager en nuestro ejemplo, vemos que se mantienen los datos que hemos introducido anteriormente, pero se ha añadido una nueva columna a la tabla.

martes, 11 de mayo de 2010

Nota Django. Crear una página de comentarios

Este post es la continuación de otros post que he realizado sobre el framework Django. En este post voy a poner un pequeño ejemplo de como se haría una página de comentarios. Creo que es bastante ilustrativo porque toca temas importantes de django. Maneja la base de datos (SQLite3 en nuestro ejemplo) a través de los modelos de django, se usan plantillas (template) con el gestor de plantillas de django, se genera una página a partir de plantillas en las cual se escriben registros almacenados en la base de datos y se leen datos de un formulario que incluye esa misma página.

Lo primero que hay que hacer es crear el proyecto de django.

django-admin startproject commentweb


Creamos una app que va a tener el modelo que gestiona los comentarios que se almacenan en la base de datos.

python manage.py startapp comments


Añadimos el modelo dentro de commentweb/commments/models.py.


from django.db import models
# Create your models here.
class Comment(models.Model):
    title = models.CharField(max_length = 20)
    date = models.DateTimeField()
    text = models.TextField(blank = True)

El modelo consta de tres campos:

  • title: título del comentario.
  • date: fecha de la publicación.
  • text: contenido del comentario.


Ahora hay que modificar el archivo settings.py

Base de datos

DATABASE_ENGINE = 'sqlite3'           # 'postgresql_psycopg2', 'postgresql', 'mysql', 'sqlite3' or 'oracle'.
DATABASE_NAME = 'comments.sqlite'             # Or path to database file if using sqlite3.
DATABASE_USER = ''             # Not used with sqlite3.
DATABASE_PASSWORD = ''         # Not used with sqlite3.
DATABASE_HOST = ''             # Set to empty string for localhost. Not used with sqlite3.
DATABASE_PORT = ''             # Set to empty string for default. Not used with sqlite3.

Zona horaria. Se puede consultar en http://en.wikipedia.org/wiki/List_of_tz_zones_by_name

TIME_ZONE = 'Europe/Madrid'

Añadimos el path donde se almacenan los templates.

TEMPLATE_DIRS = (
    # Put strings here, like "/home/html/django_templates" or "C:/www/django/templates".
    # Always use forward slashes, even on Windows.
    # Don't forget to use absolute paths, not relative paths.
    "/home/user/djangoprojects/commentweb/templates",
)


Aplicaciones disponibles. He borrado las que vienen por defecto y he añadido la que hemos creado.

INSTALLED_APPS = (
    'commentweb.comments',
)

A continuación sincronizamos la base de datos.

python manage.py syncdb


Nos inidica que hemos creado una nueva tabla

Nuestra página web va a tener dos direcciones, por lo tanto debemos editar el fichero commentweb/urls.py para añadirlas.


from django.conf.urls.defaults import *
from commentweb.comments.views import save
from commentweb.comments.views import comments

urlpatterns = patterns('',
    (r'^comments/$', comments),
    (r'^save/$', save)
)

Vamos a crear las páginas '/comments/' y '/save/'. La página '/comments/' mostrará los comentarios que hay almacenados en la base de datos. Además, tendrá un formulario que nos permita añadir nuevos comentarios. La página '/save/' almacena un comentario nuevo. Esta página se llama desde el formulario de la página anterior cuando se añade un nuevo comentario. Para gestionar estas páginas hay que crear las funciones comments y save en commentweb/comments/views.py. Pero antes, vamos a crear los templates que usan dichas funciones. En el directorio que hemos añadido anteriormente al archivo settings.py, vamos a crear el template comments.html. A continuación muestro su contenido:

< html>
    < head>
        < title>Comments< /title>
    < /head>
    < body>
        < form method="post" action="/save/">
            Title< input type="text" size="20" maxlength="20" name="title"> < br />
            < textarea name="text" rows="4" cols="40">< /textarea>< br/>
            < input type="submit" value="Comment!"/>
        < /form>
        {% for comment in comment_list %}
            < h2>{{comment.title}}< /h2>
            < p>Date: {{comment.date}}< /p>
            < p>{{comment.text}}< /p>
        {% endfor %}
    < /body>
< /html>

Nota: he dejado un espacio entre los caracteres '<' y la etiquetas para una correcta visualización en el blog. Cuando se use este fichero hay que eliminar dichos espacios.

La plantilla anterior tiene dos partes fundamentales. La primera, es un formulario que permite añadir comentarios. De este formulario es importante el nombre del textarea (name="text"), el nombre de título (name="title") y que la acción que se ejecuta al pulsar el botón "Comment!" (action="/save/") nos lleva a la página '/save/'. La segunda, es una etiqueta de plantilla for que nos muestra todos los comentarios que están almacenados en la variable comment_list. A continuación se muestra el template para la página save.html


< html>

    < head> 

        < meta http-equiv="Refresh" content="2;url=../comments/"> 

    < /head>



    < body>

        < p>Su comentario ha sido guardado. 
Por favor esperar a ser redireccionado.< /p>

    < /body>

< /html>


Nota: he dejado un espacio entre los caracteres '<' y la etiquetas para una correcta visualización en el blog. Cuando se use este fichero hay que eliminar dichos espacios. Esta plantilla es muy simple. Nos muestra un mensaje diciendo que el comentario de ha guardado y pasado 2 segundos nos redirecciona otra vez a la página comments. El proceso en el que se guarda el comentario en la base de datos se realiza en la función que invoca este template desde la vista. A continuación, vamos a ver las funciones que generan las vistas.

from commentweb.comments.models import Comment

from django.shortcuts import render_to_response

import datetime



# Create your views here.

def comments(request):

    comment_list = Comment.objects.all()

    return render_to_response('comments.html', {'comment_list': comment_list})



def save(request):

    txt = request.POST["text"]

    title = request.POST["title"]

    comment = Comment()

    comment.text = txt

    comment.date = datetime.datetime.now()

    comment.title = title

    comment.save()

    return render_to_response('save.html', None)



La funcion comment obtiente una lista de todos los comentarios que hay en la base de datos. Esta función retorna la salida de la función render_to_response que tiene dos parametros de entrada. El primero es el template con el que se crea la página. El segundo, es un diccionario que contiene los valores de las variables que hay en las plantillas. La clave del diccionario es una cadena que corresponde al nombre de la variable que usa el template ({{comment_list}} en este caso) y valor del diccionario, es el valor que la variable va a tomar durante la ejecución.


Una vez realizado esto, nuestro ejemplo ya está terminado. Para poder comprobar su funcionamiento es necesario ejecutar el servidor de pruebas que trae django.

python manage.py runserver

la dirección de nuestra nueva página es:

http://127.0.0.1:8000/comments/

Una vez realizado todos los pasos anteriores, nuestra nueva página ya nos debería permitir introducir nuevos comentarios.

lunes, 10 de mayo de 2010

Nota Django: Intro II. Hello world 2.

Este post es la continuación de Intro django I. Ahora lo que vamos a ver es como poder leer la dirección que se escribe en el navegador y usar esos datos.

Vamos a modificar el archivo urls.py y el archivo views.py para que cuando se escriba la dirección en el navegador, podamos leer los datos introducidos. Es necesario crear una nueva página, por lo que es necesario modificar el archivo urls.py y crear una nueva vista.

Vamos a crear la página http://127.0.0.1:8000/say/xxx. Donde 'xxx' es cualquier combinación de entre uno y veinte caracteres de logitud. Esta página mostrará el texto introducido ('xxx').

Añadimos la nueva vista.

vi views.py

Editamos el archivo para que quede de la siguiente manera.

# Create your views here.
from helloweb.textapp.models import Textmodel
from django.http import HttpResponse


def say_hello(request):
    text = Textmodel.objects.get(pk = 1)
    html = "%s" % text.content
    return HttpResponse(html)
 

def say(request, txt): 
    html = "%s" % txt 
    return HttpResponse(html) 

Ahora vamos a editar el fichero helloweb/urls.py para que se pueda interpretar la nueva dirección.

vi urls.py

Añadimos la nueva dirección a urlpatterns.

from django.conf.urls.defaults import * 
from helloweb.textapp.views import say_hello 
from helloweb.textapp.views import say 

# Uncomment the next two lines to enable the admin: 
# from django.contrib import admin 
# admin.autodiscover() 

urlpatterns = patterns('', 
    # (r'^admin/', include(admin.site.urls)), 
    (r'^hello/$', say_hello), 
    (r'^say/([a-z]{1,20})/$', say) 
) 

La expresión [a-z]{1,20} hace referencia a cualquier cadena de caracteres entre la a y la z (sólo minúsculas) con una longitud de entre 1 y 20 caracteres. Para más información sobre las expresiones regulares (o regexes). Enlace: http://docs.python.org/library/re.html#re-syntax

Una vez modificados los archivos, ejecutamos el servidor de pruebas que trae django.

python manage.py runserver


Ponemos la siguiente dirección en el navegador para comprobar que todo funciona.

http://127.0.0.1:8000/say/hello

El navegador nos debe mostrar el texto 'hello' en el contenido de la página. Podemos cambiar el texto 'hello' en la barra de direcciones por cualquier otro texto de entre uno y veinte caracteres en minúsculas, y esa nueva cadena es la que aparecerá en el contenido de la página.



Plantillas de Django

En el ejemplo anterior, el html se generó directamente con python. Esto no es muy conveniente y que el diseño de la página está empotrada en su programación. Lo adecuado es hacerlo de forma separada. Django tiene un sistema de plantillas (templates) que permite separar la parte de programción en django y la parte de diseño web.

A continuación vamos a modificar la función say, para que en vez de escrbir directamente el html, se extaraiga de una plantilla y los datos que queramos introducir en la página, los proporcione django.

Lo primero que hay que hacer es crear una plantilla. La voy a guardar como helloweb/templates/say_template.html

vi template.html

Añadir el siguiente código html al archivo:

 < html >
    < head >
        < title >Say page!!!< /title >
    < /head >
    < body >

        < h1 >Say page.< /h1 >
        < p >you say: {{ text }}.< /p >
    < /body >
< /html >

He dejado espacio entre las etiquetas html para que se vea correctamente en el blog pero en nuestro ejemplo no hay que dejar espacios entre los caracteres '<', '>' y las etiquetas.

El texto {{ text }} es una variable, y por lo tanto, este texto se reemplazará por un valor durante la ejecución.

A la hora de usar un template en django dentro de un proyecto, es necesario añadir el path donde se encuentra el template al fichero helloweb/settings.py. Las rutas hay que ponerlas de forma absoluta, es decir, partiendo de '/'. A continuación pongo lo que hay que variar en el archivo settings.py para añadir un directorio de templates.

TEMPLATE_DIRS = (
    # Put strings here, like "/home/html/django_templates" or "C:/www/django/templates".
    # Always use forward slashes, even on Windows.
    # Don't forget to use absolute paths, not relative paths.
    '/home/user/djangoprojects/helloweb/templates',
)

Nota: Es importante poner la coma al final de la cadena, ya que es una tupla.

Una vez hecho esto ya se han añadido los templates que estén en ese directorio al proyecto.


A continuación hay que modificar la función say del archivo helloweb/textapp/views.py para leer el template y añadir a dicho template las variables deseadas.


vi views.py

Modificamos la función say e importamos los módulos necesarios. Pongo el fichero views.py entero con las modificaciones necesarias para el uso del template.

# Create your views here.
from helloweb.textapp.models import Textmodel
from django.http import HttpResponse
from django.template.loader import get_template
from django import template

def say_hello(request):
    text = Textmodel.objects.get(pk = 1)
    html = "%s" % text.content
    return HttpResponse(html)

def say(request, txt):
    t = get_template('say_template.html')
    c = template.Context({'text': txt})
    html = t.render(c)
    return HttpResponse(html)

En la funcion say, hemos creado el template 't' a partir de la plantilla 'say_template.html'. Este fichero tiene que estar en el directorio que hemos añadido a settings.py. Después, se ha creado el contexto 'c' que contine el diccionario con la variable 'text', a la cual le daremos el valor de la variable 'txt' durante la ejecución.

Al poner la dirección http://127.0.0.1:8000/say/hello en el navegador, nos mostrará el contenido de la plantilla pero con el valor actual de la variable {{text}}, es decrir 'hello'.

jueves, 6 de mayo de 2010

Nota Django: Screencast. Crear una Wiki en 20 min

Screencast de django.
En este ejemplo, Siddhi nos muestra como crear una wiki con django en 20 minutos.
http://showmedo.com/videotutorials/video?name=1100000&fromSeriesID=110