django/db/models/options.py

   1 import re
   2 from bisect import bisect
   3 try:
   4     set
   5 except NameError:
   6     from sets import Set as set     # Python 2.3 fallback
   7
   8 from django.conf import settings
   9 from django.db.models.related import RelatedObject
  10 from django.db.models.fields.related import ManyToManyRel
  11 from django.db.models.fields import AutoField, FieldDoesNotExist
  12 from django.db.models.fields.proxy import OrderWrt
  13 from django.db.models.loading import get_models, app_cache_ready
  14 from django.db.models import Manager
  15 from django.utils.translation import activate, deactivate_all, get_language, string_concat
  16 from django.utils.encoding import force_unicode, smart_str
  17 from django.utils.datastructures import SortedDict
  18
  19 # Calculate the verbose_name by converting from InitialCaps to "lowercase with spaces".
  20 get_verbose_name = lambda class_name: re.sub('(((?<=[a-z])[A-Z])|([A-Z](?![A-Z]|$)))', ' \\1', class_name).lower().strip()
  21
  22 DEFAULT_NAMES = ('verbose_name', 'db_table', 'ordering',
  23                  'unique_together', 'permissions', 'get_latest_by',
  24                  'order_with_respect_to', 'app_label', 'db_tablespace',
  25                  'abstract')
  26
  27 class Options(object):
  28     def __init__(self, meta):
  29         self.local_fields, self.local_many_to_many = [], []
  30         self.module_name, self.verbose_name = None, None
  31         self.verbose_name_plural = None
  32         self.db_table = ''
  33         self.ordering = []
  34         self.unique_together =  []
  35         self.permissions =  []
  36         self.object_name, self.app_label = None, None
  37         self.get_latest_by = None
  38         self.order_with_respect_to = None
  39         self.db_tablespace = settings.DEFAULT_TABLESPACE
  40         self.admin = None
  41         self.meta = meta
  42         self.pk = None
  43         self.has_auto_field, self.auto_field = False, None
  44         self.one_to_one_field = None
  45         self.abstract = False
  46         self.parents = SortedDict()
  47
  48     def contribute_to_class(self, cls, name):
  49         cls._meta = self
  50         self.installed = re.sub('\.models$', '', cls.__module__) in settings.INSTALLED_APPS
  51         # First, construct the default values for these options.
  52         self.object_name = cls.__name__
  53         self.module_name = self.object_name.lower()
  54         self.verbose_name = get_verbose_name(self.object_name)
  55
  56         # Next, apply any overridden values from 'class Meta'.
  57         if self.meta:
  58             meta_attrs = self.meta.__dict__.copy()
  59             del meta_attrs['__module__']
  60             del meta_attrs['__doc__']
  61             for attr_name in DEFAULT_NAMES:
  62                 if attr_name in meta_attrs:
  63                     setattr(self, attr_name, meta_attrs.pop(attr_name))
  64                 elif hasattr(self.meta, attr_name):
  65                     setattr(self, attr_name, getattr(self.meta, attr_name))
  66
  67             # unique_together can be either a tuple of tuples, or a single
  68             # tuple of two strings. Normalize it to a tuple of tuples, so that
  69             # calling code can uniformly expect that.
  70             ut = meta_attrs.pop('unique_together', getattr(self, 'unique_together'))
  71             if ut and not isinstance(ut[0], (tuple, list)):
  72                 ut = (ut,)
  73             setattr(self, 'unique_together', ut)
  74
  75             # verbose_name_plural is a special case because it uses a 's'
  76             # by default.
  77             setattr(self, 'verbose_name_plural', meta_attrs.pop('verbose_name_plural', string_concat(self.verbose_name, 's')))
  78
  79             # Any leftover attributes must be invalid.
  80             if meta_attrs != {}:
  81                 raise TypeError, "'class Meta' got invalid attribute(s): %s" % ','.join(meta_attrs.keys())
  82         else:
  83             self.verbose_name_plural = string_concat(self.verbose_name, 's')
  84         del self.meta
  85
  86     def _prepare(self, model):
  87         from django.db import connection
  88         from django.db.backends.util import truncate_name
  89         if self.order_with_respect_to:
  90             self.order_with_respect_to = self.get_field(self.order_with_respect_to)
  91             self.ordering = ('_order',)
  92         else:
  93             self.order_with_respect_to = None
  94
  95         if self.pk is None:
  96             if self.parents:
  97                 # Promote the first parent link in lieu of adding yet another
  98                 # field.
  99                 field = self.parents.value_for_index(0)
 100                 field.primary_key = True
 101                 self.pk = field
 102             else:
 103                 auto = AutoField(verbose_name='ID', primary_key=True,
 104                         auto_created=True)
 105                 model.add_to_class('id', auto)
 106
 107         # If the db_table wasn't provided, use the app_label + module_name.
 108         if not self.db_table:
 109             self.db_table = "%s_%s" % (self.app_label, self.module_name)
 110             self.db_table = truncate_name(self.db_table, connection.ops.max_name_length())
 111
 112     def add_field(self, field):
 113         # Insert the given field in the order in which it was created, using
 114         # the "creation_counter" attribute of the field.
 115         # Move many-to-many related fields from self.fields into
 116         # self.many_to_many.
 117         if field.rel and isinstance(field.rel, ManyToManyRel):
 118             self.local_many_to_many.insert(bisect(self.local_many_to_many, field), field)
 119             if hasattr(self, '_m2m_cache'):
 120                 del self._m2m_cache
 121         else:
 122             self.local_fields.insert(bisect(self.local_fields, field), field)
 123             self.setup_pk(field)
 124             if hasattr(self, '_field_cache'):
 125                 del self._field_cache
 126                 del self._field_name_cache
 127
 128         if hasattr(self, '_name_map'):
 129             del self._name_map
 130
 131     def setup_pk(self, field):
 132         if not self.pk and field.primary_key:
 133             self.pk = field
 134             field.serialize = False
 135
 136     def __repr__(self):
 137         return '<Options for %s>' % self.object_name
 138
 139     def __str__(self):
 140         return "%s.%s" % (smart_str(self.app_label), smart_str(self.module_name))
 141
 142     def verbose_name_raw(self):
 143         """
 144         There are a few places where the untranslated verbose name is needed
 145         (so that we get the same value regardless of currently active
 146         locale).
 147         """
 148         lang = get_language()
 149         deactivate_all()
 150         raw = force_unicode(self.verbose_name)
 151         activate(lang)
 152         return raw
 153     verbose_name_raw = property(verbose_name_raw)
 154
 155     def _fields(self):
 156         """
 157         The getter for self.fields. This returns the list of field objects
 158         available to this model (including through parent models).
 159
 160         Callers are not permitted to modify this list, since it's a reference
 161         to this instance (not a copy).
 162         """
 163         try:
 164             self._field_name_cache
 165         except AttributeError:
 166             self._fill_fields_cache()
 167         return self._field_name_cache
 168     fields = property(_fields)
 169
 170     def get_fields_with_model(self):
 171         """
 172         Returns a sequence of (field, model) pairs for all fields. The "model"
 173         element is None for fields on the current model. Mostly of use when
 174         constructing queries so that we know which model a field belongs to.
 175         """
 176         try:
 177             self._field_cache
 178         except AttributeError:
 179             self._fill_fields_cache()
 180         return self._field_cache
 181
 182     def _fill_fields_cache(self):
 183         cache = []
 184         for parent in self.parents:
 185             for field, model in parent._meta.get_fields_with_model():
 186                 if model:
 187                     cache.append((field, model))
 188                 else:
 189                     cache.append((field, parent))
 190         cache.extend([(f, None) for f in self.local_fields])
 191         self._field_cache = tuple(cache)
 192         self._field_name_cache = [x for x, _ in cache]
 193
 194     def _many_to_many(self):
 195         try:
 196             self._m2m_cache
 197         except AttributeError:
 198             self._fill_m2m_cache()
 199         return self._m2m_cache.keys()
 200     many_to_many = property(_many_to_many)
 201
 202     def get_m2m_with_model(self):
 203         """
 204         The many-to-many version of get_fields_with_model().
 205         """
 206         try:
 207             self._m2m_cache
 208         except AttributeError:
 209             self._fill_m2m_cache()
 210         return self._m2m_cache.items()
 211
 212     def _fill_m2m_cache(self):
 213         cache = SortedDict()
 214         for parent in self.parents:
 215             for field, model in parent._meta.get_m2m_with_model():
 216                 if model:
 217                     cache[field] = model
 218                 else:
 219                     cache[field] = parent
 220         for field in self.local_many_to_many:
 221             cache[field] = None
 222         self._m2m_cache = cache
 223
 224     def get_field(self, name, many_to_many=True):
 225         """
 226         Returns the requested field by name. Raises FieldDoesNotExist on error.
 227         """
 228         to_search = many_to_many and (self.fields + self.many_to_many) or self.fields
 229         for f in to_search:
 230             if f.name == name:
 231                 return f
 232         raise FieldDoesNotExist, '%s has no field named %r' % (self.object_name, name)
 233
 234     def get_field_by_name(self, name):
 235         """
 236         Returns the (field_object, model, direct, m2m), where field_object is
 237         the Field instance for the given name, model is the model containing
 238         this field (None for local fields), direct is True if the field exists
 239         on this model, and m2m is True for many-to-many relations. When
 240         'direct' is False, 'field_object' is the corresponding RelatedObject
 241         for this field (since the field doesn't have an instance associated
 242         with it).
 243
 244         Uses a cache internally, so after the first access, this is very fast.
 245         """
 246         try:
 247             try:
 248                 return self._name_map[name]
 249             except AttributeError:
 250                 cache = self.init_name_map()
 251                 return self._name_map[name]
 252         except KeyError:
 253             raise FieldDoesNotExist('%s has no field named %r'
 254                     % (self.object_name, name))
 255
 256     def get_all_field_names(self):
 257         """
 258         Returns a list of all field names that are possible for this model
 259         (including reverse relation names).
 260         """
 261         try:
 262             cache = self._name_map
 263         except AttributeError:
 264             cache = self.init_name_map()
 265         names = cache.keys()
 266         names.sort()
 267         return names
 268
 269     def init_name_map(self):
 270         """
 271         Initialises the field name -> field object mapping.
 272         """
 273         cache = dict([(f.name, (f, m, True, False)) for f, m in
 274                 self.get_fields_with_model()])
 275         for f, model in self.get_m2m_with_model():
 276             cache[f.name] = (f, model, True, True)
 277         for f, model in self.get_all_related_m2m_objects_with_model():
 278             cache[f.field.related_query_name()] = (f, model, False, True)
 279         for f, model in self.get_all_related_objects_with_model():
 280             cache[f.field.related_query_name()] = (f, model, False, False)
 281         if self.order_with_respect_to:
 282             cache['_order'] = OrderWrt(), None, True, False
 283         if app_cache_ready():
 284             self._name_map = cache
 285         return cache
 286
 287     def get_add_permission(self):
 288         return 'add_%s' % self.object_name.lower()
 289
 290     def get_change_permission(self):
 291         return 'change_%s' % self.object_name.lower()
 292
 293     def get_delete_permission(self):
 294         return 'delete_%s' % self.object_name.lower()
 295
 296     def get_all_related_objects(self, local_only=False):
 297         try:
 298             self._related_objects_cache
 299         except AttributeError:
 300             self._fill_related_objects_cache()
 301         if local_only:
 302             return [k for k, v in self._related_objects_cache.items() if not v]
 303         return self._related_objects_cache.keys()
 304
 305     def get_all_related_objects_with_model(self):
 306         """
 307         Returns a list of (related-object, model) pairs. Similar to
 308         get_fields_with_model().
 309         """
 310         try:
 311             self._related_objects_cache
 312         except AttributeError:
 313             self._fill_related_objects_cache()
 314         return self._related_objects_cache.items()
 315
 316     def _fill_related_objects_cache(self):
 317         cache = SortedDict()
 318         parent_list = self.get_parent_list()
 319         for parent in self.parents:
 320             for obj, model in parent._meta.get_all_related_objects_with_model():
 321                 if (obj.field.creation_counter < 0 or obj.field.rel.parent_link) and obj.model not in parent_list:
 322                     continue
 323                 if not model:
 324                     cache[obj] = parent
 325                 else:
 326                     cache[obj] = model
 327         for klass in get_models():
 328             for f in klass._meta.local_fields:
 329                 if f.rel and not isinstance(f.rel.to, str) and self == f.rel.to._meta:
 330                     cache[RelatedObject(f.rel.to, klass, f)] = None
 331         self._related_objects_cache = cache
 332
 333     def get_all_related_many_to_many_objects(self, local_only=False):
 334         try:
 335             cache = self._related_many_to_many_cache
 336         except AttributeError:
 337             cache = self._fill_related_many_to_many_cache()
 338         if local_only:
 339             return [k for k, v in cache.items() if not v]
 340         return cache.keys()
 341
 342     def get_all_related_m2m_objects_with_model(self):
 343         """
 344         Returns a list of (related-m2m-object, model) pairs. Similar to
 345         get_fields_with_model().
 346         """
 347         try:
 348             cache = self._related_many_to_many_cache
 349         except AttributeError:
 350             cache = self._fill_related_many_to_many_cache()
 351         return cache.items()
 352
 353     def _fill_related_many_to_many_cache(self):
 354         cache = SortedDict()
 355         parent_list = self.get_parent_list()
 356         for parent in self.parents:
 357             for obj, model in parent._meta.get_all_related_m2m_objects_with_model():
 358                 if obj.field.creation_counter < 0 and obj.model not in parent_list:
 359                     continue
 360                 if not model:
 361                     cache[obj] = parent
 362                 else:
 363                     cache[obj] = model
 364         for klass in get_models():
 365             for f in klass._meta.local_many_to_many:
 366                 if f.rel and not isinstance(f.rel.to, str) and self == f.rel.to._meta:
 367                     cache[RelatedObject(f.rel.to, klass, f)] = None
 368         if app_cache_ready():
 369             self._related_many_to_many_cache = cache
 370         return cache
 371
 372     def get_followed_related_objects(self, follow=None):
 373         if follow == None:
 374             follow = self.get_follow()
 375         return [f for f in self.get_all_related_objects() if follow.get(f.name, None)]
 376
 377     def get_data_holders(self, follow=None):
 378         if follow == None:
 379             follow = self.get_follow()
 380         return [f for f in self.fields + self.many_to_many + self.get_all_related_objects() if follow.get(f.name, None)]
 381
 382     def get_follow(self, override=None):
 383         follow = {}
 384         for f in self.fields + self.many_to_many + self.get_all_related_objects():
 385             if override and f.name in override:
 386                 child_override = override[f.name]
 387             else:
 388                 child_override = None
 389             fol = f.get_follow(child_override)
 390             if fol != None:
 391                 follow[f.name] = fol
 392         return follow
 393
 394     def get_base_chain(self, model):
 395         """
 396         Returns a list of parent classes leading to 'model' (order from closet
 397         to most distant ancestor). This has to handle the case were 'model' is
 398         a granparent or even more distant relation.
 399         """
 400         if not self.parents:
 401             return
 402         if model in self.parents:
 403             return [model]
 404         for parent in self.parents:
 405             res = parent._meta.get_base_chain(model)
 406             if res:
 407                 res.insert(0, parent)
 408                 return res
 409         raise TypeError('%r is not an ancestor of this model'
 410                 % model._meta.module_name)
 411
 412     def get_parent_list(self):
 413         """
 414         Returns a list of all the ancestor of this model as a list. Useful for
 415         determining if something is an ancestor, regardless of lineage.
 416         """
 417         result = set()
 418         for parent in self.parents:
 419             result.add(parent)
 420             result.update(parent._meta.get_parent_list())
 421         return result
 422
 423     def get_ordered_objects(self):
 424         "Returns a list of Options objects that are ordered with respect to this object."
 425         if not hasattr(self, '_ordered_objects'):
 426             objects = []
 427             # TODO
 428             #for klass in get_models(get_app(self.app_label)):
 429             #    opts = klass._meta
 430             #    if opts.order_with_respect_to and opts.order_with_respect_to.rel \
 431             #        and self == opts.order_with_respect_to.rel.to._meta:
 432             #        objects.append(opts)
 433             self._ordered_objects = objects
 434         return self._ordered_objects
 435
 436     def has_field_type(self, field_type, follow=None):
 437         """
 438         Returns True if this object's admin form has at least one of the given
 439         field_type (e.g. FileField).
 440         """
 441         # TODO: follow
 442         if not hasattr(self, '_field_types'):
 443             self._field_types = {}
 444         if field_type not in self._field_types:
 445             try:
 446                 # First check self.fields.
 447                 for f in self.fields:
 448                     if isinstance(f, field_type):
 449                         raise StopIteration
 450                 # Failing that, check related fields.
 451                 for related in self.get_followed_related_objects(follow):
 452                     for f in related.opts.fields:
 453                         if isinstance(f, field_type):
 454                             raise StopIteration
 455             except StopIteration:
 456                 self._field_types[field_type] = True
 457             else:
 458                 self._field_types[field_type] = False
 459         return self._field_types[field_type]
 460
 461 class AdminOptions(object):
 462     def __init__(self, fields=None, js=None, list_display=None, list_display_links=None, list_filter=None,
 463         date_hierarchy=None, save_as=False, ordering=None, search_fields=None,
 464         save_on_top=False, list_select_related=False, manager=None, list_per_page=100):
 465         self.fields = fields
 466         self.js = js or []
 467         self.list_display = list_display or ['__str__']
 468         self.list_display_links = list_display_links or []
 469         self.list_filter = list_filter or []
 470         self.date_hierarchy = date_hierarchy
 471         self.save_as, self.ordering = save_as, ordering
 472         self.search_fields = search_fields or []
 473         self.save_on_top = save_on_top
 474         self.list_select_related = list_select_related
 475         self.list_per_page = list_per_page
 476         self.manager = manager or Manager()
 477
 478     def get_field_sets(self, opts):
 479         "Returns a list of AdminFieldSet objects for this AdminOptions object."
 480         if self.fields is None:
 481             field_struct = ((None, {'fields': [f.name for f in opts.fields + opts.many_to_many if f.editable and not isinstance(f, AutoField)]}),)
 482         else:
 483             field_struct = self.fields
 484         new_fieldset_list = []
 485         for fieldset in field_struct:
 486             fs_options = fieldset[1]
 487             classes = fs_options.get('classes', ())
 488             description = fs_options.get('description', '')
 489             new_fieldset_list.append(AdminFieldSet(fieldset[0], classes,
 490                 opts.get_field, fs_options['fields'], description))
 491         return new_fieldset_list
 492
 493     def contribute_to_class(self, cls, name):
 494         cls._meta.admin = self
 495         # Make sure the admin manager has access to the model
 496         self.manager.model = cls
 497
 498 class AdminFieldSet(object):
 499     def __init__(self, name, classes, field_locator_func, line_specs, description):
 500         self.name = name
 501         self.field_lines = [AdminFieldLine(field_locator_func, line_spec) for line_spec in line_specs]
 502         self.classes = classes
 503         self.description = description
 504
 505     def __repr__(self):
 506         return "FieldSet: (%s, %s)" % (self.name, self.field_lines)
 507
 508     def bind(self, field_mapping, original, bound_field_set_class):
 509         return bound_field_set_class(self, field_mapping, original)
 510
 511     def __iter__(self):
 512         for field_line in self.field_lines:
 513             yield field_line
 514
 515     def __len__(self):
 516         return len(self.field_lines)
 517
 518 class AdminFieldLine(object):
 519     def __init__(self, field_locator_func, linespec):
 520         if isinstance(linespec, basestring):
 521             self.fields = [field_locator_func(linespec)]
 522         else:
 523             self.fields = [field_locator_func(field_name) for field_name in linespec]
 524
 525     def bind(self, field_mapping, original, bound_field_line_class):
 526         return bound_field_line_class(self, field_mapping, original)
 527
 528     def __iter__(self):
 529         for field in self.fields:
 530             yield field
 531
 532     def __len__(self):
 533         return len(self.fields)