diff options
Diffstat (limited to 'lib/python2.7/site-packages/django/db/models/base.py')
| -rw-r--r-- | lib/python2.7/site-packages/django/db/models/base.py | 1042 |
1 files changed, 0 insertions, 1042 deletions
diff --git a/lib/python2.7/site-packages/django/db/models/base.py b/lib/python2.7/site-packages/django/db/models/base.py deleted file mode 100644 index f6001b4..0000000 --- a/lib/python2.7/site-packages/django/db/models/base.py +++ /dev/null @@ -1,1042 +0,0 @@ -from __future__ import unicode_literals - -import copy -import sys -from functools import update_wrapper -from django.utils.six.moves 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.db.models.fields import AutoField, FieldDoesNotExist -from django.db.models.fields.related import (ForeignObjectRel, 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, deferred_class_factory -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 force_str, force_text -from django.utils import six -from django.utils.text import get_text_list, capfirst - - -def subclass_exception(name, parents, module, attached_to=None): - """ - Create exception subclass. Used by ModelBase below. - - If 'attached_to' is supplied, the exception will be created in a way that - allows it to be pickled, assuming the returned exception class will be added - as an attribute to the 'attached_to' class. - """ - class_dict = {'__module__': module} - if attached_to is not None: - def __reduce__(self): - # Exceptions are special - they've got state that isn't - # in self.__dict__. We assume it is all in self.args. - return (unpickle_inner_exception, (attached_to, name), self.args) - - def __setstate__(self, args): - self.args = args - - class_dict['__reduce__'] = __reduce__ - class_dict['__setstate__'] = __setstate__ - - return type(name, parents, class_dict) - - -class ModelBase(type): - """ - Metaclass for all models. - """ - def __new__(cls, name, bases, attrs): - super_new = super(ModelBase, cls).__new__ - - # six.with_metaclass() inserts an extra class called 'NewBase' in the - # inheritance tree: Model -> NewBase -> object. But the initialization - # should be executed only once for a given model class. - - # attrs will never be empty for classes declared in the standard way - # (ie. with the `class` keyword). This is quite robust. - if name == 'NewBase' and attrs == {}: - return super_new(cls, name, bases, attrs) - - # Also ensure initialization is only performed for subclasses of Model - # (excluding Model class itself). - parents = [b for b in bases if isinstance(b, ModelBase) and - not (b.__name__ == 'NewBase' and b.__mro__ == (b, object))] - if not parents: - 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(str('DoesNotExist'), - tuple(x.DoesNotExist - for x in parents if hasattr(x, '_meta') and not x._meta.abstract) - or (ObjectDoesNotExist,), - module, attached_to=new_class)) - new_class.add_to_class('MultipleObjectsReturned', subclass_exception(str('MultipleObjectsReturned'), - tuple(x.MultipleObjectsReturned - for x in parents if hasattr(x, '_meta') and not x._meta.abstract) - or (MultipleObjectsReturned,), - module, attached_to=new_class)) - 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 the model is a proxy, ensure that the base class - # hasn't been swapped out. - if is_proxy and base_meta and base_meta.swapped: - raise TypeError("%s cannot proxy the swapped model '%s'." % (name, base_meta.swapped)) - - 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.model_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(six.with_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.concrete_fields): - # Daft, but matches old exception sans the err msg. - raise IndexError("Number of args exceeds number of fields") - - if not kwargs: - fields_iter = iter(self._meta.concrete_fields) - # 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. - fields_iter = iter(self._meta.fields) - 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) - or field.column is None)): - # This field will be populated on request. - continue - if kwargs: - if isinstance(field.rel, ForeignObjectRel): - 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 list(kwargs): - 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" % list(kwargs)[0]) - super(Model, self).__init__() - signals.post_init.send(sender=self.__class__, instance=self) - - def __repr__(self): - try: - u = six.text_type(self) - except (UnicodeEncodeError, UnicodeDecodeError): - u = '[Bad Unicode data]' - return force_str('<%s: %s>' % (self.__class__.__name__, u)) - - def __str__(self): - if six.PY2 and hasattr(self, '__unicode__'): - return force_text(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__ - if not self._deferred: - class_id = self._meta.app_label, self._meta.object_name - return model_unpickle, (class_id, [], simple_class_factory), data - defers = [] - 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 - class_id = model._meta.app_label, model._meta.object_name - return (model_unpickle, (class_id, defers, deferred_class_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. - """ - using = using or router.db_for_write(self.__class__, instance=self) - 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() - - for field in self._meta.fields: - if not field.primary_key: - field_names.add(field.name) - - if field.name != field.attname: - field_names.add(field.attname) - - 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)) - - # If saving to the same database, and this model is deferred, then - # automatically do a "update_fields" save on the loaded fields. - elif not force_insert and self._deferred and using == self._state.db: - field_names = set() - for field in self._meta.concrete_fields: - if not field.primary_key and not hasattr(field, 'through'): - field_names.add(field.attname) - deferred_fields = [ - f.attname for f in self._meta.fields - if f.attname not in self.__dict__ - and isinstance(self.__class__.__dict__[f.attname], - DeferredAttribute)] - - loaded_fields = field_names.difference(deferred_fields) - if loaded_fields: - update_fields = frozenset(loaded_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, force_insert=False, - force_update=False, using=None, update_fields=None): - """ - Handles the parts of saving which should be done only once per save, - yet need to be done in raw saves, too. This includes some sanity - checks and signal sending. - - The 'raw' argument is telling save_base not to save any parent - models and not to do any changes to the values before save. This - is used by fixture loading. - """ - 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 - cls = origin = self.__class__ - # Skip proxies, but keep the origin as the proxy model. - if cls._meta.proxy: - cls = cls._meta.concrete_model - meta = cls._meta - if not meta.auto_created: - signals.pre_save.send(sender=origin, instance=self, raw=raw, using=using, - update_fields=update_fields) - with transaction.commit_on_success_unless_managed(using=using, savepoint=False): - if not raw: - self._save_parents(cls, using, update_fields) - updated = self._save_table(raw, cls, force_insert, force_update, using, update_fields) - # 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 not meta.auto_created: - signals.post_save.send(sender=origin, instance=self, created=(not updated), - update_fields=update_fields, raw=raw, using=using) - - save_base.alters_data = True - - def _save_parents(self, cls, using, update_fields): - """ - Saves all the parents of cls using values from self. - """ - meta = cls._meta - for parent, field in meta.parents.items(): - # Make sure the link fields are synced between parent and self. - 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_parents(cls=parent, using=using, update_fields=update_fields) - self._save_table(cls=parent, using=using, update_fields=update_fields) - # Set the parent's PK value to self. - if field: - setattr(self, field.attname, self._get_pk_val(parent._meta)) - # Since we didn't have an instance of the parent handy set - # attname directly, bypassing the descriptor. Invalidate - # the related object cache, in case it's been accidentally - # populated. A fresh instance will be re-built from the - # database if necessary. - cache_name = field.get_cache_name() - if hasattr(self, cache_name): - delattr(self, cache_name) - - def _save_table(self, raw=False, cls=None, force_insert=False, - force_update=False, using=None, update_fields=None): - """ - Does the heavy-lifting involved in saving. Updates or inserts the data - for a single table. - """ - meta = cls._meta - non_pks = [f for f in meta.local_concrete_fields if not f.primary_key] - - if update_fields: - non_pks = [f for f in non_pks - if f.name in update_fields or f.attname in update_fields] - - pk_val = self._get_pk_val(meta) - pk_set = pk_val is not None - if not pk_set and (force_update or update_fields): - raise ValueError("Cannot force an update in save() with no primary key.") - updated = False - # If possible, try an UPDATE. If that doesn't update anything, do an INSERT. - if pk_set and not force_insert: - base_qs = cls._base_manager.using(using) - values = [(f, None, (getattr(self, f.attname) if raw else f.pre_save(self, False))) - for f in non_pks] - forced_update = update_fields or force_update - updated = self._do_update(base_qs, using, pk_val, values, update_fields, - forced_update) - if force_update and not updated: - raise DatabaseError("Forced update did not affect any rows.") - if update_fields and not updated: - raise DatabaseError("Save with update_fields did not affect any rows.") - if not updated: - 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 = cls._base_manager.using(using).filter( - **{field.name: getattr(self, field.attname)}).count() - self._order = order_value - - fields = meta.local_concrete_fields - if not pk_set: - fields = [f for f in fields if not isinstance(f, AutoField)] - - update_pk = bool(meta.has_auto_field and not pk_set) - result = self._do_insert(cls._base_manager, using, fields, update_pk, raw) - if update_pk: - setattr(self, meta.pk.attname, result) - return updated - - def _do_update(self, base_qs, using, pk_val, values, update_fields, forced_update): - """ - This method will try to update the model. If the model was updated (in - the sense that an update query was done and a matching row was found - from the DB) the method will return True. - """ - filtered = base_qs.filter(pk=pk_val) - if not values: - # We can end up here when saving a model in inheritance chain where - # update_fields doesn't target any field in current model. In that - # case we just say the update succeeded. Another case ending up here - # is a model with just PK - in that case check that the PK still - # exists. - return update_fields is not None or filtered.exists() - if self._meta.select_on_save and not forced_update: - if filtered.exists(): - filtered._update(values) - return True - else: - return False - return filtered._update(values) > 0 - - def _do_insert(self, manager, using, fields, update_pk, raw): - """ - Do an INSERT. If update_pk is defined then this method should return - the new pk for the model. - """ - return manager._insert([self], fields=fields, return_id=update_pk, - using=using, raw=raw) - - 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_text(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 = 'gt' if is_next else 'lt' - order = '' if is_next else '-' - param = force_text(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 = 'gt' if is_next else 'lt' - order = '_order' if is_next else '-_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): - if self.pk is None: - raise ValueError("Unsaved model instance %r cannot be used in an ORM query." % self) - 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): - 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': six.text_type(capfirst(opts.get_field(field).verbose_name)), - 'date_field': six.text_type(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': six.text_type(model_name), - 'field_label': six.text_type(field_label) - } - # unique_together - else: - field_labels = [capfirst(opts.get_field(f).verbose_name) for f in unique_check] - field_labels = get_text_list(field_labels, _('and')) - return _("%(model_name)s with this %(field_label)s already exists.") % { - 'model_name': six.text_type(model_name), - 'field_label': six.text_type(field_labels) - } - - def full_clean(self, exclude=None, validate_unique=True): - """ - Calls clean_fields, clean, and validate_unique, on the model, - and raises a ``ValidationError`` for any errors that occurred. - """ - 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. - if validate_unique: - 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 f.empty_values: - continue - try: - setattr(self, f.attname, f.clean(raw_value, self)) - except ValidationError as e: - errors[f.name] = e.error_list - - 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. - with transaction.commit_on_success_unless_managed(using=using): - for i, j in enumerate(id_list): - ordered_obj.objects.filter(**{'pk': j, order_name: rel_val}).update(_order=i) - - -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.model_name), func)(self, *args, **kwargs) - - -######## -# MISC # -######## - -class Empty(object): - pass - -def simple_class_factory(model, attrs): - """ - Needed for dynamic classes. - """ - return model - -def model_unpickle(model_id, attrs, factory): - """ - Used to unpickle Model subclasses with deferred fields. - """ - if isinstance(model_id, tuple): - model = get_model(*model_id) - else: - # Backwards compat - the model was cached directly in earlier versions. - model = model_id - cls = factory(model, attrs) - return cls.__new__(cls) -model_unpickle.__safe_for_unpickle__ = True - - -def unpickle_inner_exception(klass, exception_name): - # Get the exception class from the class it is attached to: - exception = getattr(klass, exception_name) - return exception.__new__(exception) |