Context Navigation

Back to Ticket #17627

Ticket #17627: 0003.patch

File 0003.patch, 127.9 KB (added by Luke Granger-Brown, 13 years ago)
Updated version of 0002.patch

AUTHORS

diff --git a/AUTHORS b/AUTHORS
index 5fa21d3..faa6126 100644

                answer newbie questions, and generally made Django that much better:
     David Gouldin <dgouldin@gmail.com>
     pradeep.gowda@gmail.com
     Collin Grady <collin@collingrady.com>
+    Luke Granger-Brown <django@lukegb.com>
     Gabriel Grant <g@briel.ca>
     Simon Greenhill <dev@simon.net.nz>
     Owen Griffiths
-…
+               answer newbie questions, and generally made Django that much better:
     Cameron Knight (ckknight)
     Nena Kojadin <nena@kiberpipa.org>
     Igor Kolar <ike@email.si>
+    Wiktor Kołodziej
     Tomáš Kopeček <permonik@m6.cz>
     Gasper Koren
     Mikhail Korobov <kmike84@googlemail.com>

django/conf/locale/en/LC_MESSAGES/django.po

diff --git a/django/conf/locale/en/LC_MESSAGES/django.po b/django/conf/locale/en/LC_MESSAGES/django.po
index abb52ae..1f3317b 100644

                msgstr ""
 msgid "\"%s\" is not a valid value for a primary key."
 msgstr ""
 #: forms/util.py:70
+#: forms/utils.py:70
 #, python-format
 msgid ""
 "%(datetime)s couldn't be interpreted in time zone %(current_timezone)s; it "

django/contrib/admin/actions.py

diff --git a/django/contrib/admin/actions.py b/django/contrib/admin/actions.py
index 5b56402..4a03a97 100644

                Built-in, globally-available admin actions.
 from django.core.exceptions import PermissionDenied
 from django.contrib.admin import helpers
 from django.contrib.admin.util import get_deleted_objects, model_ngettext
+from django.contrib.admin.utils import get_deleted_objects, model_ngettext
 from django.db import router
 from django.template.response import TemplateResponse
 from django.utils.encoding import force_unicode

django/contrib/admin/filters.py

diff --git a/django/contrib/admin/filters.py b/django/contrib/admin/filters.py
index 550683b..dc4434b 100644

                from django.core.exceptions import ImproperlyConfigured
 from django.utils.encoding import smart_unicode
 from django.utils.translation import ugettext_lazy as _
 from django.contrib.admin.util import (get_model_from_relation,
+from django.contrib.admin.utils import (get_model_from_relation,
     reverse_field_path, get_limit_choices_to_from_path, prepare_lookup_value)
 class ListFilter(object):

django/contrib/admin/helpers.py

diff --git a/django/contrib/admin/helpers.py b/django/contrib/admin/helpers.py
index b08d1c8..ae46be4 100644

-              a
 from django import forms
 from django.contrib.admin.util import (flatten_fieldsets, lookup_field,
+from django.contrib.admin.utils import (flatten_fieldsets, lookup_field,
     display_for_field, label_for_field, help_text_for_field)
 from django.contrib.admin.templatetags.admin_static import static
 from django.contrib.contenttypes.models import ContentType
 from django.core.exceptions import ObjectDoesNotExist
 from django.db.models.fields.related import ManyToManyRel
 from django.forms.util import flatatt
+from django.forms.utils import flatatt
 from django.template.defaultfilters import capfirst
 from django.utils.encoding import force_unicode, smart_unicode
 from django.utils.html import escape, conditional_escape
-…
+               class InlineFieldset(Fieldset):
             yield Fieldline(self.form, field, self.readonly_fields,
                 model_admin=self.model_admin)
 class AdminErrorList(forms.util.ErrorList):
+class AdminErrorList(forms.utils.ErrorList):
     """
     Stores all errors for the form/formsets in an add/change stage view.
     """

django/contrib/admin/models.py

diff --git a/django/contrib/admin/models.py b/django/contrib/admin/models.py
index 0e5b8a7..013ae44 100644

-              a
 from django.db import models
 from django.contrib.contenttypes.models import ContentType
 from django.contrib.auth.models import User
 from django.contrib.admin.util import quote
+from django.contrib.admin.utils import quote
 from django.utils.translation import ugettext_lazy as _
 from django.utils.encoding import smart_unicode
 from django.utils.safestring import mark_safe

django/contrib/admin/options.py

diff --git a/django/contrib/admin/options.py b/django/contrib/admin/options.py
index f5f6256..0dcb4e6 100644

                from django.forms.models import (modelform_factory, modelformset_factory,
     inlineformset_factory, BaseInlineFormSet)
 from django.contrib.contenttypes.models import ContentType
 from django.contrib.admin import widgets, helpers
 from django.contrib.admin.util import unquote, flatten_fieldsets, get_deleted_objects, model_format_dict
+from django.contrib.admin.utils import unquote, flatten_fieldsets, get_deleted_objects, model_format_dict
 from django.contrib.admin.templatetags.admin_static import static
 from django.contrib import messages
 from django.views.decorators.csrf import csrf_protect

django/contrib/admin/templatetags/admin_list.py

diff --git a/django/contrib/admin/templatetags/admin_list.py b/django/contrib/admin/templatetags/admin_list.py
index e778429..23ba3ea 100644

-              a
 import datetime
 from django.contrib.admin.util import lookup_field, display_for_field, label_for_field
+from django.contrib.admin.utils import lookup_field, display_for_field, label_for_field
 from django.contrib.admin.views.main import (ALL_VAR, EMPTY_CHANGELIST_VALUE,
     ORDER_VAR, PAGE_VAR, SEARCH_VAR)
 from django.contrib.admin.templatetags.admin_static import static

django/contrib/admin/util.py

diff --git a/django/contrib/admin/util.py b/django/contrib/admin/util.py
index 61182a6..fc8b3dd 100644

-              a
+from django.db import models
+from django.db.models.sql.constants import LOOKUP_SEP
+from django.db.models.deletion import Collector
+from django.db.models.related import RelatedObject
+from django.forms.forms import pretty_name
+from django.utils import formats
+from django.utils.html import escape
+from django.utils.safestring import mark_safe
+from django.utils.text import capfirst
+from django.utils import timezone
+from django.utils.encoding import force_unicode, smart_unicode, smart_str
+from django.utils.translation import ungettext
+from django.core.urlresolvers import reverse
+import warnings
+def lookup_needs_distinct(opts, lookup_path):
+    """
+    Returns True if 'distinct()' should be used to query the given lookup path.
+    """
+    field_name = lookup_path.split('__', 1)[0]
+    field = opts.get_field_by_name(field_name)[0]
+    if ((hasattr(field, 'rel') and
+         isinstance(field.rel, models.ManyToManyRel)) or
+        (isinstance(field, models.related.RelatedObject) and
+         not field.field.unique)):
+         return True
+    return False
+warnings.warn("The django.contrib.admin.util module has been renamed "
+              "(https://code.djangoproject.com/ticket/17627/). "
+              "Use django.contrib.admin.utils instead.", PendingDeprecationWarning)
+def prepare_lookup_value(key, value):
+    """
+    Returns a lookup value prepared to be used in queryset filtering.
+    """
+    # if key ends with __in, split parameter into separate values
+    if key.endswith('__in'):
+        value = value.split(',')
+    # if key ends with __isnull, special case '' and false
+    if key.endswith('__isnull'):
+        if value.lower() in ('', 'false'):
+            value = False
+        else:
+            value = True
+    return value
+def quote(s):
+    """
+    Ensure that primary key values do not confuse the admin URLs by escaping
+    any '/', '_' and ':' characters. Similar to urllib.quote, except that the
+    quoting is slightly different so that it doesn't get automatically
+    unquoted by the Web browser.
+    """
+    if not isinstance(s, basestring):
+        return s
+    res = list(s)
+    for i in range(len(res)):
+        c = res[i]
+        if c in """:/_#?;@&=+$,"<>%\\""":
+            res[i] = '_%02X' % ord(c)
+    return ''.join(res)
+def unquote(s):
+    """
+    Undo the effects of quote(). Based heavily on urllib.unquote().
+    """
+    mychr = chr
+    myatoi = int
+    list = s.split('_')
+    res = [list[0]]
+    myappend = res.append
+    del list[0]
+    for item in list:
+        if item[1:2]:
+            try:
+                myappend(mychr(myatoi(item[:2], 16)) + item[2:])
+            except ValueError:
+                myappend('_' + item)
+        else:
+            myappend('_' + item)
+    return "".join(res)
+def flatten_fieldsets(fieldsets):
+    """Returns a list of field names from an admin fieldsets structure."""
+    field_names = []
+    for name, opts in fieldsets:
+        for field in opts['fields']:
+            # type checking feels dirty, but it seems like the best way here
+            if type(field) == tuple:
+                field_names.extend(field)
+            else:
+                field_names.append(field)
+    return field_names
+def get_deleted_objects(objs, opts, user, admin_site, using):
+    """
+    Find all objects related to ``objs`` that should also be deleted. ``objs``
+    must be a homogenous iterable of objects (e.g. a QuerySet).
+    Returns a nested list of strings suitable for display in the
+    template with the ``unordered_list`` filter.
+    """
+    collector = NestedObjects(using=using)
+    collector.collect(objs)
+    perms_needed = set()
+    def format_callback(obj):
+        has_admin = obj.__class__ in admin_site._registry
+        opts = obj._meta
+        if has_admin:
+            admin_url = reverse('%s:%s_%s_change'
+                                % (admin_site.name,
+                                   opts.app_label,
+                                   opts.object_name.lower()),
+                                None, (quote(obj._get_pk_val()),))
+            p = '%s.%s' % (opts.app_label,
+                           opts.get_delete_permission())
+            if not user.has_perm(p):
+                perms_needed.add(opts.verbose_name)
+            # Display a link to the admin page.
+            return mark_safe(u'%s: <a href="%s">%s</a>' %
+                             (escape(capfirst(opts.verbose_name)),
+                              admin_url,
+                              escape(obj)))
+        else:
+            # Don't display link to edit, because it either has no
+            # admin or is edited inline.
+            return u'%s: %s' % (capfirst(opts.verbose_name),
+                                force_unicode(obj))
+    to_delete = collector.nested(format_callback)
+    protected = [format_callback(obj) for obj in collector.protected]
+    return to_delete, perms_needed, protected
+class NestedObjects(Collector):
+    def __init__(self, *args, **kwargs):
+        super(NestedObjects, self).__init__(*args, **kwargs)
+        self.edges = {} # {from_instance: [to_instances]}
+        self.protected = set()
+    def add_edge(self, source, target):
+        self.edges.setdefault(source, []).append(target)
+    def collect(self, objs, source_attr=None, **kwargs):
+        for obj in objs:
+            if source_attr:
+                self.add_edge(getattr(obj, source_attr), obj)
+            else:
+                self.add_edge(None, obj)
+        try:
+            return super(NestedObjects, self).collect(objs, source_attr=source_attr, **kwargs)
+        except models.ProtectedError, e:
+            self.protected.update(e.protected_objects)
+    def related_objects(self, related, objs):
+        qs = super(NestedObjects, self).related_objects(related, objs)
+        return qs.select_related(related.field.name)
+    def _nested(self, obj, seen, format_callback):
+        if obj in seen:
+            return []
+        seen.add(obj)
+        children = []
+        for child in self.edges.get(obj, ()):
+            children.extend(self._nested(child, seen, format_callback))
+        if format_callback:
+            ret = [format_callback(obj)]
+        else:
+            ret = [obj]
+        if children:
+            ret.append(children)
+        return ret
+    def nested(self, format_callback=None):
+        """
+        Return the graph as a nested list.
+        """
+        seen = set()
+        roots = []
+        for root in self.edges.get(None, ()):
+            roots.extend(self._nested(root, seen, format_callback))
+        return roots
+def model_format_dict(obj):
+    """
+    Return a `dict` with keys 'verbose_name' and 'verbose_name_plural',
+    typically for use with string formatting.
+    `obj` may be a `Model` instance, `Model` subclass, or `QuerySet` instance.
+    """
+    if isinstance(obj, (models.Model, models.base.ModelBase)):
+        opts = obj._meta
+    elif isinstance(obj, models.query.QuerySet):
+        opts = obj.model._meta
+    else:
+        opts = obj
+    return {
+        'verbose_name': force_unicode(opts.verbose_name),
+        'verbose_name_plural': force_unicode(opts.verbose_name_plural)
+    }
+def model_ngettext(obj, n=None):
+    """
+    Return the appropriate `verbose_name` or `verbose_name_plural` value for
+    `obj` depending on the count `n`.
+    `obj` may be a `Model` instance, `Model` subclass, or `QuerySet` instance.
+    If `obj` is a `QuerySet` instance, `n` is optional and the length of the
+    `QuerySet` is used.
+    """
+    if isinstance(obj, models.query.QuerySet):
+        if n is None:
+            n = obj.count()
+        obj = obj.model
+    d = model_format_dict(obj)
+    singular, plural = d["verbose_name"], d["verbose_name_plural"]
+    return ungettext(singular, plural, n or 0)
+def lookup_field(name, obj, model_admin=None):
+    opts = obj._meta
+    try:
+        f = opts.get_field(name)
+    except models.FieldDoesNotExist:
+        # For non-field values, the value is either a method, property or
+        # returned via a callable.
+        if callable(name):
+            attr = name
+            value = attr(obj)
+        elif (model_admin is not None and hasattr(model_admin, name) and
+          not name == '__str__' and not name == '__unicode__'):
+            attr = getattr(model_admin, name)
+            value = attr(obj)
+        else:
+            attr = getattr(obj, name)
+            if callable(attr):
+                value = attr()
+            else:
+                value = attr
+        f = None
+    else:
+        attr = None
+        value = getattr(obj, name)
+    return f, attr, value
+def label_for_field(name, model, model_admin=None, return_attr=False):
+    """
+    Returns a sensible label for a field name. The name can be a callable or the
+    name of an object attributes, as well as a genuine fields. If return_attr is
+    True, the resolved attribute (which could be a callable) is also returned.
+    This will be None if (and only if) the name refers to a field.
+    """
+    attr = None
+    try:
+        field = model._meta.get_field_by_name(name)[0]
+        if isinstance(field, RelatedObject):
+            label = field.opts.verbose_name
+        else:
+            label = field.verbose_name
+    except models.FieldDoesNotExist:
+        if name == "__unicode__":
+            label = force_unicode(model._meta.verbose_name)
+            attr = unicode
+        elif name == "__str__":
+            label = smart_str(model._meta.verbose_name)
+            attr = str
+        else:
+            if callable(name):
+                attr = name
+            elif model_admin is not None and hasattr(model_admin, name):
+                attr = getattr(model_admin, name)
+            elif hasattr(model, name):
+                attr = getattr(model, name)
+            else:
+                message = "Unable to lookup '%s' on %s" % (name, model._meta.object_name)
+                if model_admin:
+                    message += " or %s" % (model_admin.__class__.__name__,)
+                raise AttributeError(message)
+            if hasattr(attr, "short_description"):
+                label = attr.short_description
+            elif callable(attr):
+                if attr.__name__ == "<lambda>":
+                    label = "--"
+                else:
+                    label = pretty_name(attr.__name__)
+            else:
+                label = pretty_name(name)
+    if return_attr:
+        return (label, attr)
+    else:
+        return label
+def help_text_for_field(name, model):
+    try:
+        help_text = model._meta.get_field_by_name(name)[0].help_text
+    except models.FieldDoesNotExist:
+        help_text = ""
+    return smart_unicode(help_text)
+def display_for_field(value, field):
+    from django.contrib.admin.templatetags.admin_list import _boolean_icon
+    from django.contrib.admin.views.main import EMPTY_CHANGELIST_VALUE
+    if field.flatchoices:
+        return dict(field.flatchoices).get(value, EMPTY_CHANGELIST_VALUE)
+    # NullBooleanField needs special-case null-handling, so it comes
+    # before the general null test.
+    elif isinstance(field, models.BooleanField) or isinstance(field, models.NullBooleanField):
+        return _boolean_icon(value)
+    elif value is None:
+        return EMPTY_CHANGELIST_VALUE
+    elif isinstance(field, models.DateTimeField):
+        return formats.localize(timezone.localtime(value))
+    elif isinstance(field, models.DateField) or isinstance(field, models.TimeField):
+        return formats.localize(value)
+    elif isinstance(field, models.DecimalField):
+        return formats.number_format(value, field.decimal_places)
+    elif isinstance(field, models.FloatField):
+        return formats.number_format(value)
+    else:
+        return smart_unicode(value)
+class NotRelationField(Exception):
+    pass
+def get_model_from_relation(field):
+    if isinstance(field, models.related.RelatedObject):
+        return field.model
+    elif getattr(field, 'rel'): # or isinstance?
+        return field.rel.to
+    else:
+        raise NotRelationField
+def reverse_field_path(model, path):
+    """ Create a reversed field path.
+    E.g. Given (Order, "user__groups"),
+    return (Group, "user__order").
+    Final field must be a related model, not a data field.
+    """
+    reversed_path = []
+    parent = model
+    pieces = path.split(LOOKUP_SEP)
+    for piece in pieces:
+        field, model, direct, m2m = parent._meta.get_field_by_name(piece)
+        # skip trailing data field if extant:
+        if len(reversed_path) == len(pieces)-1: # final iteration
+            try:
+                get_model_from_relation(field)
+            except NotRelationField:
+                break
+        if direct:
+            related_name = field.related_query_name()
+            parent = field.rel.to
+        else:
+            related_name = field.field.name
+            parent = field.model
+        reversed_path.insert(0, related_name)
+    return (parent, LOOKUP_SEP.join(reversed_path))
+def get_fields_from_path(model, path):
+    """ Return list of Fields given path relative to model.
+    e.g. (ModelX, "user__groups__name") -> [
+        <django.db.models.fields.related.ForeignKey object at 0x...>,
+        <django.db.models.fields.related.ManyToManyField object at 0x...>,
+        <django.db.models.fields.CharField object at 0x...>,
+    ]
+    """
+    pieces = path.split(LOOKUP_SEP)
+    fields = []
+    for piece in pieces:
+        if fields:
+            parent = get_model_from_relation(fields[-1])
+        else:
+            parent = model
+        fields.append(parent._meta.get_field_by_name(piece)[0])
+    return fields
+def remove_trailing_data_field(fields):
+    """ Discard trailing non-relation field if extant. """
+    try:
+        get_model_from_relation(fields[-1])
+    except NotRelationField:
+        fields = fields[:-1]
+    return fields
+def get_limit_choices_to_from_path(model, path):
+    """ Return Q object for limiting choices if applicable.
+    If final model in path is linked via a ForeignKey or ManyToManyField which
+    has a `limit_choices_to` attribute, return it as a Q object.
+    """
+    fields = get_fields_from_path(model, path)
+    fields = remove_trailing_data_field(fields)
+    limit_choices_to = (
+        fields and hasattr(fields[-1], 'rel') and
+        getattr(fields[-1].rel, 'limit_choices_to', None))
+    if not limit_choices_to:
+        return models.Q() # empty Q
+    elif isinstance(limit_choices_to, models.Q):
+        return limit_choices_to # already a Q
+    else:
+        return models.Q(**limit_choices_to) # convert dict to Q
+from django.contrib.admin.utils import *

new file django/contrib/admin/utils.py

diff --git a/django/contrib/admin/utils.py b/django/contrib/admin/utils.py
new file mode 100644
index 0000000..61182a6

-              -
+from django.db import models
+from django.db.models.sql.constants import LOOKUP_SEP
+from django.db.models.deletion import Collector
+from django.db.models.related import RelatedObject
+from django.forms.forms import pretty_name
+from django.utils import formats
+from django.utils.html import escape
+from django.utils.safestring import mark_safe
+from django.utils.text import capfirst
+from django.utils import timezone
+from django.utils.encoding import force_unicode, smart_unicode, smart_str
+from django.utils.translation import ungettext
+from django.core.urlresolvers import reverse
+def lookup_needs_distinct(opts, lookup_path):
+    """
+    Returns True if 'distinct()' should be used to query the given lookup path.
+    """
+    field_name = lookup_path.split('__', 1)[0]
+    field = opts.get_field_by_name(field_name)[0]
+    if ((hasattr(field, 'rel') and
+         isinstance(field.rel, models.ManyToManyRel)) or
+        (isinstance(field, models.related.RelatedObject) and
+         not field.field.unique)):
+         return True
+    return False
+def prepare_lookup_value(key, value):
+    """
+    Returns a lookup value prepared to be used in queryset filtering.
+    """
+    # if key ends with __in, split parameter into separate values
+    if key.endswith('__in'):
+        value = value.split(',')
+    # if key ends with __isnull, special case '' and false
+    if key.endswith('__isnull'):
+        if value.lower() in ('', 'false'):
+            value = False
+        else:
+            value = True
+    return value
+def quote(s):
+    """
+    Ensure that primary key values do not confuse the admin URLs by escaping
+    any '/', '_' and ':' characters. Similar to urllib.quote, except that the
+    quoting is slightly different so that it doesn't get automatically
+    unquoted by the Web browser.
+    """
+    if not isinstance(s, basestring):
+        return s
+    res = list(s)
+    for i in range(len(res)):
+        c = res[i]
+        if c in """:/_#?;@&=+$,"<>%\\""":
+            res[i] = '_%02X' % ord(c)
+    return ''.join(res)
+def unquote(s):
+    """
+    Undo the effects of quote(). Based heavily on urllib.unquote().
+    """
+    mychr = chr
+    myatoi = int
+    list = s.split('_')
+    res = [list[0]]
+    myappend = res.append
+    del list[0]
+    for item in list:
+        if item[1:2]:
+            try:
+                myappend(mychr(myatoi(item[:2], 16)) + item[2:])
+            except ValueError:
+                myappend('_' + item)
+        else:
+            myappend('_' + item)
+    return "".join(res)
+def flatten_fieldsets(fieldsets):
+    """Returns a list of field names from an admin fieldsets structure."""
+    field_names = []
+    for name, opts in fieldsets:
+        for field in opts['fields']:
+            # type checking feels dirty, but it seems like the best way here
+            if type(field) == tuple:
+                field_names.extend(field)
+            else:
+                field_names.append(field)
+    return field_names
+def get_deleted_objects(objs, opts, user, admin_site, using):
+    """
+    Find all objects related to ``objs`` that should also be deleted. ``objs``
+    must be a homogenous iterable of objects (e.g. a QuerySet).
+    Returns a nested list of strings suitable for display in the
+    template with the ``unordered_list`` filter.
+    """
+    collector = NestedObjects(using=using)
+    collector.collect(objs)
+    perms_needed = set()
+    def format_callback(obj):
+        has_admin = obj.__class__ in admin_site._registry
+        opts = obj._meta
+        if has_admin:
+            admin_url = reverse('%s:%s_%s_change'
+                                % (admin_site.name,
+                                   opts.app_label,
+                                   opts.object_name.lower()),
+                                None, (quote(obj._get_pk_val()),))
+            p = '%s.%s' % (opts.app_label,
+                           opts.get_delete_permission())
+            if not user.has_perm(p):
+                perms_needed.add(opts.verbose_name)
+            # Display a link to the admin page.
+            return mark_safe(u'%s: <a href="%s">%s</a>' %
+                             (escape(capfirst(opts.verbose_name)),
+                              admin_url,
+                              escape(obj)))
+        else:
+            # Don't display link to edit, because it either has no
+            # admin or is edited inline.
+            return u'%s: %s' % (capfirst(opts.verbose_name),
+                                force_unicode(obj))
+    to_delete = collector.nested(format_callback)
+    protected = [format_callback(obj) for obj in collector.protected]
+    return to_delete, perms_needed, protected
+class NestedObjects(Collector):
+    def __init__(self, *args, **kwargs):
+        super(NestedObjects, self).__init__(*args, **kwargs)
+        self.edges = {} # {from_instance: [to_instances]}
+        self.protected = set()
+    def add_edge(self, source, target):
+        self.edges.setdefault(source, []).append(target)
+    def collect(self, objs, source_attr=None, **kwargs):
+        for obj in objs:
+            if source_attr:
+                self.add_edge(getattr(obj, source_attr), obj)
+            else:
+                self.add_edge(None, obj)
+        try:
+            return super(NestedObjects, self).collect(objs, source_attr=source_attr, **kwargs)
+        except models.ProtectedError, e:
+            self.protected.update(e.protected_objects)
+    def related_objects(self, related, objs):
+        qs = super(NestedObjects, self).related_objects(related, objs)
+        return qs.select_related(related.field.name)
+    def _nested(self, obj, seen, format_callback):
+        if obj in seen:
+            return []
+        seen.add(obj)
+        children = []
+        for child in self.edges.get(obj, ()):
+            children.extend(self._nested(child, seen, format_callback))
+        if format_callback:
+            ret = [format_callback(obj)]
+        else:
+            ret = [obj]
+        if children:
+            ret.append(children)
+        return ret
+    def nested(self, format_callback=None):
+        """
+        Return the graph as a nested list.
+        """
+        seen = set()
+        roots = []
+        for root in self.edges.get(None, ()):
+            roots.extend(self._nested(root, seen, format_callback))
+        return roots
+def model_format_dict(obj):
+    """
+    Return a `dict` with keys 'verbose_name' and 'verbose_name_plural',
+    typically for use with string formatting.
+    `obj` may be a `Model` instance, `Model` subclass, or `QuerySet` instance.
+    """
+    if isinstance(obj, (models.Model, models.base.ModelBase)):
+        opts = obj._meta
+    elif isinstance(obj, models.query.QuerySet):
+        opts = obj.model._meta
+    else:
+        opts = obj
+    return {
+        'verbose_name': force_unicode(opts.verbose_name),
+        'verbose_name_plural': force_unicode(opts.verbose_name_plural)
+    }
+def model_ngettext(obj, n=None):
+    """
+    Return the appropriate `verbose_name` or `verbose_name_plural` value for
+    `obj` depending on the count `n`.
+    `obj` may be a `Model` instance, `Model` subclass, or `QuerySet` instance.
+    If `obj` is a `QuerySet` instance, `n` is optional and the length of the
+    `QuerySet` is used.
+    """
+    if isinstance(obj, models.query.QuerySet):
+        if n is None:
+            n = obj.count()
+        obj = obj.model
+    d = model_format_dict(obj)
+    singular, plural = d["verbose_name"], d["verbose_name_plural"]
+    return ungettext(singular, plural, n or 0)
+def lookup_field(name, obj, model_admin=None):
+    opts = obj._meta
+    try:
+        f = opts.get_field(name)
+    except models.FieldDoesNotExist:
+        # For non-field values, the value is either a method, property or
+        # returned via a callable.
+        if callable(name):
+            attr = name
+            value = attr(obj)
+        elif (model_admin is not None and hasattr(model_admin, name) and
+          not name == '__str__' and not name == '__unicode__'):
+            attr = getattr(model_admin, name)
+            value = attr(obj)
+        else:
+            attr = getattr(obj, name)
+            if callable(attr):
+                value = attr()
+            else:
+                value = attr
+        f = None
+    else:
+        attr = None
+        value = getattr(obj, name)
+    return f, attr, value
+def label_for_field(name, model, model_admin=None, return_attr=False):
+    """
+    Returns a sensible label for a field name. The name can be a callable or the
+    name of an object attributes, as well as a genuine fields. If return_attr is
+    True, the resolved attribute (which could be a callable) is also returned.
+    This will be None if (and only if) the name refers to a field.
+    """
+    attr = None
+    try:
+        field = model._meta.get_field_by_name(name)[0]
+        if isinstance(field, RelatedObject):
+            label = field.opts.verbose_name
+        else:
+            label = field.verbose_name
+    except models.FieldDoesNotExist:
+        if name == "__unicode__":
+            label = force_unicode(model._meta.verbose_name)
+            attr = unicode
+        elif name == "__str__":
+            label = smart_str(model._meta.verbose_name)
+            attr = str
+        else:
+            if callable(name):
+                attr = name
+            elif model_admin is not None and hasattr(model_admin, name):
+                attr = getattr(model_admin, name)
+            elif hasattr(model, name):
+                attr = getattr(model, name)
+            else:
+                message = "Unable to lookup '%s' on %s" % (name, model._meta.object_name)
+                if model_admin:
+                    message += " or %s" % (model_admin.__class__.__name__,)
+                raise AttributeError(message)
+            if hasattr(attr, "short_description"):
+                label = attr.short_description
+            elif callable(attr):
+                if attr.__name__ == "<lambda>":
+                    label = "--"
+                else:
+                    label = pretty_name(attr.__name__)
+            else:
+                label = pretty_name(name)
+    if return_attr:
+        return (label, attr)
+    else:
+        return label
+def help_text_for_field(name, model):
+    try:
+        help_text = model._meta.get_field_by_name(name)[0].help_text
+    except models.FieldDoesNotExist:
+        help_text = ""
+    return smart_unicode(help_text)
+def display_for_field(value, field):
+    from django.contrib.admin.templatetags.admin_list import _boolean_icon
+    from django.contrib.admin.views.main import EMPTY_CHANGELIST_VALUE
+    if field.flatchoices:
+        return dict(field.flatchoices).get(value, EMPTY_CHANGELIST_VALUE)
+    # NullBooleanField needs special-case null-handling, so it comes
+    # before the general null test.
+    elif isinstance(field, models.BooleanField) or isinstance(field, models.NullBooleanField):
+        return _boolean_icon(value)
+    elif value is None:
+        return EMPTY_CHANGELIST_VALUE
+    elif isinstance(field, models.DateTimeField):
+        return formats.localize(timezone.localtime(value))
+    elif isinstance(field, models.DateField) or isinstance(field, models.TimeField):
+        return formats.localize(value)
+    elif isinstance(field, models.DecimalField):
+        return formats.number_format(value, field.decimal_places)
+    elif isinstance(field, models.FloatField):
+        return formats.number_format(value)
+    else:
+        return smart_unicode(value)
+class NotRelationField(Exception):
+    pass
+def get_model_from_relation(field):
+    if isinstance(field, models.related.RelatedObject):
+        return field.model
+    elif getattr(field, 'rel'): # or isinstance?
+        return field.rel.to
+    else:
+        raise NotRelationField
+def reverse_field_path(model, path):
+    """ Create a reversed field path.
+    E.g. Given (Order, "user__groups"),
+    return (Group, "user__order").
+    Final field must be a related model, not a data field.
+    """
+    reversed_path = []
+    parent = model
+    pieces = path.split(LOOKUP_SEP)
+    for piece in pieces:
+        field, model, direct, m2m = parent._meta.get_field_by_name(piece)
+        # skip trailing data field if extant:
+        if len(reversed_path) == len(pieces)-1: # final iteration
+            try:
+                get_model_from_relation(field)
+            except NotRelationField:
+                break
+        if direct:
+            related_name = field.related_query_name()
+            parent = field.rel.to
+        else:
+            related_name = field.field.name
+            parent = field.model
+        reversed_path.insert(0, related_name)
+    return (parent, LOOKUP_SEP.join(reversed_path))
+def get_fields_from_path(model, path):
+    """ Return list of Fields given path relative to model.
+    e.g. (ModelX, "user__groups__name") -> [
+        <django.db.models.fields.related.ForeignKey object at 0x...>,
+        <django.db.models.fields.related.ManyToManyField object at 0x...>,
+        <django.db.models.fields.CharField object at 0x...>,
+    ]
+    """
+    pieces = path.split(LOOKUP_SEP)
+    fields = []
+    for piece in pieces:
+        if fields:
+            parent = get_model_from_relation(fields[-1])
+        else:
+            parent = model
+        fields.append(parent._meta.get_field_by_name(piece)[0])
+    return fields
+def remove_trailing_data_field(fields):
+    """ Discard trailing non-relation field if extant. """
+    try:
+        get_model_from_relation(fields[-1])
+    except NotRelationField:
+        fields = fields[:-1]
+    return fields
+def get_limit_choices_to_from_path(model, path):
+    """ Return Q object for limiting choices if applicable.
+    If final model in path is linked via a ForeignKey or ManyToManyField which
+    has a `limit_choices_to` attribute, return it as a Q object.
+    """
+    fields = get_fields_from_path(model, path)
+    fields = remove_trailing_data_field(fields)
+    limit_choices_to = (
+        fields and hasattr(fields[-1], 'rel') and
+        getattr(fields[-1].rel, 'limit_choices_to', None))
+    if not limit_choices_to:
+        return models.Q() # empty Q
+    elif isinstance(limit_choices_to, models.Q):
+        return limit_choices_to # already a Q
+    else:
+        return models.Q(**limit_choices_to) # convert dict to Q

django/contrib/admin/validation.py

diff --git a/django/contrib/admin/validation.py b/django/contrib/admin/validation.py
index 733f89d..bd99b84 100644

                from django.db.models.fields import FieldDoesNotExist
 from django.forms.models import (BaseModelForm, BaseModelFormSet, fields_for_model,
     _get_foreign_key)
 from django.contrib.admin import ListFilter, FieldListFilter
 from django.contrib.admin.util import get_fields_from_path, NotRelationField
+from django.contrib.admin.utils import get_fields_from_path, NotRelationField
 from django.contrib.admin.options import (flatten_fieldsets, BaseModelAdmin,
     HORIZONTAL, VERTICAL)

django/contrib/admin/views/main.py

diff --git a/django/contrib/admin/views/main.py b/django/contrib/admin/views/main.py
index 56f13f8..e12cca5 100644

                from django.utils.http import urlencode
 from django.contrib.admin import FieldListFilter
 from django.contrib.admin.options import IncorrectLookupParameters
 from django.contrib.admin.util import (quote, get_fields_from_path,
+from django.contrib.admin.utils import (quote, get_fields_from_path,
     lookup_needs_distinct, prepare_lookup_value)
 # Changelist settings

django/contrib/admin/widgets.py

diff --git a/django/contrib/admin/widgets.py b/django/contrib/admin/widgets.py
index 29958b2..148ce1c 100644

                from django import forms
 from django.contrib.admin.templatetags.admin_static import static
 from django.core.urlresolvers import reverse
 from django.forms.widgets import RadioFieldRenderer
 from django.forms.util import flatatt
+from django.forms.utils import flatatt
 from django.utils.html import escape
 from django.utils.text import Truncator
 from django.utils.translation import ugettext as _

django/contrib/auth/admin.py

diff --git a/django/contrib/auth/admin.py b/django/contrib/auth/admin.py
index f14b3d2..973bdb8 100644

                class UserAdmin(admin.ModelAdmin):
         if obj is None:
             defaults.update({
                 'form': self.add_form,
                 'fields': admin.util.flatten_fieldsets(self.add_fieldsets),
+                'fields': admin.utils.flatten_fieldsets(self.add_fieldsets),
             })
         defaults.update(kwargs)
         return super(UserAdmin, self).get_form(request, obj, **defaults)

django/contrib/auth/forms.py

diff --git a/django/contrib/auth/forms.py b/django/contrib/auth/forms.py
index badd760..d988ce3 100644

a	b
1	1	from django import forms
2		from django.forms.util import flatatt
	2	from django.forms.utils import flatatt
3	3	from django.template import loader
4	4	from django.utils.encoding import smart_str
5	5	from django.utils.http import int_to_base36

django/contrib/comments/forms.py

diff --git a/django/contrib/comments/forms.py b/django/contrib/comments/forms.py
index 830e24b..88c2e5e 100644

-              a
 import time
 from django import forms
 from django.forms.util import ErrorDict
+from django.forms.utils import ErrorDict
 from django.conf import settings
 from django.contrib.contenttypes.models import ContentType
 from django.contrib.comments.models import Comment

django/contrib/gis/db/backends/oracle/creation.py

diff --git a/django/contrib/gis/db/backends/oracle/creation.py b/django/contrib/gis/db/backends/oracle/creation.py
index 043da91..14f8d4d 100644

a	b
1	1	from django.db.backends.oracle.creation import DatabaseCreation
2		from django.db.backends.util import truncate_name
	2	from django.db.backends.utils import truncate_name
3	3
4	4	class OracleCreation(DatabaseCreation):
5	5

django/contrib/gis/db/backends/oracle/operations.py

diff --git a/django/contrib/gis/db/backends/oracle/operations.py b/django/contrib/gis/db/backends/oracle/operations.py
index a2374bb..97380a3 100644

                from decimal import Decimal
 from django.db.backends.oracle.base import DatabaseOperations
 from django.contrib.gis.db.backends.base import BaseSpatialOperations
 from django.contrib.gis.db.backends.oracle.adapter import OracleSpatialAdapter
 from django.contrib.gis.db.backends.util import SpatialFunction
+from django.contrib.gis.db.backends.utils import SpatialFunction
 from django.contrib.gis.geometry.backend import Geometry
 from django.contrib.gis.measure import Distance

django/contrib/gis/db/backends/postgis/operations.py

diff --git a/django/contrib/gis/db/backends/postgis/operations.py b/django/contrib/gis/db/backends/postgis/operations.py
index 3286748..31e659c 100644

                from decimal import Decimal
 from django.conf import settings
 from django.contrib.gis.db.backends.base import BaseSpatialOperations
 from django.contrib.gis.db.backends.util import SpatialOperation, SpatialFunction
+from django.contrib.gis.db.backends.utils import SpatialOperation, SpatialFunction
 from django.contrib.gis.db.backends.postgis.adapter import PostGISAdapter
 from django.contrib.gis.geometry.backend import Geometry
 from django.contrib.gis.measure import Distance

django/contrib/gis/db/backends/spatialite/operations.py

diff --git a/django/contrib/gis/db/backends/spatialite/operations.py b/django/contrib/gis/db/backends/spatialite/operations.py
index a0efb99..6dacff0 100644

                import re
 from decimal import Decimal
 from django.contrib.gis.db.backends.base import BaseSpatialOperations
 from django.contrib.gis.db.backends.util import SpatialOperation, SpatialFunction
+from django.contrib.gis.db.backends.utils import SpatialOperation, SpatialFunction
 from django.contrib.gis.db.backends.spatialite.adapter import SpatiaLiteAdapter
 from django.contrib.gis.geometry.backend import Geometry
 from django.contrib.gis.measure import Distance

django/contrib/gis/db/backends/util.py

diff --git a/django/contrib/gis/db/backends/util.py b/django/contrib/gis/db/backends/util.py
index b50c8e2..3b52c38 100644

-              a
+"""
+A collection of utility routines and classes used by the spatial
+backends.
+"""
+import warnings
+def gqn(val):
+    """
+    The geographic quote name function; used for quoting tables and
+    geometries (they use single rather than the double quotes of the
+    backend quotename function).
+    """
+    if isinstance(val, basestring):
+        if isinstance(val, unicode): val = val.encode('ascii')
+        return "'%s'" % val
+    else:
+        return str(val)
+warnings.warn("The django.contrib.gis.db.util module has been renamed "
+              "(https://code.djangoproject.com/ticket/17627/). "
+              "Use django.contrib.gis.db.utils instead.", PendingDeprecationWarning)
+class SpatialOperation(object):
+    """
+    Base class for generating spatial SQL.
+    """
+    sql_template = '%(geo_col)s %(operator)s %(geometry)s'
+    def __init__(self, function='', operator='', result='', **kwargs):
+        self.function = function
+        self.operator = operator
+        self.result = result
+        self.extra = kwargs
+    def as_sql(self, geo_col, geometry='%s'):
+        return self.sql_template % self.params(geo_col, geometry)
+    def params(self, geo_col, geometry):
+        params = {'function' : self.function,
+                  'geo_col' : geo_col,
+                  'geometry' : geometry,
+                  'operator' : self.operator,
+                  'result' : self.result,
+                  }
+        params.update(self.extra)
+        return params
+class SpatialFunction(SpatialOperation):
+    """
+    Base class for generating spatial SQL related to a function.
+    """
+    sql_template = '%(function)s(%(geo_col)s, %(geometry)s)'
+    def __init__(self, func, result='', operator='', **kwargs):
+        # Getting the function prefix.
+        default = {'function' : func,
+                   'operator' : operator,
+                   'result' : result
+                   }
+        kwargs.update(default)
+        super(SpatialFunction, self).__init__(**kwargs)
+from django.contrib.gis.db.utils import *

new file django/contrib/gis/db/backends/utils.py

diff --git a/django/contrib/gis/db/backends/utils.py b/django/contrib/gis/db/backends/utils.py
new file mode 100644
index 0000000..b50c8e2

-              -
+"""
+A collection of utility routines and classes used by the spatial
+backends.
+"""
+def gqn(val):
+    """
+    The geographic quote name function; used for quoting tables and
+    geometries (they use single rather than the double quotes of the
+    backend quotename function).
+    """
+    if isinstance(val, basestring):
+        if isinstance(val, unicode): val = val.encode('ascii')
+        return "'%s'" % val
+    else:
+        return str(val)
+class SpatialOperation(object):
+    """
+    Base class for generating spatial SQL.
+    """
+    sql_template = '%(geo_col)s %(operator)s %(geometry)s'
+    def __init__(self, function='', operator='', result='', **kwargs):
+        self.function = function
+        self.operator = operator
+        self.result = result
+        self.extra = kwargs
+    def as_sql(self, geo_col, geometry='%s'):
+        return self.sql_template % self.params(geo_col, geometry)
+    def params(self, geo_col, geometry):
+        params = {'function' : self.function,
+                  'geo_col' : geo_col,
+                  'geometry' : geometry,
+                  'operator' : self.operator,
+                  'result' : self.result,
+                  }
+        params.update(self.extra)
+        return params
+class SpatialFunction(SpatialOperation):
+    """
+    Base class for generating spatial SQL related to a function.
+    """
+    sql_template = '%(function)s(%(geo_col)s, %(geometry)s)'
+    def __init__(self, func, result='', operator='', **kwargs):
+        # Getting the function prefix.
+        default = {'function' : func,
+                   'operator' : operator,
+                   'result' : result
+                   }
+        kwargs.update(default)
+        super(SpatialFunction, self).__init__(**kwargs)

django/contrib/gis/db/models/sql/compiler.py

diff --git a/django/contrib/gis/db/models/sql/compiler.py b/django/contrib/gis/db/models/sql/compiler.py
index 07eea32..a387fb6 100644

a	b
1	1	from itertools import izip
2		from django.db.backends.util import truncate_name, typecast_timestamp
	2	from django.db.backends.utils import truncate_name, typecast_timestamp
3	3	from django.db.models.sql import compiler
4	4	from django.db.models.sql.constants import TABLE_NAME, MULTI
5	5

django/contrib/localflavor/it/forms.py

diff --git a/django/contrib/localflavor/it/forms.py b/django/contrib/localflavor/it/forms.py
index 0060b48..a7dd5cd 100644

                import re
 from django.contrib.localflavor.it.it_province import PROVINCE_CHOICES
 from django.contrib.localflavor.it.it_region import REGION_CHOICES
 from django.contrib.localflavor.it.util import ssn_check_digit, vat_number_check_digit
+from django.contrib.localflavor.it.utils import ssn_check_digit, vat_number_check_digit
 from django.core.validators import EMPTY_VALUES
 from django.forms import ValidationError
 from django.forms.fields import Field, RegexField, Select

django/contrib/localflavor/it/util.py

diff --git a/django/contrib/localflavor/it/util.py b/django/contrib/localflavor/it/util.py
index c162ff7..8abd1bd 100644

-              a
+from django.utils.encoding import smart_str, smart_unicode
+import warnings
+def ssn_check_digit(value):
+    "Calculate Italian social security number check digit."
+    ssn_even_chars = {
+        '0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8,
+        '9': 9, 'A': 0, 'B': 1, 'C': 2, 'D': 3, 'E': 4, 'F': 5, 'G': 6, 'H': 7,
+        'I': 8, 'J': 9, 'K': 10, 'L': 11, 'M': 12, 'N': 13, 'O': 14, 'P': 15,
+        'Q': 16, 'R': 17, 'S': 18, 'T': 19, 'U': 20, 'V': 21, 'W': 22, 'X': 23,
+        'Y': 24, 'Z': 25
+    }
+    ssn_odd_chars = {
+        '0': 1, '1': 0, '2': 5, '3': 7, '4': 9, '5': 13, '6': 15, '7': 17, '8':
+, '9': 21, 'A': 1, 'B': 0, 'C': 5, 'D': 7, 'E': 9, 'F': 13, 'G': 15,
+        'H': 17, 'I': 19, 'J': 21, 'K': 2, 'L': 4, 'M': 18, 'N': 20, 'O': 11,
+        'P': 3, 'Q': 6, 'R': 8, 'S': 12, 'T': 14, 'U': 16, 'V': 10, 'W': 22,
+        'X': 25, 'Y': 24, 'Z': 23
+    }
+    # Chars from 'A' to 'Z'
+    ssn_check_digits = [chr(x) for x in range(65, 91)]
+warnings.warn("The django.contrib.localflavor.it.util module has been renamed "
+              "(https://code.djangoproject.com/ticket/17627/). "
+              "Use django.contrib.localflavor.it.utils instead.", PendingDeprecationWarning)
+    ssn = value.upper()
+    total = 0
+    for i in range(0, 15):
+        try:
+            if i % 2 == 0:
+                total += ssn_odd_chars[ssn[i]]
+            else:
+                total += ssn_even_chars[ssn[i]]
+        except KeyError:
+            msg = "Character '%(char)s' is not allowed." % {'char': ssn[i]}
+            raise ValueError(msg)
+    return ssn_check_digits[total % 26]
+def vat_number_check_digit(vat_number):
+    "Calculate Italian VAT number check digit."
+    normalized_vat_number = smart_str(vat_number).zfill(10)
+    total = 0
+    for i in range(0, 10, 2):
+        total += int(normalized_vat_number[i])
+    for i in range(1, 11, 2):
+        quotient , remainder = divmod(int(normalized_vat_number[i]) * 2, 10)
+        total += quotient + remainder
+    return smart_unicode((10 - total % 10) % 10)
+from django.contrib.localflavor.it.utils import *

new file django/contrib/localflavor/it/utils.py

diff --git a/django/contrib/localflavor/it/utils.py b/django/contrib/localflavor/it/utils.py
new file mode 100644
index 0000000..c162ff7

-              -
+from django.utils.encoding import smart_str, smart_unicode
+def ssn_check_digit(value):
+    "Calculate Italian social security number check digit."
+    ssn_even_chars = {
+        '0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8,
+        '9': 9, 'A': 0, 'B': 1, 'C': 2, 'D': 3, 'E': 4, 'F': 5, 'G': 6, 'H': 7,
+        'I': 8, 'J': 9, 'K': 10, 'L': 11, 'M': 12, 'N': 13, 'O': 14, 'P': 15,
+        'Q': 16, 'R': 17, 'S': 18, 'T': 19, 'U': 20, 'V': 21, 'W': 22, 'X': 23,
+        'Y': 24, 'Z': 25
+    }
+    ssn_odd_chars = {
+        '0': 1, '1': 0, '2': 5, '3': 7, '4': 9, '5': 13, '6': 15, '7': 17, '8':
+, '9': 21, 'A': 1, 'B': 0, 'C': 5, 'D': 7, 'E': 9, 'F': 13, 'G': 15,
+        'H': 17, 'I': 19, 'J': 21, 'K': 2, 'L': 4, 'M': 18, 'N': 20, 'O': 11,
+        'P': 3, 'Q': 6, 'R': 8, 'S': 12, 'T': 14, 'U': 16, 'V': 10, 'W': 22,
+        'X': 25, 'Y': 24, 'Z': 23
+    }
+    # Chars from 'A' to 'Z'
+    ssn_check_digits = [chr(x) for x in range(65, 91)]
+    ssn = value.upper()
+    total = 0
+    for i in range(0, 15):
+        try:
+            if i % 2 == 0:
+                total += ssn_odd_chars[ssn[i]]
+            else:
+                total += ssn_even_chars[ssn[i]]
+        except KeyError:
+            msg = "Character '%(char)s' is not allowed." % {'char': ssn[i]}
+            raise ValueError(msg)
+    return ssn_check_digits[total % 26]
+def vat_number_check_digit(vat_number):
+    "Calculate Italian VAT number check digit."
+    normalized_vat_number = smart_str(vat_number).zfill(10)
+    total = 0
+    for i in range(0, 10, 2):
+        total += int(normalized_vat_number[i])
+    for i in range(1, 11, 2):
+        quotient , remainder = divmod(int(normalized_vat_number[i]) * 2, 10)
+        total += quotient + remainder
+    return smart_unicode((10 - total % 10) % 10)

django/contrib/localflavor/uy/forms.py

diff --git a/django/contrib/localflavor/uy/forms.py b/django/contrib/localflavor/uy/forms.py
index 2112162..6107667 100644

                from django.core.validators import EMPTY_VALUES
 from django.forms.fields import Select, RegexField
 from django.forms import ValidationError
 from django.utils.translation import ugettext_lazy as _
 from django.contrib.localflavor.uy.util import get_validation_digit
+from django.contrib.localflavor.uy.utils import get_validation_digit
 class UYDepartamentSelect(Select):

django/contrib/localflavor/uy/util.py

diff --git a/django/contrib/localflavor/uy/util.py b/django/contrib/localflavor/uy/util.py
index 0c1a8f8..95598ad 100644

-              a
+# -*- coding: utf-8 -*-
+import warnings
+def get_validation_digit(number):
+    """ Calculates the validation digit for the given number. """
+    sum = 0
+    dvs = [4, 3, 6, 7, 8, 9, 2]
+    number = str(number)
+warnings.warn("The django.contrib.localflavor.uy.util module has been renamed "
+              "(https://code.djangoproject.com/ticket/17627/). "
+              "Use django.contrib.localflavor.uy.utils instead.", PendingDeprecationWarning)
+    for i in range(0, len(number)):
+        sum = (int(number[-1 - i]) * dvs[i] + sum) % 10
+    return (10-sum) % 10
+from django.contrib.localflavor.uy.utils import *

new file django/contrib/localflavor/uy/utils.py

diff --git a/django/contrib/localflavor/uy/utils.py b/django/contrib/localflavor/uy/utils.py
new file mode 100644
index 0000000..0c1a8f8

-              -
+# -*- coding: utf-8 -*-
+def get_validation_digit(number):
+    """ Calculates the validation digit for the given number. """
+    sum = 0
+    dvs = [4, 3, 6, 7, 8, 9, 2]
+    number = str(number)
+    for i in range(0, len(number)):
+        sum = (int(number[-1 - i]) * dvs[i] + sum) % 10
+    return (10-sum) % 10

django/db/backends/init.py

diff --git a/django/db/backends/__init__.py b/django/db/backends/__init__.py
index 7674f5c..37985e8 100644

                from contextlib import contextmanager
 from django.conf import settings
 from django.db import DEFAULT_DB_ALIAS
 from django.db.backends import util
+from django.db.backends import utils
 from django.db.transaction import TransactionManagementError
 from django.utils.importlib import import_module
 from django.utils.timezone import is_aware
-…
+               class BaseDatabaseWrapper(object):
             (self.use_debug_cursor is None and settings.DEBUG)):
             cursor = self.make_debug_cursor(self._cursor())
         else:
             cursor = util.CursorWrapper(self._cursor(), self)
+            cursor = utils.CursorWrapper(self._cursor(), self)
         return cursor
     def make_debug_cursor(self, cursor):
         return util.CursorDebugWrapper(cursor, self)
+        return utils.CursorDebugWrapper(cursor, self)
 class BaseDatabaseFeatures(object):
     allows_group_by_pk = False
-…
+               class BaseDatabaseOperations(object):
         """
         if value is None:
             return None
         return util.format_number(value, max_digits, decimal_places)
+        return utils.format_number(value, max_digits, decimal_places)
     def year_lookup_bounds(self, value):
         """

django/db/backends/creation.py

diff --git a/django/db/backends/creation.py b/django/db/backends/creation.py
index 0cd0558..e845abd 100644

                class BaseDatabaseCreation(object):
         """
         Returns any ALTER TABLE statements to add constraints after the fact.
         """
         from django.db.backends.util import truncate_name
+        from django.db.backends.utils import truncate_name
         if not model._meta.managed or model._meta.proxy:
             return []
-…
+               class BaseDatabaseCreation(object):
         """
         Return the CREATE INDEX SQL statements for a single model field.
         """
         from django.db.backends.util import truncate_name
+        from django.db.backends.utils import truncate_name
         if f.db_index and not f.unique:
             qn = self.connection.ops.quote_name
-…
+               class BaseDatabaseCreation(object):
         return output
     def sql_remove_table_constraints(self, model, references_to_delete, style):
         from django.db.backends.util import truncate_name
+        from django.db.backends.utils import truncate_name
         if not model._meta.managed or model._meta.proxy:
             return []
         output = []

django/db/backends/dummy/base.py

diff --git a/django/db/backends/dummy/base.py b/django/db/backends/dummy/base.py
index 746f26b..2800288 100644

                ImproperlyConfigured.
 """
 from django.core.exceptions import ImproperlyConfigured
 from django.db.backends import *
+from django.db.backends import BaseDatabaseFeatures, BaseDatabaseOperations, BaseDatabaseWrapper, BaseDatabaseValidation
 from django.db.backends.creation import BaseDatabaseCreation
 def complain(*args, **kwargs):

django/db/backends/mysql/base.py

diff --git a/django/db/backends/mysql/base.py b/django/db/backends/mysql/base.py
index e30cb90..830103f 100644

                if (version < (1,2,1) or (version[:3] == (1, 2, 1) and
 from MySQLdb.converters import conversions, Thing2Literal
 from MySQLdb.constants import FIELD_TYPE, CLIENT
+from django.db.backends import utils as backend_utils, BaseDatabaseFeatures, BaseDatabaseOperations, BaseDatabaseWrapper
 from django.db import utils
-from django.db.backends import *
 from django.db.backends.signals import connection_created
 from django.db.backends.mysql.client import DatabaseClient
 from django.db.backends.mysql.creation import DatabaseCreation
-…
+               def adapt_datetime_with_timezone_support(value, conv):
 # timezone support is active, Django expects timezone-aware datetime objects.
 django_conversions = conversions.copy()
 django_conversions.update({
     FIELD_TYPE.TIME: util.typecast_time,
     FIELD_TYPE.DECIMAL: util.typecast_decimal,
     FIELD_TYPE.NEWDECIMAL: util.typecast_decimal,
+    FIELD_TYPE.TIME: backend_utils.typecast_time,
+    FIELD_TYPE.DECIMAL: backend_utils.typecast_decimal,
+    FIELD_TYPE.NEWDECIMAL: backend_utils.typecast_decimal,
     FIELD_TYPE.DATETIME: parse_datetime_with_timezone_support,
     datetime.datetime: adapt_datetime_with_timezone_support,
 })
-…
+               server_version_re = re.compile(r'(\d{1,2})\.(\d{1,2})\.(\d{1,2})')
 # MySQL-4.1 and newer, so the MysqlDebugWrapper is unnecessary. Since the
 # point is to raise Warnings as exceptions, this can be done with the Python
 # warning module, and this is setup when the connection is created, and the
 # standard util.CursorDebugWrapper can be used. Also, using sql_mode
+# standard backend_utils.CursorDebugWrapper can be used. Also, using sql_mode
 # TRADITIONAL will automatically cause most warnings to be treated as errors.
 class CursorWrapper(object):
-…
+               class DatabaseFeatures(BaseDatabaseFeatures):
         self._storage_engine = None
     def _mysql_storage_engine(self):
         "Internal method used in Django tests. Don't rely on this from your code"
+        """Internal method used in Django tests. Don't rely on this from your code"""
         if self._storage_engine is None:
             cursor = self.connection.cursor()
             cursor.execute('CREATE TABLE INTROSPECT_TEST (X INT)')
-…
+               class DatabaseFeatures(BaseDatabaseFeatures):
         return self._storage_engine
     def _can_introspect_foreign_keys(self):
         "Confirm support for introspected foreign keys"
+        """Confirm support for introspected foreign keys"""
         return self._mysql_storage_engine() != 'MyISAM'
 class DatabaseOperations(BaseDatabaseOperations):

django/db/backends/oracle/base.py

diff --git a/django/db/backends/oracle/base.py b/django/db/backends/oracle/base.py
index 6bc6e1d..8a9f137 100644

                Requires cx_Oracle: http://cx-oracle.sourceforge.net/
 import datetime
 import decimal
 import sys
+import warnings
 def _setup_environment(environ):
-…
+               except ImportError, e:
     from django.core.exceptions import ImproperlyConfigured
     raise ImproperlyConfigured("Error loading cx_Oracle module: %s" % e)
 from django.conf import settings
+from django.db.backends import utils as backend_utils, settings, BaseDatabaseFeatures, BaseDatabaseOperations, BaseDatabaseWrapper, BaseDatabaseValidation
 from django.db import utils
-from django.db.backends import *
 from django.db.backends.signals import connection_created
 from django.db.backends.oracle.client import DatabaseClient
 from django.db.backends.oracle.creation import DatabaseCreation
-…
+               WHEN (new.%(col_name)s IS NULL)
             value = float(value)
         # Convert floats to decimals
         elif value is not None and field and field.get_internal_type() == 'DecimalField':
             value = util.typecast_decimal(field.format_number(value))
+            value = backend_utils.typecast_decimal(field.format_number(value))
         # cx_Oracle always returns datetime.datetime objects for
         # DATE and TIMESTAMP columns, but Django wants to see a
         # python datetime.date, .time, or .datetime.  We use the type
-…
+               WHEN (new.%(col_name)s IS NULL)
         # always defaults to uppercase.
         # We simplify things by making Oracle identifiers always uppercase.
         if not name.startswith('"') and not name.endswith('"'):
             name = '"%s"' % util.truncate_name(name.upper(),
+            name = '"%s"' % backend_utils.truncate_name(name.upper(),
                                                self.max_name_length())
         return name.upper()
-…
+               WHEN (new.%(col_name)s IS NULL)
         return [first % value, second % value]
     def combine_expression(self, connector, sub_expressions):
         "Oracle requires special cases for %% and & operators in query expressions"
+        """Oracle requires special cases for %% and & operators in query expressions"""
         if connector == '%%':
             return 'MOD(%s)' % ','.join(sub_expressions)
         elif connector == '&':
-…
+               WHEN (new.%(col_name)s IS NULL)
     def _get_sequence_name(self, table):
         name_length = self.max_name_length() - 3
         return '%s_SQ' % util.truncate_name(table, name_length).upper()
+        return '%s_SQ' % backend_utils.truncate_name(table, name_length).upper()
     def _get_trigger_name(self, table):
         name_length = self.max_name_length() - 3
         return '%s_TR' % util.truncate_name(table, name_length).upper()
+        return '%s_TR' % backend_utils.truncate_name(table, name_length).upper()
     def bulk_insert_sql(self, fields, num_values):
         items_sql = "SELECT %s FROM DUAL" % ", ".join(["%s"] * len(fields))

django/db/backends/postgresql_psycopg2/base.py

diff --git a/django/db/backends/postgresql_psycopg2/base.py b/django/db/backends/postgresql_psycopg2/base.py
index 802ebf2..9b7d647 100644

                Requires psycopg 2: http://initd.org/projects/psycopg2
 """
 import sys
+from django.db.backends import settings, BaseDatabaseFeatures, BaseDatabaseWrapper, BaseDatabaseValidation
 from django.db import utils
-from django.db.backends import *
 from django.db.backends.signals import connection_created
 from django.db.backends.postgresql_psycopg2.operations import DatabaseOperations
 from django.db.backends.postgresql_psycopg2.client import DatabaseClient

django/db/backends/postgresql_psycopg2/creation.py

diff --git a/django/db/backends/postgresql_psycopg2/creation.py b/django/db/backends/postgresql_psycopg2/creation.py
index ca389b9..75db89a 100644

-              a
 import psycopg2.extensions
 from django.db.backends.creation import BaseDatabaseCreation
 from django.db.backends.util import truncate_name
+from django.db.backends.utils import truncate_name
 class DatabaseCreation(BaseDatabaseCreation):

django/db/backends/sqlite3/base.py

diff --git a/django/db/backends/sqlite3/base.py b/django/db/backends/sqlite3/base.py
index 0b19442..0d93fc7 100644

                import warnings
 import re
 import sys
+from django.db import utils
+from django.db.backends import *
+from django.db.backends import utils as backend_utils, settings, BaseDatabaseFeatures, BaseDatabaseOperations, BaseDatabaseWrapper, BaseDatabaseValidation
 from django.db.backends.signals import connection_created
 from django.db.backends.sqlite3.client import DatabaseClient
 from django.db.backends.sqlite3.creation import DatabaseCreation
 from django.db.backends.sqlite3.introspection import DatabaseIntrospection
+from django.db import utils
 from django.utils.dateparse import parse_date, parse_datetime, parse_time
 from django.utils.safestring import SafeString
 from django.utils import timezone
-…
+               Database.register_converter("date", parse_date)
 Database.register_converter("datetime", parse_datetime_with_timezone_support)
 Database.register_converter("timestamp", parse_datetime_with_timezone_support)
 Database.register_converter("TIMESTAMP", parse_datetime_with_timezone_support)
 Database.register_converter("decimal", util.typecast_decimal)
+Database.register_converter("decimal", backend_utils.typecast_decimal)
 Database.register_adapter(datetime.datetime, adapt_datetime_with_timezone_support)
 Database.register_adapter(decimal.Decimal, util.rev_typecast_decimal)
+Database.register_adapter(decimal.Decimal, backend_utils.rev_typecast_decimal)
 if Database.version_info >= (2, 4, 1):
     # Starting in 2.4.1, the str type is not accepted anymore, therefore,
     # we convert all str objects to Unicode
-…
+               class DatabaseOperations(BaseDatabaseOperations):
         """
         internal_type = field.get_internal_type()
         if internal_type == 'DecimalField':
             return util.typecast_decimal(field.format_number(value))
+            return backend_utils.typecast_decimal(field.format_number(value))
         elif internal_type and internal_type.endswith('IntegerField') or internal_type == 'AutoField':
             return int(value)
         elif internal_type == 'DateField':
-…
+               def _sqlite_extract(lookup_type, dt):
     if dt is None:
         return None
     try:
         dt = util.typecast_timestamp(dt)
+        dt = backend_utils.typecast_timestamp(dt)
     except (ValueError, TypeError):
         return None
     if lookup_type == 'week_day':
-…
+               def _sqlite_extract(lookup_type, dt):
 def _sqlite_date_trunc(lookup_type, dt):
     try:
         dt = util.typecast_timestamp(dt)
+        dt = backend_utils.typecast_timestamp(dt)
     except (ValueError, TypeError):
         return None
     if lookup_type == 'year':
-…
+               def _sqlite_date_trunc(lookup_type, dt):
 def _sqlite_format_dtdelta(dt, conn, days, secs, usecs):
     try:
         dt = util.typecast_timestamp(dt)
+        dt = backend_utils.typecast_timestamp(dt)
         delta = datetime.timedelta(int(days), int(secs), int(usecs))
         if conn.strip() == '+':
             dt = dt + delta

django/db/backends/util.py

diff --git a/django/db/backends/util.py b/django/db/backends/util.py
index 32e0f4f..c6f3785 100644

-              a
+import datetime
+import decimal
+import hashlib
+from time import time
+import warnings
+from django.conf import settings
+from django.utils.log import getLogger
+from django.utils.timezone import utc
+warnings.warn("The django.db.backends.util module has been renamed "
+              "(https://code.djangoproject.com/ticket/17627/). "
+              "Use django.db.backends.utils instead.", PendingDeprecationWarning)
+logger = getLogger('django.db.backends')
+class CursorWrapper(object):
+    def __init__(self, cursor, db):
+        self.cursor = cursor
+        self.db = db
+    def set_dirty(self):
+        if self.db.is_managed():
+            self.db.set_dirty()
+    def __getattr__(self, attr):
+        self.set_dirty()
+        if attr in self.__dict__:
+            return self.__dict__[attr]
+        else:
+            return getattr(self.cursor, attr)
+    def __iter__(self):
+        return iter(self.cursor)
+class CursorDebugWrapper(CursorWrapper):
+    def execute(self, sql, params=()):
+        self.set_dirty()
+        start = time()
+        try:
+            return self.cursor.execute(sql, params)
+        finally:
+            stop = time()
+            duration = stop - start
+            sql = self.db.ops.last_executed_query(self.cursor, sql, params)
+            self.db.queries.append({
+                'sql': sql,
+                'time': "%.3f" % duration,
+            })
+            logger.debug('(%.3f) %s; args=%s' % (duration, sql, params),
+                extra={'duration': duration, 'sql': sql, 'params': params}
+            )
+    def executemany(self, sql, param_list):
+        self.set_dirty()
+        start = time()
+        try:
+            return self.cursor.executemany(sql, param_list)
+        finally:
+            stop = time()
+            duration = stop - start
+            try:
+                times = len(param_list)
+            except TypeError:           # param_list could be an iterator
+                times = '?'
+            self.db.queries.append({
+                'sql': '%s times: %s' % (times, sql),
+                'time': "%.3f" % duration,
+            })
+            logger.debug('(%.3f) %s; args=%s' % (duration, sql, param_list),
+                extra={'duration': duration, 'sql': sql, 'params': param_list}
+            )
+###############################################
+# Converters from database (string) to Python #
+###############################################
+def typecast_date(s):
+    return s and datetime.date(*map(int, s.split('-'))) or None # returns None if s is null
+def typecast_time(s): # does NOT store time zone information
+    if not s: return None
+    hour, minutes, seconds = s.split(':')
+    if '.' in seconds: # check whether seconds have a fractional part
+        seconds, microseconds = seconds.split('.')
+    else:
+        microseconds = '0'
+    return datetime.time(int(hour), int(minutes), int(seconds), int(float('.'+microseconds) * 1000000))
+def typecast_timestamp(s): # does NOT store time zone information
+    # "2005-07-29 15:48:00.590358-05"
+    # "2005-07-29 09:56:00-05"
+    if not s: return None
+    if not ' ' in s: return typecast_date(s)
+    d, t = s.split()
+    # Extract timezone information, if it exists. Currently we just throw
+    # it away, but in the future we may make use of it.
+    if '-' in t:
+        t, tz = t.split('-', 1)
+        tz = '-' + tz
+    elif '+' in t:
+        t, tz = t.split('+', 1)
+        tz = '+' + tz
+    else:
+        tz = ''
+    dates = d.split('-')
+    times = t.split(':')
+    seconds = times[2]
+    if '.' in seconds: # check whether seconds have a fractional part
+        seconds, microseconds = seconds.split('.')
+    else:
+        microseconds = '0'
+    tzinfo = utc if settings.USE_TZ else None
+    return datetime.datetime(int(dates[0]), int(dates[1]), int(dates[2]),
+        int(times[0]), int(times[1]), int(seconds),
+        int((microseconds + '000000')[:6]), tzinfo)
+def typecast_decimal(s):
+    if s is None or s == '':
+        return None
+    return decimal.Decimal(s)
+###############################################
+# Converters from Python to database (string) #
+###############################################
+def rev_typecast_decimal(d):
+    if d is None:
+        return None
+    return str(d)
+def truncate_name(name, length=None, hash_len=4):
+    """Shortens a string to a repeatable mangled version with the given length.
+    """
+    if length is None or len(name) <= length:
+        return name
+    hsh = hashlib.md5(name).hexdigest()[:hash_len]
+    return '%s%s' % (name[:length-hash_len], hsh)
+def format_number(value, max_digits, decimal_places):
+    """
+    Formats a number into a string with the requisite number of digits and
+    decimal places.
+    """
+    if isinstance(value, decimal.Decimal):
+        context = decimal.getcontext().copy()
+        context.prec = max_digits
+        return u'%s' % str(value.quantize(decimal.Decimal(".1") ** decimal_places, context=context))
+    else:
+        return u"%.*f" % (decimal_places, value)
+from django.db.backends.utils import *

new file django/db/backends/utils.py

diff --git a/django/db/backends/utils.py b/django/db/backends/utils.py
new file mode 100644
index 0000000..32e0f4f

-              -
+import datetime
+import decimal
+import hashlib
+from time import time
+from django.conf import settings
+from django.utils.log import getLogger
+from django.utils.timezone import utc
+logger = getLogger('django.db.backends')
+class CursorWrapper(object):
+    def __init__(self, cursor, db):
+        self.cursor = cursor
+        self.db = db
+    def set_dirty(self):
+        if self.db.is_managed():
+            self.db.set_dirty()
+    def __getattr__(self, attr):
+        self.set_dirty()
+        if attr in self.__dict__:
+            return self.__dict__[attr]
+        else:
+            return getattr(self.cursor, attr)
+    def __iter__(self):
+        return iter(self.cursor)
+class CursorDebugWrapper(CursorWrapper):
+    def execute(self, sql, params=()):
+        self.set_dirty()
+        start = time()
+        try:
+            return self.cursor.execute(sql, params)
+        finally:
+            stop = time()
+            duration = stop - start
+            sql = self.db.ops.last_executed_query(self.cursor, sql, params)
+            self.db.queries.append({
+                'sql': sql,
+                'time': "%.3f" % duration,
+            })
+            logger.debug('(%.3f) %s; args=%s' % (duration, sql, params),
+                extra={'duration': duration, 'sql': sql, 'params': params}
+            )
+    def executemany(self, sql, param_list):
+        self.set_dirty()
+        start = time()
+        try:
+            return self.cursor.executemany(sql, param_list)
+        finally:
+            stop = time()
+            duration = stop - start
+            try:
+                times = len(param_list)
+            except TypeError:           # param_list could be an iterator
+                times = '?'
+            self.db.queries.append({
+                'sql': '%s times: %s' % (times, sql),
+                'time': "%.3f" % duration,
+            })
+            logger.debug('(%.3f) %s; args=%s' % (duration, sql, param_list),
+                extra={'duration': duration, 'sql': sql, 'params': param_list}
+            )
+###############################################
+# Converters from database (string) to Python #
+###############################################
+def typecast_date(s):
+    return s and datetime.date(*map(int, s.split('-'))) or None # returns None if s is null
+def typecast_time(s): # does NOT store time zone information
+    if not s: return None
+    hour, minutes, seconds = s.split(':')
+    if '.' in seconds: # check whether seconds have a fractional part
+        seconds, microseconds = seconds.split('.')
+    else:
+        microseconds = '0'
+    return datetime.time(int(hour), int(minutes), int(seconds), int(float('.'+microseconds) * 1000000))
+def typecast_timestamp(s): # does NOT store time zone information
+    # "2005-07-29 15:48:00.590358-05"
+    # "2005-07-29 09:56:00-05"
+    if not s: return None
+    if not ' ' in s: return typecast_date(s)
+    d, t = s.split()
+    # Extract timezone information, if it exists. Currently we just throw
+    # it away, but in the future we may make use of it.
+    if '-' in t:
+        t, tz = t.split('-', 1)
+        tz = '-' + tz
+    elif '+' in t:
+        t, tz = t.split('+', 1)
+        tz = '+' + tz
+    else:
+        tz = ''
+    dates = d.split('-')
+    times = t.split(':')
+    seconds = times[2]
+    if '.' in seconds: # check whether seconds have a fractional part
+        seconds, microseconds = seconds.split('.')
+    else:
+        microseconds = '0'
+    tzinfo = utc if settings.USE_TZ else None
+    return datetime.datetime(int(dates[0]), int(dates[1]), int(dates[2]),
+        int(times[0]), int(times[1]), int(seconds),
+        int((microseconds + '000000')[:6]), tzinfo)
+def typecast_decimal(s):
+    if s is None or s == '':
+        return None
+    return decimal.Decimal(s)
+###############################################
+# Converters from Python to database (string) #
+###############################################
+def rev_typecast_decimal(d):
+    if d is None:
+        return None
+    return str(d)
+def truncate_name(name, length=None, hash_len=4):
+    """Shortens a string to a repeatable mangled version with the given length.
+    """
+    if length is None or len(name) <= length:
+        return name
+    hsh = hashlib.md5(name).hexdigest()[:hash_len]
+    return '%s%s' % (name[:length-hash_len], hsh)
+def format_number(value, max_digits, decimal_places):
+    """
+    Formats a number into a string with the requisite number of digits and
+    decimal places.
+    """
+    if isinstance(value, decimal.Decimal):
+        context = decimal.getcontext().copy()
+        context.prec = max_digits
+        return u'%s' % str(value.quantize(decimal.Decimal(".1") ** decimal_places, context=context))
+    else:
+        return u"%.*f" % (decimal_places, value)

django/db/models/fields/init.py

diff --git a/django/db/models/fields/__init__.py b/django/db/models/fields/__init__.py
index 22546c2..debdacf 100644

                class DecimalField(Field):
         Formats a number into a string with the requisite number of digits and
         decimal places.
         """
         # Method moved to django.db.backends.util.
+        # Method moved to django.db.backends.utils.
+        #
         # It is preserved because it is used by the oracle backend
         # (django.db.backends.oracle.query), and also for
         # backwards-compatibility with any external code which may have used
         # this method.
         from django.db.backends import util
         return util.format_number(value, self.max_digits, self.decimal_places)
+        from django.db.backends import utils
+        return utils.format_number(value, self.max_digits, self.decimal_places)
     def get_db_prep_save(self, value, connection):
         return connection.ops.value_to_db_decimal(self.to_python(value),

django/db/models/fields/related.py

diff --git a/django/db/models/fields/related.py b/django/db/models/fields/related.py
index e23c7dc..ab0c74e 100644

-              a
 from operator import attrgetter
 from django.db import connection, router
 from django.db.backends import util
+from django.db.backends import utils
 from django.db.models import signals, get_model
 from django.db.models.fields import (AutoField, Field, IntegerField,
     PositiveIntegerField, PositiveSmallIntegerField, FieldDoesNotExist)
-…
+               class ManyToManyField(RelatedField, Field):
         elif self.db_table:
             return self.db_table
         else:
             return util.truncate_name('%s_%s' % (opts.db_table, self.name),
+            return utils.truncate_name('%s_%s' % (opts.db_table, self.name),
                                       connection.ops.max_name_length())
     def _get_m2m_attr(self, related, attr):

django/db/models/options.py

diff --git a/django/db/models/options.py b/django/db/models/options.py
index e13a496..4bf45d7 100644

                class Options(object):
     def contribute_to_class(self, cls, name):
         from django.db import connection
         from django.db.backends.util import truncate_name
+        from django.db.backends.utils import truncate_name
         cls._meta = self
         self.installed = re.sub('\.models$', '', cls.__module__) in settings.INSTALLED_APPS

django/db/models/query_utils.py

diff --git a/django/db/models/query_utils.py b/django/db/models/query_utils.py
index a56ab5c..8e9d770 100644

                circular import difficulties.
 import weakref
 from django.db.backends import util
+from django.db.backends import utils
 from django.utils import tree
-…
+               def deferred_class_factory(model, attrs):
     # name using the passed in attrs. It's OK to reuse an existing class
     # object if the attrs are identical.
     name = "%s_Deferred_%s" % (model.__name__, '_'.join(sorted(list(attrs))))
     name = util.truncate_name(name, 80, 32)
+    name = utils.truncate_name(name, 80, 32)
     overrides = dict([(attr, DeferredAttribute(attr, model))
             for attr in attrs])

django/db/models/sql/compiler.py

diff --git a/django/db/models/sql/compiler.py b/django/db/models/sql/compiler.py
index 6c516e2..95841cd 100644

                from itertools import izip
 from django.core.exceptions import FieldError
 from django.db import transaction
 from django.db.backends.util import truncate_name
+from django.db.backends.utils import truncate_name
 from django.db.models.query_utils import select_related_descend
 from django.db.models.sql.constants import *
 from django.db.models.sql.datastructures import EmptyResultSet
-…
+               class SQLDateCompiler(SQLCompiler):
             from django.db.models.fields import DateTimeField
             fields = [DateTimeField()]
         else:
             from django.db.backends.util import typecast_timestamp
+            from django.db.backends.utils import typecast_timestamp
             needs_string_cast = self.connection.features.needs_datetime_string_cast
         offset = len(self.query.extra_select)

django/forms/fields.py

diff --git a/django/forms/fields.py b/django/forms/fields.py
index 96ecabf..61f57e0 100644

                except ImportError:
 from django.core import validators
 from django.core.exceptions import ValidationError
 from django.forms.util import ErrorList, from_current_timezone, to_current_timezone
+from django.forms.utils import ErrorList, from_current_timezone, to_current_timezone
 from django.forms.widgets import (TextInput, PasswordInput, HiddenInput,
     MultipleHiddenInput, ClearableFileInput, CheckboxInput, Select,
     NullBooleanSelect, SelectMultiple, DateInput, DateTimeInput, TimeInput,

django/forms/forms.py

diff --git a/django/forms/forms.py b/django/forms/forms.py
index 94eb22d..155ee90 100644

                import copy
 from django.core.exceptions import ValidationError
 from django.forms.fields import Field, FileField
 from django.forms.util import flatatt, ErrorDict, ErrorList
+from django.forms.utils import flatatt, ErrorDict, ErrorList
 from django.forms.widgets import Media, media_property, TextInput, Textarea
 from django.utils.datastructures import SortedDict
 from django.utils.html import conditional_escape

django/forms/formsets.py

diff --git a/django/forms/formsets.py b/django/forms/formsets.py
index dcd2f01..2736ed8 100644

                from __future__ import absolute_import
 from django.core.exceptions import ValidationError
 from django.forms import Form
 from django.forms.fields import IntegerField, BooleanField
 from django.forms.util import ErrorList
+from django.forms.utils import ErrorList
 from django.forms.widgets import Media, HiddenInput
 from django.utils.encoding import StrAndUnicode
 from django.utils.safestring import mark_safe

django/forms/models.py

diff --git a/django/forms/models.py b/django/forms/models.py
index cd8f027..730f3ee 100644

                from django.core.validators import EMPTY_VALUES
 from django.forms.fields import Field, ChoiceField
 from django.forms.forms import BaseForm, get_declared_fields
 from django.forms.formsets import BaseFormSet, formset_factory
 from django.forms.util import ErrorList
+from django.forms.utils import ErrorList
 from django.forms.widgets import (SelectMultiple, HiddenInput,
     MultipleHiddenInput, media_property)
 from django.utils.encoding import smart_unicode, force_unicode

django/forms/util.py

diff --git a/django/forms/util.py b/django/forms/util.py
index 886f08e..6b14b92 100644

-              a
+from django.conf import settings
+from django.utils.html import conditional_escape
+from django.utils.encoding import StrAndUnicode, force_unicode
+from django.utils.safestring import mark_safe
+from django.utils import timezone
+from django.utils.translation import ugettext_lazy as _
+import warnings
+# Import ValidationError so that it can be imported from this
+# module to maintain backwards compatibility.
+from django.core.exceptions import ValidationError
+warnings.warn("The django.forms.util module has been renamed "
+              "(https://code.djangoproject.com/ticket/17627/). "
+              "Use django.forms.utils instead.", PendingDeprecationWarning)
+def flatatt(attrs):
+    """
+    Convert a dictionary of attributes to a single string.
+    The returned string will contain a leading space followed by key="value",
+    XML-style pairs.  It is assumed that the keys do not need to be XML-escaped.
+    If the passed dictionary is empty, then return an empty string.
+    """
+    return u''.join([u' %s="%s"' % (k, conditional_escape(v)) for k, v in attrs.items()])
+class ErrorDict(dict, StrAndUnicode):
+    """
+    A collection of errors that knows how to display itself in various formats.
+    The dictionary keys are the field names, and the values are the errors.
+    """
+    def __unicode__(self):
+        return self.as_ul()
+    def as_ul(self):
+        if not self: return u''
+        return mark_safe(u'<ul class="errorlist">%s</ul>'
+                % ''.join([u'<li>%s%s</li>' % (k, conditional_escape(force_unicode(v)))
+                    for k, v in self.items()]))
+    def as_text(self):
+        return u'\n'.join([u'* %s\n%s' % (k, u'\n'.join([u'  * %s' % force_unicode(i) for i in v])) for k, v in self.items()])
+class ErrorList(list, StrAndUnicode):
+    """
+    A collection of errors that knows how to display itself in various formats.
+    """
+    def __unicode__(self):
+        return self.as_ul()
+    def as_ul(self):
+        if not self: return u''
+        return mark_safe(u'<ul class="errorlist">%s</ul>'
+                % ''.join([u'<li>%s</li>' % conditional_escape(force_unicode(e)) for e in self]))
+    def as_text(self):
+        if not self: return u''
+        return u'\n'.join([u'* %s' % force_unicode(e) for e in self])
+    def __repr__(self):
+        return repr([force_unicode(e) for e in self])
+# Utilities for time zone support in DateTimeField et al.
+def from_current_timezone(value):
+    """
+    When time zone support is enabled, convert naive datetimes
+    entered in the current time zone to aware datetimes.
+    """
+    if settings.USE_TZ and value is not None and timezone.is_naive(value):
+        current_timezone = timezone.get_current_timezone()
+        try:
+            return timezone.make_aware(value, current_timezone)
+        except Exception, e:
+            raise ValidationError(_('%(datetime)s couldn\'t be interpreted '
+                                    'in time zone %(current_timezone)s; it '
+                                    'may be ambiguous or it may not exist.')
+                                  % {'datetime': value,
+                                     'current_timezone': current_timezone})
+    return value
+def to_current_timezone(value):
+    """
+    When time zone support is enabled, convert aware datetimes
+    to naive dateimes in the current time zone for display.
+    """
+    if settings.USE_TZ and value is not None and timezone.is_aware(value):
+        current_timezone = timezone.get_current_timezone()
+        return timezone.make_naive(value, current_timezone)
+    return value
+from django.forms.utils import *

new file django/forms/utils.py

diff --git a/django/forms/utils.py b/django/forms/utils.py
new file mode 100644
index 0000000..886f08e

-              -
+from django.conf import settings
+from django.utils.html import conditional_escape
+from django.utils.encoding import StrAndUnicode, force_unicode
+from django.utils.safestring import mark_safe
+from django.utils import timezone
+from django.utils.translation import ugettext_lazy as _
+# Import ValidationError so that it can be imported from this
+# module to maintain backwards compatibility.
+from django.core.exceptions import ValidationError
+def flatatt(attrs):
+    """
+    Convert a dictionary of attributes to a single string.
+    The returned string will contain a leading space followed by key="value",
+    XML-style pairs.  It is assumed that the keys do not need to be XML-escaped.
+    If the passed dictionary is empty, then return an empty string.
+    """
+    return u''.join([u' %s="%s"' % (k, conditional_escape(v)) for k, v in attrs.items()])
+class ErrorDict(dict, StrAndUnicode):
+    """
+    A collection of errors that knows how to display itself in various formats.
+    The dictionary keys are the field names, and the values are the errors.
+    """
+    def __unicode__(self):
+        return self.as_ul()
+    def as_ul(self):
+        if not self: return u''
+        return mark_safe(u'<ul class="errorlist">%s</ul>'
+                % ''.join([u'<li>%s%s</li>' % (k, conditional_escape(force_unicode(v)))
+                    for k, v in self.items()]))
+    def as_text(self):
+        return u'\n'.join([u'* %s\n%s' % (k, u'\n'.join([u'  * %s' % force_unicode(i) for i in v])) for k, v in self.items()])
+class ErrorList(list, StrAndUnicode):
+    """
+    A collection of errors that knows how to display itself in various formats.
+    """
+    def __unicode__(self):
+        return self.as_ul()
+    def as_ul(self):
+        if not self: return u''
+        return mark_safe(u'<ul class="errorlist">%s</ul>'
+                % ''.join([u'<li>%s</li>' % conditional_escape(force_unicode(e)) for e in self]))
+    def as_text(self):
+        if not self: return u''
+        return u'\n'.join([u'* %s' % force_unicode(e) for e in self])
+    def __repr__(self):
+        return repr([force_unicode(e) for e in self])
+# Utilities for time zone support in DateTimeField et al.
+def from_current_timezone(value):
+    """
+    When time zone support is enabled, convert naive datetimes
+    entered in the current time zone to aware datetimes.
+    """
+    if settings.USE_TZ and value is not None and timezone.is_naive(value):
+        current_timezone = timezone.get_current_timezone()
+        try:
+            return timezone.make_aware(value, current_timezone)
+        except Exception, e:
+            raise ValidationError(_('%(datetime)s couldn\'t be interpreted '
+                                    'in time zone %(current_timezone)s; it '
+                                    'may be ambiguous or it may not exist.')
+                                  % {'datetime': value,
+                                     'current_timezone': current_timezone})
+    return value
+def to_current_timezone(value):
+    """
+    When time zone support is enabled, convert aware datetimes
+    to naive dateimes in the current time zone for display.
+    """
+    if settings.USE_TZ and value is not None and timezone.is_aware(value):
+        current_timezone = timezone.get_current_timezone()
+        return timezone.make_naive(value, current_timezone)
+    return value

django/forms/widgets.py

diff --git a/django/forms/widgets.py b/django/forms/widgets.py
index 1fbef98..74e3043 100644

                from itertools import chain
 from urlparse import urljoin
 from django.conf import settings
 from django.forms.util import flatatt, to_current_timezone
+from django.forms.utils import flatatt, to_current_timezone
 from django.utils.datastructures import MultiValueDict, MergeDict
 from django.utils.html import escape, conditional_escape
 from django.utils.translation import ugettext, ugettext_lazy

docs/internals/deprecation.txt

diff --git a/docs/internals/deprecation.txt b/docs/internals/deprecation.txt
index cb91a1c..f9bfa37 100644

                these changes.
   in 1.4. The backward compatibility will be removed --
   ``HttpRequest.raw_post_data`` will no longer work.
+.7
+---
+* Instances of ``util.py`` in the Django codebase have been renamed to ``utils.py`` in
+  an effort to unify all util and utils references across Django. Compatibility modules
+  for ``django.contrib.admin.util`` (now :mod:`django.contrib.admin.utils`),
+  ``django.contrib.gis.db.backends.util`` (now :mod:`django.contrib.gis.db.backends.utils``),
+  ``django.contrib.localflavor.it.util`` (now :mod:`django.contrib.localflavor.it.utils``),
+  ``django.contrib.localflavor.uy.util`` (now :mod:`django.contrib.localflavor.uy.utils``),
+  ``django.db.backends.util`` (now :mod:`django.db.backends.utils`),
+  and ``django.forms.util`` (now :mod:`django.forms.utils`) will be removed.
 .0
 ---

deleted file tests/regressiontests/admin_util/models.py

diff --git a/tests/regressiontests/admin_util/__init__.py b/tests/regressiontests/admin_util/__init__.py
deleted file mode 100644
index e69de29..0000000
diff --git a/tests/regressiontests/admin_util/models.py b/tests/regressiontests/admin_util/models.py
deleted file mode 100644
index 0e81df3..0000000

-              +
-from django.db import models
-class Article(models.Model):
-    """
-    A simple Article model for testing
-    """
-    site = models.ForeignKey('sites.Site', related_name="admin_articles")
-    title = models.CharField(max_length=100)
-    title2 = models.CharField(max_length=100, verbose_name="another name")
-    created = models.DateTimeField()
-    def test_from_model(self):
-        return "nothing"
-    def test_from_model_with_override(self):
-        return "nothing"
-    test_from_model_with_override.short_description = "not What you Expect"
-class Count(models.Model):
-    num = models.PositiveSmallIntegerField()
-    parent = models.ForeignKey('self', null=True)
-    def __unicode__(self):
-        return unicode(self.num)
-class Event(models.Model):
-    date = models.DateTimeField(auto_now_add=True)
-class Location(models.Model):
-    event = models.OneToOneField(Event, verbose_name='awesome event')
-class Guest(models.Model):
-    event = models.OneToOneField(Event)
-    name = models.CharField(max_length=255)
-    class Meta:
-        verbose_name = "awesome guest"

deleted file tests/regressiontests/admin_util/tests.py

diff --git a/tests/regressiontests/admin_util/tests.py b/tests/regressiontests/admin_util/tests.py
deleted file mode 100644
index 8113f2e..0000000

-              +
-from __future__ import absolute_import
-from datetime import datetime
-from django.conf import settings
-from django.contrib import admin
-from django.contrib.admin import helpers
-from django.contrib.admin.util import (display_for_field, label_for_field,
-    lookup_field, NestedObjects)
-from django.contrib.admin.views.main import EMPTY_CHANGELIST_VALUE
-from django.contrib.sites.models import Site
-from django.db import models, DEFAULT_DB_ALIAS
-from django import forms
-from django.test import TestCase
-from django.utils import unittest
-from django.utils.formats import localize
-from django.utils.safestring import mark_safe
-from .models import Article, Count, Event, Location
-class NestedObjectsTests(TestCase):
-    """
-    Tests for ``NestedObject`` utility collection.
-    """
-    def setUp(self):
-        self.n = NestedObjects(using=DEFAULT_DB_ALIAS)
-        self.objs = [Count.objects.create(num=i) for i in range(5)]
-    def _check(self, target):
-        self.assertEqual(self.n.nested(lambda obj: obj.num), target)
-    def _connect(self, i, j):
-        self.objs[i].parent = self.objs[j]
-        self.objs[i].save()
-    def _collect(self, *indices):
-        self.n.collect([self.objs[i] for i in indices])
-    def test_unrelated_roots(self):
-        self._connect(2, 1)
-        self._collect(0)
-        self._collect(1)
-        self._check([0, 1, [2]])
-    def test_siblings(self):
-        self._connect(1, 0)
-        self._connect(2, 0)
-        self._collect(0)
-        self._check([0, [1, 2]])
-    def test_non_added_parent(self):
-        self._connect(0, 1)
-        self._collect(0)
-        self._check([0])
-    def test_cyclic(self):
-        self._connect(0, 2)
-        self._connect(1, 0)
-        self._connect(2, 1)
-        self._collect(0)
-        self._check([0, [1, [2]]])
-    def test_queries(self):
-        self._connect(1, 0)
-        self._connect(2, 0)
-        # 1 query to fetch all children of 0 (1 and 2)
-        # 1 query to fetch all children of 1 and 2 (none)
-        # Should not require additional queries to populate the nested graph.
-        self.assertNumQueries(2, self._collect, 0)
-class UtilTests(unittest.TestCase):
-    def test_values_from_lookup_field(self):
-        """
-        Regression test for #12654: lookup_field
-        """
-        SITE_NAME = 'example.com'
-        TITLE_TEXT = 'Some title'
-        CREATED_DATE = datetime.min
-        ADMIN_METHOD = 'admin method'
-        SIMPLE_FUNCTION = 'function'
-        INSTANCE_ATTRIBUTE = 'attr'
-        class MockModelAdmin(object):
-            def get_admin_value(self, obj):
-                return ADMIN_METHOD
-        simple_function = lambda obj: SIMPLE_FUNCTION
-        article = Article(
-            site=Site(domain=SITE_NAME),
-            title=TITLE_TEXT,
-            created=CREATED_DATE,
+        )
-        article.non_field = INSTANCE_ATTRIBUTE
-        verifications = (
-            ('site', SITE_NAME),
-            ('created', localize(CREATED_DATE)),
-            ('title', TITLE_TEXT),
-            ('get_admin_value', ADMIN_METHOD),
-            (simple_function, SIMPLE_FUNCTION),
-            ('test_from_model', article.test_from_model()),
-            ('non_field', INSTANCE_ATTRIBUTE)
+        )
-        mock_admin = MockModelAdmin()
-        for name, value in verifications:
-            field, attr, resolved_value = lookup_field(name, article, mock_admin)
-            if field is not None:
-                resolved_value = display_for_field(resolved_value, field)
-            self.assertEqual(value, resolved_value)
-    def test_null_display_for_field(self):
-        """
-        Regression test for #12550: display_for_field should handle None
-        value.
-        """
-        display_value = display_for_field(None, models.CharField())
-        self.assertEqual(display_value, EMPTY_CHANGELIST_VALUE)
-        display_value = display_for_field(None, models.CharField(
-            choices=(
-                (None, "test_none"),
+            )
-        ))
-        self.assertEqual(display_value, "test_none")
-        display_value = display_for_field(None, models.DateField())
-        self.assertEqual(display_value, EMPTY_CHANGELIST_VALUE)
-        display_value = display_for_field(None, models.TimeField())
-        self.assertEqual(display_value, EMPTY_CHANGELIST_VALUE)
-        # Regression test for #13071: NullBooleanField has special
-        # handling.
-        display_value = display_for_field(None, models.NullBooleanField())
-        expected = u'<img src="%sadmin/img/icon-unknown.gif" alt="None" />' % settings.STATIC_URL
-        self.assertEqual(display_value, expected)
-        display_value = display_for_field(None, models.DecimalField())
-        self.assertEqual(display_value, EMPTY_CHANGELIST_VALUE)
-        display_value = display_for_field(None, models.FloatField())
-        self.assertEqual(display_value, EMPTY_CHANGELIST_VALUE)
-    def test_label_for_field(self):
-        """
-        Tests for label_for_field
-        """
-        self.assertEqual(
-            label_for_field("title", Article),
-            "title"
+        )
-        self.assertEqual(
-            label_for_field("title2", Article),
-            "another name"
+        )
-        self.assertEqual(
-            label_for_field("title2", Article, return_attr=True),
-            ("another name", None)
+        )
-        self.assertEqual(
-            label_for_field("__unicode__", Article),
-            "article"
+        )
-        self.assertEqual(
-            label_for_field("__str__", Article),
-            "article"
+        )
-        self.assertRaises(
-            AttributeError,
-            lambda: label_for_field("unknown", Article)
+        )
-        def test_callable(obj):
-            return "nothing"
-        self.assertEqual(
-            label_for_field(test_callable, Article),
-            "Test callable"
+        )
-        self.assertEqual(
-            label_for_field(test_callable, Article, return_attr=True),
-            ("Test callable", test_callable)
+        )
-        self.assertEqual(
-            label_for_field("test_from_model", Article),
-            "Test from model"
+        )
-        self.assertEqual(
-            label_for_field("test_from_model", Article, return_attr=True),
-            ("Test from model", Article.test_from_model)
+        )
-        self.assertEqual(
-            label_for_field("test_from_model_with_override", Article),
-            "not What you Expect"
+        )
-        self.assertEqual(
-            label_for_field(lambda x: "nothing", Article),
-            "--"
+        )
-        class MockModelAdmin(object):
-            def test_from_model(self, obj):
-                return "nothing"
-            test_from_model.short_description = "not Really the Model"
-        self.assertEqual(
-            label_for_field("test_from_model", Article, model_admin=MockModelAdmin),
-            "not Really the Model"
+        )
-        self.assertEqual(
-            label_for_field("test_from_model", Article,
-                model_admin = MockModelAdmin,
-                return_attr = True
-            ),
-            ("not Really the Model", MockModelAdmin.test_from_model)
+        )
-    def test_related_name(self):
-        """
-        Regression test for #13963
-        """
-        self.assertEqual(
-            label_for_field('location', Event, return_attr=True),
-            ('location', None),
+        )
-        self.assertEqual(
-            label_for_field('event', Location, return_attr=True),
-            ('awesome event', None),
+        )
-        self.assertEqual(
-            label_for_field('guest', Event, return_attr=True),
-            ('awesome guest', None),
+        )
-    def test_logentry_unicode(self):
-        """
-        Regression test for #15661
-        """
-        log_entry = admin.models.LogEntry()
-        log_entry.action_flag = admin.models.ADDITION
-        self.assertTrue(
-            unicode(log_entry).startswith('Added ')
+        )
-        log_entry.action_flag = admin.models.CHANGE
-        self.assertTrue(
-            unicode(log_entry).startswith('Changed ')
+        )
-        log_entry.action_flag = admin.models.DELETION
-        self.assertTrue(
-            unicode(log_entry).startswith('Deleted ')
+        )
-    def test_safestring_in_field_label(self):
-        # safestring should not be escaped
-        class MyForm(forms.Form):
-            text = forms.CharField(label=mark_safe('<i>text</i>'))
-            cb   = forms.BooleanField(label=mark_safe('<i>cb</i>'))
-        form = MyForm()
-        self.assertEqual(helpers.AdminField(form, 'text', is_first=False).label_tag(),
-                         '<label for="id_text" class="required inline"><i>text</i>:</label>')
-        self.assertEqual(helpers.AdminField(form, 'cb', is_first=False).label_tag(),
-                         '<label for="id_cb" class="vCheckboxLabel required inline"><i>cb</i></label>')
-        # normal strings needs to be escaped
-        class MyForm(forms.Form):
-            text = forms.CharField(label='&text')
-            cb   = forms.BooleanField(label='&cb')
-        form = MyForm()
-        self.assertEqual(helpers.AdminField(form, 'text', is_first=False).label_tag(),
-                         '<label for="id_text" class="required inline">&amp;text:</label>')
-        self.assertEqual(helpers.AdminField(form, 'cb', is_first=False).label_tag(),
-                         '<label for="id_cb" class="vCheckboxLabel required inline">&amp;cb</label>')

new file tests/regressiontests/admin_utils/models.py

diff --git a/tests/regressiontests/admin_utils/__init__.py b/tests/regressiontests/admin_utils/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/tests/regressiontests/admin_utils/models.py b/tests/regressiontests/admin_utils/models.py
new file mode 100644
index 0000000..0e81df3

-              -
+from django.db import models
+class Article(models.Model):
+    """
+    A simple Article model for testing
+    """
+    site = models.ForeignKey('sites.Site', related_name="admin_articles")
+    title = models.CharField(max_length=100)
+    title2 = models.CharField(max_length=100, verbose_name="another name")
+    created = models.DateTimeField()
+    def test_from_model(self):
+        return "nothing"
+    def test_from_model_with_override(self):
+        return "nothing"
+    test_from_model_with_override.short_description = "not What you Expect"
+class Count(models.Model):
+    num = models.PositiveSmallIntegerField()
+    parent = models.ForeignKey('self', null=True)
+    def __unicode__(self):
+        return unicode(self.num)
+class Event(models.Model):
+    date = models.DateTimeField(auto_now_add=True)
+class Location(models.Model):
+    event = models.OneToOneField(Event, verbose_name='awesome event')
+class Guest(models.Model):
+    event = models.OneToOneField(Event)
+    name = models.CharField(max_length=255)
+    class Meta:
+        verbose_name = "awesome guest"

new file tests/regressiontests/admin_utils/tests.py

diff --git a/tests/regressiontests/admin_utils/tests.py b/tests/regressiontests/admin_utils/tests.py
new file mode 100644
index 0000000..d7eaabe

-              -
+from __future__ import absolute_import
+from datetime import datetime
+from django.conf import settings
+from django.contrib import admin
+from django.contrib.admin import helpers
+from django.contrib.admin.utils import (display_for_field, label_for_field,
+    lookup_field, NestedObjects)
+from django.contrib.admin.views.main import EMPTY_CHANGELIST_VALUE
+from django.contrib.sites.models import Site
+from django.db import models, DEFAULT_DB_ALIAS
+from django import forms
+from django.test import TestCase
+from django.utils import unittest
+from django.utils.formats import localize
+from django.utils.safestring import mark_safe
+from .models import Article, Count, Event, Location
+class NestedObjectsTests(TestCase):
+    """
+    Tests for ``NestedObject`` utility collection.
+    """
+    def setUp(self):
+        self.n = NestedObjects(using=DEFAULT_DB_ALIAS)
+        self.objs = [Count.objects.create(num=i) for i in range(5)]
+    def _check(self, target):
+        self.assertEqual(self.n.nested(lambda obj: obj.num), target)
+    def _connect(self, i, j):
+        self.objs[i].parent = self.objs[j]
+        self.objs[i].save()
+    def _collect(self, *indices):
+        self.n.collect([self.objs[i] for i in indices])
+    def test_unrelated_roots(self):
+        self._connect(2, 1)
+        self._collect(0)
+        self._collect(1)
+        self._check([0, 1, [2]])
+    def test_siblings(self):
+        self._connect(1, 0)
+        self._connect(2, 0)
+        self._collect(0)
+        self._check([0, [1, 2]])
+    def test_non_added_parent(self):
+        self._connect(0, 1)
+        self._collect(0)
+        self._check([0])
+    def test_cyclic(self):
+        self._connect(0, 2)
+        self._connect(1, 0)
+        self._connect(2, 1)
+        self._collect(0)
+        self._check([0, [1, [2]]])
+    def test_queries(self):
+        self._connect(1, 0)
+        self._connect(2, 0)
+        # 1 query to fetch all children of 0 (1 and 2)
+        # 1 query to fetch all children of 1 and 2 (none)
+        # Should not require additional queries to populate the nested graph.
+        self.assertNumQueries(2, self._collect, 0)
+class UtilTests(unittest.TestCase):
+    def test_values_from_lookup_field(self):
+        """
+        Regression test for #12654: lookup_field
+        """
+        SITE_NAME = 'example.com'
+        TITLE_TEXT = 'Some title'
+        CREATED_DATE = datetime.min
+        ADMIN_METHOD = 'admin method'
+        SIMPLE_FUNCTION = 'function'
+        INSTANCE_ATTRIBUTE = 'attr'
+        class MockModelAdmin(object):
+            def get_admin_value(self, obj):
+                return ADMIN_METHOD
+        simple_function = lambda obj: SIMPLE_FUNCTION
+        article = Article(
+            site=Site(domain=SITE_NAME),
+            title=TITLE_TEXT,
+            created=CREATED_DATE,
+        )
+        article.non_field = INSTANCE_ATTRIBUTE
+        verifications = (
+            ('site', SITE_NAME),
+            ('created', localize(CREATED_DATE)),
+            ('title', TITLE_TEXT),
+            ('get_admin_value', ADMIN_METHOD),
+            (simple_function, SIMPLE_FUNCTION),
+            ('test_from_model', article.test_from_model()),
+            ('non_field', INSTANCE_ATTRIBUTE)
+        )
+        mock_admin = MockModelAdmin()
+        for name, value in verifications:
+            field, attr, resolved_value = lookup_field(name, article, mock_admin)
+            if field is not None:
+                resolved_value = display_for_field(resolved_value, field)
+            self.assertEqual(value, resolved_value)
+    def test_null_display_for_field(self):
+        """
+        Regression test for #12550: display_for_field should handle None
+        value.
+        """
+        display_value = display_for_field(None, models.CharField())
+        self.assertEqual(display_value, EMPTY_CHANGELIST_VALUE)
+        display_value = display_for_field(None, models.CharField(
+            choices=(
+                (None, "test_none"),
+            )
+        ))
+        self.assertEqual(display_value, "test_none")
+        display_value = display_for_field(None, models.DateField())
+        self.assertEqual(display_value, EMPTY_CHANGELIST_VALUE)
+        display_value = display_for_field(None, models.TimeField())
+        self.assertEqual(display_value, EMPTY_CHANGELIST_VALUE)
+        # Regression test for #13071: NullBooleanField has special
+        # handling.
+        display_value = display_for_field(None, models.NullBooleanField())
+        expected = u'<img src="%sadmin/img/icon-unknown.gif" alt="None" />' % settings.STATIC_URL
+        self.assertEqual(display_value, expected)
+        display_value = display_for_field(None, models.DecimalField())
+        self.assertEqual(display_value, EMPTY_CHANGELIST_VALUE)
+        display_value = display_for_field(None, models.FloatField())
+        self.assertEqual(display_value, EMPTY_CHANGELIST_VALUE)
+    def test_label_for_field(self):
+        """
+        Tests for label_for_field
+        """
+        self.assertEqual(
+            label_for_field("title", Article),
+            "title"
+        )
+        self.assertEqual(
+            label_for_field("title2", Article),
+            "another name"
+        )
+        self.assertEqual(
+            label_for_field("title2", Article, return_attr=True),
+            ("another name", None)
+        )
+        self.assertEqual(
+            label_for_field("__unicode__", Article),
+            "article"
+        )
+        self.assertEqual(
+            label_for_field("__str__", Article),
+            "article"
+        )
+        self.assertRaises(
+            AttributeError,
+            lambda: label_for_field("unknown", Article)
+        )
+        def test_callable(obj):
+            return "nothing"
+        self.assertEqual(
+            label_for_field(test_callable, Article),
+            "Test callable"
+        )
+        self.assertEqual(
+            label_for_field(test_callable, Article, return_attr=True),
+            ("Test callable", test_callable)
+        )
+        self.assertEqual(
+            label_for_field("test_from_model", Article),
+            "Test from model"
+        )
+        self.assertEqual(
+            label_for_field("test_from_model", Article, return_attr=True),
+            ("Test from model", Article.test_from_model)
+        )
+        self.assertEqual(
+            label_for_field("test_from_model_with_override", Article),
+            "not What you Expect"
+        )
+        self.assertEqual(
+            label_for_field(lambda x: "nothing", Article),
+            "--"
+        )
+        class MockModelAdmin(object):
+            def test_from_model(self, obj):
+                return "nothing"
+            test_from_model.short_description = "not Really the Model"
+        self.assertEqual(
+            label_for_field("test_from_model", Article, model_admin=MockModelAdmin),
+            "not Really the Model"
+        )
+        self.assertEqual(
+            label_for_field("test_from_model", Article,
+                model_admin = MockModelAdmin,
+                return_attr = True
+            ),
+            ("not Really the Model", MockModelAdmin.test_from_model)
+        )
+    def test_related_name(self):
+        """
+        Regression test for #13963
+        """
+        self.assertEqual(
+            label_for_field('location', Event, return_attr=True),
+            ('location', None),
+        )
+        self.assertEqual(
+            label_for_field('event', Location, return_attr=True),
+            ('awesome event', None),
+        )
+        self.assertEqual(
+            label_for_field('guest', Event, return_attr=True),
+            ('awesome guest', None),
+        )
+    def test_logentry_unicode(self):
+        """
+        Regression test for #15661
+        """
+        log_entry = admin.models.LogEntry()
+        log_entry.action_flag = admin.models.ADDITION
+        self.assertTrue(
+            unicode(log_entry).startswith('Added ')
+        )
+        log_entry.action_flag = admin.models.CHANGE
+        self.assertTrue(
+            unicode(log_entry).startswith('Changed ')
+        )
+        log_entry.action_flag = admin.models.DELETION
+        self.assertTrue(
+            unicode(log_entry).startswith('Deleted ')
+        )
+    def test_safestring_in_field_label(self):
+        # safestring should not be escaped
+        class MyForm(forms.Form):
+            text = forms.CharField(label=mark_safe('<i>text</i>'))
+            cb   = forms.BooleanField(label=mark_safe('<i>cb</i>'))
+        form = MyForm()
+        self.assertEqual(helpers.AdminField(form, 'text', is_first=False).label_tag(),
+                         '<label for="id_text" class="required inline"><i>text</i>:</label>')
+        self.assertEqual(helpers.AdminField(form, 'cb', is_first=False).label_tag(),
+                         '<label for="id_cb" class="vCheckboxLabel required inline"><i>cb</i></label>')
+        # normal strings needs to be escaped
+        class MyForm(forms.Form):
+            text = forms.CharField(label='&text')
+            cb   = forms.BooleanField(label='&cb')
+        form = MyForm()
+        self.assertEqual(helpers.AdminField(form, 'text', is_first=False).label_tag(),
+                         '<label for="id_text" class="required inline">&amp;text:</label>')
+        self.assertEqual(helpers.AdminField(form, 'cb', is_first=False).label_tag(),
+                         '<label for="id_cb" class="vCheckboxLabel required inline">&amp;cb</label>')

tests/regressiontests/admin_views/admin.py

diff --git a/tests/regressiontests/admin_views/admin.py b/tests/regressiontests/admin_views/admin.py
index d960749..86cd039 100644

                site.register(UnorderedObject, UnorderedObjectAdmin)
 #     related OneToOne object not registered in admin
 # when deleting Book so as exercise all four troublesome (w.r.t escaping
 # and calling force_unicode to avoid problems on Python 2.3) paths through
 # contrib.admin.util's get_deleted_objects function.
+# contrib.admin.utils's get_deleted_objects function.
 site.register(Book, inlines=[ChapterInline])
 site.register(Promo)
 site.register(ChapterXtra1, ChapterXtra1Admin)

tests/regressiontests/admin_views/tests.py

diff --git a/tests/regressiontests/admin_views/tests.py b/tests/regressiontests/admin_views/tests.py
index 5241d26..0652e81 100755

                from django.contrib import admin
 from django.contrib.admin.helpers import ACTION_CHECKBOX_NAME
 from django.contrib.admin.models import LogEntry, DELETION
 from django.contrib.admin.sites import LOGIN_FORM_KEY
 from django.contrib.admin.util import quote
+from django.contrib.admin.utils import quote
 from django.contrib.admin.views.main import IS_POPUP_VAR
 from django.contrib.admin.tests import AdminSeleniumWebDriverTestCase
 from django.contrib.auth import REDIRECT_FIELD_NAME
 from django.contrib.auth.models import Group, User, Permission, UNUSABLE_PASSWORD
 from django.contrib.contenttypes.models import ContentType
 from django.forms.util import ErrorList
+from django.forms.utils import ErrorList
 from django.template import context as context_module
 from django.template.response import TemplateResponse
 from django.test import TestCase

tests/regressiontests/db_typecasts/tests.py

diff --git a/tests/regressiontests/db_typecasts/tests.py b/tests/regressiontests/db_typecasts/tests.py
index 83bd1e6..c905a6d 100644

-              a
 import datetime
 from django.db.backends import util as typecasts
+from django.db.backends import utils as typecasts
 from django.utils import unittest

tests/regressiontests/forms/tests/init.py

diff --git a/tests/regressiontests/forms/tests/__init__.py b/tests/regressiontests/forms/tests/__init__.py
index 8e2150c..a94b2a0 100644

                from .media import FormsMediaTestCase, StaticFormsMediaTestCase
 from .models import (TestTicket12510, ModelFormCallableModelDefault,
     FormsModelTestCase, RelatedModelFormTests)
 from .regressions import FormsRegressionsTestCase
 from .util import FormsUtilTestCase
+from .utils import FormsUtilTestCase
 from .validators import TestFieldWithValidators
 from .widgets import (FormsWidgetTestCase, FormsI18NWidgetsTestCase,
     WidgetTests, ClearableFileInputTests)

tests/regressiontests/forms/tests/error_messages.py

diff --git a/tests/regressiontests/forms/tests/error_messages.py b/tests/regressiontests/forms/tests/error_messages.py
index b7b4e98..e8c8999 100644

                class FormsErrorMessagesTestCase(TestCase, AssertFormErrorsMixin):
             def clean(self):
                 raise ValidationError("I like to be awkward.")
         class CustomErrorList(util.ErrorList):
+        class CustomErrorList(utils.ErrorList):
             def __unicode__(self):
                 return self.as_divs()

tests/regressiontests/forms/tests/extra.py

diff --git a/tests/regressiontests/forms/tests/extra.py b/tests/regressiontests/forms/tests/extra.py
index c873af7..87d2c0d 100644

                import datetime
 from django.conf import settings
 from django.forms import *
 from django.forms.extras import SelectDateWidget
 from django.forms.util import ErrorList
+from django.forms.utils import ErrorList
 from django.test import TestCase
 from django.utils import translation
 from django.utils.encoding import force_unicode, smart_unicode

tests/regressiontests/forms/tests/fields.py

diff --git a/tests/regressiontests/forms/tests/fields.py b/tests/regressiontests/forms/tests/fields.py
index 03e0ff6..a1aa199 100644

a	b	class FieldsTests(SimpleTestCase):
999	999	('/django/forms/formsets.py', 'formsets.py'),
1000	1000	('/django/forms/models.py', 'models.py'),
1001	1001	('/django/forms/util.py', 'util.py'),
	1002	('/django/forms/utils.py', 'utils.py'),
1002	1003	('/django/forms/widgets.py', 'widgets.py')
1003	1004	]
1004	1005	for exp, got in zip(expected, fix_os_paths(f.choices)):
…	…	class FieldsTests(SimpleTestCase):
1019	1020	('/django/forms/formsets.py', 'formsets.py'),
1020	1021	('/django/forms/models.py', 'models.py'),
1021	1022	('/django/forms/util.py', 'util.py'),
	1023	('/django/forms/utils.py', 'utils.py'),
1022	1024	('/django/forms/widgets.py', 'widgets.py')
1023	1025	]
1024	1026	for exp, got in zip(expected, fix_os_paths(f.choices)):
…	…	class FieldsTests(SimpleTestCase):
1039	1041	('/django/forms/formsets.py', 'formsets.py'),
1040	1042	('/django/forms/models.py', 'models.py'),
1041	1043	('/django/forms/util.py', 'util.py'),
	1044	('/django/forms/utils.py', 'utils.py'),
1042	1045	('/django/forms/widgets.py', 'widgets.py')
1043	1046	]
1044	1047	for exp, got in zip(expected, fix_os_paths(f.choices)):

deleted file tests/regressiontests/forms/tests/util.py

diff --git a/tests/regressiontests/forms/tests/util.py b/tests/regressiontests/forms/tests/util.py
deleted file mode 100644
index dddb8c7..0000000

-              +
-# -*- coding: utf-8 -*-
-from django.core.exceptions import ValidationError
-from django.forms.util import flatatt, ErrorDict, ErrorList
-from django.test import TestCase
-from django.utils.safestring import mark_safe
-from django.utils.translation import ugettext_lazy
-class FormsUtilTestCase(TestCase):
-        # Tests for forms/util.py module.
-    def test_flatatt(self):
-        ###########
-        # flatatt #
-        ###########
-        self.assertEqual(flatatt({'id': "header"}), u' id="header"')
-        self.assertEqual(flatatt({'class': "news", 'title': "Read this"}), u' class="news" title="Read this"')
-        self.assertEqual(flatatt({}), u'')
-    def test_validation_error(self):
-        ###################
-        # ValidationError #
-        ###################
-        # Can take a string.
-        self.assertHTMLEqual(str(ErrorList(ValidationError("There was an error.").messages)),
-                         '<ul class="errorlist"><li>There was an error.</li></ul>')
-        # Can take a unicode string.
-        self.assertHTMLEqual(unicode(ErrorList(ValidationError(u"Not \u03C0.").messages)),
-                         u'<ul class="errorlist"><li>Not π.</li></ul>')
-        # Can take a lazy string.
-        self.assertHTMLEqual(str(ErrorList(ValidationError(ugettext_lazy("Error.")).messages)),
-                         '<ul class="errorlist"><li>Error.</li></ul>')
-        # Can take a list.
-        self.assertHTMLEqual(str(ErrorList(ValidationError(["Error one.", "Error two."]).messages)),
-                         '<ul class="errorlist"><li>Error one.</li><li>Error two.</li></ul>')
-        # Can take a mixture in a list.
-        self.assertHTMLEqual(str(ErrorList(ValidationError(["First error.", u"Not \u03C0.", ugettext_lazy("Error.")]).messages)),
-                         '<ul class="errorlist"><li>First error.</li><li>Not π.</li><li>Error.</li></ul>')
-        class VeryBadError:
-            def __unicode__(self): return u"A very bad error."
-        # Can take a non-string.
-        self.assertHTMLEqual(str(ErrorList(ValidationError(VeryBadError()).messages)),
-                         '<ul class="errorlist"><li>A very bad error.</li></ul>')
-        # Escapes non-safe input but not input marked safe.
-        example = 'Example of link: <a href="http://www.example.com/">example</a>'
-        self.assertHTMLEqual(str(ErrorList([example])),
-                         '<ul class="errorlist"><li>Example of link: &lt;a href=&quot;http://www.example.com/&quot;&gt;example&lt;/a&gt;</li></ul>')
-        self.assertHTMLEqual(str(ErrorList([mark_safe(example)])),
-                         '<ul class="errorlist"><li>Example of link: <a href="http://www.example.com/">example</a></li></ul>')
-        self.assertHTMLEqual(str(ErrorDict({'name': example})),
-                         '<ul class="errorlist"><li>nameExample of link: &lt;a href=&quot;http://www.example.com/&quot;&gt;example&lt;/a&gt;</li></ul>')
-        self.assertHTMLEqual(str(ErrorDict({'name': mark_safe(example)})),
-                         '<ul class="errorlist"><li>nameExample of link: <a href="http://www.example.com/">example</a></li></ul>')

new file tests/regressiontests/forms/tests/utils.py

diff --git a/tests/regressiontests/forms/tests/utils.py b/tests/regressiontests/forms/tests/utils.py
new file mode 100644
index 0000000..ab827e6

-              -
+# -*- coding: utf-8 -*-
+from django.core.exceptions import ValidationError
+from django.forms.utils import flatatt, ErrorDict, ErrorList
+from django.test import TestCase
+from django.utils.safestring import mark_safe
+from django.utils.translation import ugettext_lazy
+class FormsUtilTestCase(TestCase):
+        # Tests for forms/util.py module.
+    def test_flatatt(self):
+        ###########
+        # flatatt #
+        ###########
+        self.assertEqual(flatatt({'id': "header"}), u' id="header"')
+        self.assertEqual(flatatt({'class': "news", 'title': "Read this"}), u' class="news" title="Read this"')
+        self.assertEqual(flatatt({}), u'')
+    def test_validation_error(self):
+        ###################
+        # ValidationError #
+        ###################
+        # Can take a string.
+        self.assertHTMLEqual(str(ErrorList(ValidationError("There was an error.").messages)),
+                         '<ul class="errorlist"><li>There was an error.</li></ul>')
+        # Can take a unicode string.
+        self.assertHTMLEqual(unicode(ErrorList(ValidationError(u"Not \u03C0.").messages)),
+                         u'<ul class="errorlist"><li>Not π.</li></ul>')
+        # Can take a lazy string.
+        self.assertHTMLEqual(str(ErrorList(ValidationError(ugettext_lazy("Error.")).messages)),
+                         '<ul class="errorlist"><li>Error.</li></ul>')
+        # Can take a list.
+        self.assertHTMLEqual(str(ErrorList(ValidationError(["Error one.", "Error two."]).messages)),
+                         '<ul class="errorlist"><li>Error one.</li><li>Error two.</li></ul>')
+        # Can take a mixture in a list.
+        self.assertHTMLEqual(str(ErrorList(ValidationError(["First error.", u"Not \u03C0.", ugettext_lazy("Error.")]).messages)),
+                         '<ul class="errorlist"><li>First error.</li><li>Not π.</li><li>Error.</li></ul>')
+        class VeryBadError:
+            def __unicode__(self): return u"A very bad error."
+        # Can take a non-string.
+        self.assertHTMLEqual(str(ErrorList(ValidationError(VeryBadError()).messages)),
+                         '<ul class="errorlist"><li>A very bad error.</li></ul>')
+        # Escapes non-safe input but not input marked safe.
+        example = 'Example of link: <a href="http://www.example.com/">example</a>'
+        self.assertHTMLEqual(str(ErrorList([example])),
+                         '<ul class="errorlist"><li>Example of link: &lt;a href=&quot;http://www.example.com/&quot;&gt;example&lt;/a&gt;</li></ul>')
+        self.assertHTMLEqual(str(ErrorList([mark_safe(example)])),
+                         '<ul class="errorlist"><li>Example of link: <a href="http://www.example.com/">example</a></li></ul>')
+        self.assertHTMLEqual(str(ErrorDict({'name': example})),
+                         '<ul class="errorlist"><li>nameExample of link: &lt;a href=&quot;http://www.example.com/&quot;&gt;example&lt;/a&gt;</li></ul>')
+        self.assertHTMLEqual(str(ErrorDict({'name': mark_safe(example)})),
+                         '<ul class="errorlist"><li>nameExample of link: <a href="http://www.example.com/">example</a></li></ul>')

tests/regressiontests/localflavor/uy/tests.py

diff --git a/tests/regressiontests/localflavor/uy/tests.py b/tests/regressiontests/localflavor/uy/tests.py
index eda0068..b1fdc19 100644

a	b
1	1	from django.contrib.localflavor.uy.forms import UYDepartamentSelect, UYCIField
2		from django.contrib.localflavor.uy.util import get_validation_digit
	2	from django.contrib.localflavor.uy.utils import get_validation_digit
3	3
4	4	from django.test import SimpleTestCase
5	5

tests/regressiontests/model_formsets_regress/tests.py

diff --git a/tests/regressiontests/model_formsets_regress/tests.py b/tests/regressiontests/model_formsets_regress/tests.py
index d058f1d..ecdf72e 100644

                from __future__ import absolute_import, with_statement
 from django import forms
 from django.forms.formsets import BaseFormSet, DELETION_FIELD_NAME
 from django.forms.util import ErrorDict, ErrorList
+from django.forms.utils import ErrorDict, ErrorList
 from django.forms.models import modelform_factory, inlineformset_factory, modelformset_factory, BaseModelFormSet
 from django.test import TestCase

Download in other formats:

Original Format

Issues

Context Navigation

Ticket #17627: 0003.patch

Download in other formats: