Hace unos días Google lanzó Google App Engine. Me ahorro detalles que ya se han comentado en otros sitios.
El video de abajo muestra una aplicación sencilla. (No es ninguna novedad, lo saqué de la página de Google App Engine.) El framework, en este caso, no es Django (sí usa los templates de Django), pero a los que hayan programado con Django el código les resultará algo familiar.
django
Free the Dragon!
Hace unos días ActiveState ha sacado una versión open source de Komodo Edit, bajo los mismos términos que la licencia de Firefox. Esta decisión tiene sentido, pues Komodo Edit comparte parte del código fuente base de Mozilla.
Desde hace años, ActiveState desarrolla herramientas para programar en Perl, Python, PHP, Ruby y otros. También aloja varios “Cookbooks” (recetarios) en su website, por ejemplo, el imprescindible Python Cookbook.
Hay versiones para Linux, MacOs y Windows, y se puede descargar del website de ActiveState.
Using dynamic choices with Django newforms and custom widgets
Note: This post is more than 10 years old. The solutions proposed below most certainly don’t work with current Django versions.
Most of the examples I have found on the web about replacing the default Django
newforms
widgets use hard coded values for the list of choices the widget displays. But those hard coded examples fall short when the widgets are bounded to many-to-many fields or to foreign keys in the model class. That is, when the list of choices is generated dynamically at run time, read from a database table.
Maybe the explanation is “over-verbose”… suggestions accepted.
Don’t hit the database twice
Consider the following model class:
# models.py Models for django blog application
from django.db import models
class Tag(models.Model):
tag = models.CharField(maxlength=50)
class Author(models.Model):
name = models.CharField(maxlength=100)
email = models.EmailField()
class Article(models.Model):
(...)
author = models.ForeignKey(Author)
tags = models.ManyToManyField(Tag)
The standard method for displaying a form for the model class in a webpage is to subclass forms.Form, create an instance of the subclass and return the rendered the template. Examples of this can be found on the Django website and on the web.
# ArticleForm is a subclass of form.Form
ArticleForm = forms.models.form_for_model(Article)
The next step is to create an instance of
ArticleForm
, and return the rendered template:
form = ArticleForm()
return render_to_response('post.html', { 'form': form })
I don’t like lists for multiple option selection, at least not in webpages. I prefer checkboxes. It takes some CSS tweaking to render them correctly and evenly spaced on the webpage, but it greatly enhances the user experience.
The class generated by form_for_model (and by form_for_instance) stores the widgets in a variable named
base_fields
(a dictionary). This makes it simple to replace any of the default widgets with any other widget, provided it makes sense to do so. For example, the following code replaces the
author
and
tags
widgets with a RadioSelect widget and a CheckboxSelectMultiple widget:
ArticleForm.base_fields['tags'].widget = CheckboxSelectMultiple(choices= ... )
ArticleForm.base_fields['author'].widget = RadioSelect(choices= ... )
The only thing left is to provide the list of choices that both
CheckboxSelectMultiple
and
RadioSelect
constructors expect as one of their parameters. One way to build such lists is to query the database and fetch the entries for the Tag and Author classes. Something like
tagChoices = Tag.objects.all()
and
authorChoices = Author.objects.all()
. Convert the resulting queryset to a dictionary and use it as a parameter to the RadioSelect widget constructor.
ArticleForm = forms.models.form_for_model(Article)
ArticleForm.base_fields['tags'].widget = CheckboxSelectMultiple(
choices=ArticleForm.base_fields['tags'].choices)
ArticleForm.base_fields['author'].widget = RadioSelect(
choices=ArticleForm.base_fields['author'].choices)
form = ArticleForm()
return render_to_response('post.html', { 'form': form })
That’s it. The Author SelectField gets replaced by radio buttons, and the Tag MultipleSelectField by some nice checkboxes. The database gets hit only once. Nothing to be ashamed of.
A complete example
Updated 2007-5-5: added editpost.html, which was not included by mistake.
The following is a test blog application I wrote. It uses
form_for_instance
and
form_for_model
to define the proper subclass of form, then replaces the standard widgets with custom ones. The widgets load the Author and Tags choices dynamically. In addition, creation and edition of the blog posts are handled by the same method. A regular expression in
urls.py
converts web page names to slugs as registered in the database, so permalinks are effectively implemented.
Some screenshots of the Django mini-blog
This is pretty spartan. Throw in some CSS if you like.
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd>
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<title>{% block pagetitle %}Page title{% endblock %}</title>
<link rel="stylesheet" href="" type="text/css" media="screen" />
{% block head %}
{% endblock %}
</head>
<body>
{% block body %}
{% endblock %}
</body>
</html>
{% extends "base.html" %}
{% block title %}
A minimal blog, powered by Django
{% endblock %}
{% block body %}
<h2>Hello, world!</h2>
<ul>
<li><a href="./add">Write new post</a></li>
</ul>
{% for post in posts %}
<div class="post">
<h2><a href="./{{ post.slug }}.html" title="{{ post.title }}">
{{ post.title }}</a></h2>
<div class="postmeta">
<div class="postdate">{{ post.pub_date }}</div>
<div class="posttags">
Tags:
{% for tag in post.tags.all %}
{{ tag.tag }},
{% endfor %}
</div>
<div class="postauthor">
By {{ post.author }}.
</div>
</div><!-- end postmeta -->
<a href="./edit/{{ post.id }}">Edit post</a>
<div class="postcontent">
{{ post.content }}
</div>
</div>
{% endfor %}
{% endblock %}
{% extends "base.html" %}
{% block title %}
Add post
{% endblock %}
{% block body %}
<h2>Write a post</h2>
<form method="POST" action=".">
{{ form.as_p }}
<input type="submit" value="submit" />
</form>
{% endblock %}
models.py
# Models for django blog application
from django.db import models
class Tag(models.Model):
tag = models.CharField(maxlength=50) # tagname
def __str__(self):
return self.tag
class Admin:
pass
class Author(models.Model):
name = models.CharField(maxlength=100)
email = models.EmailField()
def __str__(self):
return self.name
class Admin:
pass
class Article(models.Model):
title = models.CharField(maxlength=250)
slug = models.CharField(maxlength=250)
content = models.TextField()
author = models.ForeignKey(Author)
pub_date = models.DateTimeField('date published')
mod_date = models.DateTimeField('date modified')
tags = models.ManyToManyField(Tag)
def __str__(self):
return self.title
class Admin:
pass
url.py
from django.conf.urls.defaults import *
urlpatterns = patterns('',
# Example:
# (r'^djangotest/', include('djangotest.foo.urls')),
(r'^blog/views.py
# views.py
from django.http import HttpResponse, HttpResponseRedirect
from django.template import Context, loader
from django.shortcuts import render_to_response, get_list_or_404
from django import newforms as forms
from django.newforms.widgets import *
from djangotest.blog.models import *
def index(request):
""" Display last 5 articles """
last_five = Article.objects.all().order_by('-pub_date')[:5]
t = loader.get_template('blog/index.html')
c = Context({
'posts' : last_five,
})
return HttpResponse(t.render(c))
def single(request, slug):
# handle page not found
articles = get_list_or_404(Article, slug__exact=slug)
return render_to_response('blog/index.html', { 'posts':articles })
def edit(request, post_id=None):
if post_id is None:
# no id, user is creating new post
ArticleForm = forms.models.form_for_model(Article)
else:
# editing or updating post
try:
article = Article.objects.get(id=post_id)
except Article.DoesNotExist:
HttpResponseRedirect('blog/postdoesnotexist.html')
ArticleForm = forms.models.form_for_instance(article)
# we need to feed the new widget with the choices from the
ArticleForm.base_fields['tags'].widget = CheckboxSelectMultiple(
choices=ArticleForm.base_fields['tags'].choices)
ArticleForm.base_fields['author'].widget = RadioSelect(
choices=ArticleForm.base_fields['author'].choices)
if request.method == 'POST':
# form has been submited (i.e., new post or old post update)
form = ArticleForm(request.POST)
if form.is_valid():
form.save()
return HttpResponseRedirect('/blog')
else:
# empty form
form = ArticleForm()
return render_to_response('blog/editpost.html', { 'form': form })
References
-
- The following pages were of great help in understanding the newforms library better:
- The Django documentation for newforms. (Still work in progress.)
- How to use the model specified defaults as the default values for fields, and how to make the help_text entries available in the fields for rendering.
, 'djangotest.blog.views.index'), # regex for slugs. Note that the regex matches even (r'^blog/(?P<slug>((\w+|-)*))(\.html)\/?views.py
References
-
- The following pages were of great help in understanding the newforms library better:
- The Django documentation for newforms. (Still work in progress.)
- How to use the model specified defaults as the default values for fields, and how to make the help_text entries available in the fields for rendering.
, 'djangotest.blog.views.single'), # edit post (r'^blog/edit/(?P<post_id>\d+)/views.py
References
-
- The following pages were of great help in understanding the newforms library better:
- The Django documentation for newforms. (Still work in progress.)
- How to use the model specified defaults as the default values for fields, and how to make the help_text entries available in the fields for rendering.
, 'djangotest.blog.views.edit'), # add new post (r'^blog/add/views.py
References
-
- The following pages were of great help in understanding the newforms library better:
- The Django documentation for newforms. (Still work in progress.)
- How to use the model specified defaults as the default values for fields, and how to make the help_text entries available in the fields for rendering.
, 'djangotest.blog.views.edit'), # Uncomment this for admin: (r'^admin/', include('django.contrib.admin.urls')), ) views.py
References
-
- The following pages were of great help in understanding the newforms library better:
- The Django documentation for newforms. (Still work in progress.)
- How to use the model specified defaults as the default values for fields, and how to make the help_text entries available in the fields for rendering.
Iterating over items of selection fields in django templates using newforms
A year ago I wrote a custom CheckboxSelectMultiple control for django. My application needed to display a series of checkboxes on the webpage, but the default django control did not allow iteration over each checkbox when the control was rendered in the template (as it was possible with the RadioSelect control). This finer control was necessary because I needed to insert extra HTML between each checkbox.
As of version 0.95, django has been under heavy changes, and my custom control no longer works. In particular, the old forms module is being discarded in favor of the newforms module that will become the default forms module sometime in the future. A good explanation can be found in the on-site django documentation, under newforms-migration plan.
The good news is that newforms allows access to individual items of the form fields, multiple-select fields included. The newforms documentation is still work in progress, so it took me a while to figure out how to do it… by inspecting the source code and regression tests. It seems pretty obvious now, should have asked in the django-users list.
The example code has been tested with django svn release 4812 (2007-3-23).
template
<ul>
{% for choice in form.base_fields.tag.choices %}
<li> ({{ choice.0 }}, {{ choice.1 }}) </li>
{% endfor %}
</ul>
models.py
# models.py
from django.db import models
class Tag(models.Model):
tag = models.CharField(maxlength=20)
def __str__(self):
return self.tag
class Post(models.Model):
# other fields here:
# text = models.CharField(maxlength=255)
# title = models.CharField(maxlength=50)
# etc.
tag = models.ManyToManyField(Tag)
views.py
# views.py
from django.template import Context, loader
from django.http import HttpResponse, HttpResponseRedirect
from django import newforms as forms
from django.newforms.widgets import *
from project.models import *
def add_post(request):
postForm = forms.models.form_for_model(Post)
if request.method == 'POST':
form = postForm(request.POST)
if form.is_valid():
form.save()
return HttpResponseRedirect("/")
else:
form = postForm()
t = loader.get_template('add_post.html')
c = Context({
'form': form,
})
return HttpResponse(t.render(c))
This is an old version of
views.py
. The code works, but as I discovered later, there is no need to create another object (
p = Post(**cleandata)
) to handle the many-to-many field data. form.save() takes care of everything, as expected.
# views.py
from django.template import Context, loader
from django.http import HttpResponse, HttpResponseRedirect
from django import newforms as forms
from django.newforms.widgets import *
from project.models import *
def add_post(request):
postForm = forms.models.form_for_model(Post)
if request.method == 'POST':
form = postForm(request.POST)
if form.is_valid():
cleandata = form.clean_data
# use the form tag ids to select the Tag instances
# related to this Post entry
tag = Tag.objects.in_bulk(cleandata['tag'])
# need to delete the tag ids from clean data,
# otherwise p = Post(** cleandata) will complain that
# tag is not a parameter of Post( )
del cleandata['tag']
# create an instance of Post from the form data
p = Post(**cleandata)
p.save() # need to save so p gets an id.
p.tag = tag
p.save()
return HttpResponseRedirect("/")
else:
form = postForm()
t = loader.get_template('add_post.html')
c = Context({
'form': form,
})
return HttpResponse(t.render(c))
Django and Custom CheckboxSelectMultipleField
Note: as of Django version 0.95, this solution no longer works. But thanks to the newforms module, it is no longer necessary. Explanation of how it works can be found in this post
The problem: I have been using Django in a project for some weeks. The application needs to display a series of checkboxes on the webpage, but the HTML rendering of the formfields.CheckboxSelectMultipleField class does not offer the precise placement of each checkbox that is needed on the webpage.
formfields.CheckboxSelectMultipleField is a descendant of SelectMultipleField and does not provide the ability to iterate through each of the possible choices, as formfields.RadioSelectField derived objects do:
<!-- choices is an formfields.RadioSelectField object
This is not possible with formfields.CheckboxSelectMultipleField derived objects.
-->
<div class="form-row">
<table><tr>
{% for i in form.choices.field_list %}
<td>;{{ i.field }}</td><td>{{i.name}}</td>
{% endfor %}
</tr>
</table>
</div>
The Solution: a custom CheckboxesMultipleSelectField based on the code from formfields.RadioSelectField.
CustomCheckboxSelectMultipleField is intended to be used in a custom Manipulator.
The code for the custom CheckboxSelectMultiple
from django.core import formfields
class CustomCheckboxSelectMultipleField(formfields.FormField):
def __init__(self, field_name, choices=[], ul_class='', is_required=False, validator_list=[], member_name=None):
self.field_name = field_name
# choices is a list of (value, human-readable key) tuples because order matters
self.choices, self.is_required = choices, is_required
self.validator_list = [self.isValidChoice] + validator_list
self.ul_class = ul_class
if member_name != None:
self.member_name = member_name
def render(self, data):
"""
Returns a special object that is iterable *and*
has a default str() rendered output.
This allows for flexible use in templates. You can just use the default
rendering:
{{ field_name }}
...which will output the radio buttons in an unordered list.
Or, you can manually traverse each radio option for special layout:
{% for option in field_name.field_list %}
{{ option.field }} {{ option.label }}<br />
{% endfor %}
"""
class CustomCheckBoxSelectMultipleRenderer:
def __init__(self, datalist, ul_class):
self.datalist, self.ul_class = datalist, ul_class
def __str__(self):
"Default str() output for this radio field -- a <ul>"
output = ['</ul><ul %s>' % (self.ul_class and ' class="%s"' % self.ul_class or '')]
output.extend(['<li>%s %s</li>' % (d['field'], d['label']) for d in self.datalist])
output.append('</ul>')
return ''.join(output)
def __iter__(self):
for d in self.datalist:
yield d
def __len__(self):
return len(self.datalist)
datalist = []
str_data_list = map(str, data) # normalize to string
for i, (value, display_name) in enumerate(self.choices):
checked_html = ''
if str(value) in str_data_list:
checked_html = 'checked="checked"'
datalist.append({
'value': value, 'checked': checked_html,
'name': display_name,
'field': '<input type="checkbox" id="%s" name="%s" value="%s"%s/>' % \
(self.get_id() + '_' + str(i), self.field_name, value, checked_html),
'label': '<label for="%s">%s</label>' % \
(self.get_id() + '_' + str(i), display_name),
})
return CustomCheckBoxSelectMultipleRenderer(datalist, self.ul_class)
def isValidChoice(self, data, form):
str_data = str(data)
str_choices = [str(item[0]) for item in self.choices]
if str_data not in str_choices:
raise validators.ValidationError, _("Select a valid choice; '%(data)s' is not in %(choices)s.") % {'data':str_data, 'choices':str_choices}