Rename samples subdirectories

1 files changed, 0 insertions, 938 deletions

diff --git a/samples/python/django-models-base.py b/samples/python/django-models-base.py
deleted file mode 100644
index f52a626..0000000
--- a/samples/python/django-models-base.py
+++ /dev/null
@@ -1,938 +0,0 @@
-from __future__ import unicode_literals
-
-import copy
-import sys
-from functools import update_wrapper
-from future_builtins import zip
-
-import django.db.models.manager     # Imported to register signal handler.
-from django.conf import settings
-from django.core.exceptions import (ObjectDoesNotExist,
-    MultipleObjectsReturned, FieldError, ValidationError, NON_FIELD_ERRORS)
-from django.core import validators
-from django.db.models.fields import AutoField, FieldDoesNotExist
-from django.db.models.fields.related import (ManyToOneRel,
-    OneToOneField, add_lazy_relation)
-from django.db import (router, transaction, DatabaseError,
-    DEFAULT_DB_ALIAS)
-from django.db.models.query import Q
-from django.db.models.query_utils import DeferredAttribute
-from django.db.models.deletion import Collector
-from django.db.models.options import Options
-from django.db.models import signals
-from django.db.models.loading import register_models, get_model
-from django.utils.translation import ugettext_lazy as _
-from django.utils.functional import curry
-from django.utils.encoding import smart_str, force_unicode
-from django.utils.text import get_text_list, capfirst
-
-
-class ModelBase(type):
-    """
-    Metaclass for all models.
-    """
-    def __new__(cls, name, bases, attrs):
-        super_new = super(ModelBase, cls).__new__
-        parents = [b for b in bases if isinstance(b, ModelBase)]
-        if not parents:
-            # If this isn't a subclass of Model, don't do anything special.
-            return super_new(cls, name, bases, attrs)
-
-        # Create the class.
-        module = attrs.pop('__module__')
-        new_class = super_new(cls, name, bases, {'__module__': module})
-        attr_meta = attrs.pop('Meta', None)
-        abstract = getattr(attr_meta, 'abstract', False)
-        if not attr_meta:
-            meta = getattr(new_class, 'Meta', None)
-        else:
-            meta = attr_meta
-        base_meta = getattr(new_class, '_meta', None)
-
-        if getattr(meta, 'app_label', None) is None:
-            # Figure out the app_label by looking one level up.
-            # For 'django.contrib.sites.models', this would be 'sites'.
-            model_module = sys.modules[new_class.__module__]
-            kwargs = {"app_label": model_module.__name__.split('.')[-2]}
-        else:
-            kwargs = {}
-
-        new_class.add_to_class('_meta', Options(meta, **kwargs))
-        if not abstract:
-            new_class.add_to_class('DoesNotExist', subclass_exception(b'DoesNotExist',
-                    tuple(x.DoesNotExist
-                            for x in parents if hasattr(x, '_meta') and not x._meta.abstract)
-                                    or (ObjectDoesNotExist,), module))
-            new_class.add_to_class('MultipleObjectsReturned', subclass_exception(b'MultipleObjectsReturned',
-                    tuple(x.MultipleObjectsReturned
-                            for x in parents if hasattr(x, '_meta') and not x._meta.abstract)
-                                    or (MultipleObjectsReturned,), module))
-            if base_meta and not base_meta.abstract:
-                # Non-abstract child classes inherit some attributes from their
-                # non-abstract parent (unless an ABC comes before it in the
-                # method resolution order).
-                if not hasattr(meta, 'ordering'):
-                    new_class._meta.ordering = base_meta.ordering
-                if not hasattr(meta, 'get_latest_by'):
-                    new_class._meta.get_latest_by = base_meta.get_latest_by
-
-        is_proxy = new_class._meta.proxy
-
-        if getattr(new_class, '_default_manager', None):
-            if not is_proxy:
-                # Multi-table inheritance doesn't inherit default manager from
-                # parents.
-                new_class._default_manager = None
-                new_class._base_manager = None
-            else:
-                # Proxy classes do inherit parent's default manager, if none is
-                # set explicitly.
-                new_class._default_manager = new_class._default_manager._copy_to_model(new_class)
-                new_class._base_manager = new_class._base_manager._copy_to_model(new_class)
-
-        # Bail out early if we have already created this class.
-        m = get_model(new_class._meta.app_label, name,
-                      seed_cache=False, only_installed=False)
-        if m is not None:
-            return m
-
-        # Add all attributes to the class.
-        for obj_name, obj in attrs.items():
-            new_class.add_to_class(obj_name, obj)
-
-        # All the fields of any type declared on this model
-        new_fields = new_class._meta.local_fields + \
-                     new_class._meta.local_many_to_many + \
-                     new_class._meta.virtual_fields
-        field_names = set([f.name for f in new_fields])
-
-        # Basic setup for proxy models.
-        if is_proxy:
-            base = None
-            for parent in [cls for cls in parents if hasattr(cls, '_meta')]:
-                if parent._meta.abstract:
-                    if parent._meta.fields:
-                        raise TypeError("Abstract base class containing model fields not permitted for proxy model '%s'." % name)
-                    else:
-                        continue
-                if base is not None:
-                    raise TypeError("Proxy model '%s' has more than one non-abstract model base class." % name)
-                else:
-                    base = parent
-            if base is None:
-                    raise TypeError("Proxy model '%s' has no non-abstract model base class." % name)
-            if (new_class._meta.local_fields or
-                    new_class._meta.local_many_to_many):
-                raise FieldError("Proxy model '%s' contains model fields." % name)
-            new_class._meta.setup_proxy(base)
-            new_class._meta.concrete_model = base._meta.concrete_model
-        else:
-            new_class._meta.concrete_model = new_class
-
-        # Do the appropriate setup for any model parents.
-        o2o_map = dict([(f.rel.to, f) for f in new_class._meta.local_fields
-                if isinstance(f, OneToOneField)])
-
-        for base in parents:
-            original_base = base
-            if not hasattr(base, '_meta'):
-                # Things without _meta aren't functional models, so they're
-                # uninteresting parents.
-                continue
-
-            parent_fields = base._meta.local_fields + base._meta.local_many_to_many
-            # Check for clashes between locally declared fields and those
-            # on the base classes (we cannot handle shadowed fields at the
-            # moment).
-            for field in parent_fields:
-                if field.name in field_names:
-                    raise FieldError('Local field %r in class %r clashes '
-                                     'with field of similar name from '
-                                     'base class %r' %
-                                        (field.name, name, base.__name__))
-            if not base._meta.abstract:
-                # Concrete classes...
-                base = base._meta.concrete_model
-                if base in o2o_map:
-                    field = o2o_map[base]
-                elif not is_proxy:
-                    attr_name = '%s_ptr' % base._meta.module_name
-                    field = OneToOneField(base, name=attr_name,
-                            auto_created=True, parent_link=True)
-                    new_class.add_to_class(attr_name, field)
-                else:
-                    field = None
-                new_class._meta.parents[base] = field
-            else:
-                # .. and abstract ones.
-                for field in parent_fields:
-                    new_class.add_to_class(field.name, copy.deepcopy(field))
-
-                # Pass any non-abstract parent classes onto child.
-                new_class._meta.parents.update(base._meta.parents)
-
-            # Inherit managers from the abstract base classes.
-            new_class.copy_managers(base._meta.abstract_managers)
-
-            # Proxy models inherit the non-abstract managers from their base,
-            # unless they have redefined any of them.
-            if is_proxy:
-                new_class.copy_managers(original_base._meta.concrete_managers)
-
-            # Inherit virtual fields (like GenericForeignKey) from the parent
-            # class
-            for field in base._meta.virtual_fields:
-                if base._meta.abstract and field.name in field_names:
-                    raise FieldError('Local field %r in class %r clashes '\
-                                     'with field of similar name from '\
-                                     'abstract base class %r' % \
-                                        (field.name, name, base.__name__))
-                new_class.add_to_class(field.name, copy.deepcopy(field))
-
-        if abstract:
-            # Abstract base models can't be instantiated and don't appear in
-            # the list of models for an app. We do the final setup for them a
-            # little differently from normal models.
-            attr_meta.abstract = False
-            new_class.Meta = attr_meta
-            return new_class
-
-        new_class._prepare()
-        register_models(new_class._meta.app_label, new_class)
-
-        # Because of the way imports happen (recursively), we may or may not be
-        # the first time this model tries to register with the framework. There
-        # should only be one class for each model, so we always return the
-        # registered version.
-        return get_model(new_class._meta.app_label, name,
-                         seed_cache=False, only_installed=False)
-
-    def copy_managers(cls, base_managers):
-        # This is in-place sorting of an Options attribute, but that's fine.
-        base_managers.sort()
-        for _, mgr_name, manager in base_managers:
-            val = getattr(cls, mgr_name, None)
-            if not val or val is manager:
-                new_manager = manager._copy_to_model(cls)
-                cls.add_to_class(mgr_name, new_manager)
-
-    def add_to_class(cls, name, value):
-        if hasattr(value, 'contribute_to_class'):
-            value.contribute_to_class(cls, name)
-        else:
-            setattr(cls, name, value)
-
-    def _prepare(cls):
-        """
-        Creates some methods once self._meta has been populated.
-        """
-        opts = cls._meta
-        opts._prepare(cls)
-
-        if opts.order_with_respect_to:
-            cls.get_next_in_order = curry(cls._get_next_or_previous_in_order, is_next=True)
-            cls.get_previous_in_order = curry(cls._get_next_or_previous_in_order, is_next=False)
-            # defer creating accessors on the foreign class until we are
-            # certain it has been created
-            def make_foreign_order_accessors(field, model, cls):
-                setattr(
-                    field.rel.to,
-                    'get_%s_order' % cls.__name__.lower(),
-                    curry(method_get_order, cls)
-                )
-                setattr(
-                    field.rel.to,
-                    'set_%s_order' % cls.__name__.lower(),
-                    curry(method_set_order, cls)
-                )
-            add_lazy_relation(
-                cls,
-                opts.order_with_respect_to,
-                opts.order_with_respect_to.rel.to,
-                make_foreign_order_accessors
-            )
-
-        # Give the class a docstring -- its definition.
-        if cls.__doc__ is None:
-            cls.__doc__ = "%s(%s)" % (cls.__name__, ", ".join([f.attname for f in opts.fields]))
-
-        if hasattr(cls, 'get_absolute_url'):
-            cls.get_absolute_url = update_wrapper(curry(get_absolute_url, opts, cls.get_absolute_url),
-                                                  cls.get_absolute_url)
-
-        signals.class_prepared.send(sender=cls)
-
-class ModelState(object):
-    """
-    A class for storing instance state
-    """
-    def __init__(self, db=None):
-        self.db = db
-        # If true, uniqueness validation checks will consider this a new, as-yet-unsaved object.
-        # Necessary for correct validation of new instances of objects with explicit (non-auto) PKs.
-        # This impacts validation only; it has no effect on the actual save.
-        self.adding = True
-
-class Model(object):
-    __metaclass__ = ModelBase
-    _deferred = False
-
-    def __init__(self, *args, **kwargs):
-        signals.pre_init.send(sender=self.__class__, args=args, kwargs=kwargs)
-
-        # Set up the storage for instance state
-        self._state = ModelState()
-
-        # There is a rather weird disparity here; if kwargs, it's set, then args
-        # overrides it. It should be one or the other; don't duplicate the work
-        # The reason for the kwargs check is that standard iterator passes in by
-        # args, and instantiation for iteration is 33% faster.
-        args_len = len(args)
-        if args_len > len(self._meta.fields):
-            # Daft, but matches old exception sans the err msg.
-            raise IndexError("Number of args exceeds number of fields")
-
-        fields_iter = iter(self._meta.fields)
-        if not kwargs:
-            # The ordering of the zip calls matter - zip throws StopIteration
-            # when an iter throws it. So if the first iter throws it, the second
-            # is *not* consumed. We rely on this, so don't change the order
-            # without changing the logic.
-            for val, field in zip(args, fields_iter):
-                setattr(self, field.attname, val)
-        else:
-            # Slower, kwargs-ready version.
-            for val, field in zip(args, fields_iter):
-                setattr(self, field.attname, val)
-                kwargs.pop(field.name, None)
-                # Maintain compatibility with existing calls.
-                if isinstance(field.rel, ManyToOneRel):
-                    kwargs.pop(field.attname, None)
-
-        # Now we're left with the unprocessed fields that *must* come from
-        # keywords, or default.
-
-        for field in fields_iter:
-            is_related_object = False
-            # This slightly odd construct is so that we can access any
-            # data-descriptor object (DeferredAttribute) without triggering its
-            # __get__ method.
-            if (field.attname not in kwargs and
-                    isinstance(self.__class__.__dict__.get(field.attname), DeferredAttribute)):
-                # This field will be populated on request.
-                continue
-            if kwargs:
-                if isinstance(field.rel, ManyToOneRel):
-                    try:
-                        # Assume object instance was passed in.
-                        rel_obj = kwargs.pop(field.name)
-                        is_related_object = True
-                    except KeyError:
-                        try:
-                            # Object instance wasn't passed in -- must be an ID.
-                            val = kwargs.pop(field.attname)
-                        except KeyError:
-                            val = field.get_default()
-                    else:
-                        # Object instance was passed in. Special case: You can
-                        # pass in "None" for related objects if it's allowed.
-                        if rel_obj is None and field.null:
-                            val = None
-                else:
-                    try:
-                        val = kwargs.pop(field.attname)
-                    except KeyError:
-                        # This is done with an exception rather than the
-                        # default argument on pop because we don't want
-                        # get_default() to be evaluated, and then not used.
-                        # Refs #12057.
-                        val = field.get_default()
-            else:
-                val = field.get_default()
-            if is_related_object:
-                # If we are passed a related instance, set it using the
-                # field.name instead of field.attname (e.g. "user" instead of
-                # "user_id") so that the object gets properly cached (and type
-                # checked) by the RelatedObjectDescriptor.
-                setattr(self, field.name, rel_obj)
-            else:
-                setattr(self, field.attname, val)
-
-        if kwargs:
-            for prop in kwargs.keys():
-                try:
-                    if isinstance(getattr(self.__class__, prop), property):
-                        setattr(self, prop, kwargs.pop(prop))
-                except AttributeError:
-                    pass
-            if kwargs:
-                raise TypeError("'%s' is an invalid keyword argument for this function" % kwargs.keys()[0])
-        super(Model, self).__init__()
-        signals.post_init.send(sender=self.__class__, instance=self)
-
-    def __repr__(self):
-        try:
-            u = unicode(self)
-        except (UnicodeEncodeError, UnicodeDecodeError):
-            u = '[Bad Unicode data]'
-        return smart_str('<%s: %s>' % (self.__class__.__name__, u))
-
-    def __str__(self):
-        if hasattr(self, '__unicode__'):
-            return force_unicode(self).encode('utf-8')
-        return '%s object' % self.__class__.__name__
-
-    def __eq__(self, other):
-        return isinstance(other, self.__class__) and self._get_pk_val() == other._get_pk_val()
-
-    def __ne__(self, other):
-        return not self.__eq__(other)
-
-    def __hash__(self):
-        return hash(self._get_pk_val())
-
-    def __reduce__(self):
-        """
-        Provides pickling support. Normally, this just dispatches to Python's
-        standard handling. However, for models with deferred field loading, we
-        need to do things manually, as they're dynamically created classes and
-        only module-level classes can be pickled by the default path.
-        """
-        data = self.__dict__
-        model = self.__class__
-        # The obvious thing to do here is to invoke super().__reduce__()
-        # for the non-deferred case. Don't do that.
-        # On Python 2.4, there is something weird with __reduce__,
-        # and as a result, the super call will cause an infinite recursion.
-        # See #10547 and #12121.
-        defers = []
-        if self._deferred:
-            from django.db.models.query_utils import deferred_class_factory
-            factory = deferred_class_factory
-            for field in self._meta.fields:
-                if isinstance(self.__class__.__dict__.get(field.attname),
-                        DeferredAttribute):
-                    defers.append(field.attname)
-            model = self._meta.proxy_for_model
-        else:
-            factory = simple_class_factory
-        return (model_unpickle, (model, defers, factory), data)
-
-    def _get_pk_val(self, meta=None):
-        if not meta:
-            meta = self._meta
-        return getattr(self, meta.pk.attname)
-
-    def _set_pk_val(self, value):
-        return setattr(self, self._meta.pk.attname, value)
-
-    pk = property(_get_pk_val, _set_pk_val)
-
-    def serializable_value(self, field_name):
-        """
-        Returns the value of the field name for this instance. If the field is
-        a foreign key, returns the id value, instead of the object. If there's
-        no Field object with this name on the model, the model attribute's
-        value is returned directly.
-
-        Used to serialize a field's value (in the serializer, or form output,
-        for example). Normally, you would just access the attribute directly
-        and not use this method.
-        """
-        try:
-            field = self._meta.get_field_by_name(field_name)[0]
-        except FieldDoesNotExist:
-            return getattr(self, field_name)
-        return getattr(self, field.attname)
-
-    def save(self, force_insert=False, force_update=False, using=None,
-             update_fields=None):
-        """
-        Saves the current instance. Override this in a subclass if you want to
-        control the saving process.
-
-        The 'force_insert' and 'force_update' parameters can be used to insist
-        that the "save" must be an SQL insert or update (or equivalent for
-        non-SQL backends), respectively. Normally, they should not be set.
-        """
-        if force_insert and (force_update or update_fields):
-            raise ValueError("Cannot force both insert and updating in model saving.")
-
-        if update_fields is not None:
-            # If update_fields is empty, skip the save. We do also check for
-            # no-op saves later on for inheritance cases. This bailout is
-            # still needed for skipping signal sending.
-            if len(update_fields) == 0:
-                return
-
-            update_fields = frozenset(update_fields)
-            field_names = set([field.name for field in self._meta.fields
-                               if not field.primary_key])
-            non_model_fields = update_fields.difference(field_names)
-
-            if non_model_fields:
-                raise ValueError("The following fields do not exist in this "
-                                 "model or are m2m fields: %s"
-                                 % ', '.join(non_model_fields))
-
-        self.save_base(using=using, force_insert=force_insert,
-                       force_update=force_update, update_fields=update_fields)
-    save.alters_data = True
-
-    def save_base(self, raw=False, cls=None, origin=None, force_insert=False,
-                  force_update=False, using=None, update_fields=None):
-        """
-        Does the heavy-lifting involved in saving. Subclasses shouldn't need to
-        override this method. It's separate from save() in order to hide the
-        need for overrides of save() to pass around internal-only parameters
-        ('raw', 'cls', and 'origin').
-        """
-        using = using or router.db_for_write(self.__class__, instance=self)
-        assert not (force_insert and (force_update or update_fields))
-        assert update_fields is None or len(update_fields) > 0
-        if cls is None:
-            cls = self.__class__
-            meta = cls._meta
-            if not meta.proxy:
-                origin = cls
-        else:
-            meta = cls._meta
-
-        if origin and not meta.auto_created:
-            signals.pre_save.send(sender=origin, instance=self, raw=raw, using=using,
-                                  update_fields=update_fields)
-
-        # If we are in a raw save, save the object exactly as presented.
-        # That means that we don't try to be smart about saving attributes
-        # that might have come from the parent class - we just save the
-        # attributes we have been given to the class we have been given.
-        # We also go through this process to defer the save of proxy objects
-        # to their actual underlying model.
-        if not raw or meta.proxy:
-            if meta.proxy:
-                org = cls
-            else:
-                org = None
-            for parent, field in meta.parents.items():
-                # At this point, parent's primary key field may be unknown
-                # (for example, from administration form which doesn't fill
-                # this field). If so, fill it.
-                if field and getattr(self, parent._meta.pk.attname) is None and getattr(self, field.attname) is not None:
-                    setattr(self, parent._meta.pk.attname, getattr(self, field.attname))
-
-                self.save_base(cls=parent, origin=org, using=using,
-                               update_fields=update_fields)
-
-                if field:
-                    setattr(self, field.attname, self._get_pk_val(parent._meta))
-            if meta.proxy:
-                return
-
-        if not meta.proxy:
-            non_pks = [f for f in meta.local_fields if not f.primary_key]
-
-            if update_fields:
-                non_pks = [f for f in non_pks if f.name in update_fields]
-
-            # First, try an UPDATE. If that doesn't update anything, do an INSERT.
-            pk_val = self._get_pk_val(meta)
-            pk_set = pk_val is not None
-            record_exists = True
-            manager = cls._base_manager
-            if pk_set:
-                # Determine if we should do an update (pk already exists, forced update,
-                # no force_insert)
-                if ((force_update or update_fields) or (not force_insert and
-                        manager.using(using).filter(pk=pk_val).exists())):
-                    if force_update or non_pks:
-                        values = [(f, None, (raw and getattr(self, f.attname) or f.pre_save(self, False))) for f in non_pks]
-                        if values:
-                            rows = manager.using(using).filter(pk=pk_val)._update(values)
-                            if force_update and not rows:
-                                raise DatabaseError("Forced update did not affect any rows.")
-                            if update_fields and not rows:
-                                raise DatabaseError("Save with update_fields did not affect any rows.")
-                else:
-                    record_exists = False
-            if not pk_set or not record_exists:
-                if meta.order_with_respect_to:
-                    # If this is a model with an order_with_respect_to
-                    # autopopulate the _order field
-                    field = meta.order_with_respect_to
-                    order_value = manager.using(using).filter(**{field.name: getattr(self, field.attname)}).count()
-                    self._order = order_value
-
-                fields = meta.local_fields
-                if not pk_set:
-                    if force_update or update_fields:
-                        raise ValueError("Cannot force an update in save() with no primary key.")
-                    fields = [f for f in fields if not isinstance(f, AutoField)]
-
-                record_exists = False
-
-                update_pk = bool(meta.has_auto_field and not pk_set)
-                result = manager._insert([self], fields=fields, return_id=update_pk, using=using, raw=raw)
-
-                if update_pk:
-                    setattr(self, meta.pk.attname, result)
-            transaction.commit_unless_managed(using=using)
-
-        # Store the database on which the object was saved
-        self._state.db = using
-        # Once saved, this is no longer a to-be-added instance.
-        self._state.adding = False
-
-        # Signal that the save is complete
-        if origin and not meta.auto_created:
-            signals.post_save.send(sender=origin, instance=self, created=(not record_exists),
-                                   update_fields=update_fields, raw=raw, using=using)
-
-
-    save_base.alters_data = True
-
-    def delete(self, using=None):
-        using = using or router.db_for_write(self.__class__, instance=self)
-        assert self._get_pk_val() is not None, "%s object can't be deleted because its %s attribute is set to None." % (self._meta.object_name, self._meta.pk.attname)
-
-        collector = Collector(using=using)
-        collector.collect([self])
-        collector.delete()
-
-    delete.alters_data = True
-
-    def _get_FIELD_display(self, field):
-        value = getattr(self, field.attname)
-        return force_unicode(dict(field.flatchoices).get(value, value), strings_only=True)
-
-    def _get_next_or_previous_by_FIELD(self, field, is_next, **kwargs):
-        if not self.pk:
-            raise ValueError("get_next/get_previous cannot be used on unsaved objects.")
-        op = is_next and 'gt' or 'lt'
-        order = not is_next and '-' or ''
-        param = smart_str(getattr(self, field.attname))
-        q = Q(**{'%s__%s' % (field.name, op): param})
-        q = q|Q(**{field.name: param, 'pk__%s' % op: self.pk})
-        qs = self.__class__._default_manager.using(self._state.db).filter(**kwargs).filter(q).order_by('%s%s' % (order, field.name), '%spk' % order)
-        try:
-            return qs[0]
-        except IndexError:
-            raise self.DoesNotExist("%s matching query does not exist." % self.__class__._meta.object_name)
-
-    def _get_next_or_previous_in_order(self, is_next):
-        cachename = "__%s_order_cache" % is_next
-        if not hasattr(self, cachename):
-            op = is_next and 'gt' or 'lt'
-            order = not is_next and '-_order' or '_order'
-            order_field = self._meta.order_with_respect_to
-            obj = self._default_manager.filter(**{
-                order_field.name: getattr(self, order_field.attname)
-            }).filter(**{
-                '_order__%s' % op: self._default_manager.values('_order').filter(**{
-                    self._meta.pk.name: self.pk
-                })
-            }).order_by(order)[:1].get()
-            setattr(self, cachename, obj)
-        return getattr(self, cachename)
-
-    def prepare_database_save(self, unused):
-        return self.pk
-
-    def clean(self):
-        """
-        Hook for doing any extra model-wide validation after clean() has been
-        called on every field by self.clean_fields. Any ValidationError raised
-        by this method will not be associated with a particular field; it will
-        have a special-case association with the field defined by NON_FIELD_ERRORS.
-        """
-        pass
-
-    def validate_unique(self, exclude=None):
-        """
-        Checks unique constraints on the model and raises ``ValidationError``
-        if any failed.
-        """
-        unique_checks, date_checks = self._get_unique_checks(exclude=exclude)
-
-        errors = self._perform_unique_checks(unique_checks)
-        date_errors = self._perform_date_checks(date_checks)
-
-        for k, v in date_errors.items():
-            errors.setdefault(k, []).extend(v)
-
-        if errors:
-            raise ValidationError(errors)
-
-    def _get_unique_checks(self, exclude=None):
-        """
-        Gather a list of checks to perform. Since validate_unique could be
-        called from a ModelForm, some fields may have been excluded; we can't
-        perform a unique check on a model that is missing fields involved
-        in that check.
-        Fields that did not validate should also be excluded, but they need
-        to be passed in via the exclude argument.
-        """
-        if exclude is None:
-            exclude = []
-        unique_checks = []
-
-        unique_togethers = [(self.__class__, self._meta.unique_together)]
-        for parent_class in self._meta.parents.keys():
-            if parent_class._meta.unique_together:
-                unique_togethers.append((parent_class, parent_class._meta.unique_together))
-
-        for model_class, unique_together in unique_togethers:
-            for check in unique_together:
-                for name in check:
-                    # If this is an excluded field, don't add this check.
-                    if name in exclude:
-                        break
-                else:
-                    unique_checks.append((model_class, tuple(check)))
-
-        # These are checks for the unique_for_<date/year/month>.
-        date_checks = []
-
-        # Gather a list of checks for fields declared as unique and add them to
-        # the list of checks.
-
-        fields_with_class = [(self.__class__, self._meta.local_fields)]
-        for parent_class in self._meta.parents.keys():
-            fields_with_class.append((parent_class, parent_class._meta.local_fields))
-
-        for model_class, fields in fields_with_class:
-            for f in fields:
-                name = f.name
-                if name in exclude:
-                    continue
-                if f.unique:
-                    unique_checks.append((model_class, (name,)))
-                if f.unique_for_date and f.unique_for_date not in exclude:
-                    date_checks.append((model_class, 'date', name, f.unique_for_date))
-                if f.unique_for_year and f.unique_for_year not in exclude:
-                    date_checks.append((model_class, 'year', name, f.unique_for_year))
-                if f.unique_for_month and f.unique_for_month not in exclude:
-                    date_checks.append((model_class, 'month', name, f.unique_for_month))
-        return unique_checks, date_checks
-
-    def _perform_unique_checks(self, unique_checks):
-        errors = {}
-
-        for model_class, unique_check in unique_checks:
-            # Try to look up an existing object with the same values as this
-            # object's values for all the unique field.
-
-            lookup_kwargs = {}
-            for field_name in unique_check:
-                f = self._meta.get_field(field_name)
-                lookup_value = getattr(self, f.attname)
-                if lookup_value is None:
-                    # no value, skip the lookup
-                    continue
-                if f.primary_key and not self._state.adding:
-                    # no need to check for unique primary key when editing
-                    continue
-                lookup_kwargs[str(field_name)] = lookup_value
-
-            # some fields were skipped, no reason to do the check
-            if len(unique_check) != len(lookup_kwargs.keys()):
-                continue
-
-            qs = model_class._default_manager.filter(**lookup_kwargs)
-
-            # Exclude the current object from the query if we are editing an
-            # instance (as opposed to creating a new one)
-            # Note that we need to use the pk as defined by model_class, not
-            # self.pk. These can be different fields because model inheritance
-            # allows single model to have effectively multiple primary keys.
-            # Refs #17615.
-            model_class_pk = self._get_pk_val(model_class._meta)
-            if not self._state.adding and model_class_pk is not None:
-                qs = qs.exclude(pk=model_class_pk)
-            if qs.exists():
-                if len(unique_check) == 1:
-                    key = unique_check[0]
-                else:
-                    key = NON_FIELD_ERRORS
-                errors.setdefault(key, []).append(self.unique_error_message(model_class, unique_check))
-
-        return errors
-
-    def _perform_date_checks(self, date_checks):
-        errors = {}
-        for model_class, lookup_type, field, unique_for in date_checks:
-            lookup_kwargs = {}
-            # there's a ticket to add a date lookup, we can remove this special
-            # case if that makes it's way in
-            date = getattr(self, unique_for)
-            if date is None:
-                continue
-            if lookup_type == 'date':
-                lookup_kwargs['%s__day' % unique_for] = date.day
-                lookup_kwargs['%s__month' % unique_for] = date.month
-                lookup_kwargs['%s__year' % unique_for] = date.year
-            else:
-                lookup_kwargs['%s__%s' % (unique_for, lookup_type)] = getattr(date, lookup_type)
-            lookup_kwargs[field] = getattr(self, field)
-
-            qs = model_class._default_manager.filter(**lookup_kwargs)
-            # Exclude the current object from the query if we are editing an
-            # instance (as opposed to creating a new one)
-            if not self._state.adding and self.pk is not None:
-                qs = qs.exclude(pk=self.pk)
-
-            if qs.exists():
-                errors.setdefault(field, []).append(
-                    self.date_error_message(lookup_type, field, unique_for)
-                )
-        return errors
-
-    def date_error_message(self, lookup_type, field, unique_for):
-        opts = self._meta
-        return _("%(field_name)s must be unique for %(date_field)s %(lookup)s.") % {
-            'field_name': unicode(capfirst(opts.get_field(field).verbose_name)),
-            'date_field': unicode(capfirst(opts.get_field(unique_for).verbose_name)),
-            'lookup': lookup_type,
-        }
-
-    def unique_error_message(self, model_class, unique_check):
-        opts = model_class._meta
-        model_name = capfirst(opts.verbose_name)
-
-        # A unique field
-        if len(unique_check) == 1:
-            field_name = unique_check[0]
-            field = opts.get_field(field_name)
-            field_label = capfirst(field.verbose_name)
-            # Insert the error into the error dict, very sneaky
-            return field.error_messages['unique'] %  {
-                'model_name': unicode(model_name),
-                'field_label': unicode(field_label)
-            }
-        # unique_together
-        else:
-            field_labels = map(lambda f: capfirst(opts.get_field(f).verbose_name), unique_check)
-            field_labels = get_text_list(field_labels, _('and'))
-            return _("%(model_name)s with this %(field_label)s already exists.") %  {
-                'model_name': unicode(model_name),
-                'field_label': unicode(field_labels)
-            }
-
-    def full_clean(self, exclude=None):
-        """
-        Calls clean_fields, clean, and validate_unique, on the model,
-        and raises a ``ValidationError`` for any errors that occured.
-        """
-        errors = {}
-        if exclude is None:
-            exclude = []
-
-        try:
-            self.clean_fields(exclude=exclude)
-        except ValidationError as e:
-            errors = e.update_error_dict(errors)
-
-        # Form.clean() is run even if other validation fails, so do the
-        # same with Model.clean() for consistency.
-        try:
-            self.clean()
-        except ValidationError as e:
-            errors = e.update_error_dict(errors)
-
-        # Run unique checks, but only for fields that passed validation.
-        for name in errors.keys():
-            if name != NON_FIELD_ERRORS and name not in exclude:
-                exclude.append(name)
-        try:
-            self.validate_unique(exclude=exclude)
-        except ValidationError as e:
-            errors = e.update_error_dict(errors)
-
-        if errors:
-            raise ValidationError(errors)
-
-    def clean_fields(self, exclude=None):
-        """
-        Cleans all fields and raises a ValidationError containing message_dict
-        of all validation errors if any occur.
-        """
-        if exclude is None:
-            exclude = []
-
-        errors = {}
-        for f in self._meta.fields:
-            if f.name in exclude:
-                continue
-            # Skip validation for empty fields with blank=True. The developer
-            # is responsible for making sure they have a valid value.
-            raw_value = getattr(self, f.attname)
-            if f.blank and raw_value in validators.EMPTY_VALUES:
-                continue
-            try:
-                setattr(self, f.attname, f.clean(raw_value, self))
-            except ValidationError as e:
-                errors[f.name] = e.messages
-
-        if errors:
-            raise ValidationError(errors)
-
-
-############################################
-# HELPER FUNCTIONS (CURRIED MODEL METHODS) #
-############################################
-
-# ORDERING METHODS #########################
-
-def method_set_order(ordered_obj, self, id_list, using=None):
-    if using is None:
-        using = DEFAULT_DB_ALIAS
-    rel_val = getattr(self, ordered_obj._meta.order_with_respect_to.rel.field_name)
-    order_name = ordered_obj._meta.order_with_respect_to.name
-    # FIXME: It would be nice if there was an "update many" version of update
-    # for situations like this.
-    for i, j in enumerate(id_list):
-        ordered_obj.objects.filter(**{'pk': j, order_name: rel_val}).update(_order=i)
-    transaction.commit_unless_managed(using=using)
-
-
-def method_get_order(ordered_obj, self):
-    rel_val = getattr(self, ordered_obj._meta.order_with_respect_to.rel.field_name)
-    order_name = ordered_obj._meta.order_with_respect_to.name
-    pk_name = ordered_obj._meta.pk.name
-    return [r[pk_name] for r in
-            ordered_obj.objects.filter(**{order_name: rel_val}).values(pk_name)]
-
-
-##############################################
-# HELPER FUNCTIONS (CURRIED MODEL FUNCTIONS) #
-##############################################
-
-def get_absolute_url(opts, func, self, *args, **kwargs):
-    return settings.ABSOLUTE_URL_OVERRIDES.get('%s.%s' % (opts.app_label, opts.module_name), func)(self, *args, **kwargs)
-
-
-########
-# MISC #
-########
-
-class Empty(object):
-    pass
-
-def simple_class_factory(model, attrs):
-    """Used to unpickle Models without deferred fields.
-
-    We need to do this the hard way, rather than just using
-    the default __reduce__ implementation, because of a
-    __deepcopy__ problem in Python 2.4
-    """
-    return model
-
-def model_unpickle(model, attrs, factory):
-    """
-    Used to unpickle Model subclasses with deferred fields.
-    """
-    cls = factory(model, attrs)
-    return cls.__new__(cls)
-model_unpickle.__safe_for_unpickle__ = True
-
-def subclass_exception(name, parents, module):
-    return type(name, parents, {'__module__': module})