per-object-permissions: Merged to trunk [4241]

git-svn-id: http://code.djangoproject.com/svn/django/branches/per-object-permissions@4242 bcc190cf-cafb-0310-a4f2-bffc1f526a37

64 files changed, 4053 insertions, 1532 deletions

diff --git a/AUTHORS b/AUTHORS
index f49210d303..645913e7c4 100644
--- a/AUTHORS
+++ b/AUTHORS
@@ -118,10 +118,12 @@ answer newbie questions, and generally made Django that much better:
     Manuzhai
     Petar Marić
     mark@junklight.com
+    Yasushi Masuda <whosaysni@gmail.com>
     mattycakes@gmail.com
     Jason McBrayer <http://www.carcosa.net/jason/>
     mccutchen@gmail.com
     michael.mcewan@gmail.com
+    mitakummaa@gmail.com
     mmarshall
     Eric Moritz <http://eric.themoritzfamily.com/>
     Robin Munn <http://www.geekforgod.com/>
@@ -151,6 +153,7 @@ answer newbie questions, and generally made Django that much better:
     SmileyChris <smileychris@gmail.com>
     sopel
     Thomas Steinacher <tom@eggdrop.ch>
+    nowell strite
     Radek Švarz <http://www.svarz.cz/translate/>
     Swaroop C H <http://www.swaroopch.info>
     Aaron Swartz <http://www.aaronsw.com/>
@@ -159,6 +162,7 @@ answer newbie questions, and generally made Django that much better:
     Tom Insam
     Joe Topjian <http://joe.terrarum.net/geek/code/python/django/>
     Karen Tracey <graybark@bellsouth.net>
+    Makoto Tsuyuki <mtsuyuki@gmail.com>
     Amit Upadhyay
     Geert Vanderkelen
     Milton Waddams
diff --git a/django/conf/global_settings.py b/django/conf/global_settings.py
index 36fee9ec6d..245096590d 100644
--- a/django/conf/global_settings.py
+++ b/django/conf/global_settings.py
@@ -25,7 +25,7 @@ ADMINS = ()
 INTERNAL_IPS = ()
 
 # Local time zone for this installation. All choices can be found here:
-# http://www.postgresql.org/docs/current/static/datetime-keywords.html#DATETIME-TIMEZONE-SET-TABLE
+# http://www.postgresql.org/docs/8.1/static/datetime-keywords.html#DATETIME-TIMEZONE-SET-TABLE
 TIME_ZONE = 'America/Chicago'
 
 # Language code for this installation. All choices can be found here:
diff --git a/django/conf/project_template/settings.py b/django/conf/project_template/settings.py
index d6f34a28db..a44bc172f0 100644
--- a/django/conf/project_template/settings.py
+++ b/django/conf/project_template/settings.py
@@ -17,7 +17,7 @@ DATABASE_HOST = ''             # Set to empty string for localhost. Not used wit
 DATABASE_PORT = ''             # Set to empty string for default. Not used with sqlite3.
 
 # Local time zone for this installation. All choices can be found here:
-# http://www.postgresql.org/docs/current/static/datetime-keywords.html#DATETIME-TIMEZONE-SET-TABLE
+# http://www.postgresql.org/docs/8.1/static/datetime-keywords.html#DATETIME-TIMEZONE-SET-TABLE
 TIME_ZONE = 'America/Chicago'
 
 # Language code for this installation. All choices can be found here:
diff --git a/django/conf/project_template/urls.py b/django/conf/project_template/urls.py
index 4483014173..402dd6536b 100644
--- a/django/conf/project_template/urls.py
+++ b/django/conf/project_template/urls.py
@@ -2,7 +2,7 @@ from django.conf.urls.defaults import *
 
 urlpatterns = patterns('',
     # Example:
-    # (r'^{{ project_name }}/', include('{{ project_name }}.apps.foo.urls.foo')),
+    # (r'^{{ project_name }}/', include('{{ project_name }}.foo.urls')),
 
     # Uncomment this for admin:
 #     (r'^admin/', include('django.contrib.admin.urls')),
diff --git a/django/contrib/admin/templates/admin/base.html b/django/contrib/admin/templates/admin/base.html
index b63604b268..d3e8c96b91 100644
--- a/django/contrib/admin/templates/admin/base.html
+++ b/django/contrib/admin/templates/admin/base.html
@@ -38,7 +38,10 @@
     <div id="content" class="{% block coltype %}colM{% endblock %}">
         {% block pretitle %}{% endblock %}
         {% block content_title %}{% if title %}<h1>{{ title|escape }}</h1>{% endif %}{% endblock %}
-        {% block content %}{{ content }}{% endblock %}
+        {% block content %}
+        {% block object-tools %}{% endblock %}
+        {{ content }}
+        {% endblock %}
         {% block sidebar %}{% endblock %}
         <br class="clear" />
     </div>
diff --git a/django/contrib/admin/templates/admin/change_form.html b/django/contrib/admin/templates/admin/change_form.html
index 02d05f9ad5..71a4df03e1 100644
--- a/django/contrib/admin/templates/admin/change_form.html
+++ b/django/contrib/admin/templates/admin/change_form.html
@@ -16,12 +16,14 @@
 </div>
 {% endif %}{% endblock %}
 {% block content %}<div id="content-main">
+{% block object-tools %}
 {% if change %}{% if not is_popup %}
   <ul class="object-tools"><li><a href="history/" class="historylink">{% trans "History" %}</a></li>
   {% if object_has_row_level_permissions and has_row_level_permissions %}<li><a href="row_level_permissions/" class="rowlevelpermissions">{% trans "Edit Row Level Permissions" %}</a></li>{% endif %}
   {% if has_absolute_url %}<li><a href="../../../r/{{ content_type_id }}/{{ object_id }}/" class="viewsitelink">{% trans "View on site" %}</a></li>{% endif%}
   </ul>
 {% endif %}{% endif %}
+{% endblock %}
 <form {% if has_file_field %}enctype="multipart/form-data" {% endif %}action="{{ form_url }}" method="post" id="{{ opts.module_name }}_form">{% block form_top %}{% endblock %}
 <div>
 {% if is_popup %}<input type="hidden" name="_popup" value="1" />{% endif %}
diff --git a/django/contrib/admin/templates/admin/change_list.html b/django/contrib/admin/templates/admin/change_list.html
index bd2304bd52..f50a73c934 100644
--- a/django/contrib/admin/templates/admin/change_list.html
+++ b/django/contrib/admin/templates/admin/change_list.html
@@ -7,9 +7,11 @@
 {% block coltype %}flex{% endblock %}
 {% block content %}
 <div id="content-main">
+{% block object-tools %}
 {% if has_add_permission %}
 <ul class="object-tools"><li><a href="add/{% if is_popup %}?_popup=1{% endif %}" class="addlink">{% blocktrans with cl.opts.verbose_name|escape as name %}Add {{ name }}{% endblocktrans %}</a></li></ul>
 {% endif %}
+{% endblock %}
 <div class="module{% if cl.has_filters %} filtered{% endif %}" id="changelist">
 {% block search %}{% search_form cl %}{% endblock %}
 {% block date_hierarchy %}{% date_hierarchy cl %}{% endblock %}
diff --git a/django/contrib/admin/templates/admin/search_form.html b/django/contrib/admin/templates/admin/search_form.html
index d9126c3ec5..445cca3089 100644
--- a/django/contrib/admin/templates/admin/search_form.html
+++ b/django/contrib/admin/templates/admin/search_form.html
@@ -7,7 +7,7 @@
 <input type="text" size="40" name="{{ search_var }}" value="{{ cl.query|escape }}" id="searchbar" />
 <input type="submit" value="{% trans 'Go' %}" />
 {% if show_result_count %}
-    <span class="small quiet">{% blocktrans count cl.result_count as counter %}1 result{% plural %}{{ counter }} results{% endblocktrans %} (<a href="?">{% blocktrans with cl.full_result_count as full_result_count %}{{ full_result_count }} total{% endblocktrans %}</a>)</span>
+    <span class="small quiet">{% blocktrans count cl.result_count as counter %}1 result{% plural %}{{ counter }} results{% endblocktrans %} (<a href="?{% if cl.is_popup %}pop=1{% endif %}">{% blocktrans with cl.full_result_count as full_result_count %}{{ full_result_count }} total{% endblocktrans %}</a>)</span>
 {% endif %}
 {% for pair in cl.params.items %}
     {% ifnotequal pair.0 search_var %}<input type="hidden" name="{{ pair.0|escape }}" value="{{ pair.1|escape }}"/>{% endifnotequal %}
diff --git a/django/contrib/admin/views/auth.py b/django/contrib/admin/views/auth.py
index 06e469e5d2..52bf3bcde8 100644
--- a/django/contrib/admin/views/auth.py
+++ b/django/contrib/admin/views/auth.py
@@ -2,7 +2,7 @@ from django.contrib.admin.views.decorators import staff_member_required
 from django.contrib.auth.forms import UserCreationForm
 from django.contrib.auth.models import User
 from django.core.exceptions import PermissionDenied
-from django import forms, template
+from django import oldforms, template
 from django.shortcuts import render_to_response
 from django.http import HttpResponseRedirect
 
@@ -24,7 +24,7 @@ def user_add_stage(request):
                 return HttpResponseRedirect('../%s/' % new_user.id)
     else:
         errors = new_data = {}
-    form = forms.FormWrapper(manipulator, new_data, errors)
+    form = oldforms.FormWrapper(manipulator, new_data, errors)
     return render_to_response('admin/auth/user/add_form.html', {
         'title': _('Add user'),
         'form': form,
diff --git a/django/contrib/admin/views/main.py b/django/contrib/admin/views/main.py
index e0cfb169e0..aa8b35bb96 100644
--- a/django/contrib/admin/views/main.py
+++ b/django/contrib/admin/views/main.py
@@ -1,4 +1,4 @@
-from django import forms, template
+from django import oldforms, template
 from django.conf import settings
 from django.contrib.admin.filterspecs import FilterSpec
 from django.contrib.admin.views.decorators import staff_member_required
@@ -227,7 +227,7 @@ index = staff_member_required(never_cache(index))
 def add_stage(request, app_label, model_name, show_delete=False, form_url='', post_url=None, post_url_continue='../%s/', object_id_override=None):
     model = models.get_model(app_label, model_name)
     if model is None:
-        raise Http404, "App %r, model %r, not found" % (app_label, model_name)
+        raise Http404("App %r, model %r, not found" % (app_label, model_name))
     opts = model._meta
 
     if not request.user.has_perm(app_label + '.' + opts.get_add_permission()):
@@ -299,7 +299,7 @@ def add_stage(request, app_label, model_name, show_delete=False, form_url='', po
         errors = {}
 
     # Populate the FormWrapper.
-    form = forms.FormWrapper(manipulator, new_data, errors)
+    form = oldforms.FormWrapper(manipulator, new_data, errors)
 
     c = template.RequestContext(request, {
         'title': _('Add %s') % opts.verbose_name,
@@ -318,13 +318,13 @@ def change_stage(request, app_label, model_name, object_id):
     model = models.get_model(app_label, model_name)
     object_id = unquote(object_id)
     if model is None:
-        raise Http404, "App %r, model %r, not found" % (app_label, model_name)
+        raise Http404("App %r, model %r, not found" % (app_label, model_name))
     opts = model._meta
 
     try:
         manipulator = model.ChangeManipulator(object_id)
     except ObjectDoesNotExist:
-        raise Http404
+        raise Http404('%s object with primary key %r does not exist' % (model_name, escape(object_id)))
 
     if not request.user.has_perm(app_label + '.' + opts.get_change_permission(), object=manipulator.original_object):
         raise PermissionDenied
@@ -332,8 +332,6 @@ def change_stage(request, app_label, model_name, object_id):
     if request.POST and request.POST.has_key("_saveasnew"):
         return add_stage(request, app_label, model_name, form_url='../../add/')
 
-
-
     if request.POST:
         new_data = request.POST.copy()
 
@@ -400,7 +398,7 @@ def change_stage(request, app_label, model_name, object_id):
         errors = {}
 
     # Populate the FormWrapper.
-    form = forms.FormWrapper(manipulator, new_data, errors)
+    form = oldforms.FormWrapper(manipulator, new_data, errors)
     form.original = manipulator.original_object
     form.order_objects = []
 
@@ -519,7 +517,7 @@ def delete_stage(request, app_label, model_name, object_id):
     model = models.get_model(app_label, model_name)
     object_id = unquote(object_id)
     if model is None:
-        raise Http404, "App %r, model %r, not found" % (app_label, model_name)
+        raise Http404("App %r, model %r, not found" % (app_label, model_name))
     opts = model._meta
 
     obj = get_object_or_404(model, pk=object_id)
@@ -558,7 +556,7 @@ def history(request, app_label, model_name, object_id):
     model = models.get_model(app_label, model_name)
     object_id = unquote(object_id)
     if model is None:
-        raise Http404, "App %r, model %r, not found" % (app_label, model_name)
+        raise Http404("App %r, model %r, not found" % (app_label, model_name))
     action_list = LogEntry.objects.filter(object_id=object_id,
         content_type__id__exact=ContentType.objects.get_for_model(model).id).select_related().order_by('action_time')
     # If no history was found, see whether this object even exists.
@@ -788,7 +786,7 @@ class ChangeList(object):
 def change_list(request, app_label, model_name):
     model = models.get_model(app_label, model_name)
     if model is None:
-        raise Http404, "App %r, model %r, not found" % (app_label, model_name)
+        raise Http404("App %r, model %r, not found" % (app_label, model_name))
     if not request.user.contains_permission(app_label + '.' + model._meta.get_change_permission(), model):
         raise PermissionDenied
     try:
diff --git a/django/contrib/admin/views/template.py b/django/contrib/admin/views/template.py
index 93d110b045..a3b4538b10 100644
--- a/django/contrib/admin/views/template.py
+++ b/django/contrib/admin/views/template.py
@@ -1,6 +1,6 @@
 from django.contrib.admin.views.decorators import staff_member_required
 from django.core import validators
-from django import template, forms
+from django import template, oldforms
 from django.template import loader
 from django.shortcuts import render_to_response
 from django.contrib.sites.models import Site
@@ -25,17 +25,17 @@ def template_validator(request):
             request.user.message_set.create(message='The template is valid.')
     return render_to_response('admin/template_validator.html', {
         'title': 'Template validator',
-        'form': forms.FormWrapper(manipulator, new_data, errors),
+        'form': oldforms.FormWrapper(manipulator, new_data, errors),
     }, context_instance=template.RequestContext(request))
 template_validator = staff_member_required(template_validator)
 
-class TemplateValidator(forms.Manipulator):
+class TemplateValidator(oldforms.Manipulator):
     def __init__(self, settings_modules):
         self.settings_modules = settings_modules
         site_list = Site.objects.in_bulk(settings_modules.keys()).values()
         self.fields = (
-            forms.SelectField('site', is_required=True, choices=[(s.id, s.name) for s in site_list]),
-            forms.LargeTextField('template', is_required=True, rows=25, validator_list=[self.isValidTemplate]),
+            oldforms.SelectField('site', is_required=True, choices=[(s.id, s.name) for s in site_list]),
+            oldforms.LargeTextField('template', is_required=True, rows=25, validator_list=[self.isValidTemplate]),
         )
 
     def isValidTemplate(self, field_data, all_data):
diff --git a/django/contrib/auth/forms.py b/django/contrib/auth/forms.py
index 24c69cb73e..aea52d1f2a 100644
--- a/django/contrib/auth/forms.py
+++ b/django/contrib/auth/forms.py
@@ -3,16 +3,16 @@ from django.contrib.auth import authenticate
 from django.contrib.sites.models import Site
 from django.template import Context, loader
 from django.core import validators
-from django import forms
+from django import oldforms
 
-class UserCreationForm(forms.Manipulator):
+class UserCreationForm(oldforms.Manipulator):
     "A form that creates a user, with no privileges, from the given username and password."
     def __init__(self):
         self.fields = (
-            forms.TextField(field_name='username', length=30, maxlength=30, is_required=True,
+            oldforms.TextField(field_name='username', length=30, maxlength=30, is_required=True,
                 validator_list=[validators.isAlphaNumeric, self.isValidUsername]),
-            forms.PasswordField(field_name='password1', length=30, maxlength=60, is_required=True),
-            forms.PasswordField(field_name='password2', length=30, maxlength=60, is_required=True,
+            oldforms.PasswordField(field_name='password1', length=30, maxlength=60, is_required=True),
+            oldforms.PasswordField(field_name='password2', length=30, maxlength=60, is_required=True,
                 validator_list=[validators.AlwaysMatchesOtherField('password1', _("The two password fields didn't match."))]),
         )
 
@@ -27,7 +27,7 @@ class UserCreationForm(forms.Manipulator):
         "Creates the user."
         return User.objects.create_user(new_data['username'], '', new_data['password1'])
 
-class AuthenticationForm(forms.Manipulator):
+class AuthenticationForm(oldforms.Manipulator):
     """
     Base class for authenticating users. Extend this to get a form that accepts
     username/password logins.
@@ -41,9 +41,9 @@ class AuthenticationForm(forms.Manipulator):
         """
         self.request = request
         self.fields = [
-            forms.TextField(field_name="username", length=15, maxlength=30, is_required=True,
+            oldforms.TextField(field_name="username", length=15, maxlength=30, is_required=True,
                 validator_list=[self.isValidUser, self.hasCookiesEnabled]),
-            forms.PasswordField(field_name="password", length=15, maxlength=30, is_required=True),
+            oldforms.PasswordField(field_name="password", length=15, maxlength=30, is_required=True),
         ]
         self.user_cache = None
 
@@ -68,11 +68,11 @@ class AuthenticationForm(forms.Manipulator):
     def get_user(self):
         return self.user_cache
 
-class PasswordResetForm(forms.Manipulator):
+class PasswordResetForm(oldforms.Manipulator):
     "A form that lets a user request a password reset"
     def __init__(self):
         self.fields = (
-            forms.EmailField(field_name="email", length=40, is_required=True,
+            oldforms.EmailField(field_name="email", length=40, is_required=True,
                 validator_list=[self.isValidUserEmail]),
         )
 
@@ -105,16 +105,16 @@ class PasswordResetForm(forms.Manipulator):
         }
         send_mail('Password reset on %s' % site_name, t.render(Context(c)), None, [self.user_cache.email])
 
-class PasswordChangeForm(forms.Manipulator):
+class PasswordChangeForm(oldforms.Manipulator):
     "A form that lets a user change his password."
     def __init__(self, user):
         self.user = user
         self.fields = (
-            forms.PasswordField(field_name="old_password", length=30, maxlength=30, is_required=True,
+            oldforms.PasswordField(field_name="old_password", length=30, maxlength=30, is_required=True,
                 validator_list=[self.isValidOldPassword]),
-            forms.PasswordField(field_name="new_password1", length=30, maxlength=30, is_required=True,
+            oldforms.PasswordField(field_name="new_password1", length=30, maxlength=30, is_required=True,
                 validator_list=[validators.AlwaysMatchesOtherField('new_password2', _("The two 'new password' fields didn't match."))]),
-            forms.PasswordField(field_name="new_password2", length=30, maxlength=30, is_required=True),
+            oldforms.PasswordField(field_name="new_password2", length=30, maxlength=30, is_required=True),
         )
 
     def isValidOldPassword(self, new_data, all_data):
diff --git a/django/contrib/auth/views.py b/django/contrib/auth/views.py
index 6882755787..fda17b91fb 100644
--- a/django/contrib/auth/views.py
+++ b/django/contrib/auth/views.py
@@ -1,6 +1,6 @@
 from django.contrib.auth.forms import AuthenticationForm
 from django.contrib.auth.forms import PasswordResetForm, PasswordChangeForm
-from django import forms
+from django import oldforms
 from django.shortcuts import render_to_response
 from django.template import RequestContext
 from django.contrib.sites.models import Site
@@ -26,7 +26,7 @@ def login(request, template_name='registration/login.html'):
         errors = {}
     request.session.set_test_cookie()
     return render_to_response(template_name, {
-        'form': forms.FormWrapper(manipulator, request.POST, errors),
+        'form': oldforms.FormWrapper(manipulator, request.POST, errors),
         REDIRECT_FIELD_NAME: redirect_to,
         'site_name': Site.objects.get_current().name,
     }, context_instance=RequestContext(request))
@@ -62,7 +62,7 @@ def password_reset(request, is_admin_site=False, template_name='registration/pas
             else:
                 form.save(email_template_name=email_template_name)
             return HttpResponseRedirect('%sdone/' % request.path)
-    return render_to_response(template_name, {'form': forms.FormWrapper(form, new_data, errors)},
+    return render_to_response(template_name, {'form': oldforms.FormWrapper(form, new_data, errors)},
         context_instance=RequestContext(request))
 
 def password_reset_done(request, template_name='registration/password_reset_done.html'):
@@ -77,7 +77,7 @@ def password_change(request, template_name='registration/password_change_form.ht
         if not errors:
             form.save(new_data)
             return HttpResponseRedirect('%sdone/' % request.path)
-    return render_to_response(template_name, {'form': forms.FormWrapper(form, new_data, errors)},
+    return render_to_response(template_name, {'form': oldforms.FormWrapper(form, new_data, errors)},
         context_instance=RequestContext(request))
 password_change = login_required(password_change)
 
diff --git a/django/contrib/comments/views/comments.py b/django/contrib/comments/views/comments.py
index 3640da90fe..12330afe41 100644
--- a/django/contrib/comments/views/comments.py
+++ b/django/contrib/comments/views/comments.py
@@ -1,5 +1,5 @@
 from django.core import validators
-from django import forms
+from django import oldforms
 from django.core.mail import mail_admins, mail_managers
 from django.http import Http404
 from django.core.exceptions import ObjectDoesNotExist
@@ -28,37 +28,37 @@ class PublicCommentManipulator(AuthenticationForm):
             else:
                 return []
         self.fields.extend([
-            forms.LargeTextField(field_name="comment", maxlength=3000, is_required=True,
+            oldforms.LargeTextField(field_name="comment", maxlength=3000, is_required=True,
                 validator_list=[self.hasNoProfanities]),
-            forms.RadioSelectField(field_name="rating1", choices=choices,
+            oldforms.RadioSelectField(field_name="rating1", choices=choices,
                 is_required=ratings_required and num_rating_choices > 0,
                 validator_list=get_validator_list(1),
             ),
-            forms.RadioSelectField(field_name="rating2", choices=choices,
+            oldforms.RadioSelectField(field_name="rating2", choices=choices,
                 is_required=ratings_required and num_rating_choices > 1,
                 validator_list=get_validator_list(2),
             ),
-            forms.RadioSelectField(field_name="rating3", choices=choices,
+            oldforms.RadioSelectField(field_name="rating3", choices=choices,
                 is_required=ratings_required and num_rating_choices > 2,
                 validator_list=get_validator_list(3),
             ),
-            forms.RadioSelectField(field_name="rating4", choices=choices,
+            oldforms.RadioSelectField(field_name="rating4", choices=choices,
                 is_required=ratings_required and num_rating_choices > 3,
                 validator_list=get_validator_list(4),
             ),
-            forms.RadioSelectField(field_name="rating5", choices=choices,
+            oldforms.RadioSelectField(field_name="rating5", choices=choices,
                 is_required=ratings_required and num_rating_choices > 4,
                 validator_list=get_validator_list(5),
             ),
-            forms.RadioSelectField(field_name="rating6", choices=choices,
+            oldforms.RadioSelectField(field_name="rating6", choices=choices,
                 is_required=ratings_required and num_rating_choices > 5,
                 validator_list=get_validator_list(6),
             ),
-            forms.RadioSelectField(field_name="rating7", choices=choices,
+            oldforms.RadioSelectField(field_name="rating7", choices=choices,
                 is_required=ratings_required and num_rating_choices > 6,
                 validator_list=get_validator_list(7),
             ),
-            forms.RadioSelectField(field_name="rating8", choices=choices,
+            oldforms.RadioSelectField(field_name="rating8", choices=choices,
                 is_required=ratings_required and num_rating_choices > 7,
                 validator_list=get_validator_list(8),
             ),
@@ -117,13 +117,13 @@ class PublicCommentManipulator(AuthenticationForm):
             mail_managers("Comment posted by sketchy user (%s)" % self.user_cache.username, c.get_as_text())
         return c
 
-class PublicFreeCommentManipulator(forms.Manipulator):
+class PublicFreeCommentManipulator(oldforms.Manipulator):
     "Manipulator that handles public free (unregistered) comments"
     def __init__(self):
         self.fields = (
-            forms.TextField(field_name="person_name", maxlength=50, is_required=True,
+            oldforms.TextField(field_name="person_name", maxlength=50, is_required=True,
                 validator_list=[self.hasNoProfanities]),
-            forms.LargeTextField(field_name="comment", maxlength=3000, is_required=True,
+            oldforms.LargeTextField(field_name="comment", maxlength=3000, is_required=True,
                 validator_list=[self.hasNoProfanities]),
         )
 
@@ -221,9 +221,9 @@ def post_comment(request):
         from django.contrib.auth import login
         login(request, manipulator.get_user())
     if errors or request.POST.has_key('preview'):
-        class CommentFormWrapper(forms.FormWrapper):
+        class CommentFormWrapper(oldforms.FormWrapper):
             def __init__(self, manipulator, new_data, errors, rating_choices):
-                forms.FormWrapper.__init__(self, manipulator, new_data, errors)
+                oldforms.FormWrapper.__init__(self, manipulator, new_data, errors)
                 self.rating_choices = rating_choices
             def ratings(self):
                 field_list = [self['rating%d' % (i+1)] for i in range(len(rating_choices))]
@@ -302,7 +302,7 @@ def post_free_comment(request):
         comment = errors and '' or manipulator.get_comment(new_data)
         return render_to_response('comments/free_preview.html', {
             'comment': comment,
-            'comment_form': forms.FormWrapper(manipulator, new_data, errors),
+            'comment_form': oldforms.FormWrapper(manipulator, new_data, errors),
             'options': options,
             'target': target,
             'hash': security_hash,
diff --git a/django/contrib/contenttypes/management.py b/django/contrib/contenttypes/management.py
index de3a685477..f492f54303 100644
--- a/django/contrib/contenttypes/management.py
+++ b/django/contrib/contenttypes/management.py
@@ -3,9 +3,9 @@ Creates content types for all installed models.
 """
 
 from django.dispatch import dispatcher
-from django.db.models import get_models, signals
+from django.db.models import get_apps, get_models, signals
 
-def create_contenttypes(app, created_models, verbosity):
+def create_contenttypes(app, created_models, verbosity=2):
     from django.contrib.contenttypes.models import ContentType
     app_models = get_models(app)
     if not app_models:
@@ -22,4 +22,11 @@ def create_contenttypes(app, created_models, verbosity):
             if verbosity >= 2:
                 print "Adding content type '%s | %s'" % (ct.app_label, ct.model)
 
+def create_all_contenttypes(verbosity=2):
+    for app in get_apps():
+        create_contenttypes(app, None, verbosity)
+
 dispatcher.connect(create_contenttypes, signal=signals.post_syncdb)
+
+if __name__ == "__main__":
+    create_all_contenttypes()
diff --git a/django/contrib/csrf/middleware.py b/django/contrib/csrf/middleware.py
index f6f78867dc..93a9484ca6 100644
--- a/django/contrib/csrf/middleware.py
+++ b/django/contrib/csrf/middleware.py
@@ -11,7 +11,7 @@ import md5
 import re
 import itertools
 
-_ERROR_MSG = "<h1>403 Forbidden</h1><p>Cross Site Request Forgery detected.  Request aborted.</p>"
+_ERROR_MSG = '<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en"><body><h1>403 Forbidden</h1><p>Cross Site Request Forgery detected. Request aborted.</p></body></html>'
 
 _POST_FORM_RE = \
     re.compile(r'(<form\W[^>]*\bmethod=(\'|"|)POST(\'|"|)\b[^>]*>)', re.IGNORECASE)
diff --git a/django/contrib/formtools/__init__.py b/django/contrib/formtools/__init__.py
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/django/contrib/formtools/__init__.py
diff --git a/django/contrib/formtools/preview.py b/django/contrib/formtools/preview.py
new file mode 100644
index 0000000000..9a9371b5f8
--- /dev/null
+++ b/django/contrib/formtools/preview.py
@@ -0,0 +1,160 @@
+"""
+Formtools Preview application.
+
+This is an abstraction of the following workflow:
+
+    "Display an HTML form, force a preview, then do something with the submission."
+
+Given a django.newforms.Form object that you define, this takes care of the
+following:
+
+    * Displays the form as HTML on a Web page.
+    * Validates the form data once it's submitted via POST.
+        * If it's valid, displays a preview page.
+        * If it's not valid, redisplays the form with error messages.
+    * At the preview page, if the preview confirmation button is pressed, calls
+      a hook that you define -- a done() method.
+
+The framework enforces the required preview by passing a shared-secret hash to
+the preview page. If somebody tweaks the form parameters on the preview page,
+the form submission will fail the hash comparison test.
+
+Usage
+=====
+
+Subclass FormPreview and define a done() method:
+
+    def done(self, request, clean_data):
+        # ...
+
+This method takes an HttpRequest object and a dictionary of the form data after
+it has been validated and cleaned. It should return an HttpResponseRedirect.
+
+Then, just instantiate your FormPreview subclass by passing it a Form class,
+and pass that to your URLconf, like so:
+
+    (r'^post/$', MyFormPreview(MyForm)),
+
+The FormPreview class has a few other hooks. See the docstrings in the source
+code below.
+
+The framework also uses two templates: 'formtools/preview.html' and
+'formtools/form.html'. You can override these by setting 'preview_template' and
+'form_template' attributes on your FormPreview subclass. See
+django/contrib/formtools/templates for the default templates.
+"""
+
+from django.conf import settings
+from django.core.exceptions import ImproperlyConfigured
+from django.http import Http404
+from django.shortcuts import render_to_response
+import cPickle as pickle
+import md5
+
+AUTO_ID = 'formtools_%s' # Each form here uses this as its auto_id parameter.
+
+class FormPreview(object):
+    preview_template = 'formtools/preview.html'
+    form_template = 'formtools/form.html'
+
+    # METHODS SUBCLASSES SHOULDN'T OVERRIDE ###################################
+
+    def __init__(self, form):
+        # form should be a Form class, not an instance.
+        self.form, self.state = form, {}
+
+    def __call__(self, request, *args, **kwargs):
+        stage = {'1': 'preview', '2': 'post'}.get(request.POST.get(self.unused_name('stage')), 'preview')
+        self.parse_params(*args, **kwargs)
+        try:
+            method = getattr(self, stage + '_' + request.method.lower())
+        except AttributeError:
+            raise Http404
+        return method(request)
+
+    def unused_name(self, name):
+        """
+        Given a first-choice name, adds an underscore to the name until it
+        reaches a name that isn't claimed by any field in the form.
+
+        This is calculated rather than being hard-coded so that no field names
+        are off-limits for use in the form.
+        """
+        while 1:
+            try:
+                f = self.form.fields[name]
+            except KeyError:
+                break # This field name isn't being used by the form.
+            name += '_'
+        return name
+
+    def preview_get(self, request):
+        "Displays the form"
+        f = self.form(auto_id=AUTO_ID)
+        return render_to_response(self.form_template, {'form': f, 'stage_field': self.unused_name('stage'), 'state': self.state})
+
+    def preview_post(self, request):
+        "Validates the POST data. If valid, displays the preview page. Else, redisplays form."
+        f = self.form(request.POST, auto_id=AUTO_ID)
+        context = {'form': f, 'stage_field': self.unused_name('stage'), 'state': self.state}
+        if f.is_valid():
+            context['hash_field'] = self.unused_name('hash')
+            context['hash_value'] = self.security_hash(request, f)
+            return render_to_response(self.preview_template, context)
+        else:
+            return render_to_response(self.form_template, context)
+
+    def post_post(self, request):
+        "Validates the POST data. If valid, calls done(). Else, redisplays form."
+        f = self.form(request.POST, auto_id=AUTO_ID)
+        if f.is_valid():
+            if self.security_hash(request, f) != request.POST.get(self.unused_name('hash')):
+                return self.failed_hash(request) # Security hash failed.
+            return self.done(request, f.clean_data)
+        else:
+            return render_to_response(self.form_template, {'form': f, 'stage_field': self.unused_name('stage'), 'state': self.state})
+
+    # METHODS SUBCLASSES MIGHT OVERRIDE IF APPROPRIATE ########################
+
+    def parse_params(self, *args, **kwargs):
+        """
+        Given captured args and kwargs from the URLconf, saves something in
+        self.state and/or raises Http404 if necessary.
+
+        For example, this URLconf captures a user_id variable:
+
+            (r'^contact/(?P<user_id>\d{1,6})/$', MyFormPreview(MyForm)),
+
+        In this case, the kwargs variable in parse_params would be
+        {'user_id': 32} for a request to '/contact/32/'. You can use that
+        user_id to make sure it's a valid user and/or save it for later, for
+        use in done().
+        """
+        pass
+
+    def security_hash(self, request, form):
+        """
+        Calculates the security hash for the given Form instance.
+
+        This creates a list of the form field names/values in a deterministic
+        order, pickles the result with the SECRET_KEY setting and takes an md5
+        hash of that.
+
+        Subclasses may want to take into account request-specific information
+        such as the IP address.
+        """
+        data = [(bf.name, bf.data) for bf in form] + [settings.SECRET_KEY]
+        # Use HIGHEST_PROTOCOL because it's the most efficient. It requires
+        # Python 2.3, but Django requires 2.3 anyway, so that's OK.
+        pickled = pickle.dumps(data, protocol=pickle.HIGHEST_PROTOCOL)
+        return md5.new(pickled).hexdigest()
+
+    def failed_hash(self, request):
+        "Returns an HttpResponse in the case of an invalid security hash."
+        return self.preview_post(request)
+
+    # METHODS SUBCLASSES MUST OVERRIDE ########################################
+
+    def done(self, request, clean_data):
+        "Does something with the clean_data and returns an HttpResponseRedirect."
+        raise NotImplementedError('You must define a done() method on your %s subclass.' % self.__class__.__name__)
diff --git a/django/contrib/formtools/templates/formtools/form.html b/django/contrib/formtools/templates/formtools/form.html
new file mode 100644
index 0000000000..90da8b2b2b
--- /dev/null
+++ b/django/contrib/formtools/templates/formtools/form.html
@@ -0,0 +1,15 @@
+{% extends "base.html" %}
+
+{% block content %}
+
+{% if form.errors %}<h1>Please correct the following errors</h1>{% else %}<h1>Submit</h1>{% endif %}
+
+<form action="" method="post">
+<table>
+{{ form }}
+</table>
+<input type="hidden" name="{{ stage_field }}" value="1" />
+<p><input type="submit" value="Submit" /></p>
+</form>
+
+{% endblock %}
diff --git a/django/contrib/formtools/templates/formtools/preview.html b/django/contrib/formtools/templates/formtools/preview.html
new file mode 100644
index 0000000000..c7955d46e1
--- /dev/null
+++ b/django/contrib/formtools/templates/formtools/preview.html
@@ -0,0 +1,36 @@
+{% extends "base.html" %}
+
+{% block content %}
+
+<h1>Preview your submission</h1>
+
+<table>
+{% for field in form %}
+<tr>
+<th>{{ field.verbose_name }}:</th>
+<td>{{ field.data|escape }}</td>
+</tr>
+{% endfor %}
+</table>
+
+<p>Security hash: {{ hash_value }}</p>
+
+<form action="" method="post">
+{% for field in form %}{{ field.as_hidden }}
+{% endfor %}
+<input type="hidden" name="{{ stage_field }}" value="2" />
+<input type="hidden" name="{{ hash_field }}" value="{{ hash_value }}" />
+<p><input type="submit" value="Submit" /></p>
+</form>
+
+<h1>Or edit it again</h1>
+
+<form action="" method="post">
+<table>
+{{ form }}
+</table>
+<input type="hidden" name="{{ stage_field }}" value="1" />
+<p><input type="submit" value="Submit changes" /></p>
+</form>
+
+{% endblock %}
diff --git a/django/contrib/sitemaps/__init__.py b/django/contrib/sitemaps/__init__.py
index 2c76e13c22..44ede4460a 100644
--- a/django/contrib/sitemaps/__init__.py
+++ b/django/contrib/sitemaps/__init__.py
@@ -29,7 +29,7 @@ def ping_google(sitemap_url=None, ping_url=PING_URL):
 
     from django.contrib.sites.models import Site
     current_site = Site.objects.get_current()
-    url = "%s%s" % (current_site.domain, sitemap)
+    url = "%s%s" % (current_site.domain, sitemap_url)
     params = urllib.urlencode({'sitemap':url})
     urllib.urlopen("%s?%s" % (ping_url, params))
 
diff --git a/django/core/handlers/base.py b/django/core/handlers/base.py
index c1403ea4fa..ca48b301d4 100644
--- a/django/core/handlers/base.py
+++ b/django/core/handlers/base.py
@@ -60,7 +60,10 @@ class BaseHandler(object):
             if response:
                 return response
 
-        resolver = urlresolvers.RegexURLResolver(r'^/', settings.ROOT_URLCONF)
+        # Get urlconf from request object, if available.  Otherwise use default.
+        urlconf = getattr(request, "urlconf", settings.ROOT_URLCONF)
+
+        resolver = urlresolvers.RegexURLResolver(r'^/', urlconf)
         try:
             callback, callback_args, callback_kwargs = resolver.resolve(request.path)
 
@@ -84,7 +87,11 @@ class BaseHandler(object):
 
             # Complain if the view returned None (a common error).
             if response is None:
-                raise ValueError, "The view %s.%s didn't return an HttpResponse object." % (callback.__module__, callback.func_name)
+                try:
+                    view_name = callback.func_name # If it's a function
+                except AttributeError:
+                    view_name = callback.__class__.__name__ + '.__call__' # If it's a class
+                raise ValueError, "The view %s.%s didn't return an HttpResponse object." % (callback.__module__, view_name)
 
             return response
         except http.Http404, e:
diff --git a/django/core/handlers/wsgi.py b/django/core/handlers/wsgi.py
index 7dc1a4a5eb..71cfecd9a0 100644
--- a/django/core/handlers/wsgi.py
+++ b/django/core/handlers/wsgi.py
@@ -62,7 +62,7 @@ def safe_copyfileobj(fsrc, fdst, length=16*1024, size=0):
     data in the body.
     """
     if not size:
-        return copyfileobj(fsrc, fdst, length)
+        return
     while size > 0:
         buf = fsrc.read(min(length, size))
         if not buf:
@@ -157,8 +157,11 @@ class WSGIRequest(http.HttpRequest):
             return self._raw_post_data
         except AttributeError:
             buf = StringIO()
-            # CONTENT_LENGTH might be absent if POST doesn't have content at all (lighttpd)
-            content_length = int(self.environ.get('CONTENT_LENGTH', 0))
+            try:
+                # CONTENT_LENGTH might be absent if POST doesn't have content at all (lighttpd)
+                content_length = int(self.environ.get('CONTENT_LENGTH', 0))
+            except ValueError: # if CONTENT_LENGTH was empty string or not an integer
+                content_length = 0
             safe_copyfileobj(self.environ['wsgi.input'], buf, size=content_length)
             self._raw_post_data = buf.getvalue()
             buf.close()
diff --git a/django/core/servers/fastcgi.py b/django/core/servers/fastcgi.py
index fccb7bf087..649dd6942d 100644
--- a/django/core/servers/fastcgi.py
+++ b/django/core/servers/fastcgi.py
@@ -118,6 +118,8 @@ def runfastcgi(argset=[], **kwargs):
     else:
         return fastcgi_help("ERROR: Implementation must be one of prefork or thread.")
 
+    wsgi_opts['debug'] = False # Turn off flup tracebacks
+
     # Prep up and go
     from django.core.handlers.wsgi import WSGIHandler
 
diff --git a/django/db/backends/postgresql/base.py b/django/db/backends/postgresql/base.py
index 1e48e9c3fa..e44bc0b560 100644
--- a/django/db/backends/postgresql/base.py
+++ b/django/db/backends/postgresql/base.py
@@ -118,7 +118,7 @@ def get_pk_default_value():
 try:
     Database.register_type(Database.new_type((1082,), "DATE", util.typecast_date))
 except AttributeError:
-    raise Exception, "You appear to be using psycopg version 2, which isn't supported yet, because it's still in beta. Use psycopg version 1 instead: http://initd.org/projects/psycopg1"
+    raise Exception, "You appear to be using psycopg version 2. Set your DATABASE_ENGINE to 'postgresql_psycopg2' instead of 'postgresql'."
 Database.register_type(Database.new_type((1083,1266), "TIME", util.typecast_time))
 Database.register_type(Database.new_type((1114,1184), "TIMESTAMP", util.typecast_timestamp))
 Database.register_type(Database.new_type((16,), "BOOLEAN", util.typecast_boolean))
diff --git a/django/db/models/fields/__init__.py b/django/db/models/fields/__init__.py
index bc1eaf0a6a..fe317ac24f 100644
--- a/django/db/models/fields/__init__.py
+++ b/django/db/models/fields/__init__.py
@@ -2,7 +2,8 @@ from django.db.models import signals
 from django.dispatch import dispatcher
 from django.conf import settings
 from django.core import validators
-from django import forms
+from django import oldforms
+from django import newforms as forms
 from django.core.exceptions import ObjectDoesNotExist
 from django.utils.functional import curry
 from django.utils.itercompat import tee
@@ -206,10 +207,10 @@ class Field(object):
 
         if self.choices:
             if self.radio_admin:
-                field_objs = [forms.RadioSelectField]
+                field_objs = [oldforms.RadioSelectField]
                 params['ul_class'] = get_ul_class(self.radio_admin)
             else:
-                field_objs = [forms.SelectField]
+                field_objs = [oldforms.SelectField]
 
             params['choices'] = self.get_choices_default()
         else:
@@ -218,7 +219,7 @@ class Field(object):
 
     def get_manipulator_fields(self, opts, manipulator, change, name_prefix='', rel=False, follow=True):
         """
-        Returns a list of forms.FormField instances for this field. It
+        Returns a list of oldforms.FormField instances for this field. It
         calculates the choices at runtime, not at compile time.
 
         name_prefix is a prefix to prepend to the "field_name" argument.
@@ -333,6 +334,11 @@ class Field(object):
             return self._choices
     choices = property(_get_choices)
 
+    def formfield(self):
+        "Returns a django.newforms.Field instance for this database Field."
+        # TODO: This is just a temporary default during development.
+        return forms.CharField(required=not self.blank, label=capfirst(self.verbose_name))
+
 class AutoField(Field):
     empty_strings_allowed = False
     def __init__(self, *args, **kwargs):
@@ -354,7 +360,7 @@ class AutoField(Field):
         return Field.get_manipulator_fields(self, opts, manipulator, change, name_prefix, rel, follow)
 
     def get_manipulator_field_objs(self):
-        return [forms.HiddenField]
+        return [oldforms.HiddenField]
 
     def get_manipulator_new_data(self, new_data, rel=False):
         # Never going to be called
@@ -369,6 +375,9 @@ class AutoField(Field):
         super(AutoField, self).contribute_to_class(cls, name)
         cls._meta.has_auto_field = True
 
+    def formfield(self):
+        return None
+
 class BooleanField(Field):
     def __init__(self, *args, **kwargs):
         kwargs['blank'] = True
@@ -381,11 +390,14 @@ class BooleanField(Field):
         raise validators.ValidationError, gettext("This value must be either True or False.")
 
     def get_manipulator_field_objs(self):
-        return [forms.CheckboxField]
+        return [oldforms.CheckboxField]
+
+    def formfield(self):
+        return forms.BooleanField(required=not self.blank, label=capfirst(self.verbose_name))
 
 class CharField(Field):
     def get_manipulator_field_objs(self):
-        return [forms.TextField]
+        return [oldforms.TextField]
 
     def to_python(self, value):
         if isinstance(value, basestring):
@@ -397,10 +409,13 @@ class CharField(Field):
                 raise validators.ValidationError, gettext_lazy("This field cannot be null.")
         return str(value)
 
+    def formfield(self):
+        return forms.CharField(max_length=self.maxlength, required=not self.blank, label=capfirst(self.verbose_name))
+
 # TODO: Maybe move this into contrib, because it's specialized.
 class CommaSeparatedIntegerField(CharField):
     def get_manipulator_field_objs(self):
-        return [forms.CommaSeparatedIntegerField]
+        return [oldforms.CommaSeparatedIntegerField]
 
 class DateField(Field):
     empty_strings_allowed = False
@@ -457,19 +472,20 @@ class DateField(Field):
 
     def get_db_prep_save(self, value):
         # Casts dates into string format for entry into database.
-        if isinstance(value, datetime.datetime):
-            value = value.date().strftime('%Y-%m-%d')
-        elif isinstance(value, datetime.date):
+        if value is not None:
             value = value.strftime('%Y-%m-%d')
         return Field.get_db_prep_save(self, value)
 
     def get_manipulator_field_objs(self):
-        return [forms.DateField]
+        return [oldforms.DateField]
 
     def flatten_data(self, follow, obj = None):
         val = self._get_val_from_obj(obj)
         return {self.attname: (val is not None and val.strftime("%Y-%m-%d") or '')}
 
+    def formfield(self):
+        return forms.DateField(required=not self.blank, label=capfirst(self.verbose_name))
+
 class DateTimeField(DateField):
     def to_python(self, value):
         if isinstance(value, datetime.datetime):
@@ -489,19 +505,12 @@ class DateTimeField(DateField):
 
     def get_db_prep_save(self, value):
         # Casts dates into string format for entry into database.
-        if isinstance(value, datetime.datetime):
+        if value is not None:
             # MySQL will throw a warning if microseconds are given, because it
             # doesn't support microseconds.
             if settings.DATABASE_ENGINE == 'mysql' and hasattr(value, 'microsecond'):
                 value = value.replace(microsecond=0)
             value = str(value)
-        elif isinstance(value, datetime.date):
-            # MySQL will throw a warning if microseconds are given, because it
-            # doesn't support microseconds.
-            if settings.DATABASE_ENGINE == 'mysql' and hasattr(value, 'microsecond'):
-                value = datetime.datetime(value.year, value.month, value.day, microsecond=0)
-            value = str(value)
-            
         return Field.get_db_prep_save(self, value)
 
     def get_db_prep_lookup(self, lookup_type, value):
@@ -512,7 +521,7 @@ class DateTimeField(DateField):
         return Field.get_db_prep_lookup(self, lookup_type, value)
 
     def get_manipulator_field_objs(self):
-        return [forms.DateField, forms.TimeField]
+        return [oldforms.DateField, oldforms.TimeField]
 
     def get_manipulator_field_names(self, name_prefix):
         return [name_prefix + self.name + '_date', name_prefix + self.name + '_time']
@@ -535,6 +544,9 @@ class DateTimeField(DateField):
         return {date_field: (val is not None and val.strftime("%Y-%m-%d") or ''),
                 time_field: (val is not None and val.strftime("%H:%M:%S") or '')}
 
+    def formfield(self):
+        return forms.DateTimeField(required=not self.blank, label=capfirst(self.verbose_name))
+
 class EmailField(CharField):
     def __init__(self, *args, **kwargs):
         kwargs['maxlength'] = 75
@@ -544,11 +556,14 @@ class EmailField(CharField):
         return "CharField"
 
     def get_manipulator_field_objs(self):
-        return [forms.EmailField]
+        return [oldforms.EmailField]
 
     def validate(self, field_data, all_data):
         validators.isValidEmail(field_data, all_data)
 
+    def formfield(self):
+        return forms.EmailField(required=not self.blank, label=capfirst(self.verbose_name))
+
 class FileField(Field):
     def __init__(self, verbose_name=None, name=None, upload_to='', **kwargs):
         self.upload_to = upload_to
@@ -608,7 +623,7 @@ class FileField(Field):
                 os.remove(file_name)
 
     def get_manipulator_field_objs(self):
-        return [forms.FileUploadField, forms.HiddenField]
+        return [oldforms.FileUploadField, oldforms.HiddenField]
 
     def get_manipulator_field_names(self, name_prefix):
         return [name_prefix + self.name + '_file', name_prefix + self.name]
@@ -636,7 +651,7 @@ class FilePathField(Field):
         Field.__init__(self, verbose_name, name, **kwargs)
 
     def get_manipulator_field_objs(self):
-        return [curry(forms.FilePathField, path=self.path, match=self.match, recursive=self.recursive)]
+        return [curry(oldforms.FilePathField, path=self.path, match=self.match, recursive=self.recursive)]
 
 class FloatField(Field):
     empty_strings_allowed = False
@@ -645,7 +660,7 @@ class FloatField(Field):
         Field.__init__(self, verbose_name, name, **kwargs)
 
     def get_manipulator_field_objs(self):
-        return [curry(forms.FloatField, max_digits=self.max_digits, decimal_places=self.decimal_places)]
+        return [curry(oldforms.FloatField, max_digits=self.max_digits, decimal_places=self.decimal_places)]
 
 class ImageField(FileField):
     def __init__(self, verbose_name=None, name=None, width_field=None, height_field=None, **kwargs):
@@ -653,7 +668,7 @@ class ImageField(FileField):
         FileField.__init__(self, verbose_name, name, **kwargs)
 
     def get_manipulator_field_objs(self):
-        return [forms.ImageUploadField, forms.HiddenField]
+        return [oldforms.ImageUploadField, oldforms.HiddenField]
 
     def contribute_to_class(self, cls, name):
         super(ImageField, self).contribute_to_class(cls, name)
@@ -679,7 +694,10 @@ class ImageField(FileField):
 class IntegerField(Field):
     empty_strings_allowed = False
     def get_manipulator_field_objs(self):
-        return [forms.IntegerField]
+        return [oldforms.IntegerField]
+
+    def formfield(self):
+        return forms.IntegerField(required=not self.blank, label=capfirst(self.verbose_name))
 
 class IPAddressField(Field):
     def __init__(self, *args, **kwargs):
@@ -687,7 +705,7 @@ class IPAddressField(Field):
         Field.__init__(self, *args, **kwargs)
 
     def get_manipulator_field_objs(self):
-        return [forms.IPAddressField]
+        return [oldforms.IPAddressField]
 
     def validate(self, field_data, all_data):
         validators.isValidIPAddress4(field_data, None)
@@ -698,22 +716,22 @@ class NullBooleanField(Field):
         Field.__init__(self, *args, **kwargs)
 
     def get_manipulator_field_objs(self):
-        return [forms.NullBooleanField]
+        return [oldforms.NullBooleanField]
 
 class PhoneNumberField(IntegerField):
     def get_manipulator_field_objs(self):
-        return [forms.PhoneNumberField]
+        return [oldforms.PhoneNumberField]
 
     def validate(self, field_data, all_data):
         validators.isValidPhone(field_data, all_data)
 
 class PositiveIntegerField(IntegerField):
     def get_manipulator_field_objs(self):
-        return [forms.PositiveIntegerField]
+        return [oldforms.PositiveIntegerField]
 
 class PositiveSmallIntegerField(IntegerField):
     def get_manipulator_field_objs(self):
-        return [forms.PositiveSmallIntegerField]
+        return [oldforms.PositiveSmallIntegerField]
 
 class SlugField(Field):
     def __init__(self, *args, **kwargs):
@@ -725,15 +743,15 @@ class SlugField(Field):
         Field.__init__(self, *args, **kwargs)
 
     def get_manipulator_field_objs(self):
-        return [forms.TextField]
+        return [oldforms.TextField]
 
 class SmallIntegerField(IntegerField):
     def get_manipulator_field_objs(self):
-        return [forms.SmallIntegerField]
+        return [oldforms.SmallIntegerField]
 
 class TextField(Field):
     def get_manipulator_field_objs(self):
-        return [forms.LargeTextField]
+        return [oldforms.LargeTextField]
 
 class TimeField(Field):
     empty_strings_allowed = False
@@ -769,24 +787,31 @@ class TimeField(Field):
         return Field.get_db_prep_save(self, value)
 
     def get_manipulator_field_objs(self):
-        return [forms.TimeField]
+        return [oldforms.TimeField]
 
     def flatten_data(self,follow, obj = None):
         val = self._get_val_from_obj(obj)
         return {self.attname: (val is not None and val.strftime("%H:%M:%S") or '')}
 
+    def formfield(self):
+        return forms.TimeField(required=not self.blank, label=capfirst(self.verbose_name))
+
 class URLField(Field):
     def __init__(self, verbose_name=None, name=None, verify_exists=True, **kwargs):
         if verify_exists:
             kwargs.setdefault('validator_list', []).append(validators.isExistingURL)
+        self.verify_exists = verify_exists
         Field.__init__(self, verbose_name, name, **kwargs)
 
     def get_manipulator_field_objs(self):
-        return [forms.URLField]
+        return [oldforms.URLField]
+
+    def formfield(self):
+        return forms.URLField(required=not self.blank, verify_exists=self.verify_exists, label=capfirst(self.verbose_name))
 
 class USStateField(Field):
     def get_manipulator_field_objs(self):
-        return [forms.USStateField]
+        return [oldforms.USStateField]
 
 class XMLField(TextField):
     def __init__(self, verbose_name=None, name=None, schema_path=None, **kwargs):
@@ -797,7 +822,7 @@ class XMLField(TextField):
         return "TextField"
 
     def get_manipulator_field_objs(self):
-        return [curry(forms.XMLLargeTextField, schema_path=self.schema_path)]
+        return [curry(oldforms.XMLLargeTextField, schema_path=self.schema_path)]
 
 class OrderingField(IntegerField):
     empty_strings_allowed=False
@@ -810,4 +835,4 @@ class OrderingField(IntegerField):
         return "IntegerField"
 
     def get_manipulator_fields(self, opts, manipulator, change, name_prefix='', rel=False, follow=True):
-        return [forms.HiddenField(name_prefix + self.name)]
+        return [oldforms.HiddenField(name_prefix + self.name)]
diff --git a/django/db/models/fields/generic.py b/django/db/models/fields/generic.py
index 7d7651029c..1ad8346e42 100644
--- a/django/db/models/fields/generic.py
+++ b/django/db/models/fields/generic.py
@@ -2,7 +2,7 @@
 Classes allowing "generic" relations through ContentType and object-id fields.
 """
 
-from django import forms
+from django import oldforms
 from django.core.exceptions import ObjectDoesNotExist
 from django.db import backend
 from django.db.models import signals
@@ -98,7 +98,7 @@ class GenericRelation(RelatedField, Field):
 
     def get_manipulator_field_objs(self):
         choices = self.get_choices_default()
-        return [curry(forms.SelectMultipleField, size=min(max(len(choices), 5), 15), choices=choices)]
+        return [curry(oldforms.SelectMultipleField, size=min(max(len(choices), 5), 15), choices=choices)]
 
     def get_choices_default(self):
         return Field.get_choices(self, include_blank=False)
diff --git a/django/db/models/fields/related.py b/django/db/models/fields/related.py
index bd9262d55a..797ef05be1 100644
--- a/django/db/models/fields/related.py
+++ b/django/db/models/fields/related.py
@@ -5,7 +5,7 @@ from django.db.models.related import RelatedObject
 from django.utils.translation import gettext_lazy, string_concat, ngettext
 from django.utils.functional import curry
 from django.core import validators
-from django import forms
+from django import oldforms
 from django.dispatch import dispatcher
 
 # For Python 2.3
@@ -256,8 +256,7 @@ class ForeignRelatedObjectsDescriptor(object):
         # Otherwise, just move the named objects into the set.
         if self.related.field.null:
             manager.clear()
-        for obj in value:
-            manager.add(obj)
+        manager.add(*value)
 
 def create_many_related_manager(superclass):
     """Creates a manager that subclasses 'superclass' (which is a Manager)
@@ -318,25 +317,31 @@ def create_many_related_manager(superclass):
             # *objs - objects to add
             from django.db import connection
 
-            # Add the newly created or already existing objects to the join table.
-            # First find out which items are already added, to avoid adding them twice
-            new_ids = set([obj._get_pk_val() for obj in objs])
-            cursor = connection.cursor()
-            cursor.execute("SELECT %s FROM %s WHERE %s = %%s AND %s IN (%s)" % \
-                (target_col_name, self.join_table, source_col_name,
-                target_col_name, ",".join(['%s'] * len(new_ids))),
-                [self._pk_val] + list(new_ids))
-            if cursor.rowcount is not None and cursor.rowcount != 0:
-                existing_ids = set([row[0] for row in cursor.fetchmany(cursor.rowcount)])
-            else:
-                existing_ids = set()
+            # If there aren't any objects, there is nothing to do.
+            if objs:
+                # Check that all the objects are of the right type
+                for obj in objs:
+                    if not isinstance(obj, self.model):
+                        raise ValueError, "objects to add() must be %s instances" % self.model._meta.object_name
+                # Add the newly created or already existing objects to the join table.
+                # First find out which items are already added, to avoid adding them twice
+                new_ids = set([obj._get_pk_val() for obj in objs])
+                cursor = connection.cursor()
+                cursor.execute("SELECT %s FROM %s WHERE %s = %%s AND %s IN (%s)" % \
+                    (target_col_name, self.join_table, source_col_name,
+                    target_col_name, ",".join(['%s'] * len(new_ids))),
+                    [self._pk_val] + list(new_ids))
+                if cursor.rowcount is not None and cursor.rowcount != 0:
+                    existing_ids = set([row[0] for row in cursor.fetchmany(cursor.rowcount)])
+                else:
+                    existing_ids = set()
 
-            # Add the ones that aren't there already
-            for obj_id in (new_ids - existing_ids):
-                cursor.execute("INSERT INTO %s (%s, %s) VALUES (%%s, %%s)" % \
-                    (self.join_table, source_col_name, target_col_name),
-                    [self._pk_val, obj_id])
-            transaction.commit_unless_managed()
+                # Add the ones that aren't there already
+                for obj_id in (new_ids - existing_ids):
+                    cursor.execute("INSERT INTO %s (%s, %s) VALUES (%%s, %%s)" % \
+                        (self.join_table, source_col_name, target_col_name),
+                        [self._pk_val, obj_id])
+                transaction.commit_unless_managed()
 
         def _remove_items(self, source_col_name, target_col_name, *objs):
             # source_col_name: the PK colname in join_table for the source object
@@ -344,16 +349,20 @@ def create_many_related_manager(superclass):
             # *objs - objects to remove
             from django.db import connection
 
-            for obj in objs:
-                if not isinstance(obj, self.model):
-                    raise ValueError, "objects to remove() must be %s instances" % self.model._meta.object_name
-            # Remove the specified objects from the join table
-            cursor = connection.cursor()
-            for obj in objs:
-                cursor.execute("DELETE FROM %s WHERE %s = %%s AND %s = %%s" % \
-                    (self.join_table, source_col_name, target_col_name),
-                    [self._pk_val, obj._get_pk_val()])
-            transaction.commit_unless_managed()
+            # If there aren't any objects, there is nothing to do.
+            if objs:
+                # Check that all the objects are of the right type
+                for obj in objs:
+                    if not isinstance(obj, self.model):
+                        raise ValueError, "objects to remove() must be %s instances" % self.model._meta.object_name
+                # Remove the specified objects from the join table
+                old_ids = set([obj._get_pk_val() for obj in objs])
+                cursor = connection.cursor()
+                cursor.execute("DELETE FROM %s WHERE %s = %%s AND %s IN (%s)" % \
+                    (self.join_table, source_col_name, 
+                    target_col_name, ",".join(['%s'] * len(old_ids))),
+                    [self._pk_val] + list(old_ids))
+                transaction.commit_unless_managed()
 
         def _clear_items(self, source_col_name):
             # source_col_name: the PK colname in join_table for the source object
@@ -405,8 +414,7 @@ class ManyRelatedObjectsDescriptor(object):
 
         manager = self.__get__(instance)
         manager.clear()
-        for obj in value:
-            manager.add(obj)
+        manager.add(*value)
 
 class ReverseManyRelatedObjectsDescriptor(object):
     # This class provides the functionality that makes the related-object
@@ -447,8 +455,7 @@ class ReverseManyRelatedObjectsDescriptor(object):
 
         manager = self.__get__(instance)
         manager.clear()
-        for obj in value:
-            manager.add(obj)
+        manager.add(*value)
 
 class ForeignKey(RelatedField, Field):
     empty_strings_allowed = False
@@ -493,13 +500,13 @@ class ForeignKey(RelatedField, Field):
             params['validator_list'].append(curry(manipulator_valid_rel_key, self, manipulator))
         else:
             if self.radio_admin:
-                field_objs = [forms.RadioSelectField]
+                field_objs = [oldforms.RadioSelectField]
                 params['ul_class'] = get_ul_class(self.radio_admin)
             else:
                 if self.null:
-                    field_objs = [forms.NullSelectField]
+                    field_objs = [oldforms.NullSelectField]
                 else:
-                    field_objs = [forms.SelectField]
+                    field_objs = [oldforms.SelectField]
             params['choices'] = self.get_choices_default()
         return field_objs, params
 
@@ -508,7 +515,7 @@ class ForeignKey(RelatedField, Field):
         if self.rel.raw_id_admin and not isinstance(rel_field, AutoField):
             return rel_field.get_manipulator_field_objs()
         else:
-            return [forms.IntegerField]
+            return [oldforms.IntegerField]
 
     def get_db_prep_save(self, value):
         if value == '' or value == None:
@@ -581,13 +588,13 @@ class OneToOneField(RelatedField, IntegerField):
             params['validator_list'].append(curry(manipulator_valid_rel_key, self, manipulator))
         else:
             if self.radio_admin:
-                field_objs = [forms.RadioSelectField]
+                field_objs = [oldforms.RadioSelectField]
                 params['ul_class'] = get_ul_class(self.radio_admin)
             else:
                 if self.null:
-                    field_objs = [forms.NullSelectField]
+                    field_objs = [oldforms.NullSelectField]
                 else:
-                    field_objs = [forms.SelectField]
+                    field_objs = [oldforms.SelectField]
             params['choices'] = self.get_choices_default()
         return field_objs, params
 
@@ -622,10 +629,10 @@ class ManyToManyField(RelatedField, Field):
 
     def get_manipulator_field_objs(self):
         if self.rel.raw_id_admin:
-            return [forms.RawIdAdminField]
+            return [oldforms.RawIdAdminField]
         else:
             choices = self.get_choices_default()
-            return [curry(forms.SelectMultipleField, size=min(max(len(choices), 5), 15), choices=choices)]
+            return [curry(oldforms.SelectMultipleField, size=min(max(len(choices), 5), 15), choices=choices)]
 
     def get_choices_default(self):
         return Field.get_choices(self, include_blank=False)
diff --git a/django/db/models/manipulators.py b/django/db/models/manipulators.py
index 866e12781c..e9dfa7037c 100644
--- a/django/db/models/manipulators.py
+++ b/django/db/models/manipulators.py
@@ -1,5 +1,5 @@
 from django.core.exceptions import ObjectDoesNotExist
-from django import forms
+from django import oldforms
 from django.core import validators
 from django.db.models.fields import FileField, AutoField
 from django.dispatch import dispatcher
@@ -40,7 +40,7 @@ class ManipulatorDescriptor(object):
                 self.man._prepare(model)
             return self.man
 
-class AutomaticManipulator(forms.Manipulator):
+class AutomaticManipulator(oldforms.Manipulator):
     def _prepare(cls, model):
         cls.model = model
         cls.manager = model._default_manager
@@ -76,7 +76,7 @@ class AutomaticManipulator(forms.Manipulator):
 
         # Add field for ordering.
         if self.change and self.opts.get_ordered_objects():
-            self.fields.append(forms.CommaSeparatedIntegerField(field_name="order_"))
+            self.fields.append(oldforms.CommaSeparatedIntegerField(field_name="order_"))
 
     def save(self, new_data):
         # TODO: big cleanup when core fields go -> use recursive manipulators.
@@ -313,7 +313,7 @@ def manipulator_validator_unique_together(field_name_list, opts, self, field_dat
 def manipulator_validator_unique_for_date(from_field, date_field, opts, lookup_type, self, field_data, all_data):
     from django.db.models.fields.related import ManyToOneRel
     date_str = all_data.get(date_field.get_manipulator_field_names('')[0], None)
-    date_val = forms.DateField.html2python(date_str)
+    date_val = oldforms.DateField.html2python(date_str)
     if date_val is None:
         return # Date was invalid. This will be caught by another validator.
     lookup_kwargs = {'%s__year' % date_field.name: date_val.year}
diff --git a/django/forms/__init__.py b/django/forms/__init__.py
index 0b9ac05edb..68d3d245a2 100644
--- a/django/forms/__init__.py
+++ b/django/forms/__init__.py
@@ -1,1008 +1 @@
-from django.core import validators
-from django.core.exceptions import PermissionDenied
-from django.utils.html import escape
-from django.conf import settings
-from django.utils.translation import gettext, ngettext
-
-FORM_FIELD_ID_PREFIX = 'id_'
-
-class EmptyValue(Exception):
-    "This is raised when empty data is provided"
-    pass
-
-class Manipulator(object):
-    # List of permission strings. User must have at least one to manipulate.
-    # None means everybody has permission.
-    required_permission = ''
-
-    def __init__(self):
-        # List of FormField objects
-        self.fields = []
-
-    def __getitem__(self, field_name):
-        "Looks up field by field name; raises KeyError on failure"
-        for field in self.fields:
-            if field.field_name == field_name:
-                return field
-        raise KeyError, "Field %s not found\n%s" % (field_name, repr(self.fields))
-
-    def __delitem__(self, field_name):
-        "Deletes the field with the given field name; raises KeyError on failure"
-        for i, field in enumerate(self.fields):
-            if field.field_name == field_name:
-                del self.fields[i]
-                return
-        raise KeyError, "Field %s not found" % field_name
-
-    def check_permissions(self, user):
-        """Confirms user has required permissions to use this manipulator; raises
-        PermissionDenied on failure."""
-        if self.required_permission is None:
-            return
-        if user.has_perm(self.required_permission):
-            return
-        raise PermissionDenied
-
-    def prepare(self, new_data):
-        """
-        Makes any necessary preparations to new_data, in place, before data has
-        been validated.
-        """
-        for field in self.fields:
-            field.prepare(new_data)
-
-    def get_validation_errors(self, new_data):
-        "Returns dictionary mapping field_names to error-message lists"
-        errors = {}
-        self.prepare(new_data)
-        for field in self.fields:
-            errors.update(field.get_validation_errors(new_data))
-            val_name = 'validate_%s' % field.field_name
-            if hasattr(self, val_name):
-                val = getattr(self, val_name)
-                try:
-                    field.run_validator(new_data, val)
-                except (validators.ValidationError, validators.CriticalValidationError), e:
-                    errors.setdefault(field.field_name, []).extend(e.messages)
-
-#            if field.is_required and not new_data.get(field.field_name, False):
-#                errors.setdefault(field.field_name, []).append(gettext_lazy('This field is required.'))
-#                continue
-#            try:
-#                validator_list = field.validator_list
-#                if hasattr(self, 'validate_%s' % field.field_name):
-#                    validator_list.append(getattr(self, 'validate_%s' % field.field_name))
-#                for validator in validator_list:
-#                    if field.is_required or new_data.get(field.field_name, False) or hasattr(validator, 'always_test'):
-#                        try:
-#                            if hasattr(field, 'requires_data_list'):
-#                                validator(new_data.getlist(field.field_name), new_data)
-#                            else:
-#                                validator(new_data.get(field.field_name, ''), new_data)
-#                        except validators.ValidationError, e:
-#                            errors.setdefault(field.field_name, []).extend(e.messages)
-#            # If a CriticalValidationError is raised, ignore any other ValidationErrors
-#            # for this particular field
-#            except validators.CriticalValidationError, e:
-#                errors.setdefault(field.field_name, []).extend(e.messages)
-        return errors
-
-    def save(self, new_data):
-        "Saves the changes and returns the new object"
-        # changes is a dictionary-like object keyed by field_name
-        raise NotImplementedError
-
-    def do_html2python(self, new_data):
-        """
-        Convert the data from HTML data types to Python datatypes, changing the
-        object in place. This happens after validation but before storage. This
-        must happen after validation because html2python functions aren't
-        expected to deal with invalid input.
-        """
-        for field in self.fields:
-            field.convert_post_data(new_data)
-
-class FormWrapper(object):
-    """
-    A wrapper linking a Manipulator to the template system.
-    This allows dictionary-style lookups of formfields. It also handles feeding
-    prepopulated data and validation error messages to the formfield objects.
-    """
-    def __init__(self, manipulator, data=None, error_dict=None, edit_inline=True):
-        self.manipulator = manipulator
-        if data is None:
-            data = {}
-        if error_dict is None:
-            error_dict = {}
-        self.data = data
-        self.error_dict = error_dict
-        self._inline_collections = None
-        self.edit_inline = edit_inline
-
-    def __repr__(self):
-        return repr(self.__dict__)
-
-    def __getitem__(self, key):
-        for field in self.manipulator.fields:
-            if field.field_name == key:
-                data = field.extract_data(self.data)
-                return FormFieldWrapper(field, data, self.error_dict.get(field.field_name, []))
-        if self.edit_inline:
-            self.fill_inline_collections()
-            for inline_collection in self._inline_collections:
-                if inline_collection.name == key:
-                    return inline_collection
-        raise KeyError, "Could not find Formfield or InlineObjectCollection named %r" % key
-
-    def fill_inline_collections(self):
-        if not self._inline_collections:
-            ic = []
-            related_objects = self.manipulator.get_related_objects()
-            for rel_obj in related_objects:
-                data = rel_obj.extract_data(self.data)
-                inline_collection = InlineObjectCollection(self.manipulator, rel_obj, data, self.error_dict)
-                ic.append(inline_collection)
-            self._inline_collections = ic
-
-    def has_errors(self):
-        return self.error_dict != {}
-
-    def _get_fields(self):
-        try:
-            return self._fields
-        except AttributeError:
-            self._fields = [self.__getitem__(field.field_name) for field in self.manipulator.fields]
-            return self._fields
-
-    fields = property(_get_fields)
-
-class FormFieldWrapper(object):
-    "A bridge between the template system and an individual form field. Used by FormWrapper."
-    def __init__(self, formfield, data, error_list):
-        self.formfield, self.data, self.error_list = formfield, data, error_list
-        self.field_name = self.formfield.field_name # for convenience in templates
-
-    def __str__(self):
-        "Renders the field"
-        return str(self.formfield.render(self.data))
-
-    def __repr__(self):
-        return '<FormFieldWrapper for "%s">' % self.formfield.field_name
-
-    def field_list(self):
-        """
-        Like __str__(), but returns a list. Use this when the field's render()
-        method returns a list.
-        """
-        return self.formfield.render(self.data)
-
-    def errors(self):
-        return self.error_list
-
-    def html_error_list(self):
-        if self.errors():
-            return '<ul class="errorlist"><li>%s</li></ul>' % '</li><li>'.join([escape(e) for e in self.errors()])
-        else:
-            return ''
-
-    def get_id(self):
-        return self.formfield.get_id()
-
-class FormFieldCollection(FormFieldWrapper):
-    "A utility class that gives the template access to a dict of FormFieldWrappers"
-    def __init__(self, formfield_dict):
-        self.formfield_dict = formfield_dict
-
-    def __str__(self):
-        return str(self.formfield_dict)
-
-    def __getitem__(self, template_key):
-        "Look up field by template key; raise KeyError on failure"
-        return self.formfield_dict[template_key]
-
-    def __repr__(self):
-        return "<FormFieldCollection: %s>" % self.formfield_dict
-
-    def errors(self):
-        "Returns list of all errors in this collection's formfields"
-        errors = []
-        for field in self.formfield_dict.values():
-            if hasattr(field, 'errors'):
-                errors.extend(field.errors())
-        return errors
-
-    def has_errors(self):
-        return bool(len(self.errors()))
-
-    def html_combined_error_list(self):
-        return ''.join([field.html_error_list() for field in self.formfield_dict.values() if hasattr(field, 'errors')])
-
-class InlineObjectCollection(object):
-    "An object that acts like a sparse list of form field collections."
-    def __init__(self, parent_manipulator, rel_obj, data, errors):
-        self.parent_manipulator = parent_manipulator
-        self.rel_obj = rel_obj
-        self.data = data
-        self.errors = errors
-        self._collections = None
-        self.name = rel_obj.name
-
-    def __len__(self):
-        self.fill()
-        return self._collections.__len__()
-
-    def __getitem__(self, k):
-        self.fill()
-        return self._collections.__getitem__(k)
-
-    def __setitem__(self, k, v):
-        self.fill()
-        return self._collections.__setitem__(k,v)
-
-    def __delitem__(self, k):
-        self.fill()
-        return self._collections.__delitem__(k)
-
-    def __iter__(self):
-        self.fill()
-        return iter(self._collections.values())
-
-    def items(self):
-        self.fill()
-        return self._collections.items()
-
-    def fill(self):
-        if self._collections:
-            return
-        else:
-            var_name = self.rel_obj.opts.object_name.lower()
-            collections = {}
-            orig = None
-            if hasattr(self.parent_manipulator, 'original_object'):
-                orig = self.parent_manipulator.original_object
-            orig_list = self.rel_obj.get_list(orig)
-
-            for i, instance in enumerate(orig_list):
-                collection = {'original': instance}
-                for f in self.rel_obj.editable_fields():
-                    for field_name in f.get_manipulator_field_names(''):
-                        full_field_name = '%s.%d.%s' % (var_name, i, field_name)
-                        field = self.parent_manipulator[full_field_name]
-                        data = field.extract_data(self.data)
-                        errors = self.errors.get(full_field_name, [])
-                        collection[field_name] = FormFieldWrapper(field, data, errors)
-                collections[i] = FormFieldCollection(collection)
-            self._collections = collections
-
-
-class FormField(object):
-    """Abstract class representing a form field.
-
-    Classes that extend FormField should define the following attributes:
-        field_name
-            The field's name for use by programs.
-        validator_list
-            A list of validation tests (callback functions) that the data for
-            this field must pass in order to be added or changed.
-        is_required
-            A Boolean. Is it a required field?
-    Subclasses should also implement a render(data) method, which is responsible
-    for rending the form field in XHTML.
-    """
-    def __str__(self):
-        return self.render('')
-
-    def __repr__(self):
-        return 'FormField "%s"' % self.field_name
-
-    def prepare(self, new_data):
-        "Hook for doing something to new_data (in place) before validation."
-        pass
-
-    def html2python(data):
-        "Hook for converting an HTML datatype (e.g. 'on' for checkboxes) to a Python type"
-        return data
-    html2python = staticmethod(html2python)
-
-    def render(self, data):
-        raise NotImplementedError
-
-    def get_member_name(self):
-        if hasattr(self, 'member_name'):
-            return self.member_name
-        else:
-            return self.field_name
-
-    def extract_data(self, data_dict):
-        if hasattr(self, 'requires_data_list') and hasattr(data_dict, 'getlist'):
-            data = data_dict.getlist(self.get_member_name())
-        else:
-            data = data_dict.get(self.get_member_name(), None)
-        if data is None:
-            data = ''
-        return data
-
-    def convert_post_data(self, new_data):
-        name = self.get_member_name()
-        if new_data.has_key(self.field_name):
-            d = new_data.getlist(self.field_name)
-            try:
-                converted_data = [self.__class__.html2python(data) for data in d]
-            except ValueError:
-                converted_data = d
-            new_data.setlist(name, converted_data)
-        else:
-            try:
-                #individual fields deal with None values themselves
-                new_data.setlist(name, [self.__class__.html2python(None)])
-            except EmptyValue:
-                new_data.setlist(name, [])
-
-
-    def run_validator(self, new_data, validator):
-        if self.is_required or new_data.get(self.field_name, False) or hasattr(validator, 'always_test'):
-            if hasattr(self, 'requires_data_list'):
-                validator(new_data.getlist(self.field_name), new_data)
-            else:
-                validator(new_data.get(self.field_name, ''), new_data)
-
-    def get_validation_errors(self, new_data):
-        errors = {}
-        if self.is_required and not new_data.get(self.field_name, False):
-            errors.setdefault(self.field_name, []).append(gettext('This field is required.'))
-            return errors
-        try:
-            for validator in self.validator_list:
-                try:
-                    self.run_validator(new_data, validator)
-                except validators.ValidationError, e:
-                    errors.setdefault(self.field_name, []).extend(e.messages)
-        # If a CriticalValidationError is raised, ignore any other ValidationErrors
-        # for this particular field
-        except validators.CriticalValidationError, e:
-            errors.setdefault(self.field_name, []).extend(e.messages)
-        return errors
-
-    def get_id(self):
-        "Returns the HTML 'id' attribute for this form field."
-        return FORM_FIELD_ID_PREFIX + self.field_name
-
-####################
-# GENERIC WIDGETS  #
-####################
-
-class TextField(FormField):
-    input_type = "text"
-    def __init__(self, field_name, length=30, maxlength=None, is_required=False, validator_list=None, member_name=None):
-        if validator_list is None: validator_list = []
-        self.field_name = field_name
-        self.length, self.maxlength = length, maxlength
-        self.is_required = is_required
-        self.validator_list = [self.isValidLength, self.hasNoNewlines] + validator_list
-        if member_name != None:
-            self.member_name = member_name
-
-    def isValidLength(self, data, form):
-        if data and self.maxlength and len(data.decode(settings.DEFAULT_CHARSET)) > self.maxlength:
-            raise validators.ValidationError, ngettext("Ensure your text is less than %s character.",
-                "Ensure your text is less than %s characters.", self.maxlength) % self.maxlength
-
-    def hasNoNewlines(self, data, form):
-        if data and '\n' in data:
-            raise validators.ValidationError, gettext("Line breaks are not allowed here.")
-
-    def render(self, data):
-        if data is None:
-            data = ''
-        maxlength = ''
-        if self.maxlength:
-            maxlength = 'maxlength="%s" ' % self.maxlength
-        if isinstance(data, unicode):
-            data = data.encode(settings.DEFAULT_CHARSET)
-        return '<input type="%s" id="%s" class="v%s%s" name="%s" size="%s" value="%s" %s/>' % \
-            (self.input_type, self.get_id(), self.__class__.__name__, self.is_required and ' required' or '',
-            self.field_name, self.length, escape(data), maxlength)
-
-    def html2python(data):
-        return data
-    html2python = staticmethod(html2python)
-
-class PasswordField(TextField):
-    input_type = "password"
-
-class LargeTextField(TextField):
-    def __init__(self, field_name, rows=10, cols=40, is_required=False, validator_list=None, maxlength=None):
-        if validator_list is None: validator_list = []
-        self.field_name = field_name
-        self.rows, self.cols, self.is_required = rows, cols, is_required
-        self.validator_list = validator_list[:]
-        if maxlength:
-            self.validator_list.append(self.isValidLength)
-            self.maxlength = maxlength
-
-    def render(self, data):
-        if data is None:
-            data = ''
-        if isinstance(data, unicode):
-            data = data.encode(settings.DEFAULT_CHARSET)
-        return '<textarea id="%s" class="v%s%s" name="%s" rows="%s" cols="%s">%s</textarea>' % \
-            (self.get_id(), self.__class__.__name__, self.is_required and ' required' or '',
-            self.field_name, self.rows, self.cols, escape(data))
-
-class HiddenField(FormField):
-    def __init__(self, field_name, is_required=False, validator_list=None):
-        if validator_list is None: validator_list = []
-        self.field_name, self.is_required = field_name, is_required
-        self.validator_list = validator_list[:]
-
-    def render(self, data):
-        return '<input type="hidden" id="%s" name="%s" value="%s" />' % \
-            (self.get_id(), self.field_name, escape(data))
-
-class CheckboxField(FormField):
-    def __init__(self, field_name, checked_by_default=False, validator_list=None, is_required=False):
-        if validator_list is None: validator_list = []
-        self.field_name = field_name
-        self.checked_by_default = checked_by_default
-        self.is_required = is_required
-        self.validator_list = validator_list[:]
-
-    def render(self, data):
-        checked_html = ''
-        if data or (data is '' and self.checked_by_default):
-            checked_html = ' checked="checked"'
-        return '<input type="checkbox" id="%s" class="v%s" name="%s"%s />' % \
-            (self.get_id(), self.__class__.__name__,
-            self.field_name, checked_html)
-
-    def html2python(data):
-        "Convert value from browser ('on' or '') to a Python boolean"
-        if data == 'on':
-            return True
-        return False
-    html2python = staticmethod(html2python)
-
-class SelectField(FormField):
-    def __init__(self, field_name, choices=None, size=1, is_required=False, validator_list=None, member_name=None):
-        if validator_list is None: validator_list = []
-        if choices is None: choices = []
-        self.field_name = field_name
-        # choices is a list of (value, human-readable key) tuples because order matters
-        self.choices, self.size, self.is_required = choices, size, is_required
-        self.validator_list = [self.isValidChoice] + validator_list
-        if member_name != None:
-            self.member_name = member_name
-
-    def render(self, data):
-        output = ['<select id="%s" class="v%s%s" name="%s" size="%s">' % \
-            (self.get_id(), self.__class__.__name__,
-             self.is_required and ' required' or '', self.field_name, self.size)]
-        str_data = str(data) # normalize to string
-        for value, display_name in self.choices:
-            selected_html = ''
-            if str(value) == str_data:
-                selected_html = ' selected="selected"'
-            output.append('    <option value="%s"%s>%s</option>' % (escape(value), selected_html, escape(display_name)))
-        output.append('  </select>')
-        return '\n'.join(output)
-
-    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, gettext("Select a valid choice; '%(data)s' is not in %(choices)s.") % {'data': str_data, 'choices': str_choices}
-
-class NullSelectField(SelectField):
-    "This SelectField converts blank fields to None"
-    def html2python(data):
-        if not data:
-            return None
-        return data
-    html2python = staticmethod(html2python)
-
-class RadioSelectField(FormField):
-    def __init__(self, field_name, choices=None, ul_class='', is_required=False, validator_list=None, member_name=None):
-        if validator_list is None: validator_list = []
-        if choices is None: choices = []
-        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, RadioFieldRenderer, 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 RadioFieldRenderer:
-            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%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 = str(data) # normalize to string
-        for i, (value, display_name) in enumerate(self.choices):
-            selected_html = ''
-            if str(value) == str_data:
-                selected_html = ' checked="checked"'
-            datalist.append({
-                'value': value,
-                'name': display_name,
-                'field': '<input type="radio" id="%s" name="%s" value="%s"%s/>' % \
-                    (self.get_id() + '_' + str(i), self.field_name, value, selected_html),
-                'label': '<label for="%s">%s</label>' % \
-                    (self.get_id() + '_' + str(i), display_name),
-            })
-        return RadioFieldRenderer(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, gettext("Select a valid choice; '%(data)s' is not in %(choices)s.") % {'data':str_data, 'choices':str_choices}
-
-class NullBooleanField(SelectField):
-    "This SelectField provides 'Yes', 'No' and 'Unknown', mapping results to True, False or None"
-    def __init__(self, field_name, is_required=False, validator_list=None):
-        if validator_list is None: validator_list = []
-        SelectField.__init__(self, field_name, choices=[('1', 'Unknown'), ('2', 'Yes'), ('3', 'No')],
-            is_required=is_required, validator_list=validator_list)
-
-    def render(self, data):
-        if data is None: data = '1'
-        elif data == True: data = '2'
-        elif data == False: data = '3'
-        return SelectField.render(self, data)
-
-    def html2python(data):
-        return {None: None, '1': None, '2': True, '3': False}[data]
-    html2python = staticmethod(html2python)
-
-class SelectMultipleField(SelectField):
-    requires_data_list = True
-    def render(self, data):
-        output = ['<select id="%s" class="v%s%s" name="%s" size="%s" multiple="multiple">' % \
-            (self.get_id(), self.__class__.__name__, self.is_required and ' required' or '',
-            self.field_name, self.size)]
-        str_data_list = map(str, data) # normalize to strings
-        for value, choice in self.choices:
-            selected_html = ''
-            if str(value) in str_data_list:
-                selected_html = ' selected="selected"'
-            output.append('    <option value="%s"%s>%s</option>' % (escape(value), selected_html, escape(choice)))
-        output.append('  </select>')
-        return '\n'.join(output)
-
-    def isValidChoice(self, field_data, all_data):
-        # data is something like ['1', '2', '3']
-        str_choices = [str(item[0]) for item in self.choices]
-        for val in map(str, field_data):
-            if val not in str_choices:
-                raise validators.ValidationError, gettext("Select a valid choice; '%(data)s' is not in %(choices)s.") % {'data':val, 'choices':str_choices}
-
-    def html2python(data):
-        if data is None:
-            raise EmptyValue
-        return data
-    html2python = staticmethod(html2python)
-
-class CheckboxSelectMultipleField(SelectMultipleField):
-    """
-    This has an identical interface to SelectMultipleField, except the rendered
-    widget is different. Instead of a <select multiple>, this widget outputs a
-    <ul> of <input type="checkbox">es.
-
-    Of course, that results in multiple form elements for the same "single"
-    field, so this class's prepare() method flattens the split data elements
-    back into the single list that validators, renderers and save() expect.
-    """
-    requires_data_list = True
-    def __init__(self, field_name, choices=None, ul_class='', validator_list=None):
-        if validator_list is None: validator_list = []
-        if choices is None: choices = []
-        self.ul_class = ul_class
-        SelectMultipleField.__init__(self, field_name, choices, size=1, is_required=False, validator_list=validator_list)
-
-    def prepare(self, new_data):
-        # new_data has "split" this field into several fields, so flatten it
-        # back into a single list.
-        data_list = []
-        for value, readable_value in self.choices:
-            if new_data.get('%s%s' % (self.field_name, value), '') == 'on':
-                data_list.append(value)
-        new_data.setlist(self.field_name, data_list)
-
-    def render(self, data):
-        output = ['<ul%s>' % (self.ul_class and ' class="%s"' % self.ul_class or '')]
-        str_data_list = map(str, data) # normalize to strings
-        for value, choice in self.choices:
-            checked_html = ''
-            if str(value) in str_data_list:
-                checked_html = ' checked="checked"'
-            field_name = '%s%s' % (self.field_name, value)
-            output.append('<li><input type="checkbox" id="%s" class="v%s" name="%s"%s value="on" /> <label for="%s">%s</label></li>' % \
-                (self.get_id() + escape(value), self.__class__.__name__, field_name, checked_html,
-                self.get_id() + escape(value), choice))
-        output.append('</ul>')
-        return '\n'.join(output)
-
-####################
-# FILE UPLOADS     #
-####################
-
-class FileUploadField(FormField):
-    def __init__(self, field_name, is_required=False, validator_list=None):
-        if validator_list is None: validator_list = []
-        self.field_name, self.is_required = field_name, is_required
-        self.validator_list = [self.isNonEmptyFile] + validator_list
-
-    def isNonEmptyFile(self, field_data, all_data):
-        try:
-            content = field_data['content']
-        except TypeError:
-            raise validators.CriticalValidationError, gettext("No file was submitted. Check the encoding type on the form.")
-        if not content:
-            raise validators.CriticalValidationError, gettext("The submitted file is empty.")
-
-    def render(self, data):
-        return '<input type="file" id="%s" class="v%s" name="%s" />' % \
-            (self.get_id(), self.__class__.__name__, self.field_name)
-
-    def html2python(data):
-        if data is None:
-            raise EmptyValue
-        return data
-    html2python = staticmethod(html2python)
-
-class ImageUploadField(FileUploadField):
-    "A FileUploadField that raises CriticalValidationError if the uploaded file isn't an image."
-    def __init__(self, *args, **kwargs):
-        FileUploadField.__init__(self, *args, **kwargs)
-        self.validator_list.insert(0, self.isValidImage)
-
-    def isValidImage(self, field_data, all_data):
-        try:
-            validators.isValidImage(field_data, all_data)
-        except validators.ValidationError, e:
-            raise validators.CriticalValidationError, e.messages
-
-####################
-# INTEGERS/FLOATS  #
-####################
-
-class IntegerField(TextField):
-    def __init__(self, field_name, length=10, maxlength=None, is_required=False, validator_list=None, member_name=None):
-        if validator_list is None: validator_list = []
-        validator_list = [self.isInteger] + validator_list
-        if member_name is not None:
-            self.member_name = member_name
-        TextField.__init__(self, field_name, length, maxlength, is_required, validator_list)
-
-    def isInteger(self, field_data, all_data):
-        try:
-            validators.isInteger(field_data, all_data)
-        except validators.ValidationError, e:
-            raise validators.CriticalValidationError, e.messages
-
-    def html2python(data):
-        if data == '' or data is None:
-            return None
-        return int(data)
-    html2python = staticmethod(html2python)
-
-class SmallIntegerField(IntegerField):
-    def __init__(self, field_name, length=5, maxlength=5, is_required=False, validator_list=None):
-        if validator_list is None: validator_list = []
-        validator_list = [self.isSmallInteger] + validator_list
-        IntegerField.__init__(self, field_name, length, maxlength, is_required, validator_list)
-
-    def isSmallInteger(self, field_data, all_data):
-        if not -32768 <= int(field_data) <= 32767:
-            raise validators.CriticalValidationError, gettext("Enter a whole number between -32,768 and 32,767.")
-
-class PositiveIntegerField(IntegerField):
-    def __init__(self, field_name, length=10, maxlength=None, is_required=False, validator_list=None):
-        if validator_list is None: validator_list = []
-        validator_list = [self.isPositive] + validator_list
-        IntegerField.__init__(self, field_name, length, maxlength, is_required, validator_list)
-
-    def isPositive(self, field_data, all_data):
-        if int(field_data) < 0:
-            raise validators.CriticalValidationError, gettext("Enter a positive number.")
-
-class PositiveSmallIntegerField(IntegerField):
-    def __init__(self, field_name, length=5, maxlength=None, is_required=False, validator_list=None):
-        if validator_list is None: validator_list = []
-        validator_list = [self.isPositiveSmall] + validator_list
-        IntegerField.__init__(self, field_name, length, maxlength, is_required, validator_list)
-
-    def isPositiveSmall(self, field_data, all_data):
-        if not 0 <= int(field_data) <= 32767:
-            raise validators.CriticalValidationError, gettext("Enter a whole number between 0 and 32,767.")
-
-class FloatField(TextField):
-    def __init__(self, field_name, max_digits, decimal_places, is_required=False, validator_list=None):
-        if validator_list is None: validator_list = []
-        self.max_digits, self.decimal_places = max_digits, decimal_places
-        validator_list = [self.isValidFloat] + validator_list
-        TextField.__init__(self, field_name, max_digits+2, max_digits+2, is_required, validator_list)
-
-    def isValidFloat(self, field_data, all_data):
-        v = validators.IsValidFloat(self.max_digits, self.decimal_places)
-        try:
-            v(field_data, all_data)
-        except validators.ValidationError, e:
-            raise validators.CriticalValidationError, e.messages
-
-    def html2python(data):
-        if data == '' or data is None:
-            return None
-        return float(data)
-    html2python = staticmethod(html2python)
-
-####################
-# DATES AND TIMES  #
-####################
-
-class DatetimeField(TextField):
-    """A FormField that automatically converts its data to a datetime.datetime object.
-    The data should be in the format YYYY-MM-DD HH:MM:SS."""
-    def __init__(self, field_name, length=30, maxlength=None, is_required=False, validator_list=None):
-        if validator_list is None: validator_list = []
-        self.field_name = field_name
-        self.length, self.maxlength = length, maxlength
-        self.is_required = is_required
-        self.validator_list = [validators.isValidANSIDatetime] + validator_list
-
-    def html2python(data):
-        "Converts the field into a datetime.datetime object"
-        import datetime
-        try:
-            date, time = data.split()
-            y, m, d = date.split('-')
-            timebits = time.split(':')
-            h, mn = timebits[:2]
-            if len(timebits) > 2:
-                s = int(timebits[2])
-            else:
-                s = 0
-            return datetime.datetime(int(y), int(m), int(d), int(h), int(mn), s)
-        except ValueError:
-            return None
-    html2python = staticmethod(html2python)
-
-class DateField(TextField):
-    """A FormField that automatically converts its data to a datetime.date object.
-    The data should be in the format YYYY-MM-DD."""
-    def __init__(self, field_name, is_required=False, validator_list=None):
-        if validator_list is None: validator_list = []
-        validator_list = [self.isValidDate] + validator_list
-        TextField.__init__(self, field_name, length=10, maxlength=10,
-            is_required=is_required, validator_list=validator_list)
-
-    def isValidDate(self, field_data, all_data):
-        try:
-            validators.isValidANSIDate(field_data, all_data)
-        except validators.ValidationError, e:
-            raise validators.CriticalValidationError, e.messages
-
-    def html2python(data):
-        "Converts the field into a datetime.date object"
-        import time, datetime
-        try:
-            time_tuple = time.strptime(data, '%Y-%m-%d')
-            return datetime.date(*time_tuple[0:3])
-        except (ValueError, TypeError):
-            return None
-    html2python = staticmethod(html2python)
-
-class TimeField(TextField):
-    """A FormField that automatically converts its data to a datetime.time object.
-    The data should be in the format HH:MM:SS or HH:MM:SS.mmmmmm."""
-    def __init__(self, field_name, is_required=False, validator_list=None):
-        if validator_list is None: validator_list = []
-        validator_list = [self.isValidTime] + validator_list
-        TextField.__init__(self, field_name, length=8, maxlength=8,
-            is_required=is_required, validator_list=validator_list)
-
-    def isValidTime(self, field_data, all_data):
-        try:
-            validators.isValidANSITime(field_data, all_data)
-        except validators.ValidationError, e:
-            raise validators.CriticalValidationError, e.messages
-
-    def html2python(data):
-        "Converts the field into a datetime.time object"
-        import time, datetime
-        try:
-            part_list = data.split('.')
-            try:
-                time_tuple = time.strptime(part_list[0], '%H:%M:%S')
-            except ValueError: # seconds weren't provided
-                time_tuple = time.strptime(part_list[0], '%H:%M')
-            t = datetime.time(*time_tuple[3:6])
-            if (len(part_list) == 2):
-                t = t.replace(microsecond=int(part_list[1]))
-            return t
-        except (ValueError, TypeError, AttributeError):
-            return None
-    html2python = staticmethod(html2python)
-
-####################
-# INTERNET-RELATED #
-####################
-
-class EmailField(TextField):
-    "A convenience FormField for validating e-mail addresses"
-    def __init__(self, field_name, length=50, maxlength=75, is_required=False, validator_list=None):
-        if validator_list is None: validator_list = []
-        validator_list = [self.isValidEmail] + validator_list
-        TextField.__init__(self, field_name, length, maxlength=maxlength,
-            is_required=is_required, validator_list=validator_list)
-
-    def isValidEmail(self, field_data, all_data):
-        try:
-            validators.isValidEmail(field_data, all_data)
-        except validators.ValidationError, e:
-            raise validators.CriticalValidationError, e.messages
-
-class URLField(TextField):
-    "A convenience FormField for validating URLs"
-    def __init__(self, field_name, length=50, maxlength=200, is_required=False, validator_list=None):
-        if validator_list is None: validator_list = []
-        validator_list = [self.isValidURL] + validator_list
-        TextField.__init__(self, field_name, length=length, maxlength=maxlength,
-            is_required=is_required, validator_list=validator_list)
-
-    def isValidURL(self, field_data, all_data):
-        try:
-            validators.isValidURL(field_data, all_data)
-        except validators.ValidationError, e:
-            raise validators.CriticalValidationError, e.messages
-
-class IPAddressField(TextField):
-    def __init__(self, field_name, length=15, maxlength=15, is_required=False, validator_list=None):
-        if validator_list is None: validator_list = []
-        validator_list = [self.isValidIPAddress] + validator_list
-        TextField.__init__(self, field_name, length=length, maxlength=maxlength,
-            is_required=is_required, validator_list=validator_list)
-
-    def isValidIPAddress(self, field_data, all_data):
-        try:
-            validators.isValidIPAddress4(field_data, all_data)
-        except validators.ValidationError, e:
-            raise validators.CriticalValidationError, e.messages
-
-    def html2python(data):
-        return data or None
-    html2python = staticmethod(html2python)
-
-####################
-# MISCELLANEOUS    #
-####################
-
-class FilePathField(SelectField):
-    "A SelectField whose choices are the files in a given directory."
-    def __init__(self, field_name, path, match=None, recursive=False, is_required=False, validator_list=None):
-        import os
-        from django.db.models import BLANK_CHOICE_DASH
-        if match is not None:
-            import re
-            match_re = re.compile(match)
-        choices = not is_required and BLANK_CHOICE_DASH[:] or []
-        if recursive:
-            for root, dirs, files in os.walk(path):
-                for f in files:
-                    if match is None or match_re.search(f):
-                        choices.append((os.path.join(root, f), f))
-        else:
-            try:
-                for f in os.listdir(path):
-                    full_file = os.path.join(path, f)
-                    if os.path.isfile(full_file) and (match is None or match_re.search(f)):
-                        choices.append((full_file, f))
-            except OSError:
-                pass
-        SelectField.__init__(self, field_name, choices, 1, is_required, validator_list)
-
-class PhoneNumberField(TextField):
-    "A convenience FormField for validating phone numbers (e.g. '630-555-1234')"
-    def __init__(self, field_name, is_required=False, validator_list=None):
-        if validator_list is None: validator_list = []
-        validator_list = [self.isValidPhone] + validator_list
-        TextField.__init__(self, field_name, length=12, maxlength=12,
-            is_required=is_required, validator_list=validator_list)
-
-    def isValidPhone(self, field_data, all_data):
-        try:
-            validators.isValidPhone(field_data, all_data)
-        except validators.ValidationError, e:
-            raise validators.CriticalValidationError, e.messages
-
-class USStateField(TextField):
-    "A convenience FormField for validating U.S. states (e.g. 'IL')"
-    def __init__(self, field_name, is_required=False, validator_list=None):
-        if validator_list is None: validator_list = []
-        validator_list = [self.isValidUSState] + validator_list
-        TextField.__init__(self, field_name, length=2, maxlength=2,
-            is_required=is_required, validator_list=validator_list)
-
-    def isValidUSState(self, field_data, all_data):
-        try:
-            validators.isValidUSState(field_data, all_data)
-        except validators.ValidationError, e:
-            raise validators.CriticalValidationError, e.messages
-
-    def html2python(data):
-        return data.upper() # Should always be stored in upper case
-    html2python = staticmethod(html2python)
-
-class CommaSeparatedIntegerField(TextField):
-    "A convenience FormField for validating comma-separated integer fields"
-    def __init__(self, field_name, maxlength=None, is_required=False, validator_list=None):
-        if validator_list is None: validator_list = []
-        validator_list = [self.isCommaSeparatedIntegerList] + validator_list
-        TextField.__init__(self, field_name, length=20, maxlength=maxlength,
-            is_required=is_required, validator_list=validator_list)
-
-    def isCommaSeparatedIntegerList(self, field_data, all_data):
-        try:
-            validators.isCommaSeparatedIntegerList(field_data, all_data)
-        except validators.ValidationError, e:
-            raise validators.CriticalValidationError, e.messages
-
-    def render(self, data):
-        if data is None:
-            data = ''
-        elif isinstance(data, (list, tuple)):
-            data = ','.join(data)
-        return super(CommaSeparatedIntegerField, self).render(data)
-
-class RawIdAdminField(CommaSeparatedIntegerField):
-    def html2python(data):
-        if data:
-            return data.split(',')
-        else:
-            return []
-    html2python = staticmethod(html2python)
-
-class XMLLargeTextField(LargeTextField):
-    """
-    A LargeTextField with an XML validator. The schema_path argument is the
-    full path to a Relax NG compact schema to validate against.
-    """
-    def __init__(self, field_name, schema_path, **kwargs):
-        self.schema_path = schema_path
-        kwargs.setdefault('validator_list', []).insert(0, self.isValidXML)
-        LargeTextField.__init__(self, field_name, **kwargs)
-
-    def isValidXML(self, field_data, all_data):
-        v = validators.RelaxNGCompact(self.schema_path)
-        try:
-            v(field_data, all_data)
-        except validators.ValidationError, e:
-            raise validators.CriticalValidationError, e.messages
+from django.oldforms import *
diff --git a/django/http/__init__.py b/django/http/__init__.py
index bb0e973aae..48f10329fd 100644
--- a/django/http/__init__.py
+++ b/django/http/__init__.py
@@ -208,7 +208,7 @@ class HttpResponse(object):
         if path is not None:
             self.cookies[key]['path'] = path
         if domain is not None:
-            self.cookies[key]['domain'] = path
+            self.cookies[key]['domain'] = domain
         self.cookies[key]['expires'] = 0
         self.cookies[key]['max-age'] = 0
 
diff --git a/django/newforms/__init__.py b/django/newforms/__init__.py
index 2a472d7b39..0d9c68f9e0 100644
--- a/django/newforms/__init__.py
+++ b/django/newforms/__init__.py
@@ -13,16 +13,5 @@ TODO:
 from util import ValidationError
 from widgets import *
 from fields import *
-from forms import Form
-
-##########################
-# DATABASE API SHORTCUTS #
-##########################
-
-def form_for_model(model):
-    "Returns a Form instance for the given Django model class."
-    raise NotImplementedError
-
-def form_for_fields(field_list):
-    "Returns a Form instance for the given list of Django database field instances."
-    raise NotImplementedError
+from forms import *
+from models import *
diff --git a/django/newforms/extras/__init__.py b/django/newforms/extras/__init__.py
new file mode 100644
index 0000000000..a7f6a9b3f6
--- /dev/null
+++ b/django/newforms/extras/__init__.py
@@ -0,0 +1 @@
+from widgets import *
diff --git a/django/newforms/extras/widgets.py b/django/newforms/extras/widgets.py
new file mode 100644
index 0000000000..1011934fb8
--- /dev/null
+++ b/django/newforms/extras/widgets.py
@@ -0,0 +1,59 @@
+"""
+Extra HTML Widget classes
+"""
+
+from django.newforms.widgets import Widget, Select
+from django.utils.dates import MONTHS
+import datetime
+
+__all__ = ('SelectDateWidget',)
+
+class SelectDateWidget(Widget):
+    """
+    A Widget that splits date input into three <select> boxes.
+
+    This also serves as an example of a Widget that has more than one HTML
+    element and hence implements value_from_datadict.
+    """
+    month_field = '%s_month'
+    day_field = '%s_day'
+    year_field = '%s_year'
+
+    def __init__(self, attrs=None, years=None):
+        # years is an optional list/tuple of years to use in the "year" select box.
+        self.attrs = attrs or {}
+        if years:
+            self.years = years
+        else:
+            this_year = datetime.date.today().year
+            self.years = range(this_year, this_year+10)
+
+    def render(self, name, value, attrs=None):
+        try:
+            value = datetime.date(*map(int, value.split('-')))
+            year_val, month_val, day_val = value.year, value.month, value.day
+        except (AttributeError, TypeError, ValueError):
+            year_val = month_val = day_val = None
+
+        output = []
+
+        month_choices = MONTHS.items()
+        month_choices.sort()
+        select_html = Select(choices=month_choices).render(self.month_field % name, month_val)
+        output.append(select_html)
+
+        day_choices = [(i, i) for i in range(1, 32)]
+        select_html = Select(choices=day_choices).render(self.day_field % name, day_val)
+        output.append(select_html)
+
+        year_choices = [(i, i) for i in self.years]
+        select_html = Select(choices=year_choices).render(self.year_field % name, year_val)
+        output.append(select_html)
+
+        return u'\n'.join(output)
+
+    def value_from_datadict(self, data, name):
+        y, m, d = data.get(self.year_field % name), data.get(self.month_field % name), data.get(self.day_field % name)
+        if y and m and d:
+            return '%s-%s-%s' % (y, m, d)
+        return None
diff --git a/django/newforms/fields.py b/django/newforms/fields.py
index 40fc18bd3e..5c6d46ddac 100644
--- a/django/newforms/fields.py
+++ b/django/newforms/fields.py
@@ -2,8 +2,9 @@
 Field classes
 """
 
-from util import ValidationError, DEFAULT_ENCODING, smart_unicode
-from widgets import TextInput, CheckboxInput, Select, SelectMultiple
+from django.utils.translation import gettext
+from util import ValidationError, smart_unicode
+from widgets import TextInput, PasswordInput, CheckboxInput, Select, SelectMultiple
 import datetime
 import re
 import time
@@ -11,6 +12,7 @@ import time
 __all__ = (
     'Field', 'CharField', 'IntegerField',
     'DEFAULT_DATE_INPUT_FORMATS', 'DateField',
+    'DEFAULT_TIME_INPUT_FORMATS', 'TimeField',
     'DEFAULT_DATETIME_INPUT_FORMATS', 'DateTimeField',
     'RegexField', 'EmailField', 'URLField', 'BooleanField',
     'ChoiceField', 'MultipleChoiceField',
@@ -31,11 +33,19 @@ class Field(object):
     # Tracks each time a Field instance is created. Used to retain order.
     creation_counter = 0
 
-    def __init__(self, required=True, widget=None):
-        self.required = required
+    def __init__(self, required=True, widget=None, label=None):
+        if label is not None:
+            label = smart_unicode(label)
+        self.required, self.label = required, label
         widget = widget or self.widget
         if isinstance(widget, type):
             widget = widget()
+
+        # Hook into self.widget_attrs() for any Field-specific HTML attributes.
+        extra_attrs = self.widget_attrs(widget)
+        if extra_attrs:
+            widget.attrs.update(extra_attrs)
+
         self.widget = widget
 
         # Increase the creation counter, and save our local copy.
@@ -50,36 +60,62 @@ class Field(object):
         Raises ValidationError for any errors.
         """
         if self.required and value in EMPTY_VALUES:
-            raise ValidationError(u'This field is required.')
+            raise ValidationError(gettext(u'This field is required.'))
         return value
 
+    def widget_attrs(self, widget):
+        """
+        Given a Widget instance (*not* a Widget class), returns a dictionary of
+        any HTML attributes that should be added to the Widget, based on this
+        Field.
+        """
+        return {}
+
 class CharField(Field):
-    def __init__(self, max_length=None, min_length=None, required=True, widget=None):
-        Field.__init__(self, required, widget)
+    def __init__(self, max_length=None, min_length=None, required=True, widget=None, label=None):
         self.max_length, self.min_length = max_length, min_length
+        Field.__init__(self, required, widget, label)
 
     def clean(self, value):
         "Validates max_length and min_length. Returns a Unicode object."
         Field.clean(self, value)
-        if value in EMPTY_VALUES: value = u''
+        if value in EMPTY_VALUES:
+            value = u''
+            if not self.required:
+                return value
         value = smart_unicode(value)
         if self.max_length is not None and len(value) > self.max_length:
-            raise ValidationError(u'Ensure this value has at most %d characters.' % self.max_length)
+            raise ValidationError(gettext(u'Ensure this value has at most %d characters.') % self.max_length)
         if self.min_length is not None and len(value) < self.min_length:
-            raise ValidationError(u'Ensure this value has at least %d characters.' % self.min_length)
+            raise ValidationError(gettext(u'Ensure this value has at least %d characters.') % self.min_length)
         return value
 
+    def widget_attrs(self, widget):
+        if self.max_length is not None and isinstance(widget, (TextInput, PasswordInput)):
+            return {'maxlength': str(self.max_length)}
+
 class IntegerField(Field):
+    def __init__(self, max_value=None, min_value=None, required=True, widget=None, label=None):
+        self.max_value, self.min_value = max_value, min_value
+        Field.__init__(self, required, widget, label)
+
     def clean(self, value):
         """
         Validates that int() can be called on the input. Returns the result
         of int().
         """
         super(IntegerField, self).clean(value)
+        if not self.required and value in EMPTY_VALUES:
+            return u''
         try:
-            return int(value)
+            value = int(value)
         except (ValueError, TypeError):
-            raise ValidationError(u'Enter a whole number.')
+            raise ValidationError(gettext(u'Enter a whole number.'))
+        if self.max_value is not None and value > self.max_value:
+            raise ValidationError(gettext(u'Ensure this value is less than or equal to %s.') % self.max_value)
+        if self.min_value is not None and value < self.min_value:
+            raise ValidationError(gettext(u'Ensure this value is greater than or equal to %s.') % self.min_value)
+        return value
 
 DEFAULT_DATE_INPUT_FORMATS = (
     '%Y-%m-%d', '%m/%d/%Y', '%m/%d/%y', # '2006-10-25', '10/25/2006', '10/25/06'
@@ -90,8 +126,8 @@ DEFAULT_DATE_INPUT_FORMATS = (
 )
 
 class DateField(Field):
-    def __init__(self, input_formats=None, required=True, widget=None):
-        Field.__init__(self, required, widget)
+    def __init__(self, input_formats=None, required=True, widget=None, label=None):
+        Field.__init__(self, required, widget, label)
         self.input_formats = input_formats or DEFAULT_DATE_INPUT_FORMATS
 
     def clean(self, value):
@@ -111,7 +147,34 @@ class DateField(Field):
                 return datetime.date(*time.strptime(value, format)[:3])
             except ValueError:
                 continue
-        raise ValidationError(u'Enter a valid date.')
+        raise ValidationError(gettext(u'Enter a valid date.'))
+
+DEFAULT_TIME_INPUT_FORMATS = (
+    '%H:%M:%S',     # '14:30:59'
+    '%H:%M',        # '14:30'
+)
+
+class TimeField(Field):
+    def __init__(self, input_formats=None, required=True, widget=None, label=None):
+        Field.__init__(self, required, widget, label)
+        self.input_formats = input_formats or DEFAULT_TIME_INPUT_FORMATS
+
+    def clean(self, value):
+        """
+        Validates that the input can be converted to a time. Returns a Python
+        datetime.time object.
+        """
+        Field.clean(self, value)
+        if value in EMPTY_VALUES:
+            return None
+        if isinstance(value, datetime.time):
+            return value
+        for format in self.input_formats:
+            try:
+                return datetime.time(*time.strptime(value, format)[3:6])
+            except ValueError:
+                continue
+        raise ValidationError(gettext(u'Enter a valid time.'))
 
 DEFAULT_DATETIME_INPUT_FORMATS = (
     '%Y-%m-%d %H:%M:%S',     # '2006-10-25 14:30:59'
@@ -126,8 +189,8 @@ DEFAULT_DATETIME_INPUT_FORMATS = (
 )
 
 class DateTimeField(Field):
-    def __init__(self, input_formats=None, required=True, widget=None):
-        Field.__init__(self, required, widget)
+    def __init__(self, input_formats=None, required=True, widget=None, label=None):
+        Field.__init__(self, required, widget, label)
         self.input_formats = input_formats or DEFAULT_DATETIME_INPUT_FORMATS
 
     def clean(self, value):
@@ -147,20 +210,22 @@ class DateTimeField(Field):
                 return datetime.datetime(*time.strptime(value, format)[:6])
             except ValueError:
                 continue
-        raise ValidationError(u'Enter a valid date/time.')
+        raise ValidationError(gettext(u'Enter a valid date/time.'))
 
 class RegexField(Field):
-    def __init__(self, regex, error_message=None, required=True, widget=None):
+    def __init__(self, regex, max_length=None, min_length=None, error_message=None,
+            required=True, widget=None, label=None):
         """
         regex can be either a string or a compiled regular expression object.
         error_message is an optional error message to use, if
         'Enter a valid value' is too generic for you.
         """
-        Field.__init__(self, required, widget)
+        Field.__init__(self, required, widget, label)
         if isinstance(regex, basestring):
             regex = re.compile(regex)
         self.regex = regex
-        self.error_message = error_message or u'Enter a valid value.'
+        self.max_length, self.min_length = max_length, min_length
+        self.error_message = error_message or gettext(u'Enter a valid value.')
 
     def clean(self, value):
         """
@@ -170,6 +235,12 @@ class RegexField(Field):
         Field.clean(self, value)
         if value in EMPTY_VALUES: value = u''
         value = smart_unicode(value)
+        if not self.required and value == u'':
+            return value
+        if self.max_length is not None and len(value) > self.max_length:
+            raise ValidationError(gettext(u'Ensure this value has at most %d characters.') % self.max_length)
+        if self.min_length is not None and len(value) < self.min_length:
+            raise ValidationError(gettext(u'Ensure this value has at least %d characters.') % self.min_length)
         if not self.regex.search(value):
             raise ValidationError(self.error_message)
         return value
@@ -180,8 +251,8 @@ email_re = re.compile(
     r')@(?:[A-Z0-9-]+\.)+[A-Z]{2,6}$', re.IGNORECASE)  # domain
 
 class EmailField(RegexField):
-    def __init__(self, required=True, widget=None):
-        RegexField.__init__(self, email_re, u'Enter a valid e-mail address.', required, widget)
+    def __init__(self, max_length=None, min_length=None, required=True, widget=None, label=None):
+        RegexField.__init__(self, email_re, max_length, min_length, gettext(u'Enter a valid e-mail address.'), required, widget, label)
 
 url_re = re.compile(
     r'^https?://' # http:// or https://
@@ -197,9 +268,9 @@ except ImportError:
     URL_VALIDATOR_USER_AGENT = 'Django (http://www.djangoproject.com/)'
 
 class URLField(RegexField):
-    def __init__(self, required=True, verify_exists=False, widget=None,
+    def __init__(self, max_length=None, min_length=None, required=True, verify_exists=False, widget=None, label=None,
             validator_user_agent=URL_VALIDATOR_USER_AGENT):
-        RegexField.__init__(self, url_re, u'Enter a valid URL.', required, widget)
+        RegexField.__init__(self, url_re, max_length, min_length, gettext(u'Enter a valid URL.'), required, widget, label)
         self.verify_exists = verify_exists
         self.user_agent = validator_user_agent
 
@@ -219,9 +290,9 @@ class URLField(RegexField):
                 req = urllib2.Request(value, None, headers)
                 u = urllib2.urlopen(req)
             except ValueError:
-                raise ValidationError(u'Enter a valid URL.')
+                raise ValidationError(gettext(u'Enter a valid URL.'))
             except: # urllib2.URLError, httplib.InvalidURL, etc.
-                raise ValidationError(u'This URL appears to be a broken link.')
+                raise ValidationError(gettext(u'This URL appears to be a broken link.'))
         return value
 
 class BooleanField(Field):
@@ -233,10 +304,10 @@ class BooleanField(Field):
         return bool(value)
 
 class ChoiceField(Field):
-    def __init__(self, choices=(), required=True, widget=Select):
+    def __init__(self, choices=(), required=True, widget=Select, label=None):
         if isinstance(widget, type):
             widget = widget(choices=choices)
-        Field.__init__(self, required, widget)
+        Field.__init__(self, required, widget, label)
         self.choices = choices
 
     def clean(self, value):
@@ -246,37 +317,46 @@ class ChoiceField(Field):
         value = Field.clean(self, value)
         if value in EMPTY_VALUES: value = u''
         value = smart_unicode(value)
+        if not self.required and value == u'':
+            return value
         valid_values = set([str(k) for k, v in self.choices])
         if value not in valid_values:
-            raise ValidationError(u'Select a valid choice. %s is not one of the available choices.' % value)
+            raise ValidationError(gettext(u'Select a valid choice. %s is not one of the available choices.') % value)
         return value
 
 class MultipleChoiceField(ChoiceField):
-    def __init__(self, choices=(), required=True, widget=SelectMultiple):
-        ChoiceField.__init__(self, choices, required, widget)
+    def __init__(self, choices=(), required=True, widget=SelectMultiple, label=None):
+        ChoiceField.__init__(self, choices, required, widget, label)
 
     def clean(self, value):
         """
         Validates that the input is a list or tuple.
         """
-        if not isinstance(value, (list, tuple)):
-            raise ValidationError(u'Enter a list of values.')
         if self.required and not value:
-            raise ValidationError(u'This field is required.')
+            raise ValidationError(gettext(u'This field is required.'))
+        elif not self.required and not value:
+            return []
+        if not isinstance(value, (list, tuple)):
+            raise ValidationError(gettext(u'Enter a list of values.'))
         new_value = []
         for val in value:
             val = smart_unicode(val)
             new_value.append(val)
         # Validate that each value in the value list is in self.choices.
-        valid_values = set([k for k, v in self.choices])
+        valid_values = set([smart_unicode(k) for k, v in self.choices])
         for val in new_value:
             if val not in valid_values:
-                raise ValidationError(u'Select a valid choice. %s is not one of the available choices.' % val)
+                raise ValidationError(gettext(u'Select a valid choice. %s is not one of the available choices.') % val)
         return new_value
 
 class ComboField(Field):
-    def __init__(self, fields=(), required=True, widget=None):
-        Field.__init__(self, required, widget)
+    def __init__(self, fields=(), required=True, widget=None, label=None):
+        Field.__init__(self, required, widget, label)
+        # Set 'required' to False on the individual fields, because the
+        # required validation will be handled by ComboField, not by those
+        # individual fields.
+        for f in fields:
+            f.required = False
         self.fields = fields
 
     def clean(self, value):
diff --git a/django/newforms/forms.py b/django/newforms/forms.py
index b8264fb691..201cce3868 100644
--- a/django/newforms/forms.py
+++ b/django/newforms/forms.py
@@ -2,10 +2,13 @@
 Form classes
 """
 
-from django.utils.datastructures import SortedDict
+from django.utils.datastructures import SortedDict, MultiValueDict
+from django.utils.html import escape
 from fields import Field
-from widgets import TextInput, Textarea
-from util import ErrorDict, ErrorList, ValidationError
+from widgets import TextInput, Textarea, HiddenInput
+from util import StrAndUnicode, ErrorDict, ErrorList, ValidationError
+
+__all__ = ('BaseForm', 'Form')
 
 NON_FIELD_ERRORS = '__all__'
 
@@ -31,17 +34,20 @@ class DeclarativeFieldsMetaclass(type):
         attrs['fields'] = SortedDictFromList(fields)
         return type.__new__(cls, name, bases, attrs)
 
-class Form(object):
-    "A collection of Fields, plus their associated data."
-    __metaclass__ = DeclarativeFieldsMetaclass
-
-    def __init__(self, data=None, auto_id=False): # TODO: prefix stuff
+class BaseForm(StrAndUnicode):
+    # This is the main implementation of all the Form logic. Note that this
+    # class is different than Form. See the comments by the Form class for more
+    # information. Any improvements to the form API should be made to *this*
+    # class, not to the Form class.
+    def __init__(self, data=None, auto_id='id_%s', prefix=None):
+        self.ignore_errors = data is None
         self.data = data or {}
         self.auto_id = auto_id
+        self.prefix = prefix
         self.clean_data = None # Stores the data after clean() has been called.
         self.__errors = None # Stores the errors after clean() has been called.
 
-    def __str__(self):
+    def __unicode__(self):
         return self.as_table()
 
     def __iter__(self):
@@ -56,60 +62,76 @@ class Form(object):
             raise KeyError('Key %r not found in Form' % name)
         return BoundField(self, field, name)
 
-    def clean(self):
-        if self.__errors is None:
-            self.full_clean()
-        return self.clean_data
-
-    def errors(self):
+    def _errors(self):
         "Returns an ErrorDict for self.data"
         if self.__errors is None:
             self.full_clean()
         return self.__errors
+    errors = property(_errors)
 
     def is_valid(self):
         """
-        Returns True if the form has no errors. Otherwise, False. This exists
-        solely for convenience, so client code can use positive logic rather
-        than confusing negative logic ("if not form.errors()").
+        Returns True if the form has no errors. Otherwise, False. If errors are
+        being ignored, returns False.
+        """
+        return not self.ignore_errors and not bool(self.errors)
+
+    def add_prefix(self, field_name):
+        """
+        Returns the field name with a prefix appended, if this Form has a
+        prefix set.
+
+        Subclasses may wish to override.
         """
-        return not bool(self.errors())
+        return self.prefix and ('%s-%s' % (self.prefix, field_name)) or field_name
+
+    def _html_output(self, normal_row, error_row, row_ender, errors_on_separate_row):
+        "Helper function for outputting HTML. Used by as_table(), as_ul(), as_p()."
+        top_errors = self.non_field_errors() # Errors that should be displayed above all fields.
+        output, hidden_fields = [], []
+        for name, field in self.fields.items():
+            bf = BoundField(self, field, name)
+            bf_errors = bf.errors # Cache in local variable.
+            if bf.is_hidden:
+                if bf_errors:
+                    top_errors.extend(['(Hidden field %s) %s' % (name, e) for e in bf_errors])
+                hidden_fields.append(unicode(bf))
+            else:
+                if errors_on_separate_row and bf_errors:
+                    output.append(error_row % bf_errors)
+                label = bf.label and bf.label_tag(escape(bf.label + ':')) or ''
+                output.append(normal_row % {'errors': bf_errors, 'label': label, 'field': bf})
+        if top_errors:
+            output.insert(0, error_row % top_errors)
+        if hidden_fields: # Insert any hidden fields in the last row.
+            str_hidden = u''.join(hidden_fields)
+            if output:
+                last_row = output[-1]
+                # Chop off the trailing row_ender (e.g. '</td></tr>') and insert the hidden fields.
+                output[-1] = last_row[:-len(row_ender)] + str_hidden + row_ender
+            else: # If there aren't any rows in the output, just append the hidden fields.
+                output.append(str_hidden)
+        return u'\n'.join(output)
 
     def as_table(self):
         "Returns this form rendered as HTML <tr>s -- excluding the <table></table>."
-        return u'\n'.join(['<tr><td>%s:</td><td>%s</td></tr>' % (pretty_name(name), BoundField(self, field, name)) for name, field in self.fields.items()])
+        return self._html_output(u'<tr><th>%(label)s</th><td>%(errors)s%(field)s</td></tr>', u'<tr><td colspan="2">%s</td></tr>', '</td></tr>', False)
 
     def as_ul(self):
         "Returns this form rendered as HTML <li>s -- excluding the <ul></ul>."
-        return u'\n'.join(['<li>%s: %s</li>' % (pretty_name(name), BoundField(self, field, name)) for name, field in self.fields.items()])
+        return self._html_output(u'<li>%(errors)s%(label)s %(field)s</li>', u'<li>%s</li>', '</li>', False)
 
-    def as_table_with_errors(self):
-        "Returns this form rendered as HTML <tr>s, with errors."
-        output = []
-        if self.errors().get(NON_FIELD_ERRORS):
-            # Errors not corresponding to a particular field are displayed at the top.
-            output.append('<tr><td colspan="2"><ul>%s</ul></td></tr>' % '\n'.join(['<li>%s</li>' % e for e in self.errors()[NON_FIELD_ERRORS]]))
-        for name, field in self.fields.items():
-            bf = BoundField(self, field, name)
-            if bf.errors:
-                output.append('<tr><td colspan="2"><ul>%s</ul></td></tr>' % '\n'.join(['<li>%s</li>' % e for e in bf.errors]))
-            output.append('<tr><td>%s:</td><td>%s</td></tr>' % (pretty_name(name), bf))
-        return u'\n'.join(output)
+    def as_p(self):
+        "Returns this form rendered as HTML <p>s."
+        return self._html_output(u'<p>%(label)s %(field)s</p>', u'<p>%s</p>', '</p>', True)
 
-    def as_ul_with_errors(self):
-        "Returns this form rendered as HTML <li>s, with errors."
-        output = []
-        if self.errors().get(NON_FIELD_ERRORS):
-            # Errors not corresponding to a particular field are displayed at the top.
-            output.append('<li><ul>%s</ul></li>' % '\n'.join(['<li>%s</li>' % e for e in self.errors()[NON_FIELD_ERRORS]]))
-        for name, field in self.fields.items():
-            bf = BoundField(self, field, name)
-            line = '<li>'
-            if bf.errors:
-                line += '<ul>%s</ul>' % '\n'.join(['<li>%s</li>' % e for e in bf.errors])
-            line += '%s: %s</li>' % (pretty_name(name), bf)
-            output.append(line)
-        return u'\n'.join(output)
+    def non_field_errors(self):
+        """
+        Returns an ErrorList of errors that aren't associated with a particular
+        field -- i.e., from Form.clean(). Returns an empty ErrorList if there
+        are none.
+        """
+        return self.errors.get(NON_FIELD_ERRORS, ErrorList())
 
     def full_clean(self):
         """
@@ -117,8 +139,14 @@ class Form(object):
         """
         self.clean_data = {}
         errors = ErrorDict()
+        if self.ignore_errors: # Stop further processing.
+            self.__errors = errors
+            return
         for name, field in self.fields.items():
-            value = self.data.get(name, None)
+            # value_from_datadict() gets the data from the dictionary.
+            # Each widget type knows how to retrieve its own data, because some
+            # widgets split data over several HTML fields.
+            value = field.widget.value_from_datadict(self.data, self.add_prefix(name))
             try:
                 value = field.clean(value)
                 self.clean_data[name] = value
@@ -138,40 +166,59 @@ class Form(object):
     def clean(self):
         """
         Hook for doing any extra form-wide cleaning after Field.clean() been
-        called on every field.
+        called on every field. Any ValidationError raised by this method will
+        not be associated with a particular field; it will have a special-case
+        association with the field named '__all__'.
         """
         return self.clean_data
 
-class BoundField(object):
+class Form(BaseForm):
+    "A collection of Fields, plus their associated data."
+    # This is a separate class from BaseForm in order to abstract the way
+    # self.fields is specified. This class (Form) is the one that does the
+    # fancy metaclass stuff purely for the semantic sugar -- it allows one
+    # to define a form using declarative syntax.
+    # BaseForm itself has no way of designating self.fields.
+    __metaclass__ = DeclarativeFieldsMetaclass
+
+class BoundField(StrAndUnicode):
     "A Field plus data"
     def __init__(self, form, field, name):
-        self._form = form
-        self._field = field
-        self._name = name
+        self.form = form
+        self.field = field
+        self.name = name
+        self.html_name = form.add_prefix(name)
+        if self.field.label is None:
+            self.label = pretty_name(name)
+        else:
+            self.label = self.field.label
 
-    def __str__(self):
+    def __unicode__(self):
         "Renders this field as an HTML widget."
         # Use the 'widget' attribute on the field to determine which type
         # of HTML widget to use.
-        return self.as_widget(self._field.widget)
+        value = self.as_widget(self.field.widget)
+        if not isinstance(value, basestring):
+            # Some Widget render() methods -- notably RadioSelect -- return a
+            # "special" object rather than a string. Call the __str__() on that
+            # object to get its rendered value.
+            value = value.__str__()
+        return value
 
     def _errors(self):
         """
         Returns an ErrorList for this field. Returns an empty ErrorList
         if there are none.
         """
-        try:
-            return self._form.errors()[self._name]
-        except KeyError:
-            return ErrorList()
+        return self.form.errors.get(self.name, ErrorList())
     errors = property(_errors)
 
     def as_widget(self, widget, attrs=None):
         attrs = attrs or {}
         auto_id = self.auto_id
-        if not attrs.has_key('id') and not widget.attrs.has_key('id') and auto_id:
+        if auto_id and not attrs.has_key('id') and not widget.attrs.has_key('id'):
             attrs['id'] = auto_id
-        return widget.render(self._name, self._form.data.get(self._name, None), attrs=attrs)
+        return widget.render(self.html_name, self.data, attrs=attrs)
 
     def as_text(self, attrs=None):
         """
@@ -183,15 +230,44 @@ class BoundField(object):
         "Returns a string of HTML for representing this as a <textarea>."
         return self.as_widget(Textarea(), attrs)
 
+    def as_hidden(self, attrs=None):
+        """
+        Returns a string of HTML for representing this as an <input type="hidden">.
+        """
+        return self.as_widget(HiddenInput(), attrs)
+
+    def _data(self):
+        "Returns the data for this BoundField, or None if it wasn't given."
+        return self.field.widget.value_from_datadict(self.form.data, self.html_name)
+    data = property(_data)
+
+    def label_tag(self, contents=None):
+        """
+        Wraps the given contents in a <label>, if the field has an ID attribute.
+        Does not HTML-escape the contents. If contents aren't given, uses the
+        field's HTML-escaped label.
+        """
+        contents = contents or escape(self.label)
+        widget = self.field.widget
+        id_ = widget.attrs.get('id') or self.auto_id
+        if id_:
+            contents = '<label for="%s">%s</label>' % (widget.id_for_label(id_), contents)
+        return contents
+
+    def _is_hidden(self):
+        "Returns True if this BoundField's widget is hidden."
+        return self.field.widget.is_hidden
+    is_hidden = property(_is_hidden)
+
     def _auto_id(self):
         """
         Calculates and returns the ID attribute for this BoundField, if the
         associated Form has specified auto_id. Returns an empty string otherwise.
         """
-        auto_id = self._form.auto_id
+        auto_id = self.form.auto_id
         if auto_id and '%s' in str(auto_id):
-            return str(auto_id) % self._name
+            return str(auto_id) % self.html_name
         elif auto_id:
-            return self._name
+            return self.html_name
         return ''
     auto_id = property(_auto_id)
diff --git a/django/newforms/models.py b/django/newforms/models.py
new file mode 100644
index 0000000000..6b111d7ee1
--- /dev/null
+++ b/django/newforms/models.py
@@ -0,0 +1,38 @@
+"""
+Helper functions for creating Form classes from Django models
+and database field objects.
+"""
+
+from forms import BaseForm, DeclarativeFieldsMetaclass, SortedDictFromList
+
+__all__ = ('form_for_model', 'form_for_fields')
+
+def create(self, save=True):
+    "Creates and returns model instance according to self.clean_data."
+    if self.errors:
+        raise ValueError("The %s could not be created because the data didn't validate." % self._model._meta.object_name)
+    obj = self._model(**self.clean_data)
+    if save:
+        obj.save()
+    return obj
+
+def form_for_model(model, form=None):
+    """
+    Returns a Form class for the given Django model class.
+
+    Provide 'form' if you want to use a custom BaseForm subclass.
+    """
+    opts = model._meta
+    field_list = []
+    for f in opts.fields + opts.many_to_many:
+        formfield = f.formfield()
+        if formfield:
+            field_list.append((f.name, formfield))
+    fields = SortedDictFromList(field_list)
+    form = form or BaseForm
+    return type(opts.object_name + 'Form', (form,), {'fields': fields, '_model': model, 'create': create})
+
+def form_for_fields(field_list):
+    "Returns a Form class for the given list of Django database field instances."
+    fields = SortedDictFromList([(f.name, f.formfield()) for f in field_list])
+    return type('FormForFields', (BaseForm,), {'fields': fields})
diff --git a/django/newforms/util.py b/django/newforms/util.py
index a5cc4932ea..a78623a17b 100644
--- a/django/newforms/util.py
+++ b/django/newforms/util.py
@@ -1,13 +1,22 @@
-# Default encoding for input byte strings.
-DEFAULT_ENCODING = 'utf-8' # TODO: First look at django.conf.settings, then fall back to this.
+from django.conf import settings
 
 def smart_unicode(s):
     if not isinstance(s, basestring):
         s = unicode(str(s))
     elif not isinstance(s, unicode):
-        s = unicode(s, DEFAULT_ENCODING)
+        s = unicode(s, settings.DEFAULT_CHARSET)
     return s
 
+class StrAndUnicode(object):
+    """
+    A class whose __str__ returns its __unicode__ as a bytestring
+    according to settings.DEFAULT_CHARSET.
+
+    Useful as a mix-in.
+    """
+    def __str__(self):
+        return self.__unicode__().encode(settings.DEFAULT_CHARSET)
+
 class ErrorDict(dict):
     """
     A collection of errors that knows how to display itself in various formats.
diff --git a/django/newforms/widgets.py b/django/newforms/widgets.py
index 318c76e55d..996e353775 100644
--- a/django/newforms/widgets.py
+++ b/django/newforms/widgets.py
@@ -5,10 +5,11 @@ HTML Widget classes
 __all__ = (
     'Widget', 'TextInput', 'PasswordInput', 'HiddenInput', 'FileInput',
     'Textarea', 'CheckboxInput',
-    'Select', 'SelectMultiple', 'RadioSelect',
+    'Select', 'SelectMultiple', 'RadioSelect', 'CheckboxSelectMultiple',
 )
 
-from util import smart_unicode
+from util import StrAndUnicode, smart_unicode
+from django.utils.datastructures import MultiValueDict
 from django.utils.html import escape
 from itertools import chain
 
@@ -22,25 +23,54 @@ except NameError:
 flatatt = lambda attrs: u''.join([u' %s="%s"' % (k, escape(v)) for k, v in attrs.items()])
 
 class Widget(object):
-    requires_data_list = False # Determines whether render()'s 'value' argument should be a list.
+    is_hidden = False          # Determines whether this corresponds to an <input type="hidden">.
+
     def __init__(self, attrs=None):
         self.attrs = attrs or {}
 
-    def render(self, name, value):
+    def render(self, name, value, attrs=None):
+        """
+        Returns this Widget rendered as HTML, as a Unicode string.
+
+        The 'value' given is not guaranteed to be valid input, so subclass
+        implementations should program defensively.
+        """
         raise NotImplementedError
 
     def build_attrs(self, extra_attrs=None, **kwargs):
+        "Helper function for building an attribute dictionary."
         attrs = dict(self.attrs, **kwargs)
         if extra_attrs:
             attrs.update(extra_attrs)
         return attrs
 
+    def value_from_datadict(self, data, name):
+        """
+        Given a dictionary of data and this widget's name, returns the value
+        of this widget. Returns None if it's not provided.
+        """
+        return data.get(name, None)
+
+    def id_for_label(self, id_):
+        """
+        Returns the HTML ID attribute of this Widget for use by a <label>,
+        given the ID of the field. Returns None if no ID is available.
+
+        This hook is necessary because some widgets have multiple HTML
+        elements and, thus, multiple IDs. In that case, this method should
+        return an ID value that corresponds to the first ID in the widget's
+        tags.
+        """
+        return id_
+    id_for_label = classmethod(id_for_label)
+
 class Input(Widget):
     """
     Base class for all <input> widgets (except type='checkbox' and
     type='radio', which are special).
     """
     input_type = None # Subclasses must define this.
+
     def render(self, name, value, attrs=None):
         if value is None: value = ''
         final_attrs = self.build_attrs(attrs, type=self.input_type, name=name)
@@ -55,6 +85,7 @@ class PasswordInput(Input):
 
 class HiddenInput(Input):
     input_type = 'hidden'
+    is_hidden = True
 
 class FileInput(Input):
     input_type = 'file'
@@ -67,9 +98,22 @@ class Textarea(Widget):
         return u'<textarea%s>%s</textarea>' % (flatatt(final_attrs), escape(value))
 
 class CheckboxInput(Widget):
+    def __init__(self, attrs=None, check_test=bool):
+        # check_test is a callable that takes a value and returns True
+        # if the checkbox should be checked for that value.
+        self.attrs = attrs or {}
+        self.check_test = check_test
+
     def render(self, name, value, attrs=None):
         final_attrs = self.build_attrs(attrs, type='checkbox', name=name)
-        if value: final_attrs['checked'] = 'checked'
+        try:
+            result = self.check_test(value)
+        except: # Silently catch exceptions
+            result = False
+        if result:
+            final_attrs['checked'] = 'checked'
+        if value not in ('', True, False, None):
+            final_attrs['value'] = smart_unicode(value) # Only add the 'value' attribute if a value is non-empty.
         return u'<input%s />' % flatatt(final_attrs)
 
 class Select(Widget):
@@ -91,7 +135,6 @@ class Select(Widget):
         return u'\n'.join(output)
 
 class SelectMultiple(Widget):
-    requires_data_list = True
     def __init__(self, attrs=None, choices=()):
         # choices can be any iterable
         self.attrs = attrs or {}
@@ -109,36 +152,48 @@ class SelectMultiple(Widget):
         output.append(u'</select>')
         return u'\n'.join(output)
 
-class RadioInput(object):
+    def value_from_datadict(self, data, name):
+        if isinstance(data, MultiValueDict):
+            return data.getlist(name)
+        return data.get(name, None)
+
+class RadioInput(StrAndUnicode):
     "An object used by RadioFieldRenderer that represents a single <input type='radio'>."
-    def __init__(self, name, value, attrs, choice):
+    def __init__(self, name, value, attrs, choice, index):
         self.name, self.value = name, value
-        self.attrs = attrs or {}
+        self.attrs = attrs
         self.choice_value, self.choice_label = choice
+        self.index = index
 
-    def __str__(self):
+    def __unicode__(self):
         return u'<label>%s %s</label>' % (self.tag(), self.choice_label)
 
     def is_checked(self):
         return self.value == smart_unicode(self.choice_value)
 
     def tag(self):
+        if self.attrs.has_key('id'):
+            self.attrs['id'] = '%s_%s' % (self.attrs['id'], self.index)
         final_attrs = dict(self.attrs, type='radio', name=self.name, value=self.choice_value)
         if self.is_checked():
             final_attrs['checked'] = 'checked'
         return u'<input%s />' % flatatt(final_attrs)
 
-class RadioFieldRenderer(object):
+class RadioFieldRenderer(StrAndUnicode):
     "An object used by RadioSelect to enable customization of radio widgets."
     def __init__(self, name, value, attrs, choices):
         self.name, self.value, self.attrs = name, value, attrs
         self.choices = choices
 
     def __iter__(self):
-        for choice in self.choices:
-            yield RadioInput(self.name, self.value, self.attrs, choice)
+        for i, choice in enumerate(self.choices):
+            yield RadioInput(self.name, self.value, self.attrs.copy(), choice, i)
+
+    def __getitem__(self, idx):
+        choice = self.choices[idx] # Let the IndexError propogate
+        return RadioInput(self.name, self.value, self.attrs.copy(), choice, idx)
 
-    def __str__(self):
+    def __unicode__(self):
         "Outputs a <ul> for this set of radio fields."
         return u'<ul>\n%s\n</ul>' % u'\n'.join([u'<li>%s</li>' % w for w in self])
 
@@ -147,7 +202,36 @@ class RadioSelect(Select):
         "Returns a RadioFieldRenderer instance rather than a Unicode string."
         if value is None: value = ''
         str_value = smart_unicode(value) # Normalize to string.
+        attrs = attrs or {}
         return RadioFieldRenderer(name, str_value, attrs, list(chain(self.choices, choices)))
 
-class CheckboxSelectMultiple(Widget):
-    pass
+    def id_for_label(self, id_):
+        # RadioSelect is represented by multiple <input type="radio"> fields,
+        # each of which has a distinct ID. The IDs are made distinct by a "_X"
+        # suffix, where X is the zero-based index of the radio field. Thus,
+        # the label for a RadioSelect should reference the first one ('_0').
+        if id_:
+            id_ += '_0'
+        return id_
+    id_for_label = classmethod(id_for_label)
+
+class CheckboxSelectMultiple(SelectMultiple):
+    def render(self, name, value, attrs=None, choices=()):
+        if value is None: value = []
+        final_attrs = self.build_attrs(attrs, name=name)
+        output = [u'<ul>']
+        str_values = set([smart_unicode(v) for v in value]) # Normalize to strings.
+        cb = CheckboxInput(final_attrs, check_test=lambda value: value in str_values)
+        for option_value, option_label in chain(self.choices, choices):
+            option_value = smart_unicode(option_value)
+            rendered_cb = cb.render(name, option_value)
+            output.append(u'<li><label>%s %s</label></li>' % (rendered_cb, escape(smart_unicode(option_label))))
+        output.append(u'</ul>')
+        return u'\n'.join(output)
+
+    def id_for_label(self, id_):
+        # See the comment for RadioSelect.id_for_label()
+        if id_:
+            id_ += '_0'
+        return id_
+    id_for_label = classmethod(id_for_label)
diff --git a/django/oldforms/__init__.py b/django/oldforms/__init__.py
new file mode 100644
index 0000000000..0b9ac05edb
--- /dev/null
+++ b/django/oldforms/__init__.py
@@ -0,0 +1,1008 @@
+from django.core import validators
+from django.core.exceptions import PermissionDenied
+from django.utils.html import escape
+from django.conf import settings
+from django.utils.translation import gettext, ngettext
+
+FORM_FIELD_ID_PREFIX = 'id_'
+
+class EmptyValue(Exception):
+    "This is raised when empty data is provided"
+    pass
+
+class Manipulator(object):
+    # List of permission strings. User must have at least one to manipulate.
+    # None means everybody has permission.
+    required_permission = ''
+
+    def __init__(self):
+        # List of FormField objects
+        self.fields = []
+
+    def __getitem__(self, field_name):
+        "Looks up field by field name; raises KeyError on failure"
+        for field in self.fields:
+            if field.field_name == field_name:
+                return field
+        raise KeyError, "Field %s not found\n%s" % (field_name, repr(self.fields))
+
+    def __delitem__(self, field_name):
+        "Deletes the field with the given field name; raises KeyError on failure"
+        for i, field in enumerate(self.fields):
+            if field.field_name == field_name:
+                del self.fields[i]
+                return
+        raise KeyError, "Field %s not found" % field_name
+
+    def check_permissions(self, user):
+        """Confirms user has required permissions to use this manipulator; raises
+        PermissionDenied on failure."""
+        if self.required_permission is None:
+            return
+        if user.has_perm(self.required_permission):
+            return
+        raise PermissionDenied
+
+    def prepare(self, new_data):
+        """
+        Makes any necessary preparations to new_data, in place, before data has
+        been validated.
+        """
+        for field in self.fields:
+            field.prepare(new_data)
+
+    def get_validation_errors(self, new_data):
+        "Returns dictionary mapping field_names to error-message lists"
+        errors = {}
+        self.prepare(new_data)
+        for field in self.fields:
+            errors.update(field.get_validation_errors(new_data))
+            val_name = 'validate_%s' % field.field_name
+            if hasattr(self, val_name):
+                val = getattr(self, val_name)
+                try:
+                    field.run_validator(new_data, val)
+                except (validators.ValidationError, validators.CriticalValidationError), e:
+                    errors.setdefault(field.field_name, []).extend(e.messages)
+
+#            if field.is_required and not new_data.get(field.field_name, False):
+#                errors.setdefault(field.field_name, []).append(gettext_lazy('This field is required.'))
+#                continue
+#            try:
+#                validator_list = field.validator_list
+#                if hasattr(self, 'validate_%s' % field.field_name):
+#                    validator_list.append(getattr(self, 'validate_%s' % field.field_name))
+#                for validator in validator_list:
+#                    if field.is_required or new_data.get(field.field_name, False) or hasattr(validator, 'always_test'):
+#                        try:
+#                            if hasattr(field, 'requires_data_list'):
+#                                validator(new_data.getlist(field.field_name), new_data)
+#                            else:
+#                                validator(new_data.get(field.field_name, ''), new_data)
+#                        except validators.ValidationError, e:
+#                            errors.setdefault(field.field_name, []).extend(e.messages)
+#            # If a CriticalValidationError is raised, ignore any other ValidationErrors
+#            # for this particular field
+#            except validators.CriticalValidationError, e:
+#                errors.setdefault(field.field_name, []).extend(e.messages)
+        return errors
+
+    def save(self, new_data):
+        "Saves the changes and returns the new object"
+        # changes is a dictionary-like object keyed by field_name
+        raise NotImplementedError
+
+    def do_html2python(self, new_data):
+        """
+        Convert the data from HTML data types to Python datatypes, changing the
+        object in place. This happens after validation but before storage. This
+        must happen after validation because html2python functions aren't
+        expected to deal with invalid input.
+        """
+        for field in self.fields:
+            field.convert_post_data(new_data)
+
+class FormWrapper(object):
+    """
+    A wrapper linking a Manipulator to the template system.
+    This allows dictionary-style lookups of formfields. It also handles feeding
+    prepopulated data and validation error messages to the formfield objects.
+    """
+    def __init__(self, manipulator, data=None, error_dict=None, edit_inline=True):
+        self.manipulator = manipulator
+        if data is None:
+            data = {}
+        if error_dict is None:
+            error_dict = {}
+        self.data = data
+        self.error_dict = error_dict
+        self._inline_collections = None
+        self.edit_inline = edit_inline
+
+    def __repr__(self):
+        return repr(self.__dict__)
+
+    def __getitem__(self, key):
+        for field in self.manipulator.fields:
+            if field.field_name == key:
+                data = field.extract_data(self.data)
+                return FormFieldWrapper(field, data, self.error_dict.get(field.field_name, []))
+        if self.edit_inline:
+            self.fill_inline_collections()
+            for inline_collection in self._inline_collections:
+                if inline_collection.name == key:
+                    return inline_collection
+        raise KeyError, "Could not find Formfield or InlineObjectCollection named %r" % key
+
+    def fill_inline_collections(self):
+        if not self._inline_collections:
+            ic = []
+            related_objects = self.manipulator.get_related_objects()
+            for rel_obj in related_objects:
+                data = rel_obj.extract_data(self.data)
+                inline_collection = InlineObjectCollection(self.manipulator, rel_obj, data, self.error_dict)
+                ic.append(inline_collection)
+            self._inline_collections = ic
+
+    def has_errors(self):
+        return self.error_dict != {}
+
+    def _get_fields(self):
+        try:
+            return self._fields
+        except AttributeError:
+            self._fields = [self.__getitem__(field.field_name) for field in self.manipulator.fields]
+            return self._fields
+
+    fields = property(_get_fields)
+
+class FormFieldWrapper(object):
+    "A bridge between the template system and an individual form field. Used by FormWrapper."
+    def __init__(self, formfield, data, error_list):
+        self.formfield, self.data, self.error_list = formfield, data, error_list
+        self.field_name = self.formfield.field_name # for convenience in templates
+
+    def __str__(self):
+        "Renders the field"
+        return str(self.formfield.render(self.data))
+
+    def __repr__(self):
+        return '<FormFieldWrapper for "%s">' % self.formfield.field_name
+
+    def field_list(self):
+        """
+        Like __str__(), but returns a list. Use this when the field's render()
+        method returns a list.
+        """
+        return self.formfield.render(self.data)
+
+    def errors(self):
+        return self.error_list
+
+    def html_error_list(self):
+        if self.errors():
+            return '<ul class="errorlist"><li>%s</li></ul>' % '</li><li>'.join([escape(e) for e in self.errors()])
+        else:
+            return ''
+
+    def get_id(self):
+        return self.formfield.get_id()
+
+class FormFieldCollection(FormFieldWrapper):
+    "A utility class that gives the template access to a dict of FormFieldWrappers"
+    def __init__(self, formfield_dict):
+        self.formfield_dict = formfield_dict
+
+    def __str__(self):
+        return str(self.formfield_dict)
+
+    def __getitem__(self, template_key):
+        "Look up field by template key; raise KeyError on failure"
+        return self.formfield_dict[template_key]
+
+    def __repr__(self):
+        return "<FormFieldCollection: %s>" % self.formfield_dict
+
+    def errors(self):
+        "Returns list of all errors in this collection's formfields"
+        errors = []
+        for field in self.formfield_dict.values():
+            if hasattr(field, 'errors'):
+                errors.extend(field.errors())
+        return errors
+
+    def has_errors(self):
+        return bool(len(self.errors()))
+
+    def html_combined_error_list(self):
+        return ''.join([field.html_error_list() for field in self.formfield_dict.values() if hasattr(field, 'errors')])
+
+class InlineObjectCollection(object):
+    "An object that acts like a sparse list of form field collections."
+    def __init__(self, parent_manipulator, rel_obj, data, errors):
+        self.parent_manipulator = parent_manipulator
+        self.rel_obj = rel_obj
+        self.data = data
+        self.errors = errors
+        self._collections = None
+        self.name = rel_obj.name
+
+    def __len__(self):
+        self.fill()
+        return self._collections.__len__()
+
+    def __getitem__(self, k):
+        self.fill()
+        return self._collections.__getitem__(k)
+
+    def __setitem__(self, k, v):
+        self.fill()
+        return self._collections.__setitem__(k,v)
+
+    def __delitem__(self, k):
+        self.fill()
+        return self._collections.__delitem__(k)
+
+    def __iter__(self):
+        self.fill()
+        return iter(self._collections.values())
+
+    def items(self):
+        self.fill()
+        return self._collections.items()
+
+    def fill(self):
+        if self._collections:
+            return
+        else:
+            var_name = self.rel_obj.opts.object_name.lower()
+            collections = {}
+            orig = None
+            if hasattr(self.parent_manipulator, 'original_object'):
+                orig = self.parent_manipulator.original_object
+            orig_list = self.rel_obj.get_list(orig)
+
+            for i, instance in enumerate(orig_list):
+                collection = {'original': instance}
+                for f in self.rel_obj.editable_fields():
+                    for field_name in f.get_manipulator_field_names(''):
+                        full_field_name = '%s.%d.%s' % (var_name, i, field_name)
+                        field = self.parent_manipulator[full_field_name]
+                        data = field.extract_data(self.data)
+                        errors = self.errors.get(full_field_name, [])
+                        collection[field_name] = FormFieldWrapper(field, data, errors)
+                collections[i] = FormFieldCollection(collection)
+            self._collections = collections
+
+
+class FormField(object):
+    """Abstract class representing a form field.
+
+    Classes that extend FormField should define the following attributes:
+        field_name
+            The field's name for use by programs.
+        validator_list
+            A list of validation tests (callback functions) that the data for
+            this field must pass in order to be added or changed.
+        is_required
+            A Boolean. Is it a required field?
+    Subclasses should also implement a render(data) method, which is responsible
+    for rending the form field in XHTML.
+    """
+    def __str__(self):
+        return self.render('')
+
+    def __repr__(self):
+        return 'FormField "%s"' % self.field_name
+
+    def prepare(self, new_data):
+        "Hook for doing something to new_data (in place) before validation."
+        pass
+
+    def html2python(data):
+        "Hook for converting an HTML datatype (e.g. 'on' for checkboxes) to a Python type"
+        return data
+    html2python = staticmethod(html2python)
+
+    def render(self, data):
+        raise NotImplementedError
+
+    def get_member_name(self):
+        if hasattr(self, 'member_name'):
+            return self.member_name
+        else:
+            return self.field_name
+
+    def extract_data(self, data_dict):
+        if hasattr(self, 'requires_data_list') and hasattr(data_dict, 'getlist'):
+            data = data_dict.getlist(self.get_member_name())
+        else:
+            data = data_dict.get(self.get_member_name(), None)
+        if data is None:
+            data = ''
+        return data
+
+    def convert_post_data(self, new_data):
+        name = self.get_member_name()
+        if new_data.has_key(self.field_name):
+            d = new_data.getlist(self.field_name)
+            try:
+                converted_data = [self.__class__.html2python(data) for data in d]
+            except ValueError:
+                converted_data = d
+            new_data.setlist(name, converted_data)
+        else:
+            try:
+                #individual fields deal with None values themselves
+                new_data.setlist(name, [self.__class__.html2python(None)])
+            except EmptyValue:
+                new_data.setlist(name, [])
+
+
+    def run_validator(self, new_data, validator):
+        if self.is_required or new_data.get(self.field_name, False) or hasattr(validator, 'always_test'):
+            if hasattr(self, 'requires_data_list'):
+                validator(new_data.getlist(self.field_name), new_data)
+            else:
+                validator(new_data.get(self.field_name, ''), new_data)
+
+    def get_validation_errors(self, new_data):
+        errors = {}
+        if self.is_required and not new_data.get(self.field_name, False):
+            errors.setdefault(self.field_name, []).append(gettext('This field is required.'))
+            return errors
+        try:
+            for validator in self.validator_list:
+                try:
+                    self.run_validator(new_data, validator)
+                except validators.ValidationError, e:
+                    errors.setdefault(self.field_name, []).extend(e.messages)
+        # If a CriticalValidationError is raised, ignore any other ValidationErrors
+        # for this particular field
+        except validators.CriticalValidationError, e:
+            errors.setdefault(self.field_name, []).extend(e.messages)
+        return errors
+
+    def get_id(self):
+        "Returns the HTML 'id' attribute for this form field."
+        return FORM_FIELD_ID_PREFIX + self.field_name
+
+####################
+# GENERIC WIDGETS  #
+####################
+
+class TextField(FormField):
+    input_type = "text"
+    def __init__(self, field_name, length=30, maxlength=None, is_required=False, validator_list=None, member_name=None):
+        if validator_list is None: validator_list = []
+        self.field_name = field_name
+        self.length, self.maxlength = length, maxlength
+        self.is_required = is_required
+        self.validator_list = [self.isValidLength, self.hasNoNewlines] + validator_list
+        if member_name != None:
+            self.member_name = member_name
+
+    def isValidLength(self, data, form):
+        if data and self.maxlength and len(data.decode(settings.DEFAULT_CHARSET)) > self.maxlength:
+            raise validators.ValidationError, ngettext("Ensure your text is less than %s character.",
+                "Ensure your text is less than %s characters.", self.maxlength) % self.maxlength
+
+    def hasNoNewlines(self, data, form):
+        if data and '\n' in data:
+            raise validators.ValidationError, gettext("Line breaks are not allowed here.")
+
+    def render(self, data):
+        if data is None:
+            data = ''
+        maxlength = ''
+        if self.maxlength:
+            maxlength = 'maxlength="%s" ' % self.maxlength
+        if isinstance(data, unicode):
+            data = data.encode(settings.DEFAULT_CHARSET)
+        return '<input type="%s" id="%s" class="v%s%s" name="%s" size="%s" value="%s" %s/>' % \
+            (self.input_type, self.get_id(), self.__class__.__name__, self.is_required and ' required' or '',
+            self.field_name, self.length, escape(data), maxlength)
+
+    def html2python(data):
+        return data
+    html2python = staticmethod(html2python)
+
+class PasswordField(TextField):
+    input_type = "password"
+
+class LargeTextField(TextField):
+    def __init__(self, field_name, rows=10, cols=40, is_required=False, validator_list=None, maxlength=None):
+        if validator_list is None: validator_list = []
+        self.field_name = field_name
+        self.rows, self.cols, self.is_required = rows, cols, is_required
+        self.validator_list = validator_list[:]
+        if maxlength:
+            self.validator_list.append(self.isValidLength)
+            self.maxlength = maxlength
+
+    def render(self, data):
+        if data is None:
+            data = ''
+        if isinstance(data, unicode):
+            data = data.encode(settings.DEFAULT_CHARSET)
+        return '<textarea id="%s" class="v%s%s" name="%s" rows="%s" cols="%s">%s</textarea>' % \
+            (self.get_id(), self.__class__.__name__, self.is_required and ' required' or '',
+            self.field_name, self.rows, self.cols, escape(data))
+
+class HiddenField(FormField):
+    def __init__(self, field_name, is_required=False, validator_list=None):
+        if validator_list is None: validator_list = []
+        self.field_name, self.is_required = field_name, is_required
+        self.validator_list = validator_list[:]
+
+    def render(self, data):
+        return '<input type="hidden" id="%s" name="%s" value="%s" />' % \
+            (self.get_id(), self.field_name, escape(data))
+
+class CheckboxField(FormField):
+    def __init__(self, field_name, checked_by_default=False, validator_list=None, is_required=False):
+        if validator_list is None: validator_list = []
+        self.field_name = field_name
+        self.checked_by_default = checked_by_default
+        self.is_required = is_required
+        self.validator_list = validator_list[:]
+
+    def render(self, data):
+        checked_html = ''
+        if data or (data is '' and self.checked_by_default):
+            checked_html = ' checked="checked"'
+        return '<input type="checkbox" id="%s" class="v%s" name="%s"%s />' % \
+            (self.get_id(), self.__class__.__name__,
+            self.field_name, checked_html)
+
+    def html2python(data):
+        "Convert value from browser ('on' or '') to a Python boolean"
+        if data == 'on':
+            return True
+        return False
+    html2python = staticmethod(html2python)
+
+class SelectField(FormField):
+    def __init__(self, field_name, choices=None, size=1, is_required=False, validator_list=None, member_name=None):
+        if validator_list is None: validator_list = []
+        if choices is None: choices = []
+        self.field_name = field_name
+        # choices is a list of (value, human-readable key) tuples because order matters
+        self.choices, self.size, self.is_required = choices, size, is_required
+        self.validator_list = [self.isValidChoice] + validator_list
+        if member_name != None:
+            self.member_name = member_name
+
+    def render(self, data):
+        output = ['<select id="%s" class="v%s%s" name="%s" size="%s">' % \
+            (self.get_id(), self.__class__.__name__,
+             self.is_required and ' required' or '', self.field_name, self.size)]
+        str_data = str(data) # normalize to string
+        for value, display_name in self.choices:
+            selected_html = ''
+            if str(value) == str_data:
+                selected_html = ' selected="selected"'
+            output.append('    <option value="%s"%s>%s</option>' % (escape(value), selected_html, escape(display_name)))
+        output.append('  </select>')
+        return '\n'.join(output)
+
+    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, gettext("Select a valid choice; '%(data)s' is not in %(choices)s.") % {'data': str_data, 'choices': str_choices}
+
+class NullSelectField(SelectField):
+    "This SelectField converts blank fields to None"
+    def html2python(data):
+        if not data:
+            return None
+        return data
+    html2python = staticmethod(html2python)
+
+class RadioSelectField(FormField):
+    def __init__(self, field_name, choices=None, ul_class='', is_required=False, validator_list=None, member_name=None):
+        if validator_list is None: validator_list = []
+        if choices is None: choices = []
+        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, RadioFieldRenderer, 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 RadioFieldRenderer:
+            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%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 = str(data) # normalize to string
+        for i, (value, display_name) in enumerate(self.choices):
+            selected_html = ''
+            if str(value) == str_data:
+                selected_html = ' checked="checked"'
+            datalist.append({
+                'value': value,
+                'name': display_name,
+                'field': '<input type="radio" id="%s" name="%s" value="%s"%s/>' % \
+                    (self.get_id() + '_' + str(i), self.field_name, value, selected_html),
+                'label': '<label for="%s">%s</label>' % \
+                    (self.get_id() + '_' + str(i), display_name),
+            })
+        return RadioFieldRenderer(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, gettext("Select a valid choice; '%(data)s' is not in %(choices)s.") % {'data':str_data, 'choices':str_choices}
+
+class NullBooleanField(SelectField):
+    "This SelectField provides 'Yes', 'No' and 'Unknown', mapping results to True, False or None"
+    def __init__(self, field_name, is_required=False, validator_list=None):
+        if validator_list is None: validator_list = []
+        SelectField.__init__(self, field_name, choices=[('1', 'Unknown'), ('2', 'Yes'), ('3', 'No')],
+            is_required=is_required, validator_list=validator_list)
+
+    def render(self, data):
+        if data is None: data = '1'
+        elif data == True: data = '2'
+        elif data == False: data = '3'
+        return SelectField.render(self, data)
+
+    def html2python(data):
+        return {None: None, '1': None, '2': True, '3': False}[data]
+    html2python = staticmethod(html2python)
+
+class SelectMultipleField(SelectField):
+    requires_data_list = True
+    def render(self, data):
+        output = ['<select id="%s" class="v%s%s" name="%s" size="%s" multiple="multiple">' % \
+            (self.get_id(), self.__class__.__name__, self.is_required and ' required' or '',
+            self.field_name, self.size)]
+        str_data_list = map(str, data) # normalize to strings
+        for value, choice in self.choices:
+            selected_html = ''
+            if str(value) in str_data_list:
+                selected_html = ' selected="selected"'
+            output.append('    <option value="%s"%s>%s</option>' % (escape(value), selected_html, escape(choice)))
+        output.append('  </select>')
+        return '\n'.join(output)
+
+    def isValidChoice(self, field_data, all_data):
+        # data is something like ['1', '2', '3']
+        str_choices = [str(item[0]) for item in self.choices]
+        for val in map(str, field_data):
+            if val not in str_choices:
+                raise validators.ValidationError, gettext("Select a valid choice; '%(data)s' is not in %(choices)s.") % {'data':val, 'choices':str_choices}
+
+    def html2python(data):
+        if data is None:
+            raise EmptyValue
+        return data
+    html2python = staticmethod(html2python)
+
+class CheckboxSelectMultipleField(SelectMultipleField):
+    """
+    This has an identical interface to SelectMultipleField, except the rendered
+    widget is different. Instead of a <select multiple>, this widget outputs a
+    <ul> of <input type="checkbox">es.
+
+    Of course, that results in multiple form elements for the same "single"
+    field, so this class's prepare() method flattens the split data elements
+    back into the single list that validators, renderers and save() expect.
+    """
+    requires_data_list = True
+    def __init__(self, field_name, choices=None, ul_class='', validator_list=None):
+        if validator_list is None: validator_list = []
+        if choices is None: choices = []
+        self.ul_class = ul_class
+        SelectMultipleField.__init__(self, field_name, choices, size=1, is_required=False, validator_list=validator_list)
+
+    def prepare(self, new_data):
+        # new_data has "split" this field into several fields, so flatten it
+        # back into a single list.
+        data_list = []
+        for value, readable_value in self.choices:
+            if new_data.get('%s%s' % (self.field_name, value), '') == 'on':
+                data_list.append(value)
+        new_data.setlist(self.field_name, data_list)
+
+    def render(self, data):
+        output = ['<ul%s>' % (self.ul_class and ' class="%s"' % self.ul_class or '')]
+        str_data_list = map(str, data) # normalize to strings
+        for value, choice in self.choices:
+            checked_html = ''
+            if str(value) in str_data_list:
+                checked_html = ' checked="checked"'
+            field_name = '%s%s' % (self.field_name, value)
+            output.append('<li><input type="checkbox" id="%s" class="v%s" name="%s"%s value="on" /> <label for="%s">%s</label></li>' % \
+                (self.get_id() + escape(value), self.__class__.__name__, field_name, checked_html,
+                self.get_id() + escape(value), choice))
+        output.append('</ul>')
+        return '\n'.join(output)
+
+####################
+# FILE UPLOADS     #
+####################
+
+class FileUploadField(FormField):
+    def __init__(self, field_name, is_required=False, validator_list=None):
+        if validator_list is None: validator_list = []
+        self.field_name, self.is_required = field_name, is_required
+        self.validator_list = [self.isNonEmptyFile] + validator_list
+
+    def isNonEmptyFile(self, field_data, all_data):
+        try:
+            content = field_data['content']
+        except TypeError:
+            raise validators.CriticalValidationError, gettext("No file was submitted. Check the encoding type on the form.")
+        if not content:
+            raise validators.CriticalValidationError, gettext("The submitted file is empty.")
+
+    def render(self, data):
+        return '<input type="file" id="%s" class="v%s" name="%s" />' % \
+            (self.get_id(), self.__class__.__name__, self.field_name)
+
+    def html2python(data):
+        if data is None:
+            raise EmptyValue
+        return data
+    html2python = staticmethod(html2python)
+
+class ImageUploadField(FileUploadField):
+    "A FileUploadField that raises CriticalValidationError if the uploaded file isn't an image."
+    def __init__(self, *args, **kwargs):
+        FileUploadField.__init__(self, *args, **kwargs)
+        self.validator_list.insert(0, self.isValidImage)
+
+    def isValidImage(self, field_data, all_data):
+        try:
+            validators.isValidImage(field_data, all_data)
+        except validators.ValidationError, e:
+            raise validators.CriticalValidationError, e.messages
+
+####################
+# INTEGERS/FLOATS  #
+####################
+
+class IntegerField(TextField):
+    def __init__(self, field_name, length=10, maxlength=None, is_required=False, validator_list=None, member_name=None):
+        if validator_list is None: validator_list = []
+        validator_list = [self.isInteger] + validator_list
+        if member_name is not None:
+            self.member_name = member_name
+        TextField.__init__(self, field_name, length, maxlength, is_required, validator_list)
+
+    def isInteger(self, field_data, all_data):
+        try:
+            validators.isInteger(field_data, all_data)
+        except validators.ValidationError, e:
+            raise validators.CriticalValidationError, e.messages
+
+    def html2python(data):
+        if data == '' or data is None:
+            return None
+        return int(data)
+    html2python = staticmethod(html2python)
+
+class SmallIntegerField(IntegerField):
+    def __init__(self, field_name, length=5, maxlength=5, is_required=False, validator_list=None):
+        if validator_list is None: validator_list = []
+        validator_list = [self.isSmallInteger] + validator_list
+        IntegerField.__init__(self, field_name, length, maxlength, is_required, validator_list)
+
+    def isSmallInteger(self, field_data, all_data):
+        if not -32768 <= int(field_data) <= 32767:
+            raise validators.CriticalValidationError, gettext("Enter a whole number between -32,768 and 32,767.")
+
+class PositiveIntegerField(IntegerField):
+    def __init__(self, field_name, length=10, maxlength=None, is_required=False, validator_list=None):
+        if validator_list is None: validator_list = []
+        validator_list = [self.isPositive] + validator_list
+        IntegerField.__init__(self, field_name, length, maxlength, is_required, validator_list)
+
+    def isPositive(self, field_data, all_data):
+        if int(field_data) < 0:
+            raise validators.CriticalValidationError, gettext("Enter a positive number.")
+
+class PositiveSmallIntegerField(IntegerField):
+    def __init__(self, field_name, length=5, maxlength=None, is_required=False, validator_list=None):
+        if validator_list is None: validator_list = []
+        validator_list = [self.isPositiveSmall] + validator_list
+        IntegerField.__init__(self, field_name, length, maxlength, is_required, validator_list)
+
+    def isPositiveSmall(self, field_data, all_data):
+        if not 0 <= int(field_data) <= 32767:
+            raise validators.CriticalValidationError, gettext("Enter a whole number between 0 and 32,767.")
+
+class FloatField(TextField):
+    def __init__(self, field_name, max_digits, decimal_places, is_required=False, validator_list=None):
+        if validator_list is None: validator_list = []
+        self.max_digits, self.decimal_places = max_digits, decimal_places
+        validator_list = [self.isValidFloat] + validator_list
+        TextField.__init__(self, field_name, max_digits+2, max_digits+2, is_required, validator_list)
+
+    def isValidFloat(self, field_data, all_data):
+        v = validators.IsValidFloat(self.max_digits, self.decimal_places)
+        try:
+            v(field_data, all_data)
+        except validators.ValidationError, e:
+            raise validators.CriticalValidationError, e.messages
+
+    def html2python(data):
+        if data == '' or data is None:
+            return None
+        return float(data)
+    html2python = staticmethod(html2python)
+
+####################
+# DATES AND TIMES  #
+####################
+
+class DatetimeField(TextField):
+    """A FormField that automatically converts its data to a datetime.datetime object.
+    The data should be in the format YYYY-MM-DD HH:MM:SS."""
+    def __init__(self, field_name, length=30, maxlength=None, is_required=False, validator_list=None):
+        if validator_list is None: validator_list = []
+        self.field_name = field_name
+        self.length, self.maxlength = length, maxlength
+        self.is_required = is_required
+        self.validator_list = [validators.isValidANSIDatetime] + validator_list
+
+    def html2python(data):
+        "Converts the field into a datetime.datetime object"
+        import datetime
+        try:
+            date, time = data.split()
+            y, m, d = date.split('-')
+            timebits = time.split(':')
+            h, mn = timebits[:2]
+            if len(timebits) > 2:
+                s = int(timebits[2])
+            else:
+                s = 0
+            return datetime.datetime(int(y), int(m), int(d), int(h), int(mn), s)
+        except ValueError:
+            return None
+    html2python = staticmethod(html2python)
+
+class DateField(TextField):
+    """A FormField that automatically converts its data to a datetime.date object.
+    The data should be in the format YYYY-MM-DD."""
+    def __init__(self, field_name, is_required=False, validator_list=None):
+        if validator_list is None: validator_list = []
+        validator_list = [self.isValidDate] + validator_list
+        TextField.__init__(self, field_name, length=10, maxlength=10,
+            is_required=is_required, validator_list=validator_list)
+
+    def isValidDate(self, field_data, all_data):
+        try:
+            validators.isValidANSIDate(field_data, all_data)
+        except validators.ValidationError, e:
+            raise validators.CriticalValidationError, e.messages
+
+    def html2python(data):
+        "Converts the field into a datetime.date object"
+        import time, datetime
+        try:
+            time_tuple = time.strptime(data, '%Y-%m-%d')
+            return datetime.date(*time_tuple[0:3])
+        except (ValueError, TypeError):
+            return None
+    html2python = staticmethod(html2python)
+
+class TimeField(TextField):
+    """A FormField that automatically converts its data to a datetime.time object.
+    The data should be in the format HH:MM:SS or HH:MM:SS.mmmmmm."""
+    def __init__(self, field_name, is_required=False, validator_list=None):
+        if validator_list is None: validator_list = []
+        validator_list = [self.isValidTime] + validator_list
+        TextField.__init__(self, field_name, length=8, maxlength=8,
+            is_required=is_required, validator_list=validator_list)
+
+    def isValidTime(self, field_data, all_data):
+        try:
+            validators.isValidANSITime(field_data, all_data)
+        except validators.ValidationError, e:
+            raise validators.CriticalValidationError, e.messages
+
+    def html2python(data):
+        "Converts the field into a datetime.time object"
+        import time, datetime
+        try:
+            part_list = data.split('.')
+            try:
+                time_tuple = time.strptime(part_list[0], '%H:%M:%S')
+            except ValueError: # seconds weren't provided
+                time_tuple = time.strptime(part_list[0], '%H:%M')
+            t = datetime.time(*time_tuple[3:6])
+            if (len(part_list) == 2):
+                t = t.replace(microsecond=int(part_list[1]))
+            return t
+        except (ValueError, TypeError, AttributeError):
+            return None
+    html2python = staticmethod(html2python)
+
+####################
+# INTERNET-RELATED #
+####################
+
+class EmailField(TextField):
+    "A convenience FormField for validating e-mail addresses"
+    def __init__(self, field_name, length=50, maxlength=75, is_required=False, validator_list=None):
+        if validator_list is None: validator_list = []
+        validator_list = [self.isValidEmail] + validator_list
+        TextField.__init__(self, field_name, length, maxlength=maxlength,
+            is_required=is_required, validator_list=validator_list)
+
+    def isValidEmail(self, field_data, all_data):
+        try:
+            validators.isValidEmail(field_data, all_data)
+        except validators.ValidationError, e:
+            raise validators.CriticalValidationError, e.messages
+
+class URLField(TextField):
+    "A convenience FormField for validating URLs"
+    def __init__(self, field_name, length=50, maxlength=200, is_required=False, validator_list=None):
+        if validator_list is None: validator_list = []
+        validator_list = [self.isValidURL] + validator_list
+        TextField.__init__(self, field_name, length=length, maxlength=maxlength,
+            is_required=is_required, validator_list=validator_list)
+
+    def isValidURL(self, field_data, all_data):
+        try:
+            validators.isValidURL(field_data, all_data)
+        except validators.ValidationError, e:
+            raise validators.CriticalValidationError, e.messages
+
+class IPAddressField(TextField):
+    def __init__(self, field_name, length=15, maxlength=15, is_required=False, validator_list=None):
+        if validator_list is None: validator_list = []
+        validator_list = [self.isValidIPAddress] + validator_list
+        TextField.__init__(self, field_name, length=length, maxlength=maxlength,
+            is_required=is_required, validator_list=validator_list)
+
+    def isValidIPAddress(self, field_data, all_data):
+        try:
+            validators.isValidIPAddress4(field_data, all_data)
+        except validators.ValidationError, e:
+            raise validators.CriticalValidationError, e.messages
+
+    def html2python(data):
+        return data or None
+    html2python = staticmethod(html2python)
+
+####################
+# MISCELLANEOUS    #
+####################
+
+class FilePathField(SelectField):
+    "A SelectField whose choices are the files in a given directory."
+    def __init__(self, field_name, path, match=None, recursive=False, is_required=False, validator_list=None):
+        import os
+        from django.db.models import BLANK_CHOICE_DASH
+        if match is not None:
+            import re
+            match_re = re.compile(match)
+        choices = not is_required and BLANK_CHOICE_DASH[:] or []
+        if recursive:
+            for root, dirs, files in os.walk(path):
+                for f in files:
+                    if match is None or match_re.search(f):
+                        choices.append((os.path.join(root, f), f))
+        else:
+            try:
+                for f in os.listdir(path):
+                    full_file = os.path.join(path, f)
+                    if os.path.isfile(full_file) and (match is None or match_re.search(f)):
+                        choices.append((full_file, f))
+            except OSError:
+                pass
+        SelectField.__init__(self, field_name, choices, 1, is_required, validator_list)
+
+class PhoneNumberField(TextField):
+    "A convenience FormField for validating phone numbers (e.g. '630-555-1234')"
+    def __init__(self, field_name, is_required=False, validator_list=None):
+        if validator_list is None: validator_list = []
+        validator_list = [self.isValidPhone] + validator_list
+        TextField.__init__(self, field_name, length=12, maxlength=12,
+            is_required=is_required, validator_list=validator_list)
+
+    def isValidPhone(self, field_data, all_data):
+        try:
+            validators.isValidPhone(field_data, all_data)
+        except validators.ValidationError, e:
+            raise validators.CriticalValidationError, e.messages
+
+class USStateField(TextField):
+    "A convenience FormField for validating U.S. states (e.g. 'IL')"
+    def __init__(self, field_name, is_required=False, validator_list=None):
+        if validator_list is None: validator_list = []
+        validator_list = [self.isValidUSState] + validator_list
+        TextField.__init__(self, field_name, length=2, maxlength=2,
+            is_required=is_required, validator_list=validator_list)
+
+    def isValidUSState(self, field_data, all_data):
+        try:
+            validators.isValidUSState(field_data, all_data)
+        except validators.ValidationError, e:
+            raise validators.CriticalValidationError, e.messages
+
+    def html2python(data):
+        return data.upper() # Should always be stored in upper case
+    html2python = staticmethod(html2python)
+
+class CommaSeparatedIntegerField(TextField):
+    "A convenience FormField for validating comma-separated integer fields"
+    def __init__(self, field_name, maxlength=None, is_required=False, validator_list=None):
+        if validator_list is None: validator_list = []
+        validator_list = [self.isCommaSeparatedIntegerList] + validator_list
+        TextField.__init__(self, field_name, length=20, maxlength=maxlength,
+            is_required=is_required, validator_list=validator_list)
+
+    def isCommaSeparatedIntegerList(self, field_data, all_data):
+        try:
+            validators.isCommaSeparatedIntegerList(field_data, all_data)
+        except validators.ValidationError, e:
+            raise validators.CriticalValidationError, e.messages
+
+    def render(self, data):
+        if data is None:
+            data = ''
+        elif isinstance(data, (list, tuple)):
+            data = ','.join(data)
+        return super(CommaSeparatedIntegerField, self).render(data)
+
+class RawIdAdminField(CommaSeparatedIntegerField):
+    def html2python(data):
+        if data:
+            return data.split(',')
+        else:
+            return []
+    html2python = staticmethod(html2python)
+
+class XMLLargeTextField(LargeTextField):
+    """
+    A LargeTextField with an XML validator. The schema_path argument is the
+    full path to a Relax NG compact schema to validate against.
+    """
+    def __init__(self, field_name, schema_path, **kwargs):
+        self.schema_path = schema_path
+        kwargs.setdefault('validator_list', []).insert(0, self.isValidXML)
+        LargeTextField.__init__(self, field_name, **kwargs)
+
+    def isValidXML(self, field_data, all_data):
+        v = validators.RelaxNGCompact(self.schema_path)
+        try:
+            v(field_data, all_data)
+        except validators.ValidationError, e:
+            raise validators.CriticalValidationError, e.messages
diff --git a/django/template/__init__.py b/django/template/__init__.py
index 5affafeba9..7718801684 100644
--- a/django/template/__init__.py
+++ b/django/template/__init__.py
@@ -742,7 +742,11 @@ class VariableNode(Node):
     def encode_output(self, output):
         # Check type so that we don't run str() on a Unicode object
         if not isinstance(output, basestring):
-            return str(output)
+            try:
+                return str(output)
+            except UnicodeEncodeError:
+                # If __str__() returns a Unicode object, convert it to bytestring.
+                return unicode(output).encode(settings.DEFAULT_CHARSET)
         elif isinstance(output, unicode):
             return output.encode(settings.DEFAULT_CHARSET)
         else:
diff --git a/django/utils/dateformat.py b/django/utils/dateformat.py
index 0890a81a81..00eb9fe617 100644
--- a/django/utils/dateformat.py
+++ b/django/utils/dateformat.py
@@ -11,7 +11,7 @@ Usage:
 >>>
 """
 
-from django.utils.dates import MONTHS, MONTHS_AP, WEEKDAYS
+from django.utils.dates import MONTHS, MONTHS_3, MONTHS_AP, WEEKDAYS
 from django.utils.tzinfo import LocalTimezone
 from calendar import isleap, monthrange
 import re, time
@@ -147,7 +147,7 @@ class DateFormat(TimeFormat):
 
     def M(self):
         "Month, textual, 3 letters; e.g. 'Jan'"
-        return MONTHS[self.data.month][0:3]
+        return MONTHS_3[self.data.month].title()
 
     def n(self):
         "Month without leading zeros; i.e. '1' to '12'"
diff --git a/django/utils/text.py b/django/utils/text.py
index 9e7bb3b6c4..217f42491b 100644
--- a/django/utils/text.py
+++ b/django/utils/text.py
@@ -8,17 +8,28 @@ capfirst = lambda x: x and x[0].upper() + x[1:]
 def wrap(text, width):
     """
     A word-wrap function that preserves existing line breaks and most spaces in
-    the text. Expects that existing line breaks are posix newlines (\n).
-    See http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/148061
+    the text. Expects that existing line breaks are posix newlines.
     """
-    return reduce(lambda line, word, width=width: '%s%s%s' %
-                  (line,
-                   ' \n'[(len(line[line.rfind('\n')+1:])
-                         + len(word.split('\n',1)[0]
-                              ) >= width)],
-                   word),
-                  text.split(' ')
-                 )
+    def _generator():
+        it = iter(text.split(' '))
+        word = it.next()
+        yield word
+        pos = len(word) - word.rfind('\n') - 1
+        for word in it:
+            if "\n" in word:
+                lines = word.splitlines()
+            else:
+                lines = (word,)
+            pos += len(lines[0]) + 1
+            if pos > width:
+                yield '\n'
+                pos = len(lines[-1])
+            else:
+                yield ' '
+                if len(lines) > 1:
+                    pos = len(lines[-1])
+            yield word
+    return "".join(_generator())
 
 def truncate_words(s, num):
     "Truncates a string after a certain number of words."
diff --git a/django/views/generic/create_update.py b/django/views/generic/create_update.py
index 3a03fa59e4..28987f7544 100644
--- a/django/views/generic/create_update.py
+++ b/django/views/generic/create_update.py
@@ -1,6 +1,6 @@
 from django.core.xheaders import populate_xheaders
 from django.template import loader
-from django import forms
+from django import oldforms
 from django.db.models import FileField
 from django.contrib.auth.views import redirect_to_login
 from django.template import RequestContext
@@ -56,7 +56,7 @@ def create_object(request, model, template_name=None,
         new_data = manipulator.flatten_data()
 
     # Create the FormWrapper, template, context, response
-    form = forms.FormWrapper(manipulator, new_data, errors)
+    form = oldforms.FormWrapper(manipulator, new_data, errors)
     if not template_name:
         template_name = "%s/%s_form.html" % (model._meta.app_label, model._meta.object_name.lower())
     t = template_loader.get_template(template_name)
@@ -128,7 +128,7 @@ def update_object(request, model, object_id=None, slug=None,
         # This makes sure the form acurate represents the fields of the place.
         new_data = manipulator.flatten_data()
 
-    form = forms.FormWrapper(manipulator, new_data, errors)
+    form = oldforms.FormWrapper(manipulator, new_data, errors)
     if not template_name:
         template_name = "%s/%s_form.html" % (model._meta.app_label, model._meta.object_name.lower())
     t = template_loader.get_template(template_name)
diff --git a/django/views/generic/list_detail.py b/django/views/generic/list_detail.py
index bd0f17c56a..1836ce4a9f 100644
--- a/django/views/generic/list_detail.py
+++ b/django/views/generic/list_detail.py
@@ -84,7 +84,7 @@ def object_detail(request, queryset, object_id=None, slug=None,
         context_processors=None, template_object_name='object',
         mimetype=None):
     """
-    Generic list of objects.
+    Generic detail of an object.
 
     Templates: ``<app_label>/<model_name>_detail.html``
     Context:
diff --git a/docs/add_ons.txt b/docs/add_ons.txt
index a0377700d7..58c01c4fc0 100644
--- a/docs/add_ons.txt
+++ b/docs/add_ons.txt
@@ -48,6 +48,23 @@ See the `csrf documentation`_.
 
 .. _csrf documentation: http://www.djangoproject.com/documentation/csrf/
 
+formtools
+=========
+
+**New in Django development version**
+
+A set of high-level abstractions for Django forms (django.newforms).
+
+django.contrib.formtools.preview
+--------------------------------
+
+An abstraction of the following workflow:
+
+"Display an HTML form, force a preview, then do something with the submission."
+
+Full documentation for this feature does not yet exist, but you can read the
+code and docstrings in ``django/contrib/formtools/preview.py`` for a start.
+
 humanize
 ========
 
diff --git a/docs/contributing.txt b/docs/contributing.txt
index 6ff0b038a3..de9236f6c1 100644
--- a/docs/contributing.txt
+++ b/docs/contributing.txt
@@ -22,6 +22,9 @@ of the community, so there are many ways you can help Django's development:
       likely to be skeptical of large-scale suggestions without some code to
       back it up.
 
+    * Triage patches that have been submitted by other users. Please read
+      `Ticket triage`_ below, for details on the triage process.
+
 That's all you need to know if you'd like to join the Django development
 community. The rest of this document describes the details of how our community
 works and how it handles bugs, mailing lists, and all the other minutiae of
@@ -44,8 +47,10 @@ particular:
 
     * **Do** write complete, reproducible, specific bug reports. Include as
       much information as you possibly can, complete with code snippets, test
-      cases, etc.  A minimal example that illustrates the bug in a nice small
-      test case is the best possible bug report.
+      cases, etc. This means including a clear, concise description of the
+      problem, and a clear set of instructions for replicating the problem.
+      A minimal example that illustrates the bug in a nice small test case
+      is the best possible bug report.
 
     * **Don't** use the ticket system to ask support questions.  Use the
       `django-users`_ list, or the `#django`_ IRC channel for that.
@@ -121,6 +126,50 @@ Patch style
       it obvious that the ticket includes a patch, and it will add the ticket
       to the `list of tickets with patches`_.
 
+    * The code required to fix a problem or add a feature is an essential part
+      of a patch, but it is not the only part. A good patch should also include
+      a regression test to validate the behavior that has been fixed (and prevent
+      the problem from arising again).
+
+    * If the code associated with a patch adds a new feature, or modifies behavior
+      of an existing feature, the patch should also contain documentation.
+
+Non-trivial patches
+-------------------
+
+A "non-trivial" patch is one that is more than a simple bug fix. It's a patch
+that introduces Django functionality and makes some sort of design decision.
+
+If you provide a non-trivial patch, include evidence that alternatives have
+been discussed on `django-developers`_. If you're not sure whether your patch
+should be considered non-trivial, just ask.
+
+Ticket triage
+=============
+
+Unfortunately, not all bug reports in the `ticket tracker`_ provide all
+the `required details`_. A number of tickets have patches, but those patches
+don't meet all the requirements of a `good patch`_.
+
+One way to help out is to *triage* bugs that have been reported by other users.
+Pick an open ticket that is missing some details, and try to replicate the
+problem. Fill in the missing pieces of the report. If the ticket doesn't have
+a patch, create one.
+
+Once you've completed all the missing details on the ticket and you have a
+patch with all the required features, e-mail `django-developers`_. Indicate
+that you have triaged a ticket, and recommend a course of action for dealing
+with that ticket.
+
+At first, this may require you to be persistent. If you find that your triaged
+ticket still isn't getting attention, occasional polite requests for eyeballs
+to look at your ticket may be necessary. However, as you earn a reputation for
+quality triage work, you should find that it is easier to get the developers'
+attention.
+
+.. _required details: `Reporting bugs`_
+.. _good patch: `Patch style`_
+
 Submitting and maintaining translations
 =======================================
 
@@ -338,21 +387,63 @@ trunk more than once.
 Using branches
 --------------
 
-To test a given branch, you can simply check out the entire branch, like so::
+To use a branch, you'll need to do two things:
+
+    * Get the branch's code through Subversion.
+
+    * Point your Python ``site-packages`` directory at the branch's version of
+      the ``django`` package rather than the version you already have
+      installed.
+
+Getting the code from Subversion
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+To get the latest version of a branch's code, check it out using Subversion::
 
     svn co http://code.djangoproject.com/svn/django/branches/<branch>/
 
-Or, if you've got a working directory you'd like to switch to use a branch,
-you can use::
+...where ``<branch>`` is the branch's name. See the `list of branch names`_.
 
-    svn switch http://code.djangoproject.com/svn/django/branches/<branch>/
+Alternatively, you can automatically convert an existing directory of the
+Django source code as long as you've checked it out via Subversion. To do the
+conversion, execute this command from within your ``django`` directory::
 
-...in the root of your Django sandbox (the directory that contains ``django``,
-``docs``, and ``tests``).
+    svn switch http://code.djangoproject.com/svn/django/branches/<branch>/
 
 The advantage of using ``svn switch`` instead of ``svn co`` is that the
 ``switch`` command retains any changes you might have made to your local copy
-of the code. It attempts to merge those changes into the "switched" code.
+of the code. It attempts to merge those changes into the "switched" code. The
+disadvantage is that it may cause conflicts with your local changes if the
+"switched" code has altered the same lines of code.
+
+(Note that if you use ``svn switch``, you don't need to point Python at the new
+version, as explained in the next section.)
+
+.. _list of branch names: http://code.djangoproject.com/browser/django/branches
+
+Pointing Python at the new Django version
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Once you've retrieved the branch's code, you'll need to change your Python
+``site-packages`` directory so that it points to the branch version of the
+``django`` directory. (The ``site-packages`` directory is somewhere such as
+``/usr/lib/python2.4/site-packages`` or
+``/usr/local/lib/python2.4/site-packages`` or ``C:\Python\site-packages``.)
+
+The simplest way to do this is by renaming the old ``django`` directory to
+``django.OLD`` and moving the trunk version of the code into the directory
+and calling it ``django``.
+
+Alternatively, you can use a symlink called ``django`` that points to the
+location of the branch's ``django`` package. If you want to switch back, just
+change the symlink to point to the old code.
+
+If you're using Django 0.95 or earlier and installed it using
+``python setup.py install``, you'll have a directory called something like
+``Django-0.95-py2.4.egg`` instead of ``django``. In this case, edit the file
+``setuptools.pth`` and remove the line that references the Django ``.egg``
+file. Then copy the branch's version of the ``django`` directory into
+``site-packages``.
 
 Official releases
 =================
diff --git a/docs/csrf.txt b/docs/csrf.txt
index 218b43a61a..c12dd1d116 100644
--- a/docs/csrf.txt
+++ b/docs/csrf.txt
@@ -1,9 +1,9 @@
 =====================================
-Cross Site Request Forgery Protection
+Cross Site Request Forgery protection
 =====================================
 
-The CsrfMiddleware class provides easy-to-use protection against 
-`Cross Site Request Forgeries`_.  This type of attack occurs when a malicious 
+The CsrfMiddleware class provides easy-to-use protection against
+`Cross Site Request Forgeries`_.  This type of attack occurs when a malicious
 web site creates a link or form button that is intended to perform some action
 on your web site, using the credentials of a logged-in user who is tricked
 into clicking on the link in their browser.
@@ -12,12 +12,12 @@ The first defense against CSRF attacks is to ensure that GET requests
 are side-effect free.  POST requests can then be protected by adding this
 middleware into your list of installed middleware.
 
-
 .. _Cross Site Request Forgeries:  http://www.squarefree.com/securitytips/web-developers.html#CSRF
 
 How to use it
 =============
-Add the middleware ``'django.contrib.csrf.middleware.CsrfMiddleware'`` to 
+
+Add the middleware ``'django.contrib.csrf.middleware.CsrfMiddleware'`` to
 your list of middleware classes, ``MIDDLEWARE_CLASSES``. It needs to process
 the response after the SessionMiddleware, so must come before it in the
 list. It also must process the response before things like compression
@@ -25,16 +25,17 @@ happen to the response, so it must come after GZipMiddleware in the list.
 
 How it works
 ============
+
 CsrfMiddleware does two things:
 
-1. It modifies outgoing requests by adding a hidden form field to all 
-   'POST' forms, with the name 'csrfmiddlewaretoken' and a value which is 
-   a hash of the session ID plus a secret. If there is no session ID set, 
-   this modification of the response isn't done, so there is very little 
+1. It modifies outgoing requests by adding a hidden form field to all
+   'POST' forms, with the name 'csrfmiddlewaretoken' and a value which is
+   a hash of the session ID plus a secret. If there is no session ID set,
+   this modification of the response isn't done, so there is very little
    performance penalty for those requests that don't have a session.
 
-2. On all incoming POST requests that have the session cookie set, it 
-   checks that the 'csrfmiddlewaretoken' is present and correct. If it 
+2. On all incoming POST requests that have the session cookie set, it
+   checks that the 'csrfmiddlewaretoken' is present and correct. If it
    isn't, the user will get a 403 error.
 
 This ensures that only forms that have originated from your web site
@@ -43,26 +44,26 @@ can be used to POST data back.
 It deliberately only targets HTTP POST requests (and the corresponding
 POST forms). GET requests ought never to have side effects (if you are
 using HTTP GET and POST correctly), and so a CSRF attack with a GET
-request will always be harmless. 
+request will always be harmless.
 
 POST requests that are not accompanied by a session cookie are not protected,
 but they do not need to be protected, since the 'attacking' web site
 could make these kind of requests anyway.
 
-The Content-Type is checked before modifying the response, and only 
+The Content-Type is checked before modifying the response, and only
 pages that are served as 'text/html' or 'application/xml+xhtml'
 are modified.
 
 Limitations
 ===========
+
 CsrfMiddleware requires Django's session framework to work. If you have
 a custom authentication system that manually sets cookies and the like,
 it won't help you.
 
-If your app creates HTML pages and forms in some unusual way, (e.g. 
-it sends fragments of HTML in javascript document.write statements) 
-you might bypass the filter that adds the hidden field to the form, 
+If your app creates HTML pages and forms in some unusual way, (e.g.
+it sends fragments of HTML in javascript document.write statements)
+you might bypass the filter that adds the hidden field to the form,
 in which case form submission will always fail.  It may still be possible
 to use the middleware, provided you can find some way to get the
-CSRF token and ensure that is included when your form is submitted.
-
+CSRF token and ensure that is included when your form is submitted.
\ No newline at end of file
diff --git a/docs/db-api.txt b/docs/db-api.txt
index 2f0c8b0589..13a32bd0b8 100644
--- a/docs/db-api.txt
+++ b/docs/db-api.txt
@@ -143,9 +143,9 @@ or ``UPDATE`` SQL statements. Specifically, when you call ``save()``, Django
 follows this algorithm:
 
     * If the object's primary key attribute is set to a value that evaluates to
-      ``False`` (such as ``None`` or the empty string), Django executes a
-      ``SELECT`` query to determine whether a record with the given primary key
-      already exists.
+      ``True`` (i.e., a value other than ``None`` or the empty string), Django 
+      executes a ``SELECT`` query to determine whether a record with the given 
+      primary key already exists.
     * If the record with the given primary key does already exist, Django
       executes an ``UPDATE`` query.
     * If the object's primary key attribute is *not* set, or if it's set but a
diff --git a/docs/forms.txt b/docs/forms.txt
index ff192a4717..6efa24d28f 100644
--- a/docs/forms.txt
+++ b/docs/forms.txt
@@ -2,15 +2,27 @@
 Forms, fields, and manipulators
 ===============================
 
+Forwards-compatibility note
+===========================
+
+The legacy forms/manipulators system described in this document is going to be
+replaced in the next Django release. If you're starting from scratch, we
+strongly encourage you not to waste your time learning this. Instead, learn and
+use the django.newforms system, which we have begun to document in the
+`newforms documentation`_.
+
+If you have legacy form/manipulator code, read the "Migration plan" section in
+that document to understand how we're making the switch.
+
+.. _newforms documentation: http://www.djangoproject.com/documentation/newforms/
+
+Introduction
+============
+
 Once you've got a chance to play with Django's admin interface, you'll probably
 wonder if the fantastic form validation framework it uses is available to user
 code. It is, and this document explains how the framework works.
 
-    .. admonition:: A note to the lazy
-
-        If all you want to do is present forms for a user to create and/or
-        update a given object, you may be able to use `generic views`_.
-
 We'll take a top-down approach to examining Django's form validation framework,
 because much of the time you won't need to use the lower-level APIs. Throughout
 this document, we'll be working with the following model, a "place" object::
@@ -41,17 +53,17 @@ this document, we'll be working with the following model, a "place" object::
 Defining the above class is enough to create an admin interface to a ``Place``,
 but what if you want to allow public users to submit places?
 
-Manipulators
-============
+Automatic Manipulators
+======================
 
 The highest-level interface for object creation and modification is the
-**Manipulator** framework. A manipulator is a utility class tied to a given
-model that "knows" how to create or modify instances of that model and how to
-validate data for the object. Manipulators come in two flavors:
-``AddManipulators`` and ``ChangeManipulators``. Functionally they are quite
-similar, but the former knows how to create new instances of the model, while
-the latter modifies existing instances. Both types of classes are automatically
-created when you define a new class::
+**automatic Manipulator** framework. An automatic manipulator is a utility
+class tied to a given model that "knows" how to create or modify instances of
+that model and how to validate data for the object. Automatic Manipulators come
+in two flavors: ``AddManipulators`` and ``ChangeManipulators``. Functionally
+they are quite similar, but the former knows how to create new instances of the
+model, while the latter modifies existing instances. Both types of classes are
+automatically created when you define a new class::
 
     >>> from mysite.myapp.models import Place
     >>> Place.AddManipulator
diff --git a/docs/generic_views.txt b/docs/generic_views.txt
index 1736770a20..25635f35d8 100644
--- a/docs/generic_views.txt
+++ b/docs/generic_views.txt
@@ -902,7 +902,7 @@ If ``template_name`` isn't specified, this view will use the template
 
 In addition to ``extra_context``, the template's context will be:
 
-    * ``form``: A ``django.forms.FormWrapper`` instance representing the form
+    * ``form``: A ``django.oldforms.FormWrapper`` instance representing the form
       for editing the object. This lets you refer to form fields easily in the
       template system.
 
@@ -984,7 +984,7 @@ If ``template_name`` isn't specified, this view will use the template
 
 In addition to ``extra_context``, the template's context will be:
 
-    * ``form``: A ``django.forms.FormWrapper`` instance representing the form
+    * ``form``: A ``django.oldforms.FormWrapper`` instance representing the form
       for editing the object. This lets you refer to form fields easily in the
       template system.
 
diff --git a/docs/newforms.txt b/docs/newforms.txt
new file mode 100644
index 0000000000..c4986eb45e
--- /dev/null
+++ b/docs/newforms.txt
@@ -0,0 +1,300 @@
+====================
+The newforms library
+====================
+
+``django.newforms`` is a new replacement for ``django.forms``, the old Django
+form/manipulator/validation framework. This document explains how to use this
+new form library.
+
+Migration plan
+==============
+
+``django.newforms`` currently is only available in the Django development version
+-- i.e., it's not available in the Django 0.95 release. For the next Django
+release, our plan is to do the following:
+
+    * As of revision [4208], we've copied the current ``django.forms`` to
+      ``django.oldforms``. This allows you to upgrade your code *now* rather
+      than waiting for the backwards-incompatible change and rushing to fix
+      your code after the fact. Just change your import statements like this::
+
+          from django import forms             # old
+          from django import oldforms as forms # new
+
+    * At an undecided future date, we will move the current ``django.newforms``
+      to ``django.forms``. This will be a backwards-incompatible change, and 
+      anybody who is still using the old version of ``django.forms`` at that
+      time will need to change their import statements, as described in the
+      previous bullet.
+
+    * We will remove ``django.oldforms`` in the release *after* the next Django
+      release -- the release that comes after the release in which we're
+      creating the new ``django.forms``.
+
+With this in mind, we recommend you use the following import statement when
+using ``django.newforms``::
+
+    from django import newforms as forms
+
+This way, your code can refer to the ``forms`` module, and when
+``django.newforms`` is renamed to ``django.forms``, you'll only have to change
+your ``import`` statements.
+
+If you prefer "``import *``" syntax, you can do the following::
+
+    from django.newforms import *
+
+This will import all fields, widgets, form classes and other various utilities
+into your local namespace. Some people find this convenient; others find it
+too messy. The choice is yours.
+
+Overview
+========
+
+As the ``django.forms`` ("manipulators") system before it, ``django.newforms``
+is intended to handle HTML form display, validation and redisplay. It's what
+you use if you want to perform server-side validation for an HTML form.
+
+For example, if your Web site has a contact form that visitors can use to
+send you e-mail, you'd use this library to implement the display of the HTML
+form fields, along with the form validation. Any time you need to use an HTML
+``<form>``, you can use this library.
+
+The library deals with these concepts:
+
+    * **Widget** -- A class that corresponds to an HTML form widget, e.g.
+      ``<input type="text">`` or ``<textarea>``. This handles rendering of the
+      widget as HTML.
+
+    * **Field** -- A class that is responsible for doing validation, e.g.
+      an ``EmailField`` that makes sure its data is a valid e-mail address.
+
+    * **Form** -- A collection of fields that knows how to validate itself and
+      display itself as HTML.
+
+Form objects
+============
+
+The primary way of using the ``newforms`` library is to create a form object.
+Do this by subclassing ``django.newforms.Form`` and specifying the form's
+fields, in a declarative style that you'll be familiar with if you've used
+Django database models. In this section, we'll iteratively develop a form
+object that you might to implement "contact me" functionality on your personal
+Web site.
+
+Start with this basic ``Form`` subclass, which we'll call ``ContactForm``::
+
+    from django import newforms as forms
+
+    class ContactForm(forms.Form):
+        subject = forms.CharField(max_length=100)
+        message = forms.CharField()
+        sender = forms.EmailField()
+        cc_myself = forms.BooleanField()
+
+A form is composed of ``Field`` objects. In this case, our form has four
+fields: ``subject``, ``message``, ``sender`` and ``cc_myself``. We'll explain
+the different types of fields -- e.g., ``CharField`` and ``EmailField`` --
+shortly.
+
+Outputting forms as HTML
+------------------------
+
+The first thing we can do with this is output it as HTML. To do so, instantiate
+it and ``print`` it::
+
+    >>> f = ContactForm()
+    >>> print f
+    <tr><th><label for="id_subject">Subject:</label></th><td><input id="id_subject" type="text" name="subject" maxlength="100" /></td></tr>
+    <tr><th><label for="id_message">Message:</label></th><td><input type="text" name="message" id="id_message" /></td></tr>
+    <tr><th><label for="id_sender">Sender:</label></th><td><input type="text" name="sender" id="id_sender" /></td></tr>
+    <tr><th><label for="id_cc_myself">Cc myself:</label></th><td><input type="checkbox" name="cc_myself" id="id_cc_myself" /></td></tr>
+
+This default output is a two-column HTML table, with a ``<tr>`` for each field.
+Notice the following:
+
+    * For flexibility, the output does *not* include the ``<table>`` and
+      ``</table>`` tags, nor does it include the ``<form>`` and ``</form>``
+      tags or an ``<input type="submit">`` tag. It's your job to do that.
+
+    * Each field type has a default HTML representation. ``CharField`` and
+      ``EmailField`` are represented by an ``<input type="text">``.
+      ``BooleanField`` is represented by an ``<input type="checkbox">``. Note
+      these are merely sensible defaults; you can specify which HTML to use for
+      a given field by using ``widgets``, which we'll explain shortly.
+
+    * The HTML ``name`` for each tag is taken directly from its attribute name
+      in the ``ContactForm`` class.
+
+    * The text label for each field -- e.g. ``'Subject:'``, ``'Message:'`` and
+      ``'CC myself:'`` is generated from the field name by converting all
+      underscores to spaces and upper-casing the first letter. Again, note
+      these are merely sensible defaults; you can also specify labels manually.
+
+    * Each text label is surrounded in an HTML ``<label>`` tag, which points
+      to the appropriate form field via its ``id``. Its ``id``, in turn, is
+      generated by prepending ``'id_'`` to the field name. The ``id``
+      attributes and ``<label>`` tags are included in the output by default, to
+      follow best practices, but you can change that behavior.
+
+Although ``<table>`` output is the default output style when you ``print`` a
+form, other output styles are available. Each style is available as a method on
+a form object, and each rendering method returns a Unicode object.
+
+``as_p()``
+~~~~~~~~~~
+
+``Form.as_p()`` renders the form as a series of ``<p>`` tags, with each ``<p>``
+containing one field::
+
+    >>> f = ContactForm()
+    >>> f.as_p()
+    u'<p><label for="id_subject">Subject:</label> <input id="id_subject" type="text" name="subject" maxlength="100" /></p>\n<p><label for="id_message">Message:</label> <input type="text" name="message" id="id_message" /></p>\n<p><label for="id_sender">Sender:</label> <input type="text" name="sender" id="id_sender" /></p>\n<p><label for="id_cc_myself">Cc myself:</label> <input type="checkbox" name="cc_myself" id="id_cc_myself" /></p>'
+    >>> print f.as_p()
+    <p><label for="id_subject">Subject:</label> <input id="id_subject" type="text" name="subject" maxlength="100" /></p>
+    <p><label for="id_message">Message:</label> <input type="text" name="message" id="id_message" /></p>
+    <p><label for="id_sender">Sender:</label> <input type="text" name="sender" id="id_sender" /></p>
+    <p><label for="id_cc_myself">Cc myself:</label> <input type="checkbox" name="cc_myself" id="id_cc_myself" /></p>
+
+``as_ul()``
+~~~~~~~~~~~
+
+``Form.as_ul()`` renders the form as a series of ``<li>`` tags, with each
+``<li>`` containing one field. It does *not* include the ``<ul>`` or ``</ul>``,
+so that you can specify any HTML attributes on the ``<ul>`` for flexibility::
+
+    >>> f = ContactForm()
+    >>> f.as_ul()
+    u'<li><label for="id_subject">Subject:</label> <input id="id_subject" type="text" name="subject" maxlength="100" /></li>\n<li><label for="id_message">Message:</label> <input type="text" name="message" id="id_message" /></li>\n<li><label for="id_sender">Sender:</label> <input type="text" name="sender" id="id_sender" /></li>\n<li><label for="id_cc_myself">Cc myself:</label> <input type="checkbox" name="cc_myself" id="id_cc_myself" /></li>'
+    >>> print f.as_ul()
+    <li><label for="id_subject">Subject:</label> <input id="id_subject" type="text" name="subject" maxlength="100" /></li>
+    <li><label for="id_message">Message:</label> <input type="text" name="message" id="id_message" /></li>
+    <li><label for="id_sender">Sender:</label> <input type="text" name="sender" id="id_sender" /></li>
+    <li><label for="id_cc_myself">Cc myself:</label> <input type="checkbox" name="cc_myself" id="id_cc_myself" /></li>
+
+``as_table()``
+~~~~~~~~~~~~~~
+
+Finally, ``Form.as_table()`` outputs the form as an HTML ``<table>``. This is
+exactly the same as ``print``. In fact, when you ``print`` a form object, it
+calls its ``as_table()`` method behind the scenes::
+
+    >>> f = ContactForm()
+    >>> f.as_table()
+    u'<tr><th><label for="id_subject">Subject:</label></th><td><input id="id_subject" type="text" name="subject" maxlength="100" /></td></tr>\n<tr><th><label for="id_message">Message:</label></th><td><input type="text" name="message" id="id_message" /></td></tr>\n<tr><th><label for="id_sender">Sender:</label></th><td><input type="text" name="sender" id="id_sender" /></td></tr>\n<tr><th><label for="id_cc_myself">Cc myself:</label></th><td><input type="checkbox" name="cc_myself" id="id_cc_myself" /></td></tr>'
+    >>> print f.as_table()
+    <tr><th><label for="id_subject">Subject:</label></th><td><input id="id_subject" type="text" name="subject" maxlength="100" /></td></tr>
+    <tr><th><label for="id_message">Message:</label></th><td><input type="text" name="message" id="id_message" /></td></tr>
+    <tr><th><label for="id_sender">Sender:</label></th><td><input type="text" name="sender" id="id_sender" /></td></tr>
+    <tr><th><label for="id_cc_myself">Cc myself:</label></th><td><input type="checkbox" name="cc_myself" id="id_cc_myself" /></td></tr>
+
+Configuring HTML ``<label>`` tags
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+An HTML ``<label>`` tag designates which label text is associated with which
+form element. This small enhancement makes forms more usable and more accessible
+to assistive devices. It's always a good idea to use ``<label>`` tags.
+
+By default, the form rendering methods include HTML ``id`` attributes on the
+form elements and corresponding ``<label>`` tags around the labels. The ``id``
+attribute values are generated by prepending ``id_`` to the form field names.
+This behavior is configurable, though, if you want to change the ``id``
+convention or remove HTML ``id`` attributes and ``<label>`` tags entirely.
+
+Use the ``auto_id`` argument to the ``Form`` constructor to control the label
+and ``id`` behavior. This argument must be ``True``, ``False`` or a string.
+
+If ``auto_id`` is ``False``, then the form output will not include ``<label>``
+tags nor ``id`` attributes::
+
+    >>> f = ContactForm(auto_id=False)
+    >>> print f.as_table()
+    <tr><th>Subject:</th><td><input type="text" name="subject" maxlength="100" /></td></tr>
+    <tr><th>Message:</th><td><input type="text" name="message" /></td></tr>
+    <tr><th>Sender:</th><td><input type="text" name="sender" /></td></tr>
+    <tr><th>Cc myself:</th><td><input type="checkbox" name="cc_myself" /></td></tr>
+    >>> print f.as_ul()
+    <li>Subject: <input type="text" name="subject" maxlength="100" /></li>
+    <li>Message: <input type="text" name="message" /></li>
+    <li>Sender: <input type="text" name="sender" /></li>
+    <li>Cc myself: <input type="checkbox" name="cc_myself" /></li>
+    >>> print f.as_p()
+    <p>Subject: <input type="text" name="subject" maxlength="100" /></p>
+    <p>Message: <input type="text" name="message" /></p>
+    <p>Sender: <input type="text" name="sender" /></p>
+    <p>Cc myself: <input type="checkbox" name="cc_myself" /></p>
+
+If ``auto_id`` is set to ``True``, then the form output *will* include
+``<label>`` tags and will simply use the field name as its ``id`` for each form
+field::
+
+    >>> f = ContactForm(auto_id=True)
+    >>> print f.as_table()
+    <tr><th><label for="subject">Subject:</label></th><td><input id="subject" type="text" name="subject" maxlength="100" /></td></tr>
+    <tr><th><label for="message">Message:</label></th><td><input type="text" name="message" id="message" /></td></tr>
+    <tr><th><label for="sender">Sender:</label></th><td><input type="text" name="sender" id="sender" /></td></tr>
+    <tr><th><label for="cc_myself">Cc myself:</label></th><td><input type="checkbox" name="cc_myself" id="cc_myself" /></td></tr>
+    >>> print f.as_ul()
+    <li><label for="subject">Subject:</label> <input id="subject" type="text" name="subject" maxlength="100" /></li>
+    <li><label for="message">Message:</label> <input type="text" name="message" id="message" /></li>
+    <li><label for="sender">Sender:</label> <input type="text" name="sender" id="sender" /></li>
+    <li><label for="cc_myself">Cc myself:</label> <input type="checkbox" name="cc_myself" id="cc_myself" /></li>
+    >>> print f.as_p()
+    <p><label for="subject">Subject:</label> <input id="subject" type="text" name="subject" maxlength="100" /></p>
+    <p><label for="message">Message:</label> <input type="text" name="message" id="message" /></p>
+    <p><label for="sender">Sender:</label> <input type="text" name="sender" id="sender" /></p>
+    <p><label for="cc_myself">Cc myself:</label> <input type="checkbox" name="cc_myself" id="cc_myself" /></p>
+
+If ``auto_id`` is set to a string containing the format character ``'%s'``,
+then the form output will include ``<label>`` tags, and will generate ``id``
+attributes based on the format string. For example, for a format string
+``'field_%s'``, a field named ``subject`` will get the ``id``
+``'field_subject'``. Continuing our example::
+
+    >>> f = ContactForm(auto_id='id_for_%s')
+    >>> print f.as_table()
+    <tr><th><label for="id_for_subject">Subject:</label></th><td><input id="id_for_subject" type="text" name="subject" maxlength="100" /></td></tr>
+    <tr><th><label for="id_for_message">Message:</label></th><td><input type="text" name="message" id="id_for_message" /></td></tr>
+    <tr><th><label for="id_for_sender">Sender:</label></th><td><input type="text" name="sender" id="id_for_sender" /></td></tr>
+    <tr><th><label for="id_for_cc_myself">Cc myself:</label></th><td><input type="checkbox" name="cc_myself" id="id_for_cc_myself" /></td></tr>
+    >>> print f.as_ul()
+    <li><label for="id_for_subject">Subject:</label> <input id="id_for_subject" type="text" name="subject" maxlength="100" /></li>
+    <li><label for="id_for_message">Message:</label> <input type="text" name="message" id="id_for_message" /></li>
+    <li><label for="id_for_sender">Sender:</label> <input type="text" name="sender" id="id_for_sender" /></li>
+    <li><label for="id_for_cc_myself">Cc myself:</label> <input type="checkbox" name="cc_myself" id="id_for_cc_myself" /></li>
+    >>> print f.as_p()
+    <p><label for="id_for_subject">Subject:</label> <input id="id_for_subject" type="text" name="subject" maxlength="100" /></p>
+    <p><label for="id_for_message">Message:</label> <input type="text" name="message" id="id_for_message" /></p>
+    <p><label for="id_for_sender">Sender:</label> <input type="text" name="sender" id="id_for_sender" /></p>
+    <p><label for="id_for_cc_myself">Cc myself:</label> <input type="checkbox" name="cc_myself" id="id_for_cc_myself" /></p>
+
+If ``auto_id`` is set to any other true value -- such as a string that doesn't
+include ``%s`` -- then the library will act as if ``auto_id`` is ``True``.
+
+By default, ``auto_id`` is set to the string ``'id_%s'``.
+
+Notes on field ordering
+~~~~~~~~~~~~~~~~~~~~~~~
+
+In the ``as_p()``, ``as_ul()`` and ``as_table()`` shortcuts, the fields are
+displayed in the order in which you define them in your form class. For
+example, in the ``ContactForm`` example, the fields are defined in the order
+``subject``, ``message``, ``sender``, ``cc_myself``. To reorder the HTML
+output, just change the order in which those fields are listed in the class.
+
+More coming soon
+================
+
+That's all the documentation for now. For more, see the file
+http://code.djangoproject.com/browser/django/trunk/tests/regressiontests/forms/tests.py
+-- the unit tests for ``django.newforms``. This can give you a good idea of
+what's possible.
+
+Using forms to validate data
+----------------------------
+
+Using forms with templates
+==========================
+
+Using forms in views
+====================
diff --git a/docs/redirects.txt b/docs/redirects.txt
index e0bcb2f1fa..13f08668c8 100644
--- a/docs/redirects.txt
+++ b/docs/redirects.txt
@@ -63,9 +63,9 @@ Via the Python API
 ------------------
 
 Redirects are represented by a standard `Django model`_, which lives in
-`django/contrib/redirects/models/redirects.py`_. You can access redirect
+`django/contrib/redirects/models.py`_. You can access redirect
 objects via the `Django database API`_.
 
 .. _Django model: http://www.djangoproject.com/documentation/model_api/
-.. _django/contrib/redirects/models/redirects.py: http://code.djangoproject.com/browser/django/trunk/django/contrib/redirects/models/redirects.py
+.. _django/contrib/redirects/models.py: http://code.djangoproject.com/browser/django/trunk/django/contrib/redirects/models.py
 .. _Django database API: http://www.djangoproject.com/documentation/db_api/
diff --git a/docs/sessions.txt b/docs/sessions.txt
index d39f42c3bf..dd4a581d91 100644
--- a/docs/sessions.txt
+++ b/docs/sessions.txt
@@ -141,7 +141,7 @@ Do this after you've verified that the test cookie worked.
 Here's a typical usage example::
 
     def login(request):
-        if request.POST:
+        if request.method == 'POST':
             if request.session.test_cookie_worked():
                 request.session.delete_test_cookie()
                 return HttpResponse("You're logged in.")
diff --git a/docs/settings.txt b/docs/settings.txt
index ff1e2eeca2..ba1e8eafea 100644
--- a/docs/settings.txt
+++ b/docs/settings.txt
@@ -830,7 +830,7 @@ Default: ``Django/<version> (http://www.djangoproject.com/)``
 The string to use as the ``User-Agent`` header when checking to see if URLs
 exist (see the ``verify_exists`` option on URLField_).
 
-.. URLField: ../model_api/#urlfield
+.. _URLField: ../model_api/#urlfield
 
 USE_ETAGS
 ---------
@@ -871,7 +871,7 @@ TIME_FORMAT and MONTH_DAY_FORMAT.
 .. _cache docs: http://www.djangoproject.com/documentation/cache/
 .. _middleware docs: http://www.djangoproject.com/documentation/middleware/
 .. _session docs: http://www.djangoproject.com/documentation/sessions/
-.. _See available choices: http://www.postgresql.org/docs/current/static/datetime-keywords.html#DATETIME-TIMEZONE-SET-TABLE
+.. _See available choices: http://www.postgresql.org/docs/8.1/static/datetime-keywords.html#DATETIME-TIMEZONE-SET-TABLE
 .. _template documentation: http://www.djangoproject.com/documentation/templates_python/
 
 Creating your own settings
diff --git a/docs/testing.txt b/docs/testing.txt
index 68eff07788..a0b8a8a187 100644
--- a/docs/testing.txt
+++ b/docs/testing.txt
@@ -133,7 +133,7 @@ together, picking the test system to match the type of tests you need to
 write.
 
 For developers new to testing, however, this choice can seem
-confusing, so here are a few key differences to help you decide weather
+confusing, so here are a few key differences to help you decide whether
 doctests or unit tests are right for you.
 
 If you've been using Python for a while, ``doctest`` will probably feel more
diff --git a/setup.py b/setup.py
index 9dd5fd9144..f403029efe 100644
--- a/setup.py
+++ b/setup.py
@@ -11,19 +11,26 @@ for scheme in INSTALL_SCHEMES.values():
 # Compile the list of packages available, because distutils doesn't have
 # an easy way to do this.
 packages, data_files = [], []
-root_dir = os.path.join(os.path.dirname(__file__), 'django')
-for dirpath, dirnames, filenames in os.walk(root_dir):
+root_dir = os.path.dirname(__file__)
+len_root_dir = len(root_dir)
+django_dir = os.path.join(root_dir, 'django')
+
+for dirpath, dirnames, filenames in os.walk(django_dir):
     # Ignore dirnames that start with '.'
     for i, dirname in enumerate(dirnames):
         if dirname.startswith('.'): del dirnames[i]
     if '__init__.py' in filenames:
-        packages.append(dirpath.replace('/', '.'))
+        package = dirpath[len_root_dir:].lstrip('/').replace('/', '.')
+        packages.append(package)
     else:
         data_files.append((dirpath, [os.path.join(dirpath, f) for f in filenames]))
 
+# Dynamically calculate the version based on django.VERSION.
+version = "%d.%d-%s" % (__import__('django').VERSION)
+
 setup(
     name = "Django",
-    version = "0.95",
+    version = version,
     url = 'http://www.djangoproject.com/',
     author = 'Lawrence Journal-World',
     author_email = 'holovaty@gmail.com',
diff --git a/tests/modeltests/basic/models.py b/tests/modeltests/basic/models.py
index 5638865f31..1663068892 100644
--- a/tests/modeltests/basic/models.py
+++ b/tests/modeltests/basic/models.py
@@ -10,6 +10,9 @@ class Article(models.Model):
     headline = models.CharField(maxlength=100, default='Default headline')
     pub_date = models.DateTimeField()
 
+    class Meta:
+        ordering = ('pub_date','headline')
+        
     def __str__(self):
         return self.headline
 
@@ -245,7 +248,7 @@ datetime.datetime(2005, 7, 28, 0, 0)
 
 # Slices (without step) are lazy:
 >>> Article.objects.all()[0:5].filter()
-[<Article: Area woman programs in Python>, <Article: Second article>, <Article: Third article>, <Article: Fourth article>, <Article: Article 6>]
+[<Article: Area woman programs in Python>, <Article: Second article>, <Article: Third article>, <Article: Article 6>, <Article: Default headline>]
 
 # Slicing again works:
 >>> Article.objects.all()[0:5][0:2]
@@ -253,17 +256,17 @@ datetime.datetime(2005, 7, 28, 0, 0)
 >>> Article.objects.all()[0:5][:2]
 [<Article: Area woman programs in Python>, <Article: Second article>]
 >>> Article.objects.all()[0:5][4:]
-[<Article: Article 6>]
+[<Article: Default headline>]
 >>> Article.objects.all()[0:5][5:]
 []
 
 # Some more tests!
 >>> Article.objects.all()[2:][0:2]
-[<Article: Third article>, <Article: Fourth article>]
+[<Article: Third article>, <Article: Article 6>]
 >>> Article.objects.all()[2:][:2]
-[<Article: Third article>, <Article: Fourth article>]
+[<Article: Third article>, <Article: Article 6>]
 >>> Article.objects.all()[2:][2:3]
-[<Article: Article 6>]
+[<Article: Default headline>]
 
 # Note that you can't use 'offset' without 'limit' (on some dbs), so this doesn't work:
 >>> Article.objects.all()[2:]
@@ -312,7 +315,7 @@ AttributeError: Manager isn't accessible via Article instances
 
 # Bulk delete test: How many objects before and after the delete?
 >>> Article.objects.all()
-[<Article: Area woman programs in Python>, <Article: Second article>, <Article: Third article>, <Article: Fourth article>, <Article: Article 6>, <Article: Default headline>, <Article: Article 7>, <Article: Updated article 8>]
+[<Article: Area woman programs in Python>, <Article: Second article>, <Article: Third article>, <Article: Article 6>, <Article: Default headline>, <Article: Fourth article>, <Article: Article 7>, <Article: Updated article 8>]
 >>> Article.objects.filter(id__lte=4).delete()
 >>> Article.objects.all()
 [<Article: Article 6>, <Article: Default headline>, <Article: Article 7>, <Article: Updated article 8>]
diff --git a/tests/modeltests/many_to_many/models.py b/tests/modeltests/many_to_many/models.py
index 357f3ca629..38f8931ee7 100644
--- a/tests/modeltests/many_to_many/models.py
+++ b/tests/modeltests/many_to_many/models.py
@@ -231,4 +231,16 @@ __test__ = {'API_TESTS':"""
 >>> p1.article_set.all()
 [<Article: NASA uses Python>]
 
+# An alternate to calling clear() is to assign the empty set
+>>> p1.article_set = []
+>>> p1.article_set.all()
+[]
+
+>>> a2.publications = [p1, new_publication]
+>>> a2.publications.all()
+[<Publication: Highlights for Children>, <Publication: The Python Journal>]
+>>> a2.publications = []
+>>> a2.publications.all()
+[]
+
 """}
diff --git a/tests/modeltests/model_forms/__init__.py b/tests/modeltests/model_forms/__init__.py
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/tests/modeltests/model_forms/__init__.py
diff --git a/tests/modeltests/model_forms/models.py b/tests/modeltests/model_forms/models.py
new file mode 100644
index 0000000000..5ffd6aac9f
--- /dev/null
+++ b/tests/modeltests/model_forms/models.py
@@ -0,0 +1,113 @@
+"""
+34. Generating HTML forms from models
+
+Django provides shortcuts for creating Form objects from a model class.
+
+The function django.newforms.form_for_model() takes a model class and returns
+a Form that is tied to the model. This Form works just like any other Form,
+with one additional method: create(). The create() method creates an instance
+of the model and returns that newly created instance. It saves the instance to
+the database if create(save=True), which is default. If you pass
+create(save=False), then you'll get the object without saving it.
+"""
+
+from django.db import models
+
+class Category(models.Model):
+    name = models.CharField(maxlength=20)
+    url = models.CharField('The URL', maxlength=40)
+
+    def __str__(self):
+        return self.name
+
+class Article(models.Model):
+    headline = models.CharField(maxlength=50)
+    pub_date = models.DateTimeField()
+    categories = models.ManyToManyField(Category)
+
+    def __str__(self):
+        return self.headline
+
+__test__ = {'API_TESTS': """
+>>> from django.newforms import form_for_model, BaseForm
+
+>>> Category.objects.all()
+[]
+
+>>> CategoryForm = form_for_model(Category)
+>>> f = CategoryForm()
+>>> print f
+<tr><th><label for="id_name">Name:</label></th><td><input id="id_name" type="text" name="name" maxlength="20" /></td></tr>
+<tr><th><label for="id_url">The URL:</label></th><td><input id="id_url" type="text" name="url" maxlength="40" /></td></tr>
+>>> print f.as_ul()
+<li><label for="id_name">Name:</label> <input id="id_name" type="text" name="name" maxlength="20" /></li>
+<li><label for="id_url">The URL:</label> <input id="id_url" type="text" name="url" maxlength="40" /></li>
+>>> print f['name']
+<input id="id_name" type="text" name="name" maxlength="20" />
+
+>>> f = CategoryForm(auto_id=False)
+>>> print f.as_ul()
+<li>Name: <input type="text" name="name" maxlength="20" /></li>
+<li>The URL: <input type="text" name="url" maxlength="40" /></li>
+
+>>> f = CategoryForm({'name': 'Entertainment', 'url': 'entertainment'})
+>>> f.errors
+{}
+>>> f.clean_data
+{'url': u'entertainment', 'name': u'Entertainment'}
+>>> obj = f.create()
+>>> obj
+<Category: Entertainment>
+>>> Category.objects.all()
+[<Category: Entertainment>]
+
+>>> f = CategoryForm({'name': "It's a test", 'url': 'test'})
+>>> f.errors
+{}
+>>> f.clean_data
+{'url': u'test', 'name': u"It's a test"}
+>>> obj = f.create()
+>>> obj
+<Category: It's a test>
+>>> Category.objects.all()
+[<Category: Entertainment>, <Category: It's a test>]
+
+>>> f = CategoryForm({'name': 'Third test', 'url': 'third'})
+>>> f.errors
+{}
+>>> f.clean_data
+{'url': u'third', 'name': u'Third test'}
+>>> obj = f.create(save=False)
+>>> obj
+<Category: Third test>
+>>> Category.objects.all()
+[<Category: Entertainment>, <Category: It's a test>]
+>>> obj.save()
+>>> Category.objects.all()
+[<Category: Entertainment>, <Category: It's a test>, <Category: Third test>]
+
+>>> f = CategoryForm({'name': '', 'url': 'foo'})
+>>> f.errors
+{'name': [u'This field is required.']}
+>>> f.clean_data
+>>> f.create()
+Traceback (most recent call last):
+...
+ValueError: The Category could not be created because the data didn't validate.
+
+>>> f = CategoryForm({'name': '', 'url': 'foo'})
+>>> f.create()
+Traceback (most recent call last):
+...
+ValueError: The Category could not be created because the data didn't validate.
+
+You can pass a custom Form class to form_for_model. Make sure it's a
+subclass of BaseForm, not Form.
+>>> class CustomForm(BaseForm):
+...     def say_hello(self):
+...         print 'hello'
+>>> CategoryForm = form_for_model(Category, form=CustomForm)
+>>> f = CategoryForm()
+>>> f.say_hello()
+hello
+"""}
diff --git a/tests/regressiontests/forms/tests.py b/tests/regressiontests/forms/tests.py
index 73fa3c27bf..50bc7a7595 100644
--- a/tests/regressiontests/forms/tests.py
+++ b/tests/regressiontests/forms/tests.py
@@ -4,6 +4,14 @@ r"""
 >>> import datetime
 >>> import re
 
+###########
+# Widgets #
+###########
+
+Each Widget class corresponds to an HTML form widget. A Widget knows how to
+render itself, given a field name and some data. Widgets don't perform
+validation.
+
 # TextInput Widget ############################################################
 
 >>> w = TextInput()
@@ -156,10 +164,18 @@ u'<textarea class="fun" name="msg">\u0160\u0110\u0106\u017d\u0107\u017e\u0161\u0
 >>> w = CheckboxInput()
 >>> w.render('is_cool', '')
 u'<input type="checkbox" name="is_cool" />'
+>>> w.render('is_cool', None)
+u'<input type="checkbox" name="is_cool" />'
 >>> w.render('is_cool', False)
 u'<input type="checkbox" name="is_cool" />'
 >>> w.render('is_cool', True)
 u'<input checked="checked" type="checkbox" name="is_cool" />'
+
+Using any value that's not in ('', None, False, True) will check the checkbox
+and set the 'value' attribute.
+>>> w.render('is_cool', 'foo')
+u'<input checked="checked" type="checkbox" name="is_cool" value="foo" />'
+
 >>> w.render('is_cool', False, attrs={'class': 'pretty'})
 u'<input type="checkbox" name="is_cool" class="pretty" />'
 
@@ -173,6 +189,29 @@ u'<input type="checkbox" class="pretty" name="is_cool" />'
 >>> w.render('is_cool', '', attrs={'class': 'special'})
 u'<input type="checkbox" class="special" name="is_cool" />'
 
+You can pass 'check_test' to the constructor. This is a callable that takes the
+value and returns True if the box should be checked.
+>>> w = CheckboxInput(check_test=lambda value: value.startswith('hello'))
+>>> w.render('greeting', '')
+u'<input type="checkbox" name="greeting" />'
+>>> w.render('greeting', 'hello')
+u'<input checked="checked" type="checkbox" name="greeting" value="hello" />'
+>>> w.render('greeting', 'hello there')
+u'<input checked="checked" type="checkbox" name="greeting" value="hello there" />'
+>>> w.render('greeting', 'hello & goodbye')
+u'<input checked="checked" type="checkbox" name="greeting" value="hello &amp; goodbye" />'
+
+A subtlety: If the 'check_test' argument cannot handle a value and raises any
+exception during its __call__, then the exception will be swallowed and the box
+will not be checked. In this example, the 'check_test' assumes the value has a
+startswith() method, which fails for the values True, False and None.
+>>> w.render('greeting', True)
+u'<input type="checkbox" name="greeting" />'
+>>> w.render('greeting', False)
+u'<input type="checkbox" name="greeting" />'
+>>> w.render('greeting', None)
+u'<input type="checkbox" name="greeting" />'
+
 # Select Widget ###############################################################
 
 >>> w = Select()
@@ -475,8 +514,172 @@ beatle J P Paul False
 beatle J G George False
 beatle J R Ringo False
 
+A RadioFieldRenderer object also allows index access to individual RadioInput
+objects.
+>>> w = RadioSelect()
+>>> r = w.render('beatle', 'J', choices=(('J', 'John'), ('P', 'Paul'), ('G', 'George'), ('R', 'Ringo')))
+>>> print r[1]
+<label><input type="radio" name="beatle" value="P" /> Paul</label>
+>>> print r[0]
+<label><input checked="checked" type="radio" name="beatle" value="J" /> John</label>
+>>> r[0].is_checked()
+True
+>>> r[1].is_checked()
+False
+>>> r[1].name, r[1].value, r[1].choice_value, r[1].choice_label
+('beatle', u'J', 'P', 'Paul')
+>>> r[10]
+Traceback (most recent call last):
+...
+IndexError: list index out of range
+
+# CheckboxSelectMultiple Widget ###############################################
+
+>>> w = CheckboxSelectMultiple()
+>>> print w.render('beatles', ['J'], choices=(('J', 'John'), ('P', 'Paul'), ('G', 'George'), ('R', 'Ringo')))
+<ul>
+<li><label><input checked="checked" type="checkbox" name="beatles" value="J" /> John</label></li>
+<li><label><input type="checkbox" name="beatles" value="P" /> Paul</label></li>
+<li><label><input type="checkbox" name="beatles" value="G" /> George</label></li>
+<li><label><input type="checkbox" name="beatles" value="R" /> Ringo</label></li>
+</ul>
+>>> print w.render('beatles', ['J', 'P'], choices=(('J', 'John'), ('P', 'Paul'), ('G', 'George'), ('R', 'Ringo')))
+<ul>
+<li><label><input checked="checked" type="checkbox" name="beatles" value="J" /> John</label></li>
+<li><label><input checked="checked" type="checkbox" name="beatles" value="P" /> Paul</label></li>
+<li><label><input type="checkbox" name="beatles" value="G" /> George</label></li>
+<li><label><input type="checkbox" name="beatles" value="R" /> Ringo</label></li>
+</ul>
+>>> print w.render('beatles', ['J', 'P', 'R'], choices=(('J', 'John'), ('P', 'Paul'), ('G', 'George'), ('R', 'Ringo')))
+<ul>
+<li><label><input checked="checked" type="checkbox" name="beatles" value="J" /> John</label></li>
+<li><label><input checked="checked" type="checkbox" name="beatles" value="P" /> Paul</label></li>
+<li><label><input type="checkbox" name="beatles" value="G" /> George</label></li>
+<li><label><input checked="checked" type="checkbox" name="beatles" value="R" /> Ringo</label></li>
+</ul>
+
+If the value is None, none of the options are selected:
+>>> print w.render('beatles', None, choices=(('J', 'John'), ('P', 'Paul'), ('G', 'George'), ('R', 'Ringo')))
+<ul>
+<li><label><input type="checkbox" name="beatles" value="J" /> John</label></li>
+<li><label><input type="checkbox" name="beatles" value="P" /> Paul</label></li>
+<li><label><input type="checkbox" name="beatles" value="G" /> George</label></li>
+<li><label><input type="checkbox" name="beatles" value="R" /> Ringo</label></li>
+</ul>
+
+If the value corresponds to a label (but not to an option value), none of the options are selected:
+>>> print w.render('beatles', ['John'], choices=(('J', 'John'), ('P', 'Paul'), ('G', 'George'), ('R', 'Ringo')))
+<ul>
+<li><label><input type="checkbox" name="beatles" value="J" /> John</label></li>
+<li><label><input type="checkbox" name="beatles" value="P" /> Paul</label></li>
+<li><label><input type="checkbox" name="beatles" value="G" /> George</label></li>
+<li><label><input type="checkbox" name="beatles" value="R" /> Ringo</label></li>
+</ul>
+
+If multiple values are given, but some of them are not valid, the valid ones are selected:
+>>> print w.render('beatles', ['J', 'G', 'foo'], choices=(('J', 'John'), ('P', 'Paul'), ('G', 'George'), ('R', 'Ringo')))
+<ul>
+<li><label><input checked="checked" type="checkbox" name="beatles" value="J" /> John</label></li>
+<li><label><input type="checkbox" name="beatles" value="P" /> Paul</label></li>
+<li><label><input checked="checked" type="checkbox" name="beatles" value="G" /> George</label></li>
+<li><label><input type="checkbox" name="beatles" value="R" /> Ringo</label></li>
+</ul>
+
+The value is compared to its str():
+>>> print w.render('nums', [2], choices=[('1', '1'), ('2', '2'), ('3', '3')])
+<ul>
+<li><label><input type="checkbox" name="nums" value="1" /> 1</label></li>
+<li><label><input checked="checked" type="checkbox" name="nums" value="2" /> 2</label></li>
+<li><label><input type="checkbox" name="nums" value="3" /> 3</label></li>
+</ul>
+>>> print w.render('nums', ['2'], choices=[(1, 1), (2, 2), (3, 3)])
+<ul>
+<li><label><input type="checkbox" name="nums" value="1" /> 1</label></li>
+<li><label><input checked="checked" type="checkbox" name="nums" value="2" /> 2</label></li>
+<li><label><input type="checkbox" name="nums" value="3" /> 3</label></li>
+</ul>
+>>> print w.render('nums', [2], choices=[(1, 1), (2, 2), (3, 3)])
+<ul>
+<li><label><input type="checkbox" name="nums" value="1" /> 1</label></li>
+<li><label><input checked="checked" type="checkbox" name="nums" value="2" /> 2</label></li>
+<li><label><input type="checkbox" name="nums" value="3" /> 3</label></li>
+</ul>
+
+The 'choices' argument can be any iterable:
+>>> def get_choices():
+...     for i in range(5):
+...         yield (i, i)
+>>> print w.render('nums', [2], choices=get_choices())
+<ul>
+<li><label><input type="checkbox" name="nums" value="0" /> 0</label></li>
+<li><label><input type="checkbox" name="nums" value="1" /> 1</label></li>
+<li><label><input checked="checked" type="checkbox" name="nums" value="2" /> 2</label></li>
+<li><label><input type="checkbox" name="nums" value="3" /> 3</label></li>
+<li><label><input type="checkbox" name="nums" value="4" /> 4</label></li>
+</ul>
+
+You can also pass 'choices' to the constructor:
+>>> w = CheckboxSelectMultiple(choices=[(1, 1), (2, 2), (3, 3)])
+>>> print w.render('nums', [2])
+<ul>
+<li><label><input type="checkbox" name="nums" value="1" /> 1</label></li>
+<li><label><input checked="checked" type="checkbox" name="nums" value="2" /> 2</label></li>
+<li><label><input type="checkbox" name="nums" value="3" /> 3</label></li>
+</ul>
+
+If 'choices' is passed to both the constructor and render(), then they'll both be in the output:
+>>> print w.render('nums', [2], choices=[(4, 4), (5, 5)])
+<ul>
+<li><label><input type="checkbox" name="nums" value="1" /> 1</label></li>
+<li><label><input checked="checked" type="checkbox" name="nums" value="2" /> 2</label></li>
+<li><label><input type="checkbox" name="nums" value="3" /> 3</label></li>
+<li><label><input type="checkbox" name="nums" value="4" /> 4</label></li>
+<li><label><input type="checkbox" name="nums" value="5" /> 5</label></li>
+</ul>
+
+>>> w.render('nums', ['ŠĐĆŽćžšđ'], choices=[('ŠĐĆŽćžšđ', 'ŠĐabcĆŽćžšđ'), ('ćžšđ', 'abcćžšđ')])
+u'<ul>\n<li><label><input type="checkbox" name="nums" value="1" /> 1</label></li>\n<li><label><input type="checkbox" name="nums" value="2" /> 2</label></li>\n<li><label><input type="checkbox" name="nums" value="3" /> 3</label></li>\n<li><label><input checked="checked" type="checkbox" name="nums" value="\u0160\u0110\u0106\u017d\u0107\u017e\u0161\u0111" /> \u0160\u0110abc\u0106\u017d\u0107\u017e\u0161\u0111</label></li>\n<li><label><input type="checkbox" name="nums" value="\u0107\u017e\u0161\u0111" /> abc\u0107\u017e\u0161\u0111</label></li>\n</ul>'
+
+##########
+# Fields #
+##########
+
+Each Field class does some sort of validation. Each Field has a clean() method,
+which either raises django.newforms.ValidationError or returns the "clean"
+data -- usually a Unicode object, but, in some rare cases, a list.
+
+Each Field's __init__() takes at least these parameters:
+    required -- Boolean that specifies whether the field is required.
+                True by default.
+    widget -- A Widget class, or instance of a Widget class, that should be
+              used for this Field when displaying it. Each Field has a default
+              Widget that it'll use if you don't specify this. In most cases,
+              the default widget is TextInput.
+    label -- A verbose name for this field, for use in displaying this field in
+             a form. By default, Django will use a "pretty" version of the form
+             field name, if the Field is part of a Form.
+
+Other than that, the Field subclasses have class-specific options for
+__init__(). For example, CharField has a max_length option.
+
 # CharField ###################################################################
 
+>>> f = CharField()
+>>> f.clean(1)
+u'1'
+>>> f.clean('hello')
+u'hello'
+>>> f.clean(None)
+Traceback (most recent call last):
+...
+ValidationError: [u'This field is required.']
+>>> f.clean('')
+Traceback (most recent call last):
+...
+ValidationError: [u'This field is required.']
+>>> f.clean([1, 2, 3])
+u'[1, 2, 3]'
+
 >>> f = CharField(required=False)
 >>> f.clean(1)
 u'1'
@@ -484,13 +687,13 @@ u'1'
 u'hello'
 >>> f.clean(None)
 u''
+>>> f.clean('')
+u''
 >>> f.clean([1, 2, 3])
 u'[1, 2, 3]'
 
 CharField accepts an optional max_length parameter:
 >>> f = CharField(max_length=10, required=False)
->>> f.clean('')
-u''
 >>> f.clean('12345')
 u'12345'
 >>> f.clean('1234567890')
@@ -503,9 +706,21 @@ ValidationError: [u'Ensure this value has at most 10 characters.']
 CharField accepts an optional min_length parameter:
 >>> f = CharField(min_length=10, required=False)
 >>> f.clean('')
+u''
+>>> f.clean('12345')
 Traceback (most recent call last):
 ...
 ValidationError: [u'Ensure this value has at least 10 characters.']
+>>> f.clean('1234567890')
+u'1234567890'
+>>> f.clean('1234567890a')
+u'1234567890a'
+
+>>> f = CharField(min_length=10, required=True)
+>>> f.clean('')
+Traceback (most recent call last):
+...
+ValidationError: [u'This field is required.']
 >>> f.clean('12345')
 Traceback (most recent call last):
 ...
@@ -518,6 +733,40 @@ u'1234567890a'
 # IntegerField ################################################################
 
 >>> f = IntegerField()
+>>> f.clean('')
+Traceback (most recent call last):
+...
+ValidationError: [u'This field is required.']
+>>> f.clean(None)
+Traceback (most recent call last):
+...
+ValidationError: [u'This field is required.']
+>>> f.clean('1')
+1
+>>> isinstance(f.clean('1'), int)
+True
+>>> f.clean('23')
+23
+>>> f.clean('a')
+Traceback (most recent call last):
+...
+ValidationError: [u'Enter a whole number.']
+>>> f.clean('1 ')
+1
+>>> f.clean(' 1')
+1
+>>> f.clean(' 1 ')
+1
+>>> f.clean('1a')
+Traceback (most recent call last):
+...
+ValidationError: [u'Enter a whole number.']
+
+>>> f = IntegerField(required=False)
+>>> f.clean('')
+u''
+>>> f.clean(None)
+u''
 >>> f.clean('1')
 1
 >>> isinstance(f.clean('1'), int)
@@ -539,6 +788,71 @@ Traceback (most recent call last):
 ...
 ValidationError: [u'Enter a whole number.']
 
+IntegerField accepts an optional max_value parameter:
+>>> f = IntegerField(max_value=10)
+>>> f.clean(None)
+Traceback (most recent call last):
+...
+ValidationError: [u'This field is required.']
+>>> f.clean(1)
+1
+>>> f.clean(10)
+10
+>>> f.clean(11)
+Traceback (most recent call last):
+...
+ValidationError: [u'Ensure this value is less than or equal to 10.']
+>>> f.clean('10')
+10
+>>> f.clean('11')
+Traceback (most recent call last):
+...
+ValidationError: [u'Ensure this value is less than or equal to 10.']
+
+IntegerField accepts an optional min_value parameter:
+>>> f = IntegerField(min_value=10)
+>>> f.clean(None)
+Traceback (most recent call last):
+...
+ValidationError: [u'This field is required.']
+>>> f.clean(1)
+Traceback (most recent call last):
+...
+ValidationError: [u'Ensure this value is greater than or equal to 10.']
+>>> f.clean(10)
+10
+>>> f.clean(11)
+11
+>>> f.clean('10')
+10
+>>> f.clean('11')
+11
+
+min_value and max_value can be used together:
+>>> f = IntegerField(min_value=10, max_value=20)
+>>> f.clean(None)
+Traceback (most recent call last):
+...
+ValidationError: [u'This field is required.']
+>>> f.clean(1)
+Traceback (most recent call last):
+...
+ValidationError: [u'Ensure this value is greater than or equal to 10.']
+>>> f.clean(10)
+10
+>>> f.clean(11)
+11
+>>> f.clean('10')
+10
+>>> f.clean('11')
+11
+>>> f.clean(20)
+20
+>>> f.clean(21)
+Traceback (most recent call last):
+...
+ValidationError: [u'Ensure this value is less than or equal to 20.']
+
 # DateField ###################################################################
 
 >>> import datetime
@@ -616,6 +930,45 @@ Traceback (most recent call last):
 ...
 ValidationError: [u'Enter a valid date.']
 
+# TimeField ###################################################################
+
+>>> import datetime
+>>> f = TimeField()
+>>> f.clean(datetime.time(14, 25))
+datetime.time(14, 25)
+>>> f.clean(datetime.time(14, 25, 59))
+datetime.time(14, 25, 59)
+>>> f.clean('14:25')
+datetime.time(14, 25)
+>>> f.clean('14:25:59')
+datetime.time(14, 25, 59)
+>>> f.clean('hello')
+Traceback (most recent call last):
+...
+ValidationError: [u'Enter a valid time.']
+>>> f.clean('1:24 p.m.')
+Traceback (most recent call last):
+...
+ValidationError: [u'Enter a valid time.']
+
+TimeField accepts an optional input_formats parameter:
+>>> f = TimeField(input_formats=['%I:%M %p'])
+>>> f.clean(datetime.time(14, 25))
+datetime.time(14, 25)
+>>> f.clean(datetime.time(14, 25, 59))
+datetime.time(14, 25, 59)
+>>> f.clean('4:25 AM')
+datetime.time(4, 25)
+>>> f.clean('4:25 PM')
+datetime.time(16, 25)
+
+The input_formats parameter overrides all default input formats,
+so the default formats won't work unless you specify them:
+>>> f.clean('14:30:45')
+Traceback (most recent call last):
+...
+ValidationError: [u'Enter a valid time.']
+
 # DateTimeField ###############################################################
 
 >>> import datetime
@@ -681,6 +1034,14 @@ Traceback (most recent call last):
 ...
 ValidationError: [u'Enter a valid date/time.']
 
+>>> f = DateTimeField(required=False)
+>>> f.clean(None)
+>>> repr(f.clean(None))
+'None'
+>>> f.clean('')
+>>> repr(f.clean(''))
+'None'
+
 # RegexField ##################################################################
 
 >>> f = RegexField('^\d[A-F]\d$')
@@ -700,6 +1061,22 @@ ValidationError: [u'Enter a valid value.']
 Traceback (most recent call last):
 ...
 ValidationError: [u'Enter a valid value.']
+>>> f.clean('')
+Traceback (most recent call last):
+...
+ValidationError: [u'This field is required.']
+
+>>> f = RegexField('^\d[A-F]\d$', required=False)
+>>> f.clean('2A2')
+u'2A2'
+>>> f.clean('3F3')
+u'3F3'
+>>> f.clean('3G3')
+Traceback (most recent call last):
+...
+ValidationError: [u'Enter a valid value.']
+>>> f.clean('')
+u''
 
 Alternatively, RegexField can take a compiled regular expression:
 >>> f = RegexField(re.compile('^\d[A-F]\d$'))
@@ -721,7 +1098,7 @@ Traceback (most recent call last):
 ValidationError: [u'Enter a valid value.']
 
 RegexField takes an optional error_message argument:
->>> f = RegexField('^\d\d\d\d$', 'Enter a four-digit number.')
+>>> f = RegexField('^\d\d\d\d$', error_message='Enter a four-digit number.')
 >>> f.clean('1234')
 u'1234'
 >>> f.clean('123')
@@ -733,9 +1110,60 @@ Traceback (most recent call last):
 ...
 ValidationError: [u'Enter a four-digit number.']
 
+RegexField also access min_length and max_length parameters, for convenience.
+>>> f = RegexField('^\d+$', min_length=5, max_length=10)
+>>> f.clean('123')
+Traceback (most recent call last):
+...
+ValidationError: [u'Ensure this value has at least 5 characters.']
+>>> f.clean('abc')
+Traceback (most recent call last):
+...
+ValidationError: [u'Ensure this value has at least 5 characters.']
+>>> f.clean('12345')
+u'12345'
+>>> f.clean('1234567890')
+u'1234567890'
+>>> f.clean('12345678901')
+Traceback (most recent call last):
+...
+ValidationError: [u'Ensure this value has at most 10 characters.']
+>>> f.clean('12345a')
+Traceback (most recent call last):
+...
+ValidationError: [u'Enter a valid value.']
+
 # EmailField ##################################################################
 
 >>> f = EmailField()
+>>> f.clean('')
+Traceback (most recent call last):
+...
+ValidationError: [u'This field is required.']
+>>> f.clean(None)
+Traceback (most recent call last):
+...
+ValidationError: [u'This field is required.']
+>>> f.clean('person@example.com')
+u'person@example.com'
+>>> f.clean('foo')
+Traceback (most recent call last):
+...
+ValidationError: [u'Enter a valid e-mail address.']
+>>> f.clean('foo@')
+Traceback (most recent call last):
+...
+ValidationError: [u'Enter a valid e-mail address.']
+>>> f.clean('foo@bar')
+Traceback (most recent call last):
+...
+ValidationError: [u'Enter a valid e-mail address.']
+
+>>> f = EmailField(required=False)
+>>> f.clean('')
+u''
+>>> f.clean(None)
+u''
 >>> f.clean('person@example.com')
 u'person@example.com'
 >>> f.clean('foo')
@@ -751,9 +1179,64 @@ Traceback (most recent call last):
 ...
 ValidationError: [u'Enter a valid e-mail address.']
 
+EmailField also access min_length and max_length parameters, for convenience.
+>>> f = EmailField(min_length=10, max_length=15)
+>>> f.clean('a@foo.com')
+Traceback (most recent call last):
+...
+ValidationError: [u'Ensure this value has at least 10 characters.']
+>>> f.clean('alf@foo.com')
+u'alf@foo.com'
+>>> f.clean('alf123456788@foo.com')
+Traceback (most recent call last):
+...
+ValidationError: [u'Ensure this value has at most 15 characters.']
+
 # URLField ##################################################################
 
 >>> f = URLField()
+>>> f.clean('')
+Traceback (most recent call last):
+...
+ValidationError: [u'This field is required.']
+>>> f.clean(None)
+Traceback (most recent call last):
+...
+ValidationError: [u'This field is required.']
+>>> f.clean('http://example.com')
+u'http://example.com'
+>>> f.clean('http://www.example.com')
+u'http://www.example.com'
+>>> f.clean('foo')
+Traceback (most recent call last):
+...
+ValidationError: [u'Enter a valid URL.']
+>>> f.clean('example.com')
+Traceback (most recent call last):
+...
+ValidationError: [u'Enter a valid URL.']
+>>> f.clean('http://')
+Traceback (most recent call last):
+...
+ValidationError: [u'Enter a valid URL.']
+>>> f.clean('http://example')
+Traceback (most recent call last):
+...
+ValidationError: [u'Enter a valid URL.']
+>>> f.clean('http://example.')
+Traceback (most recent call last):
+...
+ValidationError: [u'Enter a valid URL.']
+>>> f.clean('http://.com')
+Traceback (most recent call last):
+...
+ValidationError: [u'Enter a valid URL.']
+
+>>> f = URLField(required=False)
+>>> f.clean('')
+u''
+>>> f.clean(None)
+u''
 >>> f.clean('http://example.com')
 u'http://example.com'
 >>> f.clean('http://www.example.com')
@@ -801,9 +1284,46 @@ Traceback (most recent call last):
 ...
 ValidationError: [u'This URL appears to be a broken link.']
 
+EmailField also access min_length and max_length parameters, for convenience.
+>>> f = URLField(min_length=15, max_length=20)
+>>> f.clean('http://f.com')
+Traceback (most recent call last):
+...
+ValidationError: [u'Ensure this value has at least 15 characters.']
+>>> f.clean('http://example.com')
+u'http://example.com'
+>>> f.clean('http://abcdefghijklmnopqrstuvwxyz.com')
+Traceback (most recent call last):
+...
+ValidationError: [u'Ensure this value has at most 20 characters.']
+
 # BooleanField ################################################################
 
 >>> f = BooleanField()
+>>> f.clean('')
+Traceback (most recent call last):
+...
+ValidationError: [u'This field is required.']
+>>> f.clean(None)
+Traceback (most recent call last):
+...
+ValidationError: [u'This field is required.']
+>>> f.clean(True)
+True
+>>> f.clean(False)
+False
+>>> f.clean(1)
+True
+>>> f.clean(0)
+False
+>>> f.clean('Django rocks')
+True
+
+>>> f = BooleanField(required=False)
+>>> f.clean('')
+False
+>>> f.clean(None)
+False
 >>> f.clean(True)
 True
 >>> f.clean(False)
@@ -818,18 +1338,32 @@ True
 # ChoiceField #################################################################
 
 >>> f = ChoiceField(choices=[('1', '1'), ('2', '2')])
+>>> f.clean('')
+Traceback (most recent call last):
+...
+ValidationError: [u'This field is required.']
+>>> f.clean(None)
+Traceback (most recent call last):
+...
+ValidationError: [u'This field is required.']
 >>> f.clean(1)
 u'1'
 >>> f.clean('1')
 u'1'
->>> f.clean(None)
+>>> f.clean('3')
 Traceback (most recent call last):
 ...
-ValidationError: [u'This field is required.']
+ValidationError: [u'Select a valid choice. 3 is not one of the available choices.']
+
+>>> f = ChoiceField(choices=[('1', '1'), ('2', '2')], required=False)
 >>> f.clean('')
-Traceback (most recent call last):
-...
-ValidationError: [u'This field is required.']
+u''
+>>> f.clean(None)
+u''
+>>> f.clean(1)
+u'1'
+>>> f.clean('1')
+u'1'
 >>> f.clean('3')
 Traceback (most recent call last):
 ...
@@ -846,6 +1380,14 @@ ValidationError: [u'Select a valid choice. John is not one of the available choi
 # MultipleChoiceField #########################################################
 
 >>> f = MultipleChoiceField(choices=[('1', '1'), ('2', '2')])
+>>> f.clean('')
+Traceback (most recent call last):
+...
+ValidationError: [u'This field is required.']
+>>> f.clean(None)
+Traceback (most recent call last):
+...
+ValidationError: [u'This field is required.']
 >>> f.clean([1])
 [u'1']
 >>> f.clean(['1'])
@@ -873,10 +1415,38 @@ Traceback (most recent call last):
 ...
 ValidationError: [u'Select a valid choice. 3 is not one of the available choices.']
 
+>>> f = MultipleChoiceField(choices=[('1', '1'), ('2', '2')], required=False)
+>>> f.clean('')
+[]
+>>> f.clean(None)
+[]
+>>> f.clean([1])
+[u'1']
+>>> f.clean(['1'])
+[u'1']
+>>> f.clean(['1', '2'])
+[u'1', u'2']
+>>> f.clean([1, '2'])
+[u'1', u'2']
+>>> f.clean((1, '2'))
+[u'1', u'2']
+>>> f.clean('hello')
+Traceback (most recent call last):
+...
+ValidationError: [u'Enter a list of values.']
+>>> f.clean([])
+[]
+>>> f.clean(())
+[]
+>>> f.clean(['3'])
+Traceback (most recent call last):
+...
+ValidationError: [u'Select a valid choice. 3 is not one of the available choices.']
+
 # ComboField ##################################################################
 
 ComboField takes a list of fields that should be used to validate a value,
-in that order:
+in that order.
 >>> f = ComboField(fields=[CharField(max_length=20), EmailField()])
 >>> f.clean('test@example.com')
 u'test@example.com'
@@ -897,78 +1467,149 @@ Traceback (most recent call last):
 ...
 ValidationError: [u'This field is required.']
 
+>>> f = ComboField(fields=[CharField(max_length=20), EmailField()], required=False)
+>>> f.clean('test@example.com')
+u'test@example.com'
+>>> f.clean('longemailaddress@example.com')
+Traceback (most recent call last):
+...
+ValidationError: [u'Ensure this value has at most 20 characters.']
+>>> f.clean('not an e-mail')
+Traceback (most recent call last):
+...
+ValidationError: [u'Enter a valid e-mail address.']
+>>> f.clean('')
+u''
+>>> f.clean(None)
+u''
+
+#########
+# Forms #
+#########
+
+A Form is a collection of Fields. It knows how to validate a set of data and it
+knows how to render itself in a couple of default ways (e.g., an HTML table).
+You can pass it data in __init__(), as a dictionary.
+
 # Form ########################################################################
 
 >>> class Person(Form):
 ...     first_name = CharField()
 ...     last_name = CharField()
 ...     birthday = DateField()
->>> p = Person()
->>> print p
-<tr><td>First name:</td><td><input type="text" name="first_name" /></td></tr>
-<tr><td>Last name:</td><td><input type="text" name="last_name" /></td></tr>
-<tr><td>Birthday:</td><td><input type="text" name="birthday" /></td></tr>
->>> print p.as_table()
-<tr><td>First name:</td><td><input type="text" name="first_name" /></td></tr>
-<tr><td>Last name:</td><td><input type="text" name="last_name" /></td></tr>
-<tr><td>Birthday:</td><td><input type="text" name="birthday" /></td></tr>
->>> print p.as_ul()
-<li>First name: <input type="text" name="first_name" /></li>
-<li>Last name: <input type="text" name="last_name" /></li>
-<li>Birthday: <input type="text" name="birthday" /></li>
->>> print p.as_table_with_errors()
-<tr><td colspan="2"><ul><li>This field is required.</li></ul></td></tr>
-<tr><td>First name:</td><td><input type="text" name="first_name" /></td></tr>
-<tr><td colspan="2"><ul><li>This field is required.</li></ul></td></tr>
-<tr><td>Last name:</td><td><input type="text" name="last_name" /></td></tr>
-<tr><td colspan="2"><ul><li>This field is required.</li></ul></td></tr>
-<tr><td>Birthday:</td><td><input type="text" name="birthday" /></td></tr>
->>> print p.as_ul_with_errors()
-<li><ul><li>This field is required.</li></ul>First name: <input type="text" name="first_name" /></li>
-<li><ul><li>This field is required.</li></ul>Last name: <input type="text" name="last_name" /></li>
-<li><ul><li>This field is required.</li></ul>Birthday: <input type="text" name="birthday" /></li>
 
+Pass a dictionary to a Form's __init__().
 >>> p = Person({'first_name': u'John', 'last_name': u'Lennon', 'birthday': u'1940-10-9'})
->>> p.errors()
+>>> p.errors
 {}
 >>> p.is_valid()
 True
->>> p.errors().as_ul()
+>>> p.errors.as_ul()
 u''
->>> p.errors().as_text()
+>>> p.errors.as_text()
 u''
->>> p.clean()
+>>> p.clean_data
 {'first_name': u'John', 'last_name': u'Lennon', 'birthday': datetime.date(1940, 10, 9)}
 >>> print p['first_name']
-<input type="text" name="first_name" value="John" />
+<input type="text" name="first_name" value="John" id="id_first_name" />
 >>> print p['last_name']
-<input type="text" name="last_name" value="Lennon" />
+<input type="text" name="last_name" value="Lennon" id="id_last_name" />
 >>> print p['birthday']
-<input type="text" name="birthday" value="1940-10-9" />
+<input type="text" name="birthday" value="1940-10-9" id="id_birthday" />
+>>> print p['nonexistentfield']
+Traceback (most recent call last):
+...
+KeyError: "Key 'nonexistentfield' not found in Form"
+
 >>> for boundfield in p:
 ...     print boundfield
-<input type="text" name="first_name" value="John" />
-<input type="text" name="last_name" value="Lennon" />
-<input type="text" name="birthday" value="1940-10-9" />
+<input type="text" name="first_name" value="John" id="id_first_name" />
+<input type="text" name="last_name" value="Lennon" id="id_last_name" />
+<input type="text" name="birthday" value="1940-10-9" id="id_birthday" />
+>>> for boundfield in p:
+...     print boundfield.label, boundfield.data
+First name John
+Last name Lennon
+Birthday 1940-10-9
+>>> print p
+<tr><th><label for="id_first_name">First name:</label></th><td><input type="text" name="first_name" value="John" id="id_first_name" /></td></tr>
+<tr><th><label for="id_last_name">Last name:</label></th><td><input type="text" name="last_name" value="Lennon" id="id_last_name" /></td></tr>
+<tr><th><label for="id_birthday">Birthday:</label></th><td><input type="text" name="birthday" value="1940-10-9" id="id_birthday" /></td></tr>
+
+Empty dictionaries are valid, too.
+>>> p = Person({})
+>>> p.errors
+{'first_name': [u'This field is required.'], 'last_name': [u'This field is required.'], 'birthday': [u'This field is required.']}
+>>> p.is_valid()
+False
+>>> print p
+<tr><th><label for="id_first_name">First name:</label></th><td><ul class="errorlist"><li>This field is required.</li></ul><input type="text" name="first_name" id="id_first_name" /></td></tr>
+<tr><th><label for="id_last_name">Last name:</label></th><td><ul class="errorlist"><li>This field is required.</li></ul><input type="text" name="last_name" id="id_last_name" /></td></tr>
+<tr><th><label for="id_birthday">Birthday:</label></th><td><ul class="errorlist"><li>This field is required.</li></ul><input type="text" name="birthday" id="id_birthday" /></td></tr>
+>>> print p.as_table()
+<tr><th><label for="id_first_name">First name:</label></th><td><ul class="errorlist"><li>This field is required.</li></ul><input type="text" name="first_name" id="id_first_name" /></td></tr>
+<tr><th><label for="id_last_name">Last name:</label></th><td><ul class="errorlist"><li>This field is required.</li></ul><input type="text" name="last_name" id="id_last_name" /></td></tr>
+<tr><th><label for="id_birthday">Birthday:</label></th><td><ul class="errorlist"><li>This field is required.</li></ul><input type="text" name="birthday" id="id_birthday" /></td></tr>
+>>> print p.as_ul()
+<li><ul class="errorlist"><li>This field is required.</li></ul><label for="id_first_name">First name:</label> <input type="text" name="first_name" id="id_first_name" /></li>
+<li><ul class="errorlist"><li>This field is required.</li></ul><label for="id_last_name">Last name:</label> <input type="text" name="last_name" id="id_last_name" /></li>
+<li><ul class="errorlist"><li>This field is required.</li></ul><label for="id_birthday">Birthday:</label> <input type="text" name="birthday" id="id_birthday" /></li>
+>>> print p.as_p()
+<p><ul class="errorlist"><li>This field is required.</li></ul></p>
+<p><label for="id_first_name">First name:</label> <input type="text" name="first_name" id="id_first_name" /></p>
+<p><ul class="errorlist"><li>This field is required.</li></ul></p>
+<p><label for="id_last_name">Last name:</label> <input type="text" name="last_name" id="id_last_name" /></p>
+<p><ul class="errorlist"><li>This field is required.</li></ul></p>
+<p><label for="id_birthday">Birthday:</label> <input type="text" name="birthday" id="id_birthday" /></p>
+
+If you don't pass any values to the Form's __init__(), or if you pass None,
+the Form won't do any validation. Form.errors will be an empty dictionary *but*
+Form.is_valid() will return False.
+>>> p = Person()
+>>> p.errors
+{}
+>>> p.is_valid()
+False
 >>> print p
-<tr><td>First name:</td><td><input type="text" name="first_name" value="John" /></td></tr>
-<tr><td>Last name:</td><td><input type="text" name="last_name" value="Lennon" /></td></tr>
-<tr><td>Birthday:</td><td><input type="text" name="birthday" value="1940-10-9" /></td></tr>
+<tr><th><label for="id_first_name">First name:</label></th><td><input type="text" name="first_name" id="id_first_name" /></td></tr>
+<tr><th><label for="id_last_name">Last name:</label></th><td><input type="text" name="last_name" id="id_last_name" /></td></tr>
+<tr><th><label for="id_birthday">Birthday:</label></th><td><input type="text" name="birthday" id="id_birthday" /></td></tr>
+>>> print p.as_table()
+<tr><th><label for="id_first_name">First name:</label></th><td><input type="text" name="first_name" id="id_first_name" /></td></tr>
+<tr><th><label for="id_last_name">Last name:</label></th><td><input type="text" name="last_name" id="id_last_name" /></td></tr>
+<tr><th><label for="id_birthday">Birthday:</label></th><td><input type="text" name="birthday" id="id_birthday" /></td></tr>
+>>> print p.as_ul()
+<li><label for="id_first_name">First name:</label> <input type="text" name="first_name" id="id_first_name" /></li>
+<li><label for="id_last_name">Last name:</label> <input type="text" name="last_name" id="id_last_name" /></li>
+<li><label for="id_birthday">Birthday:</label> <input type="text" name="birthday" id="id_birthday" /></li>
+>>> print p.as_p()
+<p><label for="id_first_name">First name:</label> <input type="text" name="first_name" id="id_first_name" /></p>
+<p><label for="id_last_name">Last name:</label> <input type="text" name="last_name" id="id_last_name" /></p>
+<p><label for="id_birthday">Birthday:</label> <input type="text" name="birthday" id="id_birthday" /></p>
+
+Unicode values are handled properly.
+>>> p = Person({'first_name': u'John', 'last_name': u'\u0160\u0110\u0106\u017d\u0107\u017e\u0161\u0111', 'birthday': '1940-10-9'})
+>>> p.as_table()
+u'<tr><th><label for="id_first_name">First name:</label></th><td><input type="text" name="first_name" value="John" id="id_first_name" /></td></tr>\n<tr><th><label for="id_last_name">Last name:</label></th><td><input type="text" name="last_name" value="\u0160\u0110\u0106\u017d\u0107\u017e\u0161\u0111" id="id_last_name" /></td></tr>\n<tr><th><label for="id_birthday">Birthday:</label></th><td><input type="text" name="birthday" value="1940-10-9" id="id_birthday" /></td></tr>'
+>>> p.as_ul()
+u'<li><label for="id_first_name">First name:</label> <input type="text" name="first_name" value="John" id="id_first_name" /></li>\n<li><label for="id_last_name">Last name:</label> <input type="text" name="last_name" value="\u0160\u0110\u0106\u017d\u0107\u017e\u0161\u0111" id="id_last_name" /></li>\n<li><label for="id_birthday">Birthday:</label> <input type="text" name="birthday" value="1940-10-9" id="id_birthday" /></li>'
+>>> p.as_p()
+u'<p><label for="id_first_name">First name:</label> <input type="text" name="first_name" value="John" id="id_first_name" /></p>\n<p><label for="id_last_name">Last name:</label> <input type="text" name="last_name" value="\u0160\u0110\u0106\u017d\u0107\u017e\u0161\u0111" id="id_last_name" /></p>\n<p><label for="id_birthday">Birthday:</label> <input type="text" name="birthday" value="1940-10-9" id="id_birthday" /></p>'
 
 >>> p = Person({'last_name': u'Lennon'})
->>> p.errors()
+>>> p.errors
 {'first_name': [u'This field is required.'], 'birthday': [u'This field is required.']}
 >>> p.is_valid()
 False
->>> p.errors().as_ul()
+>>> p.errors.as_ul()
 u'<ul class="errorlist"><li>first_name<ul class="errorlist"><li>This field is required.</li></ul></li><li>birthday<ul class="errorlist"><li>This field is required.</li></ul></li></ul>'
->>> print p.errors().as_text()
+>>> print p.errors.as_text()
 * first_name
   * This field is required.
 * birthday
   * This field is required.
->>> p.clean()
->>> repr(p.clean())
+>>> p.clean_data
+>>> repr(p.clean_data)
 'None'
 >>> p['first_name'].errors
 [u'This field is required.']
@@ -979,28 +1620,37 @@ u'* This field is required.'
 
 >>> p = Person()
 >>> print p['first_name']
-<input type="text" name="first_name" />
+<input type="text" name="first_name" id="id_first_name" />
 >>> print p['last_name']
-<input type="text" name="last_name" />
+<input type="text" name="last_name" id="id_last_name" />
 >>> print p['birthday']
-<input type="text" name="birthday" />
+<input type="text" name="birthday" id="id_birthday" />
 
 "auto_id" tells the Form to add an "id" attribute to each form element.
 If it's a string that contains '%s', Django will use that as a format string
-into which the field's name will be inserted.
->>> p = Person(auto_id='id_%s')
+into which the field's name will be inserted. It will also put a <label> around
+the human-readable labels for a field.
+>>> p = Person(auto_id='%s_id')
+>>> print p.as_table()
+<tr><th><label for="first_name_id">First name:</label></th><td><input type="text" name="first_name" id="first_name_id" /></td></tr>
+<tr><th><label for="last_name_id">Last name:</label></th><td><input type="text" name="last_name" id="last_name_id" /></td></tr>
+<tr><th><label for="birthday_id">Birthday:</label></th><td><input type="text" name="birthday" id="birthday_id" /></td></tr>
 >>> print p.as_ul()
-<li>First name: <input type="text" name="first_name" id="id_first_name" /></li>
-<li>Last name: <input type="text" name="last_name" id="id_last_name" /></li>
-<li>Birthday: <input type="text" name="birthday" id="id_birthday" /></li>
+<li><label for="first_name_id">First name:</label> <input type="text" name="first_name" id="first_name_id" /></li>
+<li><label for="last_name_id">Last name:</label> <input type="text" name="last_name" id="last_name_id" /></li>
+<li><label for="birthday_id">Birthday:</label> <input type="text" name="birthday" id="birthday_id" /></li>
+>>> print p.as_p()
+<p><label for="first_name_id">First name:</label> <input type="text" name="first_name" id="first_name_id" /></p>
+<p><label for="last_name_id">Last name:</label> <input type="text" name="last_name" id="last_name_id" /></p>
+<p><label for="birthday_id">Birthday:</label> <input type="text" name="birthday" id="birthday_id" /></p>
 
 If auto_id is any True value whose str() does not contain '%s', the "id"
 attribute will be the name of the field.
 >>> p = Person(auto_id=True)
 >>> print p.as_ul()
-<li>First name: <input type="text" name="first_name" id="first_name" /></li>
-<li>Last name: <input type="text" name="last_name" id="last_name" /></li>
-<li>Birthday: <input type="text" name="birthday" id="birthday" /></li>
+<li><label for="first_name">First name:</label> <input type="text" name="first_name" id="first_name" /></li>
+<li><label for="last_name">Last name:</label> <input type="text" name="last_name" id="last_name" /></li>
+<li><label for="birthday">Birthday:</label> <input type="text" name="birthday" id="birthday" /></li>
 
 If auto_id is any False value, an "id" attribute won't be output unless it
 was manually entered.
@@ -1011,14 +1661,14 @@ was manually entered.
 <li>Birthday: <input type="text" name="birthday" /></li>
 
 In this example, auto_id is False, but the "id" attribute for the "first_name"
-field is given.
+field is given. Also note that field gets a <label>, while the others don't.
 >>> class PersonNew(Form):
 ...     first_name = CharField(widget=TextInput(attrs={'id': 'first_name_id'}))
 ...     last_name = CharField()
 ...     birthday = DateField()
 >>> p = PersonNew(auto_id=False)
 >>> print p.as_ul()
-<li>First name: <input type="text" id="first_name_id" name="first_name" /></li>
+<li><label for="first_name_id">First name:</label> <input type="text" id="first_name_id" name="first_name" /></li>
 <li>Last name: <input type="text" name="last_name" /></li>
 <li>Birthday: <input type="text" name="birthday" /></li>
 
@@ -1026,20 +1676,20 @@ If the "id" attribute is specified in the Form and auto_id is True, the "id"
 attribute in the Form gets precedence.
 >>> p = PersonNew(auto_id=True)
 >>> print p.as_ul()
-<li>First name: <input type="text" id="first_name_id" name="first_name" /></li>
-<li>Last name: <input type="text" name="last_name" id="last_name" /></li>
-<li>Birthday: <input type="text" name="birthday" id="birthday" /></li>
+<li><label for="first_name_id">First name:</label> <input type="text" id="first_name_id" name="first_name" /></li>
+<li><label for="last_name">Last name:</label> <input type="text" name="last_name" id="last_name" /></li>
+<li><label for="birthday">Birthday:</label> <input type="text" name="birthday" id="birthday" /></li>
 
 >>> class SignupForm(Form):
 ...     email = EmailField()
 ...     get_spam = BooleanField()
->>> f = SignupForm()
+>>> f = SignupForm(auto_id=False)
 >>> print f['email']
 <input type="text" name="email" />
 >>> print f['get_spam']
 <input type="checkbox" name="get_spam" />
 
->>> f = SignupForm({'email': 'test@example.com', 'get_spam': True})
+>>> f = SignupForm({'email': 'test@example.com', 'get_spam': True}, auto_id=False)
 >>> print f['email']
 <input type="text" name="email" value="test@example.com" />
 >>> print f['get_spam']
@@ -1049,70 +1699,131 @@ Any Field can have a Widget class passed to its constructor:
 >>> class ContactForm(Form):
 ...     subject = CharField()
 ...     message = CharField(widget=Textarea)
->>> f = ContactForm()
+>>> f = ContactForm(auto_id=False)
 >>> print f['subject']
 <input type="text" name="subject" />
 >>> print f['message']
 <textarea name="message"></textarea>
 
-as_textarea() and as_text() are shortcuts for changing the output widget type:
+as_textarea(), as_text() and as_hidden() are shortcuts for changing the output
+widget type:
 >>> f['subject'].as_textarea()
 u'<textarea name="subject"></textarea>'
 >>> f['message'].as_text()
 u'<input type="text" name="message" />'
+>>> f['message'].as_hidden()
+u'<input type="hidden" name="message" />'
 
 The 'widget' parameter to a Field can also be an instance:
 >>> class ContactForm(Form):
 ...     subject = CharField()
 ...     message = CharField(widget=Textarea(attrs={'rows': 80, 'cols': 20}))
->>> f = ContactForm()
+>>> f = ContactForm(auto_id=False)
 >>> print f['message']
 <textarea rows="80" cols="20" name="message"></textarea>
 
-Instance-level attrs are *not* carried over to as_textarea() and as_text():
+Instance-level attrs are *not* carried over to as_textarea(), as_text() and
+as_hidden():
 >>> f['message'].as_text()
 u'<input type="text" name="message" />'
->>> f = ContactForm({'subject': 'Hello', 'message': 'I love you.'})
+>>> f = ContactForm({'subject': 'Hello', 'message': 'I love you.'}, auto_id=False)
 >>> f['subject'].as_textarea()
 u'<textarea name="subject">Hello</textarea>'
 >>> f['message'].as_text()
 u'<input type="text" name="message" value="I love you." />'
+>>> f['message'].as_hidden()
+u'<input type="hidden" name="message" value="I love you." />'
 
 For a form with a <select>, use ChoiceField:
 >>> class FrameworkForm(Form):
 ...     name = CharField()
 ...     language = ChoiceField(choices=[('P', 'Python'), ('J', 'Java')])
->>> f = FrameworkForm()
+>>> f = FrameworkForm(auto_id=False)
 >>> print f['language']
 <select name="language">
 <option value="P">Python</option>
 <option value="J">Java</option>
 </select>
->>> f = FrameworkForm({'name': 'Django', 'language': 'P'})
+>>> f = FrameworkForm({'name': 'Django', 'language': 'P'}, auto_id=False)
 >>> print f['language']
 <select name="language">
 <option value="P" selected="selected">Python</option>
 <option value="J">Java</option>
 </select>
 
+Add widget=RadioSelect to use that widget with a ChoiceField.
+>>> class FrameworkForm(Form):
+...     name = CharField()
+...     language = ChoiceField(choices=[('P', 'Python'), ('J', 'Java')], widget=RadioSelect)
+>>> f = FrameworkForm(auto_id=False)
+>>> print f['language']
+<ul>
+<li><label><input type="radio" name="language" value="P" /> Python</label></li>
+<li><label><input type="radio" name="language" value="J" /> Java</label></li>
+</ul>
+>>> print f
+<tr><th>Name:</th><td><input type="text" name="name" /></td></tr>
+<tr><th>Language:</th><td><ul>
+<li><label><input type="radio" name="language" value="P" /> Python</label></li>
+<li><label><input type="radio" name="language" value="J" /> Java</label></li>
+</ul></td></tr>
+>>> print f.as_ul()
+<li>Name: <input type="text" name="name" /></li>
+<li>Language: <ul>
+<li><label><input type="radio" name="language" value="P" /> Python</label></li>
+<li><label><input type="radio" name="language" value="J" /> Java</label></li>
+</ul></li>
+
+Regarding auto_id and <label>, RadioSelect is a special case. Each radio button
+gets a distinct ID, formed by appending an underscore plus the button's
+zero-based index.
+>>> f = FrameworkForm(auto_id='id_%s')
+>>> print f['language']
+<ul>
+<li><label><input type="radio" id="id_language_0" value="P" name="language" /> Python</label></li>
+<li><label><input type="radio" id="id_language_1" value="J" name="language" /> Java</label></li>
+</ul>
+
+When RadioSelect is used with auto_id, and the whole form is printed using
+either as_table() or as_ul(), the label for the RadioSelect will point to the
+ID of the *first* radio button.
+>>> print f
+<tr><th><label for="id_name">Name:</label></th><td><input type="text" name="name" id="id_name" /></td></tr>
+<tr><th><label for="id_language_0">Language:</label></th><td><ul>
+<li><label><input type="radio" id="id_language_0" value="P" name="language" /> Python</label></li>
+<li><label><input type="radio" id="id_language_1" value="J" name="language" /> Java</label></li>
+</ul></td></tr>
+>>> print f.as_ul()
+<li><label for="id_name">Name:</label> <input type="text" name="name" id="id_name" /></li>
+<li><label for="id_language_0">Language:</label> <ul>
+<li><label><input type="radio" id="id_language_0" value="P" name="language" /> Python</label></li>
+<li><label><input type="radio" id="id_language_1" value="J" name="language" /> Java</label></li>
+</ul></li>
+>>> print f.as_p()
+<p><label for="id_name">Name:</label> <input type="text" name="name" id="id_name" /></p>
+<p><label for="id_language_0">Language:</label> <ul>
+<li><label><input type="radio" id="id_language_0" value="P" name="language" /> Python</label></li>
+<li><label><input type="radio" id="id_language_1" value="J" name="language" /> Java</label></li>
+</ul></p>
+
 MultipleChoiceField is a special case, as its data is required to be a list:
 >>> class SongForm(Form):
 ...     name = CharField()
 ...     composers = MultipleChoiceField()
->>> f = SongForm()
+>>> f = SongForm(auto_id=False)
 >>> print f['composers']
 <select multiple="multiple" name="composers">
 </select>
 >>> class SongForm(Form):
 ...     name = CharField()
 ...     composers = MultipleChoiceField(choices=[('J', 'John Lennon'), ('P', 'Paul McCartney')])
->>> f = SongForm()
+>>> f = SongForm(auto_id=False)
 >>> print f['composers']
 <select multiple="multiple" name="composers">
 <option value="J">John Lennon</option>
 <option value="P">Paul McCartney</option>
 </select>
->>> f = SongForm({'name': 'Yesterday', 'composers': ['P']})
+>>> f = SongForm({'name': 'Yesterday', 'composers': ['P']}, auto_id=False)
 >>> print f['name']
 <input type="text" name="name" value="Yesterday" />
 >>> print f['composers']
@@ -1121,10 +1832,69 @@ MultipleChoiceField is a special case, as its data is required to be a list:
 <option value="P" selected="selected">Paul McCartney</option>
 </select>
 
+MultipleChoiceField can also be used with the CheckboxSelectMultiple widget.
+>>> class SongForm(Form):
+...     name = CharField()
+...     composers = MultipleChoiceField(choices=[('J', 'John Lennon'), ('P', 'Paul McCartney')], widget=CheckboxSelectMultiple)
+>>> f = SongForm(auto_id=False)
+>>> print f['composers']
+<ul>
+<li><label><input type="checkbox" name="composers" value="J" /> John Lennon</label></li>
+<li><label><input type="checkbox" name="composers" value="P" /> Paul McCartney</label></li>
+</ul>
+>>> f = SongForm({'composers': ['J']}, auto_id=False)
+>>> print f['composers']
+<ul>
+<li><label><input checked="checked" type="checkbox" name="composers" value="J" /> John Lennon</label></li>
+<li><label><input type="checkbox" name="composers" value="P" /> Paul McCartney</label></li>
+</ul>
+>>> f = SongForm({'composers': ['J', 'P']}, auto_id=False)
+>>> print f['composers']
+<ul>
+<li><label><input checked="checked" type="checkbox" name="composers" value="J" /> John Lennon</label></li>
+<li><label><input checked="checked" type="checkbox" name="composers" value="P" /> Paul McCartney</label></li>
+</ul>
+
+Data for a MultipleChoiceField should be a list. QueryDict and MultiValueDict
+conveniently work with this.
+>>> data = {'name': 'Yesterday', 'composers': ['J', 'P']}
+>>> f = SongForm(data)
+>>> f.errors
+{}
+>>> from django.http import QueryDict
+>>> data = QueryDict('name=Yesterday&composers=J&composers=P')
+>>> f = SongForm(data)
+>>> f.errors
+{}
+>>> from django.utils.datastructures import MultiValueDict
+>>> data = MultiValueDict(dict(name='Yesterday', composers=['J', 'P']))
+>>> f = SongForm(data)
+>>> f.errors
+{}
+
+When using CheckboxSelectMultiple, the framework expects a list of input and
+returns a list of input.
+>>> f = SongForm({'name': 'Yesterday'}, auto_id=False)
+>>> f.errors
+{'composers': [u'This field is required.']}
+>>> f = SongForm({'name': 'Yesterday', 'composers': ['J']}, auto_id=False)
+>>> f.errors
+{}
+>>> f.clean_data
+{'composers': [u'J'], 'name': u'Yesterday'}
+>>> f = SongForm({'name': 'Yesterday', 'composers': ['J', 'P']}, auto_id=False)
+>>> f.errors
+{}
+>>> f.clean_data
+{'composers': [u'J', u'P'], 'name': u'Yesterday'}
+
 There are a couple of ways to do multiple-field validation. If you want the
 validation message to be associated with a particular field, implement the
 clean_XXX() method on the Form, where XXX is the field name. As in
-Field.clean(), the clean_XXX() method should return the cleaned value:
+Field.clean(), the clean_XXX() method should return the cleaned value. In the
+clean_XXX() method, you have access to self.clean_data, which is a dictionary
+of all the data that has been cleaned *so far*, in order by the fields,
+including the current field (e.g., the field XXX if you're in clean_XXX()).
 >>> class UserRegistration(Form):
 ...    username = CharField(max_length=10)
 ...    password1 = CharField(widget=PasswordInput)
@@ -1133,23 +1903,28 @@ Field.clean(), the clean_XXX() method should return the cleaned value:
 ...        if self.clean_data.get('password1') and self.clean_data.get('password2') and self.clean_data['password1'] != self.clean_data['password2']:
 ...            raise ValidationError(u'Please make sure your passwords match.')
 ...        return self.clean_data['password2']
->>> f = UserRegistration()
->>> f.errors()
+>>> f = UserRegistration(auto_id=False)
+>>> f.errors
+{}
+>>> f = UserRegistration({}, auto_id=False)
+>>> f.errors
 {'username': [u'This field is required.'], 'password1': [u'This field is required.'], 'password2': [u'This field is required.']}
->>> f = UserRegistration({'username': 'adrian', 'password1': 'foo', 'password2': 'bar'})
->>> f.errors()
+>>> f = UserRegistration({'username': 'adrian', 'password1': 'foo', 'password2': 'bar'}, auto_id=False)
+>>> f.errors
 {'password2': [u'Please make sure your passwords match.']}
->>> f = UserRegistration({'username': 'adrian', 'password1': 'foo', 'password2': 'foo'})
->>> f.errors()
+>>> f = UserRegistration({'username': 'adrian', 'password1': 'foo', 'password2': 'foo'}, auto_id=False)
+>>> f.errors
 {}
->>> f.clean()
+>>> f.clean_data
 {'username': u'adrian', 'password1': u'foo', 'password2': u'foo'}
 
 Another way of doing multiple-field validation is by implementing the
 Form's clean() method. If you do this, any ValidationError raised by that
 method will not be associated with a particular field; it will have a
-special-case association with the field named '__all__'. Note that
-Form.clean() still needs to return a dictionary of all clean data:
+special-case association with the field named '__all__'.
+Note that in Form.clean(), you have access to self.clean_data, a dictionary of
+all the fields/values that have *not* raised a ValidationError. Also note
+Form.clean() is required to return a dictionary of all clean data.
 >>> class UserRegistration(Form):
 ...    username = CharField(max_length=10)
 ...    password1 = CharField(widget=PasswordInput)
@@ -1158,34 +1933,33 @@ Form.clean() still needs to return a dictionary of all clean data:
 ...        if self.clean_data.get('password1') and self.clean_data.get('password2') and self.clean_data['password1'] != self.clean_data['password2']:
 ...            raise ValidationError(u'Please make sure your passwords match.')
 ...        return self.clean_data
->>> f = UserRegistration()
+>>> f = UserRegistration(auto_id=False)
+>>> f.errors
+{}
+>>> f = UserRegistration({}, auto_id=False)
 >>> print f.as_table()
-<tr><td>Username:</td><td><input type="text" name="username" /></td></tr>
-<tr><td>Password1:</td><td><input type="password" name="password1" /></td></tr>
-<tr><td>Password2:</td><td><input type="password" name="password2" /></td></tr>
->>> f.errors()
+<tr><th>Username:</th><td><ul class="errorlist"><li>This field is required.</li></ul><input type="text" name="username" maxlength="10" /></td></tr>
+<tr><th>Password1:</th><td><ul class="errorlist"><li>This field is required.</li></ul><input type="password" name="password1" /></td></tr>
+<tr><th>Password2:</th><td><ul class="errorlist"><li>This field is required.</li></ul><input type="password" name="password2" /></td></tr>
+>>> f.errors
 {'username': [u'This field is required.'], 'password1': [u'This field is required.'], 'password2': [u'This field is required.']}
->>> f = UserRegistration({'username': 'adrian', 'password1': 'foo', 'password2': 'bar'})
->>> f.errors()
+>>> f = UserRegistration({'username': 'adrian', 'password1': 'foo', 'password2': 'bar'}, auto_id=False)
+>>> f.errors
 {'__all__': [u'Please make sure your passwords match.']}
 >>> print f.as_table()
-<tr><td>Username:</td><td><input type="text" name="username" value="adrian" /></td></tr>
-<tr><td>Password1:</td><td><input type="password" name="password1" value="foo" /></td></tr>
-<tr><td>Password2:</td><td><input type="password" name="password2" value="bar" /></td></tr>
->>> print f.as_table_with_errors()
-<tr><td colspan="2"><ul><li>Please make sure your passwords match.</li></ul></td></tr>
-<tr><td>Username:</td><td><input type="text" name="username" value="adrian" /></td></tr>
-<tr><td>Password1:</td><td><input type="password" name="password1" value="foo" /></td></tr>
-<tr><td>Password2:</td><td><input type="password" name="password2" value="bar" /></td></tr>
->>> print f.as_ul_with_errors()
-<li><ul><li>Please make sure your passwords match.</li></ul></li>
-<li>Username: <input type="text" name="username" value="adrian" /></li>
+<tr><td colspan="2"><ul class="errorlist"><li>Please make sure your passwords match.</li></ul></td></tr>
+<tr><th>Username:</th><td><input type="text" name="username" value="adrian" maxlength="10" /></td></tr>
+<tr><th>Password1:</th><td><input type="password" name="password1" value="foo" /></td></tr>
+<tr><th>Password2:</th><td><input type="password" name="password2" value="bar" /></td></tr>
+>>> print f.as_ul()
+<li><ul class="errorlist"><li>Please make sure your passwords match.</li></ul></li>
+<li>Username: <input type="text" name="username" value="adrian" maxlength="10" /></li>
 <li>Password1: <input type="password" name="password1" value="foo" /></li>
 <li>Password2: <input type="password" name="password2" value="bar" /></li>
->>> f = UserRegistration({'username': 'adrian', 'password1': 'foo', 'password2': 'foo'})
->>> f.errors()
+>>> f = UserRegistration({'username': 'adrian', 'password1': 'foo', 'password2': 'foo'}, auto_id=False)
+>>> f.errors
 {}
->>> f.clean()
+>>> f.clean_data
 {'username': u'adrian', 'password1': u'foo', 'password2': u'foo'}
 
 It's possible to construct a Form dynamically by adding to the self.fields
@@ -1194,14 +1968,85 @@ subclass' __init__().
 >>> class Person(Form):
 ...     first_name = CharField()
 ...     last_name = CharField()
-...     def __init__(self):
-...         super(Person, self).__init__()
+...     def __init__(self, *args, **kwargs):
+...         super(Person, self).__init__(*args, **kwargs)
 ...         self.fields['birthday'] = DateField()
->>> p = Person()
+>>> p = Person(auto_id=False)
+>>> print p
+<tr><th>First name:</th><td><input type="text" name="first_name" /></td></tr>
+<tr><th>Last name:</th><td><input type="text" name="last_name" /></td></tr>
+<tr><th>Birthday:</th><td><input type="text" name="birthday" /></td></tr>
+
+HiddenInput widgets are displayed differently in the as_table(), as_ul()
+and as_p() output of a Form -- their verbose names are not displayed, and a
+separate row is not displayed. They're displayed in the last row of the
+form, directly after that row's form element.
+>>> class Person(Form):
+...     first_name = CharField()
+...     last_name = CharField()
+...     hidden_text = CharField(widget=HiddenInput)
+...     birthday = DateField()
+>>> p = Person(auto_id=False)
 >>> print p
-<tr><td>First name:</td><td><input type="text" name="first_name" /></td></tr>
-<tr><td>Last name:</td><td><input type="text" name="last_name" /></td></tr>
-<tr><td>Birthday:</td><td><input type="text" name="birthday" /></td></tr>
+<tr><th>First name:</th><td><input type="text" name="first_name" /></td></tr>
+<tr><th>Last name:</th><td><input type="text" name="last_name" /></td></tr>
+<tr><th>Birthday:</th><td><input type="text" name="birthday" /><input type="hidden" name="hidden_text" /></td></tr>
+>>> print p.as_ul()
+<li>First name: <input type="text" name="first_name" /></li>
+<li>Last name: <input type="text" name="last_name" /></li>
+<li>Birthday: <input type="text" name="birthday" /><input type="hidden" name="hidden_text" /></li>
+>>> print p.as_p()
+<p>First name: <input type="text" name="first_name" /></p>
+<p>Last name: <input type="text" name="last_name" /></p>
+<p>Birthday: <input type="text" name="birthday" /><input type="hidden" name="hidden_text" /></p>
+
+With auto_id set, a HiddenInput still gets an ID, but it doesn't get a label.
+>>> p = Person(auto_id='id_%s')
+>>> print p
+<tr><th><label for="id_first_name">First name:</label></th><td><input type="text" name="first_name" id="id_first_name" /></td></tr>
+<tr><th><label for="id_last_name">Last name:</label></th><td><input type="text" name="last_name" id="id_last_name" /></td></tr>
+<tr><th><label for="id_birthday">Birthday:</label></th><td><input type="text" name="birthday" id="id_birthday" /><input type="hidden" name="hidden_text" id="id_hidden_text" /></td></tr>
+>>> print p.as_ul()
+<li><label for="id_first_name">First name:</label> <input type="text" name="first_name" id="id_first_name" /></li>
+<li><label for="id_last_name">Last name:</label> <input type="text" name="last_name" id="id_last_name" /></li>
+<li><label for="id_birthday">Birthday:</label> <input type="text" name="birthday" id="id_birthday" /><input type="hidden" name="hidden_text" id="id_hidden_text" /></li>
+>>> print p.as_p()
+<p><label for="id_first_name">First name:</label> <input type="text" name="first_name" id="id_first_name" /></p>
+<p><label for="id_last_name">Last name:</label> <input type="text" name="last_name" id="id_last_name" /></p>
+<p><label for="id_birthday">Birthday:</label> <input type="text" name="birthday" id="id_birthday" /><input type="hidden" name="hidden_text" id="id_hidden_text" /></p>
+
+If a field with a HiddenInput has errors, the as_table() and as_ul() output
+will include the error message(s) with the text "(Hidden field [fieldname]) "
+prepended. This message is displayed at the top of the output, regardless of
+its field's order in the form.
+>>> p = Person({'first_name': 'John', 'last_name': 'Lennon', 'birthday': '1940-10-9'}, auto_id=False)
+>>> print p
+<tr><td colspan="2"><ul class="errorlist"><li>(Hidden field hidden_text) This field is required.</li></ul></td></tr>
+<tr><th>First name:</th><td><input type="text" name="first_name" value="John" /></td></tr>
+<tr><th>Last name:</th><td><input type="text" name="last_name" value="Lennon" /></td></tr>
+<tr><th>Birthday:</th><td><input type="text" name="birthday" value="1940-10-9" /><input type="hidden" name="hidden_text" /></td></tr>
+>>> print p.as_ul()
+<li><ul class="errorlist"><li>(Hidden field hidden_text) This field is required.</li></ul></li>
+<li>First name: <input type="text" name="first_name" value="John" /></li>
+<li>Last name: <input type="text" name="last_name" value="Lennon" /></li>
+<li>Birthday: <input type="text" name="birthday" value="1940-10-9" /><input type="hidden" name="hidden_text" /></li>
+>>> print p.as_p()
+<p><ul class="errorlist"><li>(Hidden field hidden_text) This field is required.</li></ul></p>
+<p>First name: <input type="text" name="first_name" value="John" /></p>
+<p>Last name: <input type="text" name="last_name" value="Lennon" /></p>
+<p>Birthday: <input type="text" name="birthday" value="1940-10-9" /><input type="hidden" name="hidden_text" /></p>
+
+A corner case: It's possible for a form to have only HiddenInputs.
+>>> class TestForm(Form):
+...     foo = CharField(widget=HiddenInput)
+...     bar = CharField(widget=HiddenInput)
+>>> p = TestForm(auto_id=False)
+>>> print p.as_table()
+<input type="hidden" name="foo" /><input type="hidden" name="bar" />
+>>> print p.as_ul()
+<input type="hidden" name="foo" /><input type="hidden" name="bar" />
+>>> print p.as_p()
+<input type="hidden" name="foo" /><input type="hidden" name="bar" />
 
 A Form's fields are displayed in the same order in which they were defined.
 >>> class TestForm(Form):
@@ -1219,22 +2064,504 @@ A Form's fields are displayed in the same order in which they were defined.
 ...     field12 = CharField()
 ...     field13 = CharField()
 ...     field14 = CharField()
->>> p = TestForm()
+>>> p = TestForm(auto_id=False)
 >>> print p
-<tr><td>Field1:</td><td><input type="text" name="field1" /></td></tr>
-<tr><td>Field2:</td><td><input type="text" name="field2" /></td></tr>
-<tr><td>Field3:</td><td><input type="text" name="field3" /></td></tr>
-<tr><td>Field4:</td><td><input type="text" name="field4" /></td></tr>
-<tr><td>Field5:</td><td><input type="text" name="field5" /></td></tr>
-<tr><td>Field6:</td><td><input type="text" name="field6" /></td></tr>
-<tr><td>Field7:</td><td><input type="text" name="field7" /></td></tr>
-<tr><td>Field8:</td><td><input type="text" name="field8" /></td></tr>
-<tr><td>Field9:</td><td><input type="text" name="field9" /></td></tr>
-<tr><td>Field10:</td><td><input type="text" name="field10" /></td></tr>
-<tr><td>Field11:</td><td><input type="text" name="field11" /></td></tr>
-<tr><td>Field12:</td><td><input type="text" name="field12" /></td></tr>
-<tr><td>Field13:</td><td><input type="text" name="field13" /></td></tr>
-<tr><td>Field14:</td><td><input type="text" name="field14" /></td></tr>
+<tr><th>Field1:</th><td><input type="text" name="field1" /></td></tr>
+<tr><th>Field2:</th><td><input type="text" name="field2" /></td></tr>
+<tr><th>Field3:</th><td><input type="text" name="field3" /></td></tr>
+<tr><th>Field4:</th><td><input type="text" name="field4" /></td></tr>
+<tr><th>Field5:</th><td><input type="text" name="field5" /></td></tr>
+<tr><th>Field6:</th><td><input type="text" name="field6" /></td></tr>
+<tr><th>Field7:</th><td><input type="text" name="field7" /></td></tr>
+<tr><th>Field8:</th><td><input type="text" name="field8" /></td></tr>
+<tr><th>Field9:</th><td><input type="text" name="field9" /></td></tr>
+<tr><th>Field10:</th><td><input type="text" name="field10" /></td></tr>
+<tr><th>Field11:</th><td><input type="text" name="field11" /></td></tr>
+<tr><th>Field12:</th><td><input type="text" name="field12" /></td></tr>
+<tr><th>Field13:</th><td><input type="text" name="field13" /></td></tr>
+<tr><th>Field14:</th><td><input type="text" name="field14" /></td></tr>
+
+Some Field classes have an effect on the HTML attributes of their associated
+Widget. If you set max_length in a CharField and its associated widget is
+either a TextInput or PasswordInput, then the widget's rendered HTML will
+include the "maxlength" attribute.
+>>> class UserRegistration(Form):
+...    username = CharField(max_length=10)                   # uses TextInput by default
+...    password = CharField(max_length=10, widget=PasswordInput)
+...    realname = CharField(max_length=10, widget=TextInput) # redundantly define widget, just to test
+...    address = CharField()                                 # no max_length defined here
+>>> p = UserRegistration(auto_id=False)
+>>> print p.as_ul()
+<li>Username: <input type="text" name="username" maxlength="10" /></li>
+<li>Password: <input type="password" name="password" maxlength="10" /></li>
+<li>Realname: <input type="text" name="realname" maxlength="10" /></li>
+<li>Address: <input type="text" name="address" /></li>
+
+If you specify a custom "attrs" that includes the "maxlength" attribute,
+the Field's max_length attribute will override whatever "maxlength" you specify
+in "attrs".
+>>> class UserRegistration(Form):
+...    username = CharField(max_length=10, widget=TextInput(attrs={'maxlength': 20}))
+...    password = CharField(max_length=10, widget=PasswordInput)
+>>> p = UserRegistration(auto_id=False)
+>>> print p.as_ul()
+<li>Username: <input type="text" name="username" maxlength="10" /></li>
+<li>Password: <input type="password" name="password" maxlength="10" /></li>
+
+You can specify the label for a field by using the 'label' argument to a Field
+class. If you don't specify 'label', Django will use the field name with
+underscores converted to spaces, and the initial letter capitalized.
+>>> class UserRegistration(Form):
+...    username = CharField(max_length=10, label='Your username')
+...    password1 = CharField(widget=PasswordInput)
+...    password2 = CharField(widget=PasswordInput, label='Password (again)')
+>>> p = UserRegistration(auto_id=False)
+>>> print p.as_ul()
+<li>Your username: <input type="text" name="username" maxlength="10" /></li>
+<li>Password1: <input type="password" name="password1" /></li>
+<li>Password (again): <input type="password" name="password2" /></li>
+
+A label can be a Unicode object or a bytestring with special characters.
+>>> class UserRegistration(Form):
+...    username = CharField(max_length=10, label='ŠĐĆŽćžšđ')
+...    password = CharField(widget=PasswordInput, label=u'\u0160\u0110\u0106\u017d\u0107\u017e\u0161\u0111')
+>>> p = UserRegistration(auto_id=False)
+>>> p.as_ul()
+u'<li>\u0160\u0110\u0106\u017d\u0107\u017e\u0161\u0111: <input type="text" name="username" maxlength="10" /></li>\n<li>\u0160\u0110\u0106\u017d\u0107\u017e\u0161\u0111: <input type="password" name="password" /></li>'
+
+If a label is set to the empty string for a field, that field won't get a label.
+>>> class UserRegistration(Form):
+...    username = CharField(max_length=10, label='')
+...    password = CharField(widget=PasswordInput)
+>>> p = UserRegistration(auto_id=False)
+>>> print p.as_ul()
+<li> <input type="text" name="username" maxlength="10" /></li>
+<li>Password: <input type="password" name="password" /></li>
+>>> p = UserRegistration(auto_id='id_%s')
+>>> print p.as_ul()
+<li> <input id="id_username" type="text" name="username" maxlength="10" /></li>
+<li><label for="id_password">Password:</label> <input type="password" name="password" id="id_password" /></li>
+
+If label is None, Django will auto-create the label from the field name. This
+is default behavior.
+>>> class UserRegistration(Form):
+...    username = CharField(max_length=10, label=None)
+...    password = CharField(widget=PasswordInput)
+>>> p = UserRegistration(auto_id=False)
+>>> print p.as_ul()
+<li>Username: <input type="text" name="username" maxlength="10" /></li>
+<li>Password: <input type="password" name="password" /></li>
+>>> p = UserRegistration(auto_id='id_%s')
+>>> print p.as_ul()
+<li><label for="id_username">Username:</label> <input id="id_username" type="text" name="username" maxlength="10" /></li>
+<li><label for="id_password">Password:</label> <input type="password" name="password" id="id_password" /></li>
+
+# Forms with prefixes #########################################################
+
+Sometimes it's necessary to have multiple forms display on the same HTML page,
+or multiple copies of the same form. We can accomplish this with form prefixes.
+Pass the keyword argument 'prefix' to the Form constructor to use this feature.
+This value will be prepended to each HTML form field name. One way to think
+about this is "namespaces for HTML forms". Notice that in the data argument,
+each field's key has the prefix, in this case 'person1', prepended to the
+actual field name.
+>>> class Person(Form):
+...     first_name = CharField()
+...     last_name = CharField()
+...     birthday = DateField()
+>>> data = {
+...     'person1-first_name': u'John',
+...     'person1-last_name': u'Lennon',
+...     'person1-birthday': u'1940-10-9'
+... }
+>>> p = Person(data, prefix='person1')
+>>> print p.as_ul()
+<li><label for="id_person1-first_name">First name:</label> <input type="text" name="person1-first_name" value="John" id="id_person1-first_name" /></li>
+<li><label for="id_person1-last_name">Last name:</label> <input type="text" name="person1-last_name" value="Lennon" id="id_person1-last_name" /></li>
+<li><label for="id_person1-birthday">Birthday:</label> <input type="text" name="person1-birthday" value="1940-10-9" id="id_person1-birthday" /></li>
+>>> print p['first_name']
+<input type="text" name="person1-first_name" value="John" id="id_person1-first_name" />
+>>> print p['last_name']
+<input type="text" name="person1-last_name" value="Lennon" id="id_person1-last_name" />
+>>> print p['birthday']
+<input type="text" name="person1-birthday" value="1940-10-9" id="id_person1-birthday" />
+>>> p.errors
+{}
+>>> p.is_valid()
+True
+>>> p.clean_data
+{'first_name': u'John', 'last_name': u'Lennon', 'birthday': datetime.date(1940, 10, 9)}
+
+Let's try submitting some bad data to make sure form.errors and field.errors
+work as expected.
+>>> data = {
+...     'person1-first_name': u'',
+...     'person1-last_name': u'',
+...     'person1-birthday': u''
+... }
+>>> p = Person(data, prefix='person1')
+>>> p.errors
+{'first_name': [u'This field is required.'], 'last_name': [u'This field is required.'], 'birthday': [u'This field is required.']}
+>>> p['first_name'].errors
+[u'This field is required.']
+>>> p['person1-first_name'].errors
+Traceback (most recent call last):
+...
+KeyError: "Key 'person1-first_name' not found in Form"
+
+In this example, the data doesn't have a prefix, but the form requires it, so
+the form doesn't "see" the fields.
+>>> data = {
+...     'first_name': u'John',
+...     'last_name': u'Lennon',
+...     'birthday': u'1940-10-9'
+... }
+>>> p = Person(data, prefix='person1')
+>>> p.errors
+{'first_name': [u'This field is required.'], 'last_name': [u'This field is required.'], 'birthday': [u'This field is required.']}
+
+With prefixes, a single data dictionary can hold data for multiple instances
+of the same form.
+>>> data = {
+...     'person1-first_name': u'John',
+...     'person1-last_name': u'Lennon',
+...     'person1-birthday': u'1940-10-9',
+...     'person2-first_name': u'Jim',
+...     'person2-last_name': u'Morrison',
+...     'person2-birthday': u'1943-12-8'
+... }
+>>> p1 = Person(data, prefix='person1')
+>>> p1.is_valid()
+True
+>>> p1.clean_data
+{'first_name': u'John', 'last_name': u'Lennon', 'birthday': datetime.date(1940, 10, 9)}
+>>> p2 = Person(data, prefix='person2')
+>>> p2.is_valid()
+True
+>>> p2.clean_data
+{'first_name': u'Jim', 'last_name': u'Morrison', 'birthday': datetime.date(1943, 12, 8)}
+
+By default, forms append a hyphen between the prefix and the field name, but a
+form can alter that behavior by implementing the add_prefix() method. This
+method takes a field name and returns the prefixed field, according to
+self.prefix.
+>>> class Person(Form):
+...     first_name = CharField()
+...     last_name = CharField()
+...     birthday = DateField()
+...     def add_prefix(self, field_name):
+...         return self.prefix and '%s-prefix-%s' % (self.prefix, field_name) or field_name
+>>> p = Person(prefix='foo')
+>>> print p.as_ul()
+<li><label for="id_foo-prefix-first_name">First name:</label> <input type="text" name="foo-prefix-first_name" id="id_foo-prefix-first_name" /></li>
+<li><label for="id_foo-prefix-last_name">Last name:</label> <input type="text" name="foo-prefix-last_name" id="id_foo-prefix-last_name" /></li>
+<li><label for="id_foo-prefix-birthday">Birthday:</label> <input type="text" name="foo-prefix-birthday" id="id_foo-prefix-birthday" /></li>
+>>> data = {
+...     'foo-prefix-first_name': u'John',
+...     'foo-prefix-last_name': u'Lennon',
+...     'foo-prefix-birthday': u'1940-10-9'
+... }
+>>> p = Person(data, prefix='foo')
+>>> p.is_valid()
+True
+>>> p.clean_data
+{'first_name': u'John', 'last_name': u'Lennon', 'birthday': datetime.date(1940, 10, 9)}
+
+# Basic form processing in a view #############################################
+
+>>> from django.template import Template, Context
+>>> class UserRegistration(Form):
+...    username = CharField(max_length=10)
+...    password1 = CharField(widget=PasswordInput)
+...    password2 = CharField(widget=PasswordInput)
+...    def clean(self):
+...        if self.clean_data.get('password1') and self.clean_data.get('password2') and self.clean_data['password1'] != self.clean_data['password2']:
+...            raise ValidationError(u'Please make sure your passwords match.')
+...        return self.clean_data
+>>> def my_function(method, post_data):
+...     if method == 'POST':
+...         form = UserRegistration(post_data, auto_id=False)
+...     else:
+...         form = UserRegistration(auto_id=False)
+...     if form.is_valid():
+...         return 'VALID: %r' % form.clean_data
+...     t = Template('<form action="" method="post">\n<table>\n{{ form }}\n</table>\n<input type="submit" />\n</form>')
+...     return t.render(Context({'form': form}))
+
+Case 1: GET (an empty form, with no errors).
+>>> print my_function('GET', {})
+<form action="" method="post">
+<table>
+<tr><th>Username:</th><td><input type="text" name="username" maxlength="10" /></td></tr>
+<tr><th>Password1:</th><td><input type="password" name="password1" /></td></tr>
+<tr><th>Password2:</th><td><input type="password" name="password2" /></td></tr>
+</table>
+<input type="submit" />
+</form>
+
+Case 2: POST with erroneous data (a redisplayed form, with errors).
+>>> print my_function('POST', {'username': 'this-is-a-long-username', 'password1': 'foo', 'password2': 'bar'})
+<form action="" method="post">
+<table>
+<tr><td colspan="2"><ul class="errorlist"><li>Please make sure your passwords match.</li></ul></td></tr>
+<tr><th>Username:</th><td><ul class="errorlist"><li>Ensure this value has at most 10 characters.</li></ul><input type="text" name="username" value="this-is-a-long-username" maxlength="10" /></td></tr>
+<tr><th>Password1:</th><td><input type="password" name="password1" value="foo" /></td></tr>
+<tr><th>Password2:</th><td><input type="password" name="password2" value="bar" /></td></tr>
+</table>
+<input type="submit" />
+</form>
+
+Case 3: POST with valid data (the success message).
+>>> print my_function('POST', {'username': 'adrian', 'password1': 'secret', 'password2': 'secret'})
+VALID: {'username': u'adrian', 'password1': u'secret', 'password2': u'secret'}
+
+# Some ideas for using templates with forms ###################################
+
+>>> class UserRegistration(Form):
+...    username = CharField(max_length=10)
+...    password1 = CharField(widget=PasswordInput)
+...    password2 = CharField(widget=PasswordInput)
+...    def clean(self):
+...        if self.clean_data.get('password1') and self.clean_data.get('password2') and self.clean_data['password1'] != self.clean_data['password2']:
+...            raise ValidationError(u'Please make sure your passwords match.')
+...        return self.clean_data
+
+You have full flexibility in displaying form fields in a template. Just pass a
+Form instance to the template, and use "dot" access to refer to individual
+fields. Note, however, that this flexibility comes with the responsibility of
+displaying all the errors, including any that might not be associated with a
+particular field.
+>>> t = Template('''<form action="">
+... {{ form.username.errors.as_ul }}<p><label>Your username: {{ form.username }}</label></p>
+... {{ form.password1.errors.as_ul }}<p><label>Password: {{ form.password1 }}</label></p>
+... {{ form.password2.errors.as_ul }}<p><label>Password (again): {{ form.password2 }}</label></p>
+... <input type="submit" />
+... </form>''')
+>>> print t.render(Context({'form': UserRegistration(auto_id=False)}))
+<form action="">
+<p><label>Your username: <input type="text" name="username" maxlength="10" /></label></p>
+<p><label>Password: <input type="password" name="password1" /></label></p>
+<p><label>Password (again): <input type="password" name="password2" /></label></p>
+<input type="submit" />
+</form>
+>>> print t.render(Context({'form': UserRegistration({'username': 'django'}, auto_id=False)}))
+<form action="">
+<p><label>Your username: <input type="text" name="username" value="django" maxlength="10" /></label></p>
+<ul class="errorlist"><li>This field is required.</li></ul><p><label>Password: <input type="password" name="password1" /></label></p>
+<ul class="errorlist"><li>This field is required.</li></ul><p><label>Password (again): <input type="password" name="password2" /></label></p>
+<input type="submit" />
+</form>
+
+Use form.[field].label to output a field's label. You can specify the label for
+a field by using the 'label' argument to a Field class. If you don't specify
+'label', Django will use the field name with underscores converted to spaces,
+and the initial letter capitalized.
+>>> t = Template('''<form action="">
+... <p><label>{{ form.username.label }}: {{ form.username }}</label></p>
+... <p><label>{{ form.password1.label }}: {{ form.password1 }}</label></p>
+... <p><label>{{ form.password2.label }}: {{ form.password2 }}</label></p>
+... <input type="submit" />
+... </form>''')
+>>> print t.render(Context({'form': UserRegistration(auto_id=False)}))
+<form action="">
+<p><label>Username: <input type="text" name="username" maxlength="10" /></label></p>
+<p><label>Password1: <input type="password" name="password1" /></label></p>
+<p><label>Password2: <input type="password" name="password2" /></label></p>
+<input type="submit" />
+</form>
+
+User form.[field].label_tag to output a field's label with a <label> tag
+wrapped around it, but *only* if the given field has an "id" attribute.
+Recall from above that passing the "auto_id" argument to a Form gives each
+field an "id" attribute.
+>>> t = Template('''<form action="">
+... <p>{{ form.username.label_tag }}: {{ form.username }}</p>
+... <p>{{ form.password1.label_tag }}: {{ form.password1 }}</p>
+... <p>{{ form.password2.label_tag }}: {{ form.password2 }}</p>
+... <input type="submit" />
+... </form>''')
+>>> print t.render(Context({'form': UserRegistration(auto_id=False)}))
+<form action="">
+<p>Username: <input type="text" name="username" maxlength="10" /></p>
+<p>Password1: <input type="password" name="password1" /></p>
+<p>Password2: <input type="password" name="password2" /></p>
+<input type="submit" />
+</form>
+>>> print t.render(Context({'form': UserRegistration(auto_id='id_%s')}))
+<form action="">
+<p><label for="id_username">Username</label>: <input id="id_username" type="text" name="username" maxlength="10" /></p>
+<p><label for="id_password1">Password1</label>: <input type="password" name="password1" id="id_password1" /></p>
+<p><label for="id_password2">Password2</label>: <input type="password" name="password2" id="id_password2" /></p>
+<input type="submit" />
+</form>
+
+To display the errors that aren't associated with a particular field -- e.g.,
+the errors caused by Form.clean() -- use {{ form.non_field_errors }} in the
+template. If used on its own, it is displayed as a <ul> (or an empty string, if
+the list of errors is empty). You can also use it in {% if %} statements.
+>>> t = Template('''<form action="">
+... {{ form.username.errors.as_ul }}<p><label>Your username: {{ form.username }}</label></p>
+... {{ form.password1.errors.as_ul }}<p><label>Password: {{ form.password1 }}</label></p>
+... {{ form.password2.errors.as_ul }}<p><label>Password (again): {{ form.password2 }}</label></p>
+... <input type="submit" />
+... </form>''')
+>>> print t.render(Context({'form': UserRegistration({'username': 'django', 'password1': 'foo', 'password2': 'bar'}, auto_id=False)}))
+<form action="">
+<p><label>Your username: <input type="text" name="username" value="django" maxlength="10" /></label></p>
+<p><label>Password: <input type="password" name="password1" value="foo" /></label></p>
+<p><label>Password (again): <input type="password" name="password2" value="bar" /></label></p>
+<input type="submit" />
+</form>
+>>> t = Template('''<form action="">
+... {{ form.non_field_errors }}
+... {{ form.username.errors.as_ul }}<p><label>Your username: {{ form.username }}</label></p>
+... {{ form.password1.errors.as_ul }}<p><label>Password: {{ form.password1 }}</label></p>
+... {{ form.password2.errors.as_ul }}<p><label>Password (again): {{ form.password2 }}</label></p>
+... <input type="submit" />
+... </form>''')
+>>> print t.render(Context({'form': UserRegistration({'username': 'django', 'password1': 'foo', 'password2': 'bar'}, auto_id=False)}))
+<form action="">
+<ul class="errorlist"><li>Please make sure your passwords match.</li></ul>
+<p><label>Your username: <input type="text" name="username" value="django" maxlength="10" /></label></p>
+<p><label>Password: <input type="password" name="password1" value="foo" /></label></p>
+<p><label>Password (again): <input type="password" name="password2" value="bar" /></label></p>
+<input type="submit" />
+</form>
+
+#################
+# Extra widgets #
+#################
+
+The newforms library comes with some extra, higher-level Widget classes that
+demonstrate some of the library's abilities.
+
+# SelectDateWidget ############################################################
+
+>>> from django.newforms.extras import SelectDateWidget
+>>> w = SelectDateWidget()
+>>> print w.render('mydate', '')
+<select name="mydate_month">
+<option value="1">January</option>
+<option value="2">February</option>
+<option value="3">March</option>
+<option value="4">April</option>
+<option value="5">May</option>
+<option value="6">June</option>
+<option value="7">July</option>
+<option value="8">August</option>
+<option value="9">September</option>
+<option value="10">October</option>
+<option value="11">November</option>
+<option value="12">December</option>
+</select>
+<select name="mydate_day">
+<option value="1">1</option>
+<option value="2">2</option>
+<option value="3">3</option>
+<option value="4">4</option>
+<option value="5">5</option>
+<option value="6">6</option>
+<option value="7">7</option>
+<option value="8">8</option>
+<option value="9">9</option>
+<option value="10">10</option>
+<option value="11">11</option>
+<option value="12">12</option>
+<option value="13">13</option>
+<option value="14">14</option>
+<option value="15">15</option>
+<option value="16">16</option>
+<option value="17">17</option>
+<option value="18">18</option>
+<option value="19">19</option>
+<option value="20">20</option>
+<option value="21">21</option>
+<option value="22">22</option>
+<option value="23">23</option>
+<option value="24">24</option>
+<option value="25">25</option>
+<option value="26">26</option>
+<option value="27">27</option>
+<option value="28">28</option>
+<option value="29">29</option>
+<option value="30">30</option>
+<option value="31">31</option>
+</select>
+<select name="mydate_year">
+<option value="2006">2006</option>
+<option value="2007">2007</option>
+<option value="2008">2008</option>
+<option value="2009">2009</option>
+<option value="2010">2010</option>
+<option value="2011">2011</option>
+<option value="2012">2012</option>
+<option value="2013">2013</option>
+<option value="2014">2014</option>
+<option value="2015">2015</option>
+</select>
+>>> w.render('mydate', None) == w.render('mydate', '')
+True
+>>> print w.render('mydate', '2010-04-15')
+<select name="mydate_month">
+<option value="1">January</option>
+<option value="2">February</option>
+<option value="3">March</option>
+<option value="4" selected="selected">April</option>
+<option value="5">May</option>
+<option value="6">June</option>
+<option value="7">July</option>
+<option value="8">August</option>
+<option value="9">September</option>
+<option value="10">October</option>
+<option value="11">November</option>
+<option value="12">December</option>
+</select>
+<select name="mydate_day">
+<option value="1">1</option>
+<option value="2">2</option>
+<option value="3">3</option>
+<option value="4">4</option>
+<option value="5">5</option>
+<option value="6">6</option>
+<option value="7">7</option>
+<option value="8">8</option>
+<option value="9">9</option>
+<option value="10">10</option>
+<option value="11">11</option>
+<option value="12">12</option>
+<option value="13">13</option>
+<option value="14">14</option>
+<option value="15" selected="selected">15</option>
+<option value="16">16</option>
+<option value="17">17</option>
+<option value="18">18</option>
+<option value="19">19</option>
+<option value="20">20</option>
+<option value="21">21</option>
+<option value="22">22</option>
+<option value="23">23</option>
+<option value="24">24</option>
+<option value="25">25</option>
+<option value="26">26</option>
+<option value="27">27</option>
+<option value="28">28</option>
+<option value="29">29</option>
+<option value="30">30</option>
+<option value="31">31</option>
+</select>
+<select name="mydate_year">
+<option value="2006">2006</option>
+<option value="2007">2007</option>
+<option value="2008">2008</option>
+<option value="2009">2009</option>
+<option value="2010" selected="selected">2010</option>
+<option value="2011">2011</option>
+<option value="2012">2012</option>
+<option value="2013">2013</option>
+<option value="2014">2014</option>
+<option value="2015">2015</option>
+</select>
+
 """
 
 if __name__ == "__main__":
diff --git a/tests/regressiontests/templates/tests.py b/tests/regressiontests/templates/tests.py
index 3c31bb0604..0a41f5b5b7 100644
--- a/tests/regressiontests/templates/tests.py
+++ b/tests/regressiontests/templates/tests.py
@@ -1,3 +1,4 @@
+# -*- coding: utf-8 -*-
 from django.conf import settings
 
 if __name__ == '__main__':
@@ -62,6 +63,11 @@ class OtherClass:
     def method(self):
         return "OtherClass.method"
 
+class UnicodeInStrClass:
+    "Class whose __str__ returns a Unicode object."
+    def __str__(self):
+        return u'ŠĐĆŽćžšđ'
+
 class Templates(unittest.TestCase):
     def test_templates(self):
         # NOW and NOW_tz are used by timesince tag tests.
@@ -173,6 +179,10 @@ class Templates(unittest.TestCase):
             # Empty strings can be passed as arguments to filters
             'basic-syntax36': (r'{{ var|join:"" }}', {'var': ['a', 'b', 'c']}, 'abc'),
 
+            # If a variable has a __str__() that returns a Unicode object, the value
+            # will be converted to a bytestring.
+            'basic-syntax37': (r'{{ var }}', {'var': UnicodeInStrClass()}, '\xc5\xa0\xc4\x90\xc4\x86\xc5\xbd\xc4\x87\xc5\xbe\xc5\xa1\xc4\x91'),
+
             ### COMMENT SYNTAX ########################################################
             'comment-syntax01': ("{# this is hidden #}hello", {}, "hello"),
             'comment-syntax02': ("{# this is hidden #}hello{# foo #}", {}, "hello"),
@@ -328,18 +338,18 @@ class Templates(unittest.TestCase):
             'ifchanged05': ('{% for n in num %}{% ifchanged %}{{ n }}{% endifchanged %}{% for x in numx %}{% ifchanged %}{{ x }}{% endifchanged %}{% endfor %}{% endfor %}', { 'num': (1, 1, 1), 'numx': (1, 2, 3)}, '1123123123'),
             'ifchanged06': ('{% for n in num %}{% ifchanged %}{{ n }}{% endifchanged %}{% for x in numx %}{% ifchanged %}{{ x }}{% endifchanged %}{% endfor %}{% endfor %}', { 'num': (1, 1, 1), 'numx': (2, 2, 2)}, '1222'),
             'ifchanged07': ('{% for n in num %}{% ifchanged %}{{ n }}{% endifchanged %}{% for x in numx %}{% ifchanged %}{{ x }}{% endifchanged %}{% for y in numy %}{% ifchanged %}{{ y }}{% endifchanged %}{% endfor %}{% endfor %}{% endfor %}', { 'num': (1, 1, 1), 'numx': (2, 2, 2), 'numy': (3, 3, 3)}, '1233323332333'),
-            
+
             # Test one parameter given to ifchanged.
             'ifchanged-param01': ('{% for n in num %}{% ifchanged n %}..{% endifchanged %}{{ n }}{% endfor %}', { 'num': (1,2,3) }, '..1..2..3'),
             'ifchanged-param02': ('{% for n in num %}{% for x in numx %}{% ifchanged n %}..{% endifchanged %}{{ x }}{% endfor %}{% endfor %}', { 'num': (1,2,3), 'numx': (5,6,7) }, '..567..567..567'),
-            
+
             # Test multiple parameters to ifchanged.
             'ifchanged-param03': ('{% for n in num %}{{ n }}{% for x in numx %}{% ifchanged x n %}{{ x }}{% endifchanged %}{% endfor %}{% endfor %}', { 'num': (1,1,2), 'numx': (5,6,6) }, '156156256'),
-            
+
             # Test a date+hour like construct, where the hour of the last day
             # is the same but the date had changed, so print the hour anyway.
             'ifchanged-param04': ('{% for d in days %}{% ifchanged %}{{ d.day }}{% endifchanged %}{% for h in d.hours %}{% ifchanged d h %}{{ h }}{% endifchanged %}{% endfor %}{% endfor %}', {'days':[{'day':1, 'hours':[1,2,3]},{'day':2, 'hours':[3]},] }, '112323'),
-            
+
             # Logically the same as above, just written with explicit
             # ifchanged for the day.
             'ifchanged-param04': ('{% for d in days %}{% ifchanged d.day %}{{ d.day }}{% endifchanged %}{% for h in d.hours %}{% ifchanged d.day h %}{{ h }}{% endifchanged %}{% endfor %}{% endfor %}', {'days':[{'day':1, 'hours':[1,2,3]},{'day':2, 'hours':[3]},] }, '112323'),
diff --git a/tests/runtests.py b/tests/runtests.py
index 359fca2bf5..20189c2d99 100755
--- a/tests/runtests.py
+++ b/tests/runtests.py
@@ -40,12 +40,12 @@ def get_invalid_models():
             if f.startswith('invalid'):
                 models.append((loc, f))
     return models
-                
+
 class InvalidModelTestCase(unittest.TestCase):
     def __init__(self, model_label):
         unittest.TestCase.__init__(self)
         self.model_label = model_label
-        
+
     def runTest(self):
         from django.core import management
         from django.db.models.loading import load_app
@@ -55,7 +55,7 @@ class InvalidModelTestCase(unittest.TestCase):
             module = load_app(self.model_label)
         except Exception, e:
             self.fail('Unable to load invalid model module')
-        
+
         s = StringIO()
         count = management.get_validation_errors(s, module)
         s.seek(0)
@@ -71,39 +71,43 @@ class InvalidModelTestCase(unittest.TestCase):
 
 def django_tests(verbosity, tests_to_run):
     from django.conf import settings
-    from django.db.models.loading import get_apps, load_app
 
     old_installed_apps = settings.INSTALLED_APPS
     old_test_database_name = settings.TEST_DATABASE_NAME
     old_root_urlconf = settings.ROOT_URLCONF
     old_template_dirs = settings.TEMPLATE_DIRS
-    
+    old_use_i18n = settings.USE_I18N
+
     # Redirect some settings for the duration of these tests
     settings.TEST_DATABASE_NAME = TEST_DATABASE_NAME
     settings.INSTALLED_APPS = ALWAYS_INSTALLED_APPS
     settings.ROOT_URLCONF = 'urls'
     settings.TEMPLATE_DIRS = (os.path.join(os.path.dirname(__file__), TEST_TEMPLATE_DIR),)
-    
-    # load all the ALWAYS_INSTALLED_APPS
+    settings.USE_I18N = True
+
+    # Load all the ALWAYS_INSTALLED_APPS.
+    # (This import statement is intentionally delayed until after we
+    # access settings because of the USE_I18N dependency.)
+    from django.db.models.loading import get_apps, load_app
     get_apps()
-    
+
     # Load all the test model apps
     test_models = []
-    for model_dir, model_name in get_test_models():        
+    for model_dir, model_name in get_test_models():
         model_label = '.'.join([model_dir, model_name])
         try:
             # if the model was named on the command line, or
-            # no models were named (i.e., run all), import 
+            # no models were named (i.e., run all), import
             # this model and add it to the list to test.
             if not tests_to_run or model_name in tests_to_run:
                 if verbosity >= 1:
                     print "Importing model %s" % model_name
                 mod = load_app(model_label)
-                settings.INSTALLED_APPS.append(model_label)        
+                settings.INSTALLED_APPS.append(model_label)
                 test_models.append(mod)
         except Exception, e:
             sys.stderr.write("Error while importing %s:" % model_name + ''.join(traceback.format_exception(*sys.exc_info())[1:]))
-            continue    
+            continue
 
     # Add tests for invalid models
     extra_tests = []
@@ -111,28 +115,29 @@ def django_tests(verbosity, tests_to_run):
         model_label = '.'.join([model_dir, model_name])
         if not tests_to_run or model_name in tests_to_run:
             extra_tests.append(InvalidModelTestCase(model_label))
-    
+
     # Run the test suite, including the extra validation tests.
     from django.test.simple import run_tests
     run_tests(test_models, verbosity, extra_tests=extra_tests)
-  
+
     # Restore the old settings
     settings.INSTALLED_APPS = old_installed_apps
     settings.TESTS_DATABASE_NAME = old_test_database_name
     settings.ROOT_URLCONF = old_root_urlconf
     settings.TEMPLATE_DIRS = old_template_dirs
-    
+    settings.USE_I18N = old_use_i18n
+
 if __name__ == "__main__":
     from optparse import OptionParser
     usage = "%prog [options] [model model model ...]"
     parser = OptionParser(usage=usage)
     parser.add_option('-v','--verbosity', action='store', dest='verbosity', default='0',
         type='choice', choices=['0', '1', '2'],
-        help='Verbosity level; 0=minimal output, 1=normal output, 2=all output')    
+        help='Verbosity level; 0=minimal output, 1=normal output, 2=all output')
     parser.add_option('--settings',
         help='Python path to settings module, e.g. "myproject.settings". If this isn\'t provided, the DJANGO_SETTINGS_MODULE environment variable will be used.')
     options, args = parser.parse_args()
     if options.settings:
         os.environ['DJANGO_SETTINGS_MODULE'] = options.settings
-        
+
     django_tests(int(options.verbosity), args)