1049 lines
45 KiB
Python
1049 lines
45 KiB
Python
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, MODELS_MODULE_NAME
|
|
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 from the package
|
|
# or module named 'models'. If no such package or module exists,
|
|
# fall back to looking one level up from the module this model is
|
|
# defined in.
|
|
|
|
# For 'django.contrib.sites.models', this would be 'sites'.
|
|
# For 'geo.models.places' this would be 'geo'.
|
|
|
|
model_module = sys.modules[new_class.__module__]
|
|
package_components = model_module.__name__.split('.')
|
|
package_components.reverse() # find the last occurrence of 'models'
|
|
try:
|
|
app_label_index = package_components.index(MODELS_MODULE_NAME) + 1
|
|
except ValueError:
|
|
app_label_index = 1
|
|
kwargs = {"app_label": package_components[app_label_index]}
|
|
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 = new_class._meta.app_cache.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()
|
|
|
|
new_class._meta.app_cache.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 new_class._meta.app_cache.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 not six.PY3 and hasattr(self, '__unicode__'):
|
|
if type(self).__unicode__ == Model.__str__:
|
|
klass_name = type(self).__name__
|
|
raise RuntimeError("%s.__unicode__ is aliased to __str__. Did"
|
|
" you apply @python_2_unicode_compatible"
|
|
" without defining __str__?" % klass_name)
|
|
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]
|
|
updated = self._do_update(base_qs, using, pk_val, values, update_fields)
|
|
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):
|
|
"""
|
|
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.
|
|
"""
|
|
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 base_qs.filter(pk=pk_val).exists()
|
|
else:
|
|
return base_qs.filter(pk=pk_val)._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):
|
|
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 #
|
|
########
|
|
|
|
|
|
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)
|