|
1 import copy |
|
2 import types |
|
3 import sys |
|
4 import os |
|
5 from itertools import izip |
|
6 |
|
7 import django.db.models.manipulators # Imported to register signal handler. |
|
8 import django.db.models.manager # Ditto. |
|
9 from django.core import validators |
|
10 from django.core.exceptions import ObjectDoesNotExist, MultipleObjectsReturned, FieldError |
|
11 from django.db.models.fields import AutoField, ImageField, FieldDoesNotExist |
|
12 from django.db.models.fields.related import OneToOneRel, ManyToOneRel, OneToOneField |
|
13 from django.db.models.query import delete_objects, Q |
|
14 from django.db.models.options import Options, AdminOptions |
|
15 from django.db import connection, transaction |
|
16 from django.db.models import signals |
|
17 from django.db.models.loading import register_models, get_model |
|
18 from django.dispatch import dispatcher |
|
19 from django.utils.datastructures import SortedDict |
|
20 from django.utils.functional import curry |
|
21 from django.utils.encoding import smart_str, force_unicode, smart_unicode |
|
22 from django.conf import settings |
|
23 |
|
24 try: |
|
25 set |
|
26 except NameError: |
|
27 from sets import Set as set # Python 2.3 fallback |
|
28 |
|
29 class ModelBase(type): |
|
30 "Metaclass for all models" |
|
31 def __new__(cls, name, bases, attrs): |
|
32 # If this isn't a subclass of Model, don't do anything special. |
|
33 try: |
|
34 parents = [b for b in bases if issubclass(b, Model)] |
|
35 except NameError: |
|
36 # 'Model' isn't defined yet, meaning we're looking at Django's own |
|
37 # Model class, defined below. |
|
38 parents = [] |
|
39 if not parents: |
|
40 return super(ModelBase, cls).__new__(cls, name, bases, attrs) |
|
41 |
|
42 # Create the class. |
|
43 module = attrs.pop('__module__') |
|
44 new_class = type.__new__(cls, name, bases, {'__module__': module}) |
|
45 attr_meta = attrs.pop('Meta', None) |
|
46 abstract = getattr(attr_meta, 'abstract', False) |
|
47 if not attr_meta: |
|
48 meta = getattr(new_class, 'Meta', None) |
|
49 else: |
|
50 meta = attr_meta |
|
51 base_meta = getattr(new_class, '_meta', None) |
|
52 |
|
53 new_class.add_to_class('_meta', Options(meta)) |
|
54 if not abstract: |
|
55 new_class.add_to_class('DoesNotExist', |
|
56 subclass_exception('DoesNotExist', ObjectDoesNotExist, module)) |
|
57 new_class.add_to_class('MultipleObjectsReturned', |
|
58 subclass_exception('MultipleObjectsReturned', MultipleObjectsReturned, module)) |
|
59 if base_meta and not base_meta.abstract: |
|
60 # Non-abstract child classes inherit some attributes from their |
|
61 # non-abstract parent (unless an ABC comes before it in the |
|
62 # method resolution order). |
|
63 if not hasattr(meta, 'ordering'): |
|
64 new_class._meta.ordering = base_meta.ordering |
|
65 if not hasattr(meta, 'get_latest_by'): |
|
66 new_class._meta.get_latest_by = base_meta.get_latest_by |
|
67 |
|
68 old_default_mgr = None |
|
69 if getattr(new_class, '_default_manager', None): |
|
70 # We have a parent who set the default manager. |
|
71 if new_class._default_manager.model._meta.abstract: |
|
72 old_default_mgr = new_class._default_manager |
|
73 new_class._default_manager = None |
|
74 if getattr(new_class._meta, 'app_label', None) is None: |
|
75 # Figure out the app_label by looking one level up. |
|
76 # For 'django.contrib.sites.models', this would be 'sites'. |
|
77 model_module = sys.modules[new_class.__module__] |
|
78 new_class._meta.app_label = model_module.__name__.split('.')[-2] |
|
79 |
|
80 # Bail out early if we have already created this class. |
|
81 m = get_model(new_class._meta.app_label, name, False) |
|
82 if m is not None: |
|
83 return m |
|
84 |
|
85 # Add all attributes to the class. |
|
86 for obj_name, obj in attrs.items(): |
|
87 new_class.add_to_class(obj_name, obj) |
|
88 |
|
89 # Do the appropriate setup for any model parents. |
|
90 o2o_map = dict([(f.rel.to, f) for f in new_class._meta.local_fields |
|
91 if isinstance(f, OneToOneField)]) |
|
92 for base in parents: |
|
93 if not hasattr(base, '_meta'): |
|
94 # Things without _meta aren't functional models, so they're |
|
95 # uninteresting parents. |
|
96 continue |
|
97 if not base._meta.abstract: |
|
98 if base in o2o_map: |
|
99 field = o2o_map[base] |
|
100 field.primary_key = True |
|
101 new_class._meta.setup_pk(field) |
|
102 else: |
|
103 attr_name = '%s_ptr' % base._meta.module_name |
|
104 field = OneToOneField(base, name=attr_name, |
|
105 auto_created=True, parent_link=True) |
|
106 new_class.add_to_class(attr_name, field) |
|
107 new_class._meta.parents[base] = field |
|
108 else: |
|
109 # The abstract base class case. |
|
110 names = set([f.name for f in new_class._meta.local_fields + new_class._meta.many_to_many]) |
|
111 for field in base._meta.local_fields + base._meta.local_many_to_many: |
|
112 if field.name in names: |
|
113 raise FieldError('Local field %r in class %r clashes with field of similar name from abstract base class %r' |
|
114 % (field.name, name, base.__name__)) |
|
115 new_class.add_to_class(field.name, copy.deepcopy(field)) |
|
116 |
|
117 if abstract: |
|
118 # Abstract base models can't be instantiated and don't appear in |
|
119 # the list of models for an app. We do the final setup for them a |
|
120 # little differently from normal models. |
|
121 attr_meta.abstract = False |
|
122 new_class.Meta = attr_meta |
|
123 return new_class |
|
124 |
|
125 if old_default_mgr and not new_class._default_manager: |
|
126 new_class._default_manager = old_default_mgr._copy_to_model(new_class) |
|
127 new_class._prepare() |
|
128 register_models(new_class._meta.app_label, new_class) |
|
129 |
|
130 # Because of the way imports happen (recursively), we may or may not be |
|
131 # the first time this model tries to register with the framework. There |
|
132 # should only be one class for each model, so we always return the |
|
133 # registered version. |
|
134 return get_model(new_class._meta.app_label, name, False) |
|
135 |
|
136 def add_to_class(cls, name, value): |
|
137 if name == 'Admin': |
|
138 assert type(value) == types.ClassType, "%r attribute of %s model must be a class, not a %s object" % (name, cls.__name__, type(value)) |
|
139 value = AdminOptions(**dict([(k, v) for k, v in value.__dict__.items() if not k.startswith('_')])) |
|
140 if hasattr(value, 'contribute_to_class'): |
|
141 value.contribute_to_class(cls, name) |
|
142 else: |
|
143 setattr(cls, name, value) |
|
144 |
|
145 def _prepare(cls): |
|
146 # Creates some methods once self._meta has been populated. |
|
147 opts = cls._meta |
|
148 opts._prepare(cls) |
|
149 |
|
150 if opts.order_with_respect_to: |
|
151 cls.get_next_in_order = curry(cls._get_next_or_previous_in_order, is_next=True) |
|
152 cls.get_previous_in_order = curry(cls._get_next_or_previous_in_order, is_next=False) |
|
153 setattr(opts.order_with_respect_to.rel.to, 'get_%s_order' % cls.__name__.lower(), curry(method_get_order, cls)) |
|
154 setattr(opts.order_with_respect_to.rel.to, 'set_%s_order' % cls.__name__.lower(), curry(method_set_order, cls)) |
|
155 |
|
156 # Give the class a docstring -- its definition. |
|
157 if cls.__doc__ is None: |
|
158 cls.__doc__ = "%s(%s)" % (cls.__name__, ", ".join([f.attname for f in opts.fields])) |
|
159 |
|
160 if hasattr(cls, 'get_absolute_url'): |
|
161 cls.get_absolute_url = curry(get_absolute_url, opts, cls.get_absolute_url) |
|
162 |
|
163 dispatcher.send(signal=signals.class_prepared, sender=cls) |
|
164 |
|
165 class Model(object): |
|
166 __metaclass__ = ModelBase |
|
167 |
|
168 def __init__(self, *args, **kwargs): |
|
169 dispatcher.send(signal=signals.pre_init, sender=self.__class__, args=args, kwargs=kwargs) |
|
170 |
|
171 # There is a rather weird disparity here; if kwargs, it's set, then args |
|
172 # overrides it. It should be one or the other; don't duplicate the work |
|
173 # The reason for the kwargs check is that standard iterator passes in by |
|
174 # args, and instantiation for iteration is 33% faster. |
|
175 args_len = len(args) |
|
176 if args_len > len(self._meta.fields): |
|
177 # Daft, but matches old exception sans the err msg. |
|
178 raise IndexError("Number of args exceeds number of fields") |
|
179 |
|
180 fields_iter = iter(self._meta.fields) |
|
181 if not kwargs: |
|
182 # The ordering of the izip calls matter - izip throws StopIteration |
|
183 # when an iter throws it. So if the first iter throws it, the second |
|
184 # is *not* consumed. We rely on this, so don't change the order |
|
185 # without changing the logic. |
|
186 for val, field in izip(args, fields_iter): |
|
187 setattr(self, field.attname, val) |
|
188 else: |
|
189 # Slower, kwargs-ready version. |
|
190 for val, field in izip(args, fields_iter): |
|
191 setattr(self, field.attname, val) |
|
192 kwargs.pop(field.name, None) |
|
193 # Maintain compatibility with existing calls. |
|
194 if isinstance(field.rel, ManyToOneRel): |
|
195 kwargs.pop(field.attname, None) |
|
196 |
|
197 # Now we're left with the unprocessed fields that *must* come from |
|
198 # keywords, or default. |
|
199 |
|
200 for field in fields_iter: |
|
201 if kwargs: |
|
202 if isinstance(field.rel, ManyToOneRel): |
|
203 try: |
|
204 # Assume object instance was passed in. |
|
205 rel_obj = kwargs.pop(field.name) |
|
206 except KeyError: |
|
207 try: |
|
208 # Object instance wasn't passed in -- must be an ID. |
|
209 val = kwargs.pop(field.attname) |
|
210 except KeyError: |
|
211 val = field.get_default() |
|
212 else: |
|
213 # Object instance was passed in. Special case: You can |
|
214 # pass in "None" for related objects if it's allowed. |
|
215 if rel_obj is None and field.null: |
|
216 val = None |
|
217 else: |
|
218 try: |
|
219 val = getattr(rel_obj, field.rel.get_related_field().attname) |
|
220 except AttributeError: |
|
221 raise TypeError("Invalid value: %r should be a %s instance, not a %s" % |
|
222 (field.name, field.rel.to, type(rel_obj))) |
|
223 else: |
|
224 val = kwargs.pop(field.attname, field.get_default()) |
|
225 else: |
|
226 val = field.get_default() |
|
227 setattr(self, field.attname, val) |
|
228 |
|
229 if kwargs: |
|
230 for prop in kwargs.keys(): |
|
231 try: |
|
232 if isinstance(getattr(self.__class__, prop), property): |
|
233 setattr(self, prop, kwargs.pop(prop)) |
|
234 except AttributeError: |
|
235 pass |
|
236 if kwargs: |
|
237 raise TypeError, "'%s' is an invalid keyword argument for this function" % kwargs.keys()[0] |
|
238 dispatcher.send(signal=signals.post_init, sender=self.__class__, instance=self) |
|
239 |
|
240 def __repr__(self): |
|
241 return smart_str(u'<%s: %s>' % (self.__class__.__name__, unicode(self))) |
|
242 |
|
243 def __str__(self): |
|
244 if hasattr(self, '__unicode__'): |
|
245 return force_unicode(self).encode('utf-8') |
|
246 return '%s object' % self.__class__.__name__ |
|
247 |
|
248 def __eq__(self, other): |
|
249 return isinstance(other, self.__class__) and self._get_pk_val() == other._get_pk_val() |
|
250 |
|
251 def __ne__(self, other): |
|
252 return not self.__eq__(other) |
|
253 |
|
254 def __hash__(self): |
|
255 return hash(self._get_pk_val()) |
|
256 |
|
257 def _get_pk_val(self, meta=None): |
|
258 if not meta: |
|
259 meta = self._meta |
|
260 return getattr(self, meta.pk.attname) |
|
261 |
|
262 def _set_pk_val(self, value): |
|
263 return setattr(self, self._meta.pk.attname, value) |
|
264 |
|
265 pk = property(_get_pk_val, _set_pk_val) |
|
266 |
|
267 def save(self): |
|
268 """ |
|
269 Save the current instance. Override this in a subclass if you want to |
|
270 control the saving process. |
|
271 """ |
|
272 self.save_base() |
|
273 |
|
274 save.alters_data = True |
|
275 |
|
276 def save_base(self, raw=False, cls=None): |
|
277 """ |
|
278 Does the heavy-lifting involved in saving. Subclasses shouldn't need to |
|
279 override this method. It's separate from save() in order to hide the |
|
280 need for overrides of save() to pass around internal-only parameters |
|
281 ('raw' and 'cls'). |
|
282 """ |
|
283 if not cls: |
|
284 cls = self.__class__ |
|
285 meta = self._meta |
|
286 signal = True |
|
287 dispatcher.send(signal=signals.pre_save, sender=self.__class__, |
|
288 instance=self, raw=raw) |
|
289 else: |
|
290 meta = cls._meta |
|
291 signal = False |
|
292 |
|
293 for parent, field in meta.parents.items(): |
|
294 self.save_base(raw, parent) |
|
295 setattr(self, field.attname, self._get_pk_val(parent._meta)) |
|
296 |
|
297 non_pks = [f for f in meta.local_fields if not f.primary_key] |
|
298 |
|
299 # First, try an UPDATE. If that doesn't update anything, do an INSERT. |
|
300 pk_val = self._get_pk_val(meta) |
|
301 # Note: the comparison with '' is required for compatibility with |
|
302 # oldforms-style model creation. |
|
303 pk_set = pk_val is not None and smart_unicode(pk_val) != u'' |
|
304 record_exists = True |
|
305 manager = cls._default_manager |
|
306 if pk_set: |
|
307 # Determine whether a record with the primary key already exists. |
|
308 if manager.filter(pk=pk_val).extra(select={'a': 1}).values('a').order_by(): |
|
309 # It does already exist, so do an UPDATE. |
|
310 if non_pks: |
|
311 values = [(f, None, f.get_db_prep_save(raw and getattr(self, f.attname) or f.pre_save(self, False))) for f in non_pks] |
|
312 manager.filter(pk=pk_val)._update(values) |
|
313 else: |
|
314 record_exists = False |
|
315 if not pk_set or not record_exists: |
|
316 if not pk_set: |
|
317 values = [(f, f.get_db_prep_save(raw and getattr(self, f.attname) or f.pre_save(self, True))) for f in meta.local_fields if not isinstance(f, AutoField)] |
|
318 else: |
|
319 values = [(f, f.get_db_prep_save(raw and getattr(self, f.attname) or f.pre_save(self, True))) for f in meta.local_fields] |
|
320 |
|
321 if meta.order_with_respect_to: |
|
322 field = meta.order_with_respect_to |
|
323 values.append((meta.get_field_by_name('_order')[0], manager.filter(**{field.name: getattr(self, field.attname)}).count())) |
|
324 record_exists = False |
|
325 |
|
326 update_pk = bool(meta.has_auto_field and not pk_set) |
|
327 if values: |
|
328 # Create a new record. |
|
329 result = manager._insert(values, return_id=update_pk) |
|
330 else: |
|
331 # Create a new record with defaults for everything. |
|
332 result = manager._insert([(meta.pk, connection.ops.pk_default_value())], return_id=update_pk, raw_values=True) |
|
333 |
|
334 if update_pk: |
|
335 setattr(self, meta.pk.attname, result) |
|
336 transaction.commit_unless_managed() |
|
337 |
|
338 if signal: |
|
339 dispatcher.send(signal=signals.post_save, sender=self.__class__, |
|
340 instance=self, created=(not record_exists), raw=raw) |
|
341 |
|
342 save_base.alters_data = True |
|
343 |
|
344 def validate(self): |
|
345 """ |
|
346 First coerces all fields on this instance to their proper Python types. |
|
347 Then runs validation on every field. Returns a dictionary of |
|
348 field_name -> error_list. |
|
349 """ |
|
350 error_dict = {} |
|
351 invalid_python = {} |
|
352 for f in self._meta.fields: |
|
353 try: |
|
354 setattr(self, f.attname, f.to_python(getattr(self, f.attname, f.get_default()))) |
|
355 except validators.ValidationError, e: |
|
356 error_dict[f.name] = e.messages |
|
357 invalid_python[f.name] = 1 |
|
358 for f in self._meta.fields: |
|
359 if f.name in invalid_python: |
|
360 continue |
|
361 errors = f.validate_full(getattr(self, f.attname, f.get_default()), self.__dict__) |
|
362 if errors: |
|
363 error_dict[f.name] = errors |
|
364 return error_dict |
|
365 |
|
366 def _collect_sub_objects(self, seen_objs): |
|
367 """ |
|
368 Recursively populates seen_objs with all objects related to this object. |
|
369 When done, seen_objs will be in the format: |
|
370 {model_class: {pk_val: obj, pk_val: obj, ...}, |
|
371 model_class: {pk_val: obj, pk_val: obj, ...}, ...} |
|
372 """ |
|
373 pk_val = self._get_pk_val() |
|
374 if pk_val in seen_objs.setdefault(self.__class__, {}): |
|
375 return |
|
376 seen_objs.setdefault(self.__class__, {})[pk_val] = self |
|
377 |
|
378 for related in self._meta.get_all_related_objects(): |
|
379 rel_opts_name = related.get_accessor_name() |
|
380 if isinstance(related.field.rel, OneToOneRel): |
|
381 try: |
|
382 sub_obj = getattr(self, rel_opts_name) |
|
383 except ObjectDoesNotExist: |
|
384 pass |
|
385 else: |
|
386 sub_obj._collect_sub_objects(seen_objs) |
|
387 else: |
|
388 for sub_obj in getattr(self, rel_opts_name).all(): |
|
389 sub_obj._collect_sub_objects(seen_objs) |
|
390 |
|
391 def delete(self): |
|
392 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) |
|
393 |
|
394 # Find all the objects than need to be deleted |
|
395 seen_objs = SortedDict() |
|
396 self._collect_sub_objects(seen_objs) |
|
397 |
|
398 # Actually delete the objects |
|
399 delete_objects(seen_objs) |
|
400 |
|
401 delete.alters_data = True |
|
402 |
|
403 def _get_FIELD_display(self, field): |
|
404 value = getattr(self, field.attname) |
|
405 return force_unicode(dict(field.choices).get(value, value), strings_only=True) |
|
406 |
|
407 def _get_next_or_previous_by_FIELD(self, field, is_next, **kwargs): |
|
408 op = is_next and 'gt' or 'lt' |
|
409 order = not is_next and '-' or '' |
|
410 param = smart_str(getattr(self, field.attname)) |
|
411 q = Q(**{'%s__%s' % (field.name, op): param}) |
|
412 q = q|Q(**{field.name: param, 'pk__%s' % op: self.pk}) |
|
413 qs = self.__class__._default_manager.filter(**kwargs).filter(q).order_by('%s%s' % (order, field.name), '%spk' % order) |
|
414 try: |
|
415 return qs[0] |
|
416 except IndexError: |
|
417 raise self.DoesNotExist, "%s matching query does not exist." % self.__class__._meta.object_name |
|
418 |
|
419 def _get_next_or_previous_in_order(self, is_next): |
|
420 cachename = "__%s_order_cache" % is_next |
|
421 if not hasattr(self, cachename): |
|
422 qn = connection.ops.quote_name |
|
423 op = is_next and '>' or '<' |
|
424 order = not is_next and '-_order' or '_order' |
|
425 order_field = self._meta.order_with_respect_to |
|
426 # FIXME: When querysets support nested queries, this can be turned |
|
427 # into a pure queryset operation. |
|
428 where = ['%s %s (SELECT %s FROM %s WHERE %s=%%s)' % \ |
|
429 (qn('_order'), op, qn('_order'), |
|
430 qn(self._meta.db_table), qn(self._meta.pk.column))] |
|
431 params = [self.pk] |
|
432 obj = self._default_manager.filter(**{order_field.name: getattr(self, order_field.attname)}).extra(where=where, params=params).order_by(order)[:1].get() |
|
433 setattr(self, cachename, obj) |
|
434 return getattr(self, cachename) |
|
435 |
|
436 def _get_FIELD_filename(self, field): |
|
437 if getattr(self, field.attname): # value is not blank |
|
438 return os.path.join(settings.MEDIA_ROOT, getattr(self, field.attname)) |
|
439 return '' |
|
440 |
|
441 def _get_FIELD_url(self, field): |
|
442 if getattr(self, field.attname): # value is not blank |
|
443 import urlparse |
|
444 return urlparse.urljoin(settings.MEDIA_URL, getattr(self, field.attname)).replace('\\', '/') |
|
445 return '' |
|
446 |
|
447 def _get_FIELD_size(self, field): |
|
448 return os.path.getsize(self._get_FIELD_filename(field)) |
|
449 |
|
450 def _save_FIELD_file(self, field, filename, raw_contents, save=True): |
|
451 directory = field.get_directory_name() |
|
452 try: # Create the date-based directory if it doesn't exist. |
|
453 os.makedirs(os.path.join(settings.MEDIA_ROOT, directory)) |
|
454 except OSError: # Directory probably already exists. |
|
455 pass |
|
456 filename = field.get_filename(filename) |
|
457 |
|
458 # If the filename already exists, keep adding an underscore to the name of |
|
459 # the file until the filename doesn't exist. |
|
460 while os.path.exists(os.path.join(settings.MEDIA_ROOT, filename)): |
|
461 try: |
|
462 dot_index = filename.rindex('.') |
|
463 except ValueError: # filename has no dot |
|
464 filename += '_' |
|
465 else: |
|
466 filename = filename[:dot_index] + '_' + filename[dot_index:] |
|
467 |
|
468 # Write the file to disk. |
|
469 setattr(self, field.attname, filename) |
|
470 |
|
471 full_filename = self._get_FIELD_filename(field) |
|
472 fp = open(full_filename, 'wb') |
|
473 fp.write(raw_contents) |
|
474 fp.close() |
|
475 |
|
476 # Save the width and/or height, if applicable. |
|
477 if isinstance(field, ImageField) and (field.width_field or field.height_field): |
|
478 from django.utils.images import get_image_dimensions |
|
479 width, height = get_image_dimensions(full_filename) |
|
480 if field.width_field: |
|
481 setattr(self, field.width_field, width) |
|
482 if field.height_field: |
|
483 setattr(self, field.height_field, height) |
|
484 |
|
485 # Save the object because it has changed unless save is False |
|
486 if save: |
|
487 self.save() |
|
488 |
|
489 _save_FIELD_file.alters_data = True |
|
490 |
|
491 def _get_FIELD_width(self, field): |
|
492 return self._get_image_dimensions(field)[0] |
|
493 |
|
494 def _get_FIELD_height(self, field): |
|
495 return self._get_image_dimensions(field)[1] |
|
496 |
|
497 def _get_image_dimensions(self, field): |
|
498 cachename = "__%s_dimensions_cache" % field.name |
|
499 if not hasattr(self, cachename): |
|
500 from django.utils.images import get_image_dimensions |
|
501 filename = self._get_FIELD_filename(field) |
|
502 setattr(self, cachename, get_image_dimensions(filename)) |
|
503 return getattr(self, cachename) |
|
504 |
|
505 ############################################ |
|
506 # HELPER FUNCTIONS (CURRIED MODEL METHODS) # |
|
507 ############################################ |
|
508 |
|
509 # ORDERING METHODS ######################### |
|
510 |
|
511 def method_set_order(ordered_obj, self, id_list): |
|
512 rel_val = getattr(self, ordered_obj._meta.order_with_respect_to.rel.field_name) |
|
513 order_name = ordered_obj._meta.order_with_respect_to.name |
|
514 # FIXME: It would be nice if there was an "update many" version of update |
|
515 # for situations like this. |
|
516 for i, j in enumerate(id_list): |
|
517 ordered_obj.objects.filter(**{'pk': j, order_name: rel_val}).update(_order=i) |
|
518 transaction.commit_unless_managed() |
|
519 |
|
520 def method_get_order(ordered_obj, self): |
|
521 rel_val = getattr(self, ordered_obj._meta.order_with_respect_to.rel.field_name) |
|
522 order_name = ordered_obj._meta.order_with_respect_to.name |
|
523 pk_name = ordered_obj._meta.pk.name |
|
524 return [r[pk_name] for r in |
|
525 ordered_obj.objects.filter(**{order_name: rel_val}).values(pk_name)] |
|
526 |
|
527 ############################################## |
|
528 # HELPER FUNCTIONS (CURRIED MODEL FUNCTIONS) # |
|
529 ############################################## |
|
530 |
|
531 def get_absolute_url(opts, func, self, *args, **kwargs): |
|
532 return settings.ABSOLUTE_URL_OVERRIDES.get('%s.%s' % (opts.app_label, opts.module_name), func)(self, *args, **kwargs) |
|
533 |
|
534 ######## |
|
535 # MISC # |
|
536 ######## |
|
537 |
|
538 class Empty(object): |
|
539 pass |
|
540 |
|
541 if sys.version_info < (2, 5): |
|
542 # Prior to Python 2.5, Exception was an old-style class |
|
543 def subclass_exception(name, parent, unused): |
|
544 return types.ClassType(name, (parent,), {}) |
|
545 |
|
546 else: |
|
547 def subclass_exception(name, parent, module): |
|
548 return type(name, (parent,), {'__module__': module}) |
|
549 |