- {% trans "History" %} - {% if bound_manipulator.has_absolute_url %}
- {% trans "View on site" %} {% endif%} + {% if has_absolute_url %}
- {% trans "View on site" %} {% endif%}
{% if change %}{% if not is_popup %}
{% endblock %}
diff --git a/django/contrib/admin/templates/admin/change_list.html b/django/contrib/admin/templates/admin/change_list.html
index 17b388b699..5b54bfb8cc 100644
--- a/django/contrib/admin/templates/admin/change_list.html
+++ b/django/contrib/admin/templates/admin/change_list.html
@@ -1,8 +1,9 @@
-{% extends "admin/base_site" %}
+{% extends "admin/base_site.html" %}
{% load adminmedia admin_list i18n %}
+{% block stylesheet %}{% admin_media_prefix %}css/changelists.css{% endblock %}
{% block bodyclass %}change-list{% endblock %}
{% block userlinks %}{% trans 'Documentation' %} / {% trans 'Change password' %} / {% trans 'Log out' %}{% endblock %}
-{% if not is_popup %}{% block breadcrumbs %}{% endblock %}{% endif %}
+{% if not is_popup %}{% block breadcrumbs %}{% endblock %}{% endif %}
{% block coltype %}flex{% endblock %}
{% block content %}
diff --git a/django/contrib/admin/templates/admin/delete_confirmation.html b/django/contrib/admin/templates/admin/delete_confirmation.html
index 7fba4cebd7..f907c18a16 100644
--- a/django/contrib/admin/templates/admin/delete_confirmation.html
+++ b/django/contrib/admin/templates/admin/delete_confirmation.html
@@ -1,6 +1,14 @@
-{% extends "admin/base_site" %}
+{% extends "admin/base_site.html" %}
{% load i18n %}
{% block userlinks %}{% trans 'Documentation' %} / {% trans 'Change password' %} / {% trans 'Log out' %}{% endblock %}
+{% block breadcrumbs %}
+
+{% endblock %}
{% block content %}
{% if perms_lacking %}
diff --git a/django/contrib/admin/templates/admin/index.html b/django/contrib/admin/templates/admin/index.html
index aabd4eecca..246086861b 100644
--- a/django/contrib/admin/templates/admin/index.html
+++ b/django/contrib/admin/templates/admin/index.html
@@ -1,6 +1,7 @@
-{% extends "admin/base_site" %}
+{% extends "admin/base_site.html" %}
{% load i18n %}
+{% block stylesheet %}{% load adminmedia %}{% admin_media_prefix %}css/dashboard.css{% endblock %}
{% block coltype %}colMS{% endblock %}
{% block bodyclass %}dashboard{% endblock %}
{% block breadcrumbs %}{% endblock %}
@@ -13,14 +14,14 @@
{% if app_list %}
{% for app in app_list %}
{% blocktrans %}Deleting the {{ object_name }} '{{ object }}' would result in deleting related objects, but your account doesn't have permission to delete the following types of objects:{% endblocktrans %}
@@ -13,8 +21,10 @@{% blocktrans %}Are you sure you want to delete the {{ object_name }} "{{ object }}"? All of the following related items will be deleted:{% endblocktrans %}
- {{ deleted_objects|unordered_list }}
{{ bound_field.field.help_text }}
{% endif %} {% endfor %}
-
+
+ " % self.delta
-
- def __get_value__(self):
- return datetime.datetime.now() + self.delta
-
-################
-# MAIN CLASSES #
-################
-
-class FieldDoesNotExist(Exception):
- pass
-
-class BadKeywordArguments(Exception):
- pass
-
-class BoundRelatedObject(object):
- def __init__(self, related_object, field_mapping, original):
- self.relation = related_object
- self.field_mappings = field_mapping[related_object.opts.module_name]
-
- def template_name(self):
- raise NotImplementedError
-
- def __repr__(self):
- return repr(self.__dict__)
-
-class RelatedObject(object):
- def __init__(self, parent_opts, opts, field):
- self.parent_opts = parent_opts
- self.opts = opts
- self.field = field
- self.edit_inline = field.rel.edit_inline
- self.name = opts.module_name
- self.var_name = opts.object_name.lower()
-
- def flatten_data(self, follow, obj=None):
- new_data = {}
- rel_instances = self.get_list(obj)
- for i, rel_instance in enumerate(rel_instances):
- instance_data = {}
- for f in self.opts.fields + self.opts.many_to_many:
- # TODO: Fix for recursive manipulators.
- fol = follow.get(f.name, None)
- if fol:
- field_data = f.flatten_data(fol, rel_instance)
- for name, value in field_data.items():
- instance_data['%s.%d.%s' % (self.var_name, i, name)] = value
- new_data.update(instance_data)
- return new_data
-
- def extract_data(self, data):
- """
- Pull out the data meant for inline objects of this class,
- i.e. anything starting with our module name.
- """
- return data # TODO
-
- def get_list(self, parent_instance=None):
- "Get the list of this type of object from an instance of the parent class."
- if parent_instance != None:
- func_name = 'get_%s_list' % self.get_method_name_part()
- func = getattr(parent_instance, func_name)
- list = func()
-
- count = len(list) + self.field.rel.num_extra_on_change
- if self.field.rel.min_num_in_admin:
- count = max(count, self.field.rel.min_num_in_admin)
- if self.field.rel.max_num_in_admin:
- count = min(count, self.field.rel.max_num_in_admin)
-
- change = count - len(list)
- if change > 0:
- return list + [None] * change
- if change < 0:
- return list[:change]
- else: # Just right
- return list
- else:
- return [None] * self.field.rel.num_in_admin
-
- def editable_fields(self):
- "Get the fields in this class that should be edited inline."
- return [f for f in self.opts.fields + self.opts.many_to_many if f.editable and f != self.field]
-
- def get_follow(self, override=None):
- if isinstance(override, bool):
- if override:
- over = {}
- else:
- return None
- else:
- if override:
- over = override.copy()
- elif self.edit_inline:
- over = {}
- else:
- return None
-
- over[self.field.name] = False
- return self.opts.get_follow(over)
-
- def __repr__(self):
- return "" % ( self.name, self.field.name)
-
- def get_manipulator_fields(self, opts, manipulator, change, follow):
- # TODO: Remove core fields stuff.
- if change:
- meth_name = 'get_%s_count' % self.get_method_name_part()
- count = getattr(manipulator.original_object, meth_name)()
- count += self.field.rel.num_extra_on_change
- if self.field.rel.min_num_in_admin:
- count = max(count, self.field.rel.min_num_in_admin)
- if self.field.rel.max_num_in_admin:
- count = min(count, self.field.rel.max_num_in_admin)
- else:
- count = self.field.rel.num_in_admin
-
- fields = []
- for i in range(count):
- for f in self.opts.fields + self.opts.many_to_many:
- if follow.get(f.name, False):
- prefix = '%s.%d.' % (self.var_name, i)
- fields.extend(f.get_manipulator_fields(self.opts, manipulator, change, name_prefix=prefix, rel=True))
- return fields
-
- def bind(self, field_mapping, original, bound_related_object_class=BoundRelatedObject):
- return bound_related_object_class(self, field_mapping, original)
-
- def get_method_name_part(self):
- # This method encapsulates the logic that decides what name to give a
- # method that retrieves related many-to-one or many-to-many objects.
- # Usually it just uses the lower-cased object_name, but if the related
- # object is in another app, the related object's app_label is appended.
- #
- # Examples:
- #
- # # Normal case -- a related object in the same app.
- # # This method returns "choice".
- # Poll.get_choice_list()
- #
- # # A related object in a different app.
- # # This method returns "lcom_bestofaward".
- # Place.get_lcom_bestofaward_list() # "lcom_bestofaward"
- rel_obj_name = self.field.rel.related_name or self.opts.object_name.lower()
- if self.parent_opts.app_label != self.opts.app_label:
- rel_obj_name = '%s_%s' % (self.opts.app_label, rel_obj_name)
- return rel_obj_name
-
-class QBase:
- "Base class for QAnd and QOr"
- def __init__(self, *args):
- self.args = args
-
- def __repr__(self):
- return '(%s)' % self.operator.join([repr(el) for el in self.args])
-
- def get_sql(self, opts, table_count):
- tables, join_where, where, params = [], [], [], []
- for val in self.args:
- tables2, join_where2, where2, params2, table_count = val.get_sql(opts, table_count)
- tables.extend(tables2)
- join_where.extend(join_where2)
- where.extend(where2)
- params.extend(params2)
- return tables, join_where, ['(%s)' % self.operator.join(where)], params, table_count
-
-class QAnd(QBase):
- "Encapsulates a combined query that uses 'AND'."
- operator = ' AND '
- def __or__(self, other):
- if isinstance(other, (QAnd, QOr, Q)):
- return QOr(self, other)
- else:
- raise TypeError, other
-
- def __and__(self, other):
- if isinstance(other, QAnd):
- return QAnd(*(self.args+other.args))
- elif isinstance(other, (Q, QOr)):
- return QAnd(*(self.args+(other,)))
- else:
- raise TypeError, other
-
-class QOr(QBase):
- "Encapsulates a combined query that uses 'OR'."
- operator = ' OR '
- def __and__(self, other):
- if isinstance(other, (QAnd, QOr, Q)):
- return QAnd(self, other)
- else:
- raise TypeError, other
-
- def __or__(self, other):
- if isinstance(other, QOr):
- return QOr(*(self.args+other.args))
- elif isinstance(other, (Q, QAnd)):
- return QOr(*(self.args+(other,)))
- else:
- raise TypeError, other
-
-class Q:
- "Encapsulates queries for the 'complex' parameter to Django API functions."
- def __init__(self, **kwargs):
- self.kwargs = kwargs
-
- def __repr__(self):
- return 'Q%r' % self.kwargs
-
- def __and__(self, other):
- if isinstance(other, (Q, QAnd, QOr)):
- return QAnd(self, other)
- else:
- raise TypeError, other
-
- def __or__(self, other):
- if isinstance(other, (Q, QAnd, QOr)):
- return QOr(self, other)
- else:
- raise TypeError, other
-
- def get_sql(self, opts, table_count):
- return _parse_lookup(self.kwargs.items(), opts, table_count)
-
-class Options:
- def __init__(self, module_name='', verbose_name='', verbose_name_plural='', db_table='',
- fields=None, ordering=None, unique_together=None, admin=None, has_related_links=False,
- where_constraints=None, object_name=None, app_label=None,
- exceptions=None, permissions=None, get_latest_by=None,
- order_with_respect_to=None, module_constants=None):
-
- # Save the original function args, for use by copy(). Note that we're
- # NOT using copy.deepcopy(), because that would create a new copy of
- # everything in memory, and it's better to conserve memory. Of course,
- # this comes with the important gotcha that changing any attribute of
- # this object will change its value in self._orig_init_args, so we
- # need to be careful not to do that. In practice, we can pull this off
- # because Options are generally read-only objects, and __init__() is
- # the only place where its attributes are manipulated.
-
- # locals() is used purely for convenience, so we don't have to do
- # something verbose like this:
- # self._orig_init_args = {
- # 'module_name': module_name,
- # 'verbose_name': verbose_name,
- # ...
- # }
- self._orig_init_args = locals()
- del self._orig_init_args['self'] # because we don't care about it.
-
- # Move many-to-many related fields from self.fields into self.many_to_many.
- self.fields, self.many_to_many = [], []
- for field in (fields or []):
- if field.rel and isinstance(field.rel, ManyToManyRel):
- self.many_to_many.append(field)
- else:
- self.fields.append(field)
- self.module_name, self.verbose_name = module_name, verbose_name
- self.verbose_name_plural = verbose_name_plural or verbose_name + 's'
- self.db_table, self.has_related_links = db_table, has_related_links
- self.ordering = ordering or []
- self.unique_together = unique_together or []
- self.where_constraints = where_constraints or []
- self.exceptions = exceptions or []
- self.permissions = permissions or []
- self.object_name, self.app_label = object_name, app_label
- self.get_latest_by = get_latest_by
- if order_with_respect_to:
- self.order_with_respect_to = self.get_field(order_with_respect_to)
- self.ordering = ('_order',)
- else:
- self.order_with_respect_to = None
- self.module_constants = module_constants or {}
- self.admin = admin
-
- # Calculate one_to_one_field.
- self.one_to_one_field = None
- for f in self.fields:
- if isinstance(f.rel, OneToOneRel):
- self.one_to_one_field = f
- break
- # Cache the primary-key field.
- self.pk = None
- for f in self.fields:
- if f.primary_key:
- self.pk = f
- break
- # If a primary_key field hasn't been specified, add an
- # auto-incrementing primary-key ID field automatically.
- if self.pk is None:
- self.fields.insert(0, AutoField(name='id', verbose_name='ID', primary_key=True))
- self.pk = self.fields[0]
- # Cache whether this has an AutoField.
- self.has_auto_field = False
- for f in self.fields:
- is_auto = isinstance(f, AutoField)
- if is_auto and self.has_auto_field:
- raise AssertionError, "A model can't have more than one AutoField."
- elif is_auto:
- self.has_auto_field = True
-
- def __repr__(self):
- return '' % self.module_name
-
- def copy(self, **kwargs):
- args = self._orig_init_args.copy()
- args.update(kwargs)
- return self.__class__(**args)
-
- def get_model_module(self):
- return get_module(self.app_label, self.module_name)
-
- def get_content_type_id(self):
- "Returns the content-type ID for this object type."
- if not hasattr(self, '_content_type_id'):
- mod = get_module('core', 'contenttypes')
- self._content_type_id = mod.get_object(python_module_name__exact=self.module_name, package__label__exact=self.app_label).id
- return self._content_type_id
-
- def get_field(self, name, many_to_many=True):
- """
- Returns the requested field by name. Raises FieldDoesNotExist on error.
- """
- to_search = many_to_many and (self.fields + self.many_to_many) or self.fields
- for f in to_search:
- if f.name == name:
- return f
- raise FieldDoesNotExist, "name=%s" % name
-
- def get_order_sql(self, table_prefix=''):
- "Returns the full 'ORDER BY' clause for this object, according to self.ordering."
- if not self.ordering: return ''
- pre = table_prefix and (table_prefix + '.') or ''
- return 'ORDER BY ' + orderlist2sql(self.ordering, self, pre)
-
- def get_add_permission(self):
- return 'add_%s' % self.object_name.lower()
-
- def get_change_permission(self):
- return 'change_%s' % self.object_name.lower()
-
- def get_delete_permission(self):
- return 'delete_%s' % self.object_name.lower()
-
- def get_all_related_objects(self):
- try: # Try the cache first.
- return self._all_related_objects
- except AttributeError:
- module_list = get_installed_model_modules()
- rel_objs = []
- for mod in module_list:
- for klass in mod._MODELS:
- for f in klass._meta.fields:
- if f.rel and self == f.rel.to:
- rel_objs.append(RelatedObject(self, klass._meta, f))
- if self.has_related_links:
- # Manually add RelatedLink objects, which are a special case.
- relatedlinks = get_module('relatedlinks', 'relatedlinks')
- # Note that the copy() is very important -- otherwise any
- # subsequently loaded object with related links will override this
- # relationship we're adding.
- link_field = copy.copy(relatedlinks.RelatedLink._meta.get_field('object_id'))
- link_field.rel = ManyToOneRel(self.get_model_module().Klass, 'id',
- num_in_admin=3, min_num_in_admin=3, edit_inline=TABULAR,
- lookup_overrides={
- 'content_type__package__label__exact': self.app_label,
- 'content_type__python_module_name__exact': self.module_name,
- })
- rel_objs.append(RelatedObject(self, relatedlinks.RelatedLink._meta, link_field))
- self._all_related_objects = rel_objs
- return rel_objs
-
- def get_followed_related_objects(self, follow=None):
- if follow == None:
- follow = self.get_follow()
- return [f for f in self.get_all_related_objects() if follow.get(f.name, None)]
-
- def get_data_holders(self, follow=None):
- if follow == None:
- follow = self.get_follow()
- return [f for f in self.fields + self.many_to_many + self.get_all_related_objects() if follow.get(f.name, None)]
-
- def get_follow(self, override=None):
- follow = {}
- for f in self.fields + self.many_to_many + self.get_all_related_objects():
- if override and override.has_key(f.name):
- child_override = override[f.name]
- else:
- child_override = None
- fol = f.get_follow(child_override)
- if fol:
- follow[f.name] = fol
- return follow
-
- def get_all_related_many_to_many_objects(self):
- module_list = get_installed_model_modules()
- rel_objs = []
- for mod in module_list:
- for klass in mod._MODELS:
- for f in klass._meta.many_to_many:
- if f.rel and self == f.rel.to:
- rel_objs.append(RelatedObject(self, klass._meta, f))
- return rel_objs
-
- def get_ordered_objects(self):
- "Returns a list of Options objects that are ordered with respect to this object."
- if not hasattr(self, '_ordered_objects'):
- objects = []
- for klass in get_app(self.app_label)._MODELS:
- opts = klass._meta
- if opts.order_with_respect_to and opts.order_with_respect_to.rel \
- and self == opts.order_with_respect_to.rel.to:
- objects.append(opts)
- self._ordered_objects = objects
- return self._ordered_objects
-
- def has_field_type(self, field_type, follow=None):
- """
- Returns True if this object's admin form has at least one of the given
- field_type (e.g. FileField).
- """
- # TODO: follow
- if not hasattr(self, '_field_types'):
- self._field_types = {}
- if not self._field_types.has_key(field_type):
- try:
- # First check self.fields.
- for f in self.fields:
- if isinstance(f, field_type):
- raise StopIteration
- # Failing that, check related fields.
- for related in self.get_followed_related_objects(follow):
- for f in related.opts.fields:
- if isinstance(f, field_type):
- raise StopIteration
- except StopIteration:
- self._field_types[field_type] = True
- else:
- self._field_types[field_type] = False
- return self._field_types[field_type]
-
-def _reassign_globals(function_dict, extra_globals, namespace):
- new_functions = {}
- for k, v in function_dict.items():
- # Get the code object.
- code = v.func_code
- # Recreate the function, but give it access to extra_globals and the
- # given namespace's globals, too.
- new_globals = {'__builtins__': __builtins__, 'db': db.db, 'datetime': datetime}
- new_globals.update(extra_globals.__dict__)
- func = types.FunctionType(code, globals=new_globals, name=k, argdefs=v.func_defaults)
- func.__dict__.update(v.__dict__)
- setattr(namespace, k, func)
- # For all of the custom functions that have been added so far, give
- # them access to the new function we've just created.
- for new_k, new_v in new_functions.items():
- new_v.func_globals[k] = func
- new_functions[k] = func
-
-# Calculate the module_name using a poor-man's pluralization.
-get_module_name = lambda class_name: class_name.lower() + 's'
-
-# Calculate the verbose_name by converting from InitialCaps to "lowercase with spaces".
-get_verbose_name = lambda class_name: re.sub('([A-Z])', ' \\1', class_name).lower().strip()
-
-class ModelBase(type):
- "Metaclass for all models"
- def __new__(cls, name, bases, attrs):
- # If this isn't a subclass of Model, don't do anything special.
- if not bases:
- return type.__new__(cls, name, bases, attrs)
-
- try:
- meta_attrs = attrs.pop('META').__dict__
- del meta_attrs['__module__']
- del meta_attrs['__doc__']
- except KeyError:
- meta_attrs = {}
-
- # Gather all attributes that are Field instances.
- fields = []
- for obj_name, obj in attrs.items():
- if isinstance(obj, Field):
- obj.set_name(obj_name)
- fields.append(obj)
- del attrs[obj_name]
-
- # Sort the fields in the order that they were created. The
- # "creation_counter" is needed because metaclasses don't preserve the
- # attribute order.
- fields.sort(lambda x, y: x.creation_counter - y.creation_counter)
-
- # If this model is a subclass of another model, create an Options
- # object by first copying the base class's _meta and then updating it
- # with the overrides from this class.
- replaces_module = None
- if bases[0] != Model:
- field_names = [f.name for f in fields]
- remove_fields = meta_attrs.pop('remove_fields', [])
- for f in bases[0]._meta._orig_init_args['fields']:
- if f.name not in field_names and f.name not in remove_fields:
- fields.insert(0, f)
- if meta_attrs.has_key('replaces_module'):
- # Set the replaces_module variable for now. We can't actually
- # do anything with it yet, because the module hasn't yet been
- # created.
- replaces_module = meta_attrs.pop('replaces_module').split('.')
- # Pass any Options overrides to the base's Options instance, and
- # simultaneously remove them from attrs. When this is done, attrs
- # will be a dictionary of custom methods, plus __module__.
- meta_overrides = {'fields': fields, 'module_name': get_module_name(name), 'verbose_name': get_verbose_name(name)}
- for k, v in meta_attrs.items():
- if not callable(v) and k != '__module__':
- meta_overrides[k] = meta_attrs.pop(k)
- opts = bases[0]._meta.copy(**meta_overrides)
- opts.object_name = name
- del meta_overrides
- else:
- opts = Options(
- module_name = meta_attrs.pop('module_name', get_module_name(name)),
- # If the verbose_name wasn't given, use the class name,
- # converted from InitialCaps to "lowercase with spaces".
- verbose_name = meta_attrs.pop('verbose_name', get_verbose_name(name)),
- verbose_name_plural = meta_attrs.pop('verbose_name_plural', ''),
- db_table = meta_attrs.pop('db_table', ''),
- fields = fields,
- ordering = meta_attrs.pop('ordering', None),
- unique_together = meta_attrs.pop('unique_together', None),
- admin = meta_attrs.pop('admin', None),
- has_related_links = meta_attrs.pop('has_related_links', False),
- where_constraints = meta_attrs.pop('where_constraints', None),
- object_name = name,
- app_label = meta_attrs.pop('app_label', None),
- exceptions = meta_attrs.pop('exceptions', None),
- permissions = meta_attrs.pop('permissions', None),
- get_latest_by = meta_attrs.pop('get_latest_by', None),
- order_with_respect_to = meta_attrs.pop('order_with_respect_to', None),
- module_constants = meta_attrs.pop('module_constants', None),
- )
-
- if meta_attrs != {}:
- raise TypeError, "'class META' got invalid attribute(s): %s" % ','.join(meta_attrs.keys())
-
- # Dynamically create the module that will contain this class and its
- # associated helper functions.
- if replaces_module is not None:
- new_mod = get_module(*replaces_module)
- else:
- new_mod = types.ModuleType(opts.module_name)
-
- # Collect any/all custom class methods and module functions, and move
- # them to a temporary holding variable. We'll deal with them later.
- if replaces_module is not None:
- # Initialize these values to the base class' custom_methods and
- # custom_functions.
- custom_methods = dict([(k, v) for k, v in new_mod.Klass.__dict__.items() if hasattr(v, 'custom')])
- custom_functions = dict([(k, v) for k, v in new_mod.__dict__.items() if hasattr(v, 'custom')])
- else:
- custom_methods, custom_functions = {}, {}
- manipulator_methods = {}
- for k, v in attrs.items():
- if k in ('__module__', '__init__', '_overrides', '__doc__'):
- continue # Skip the important stuff.
- assert callable(v), "%r is an invalid model parameter." % k
- # Give the function a function attribute "custom" to designate that
- # it's a custom function/method.
- v.custom = True
- if k.startswith(MODEL_FUNCTIONS_PREFIX):
- custom_functions[k[len(MODEL_FUNCTIONS_PREFIX):]] = v
- elif k.startswith(MANIPULATOR_FUNCTIONS_PREFIX):
- manipulator_methods[k[len(MANIPULATOR_FUNCTIONS_PREFIX):]] = v
- else:
- custom_methods[k] = v
- del attrs[k]
-
- # Create the module-level ObjectDoesNotExist exception.
- dne_exc_name = '%sDoesNotExist' % name
- does_not_exist_exception = types.ClassType(dne_exc_name, (ObjectDoesNotExist,), {})
- # Explicitly set its __module__ because it will initially (incorrectly)
- # be set to the module the code is being executed in.
- does_not_exist_exception.__module__ = MODEL_PREFIX + '.' + opts.module_name
- setattr(new_mod, dne_exc_name, does_not_exist_exception)
-
- # Create other exceptions.
- for exception_name in opts.exceptions:
- exc = types.ClassType(exception_name, (Exception,), {})
- exc.__module__ = MODEL_PREFIX + '.' + opts.module_name # Set this explicitly, as above.
- setattr(new_mod, exception_name, exc)
-
- # Create any module-level constants, if applicable.
- for k, v in opts.module_constants.items():
- setattr(new_mod, k, v)
-
- # Create the default class methods.
- attrs['__init__'] = curry(method_init, opts)
- attrs['__eq__'] = curry(method_eq, opts)
- attrs['__ne__'] = curry(method_ne, opts)
- attrs['save'] = curry(method_save, opts)
- attrs['save'].alters_data = True
- attrs['delete'] = curry(method_delete, opts)
- attrs['delete'].alters_data = True
-
- if opts.order_with_respect_to:
- attrs['get_next_in_order'] = curry(method_get_next_in_order, opts, opts.order_with_respect_to)
- attrs['get_previous_in_order'] = curry(method_get_previous_in_order, opts, opts.order_with_respect_to)
-
- for f in opts.fields:
- # If the object has a relationship to itself, as designated by
- # RECURSIVE_RELATIONSHIP_CONSTANT, create that relationship formally.
- if f.rel and f.rel.to == RECURSIVE_RELATIONSHIP_CONSTANT:
- f.rel.to = opts
- f.name = f.name or (f.rel.to.object_name.lower() + '_' + f.rel.to.pk.name)
- f.verbose_name = f.verbose_name or f.rel.to.verbose_name
- f.rel.field_name = f.rel.field_name or f.rel.to.pk.name
- # Add "get_thingie" methods for many-to-one related objects.
- # EXAMPLES: Choice.get_poll(), Story.get_dateline()
- if isinstance(f.rel, ManyToOneRel):
- func = curry(method_get_many_to_one, f)
- func.__doc__ = "Returns the associated `%s.%s` object." % (f.rel.to.app_label, f.rel.to.module_name)
- attrs['get_%s' % f.name] = func
-
- for f in opts.many_to_many:
- # Add "get_thingie" methods for many-to-many related objects.
- # EXAMPLES: Poll.get_site_list(), Story.get_byline_list()
- func = curry(method_get_many_to_many, f)
- func.__doc__ = "Returns a list of associated `%s.%s` objects." % (f.rel.to.app_label, f.rel.to.module_name)
- attrs['get_%s_list' % f.rel.singular] = func
- # Add "set_thingie" methods for many-to-many related objects.
- # EXAMPLES: Poll.set_sites(), Story.set_bylines()
- func = curry(method_set_many_to_many, f)
- func.__doc__ = "Resets this object's `%s.%s` list to the given list of IDs. Note that it doesn't check whether the given IDs are valid." % (f.rel.to.app_label, f.rel.to.module_name)
- func.alters_data = True
- attrs['set_%s' % f.name] = func
-
- # Create the class, because we need it to use in currying.
- new_class = type.__new__(cls, name, bases, attrs)
-
- # Give the class a docstring -- its definition.
- if new_class.__doc__ is None:
- new_class.__doc__ = "%s.%s(%s)" % (opts.module_name, name, ", ".join([f.name for f in opts.fields]))
-
- # Create the standard, module-level API helper functions such
- # as get_object() and get_list().
- new_mod.get_object = curry(function_get_object, opts, new_class, does_not_exist_exception)
- new_mod.get_object.__doc__ = "Returns the %s object matching the given parameters." % name
-
- new_mod.get_list = curry(function_get_list, opts, new_class)
- new_mod.get_list.__doc__ = "Returns a list of %s objects matching the given parameters." % name
-
- new_mod.get_iterator = curry(function_get_iterator, opts, new_class)
- new_mod.get_iterator.__doc__ = "Returns an iterator of %s objects matching the given parameters." % name
-
- new_mod.get_values = curry(function_get_values, opts, new_class)
- new_mod.get_values.__doc__ = "Returns a list of dictionaries matching the given parameters."
-
- new_mod.get_values_iterator = curry(function_get_values_iterator, opts, new_class)
- new_mod.get_values_iterator.__doc__ = "Returns an iterator of dictionaries matching the given parameters."
-
- new_mod.get_count = curry(function_get_count, opts)
- new_mod.get_count.__doc__ = "Returns the number of %s objects matching the given parameters." % name
-
- new_mod._get_sql_clause = curry(function_get_sql_clause, opts)
-
- new_mod.get_in_bulk = curry(function_get_in_bulk, opts, new_class)
- new_mod.get_in_bulk.__doc__ = "Returns a dictionary of ID -> %s for the %s objects with IDs in the given id_list." % (name, name)
-
- if opts.get_latest_by:
- new_mod.get_latest = curry(function_get_latest, opts, new_class, does_not_exist_exception)
-
- for f in opts.fields:
- #TODO : change this into a virtual function so that user defined fields will be able to add methods to module or class.
- if f.choices:
- # Add "get_thingie_display" method to get human-readable value.
- func = curry(method_get_display_value, f)
- setattr(new_class, 'get_%s_display' % f.name, func)
- if isinstance(f, DateField) or isinstance(f, DateTimeField):
- # Add "get_next_by_thingie" and "get_previous_by_thingie" methods
- # for all DateFields and DateTimeFields that cannot be null.
- # EXAMPLES: Poll.get_next_by_pub_date(), Poll.get_previous_by_pub_date()
- if not f.null:
- setattr(new_class, 'get_next_by_%s' % f.name, curry(method_get_next_or_previous, new_mod.get_object, opts, f, True))
- setattr(new_class, 'get_previous_by_%s' % f.name, curry(method_get_next_or_previous, new_mod.get_object, opts, f, False))
- # Add "get_thingie_list" for all DateFields and DateTimeFields.
- # EXAMPLE: polls.get_pub_date_list()
- func = curry(function_get_date_list, opts, f)
- func.__doc__ = "Returns a list of days, months or years (as datetime.datetime objects) in which %s objects are available. The first parameter ('kind') must be one of 'year', 'month' or 'day'." % name
- setattr(new_mod, 'get_%s_list' % f.name, func)
-
- elif isinstance(f, FileField):
- setattr(new_class, 'get_%s_filename' % f.name, curry(method_get_file_filename, f))
- setattr(new_class, 'get_%s_url' % f.name, curry(method_get_file_url, f))
- setattr(new_class, 'get_%s_size' % f.name, curry(method_get_file_size, f))
- func = curry(method_save_file, f)
- func.alters_data = True
- setattr(new_class, 'save_%s_file' % f.name, func)
- if isinstance(f, ImageField):
- # Add get_BLAH_width and get_BLAH_height methods, but only
- # if the image field doesn't have width and height cache
- # fields.
- if not f.width_field:
- setattr(new_class, 'get_%s_width' % f.name, curry(method_get_image_width, f))
- if not f.height_field:
- setattr(new_class, 'get_%s_height' % f.name, curry(method_get_image_height, f))
-
- # Add the class itself to the new module we've created.
- new_mod.__dict__[name] = new_class
-
- # Add "Klass" -- a shortcut reference to the class.
- new_mod.__dict__['Klass'] = new_class
-
- # Add the Manipulators.
- new_mod.__dict__['AddManipulator'] = get_manipulator(opts, new_class, manipulator_methods, add=True)
- new_mod.__dict__['ChangeManipulator'] = get_manipulator(opts, new_class, manipulator_methods, change=True)
-
- # Now that we have references to new_mod and new_class, we can add
- # any/all extra class methods to the new class. Note that we could
- # have just left the extra methods in attrs (above), but that would
- # have meant that any code within the extra methods would *not* have
- # access to module-level globals, such as get_list(), db, etc.
- # In order to give these methods access to those globals, we have to
- # deconstruct the method getting its raw "code" object, then recreating
- # the function with a new "globals" dictionary.
- #
- # To complicate matters more, because each method is manually assigned
- # a "globals" value, that "globals" value does NOT include the methods
- # that haven't been created yet. For instance, if there are two custom
- # methods, foo() and bar(), and foo() is created first, it won't have
- # bar() within its globals(). This is a problem because sometimes
- # custom methods/functions refer to other custom methods/functions. To
- # solve this problem, we keep track of the new functions created (in
- # the new_functions variable) and manually append each new function to
- # the func_globals() of all previously-created functions. So, by the
- # end of the loop, all functions will "know" about all the other
- # functions.
- _reassign_globals(custom_methods, new_mod, new_class)
- _reassign_globals(custom_functions, new_mod, new_mod)
- _reassign_globals(manipulator_methods, new_mod, new_mod.__dict__['AddManipulator'])
- _reassign_globals(manipulator_methods, new_mod, new_mod.__dict__['ChangeManipulator'])
-
- if hasattr(new_class, 'get_absolute_url'):
- new_class.get_absolute_url = curry(get_absolute_url, opts, new_class.get_absolute_url)
-
- # Get a reference to the module the class is in, and dynamically add
- # the new module to it.
- app_package = sys.modules.get(new_class.__module__)
- if replaces_module is not None:
- app_label = replaces_module[0]
- else:
- app_package.__dict__[opts.module_name] = new_mod
- app_label = app_package.__name__[app_package.__name__.rfind('.')+1:]
-
- # Populate the _MODELS member on the module the class is in.
- # Example: django.models.polls will have a _MODELS member that will
- # contain this list:
- # [, ]
- # Don't do this if replaces_module is set.
- app_package.__dict__.setdefault('_MODELS', []).append(new_class)
-
- # Cache the app label.
- opts.app_label = app_label
-
- # If the db_table wasn't provided, use the app_label + module_name.
- if not opts.db_table:
- opts.db_table = "%s_%s" % (app_label, opts.module_name)
- new_class._meta = opts
-
- # Set the __file__ attribute to the __file__ attribute of its package,
- # because they're technically from the same file. Note: if we didn't
- # set this, sys.modules would think this module was built-in.
- try:
- new_mod.__file__ = app_package.__file__
- except AttributeError:
- # 'module' object has no attribute '__file__', which means the
- # class was probably being entered via the interactive interpreter.
- pass
-
- # Add the module's entry to sys.modules -- for instance,
- # "django.models.polls.polls". Note that "django.models.polls" has already
- # been added automatically.
- sys.modules.setdefault('%s.%s.%s' % (MODEL_PREFIX, app_label, opts.module_name), new_mod)
-
- # If this module replaces another one, get a reference to the other
- # module's parent, and replace the other module with the one we've just
- # created.
- if replaces_module is not None:
- old_app = get_app(replaces_module[0])
- setattr(old_app, replaces_module[1], new_mod)
- for i, model in enumerate(old_app._MODELS):
- if model._meta.module_name == replaces_module[1]:
- # Replace the appropriate member of the old app's _MODELS
- # data structure.
- old_app._MODELS[i] = new_class
- # Replace all relationships to the old class with
- # relationships to the new one.
- for related in model._meta.get_all_related_objects() + model._meta.get_all_related_many_to_many_objects():
- related.field.rel.to = opts
- break
- return new_class
-
-class Model:
- __metaclass__ = ModelBase
-
- def __repr__(self):
- return '<%s object>' % self.__class__.__name__
-
-############################################
-# HELPER FUNCTIONS (CURRIED MODEL METHODS) #
-############################################
-
-# CORE METHODS #############################
-
-def method_init(opts, self, *args, **kwargs):
- if kwargs:
- for f in opts.fields:
- if isinstance(f.rel, ManyToOneRel):
- try:
- # Assume object instance was passed in.
- rel_obj = kwargs.pop(f.name)
- except KeyError:
- try:
- # Object instance wasn't passed in -- must be an ID.
- val = kwargs.pop(f.attname)
- except KeyError:
- val = f.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 f.null:
- val = None
- else:
- try:
- val = getattr(rel_obj, f.rel.get_related_field().attname)
- except AttributeError:
- raise TypeError, "Invalid value: %r should be a %s instance, not a %s" % (f.name, f.rel.to, type(rel_obj))
- setattr(self, f.attname, val)
- else:
- val = kwargs.pop(f.attname, f.get_default())
- setattr(self, f.attname, val)
- if kwargs:
- raise TypeError, "'%s' is an invalid keyword argument for this function" % kwargs.keys()[0]
- for i, arg in enumerate(args):
- setattr(self, opts.fields[i].attname, arg)
-
-def method_eq(opts, self, other):
- return isinstance(other, self.__class__) and getattr(self, opts.pk.attname) == getattr(other, opts.pk.attname)
-
-def method_ne(opts, self, other):
- return not method_eq(opts, self, other)
-
-def method_save(opts, self):
- # Run any pre-save hooks.
- if hasattr(self, '_pre_save'):
- self._pre_save()
- non_pks = [f for f in opts.fields if not f.primary_key]
- cursor = db.db.cursor()
-
- # First, try an UPDATE. If that doesn't update anything, do an INSERT.
- pk_val = getattr(self, opts.pk.attname)
- pk_set = bool(pk_val)
- record_exists = True
- if pk_set:
- # Determine whether a record with the primary key already exists.
- cursor.execute("SELECT 1 FROM %s WHERE %s=%%s LIMIT 1" % \
- (db.db.quote_name(opts.db_table), db.db.quote_name(opts.pk.column)), [pk_val])
- # If it does already exist, do an UPDATE.
- if cursor.fetchone():
- db_values = [f.get_db_prep_save(f.pre_save(getattr(self, f.attname), False)) for f in non_pks]
- cursor.execute("UPDATE %s SET %s WHERE %s=%%s" % \
- (db.db.quote_name(opts.db_table),
- ','.join(['%s=%%s' % db.db.quote_name(f.column) for f in non_pks]),
- db.db.quote_name(opts.pk.attname)),
- db_values + [pk_val])
- else:
- record_exists = False
- if not pk_set or not record_exists:
- field_names = [db.db.quote_name(f.column) for f in opts.fields if not isinstance(f, AutoField)]
- db_values = [f.get_db_prep_save(f.pre_save(getattr(self, f.attname), True)) for f in opts.fields if not isinstance(f, AutoField)]
- # If the PK has been manually set we must respect that
- if pk_set:
- field_names += [f.column for f in opts.fields if isinstance(f, AutoField)]
- db_values += [f.get_db_prep_save(f.pre_save(getattr(self, f.column), True)) for f in opts.fields if isinstance(f, AutoField)]
- placeholders = ['%s'] * len(field_names)
- if opts.order_with_respect_to:
- field_names.append(db.db.quote_name('_order'))
- # TODO: This assumes the database supports subqueries.
- placeholders.append('(SELECT COUNT(*) FROM %s WHERE %s = %%s)' % \
- (db.db.quote_name(opts.db_table), db.db.quote_name(opts.order_with_respect_to.column)))
- db_values.append(getattr(self, opts.order_with_respect_to.attname))
- cursor.execute("INSERT INTO %s (%s) VALUES (%s)" % \
- (db.db.quote_name(opts.db_table), ','.join(field_names),
- ','.join(placeholders)), db_values)
- if opts.has_auto_field and not pk_set:
- setattr(self, opts.pk.attname, db.get_last_insert_id(cursor, opts.db_table, opts.pk.column))
- db.db.commit()
- # Run any post-save hooks.
- if hasattr(self, '_post_save'):
- self._post_save()
-
-def method_delete(opts, self):
- assert getattr(self, opts.pk.attname) is not None, "%r can't be deleted because it doesn't have an ID."
- # Run any pre-delete hooks.
- if hasattr(self, '_pre_delete'):
- self._pre_delete()
- cursor = db.db.cursor()
- for related in opts.get_all_related_objects():
- rel_opts_name = related.get_method_name_part()
- if isinstance(related.field.rel, OneToOneRel):
- try:
- sub_obj = getattr(self, 'get_%s' % rel_opts_name)()
- except ObjectDoesNotExist:
- pass
- else:
- sub_obj.delete()
- else:
- for sub_obj in getattr(self, 'get_%s_list' % rel_opts_name)():
- sub_obj.delete()
- for related in opts.get_all_related_many_to_many_objects():
- cursor.execute("DELETE FROM %s WHERE %s=%%s" % \
- (db.db.quote_name(related.field.get_m2m_db_table(related.opts)),
- db.db.quote_name(self._meta.object_name.lower() + '_id')), [getattr(self, opts.pk.attname)])
- for f in opts.many_to_many:
- cursor.execute("DELETE FROM %s WHERE %s=%%s" % \
- (db.db.quote_name(f.get_m2m_db_table(opts)),
- db.db.quote_name(self._meta.object_name.lower() + '_id')),
- [getattr(self, opts.pk.attname)])
- cursor.execute("DELETE FROM %s WHERE %s=%%s" % \
- (db.db.quote_name(opts.db_table), db.db.quote_name(opts.pk.column)),
- [getattr(self, opts.pk.attname)])
- db.db.commit()
- setattr(self, opts.pk.attname, None)
- for f in opts.fields:
- if isinstance(f, FileField) and getattr(self, f.attname):
- file_name = getattr(self, 'get_%s_filename' % f.name)()
- # If the file exists and no other object of this type references it,
- # delete it from the filesystem.
- if os.path.exists(file_name) and not opts.get_model_module().get_list(**{'%s__exact' % f.name: getattr(self, f.name)}):
- os.remove(file_name)
- # Run any post-delete hooks.
- if hasattr(self, '_post_delete'):
- self._post_delete()
-
-def method_get_next_in_order(opts, order_field, self):
- if not hasattr(self, '_next_in_order_cache'):
- self._next_in_order_cache = opts.get_model_module().get_object(order_by=('_order',),
- where=['%s > (SELECT %s FROM %s WHERE %s=%%s)' % \
- (db.db.quote_name('_order'), db.db.quote_name('_order'),
- db.db.quote_name(opts.db_table), db.db.quote_name(opts.pk.column)),
- '%s=%%s' % db.db.quote_name(order_field.column)], limit=1,
- params=[getattr(self, opts.pk.attname), getattr(self, order_field.attname)])
- return self._next_in_order_cache
-
-def method_get_previous_in_order(opts, order_field, self):
- if not hasattr(self, '_previous_in_order_cache'):
- self._previous_in_order_cache = opts.get_model_module().get_object(order_by=('-_order',),
- where=['%s < (SELECT %s FROM %s WHERE %s=%%s)' % \
- (db.db.quote_name('_order'), db.db.quote_name('_order'),
- db.db.quote_name(opts.db_table), db.db.quote_name(opts.pk.column)),
- '%s=%%s' % db.db.quote_name(order_field.column)], limit=1,
- params=[getattr(self, opts.pk.attname), getattr(self, order_field.attname)])
- return self._previous_in_order_cache
-
-# RELATIONSHIP METHODS #####################
-
-# Example: Story.get_dateline()
-def method_get_many_to_one(field_with_rel, self):
- cache_var = field_with_rel.get_cache_name()
- if not hasattr(self, cache_var):
- val = getattr(self, field_with_rel.attname)
- mod = field_with_rel.rel.to.get_model_module()
- if val is None:
- raise getattr(mod, '%sDoesNotExist' % field_with_rel.rel.to.object_name)
- other_field = field_with_rel.rel.get_related_field()
- if other_field.rel:
- params = {'%s__%s__exact' % (field_with_rel.rel.field_name, other_field.rel.field_name): val}
- else:
- params = {'%s__exact'% field_with_rel.rel.field_name: val}
- retrieved_obj = mod.get_object(**params)
- setattr(self, cache_var, retrieved_obj)
- return getattr(self, cache_var)
-
-# Handles getting many-to-many related objects.
-# Example: Poll.get_site_list()
-def method_get_many_to_many(field_with_rel, self):
- rel = field_with_rel.rel.to
- cache_var = '_%s_cache' % field_with_rel.name
- if not hasattr(self, cache_var):
- mod = rel.get_model_module()
- sql = "SELECT %s FROM %s a, %s b WHERE a.%s = b.%s AND b.%s = %%s %s" % \
- (','.join(['a.%s' % db.db.quote_name(f.column) for f in rel.fields]),
- db.db.quote_name(rel.db_table),
- db.db.quote_name(field_with_rel.get_m2m_db_table(self._meta)),
- db.db.quote_name(rel.pk.column),
- db.db.quote_name(rel.object_name.lower() + '_id'),
- db.db.quote_name(self._meta.object_name.lower() + '_id'), rel.get_order_sql('a'))
- cursor = db.db.cursor()
- cursor.execute(sql, [getattr(self, self._meta.pk.attname)])
- setattr(self, cache_var, [getattr(mod, rel.object_name)(*row) for row in cursor.fetchall()])
- return getattr(self, cache_var)
-
-# Handles setting many-to-many relationships.
-# Example: Poll.set_sites()
-def method_set_many_to_many(rel_field, self, id_list):
- current_ids = [getattr(obj, obj._meta.pk.attname) for obj in method_get_many_to_many(rel_field, self)]
- ids_to_add, ids_to_delete = dict([(i, 1) for i in id_list]), []
- for current_id in current_ids:
- if current_id in id_list:
- del ids_to_add[current_id]
- else:
- ids_to_delete.append(current_id)
- ids_to_add = ids_to_add.keys()
- # Now ids_to_add is a list of IDs to add, and ids_to_delete is a list of IDs to delete.
- if not ids_to_delete and not ids_to_add:
- return False # No change
- rel = rel_field.rel.to
- m2m_table = rel_field.get_m2m_db_table(self._meta)
- cursor = db.db.cursor()
- this_id = getattr(self, self._meta.pk.attname)
- if ids_to_delete:
- sql = "DELETE FROM %s WHERE %s = %%s AND %s IN (%s)" % \
- (db.db.quote_name(m2m_table),
- db.db.quote_name(self._meta.object_name.lower() + '_id'),
- db.db.quote_name(rel.object_name.lower() + '_id'), ','.join(map(str, ids_to_delete)))
- cursor.execute(sql, [this_id])
- if ids_to_add:
- sql = "INSERT INTO %s (%s, %s) VALUES (%%s, %%s)" % \
- (db.db.quote_name(m2m_table),
- db.db.quote_name(self._meta.object_name.lower() + '_id'),
- db.db.quote_name(rel.object_name.lower() + '_id'))
- cursor.executemany(sql, [(this_id, i) for i in ids_to_add])
- db.db.commit()
- try:
- delattr(self, '_%s_cache' % rel_field.name) # clear cache, if it exists
- except AttributeError:
- pass
- return True
-
-# Handles related-object retrieval.
-# Examples: Poll.get_choice(), Poll.get_choice_list(), Poll.get_choice_count()
-def method_get_related(method_name, rel_mod, rel_field, self, **kwargs):
- if self._meta.has_related_links and rel_mod.Klass._meta.module_name == 'relatedlinks':
- kwargs['object_id__exact'] = getattr(self, rel_field.rel.field_name)
- else:
- kwargs['%s__%s__exact' % (rel_field.name, rel_field.rel.to.pk.name)] = getattr(self, rel_field.rel.get_related_field().attname)
- kwargs.update(rel_field.rel.lookup_overrides)
- related = getattr(rel_mod, method_name)(**kwargs)
-
- # Cache the 'self' object for backward links.
- # Example: Each choice in Poll.get_choice_list() will have its poll cache filled.
- # Pre-cache the self object, for following links back.
- if method_name == 'get_list':
- cache_name = rel_field.get_cache_name()
- for obj in related:
- setattr(obj, cache_name, self)
- elif method_name == 'get_object':
- setattr(related, rel_field.get_cache_name(), self)
- return related
-
-# Handles adding related objects.
-# Example: Poll.add_choice()
-def method_add_related(rel_obj, rel_mod, rel_field, self, *args, **kwargs):
- init_kwargs = dict(zip([f.attname for f in rel_obj.fields if f != rel_field and not isinstance(f, AutoField)], args))
- init_kwargs.update(kwargs)
- for f in rel_obj.fields:
- if isinstance(f, AutoField):
- init_kwargs[f.attname] = None
- init_kwargs[rel_field.name] = self
- obj = rel_mod.Klass(**init_kwargs)
- obj.save()
- return obj
-
-# Handles related many-to-many object retrieval.
-# Examples: Album.get_song(), Album.get_song_list(), Album.get_song_count()
-def method_get_related_many_to_many(method_name, opts, rel_mod, rel_field, self, **kwargs):
- kwargs['%s__%s__exact' % (rel_field.name, opts.pk.name)] = getattr(self, opts.pk.attname)
- return getattr(rel_mod, method_name)(**kwargs)
-
-# Handles setting many-to-many related objects.
-# Example: Album.set_songs()
-def method_set_related_many_to_many(rel_opts, rel_field, self, id_list):
- id_list = map(int, id_list) # normalize to integers
- rel = rel_field.rel.to
- m2m_table = rel_field.get_m2m_db_table(rel_opts)
- this_id = getattr(self, self._meta.pk.attname)
- cursor = db.db.cursor()
- cursor.execute("DELETE FROM %s WHERE %s = %%s" % \
- (db.db.quote_name(m2m_table),
- db.db.quote_name(rel.object_name.lower() + '_id')), [this_id])
- sql = "INSERT INTO %s (%s, %s) VALUES (%%s, %%s)" % \
- (db.db.quote_name(m2m_table),
- db.db.quote_name(rel.object_name.lower() + '_id'),
- db.db.quote_name(rel_opts.object_name.lower() + '_id'))
- cursor.executemany(sql, [(this_id, i) for i in id_list])
- db.db.commit()
-
-# ORDERING METHODS #########################
-
-def method_set_order(ordered_obj, self, id_list):
- cursor = db.db.cursor()
- # Example: "UPDATE poll_choices SET _order = %s WHERE poll_id = %s AND id = %s"
- sql = "UPDATE %s SET %s = %%s WHERE %s = %%s AND %s = %%s" % \
- (db.db.quote_name(ordered_obj.db_table), db.db.quote_name('_order'),
- db.db.quote_name(ordered_obj.order_with_respect_to.column),
- db.db.quote_name(ordered_obj.pk.column))
- rel_val = getattr(self, ordered_obj.order_with_respect_to.rel.field_name)
- cursor.executemany(sql, [(i, rel_val, j) for i, j in enumerate(id_list)])
- db.db.commit()
-
-def method_get_order(ordered_obj, self):
- cursor = db.db.cursor()
- # Example: "SELECT id FROM poll_choices WHERE poll_id = %s ORDER BY _order"
- sql = "SELECT %s FROM %s WHERE %s = %%s ORDER BY %s" % \
- (db.db.quote_name(ordered_obj.pk.column),
- db.db.quote_name(ordered_obj.db_table),
- db.db.quote_name(ordered_obj.order_with_respect_to.column),
- db.db.quote_name('_order'))
- rel_val = getattr(self, ordered_obj.order_with_respect_to.rel.field_name)
- cursor.execute(sql, [rel_val])
- return [r[0] for r in cursor.fetchall()]
-
-# DATE-RELATED METHODS #####################
-
-def method_get_next_or_previous(get_object_func, opts, field, is_next, self, **kwargs):
- op = is_next and '>' or '<'
- kwargs.setdefault('where', []).append('(%s %s %%s OR (%s = %%s AND %s.%s %s %%s))' % \
- (db.db.quote_name(field.column), op, db.db.quote_name(field.column),
- db.db.quote_name(opts.db_table), db.db.quote_name(opts.pk.column), op))
- param = str(getattr(self, field.attname))
- kwargs.setdefault('params', []).extend([param, param, getattr(self, opts.pk.attname)])
- kwargs['order_by'] = [(not is_next and '-' or '') + field.name, (not is_next and '-' or '') + opts.pk.name]
- kwargs['limit'] = 1
- return get_object_func(**kwargs)
-
-# CHOICE-RELATED METHODS ###################
-
-def method_get_display_value(field, self):
- value = getattr(self, field.attname)
- return dict(field.choices).get(value, value)
-
-# FILE-RELATED METHODS #####################
-
-def method_get_file_filename(field, self):
- return os.path.join(settings.MEDIA_ROOT, getattr(self, field.attname))
-
-def method_get_file_url(field, self):
- if getattr(self, field.attname): # value is not blank
- import urlparse
- return urlparse.urljoin(settings.MEDIA_URL, getattr(self, field.attname)).replace('\\', '/')
- return ''
-
-def method_get_file_size(field, self):
- return os.path.getsize(method_get_file_filename(field, self))
-
-def method_save_file(field, self, filename, raw_contents):
- directory = field.get_directory_name()
- try: # Create the date-based directory if it doesn't exist.
- os.makedirs(os.path.join(settings.MEDIA_ROOT, directory))
- except OSError: # Directory probably already exists.
- pass
- filename = field.get_filename(filename)
-
- # If the filename already exists, keep adding an underscore to the name of
- # the file until the filename doesn't exist.
- while os.path.exists(os.path.join(settings.MEDIA_ROOT, filename)):
- try:
- dot_index = filename.rindex('.')
- except ValueError: # filename has no dot
- filename += '_'
- else:
- filename = filename[:dot_index] + '_' + filename[dot_index:]
-
- # Write the file to disk.
- setattr(self, field.attname, filename)
- fp = open(getattr(self, 'get_%s_filename' % field.name)(), 'wb')
- fp.write(raw_contents)
- fp.close()
-
- # Save the width and/or height, if applicable.
- if isinstance(field, ImageField) and (field.width_field or field.height_field):
- from django.utils.images import get_image_dimensions
- width, height = get_image_dimensions(getattr(self, 'get_%s_filename' % field.name)())
- if field.width_field:
- setattr(self, field.width_field, width)
- if field.height_field:
- setattr(self, field.height_field, height)
-
- # Save the object, because it has changed.
- self.save()
-
-# IMAGE FIELD METHODS ######################
-
-def method_get_image_width(field, self):
- return _get_image_dimensions(field, self)[0]
-
-def method_get_image_height(field, self):
- return _get_image_dimensions(field, self)[1]
-
-def _get_image_dimensions(field, self):
- cachename = "__%s_dimensions_cache" % field.name
- if not hasattr(self, cachename):
- from django.utils.images import get_image_dimensions
- fname = getattr(self, "get_%s_filename" % field.name)()
- setattr(self, cachename, get_image_dimensions(fname))
- return getattr(self, cachename)
-
-##############################################
-# HELPER FUNCTIONS (CURRIED MODEL FUNCTIONS) #
-##############################################
-
-def get_absolute_url(opts, func, self):
- return settings.ABSOLUTE_URL_OVERRIDES.get('%s.%s' % (opts.app_label, opts.module_name), func)(self)
-
-def _get_where_clause(lookup_type, table_prefix, field_name, value):
- if table_prefix.endswith('.'):
- table_prefix = db.db.quote_name(table_prefix[:-1])+'.'
- field_name = db.db.quote_name(field_name)
- try:
- return '%s%s %s' % (table_prefix, field_name, (db.OPERATOR_MAPPING[lookup_type] % '%s'))
- except KeyError:
- pass
- if lookup_type == 'in':
- return '%s%s IN (%s)' % (table_prefix, field_name, ','.join(['%s' for v in value]))
- elif lookup_type == 'range':
- return '%s%s BETWEEN %%s AND %%s' % (table_prefix, field_name)
- elif lookup_type in ('year', 'month', 'day'):
- return "%s = %%s" % db.get_date_extract_sql(lookup_type, table_prefix + field_name)
- elif lookup_type == 'isnull':
- return "%s%s IS %sNULL" % (table_prefix, field_name, (not value and 'NOT ' or ''))
- raise TypeError, "Got invalid lookup_type: %s" % repr(lookup_type)
-
-def function_get_object(opts, klass, does_not_exist_exception, **kwargs):
- kwargs['order_by'] = kwargs.get('order_by', ())
- obj_list = function_get_list(opts, klass, **kwargs)
- if len(obj_list) < 1:
- raise does_not_exist_exception, "%s does not exist for %s" % (opts.object_name, kwargs)
- assert len(obj_list) == 1, "get_object() returned more than one %s -- it returned %s! Lookup parameters were %s" % (opts.object_name, len(obj_list), kwargs)
- return obj_list[0]
-
-def _get_cached_row(opts, row, index_start):
- "Helper function that recursively returns an object with cache filled"
- index_end = index_start + len(opts.fields)
- obj = opts.get_model_module().Klass(*row[index_start:index_end])
- for f in opts.fields:
- if f.rel and not f.null:
- rel_obj, index_end = _get_cached_row(f.rel.to, row, index_end)
- setattr(obj, f.get_cache_name(), rel_obj)
- return obj, index_end
-
-def function_get_iterator(opts, klass, **kwargs):
- # kwargs['select'] is a dictionary, and dictionaries' key order is
- # undefined, so we convert it to a list of tuples internally.
- kwargs['select'] = kwargs.get('select', {}).items()
-
- cursor = db.db.cursor()
- select, sql, params = function_get_sql_clause(opts, **kwargs)
- cursor.execute("SELECT " + (kwargs.get('distinct') and "DISTINCT " or "") + ",".join(select) + sql, params)
- fill_cache = kwargs.get('select_related')
- index_end = len(opts.fields)
- while 1:
- rows = cursor.fetchmany(GET_ITERATOR_CHUNK_SIZE)
- if not rows:
- raise StopIteration
- for row in rows:
- if fill_cache:
- obj, index_end = _get_cached_row(opts, row, 0)
- else:
- obj = klass(*row[:index_end])
- for i, k in enumerate(kwargs['select']):
- setattr(obj, k[0], row[index_end+i])
- yield obj
-
-def function_get_list(opts, klass, **kwargs):
- return list(function_get_iterator(opts, klass, **kwargs))
-
-def function_get_count(opts, **kwargs):
- kwargs['order_by'] = []
- kwargs['offset'] = None
- kwargs['limit'] = None
- kwargs['select_related'] = False
- _, sql, params = function_get_sql_clause(opts, **kwargs)
- cursor = db.db.cursor()
- cursor.execute("SELECT COUNT(*)" + sql, params)
- return cursor.fetchone()[0]
-
-def function_get_values_iterator(opts, klass, **kwargs):
- # select_related and select aren't supported in get_values().
- kwargs['select_related'] = False
- kwargs['select'] = {}
-
- # 'fields' is a list of field names to fetch.
- try:
- fields = [opts.get_field(f).column for f in kwargs.pop('fields')]
- except KeyError: # Default to all fields.
- fields = [f.column for f in opts.fields]
-
- cursor = db.db.cursor()
- _, sql, params = function_get_sql_clause(opts, **kwargs)
- select = ['%s.%s' % (db.db.quote_name(opts.db_table), db.db.quote_name(f)) for f in fields]
- cursor.execute("SELECT " + (kwargs.get('distinct') and "DISTINCT " or "") + ",".join(select) + sql, params)
- while 1:
- rows = cursor.fetchmany(GET_ITERATOR_CHUNK_SIZE)
- if not rows:
- raise StopIteration
- for row in rows:
- yield dict(zip(fields, row))
-
-def function_get_values(opts, klass, **kwargs):
- return list(function_get_values_iterator(opts, klass, **kwargs))
-
-def _fill_table_cache(opts, select, tables, where, old_prefix, cache_tables_seen):
- """
- Helper function that recursively populates the select, tables and where (in
- place) for fill-cache queries.
- """
- for f in opts.fields:
- if f.rel and not f.null:
- db_table = f.rel.to.db_table
- if db_table not in cache_tables_seen:
- tables.append(db.db.quote_name(db_table))
- else: # The table was already seen, so give it a table alias.
- new_prefix = '%s%s' % (db_table, len(cache_tables_seen))
- tables.append('%s %s' % (db.db.quote_name(db_table), db.db.quote_name(new_prefix)))
- db_table = new_prefix
- cache_tables_seen.append(db_table)
- where.append('%s.%s = %s.%s' % \
- (db.db.quote_name(old_prefix), db.db.quote_name(f.column),
- db.db.quote_name(db_table), db.db.quote_name(f.rel.get_related_field().column)))
- select.extend(['%s.%s' % (db.db.quote_name(db_table), db.db.quote_name(f2.column)) for f2 in f.rel.to.fields])
- _fill_table_cache(f.rel.to, select, tables, where, db_table, cache_tables_seen)
-
-def _throw_bad_kwarg_error(kwarg):
- # Helper function to remove redundancy.
- raise TypeError, "got unexpected keyword argument '%s'" % kwarg
-
-def _parse_lookup(kwarg_items, opts, table_count=0):
- # Helper function that handles converting API kwargs (e.g.
- # "name__exact": "tom") to SQL.
-
- # Note that there is a distinction between where and join_where. The latter
- # is specifically a list of where clauses to use for JOINs. This
- # distinction is necessary because of support for "_or".
-
- # table_count is used to ensure table aliases are unique.
- tables, join_where, where, params = [], [], [], []
- for kwarg, kwarg_value in kwarg_items:
- if kwarg in ('order_by', 'limit', 'offset', 'select_related', 'distinct', 'select', 'tables', 'where', 'params'):
- continue
- if kwarg_value is None:
- continue
- if kwarg == 'complex':
- tables2, join_where2, where2, params2, table_count = kwarg_value.get_sql(opts, table_count)
- tables.extend(tables2)
- join_where.extend(join_where2)
- where.extend(where2)
- params.extend(params2)
- continue
- if kwarg == '_or':
- for val in kwarg_value:
- tables2, join_where2, where2, params2, table_count = _parse_lookup(val, opts, table_count)
- tables.extend(tables2)
- join_where.extend(join_where2)
- where.append('(%s)' % ' OR '.join(where2))
- params.extend(params2)
- continue
- lookup_list = kwarg.split(LOOKUP_SEPARATOR)
- # pk="value" is shorthand for (primary key)__exact="value"
- if lookup_list[-1] == 'pk':
- if opts.pk.rel:
- lookup_list = lookup_list[:-1] + [opts.pk.name, opts.pk.rel.field_name, 'exact']
- else:
- lookup_list = lookup_list[:-1] + [opts.pk.name, 'exact']
- if len(lookup_list) == 1:
- _throw_bad_kwarg_error(kwarg)
- lookup_type = lookup_list.pop()
- current_opts = opts # We'll be overwriting this, so keep a reference to the original opts.
- current_table_alias = current_opts.db_table
- param_required = False
- while lookup_list or param_required:
- table_count += 1
- try:
- # "current" is a piece of the lookup list. For example, in
- # choices.get_list(poll__sites__id__exact=5), lookup_list is
- # ["polls", "sites", "id"], and the first current is "polls".
- try:
- current = lookup_list.pop(0)
- except IndexError:
- # If we're here, lookup_list is empty but param_required
- # is set to True, which means the kwarg was bad.
- # Example: choices.get_list(poll__exact='foo')
- _throw_bad_kwarg_error(kwarg)
- # Try many-to-many relationships first...
- for f in current_opts.many_to_many:
- if f.name == current:
- rel_table_alias = db.db.quote_name('t%s' % table_count)
- table_count += 1
- tables.append('%s %s' % \
- (db.db.quote_name(f.get_m2m_db_table(current_opts)), rel_table_alias))
- join_where.append('%s.%s = %s.%s' % \
- (db.db.quote_name(current_table_alias),
- db.db.quote_name(current_opts.pk.column),
- rel_table_alias,
- db.db.quote_name(current_opts.object_name.lower() + '_id')))
- # Optimization: In the case of primary-key lookups, we
- # don't have to do an extra join.
- if lookup_list and lookup_list[0] == f.rel.to.pk.name and lookup_type == 'exact':
- where.append(_get_where_clause(lookup_type, rel_table_alias+'.',
- f.rel.to.object_name.lower()+'_id', kwarg_value))
- params.extend(f.get_db_prep_lookup(lookup_type, kwarg_value))
- lookup_list.pop()
- param_required = False
- else:
- new_table_alias = 't%s' % table_count
- tables.append('%s %s' % (db.db.quote_name(f.rel.to.db_table),
- db.db.quote_name(new_table_alias)))
- join_where.append('%s.%s = %s.%s' % \
- (db.db.quote_name(rel_table_alias),
- db.db.quote_name(f.rel.to.object_name.lower() + '_id'),
- db.db.quote_name(new_table_alias),
- db.db.quote_name(f.rel.to.pk.column)))
- current_table_alias = new_table_alias
- param_required = True
- current_opts = f.rel.to
- raise StopIteration
- for f in current_opts.fields:
- # Try many-to-one relationships...
- if f.rel and f.name == current:
- # Optimization: In the case of primary-key lookups, we
- # don't have to do an extra join.
- if lookup_list and lookup_list[0] == f.rel.to.pk.name and lookup_type == 'exact':
- where.append(_get_where_clause(lookup_type, current_table_alias+'.', f.column, kwarg_value))
- params.extend(f.get_db_prep_lookup(lookup_type, kwarg_value))
- lookup_list.pop()
- param_required = False
- # 'isnull' lookups in many-to-one relationships are a special case,
- # because we don't want to do a join. We just want to find out
- # whether the foreign key field is NULL.
- elif lookup_type == 'isnull' and not lookup_list:
- where.append(_get_where_clause(lookup_type, current_table_alias+'.', f.column, kwarg_value))
- params.extend(f.get_db_prep_lookup(lookup_type, kwarg_value))
- else:
- new_table_alias = 't%s' % table_count
- tables.append('%s %s' % \
- (db.db.quote_name(f.rel.to.db_table), db.db.quote_name(new_table_alias)))
- join_where.append('%s.%s = %s.%s' % \
- (db.db.quote_name(current_table_alias), db.db.quote_name(f.column),
- db.db.quote_name(new_table_alias), db.db.quote_name(f.rel.to.pk.column)))
- current_table_alias = new_table_alias
- param_required = True
- current_opts = f.rel.to
- raise StopIteration
- # Try direct field-name lookups...
- if f.name == current:
- where.append(_get_where_clause(lookup_type, current_table_alias+'.', f.column, kwarg_value))
- params.extend(f.get_db_prep_lookup(lookup_type, kwarg_value))
- param_required = False
- raise StopIteration
- # If we haven't hit StopIteration at this point, "current" must be
- # an invalid lookup, so raise an exception.
- _throw_bad_kwarg_error(kwarg)
- except StopIteration:
- continue
- return tables, join_where, where, params, table_count
-
-def function_get_sql_clause(opts, **kwargs):
- def quote_only_if_word(word):
- if ' ' in word:
- return word
- else:
- return db.db.quote_name(word)
-
- # Construct the fundamental parts of the query: SELECT X FROM Y WHERE Z.
- select = ["%s.%s" % (db.db.quote_name(opts.db_table), db.db.quote_name(f.column)) for f in opts.fields]
- tables = [opts.db_table] + (kwargs.get('tables') and kwargs['tables'][:] or [])
- tables = [quote_only_if_word(t) for t in tables]
- where = kwargs.get('where') and kwargs['where'][:] or []
- params = kwargs.get('params') and kwargs['params'][:] or []
-
- # Convert the kwargs into SQL.
- tables2, join_where2, where2, params2, _ = _parse_lookup(kwargs.items(), opts)
- tables.extend(tables2)
- where.extend(join_where2 + where2)
- params.extend(params2)
-
- # Add any additional constraints from the "where_constraints" parameter.
- where.extend(opts.where_constraints)
-
- # Add additional tables and WHERE clauses based on select_related.
- if kwargs.get('select_related') is True:
- _fill_table_cache(opts, select, tables, where, opts.db_table, [opts.db_table])
-
- # Add any additional SELECTs passed in via kwargs.
- if kwargs.get('select'):
- select.extend(['(%s) AS %s' % (quote_only_if_word(s[1]), db.db.quote_name(s[0])) for s in kwargs['select']])
-
- # ORDER BY clause
- order_by = []
- for f in handle_legacy_orderlist(kwargs.get('order_by', opts.ordering)):
- if f == '?': # Special case.
- order_by.append(db.get_random_function_sql())
- else:
- if f.startswith('-'):
- col_name = f[1:]
- order = "DESC"
- else:
- col_name = f
- order = "ASC"
- if "." in col_name:
- table_prefix, col_name = col_name.split('.', 1)
- table_prefix = db.db.quote_name(table_prefix) + '.'
- else:
- # Use the database table as a column prefix if it wasn't given,
- # and if the requested column isn't a custom SELECT.
- if "." not in col_name and col_name not in [k[0] for k in kwargs.get('select', [])]:
- table_prefix = db.db.quote_name(opts.db_table) + '.'
- else:
- table_prefix = ''
- order_by.append('%s%s %s' % (table_prefix, db.db.quote_name(orderfield2column(col_name, opts)), order))
- order_by = ", ".join(order_by)
-
- # LIMIT and OFFSET clauses
- if kwargs.get('limit') is not None:
- limit_sql = " %s " % db.get_limit_offset_sql(kwargs['limit'], kwargs.get('offset'))
- else:
- assert kwargs.get('offset') is None, "'offset' is not allowed without 'limit'"
- limit_sql = ""
-
- return select, " FROM " + ",".join(tables) + (where and " WHERE " + " AND ".join(where) or "") + (order_by and " ORDER BY " + order_by or "") + limit_sql, params
-
-def function_get_in_bulk(opts, klass, *args, **kwargs):
- id_list = args and args[0] or kwargs.get('id_list', [])
- assert id_list != [], "get_in_bulk() cannot be passed an empty list."
- kwargs['where'] = ["%s.%s IN (%s)" % (db.db.quote_name(opts.db_table), db.db.quote_name(opts.pk.column), ",".join(['%s'] * len(id_list)))]
- kwargs['params'] = id_list
- obj_list = function_get_list(opts, klass, **kwargs)
- return dict([(getattr(o, opts.pk.attname), o) for o in obj_list])
-
-def function_get_latest(opts, klass, does_not_exist_exception, **kwargs):
- kwargs['order_by'] = ('-' + opts.get_latest_by,)
- kwargs['limit'] = 1
- return function_get_object(opts, klass, does_not_exist_exception, **kwargs)
-
-def function_get_date_list(opts, field, *args, **kwargs):
- from django.core.db.typecasts import typecast_timestamp
- kind = args and args[0] or kwargs['kind']
- assert kind in ("month", "year", "day"), "'kind' must be one of 'year', 'month' or 'day'."
- order = kwargs.pop('_order', 'ASC')
- assert order in ('ASC', 'DESC'), "'order' must be either 'ASC' or 'DESC'"
- kwargs['order_by'] = [] # Clear this because it'll mess things up otherwise.
- if field.null:
- kwargs.setdefault('where', []).append('%s.%s IS NOT NULL' % \
- (db.db.quote_name(opts.db_table), db.db.quote_name(field.column)))
- select, sql, params = function_get_sql_clause(opts, **kwargs)
- sql = 'SELECT %s %s GROUP BY 1 ORDER BY 1' % (db.get_date_trunc_sql(kind, '%s.%s' % (db.db.quote_name(opts.db_table), db.db.quote_name(field.column))), sql)
- cursor = db.db.cursor()
- cursor.execute(sql, params)
- # We have to manually run typecast_timestamp(str()) on the results, because
- # MySQL doesn't automatically cast the result of date functions as datetime
- # objects -- MySQL returns the values as strings, instead.
- return [typecast_timestamp(str(row[0])) for row in cursor.fetchall()]
-
-###################################
-# HELPER FUNCTIONS (MANIPULATORS) #
-###################################
-
-def get_manipulator(opts, klass, extra_methods, add=False, change=False):
- "Returns the custom Manipulator (either add or change) for the given opts."
- assert (add == False or change == False) and add != change, "get_manipulator() can be passed add=True or change=True, but not both"
- man = types.ClassType('%sManipulator%s' % (opts.object_name, add and 'Add' or 'Change'), (formfields.Manipulator,), {})
- man.__module__ = MODEL_PREFIX + '.' + opts.module_name # Set this explicitly, as above.
- man.__init__ = curry(manipulator_init, opts, add, change)
- man.save = curry(manipulator_save, opts, klass, add, change)
- man.get_related_objects = curry(manipulator_get_related_objects, opts, klass, add, change)
- man.flatten_data = curry(manipulator_flatten_data, opts, klass, add, change)
- for field_name_list in opts.unique_together:
- setattr(man, 'isUnique%s' % '_'.join(field_name_list), curry(manipulator_validator_unique_together, field_name_list, opts))
- for f in opts.fields:
- if f.unique_for_date:
- setattr(man, 'isUnique%sFor%s' % (f.name, f.unique_for_date), curry(manipulator_validator_unique_for_date, f, opts.get_field(f.unique_for_date), opts, 'date'))
- if f.unique_for_month:
- setattr(man, 'isUnique%sFor%s' % (f.name, f.unique_for_month), curry(manipulator_validator_unique_for_date, f, opts.get_field(f.unique_for_month), opts, 'month'))
- if f.unique_for_year:
- setattr(man, 'isUnique%sFor%s' % (f.name, f.unique_for_year), curry(manipulator_validator_unique_for_date, f, opts.get_field(f.unique_for_year), opts, 'year'))
- for k, v in extra_methods.items():
- setattr(man, k, v)
- return man
-
-def manipulator_init(opts, add, change, self, obj_key=None, follow=None):
- self.follow = opts.get_follow(follow)
-
- if change:
- assert obj_key is not None, "ChangeManipulator.__init__() must be passed obj_key parameter."
- self.obj_key = obj_key
- try:
- self.original_object = opts.get_model_module().get_object(pk=obj_key)
- except ObjectDoesNotExist:
- # If the object doesn't exist, this might be a manipulator for a
- # one-to-one related object that hasn't created its subobject yet.
- # For example, this might be a Restaurant for a Place that doesn't
- # yet have restaurant information.
- if opts.one_to_one_field:
- # Sanity check -- Make sure the "parent" object exists.
- # For example, make sure the Place exists for the Restaurant.
- # Let the ObjectDoesNotExist exception propagate up.
- lookup_kwargs = opts.one_to_one_field.rel.limit_choices_to
- lookup_kwargs['%s__exact' % opts.one_to_one_field.rel.field_name] = obj_key
- _ = opts.one_to_one_field.rel.to.get_model_module().get_object(**lookup_kwargs)
- params = dict([(f.attname, f.get_default()) for f in opts.fields])
- params[opts.pk.attname] = obj_key
- self.original_object = opts.get_model_module().Klass(**params)
- else:
- raise
- self.fields = []
-
- for f in opts.fields + opts.many_to_many:
- if self.follow.get(f.name, False):
- self.fields.extend(f.get_manipulator_fields(opts, self, change))
-
- # Add fields for related objects.
- for f in opts.get_all_related_objects():
- if self.follow.get(f.name, False):
- fol = self.follow[f.name]
- self.fields.extend(f.get_manipulator_fields(opts, self, change, fol))
-
- # Add field for ordering.
- if change and opts.get_ordered_objects():
- self.fields.append(formfields.CommaSeparatedIntegerField(field_name="order_"))
-
-def manipulator_save(opts, klass, add, change, self, new_data):
- # TODO: big cleanup when core fields go -> use recursive manipulators.
- from django.utils.datastructures import DotExpandedDict
- params = {}
- for f in opts.fields:
- # Fields with auto_now_add should keep their original value in the change stage.
- auto_now_add = change and getattr(f, 'auto_now_add', False)
- if self.follow.get(f.name, None) and not auto_now_add:
- param = f.get_manipulator_new_data(new_data)
- else:
- if change:
- param = getattr(self.original_object, f.attname)
- else:
- param = f.get_default()
- params[f.attname] = param
-
- if change:
- params[opts.pk.attname] = self.obj_key
-
- # First, save the basic object itself.
- new_object = klass(**params)
- new_object.save()
-
- # Now that the object's been saved, save any uploaded files.
- for f in opts.fields:
- if isinstance(f, FileField):
- f.save_file(new_data, new_object, change and self.original_object or None, change, rel=False)
-
- # Calculate which primary fields have changed.
- if change:
- self.fields_added, self.fields_changed, self.fields_deleted = [], [], []
- for f in opts.fields:
- if not f.primary_key and str(getattr(self.original_object, f.attname)) != str(getattr(new_object, f.attname)):
- self.fields_changed.append(f.verbose_name)
-
- # Save many-to-many objects. Example: Poll.set_sites()
- for f in opts.many_to_many:
- if self.follow.get(f.name, None):
- if not f.rel.edit_inline:
- if f.rel.raw_id_admin:
- new_vals = new_data.get(f.name, ())
- else:
- new_vals = new_data.getlist(f.name)
- was_changed = getattr(new_object, 'set_%s' % f.name)(new_vals)
- if change and was_changed:
- self.fields_changed.append(f.verbose_name)
-
- expanded_data = DotExpandedDict(dict(new_data))
- # Save many-to-one objects. Example: Add the Choice objects for a Poll.
- for related in opts.get_all_related_objects():
- # Create obj_list, which is a DotExpandedDict such as this:
- # [('0', {'id': ['940'], 'choice': ['This is the first choice']}),
- # ('1', {'id': ['941'], 'choice': ['This is the second choice']}),
- # ('2', {'id': [''], 'choice': ['']})]
- child_follow = self.follow.get(related.name, None)
-
- if child_follow:
- obj_list = expanded_data[related.var_name].items()
- obj_list.sort(lambda x, y: cmp(int(x[0]), int(y[0])))
-
- # For each related item...
- for _, rel_new_data in obj_list:
-
- params = {}
-
- # Keep track of which core=True fields were provided.
- # If all core fields were given, the related object will be saved.
- # If none of the core fields were given, the object will be deleted.
- # If some, but not all, of the fields were given, the validator would
- # have caught that.
- all_cores_given, all_cores_blank = True, True
-
- # Get a reference to the old object. We'll use it to compare the
- # old to the new, to see which fields have changed.
- old_rel_obj = None
- if change:
- if rel_new_data[related.opts.pk.name][0]:
- try:
- old_rel_obj = getattr(self.original_object, 'get_%s' % related.get_method_name_part() )(**{'%s__exact' % related.opts.pk.name: rel_new_data[related.opts.pk.attname][0]})
- except ObjectDoesNotExist:
- pass
-
- for f in related.opts.fields:
- if f.core and not isinstance(f, FileField) and f.get_manipulator_new_data(rel_new_data, rel=True) in (None, ''):
- all_cores_given = False
- elif f.core and not isinstance(f, FileField) and f.get_manipulator_new_data(rel_new_data, rel=True) not in (None, ''):
- all_cores_blank = False
- # If this field isn't editable, give it the same value it had
- # previously, according to the given ID. If the ID wasn't
- # given, use a default value. FileFields are also a special
- # case, because they'll be dealt with later.
-
- if f == related.field:
- param = getattr(new_object, related.field.rel.field_name)
- elif add and isinstance(f, AutoField):
- param = None
- elif change and (isinstance(f, FileField) or not child_follow.get(f.name, None)):
- if old_rel_obj:
- param = getattr(old_rel_obj, f.column)
- else:
- param = f.get_default()
- else:
- param = f.get_manipulator_new_data(rel_new_data, rel=True)
- if param != None:
- params[f.attname] = param
-
- # Related links are a special case, because we have to
- # manually set the "content_type_id" and "object_id" fields.
- if opts.has_related_links and related.opts.module_name == 'relatedlinks':
- contenttypes_mod = get_module('core', 'contenttypes')
- params['content_type_id'] = contenttypes_mod.get_object(package__label__exact=opts.app_label, python_module_name__exact=opts.module_name).id
- params['object_id'] = new_object.id
-
- # Create the related item.
- new_rel_obj = related.opts.get_model_module().Klass(**params)
-
- # If all the core fields were provided (non-empty), save the item.
- if all_cores_given:
- new_rel_obj.save()
-
- # Save any uploaded files.
- for f in related.opts.fields:
- if child_follow.get(f.name, None):
- if isinstance(f, FileField) and rel_new_data.get(f.name, False):
- f.save_file(rel_new_data, new_rel_obj, change and old_rel_obj or None, old_rel_obj is not None, rel=True)
-
- # Calculate whether any fields have changed.
- if change:
- if not old_rel_obj: # This object didn't exist before.
- self.fields_added.append('%s "%s"' % (related.opts.verbose_name, new_rel_obj))
- else:
- for f in related.opts.fields:
- if not f.primary_key and f != related.field and str(getattr(old_rel_obj, f.attname)) != str(getattr(new_rel_obj, f.attname)):
- self.fields_changed.append('%s for %s "%s"' % (f.verbose_name, related.opts.verbose_name, new_rel_obj))
-
- # Save many-to-many objects.
- for f in related.opts.many_to_many:
- if child_follow.get(f.name, None) and not f.rel.edit_inline:
- was_changed = getattr(new_rel_obj, 'set_%s' % f.name)(rel_new_data[f.attname])
- if change and was_changed:
- self.fields_changed.append('%s for %s "%s"' % (f.verbose_name, related.opts.verbose_name, new_rel_obj))
-
- # If, in the change stage, all of the core fields were blank and
- # the primary key (ID) was provided, delete the item.
- if change and all_cores_blank and old_rel_obj:
- new_rel_obj.delete()
- self.fields_deleted.append('%s "%s"' % (related.opts.verbose_name, old_rel_obj))
-
- # Save the order, if applicable.
- if change and opts.get_ordered_objects():
- order = new_data['order_'] and map(int, new_data['order_'].split(',')) or []
- for rel_opts in opts.get_ordered_objects():
- getattr(new_object, 'set_%s_order' % rel_opts.object_name.lower())(order)
- return new_object
-
-def manipulator_get_related_objects(opts, klass, add, change, self):
- return opts.get_followed_related_objects(self.follow)
-
-def manipulator_flatten_data(opts, klass, add, change, self):
- new_data = {}
- obj = change and self.original_object or None
- for f in opts.get_data_holders(self.follow):
- fol = self.follow.get(f.name)
- new_data.update(f.flatten_data(fol, obj))
- return new_data
-
-def manipulator_validator_unique_together(field_name_list, opts, self, field_data, all_data):
- from django.utils.text import get_text_list
- field_list = [opts.get_field(field_name) for field_name in field_name_list]
- if isinstance(field_list[0].rel, ManyToOneRel):
- kwargs = {'%s__%s__iexact' % (field_name_list[0], field_list[0].rel.field_name): field_data}
- else:
- kwargs = {'%s__iexact' % field_name_list[0]: field_data}
- for f in field_list[1:]:
- # This is really not going to work for fields that have different
- # form fields, e.g. DateTime.
- # This validation needs to occur after html2python to be effective.
- field_val = all_data.get(f.attname, None)
- if field_val is None:
- # This will be caught by another validator, assuming the field
- # doesn't have blank=True.
- return
- if isinstance(f.rel, ManyToOneRel):
- kwargs['%s__pk' % f.name] = field_val
- else:
- kwargs['%s__iexact' % f.name] = field_val
- mod = opts.get_model_module()
- try:
- old_obj = mod.get_object(**kwargs)
- except ObjectDoesNotExist:
- return
- if hasattr(self, 'original_object') and getattr(self.original_object, opts.pk.attname) == getattr(old_obj, opts.pk.attname):
- pass
- else:
- raise validators.ValidationError, _("%(object)s with this %(type)s already exists for the given %(field)s.") % {
- 'object': capfirst(opts.verbose_name), 'type': field_list[0].verbose_name, 'field': get_text_list(field_name_list[1:], 'and')}
-
-def manipulator_validator_unique_for_date(from_field, date_field, opts, lookup_type, self, field_data, all_data):
- date_str = all_data.get(date_field.get_manipulator_field_names('')[0], None)
- mod = opts.get_model_module()
- date_val = formfields.DateField.html2python(date_str)
- if date_val is None:
- return # Date was invalid. This will be caught by another validator.
- lookup_kwargs = {'%s__year' % date_field.name: date_val.year}
- if isinstance(from_field.rel, ManyToOneRel):
- lookup_kwargs['%s__pk' % from_field.name] = field_data
- else:
- lookup_kwargs['%s__iexact' % from_field.name] = field_data
- if lookup_type in ('month', 'date'):
- lookup_kwargs['%s__month' % date_field.name] = date_val.month
- if lookup_type == 'date':
- lookup_kwargs['%s__day' % date_field.name] = date_val.day
- try:
- old_obj = mod.get_object(**lookup_kwargs)
- except ObjectDoesNotExist:
- return
- else:
- if hasattr(self, 'original_object') and getattr(self.original_object, opts.pk.attname) == getattr(old_obj, opts.pk.attname):
- pass
- else:
- format_string = (lookup_type == 'date') and '%B %d, %Y' or '%B %Y'
- raise validators.ValidationError, "Please enter a different %s. The one you entered is already being used for %s." % \
- (from_field.verbose_name, date_val.strftime(format_string))
diff --git a/django/core/paginator.py b/django/core/paginator.py
index a4dbfebaae..6e01c1ccec 100644
--- a/django/core/paginator.py
+++ b/django/core/paginator.py
@@ -6,20 +6,17 @@ class InvalidPage(Exception):
class ObjectPaginator:
"""
- This class makes pagination easy. Feed it a module (an object with
- get_count() and get_list() methods) and a dictionary of arguments
- to be passed to those methods, plus the number of objects you want
- on each page. Then read the hits and pages properties to see how
- many pages it involves. Call get_page with a page number (starting
+ This class makes pagination easy. Feed it a QuerySet, plus the number of
+ objects you want on each page. Then read the hits and pages properties to
+ see how many pages it involves. Call get_page with a page number (starting
at 0) to get back a list of objects for that page.
Finally, check if a page number has a next/prev page using
has_next_page(page_number) and has_previous_page(page_number).
"""
- def __init__(self, module, args, num_per_page, count_method='get_count', list_method='get_list'):
- self.module, self.args = module, args
+ def __init__(self, query_set, num_per_page):
+ self.query_set = query_set
self.num_per_page = num_per_page
- self.count_method, self.list_method = count_method, list_method
self._hits, self._pages = None, None
self._has_next = {} # Caches page_number -> has_next_boolean
@@ -30,14 +27,17 @@ class ObjectPaginator:
raise InvalidPage
if page_number < 0:
raise InvalidPage
- args = copy(self.args)
- args['offset'] = page_number * self.num_per_page
+
# Retrieve one extra record, and check for the existence of that extra
# record to determine whether there's a next page.
- args['limit'] = self.num_per_page + 1
- object_list = getattr(self.module, self.list_method)(**args)
+ limit = self.num_per_page + 1
+ offset = page_number * self.num_per_page
+
+ object_list = list(self.query_set[offset:offset+limit])
+
if not object_list:
raise InvalidPage
+
self._has_next[page_number] = (len(object_list) > self.num_per_page)
return object_list[:self.num_per_page]
@@ -45,11 +45,8 @@ class ObjectPaginator:
"Does page $page_number have a 'next' page?"
if not self._has_next.has_key(page_number):
if self._pages is None:
- args = copy(self.args)
- args['offset'] = (page_number + 1) * self.num_per_page
- args['limit'] = 1
- object_list = getattr(self.module, self.list_method)(**args)
- self._has_next[page_number] = (object_list != [])
+ offset = (page_number + 1) * self.num_per_page
+ self._has_next[page_number] = len(self.query_set[offset:offset+1]) > 0
else:
self._has_next[page_number] = page_number < (self.pages - 1)
return self._has_next[page_number]
@@ -59,12 +56,7 @@ class ObjectPaginator:
def _get_hits(self):
if self._hits is None:
- order_args = copy(self.args)
- if order_args.has_key('order_by'):
- del order_args['order_by']
- if order_args.has_key('select_related'):
- del order_args['select_related']
- self._hits = getattr(self.module, self.count_method)(**order_args)
+ self._hits = self.query_set.count()
return self._hits
def _get_pages(self):
diff --git a/django/core/servers/basehttp.py b/django/core/servers/basehttp.py
index c792e0a970..5772912031 100644
--- a/django/core/servers/basehttp.py
+++ b/django/core/servers/basehttp.py
@@ -242,7 +242,7 @@ class ServerHandler:
# Error handling (also per-subclass or per-instance)
traceback_limit = None # Print entire traceback to self.get_stderr()
- error_status = "500 Dude, this is whack!"
+ error_status = "500 INTERNAL SERVER ERROR"
error_headers = [('Content-Type','text/plain')]
# State variables (don't mess with these)
@@ -383,7 +383,7 @@ class ServerHandler:
assert type(data) is StringType,"write() argument must be string"
if not self.status:
- raise AssertionError("write() before start_response()")
+ raise AssertionError("write() before start_response()")
elif not self.headers_sent:
# Before the first output, send the stored headers
@@ -532,8 +532,8 @@ class WSGIRequestHandler(BaseHTTPRequestHandler):
server_version = "WSGIServer/" + __version__
def __init__(self, *args, **kwargs):
- from django.conf.settings import ADMIN_MEDIA_PREFIX
- self.admin_media_prefix = ADMIN_MEDIA_PREFIX
+ from django.conf import settings
+ self.admin_media_prefix = settings.ADMIN_MEDIA_PREFIX
BaseHTTPRequestHandler.__init__(self, *args, **kwargs)
def get_environ(self):
diff --git a/django/core/signals.py b/django/core/signals.py
new file mode 100644
index 0000000000..7a236079a5
--- /dev/null
+++ b/django/core/signals.py
@@ -0,0 +1,3 @@
+request_started = object()
+request_finished = object()
+got_request_exception = object()
diff --git a/django/core/template_loader.py b/django/core/template_loader.py
index e268c390e1..ee86178cc1 100644
--- a/django/core/template_loader.py
+++ b/django/core/template_loader.py
@@ -1,7 +1,7 @@
# This module is DEPRECATED!
#
-# You should no longer be using django.core.template_loader.
+# You should no longer be using django.template_loader.
#
-# Use django.core.template.loader instead.
+# Use django.template.loader instead.
-from django.core.template.loader import *
+from django.template.loader import *
diff --git a/django/core/urlresolvers.py b/django/core/urlresolvers.py
index 9582dd4d81..e11b63e977 100644
--- a/django/core/urlresolvers.py
+++ b/django/core/urlresolvers.py
@@ -7,7 +7,8 @@ a string) and returns a tuple in this format:
(view_function, function_args, function_kwargs)
"""
-from django.core.exceptions import Http404, ImproperlyConfigured, ViewDoesNotExist
+from django.http import Http404
+from django.core.exceptions import ImproperlyConfigured, ViewDoesNotExist
import re
class Resolver404(Http404):
diff --git a/django/core/validators.py b/django/core/validators.py
index 88cf6db4e1..91d72033de 100644
--- a/django/core/validators.py
+++ b/django/core/validators.py
@@ -8,6 +8,9 @@ validator will *always* be run, regardless of whether its associated
form field is required.
"""
+from django.conf import settings
+from django.utils.translation import gettext, gettext_lazy, ngettext
+from django.utils.functional import Promise, lazy
import re
_datere = r'(19|2\d)\d{2}-((?:0?[1-9])|(?:1[0-2]))-((?:0?[1-9])|(?:[12][0-9])|(?:3[0-1]))'
@@ -24,10 +27,6 @@ phone_re = re.compile(r'^[A-PR-Y0-9]{3}-[A-PR-Y0-9]{3}-[A-PR-Y0-9]{4}$', re.IGNO
slug_re = re.compile(r'^[-\w]+$')
url_re = re.compile(r'^https?://\S+$')
-from django.conf.settings import JING_PATH
-from django.utils.translation import gettext_lazy, ngettext
-from django.utils.functional import Promise, lazy
-
lazy_inter = lazy(lambda a,b: str(a) % b, str)
class ValidationError(Exception):
@@ -58,11 +57,11 @@ class CriticalValidationError(Exception):
def isAlphaNumeric(field_data, all_data):
if not alnum_re.search(field_data):
- raise ValidationError, _("This value must contain only letters, numbers and underscores.")
+ raise ValidationError, gettext("This value must contain only letters, numbers and underscores.")
def isAlphaNumericURL(field_data, all_data):
if not alnumurl_re.search(field_data):
- raise ValidationError, _("This value must contain only letters, numbers, underscores, dashes or slashes.")
+ raise ValidationError, gettext("This value must contain only letters, numbers, underscores, dashes or slashes.")
def isSlug(field_data, all_data):
if not slug_re.search(field_data):
@@ -70,18 +69,18 @@ def isSlug(field_data, all_data):
def isLowerCase(field_data, all_data):
if field_data.lower() != field_data:
- raise ValidationError, _("Uppercase letters are not allowed here.")
+ raise ValidationError, gettext("Uppercase letters are not allowed here.")
def isUpperCase(field_data, all_data):
if field_data.upper() != field_data:
- raise ValidationError, _("Lowercase letters are not allowed here.")
+ raise ValidationError, gettext("Lowercase letters are not allowed here.")
def isCommaSeparatedIntegerList(field_data, all_data):
for supposed_int in field_data.split(','):
try:
int(supposed_int)
except ValueError:
- raise ValidationError, _("Enter only digits separated by commas.")
+ raise ValidationError, gettext("Enter only digits separated by commas.")
def isCommaSeparatedEmailList(field_data, all_data):
"""
@@ -93,48 +92,48 @@ def isCommaSeparatedEmailList(field_data, all_data):
try:
isValidEmail(supposed_email.strip(), '')
except ValidationError:
- raise ValidationError, _("Enter valid e-mail addresses separated by commas.")
+ raise ValidationError, gettext("Enter valid e-mail addresses separated by commas.")
def isValidIPAddress4(field_data, all_data):
if not ip4_re.search(field_data):
- raise ValidationError, _("Please enter a valid IP address.")
+ raise ValidationError, gettext("Please enter a valid IP address.")
def isNotEmpty(field_data, all_data):
if field_data.strip() == '':
- raise ValidationError, _("Empty values are not allowed here.")
+ raise ValidationError, gettext("Empty values are not allowed here.")
def isOnlyDigits(field_data, all_data):
if not field_data.isdigit():
- raise ValidationError, _("Non-numeric characters aren't allowed here.")
+ raise ValidationError, gettext("Non-numeric characters aren't allowed here.")
def isNotOnlyDigits(field_data, all_data):
if field_data.isdigit():
- raise ValidationError, _("This value can't be comprised solely of digits.")
+ raise ValidationError, gettext("This value can't be comprised solely of digits.")
def isInteger(field_data, all_data):
# This differs from isOnlyDigits because this accepts the negative sign
if not integer_re.search(field_data):
- raise ValidationError, _("Enter a whole number.")
+ raise ValidationError, gettext("Enter a whole number.")
def isOnlyLetters(field_data, all_data):
if not field_data.isalpha():
- raise ValidationError, _("Only alphabetical characters are allowed here.")
+ raise ValidationError, gettext("Only alphabetical characters are allowed here.")
def isValidANSIDate(field_data, all_data):
if not ansi_date_re.search(field_data):
- raise ValidationError, _('Enter a valid date in YYYY-MM-DD format.')
+ raise ValidationError, gettext('Enter a valid date in YYYY-MM-DD format.')
def isValidANSITime(field_data, all_data):
if not ansi_time_re.search(field_data):
- raise ValidationError, _('Enter a valid time in HH:MM format.')
+ raise ValidationError, gettext('Enter a valid time in HH:MM format.')
def isValidANSIDatetime(field_data, all_data):
if not ansi_datetime_re.search(field_data):
- raise ValidationError, _('Enter a valid date/time in YYYY-MM-DD HH:MM format.')
+ raise ValidationError, gettext('Enter a valid date/time in YYYY-MM-DD HH:MM format.')
def isValidEmail(field_data, all_data):
if not email_re.search(field_data):
- raise ValidationError, _('Enter a valid e-mail address.')
+ raise ValidationError, gettext('Enter a valid e-mail address.')
def isValidImage(field_data, all_data):
"""
@@ -146,18 +145,18 @@ def isValidImage(field_data, all_data):
try:
Image.open(StringIO(field_data['content']))
except IOError: # Python Imaging Library doesn't recognize it as an image
- raise ValidationError, _("Upload a valid image. The file you uploaded was either not an image or a corrupted image.")
+ raise ValidationError, gettext("Upload a valid image. The file you uploaded was either not an image or a corrupted image.")
def isValidImageURL(field_data, all_data):
uc = URLMimeTypeCheck(('image/jpeg', 'image/gif', 'image/png'))
try:
uc(field_data, all_data)
except URLMimeTypeCheck.InvalidContentType:
- raise ValidationError, _("The URL %s does not point to a valid image.") % field_data
+ raise ValidationError, gettext("The URL %s does not point to a valid image.") % field_data
def isValidPhone(field_data, all_data):
if not phone_re.search(field_data):
- raise ValidationError, _('Phone numbers must be in XXX-XXX-XXXX format. "%s" is invalid.') % field_data
+ raise ValidationError, gettext('Phone numbers must be in XXX-XXX-XXXX format. "%s" is invalid.') % field_data
def isValidQuicktimeVideoURL(field_data, all_data):
"Checks that the given URL is a video that can be played by QuickTime (qt, mpeg)"
@@ -165,11 +164,11 @@ def isValidQuicktimeVideoURL(field_data, all_data):
try:
uc(field_data, all_data)
except URLMimeTypeCheck.InvalidContentType:
- raise ValidationError, _("The URL %s does not point to a valid QuickTime video.") % field_data
+ raise ValidationError, gettext("The URL %s does not point to a valid QuickTime video.") % field_data
def isValidURL(field_data, all_data):
if not url_re.search(field_data):
- raise ValidationError, _("A valid URL is required.")
+ raise ValidationError, gettext("A valid URL is required.")
def isValidHTML(field_data, all_data):
import urllib, urllib2
@@ -183,14 +182,14 @@ def isValidHTML(field_data, all_data):
return
from xml.dom.minidom import parseString
error_messages = [e.firstChild.wholeText for e in parseString(u.read()).getElementsByTagName('messages')[0].getElementsByTagName('msg')]
- raise ValidationError, _("Valid HTML is required. Specific errors are:\n%s") % "\n".join(error_messages)
+ raise ValidationError, gettext("Valid HTML is required. Specific errors are:\n%s") % "\n".join(error_messages)
def isWellFormedXml(field_data, all_data):
from xml.dom.minidom import parseString
try:
parseString(field_data)
except Exception, e: # Naked except because we're not sure what will be thrown
- raise ValidationError, _("Badly formed XML: %s") % str(e)
+ raise ValidationError, gettext("Badly formed XML: %s") % str(e)
def isWellFormedXmlFragment(field_data, all_data):
isWellFormedXml('%s ' % field_data, all_data)
@@ -200,19 +199,19 @@ def isExistingURL(field_data, all_data):
try:
u = urllib2.urlopen(field_data)
except ValueError:
- raise ValidationError, _("Invalid URL: %s") % field_data
+ raise ValidationError, gettext("Invalid URL: %s") % field_data
except urllib2.HTTPError, e:
# 401s are valid; they just mean authorization is required.
if e.code not in ('401',):
- raise ValidationError, _("The URL %s is a broken link.") % field_data
+ raise ValidationError, gettext("The URL %s is a broken link.") % field_data
except: # urllib2.URLError, httplib.InvalidURL, etc.
- raise ValidationError, _("The URL %s is a broken link.") % field_data
+ raise ValidationError, gettext("The URL %s is a broken link.") % field_data
def isValidUSState(field_data, all_data):
"Checks that the given string is a valid two-letter U.S. state abbreviation"
states = ['AA', 'AE', 'AK', 'AL', 'AP', 'AR', 'AS', 'AZ', 'CA', 'CO', 'CT', 'DC', 'DE', 'FL', 'FM', 'GA', 'GU', 'HI', 'IA', 'ID', 'IL', 'IN', 'KS', 'KY', 'LA', 'MA', 'MD', 'ME', 'MH', 'MI', 'MN', 'MO', 'MP', 'MS', 'MT', 'NC', 'ND', 'NE', 'NH', 'NJ', 'NM', 'NV', 'NY', 'OH', 'OK', 'OR', 'PA', 'PR', 'PW', 'RI', 'SC', 'SD', 'TN', 'TX', 'UT', 'VA', 'VI', 'VT', 'WA', 'WI', 'WV', 'WY']
if field_data.upper() not in states:
- raise ValidationError, _("Enter a valid U.S. state abbreviation.")
+ raise ValidationError, gettext("Enter a valid U.S. state abbreviation.")
def hasNoProfanities(field_data, all_data):
"""
@@ -334,7 +333,7 @@ class IsAPowerOf:
from math import log
val = log(int(field_data)) / log(self.power_of)
if val != int(val):
- raise ValidationError, _("This value must be a power of %s.") % self.power_of
+ raise ValidationError, gettext("This value must be a power of %s.") % self.power_of
class IsValidFloat:
def __init__(self, max_digits, decimal_places):
@@ -345,9 +344,9 @@ class IsValidFloat:
try:
float(data)
except ValueError:
- raise ValidationError, _("Please enter a valid decimal number.")
+ raise ValidationError, gettext("Please enter a valid decimal number.")
if len(data) > (self.max_digits + 1):
- raise ValidationError, ngettext( "Please enter a valid decimal number with at most %s total digit.",
+ raise ValidationError, ngettext("Please enter a valid decimal number with at most %s total digit.",
"Please enter a valid decimal number with at most %s total digits.", self.max_digits) % self.max_digits
if '.' in data and len(data.split('.')[1]) > self.decimal_places:
raise ValidationError, ngettext("Please enter a valid decimal number with at most %s decimal place.",
@@ -424,10 +423,10 @@ class URLMimeTypeCheck:
try:
info = urllib2.urlopen(field_data).info()
except (urllib2.HTTPError, urllib2.URLError):
- raise URLMimeTypeCheck.CouldNotRetrieve, _("Could not retrieve anything from %s.") % field_data
+ raise URLMimeTypeCheck.CouldNotRetrieve, gettext("Could not retrieve anything from %s.") % field_data
content_type = info['content-type']
if content_type not in self.mime_type_list:
- raise URLMimeTypeCheck.InvalidContentType, _("The URL %(url)s returned the invalid Content-Type header '%(contenttype)s'.") % {
+ raise URLMimeTypeCheck.InvalidContentType, gettext("The URL %(url)s returned the invalid Content-Type header '%(contenttype)s'.") % {
'url': field_data, 'contenttype': content_type}
class RelaxNGCompact:
@@ -447,9 +446,9 @@ class RelaxNGCompact:
fp = open(filename, 'w')
fp.write(field_data)
fp.close()
- if not os.path.exists(JING_PATH):
- raise Exception, "%s not found!" % JING_PATH
- p = os.popen('%s -c %s %s' % (JING_PATH, self.schema_path, filename))
+ if not os.path.exists(settings.JING_PATH):
+ raise Exception, "%s not found!" % settings.JING_PATH
+ p = os.popen('%s -c %s %s' % (settings.JING_PATH, self.schema_path, filename))
errors = [line.strip() for line in p.readlines()]
p.close()
os.unlink(filename)
diff --git a/django/core/xheaders.py b/django/core/xheaders.py
index 98d2586b75..e173bcbca8 100644
--- a/django/core/xheaders.py
+++ b/django/core/xheaders.py
@@ -9,14 +9,13 @@ that custom headers are prefxed with "X-").
Next time you're at slashdot.org, watch out for X-Fry and X-Bender. :)
"""
-def populate_xheaders(request, response, package, python_module_name, object_id):
+def populate_xheaders(request, response, model, object_id):
"""
Adds the "X-Object-Type" and "X-Object-Id" headers to the given
- HttpResponse according to the given package, python_module_name and
- object_id -- but only if the given HttpRequest object has an IP address
- within the INTERNAL_IPS setting.
+ HttpResponse according to the given model and object_id -- but only if the
+ given HttpRequest object has an IP address within the INTERNAL_IPS setting.
"""
- from django.conf.settings import INTERNAL_IPS
- if request.META.get('REMOTE_ADDR') in INTERNAL_IPS:
- response['X-Object-Type'] = "%s.%s" % (package, python_module_name)
+ from django.conf import settings
+ if request.META.get('REMOTE_ADDR') in settings.INTERNAL_IPS:
+ response['X-Object-Type'] = "%s.%s" % (model._meta.app_label, model._meta.object_name.lower())
response['X-Object-Id'] = str(object_id)
diff --git a/django/db/__init__.py b/django/db/__init__.py
new file mode 100644
index 0000000000..317d6059bf
--- /dev/null
+++ b/django/db/__init__.py
@@ -0,0 +1,45 @@
+from django.conf import settings
+from django.core import signals
+from django.dispatch import dispatcher
+
+__all__ = ('backend', 'connection', 'DatabaseError')
+
+if not settings.DATABASE_ENGINE:
+ settings.DATABASE_ENGINE = 'dummy'
+
+try:
+ backend = __import__('django.db.backends.%s.base' % settings.DATABASE_ENGINE, '', '', [''])
+except ImportError, e:
+ # The database backend wasn't found. Display a helpful error message
+ # listing all possible database backends.
+ from django.core.exceptions import ImproperlyConfigured
+ import os
+ backend_dir = os.path.join(__path__[0], 'backends')
+ available_backends = [f for f in os.listdir(backend_dir) if not f.startswith('_') and not f.startswith('.') and not f.endswith('.py') and not f.endswith('.pyc')]
+ available_backends.sort()
+ raise ImproperlyConfigured, "Could not load database backend: %s. Is your DATABASE_ENGINE setting (currently, %r) spelled correctly? Available options are: %s" % \
+ (e, settings.DATABASE_ENGINE, ", ".join(map(repr, available_backends)))
+
+get_introspection_module = lambda: __import__('django.db.backends.%s.introspection' % settings.DATABASE_ENGINE, '', '', [''])
+get_creation_module = lambda: __import__('django.db.backends.%s.creation' % settings.DATABASE_ENGINE, '', '', [''])
+runshell = lambda: __import__('django.db.backends.%s.client' % settings.DATABASE_ENGINE, '', '', ['']).runshell()
+
+connection = backend.DatabaseWrapper()
+DatabaseError = backend.DatabaseError
+
+# Register an event that closes the database connection
+# when a Django request is finished.
+dispatcher.connect(connection.close, signal=signals.request_finished)
+
+# Register an event that resets connection.queries
+# when a Django request is started.
+def reset_queries():
+ connection.queries = []
+dispatcher.connect(reset_queries, signal=signals.request_started)
+
+# Register an event that rolls back the connection
+# when a Django request has an exception.
+def _rollback_on_exception():
+ from django.db import transaction
+ transaction.rollback_unless_managed()
+dispatcher.connect(_rollback_on_exception, signal=signals.got_request_exception)
diff --git a/django/parts/__init__.py b/django/db/backends/__init__.py
similarity index 100%
rename from django/parts/__init__.py
rename to django/db/backends/__init__.py
diff --git a/django/parts/auth/__init__.py b/django/db/backends/ado_mssql/__init__.py
similarity index 100%
rename from django/parts/auth/__init__.py
rename to django/db/backends/ado_mssql/__init__.py
diff --git a/django/core/db/backends/ado_mssql.py b/django/db/backends/ado_mssql/base.py
similarity index 64%
rename from django/core/db/backends/ado_mssql.py
rename to django/db/backends/ado_mssql/base.py
index 4afe0cef70..b43be1fa7a 100644
--- a/django/core/db/backends/ado_mssql.py
+++ b/django/db/backends/ado_mssql/base.py
@@ -4,8 +4,7 @@ ADO MSSQL database backend for Django.
Requires adodbapi 2.0.1: http://adodbapi.sourceforge.net/
"""
-from django.core.db import base
-from django.core.db.dicthelpers import *
+from django.db.backends import util
import adodbapi as Database
import datetime
try:
@@ -45,10 +44,10 @@ def variantToPython(variant, adType):
Database.convertVariantToPython = variantToPython
try:
- # Only exists in python 2.4+
+ # Only exists in Python 2.4+
from threading import local
except ImportError:
- # Import copy of _thread_local.py from python 2.4
+ # Import copy of _thread_local.py from Python 2.4
from django.utils._threading_local import local
class DatabaseWrapper(local):
@@ -57,25 +56,25 @@ class DatabaseWrapper(local):
self.queries = []
def cursor(self):
- from django.conf.settings import DATABASE_USER, DATABASE_NAME, DATABASE_HOST, DATABASE_PORT, DATABASE_PASSWORD, DEBUG
+ from django.conf import settings
if self.connection is None:
- if DATABASE_NAME == '' or DATABASE_USER == '':
+ if settings.DATABASE_NAME == '' or settings.DATABASE_USER == '':
from django.core.exceptions import ImproperlyConfigured
raise ImproperlyConfigured, "You need to specify both DATABASE_NAME and DATABASE_USER in your Django settings file."
- if not DATABASE_HOST:
- DATABASE_HOST = "127.0.0.1"
+ if not settings.DATABASE_HOST:
+ settings.DATABASE_HOST = "127.0.0.1"
# TODO: Handle DATABASE_PORT.
- conn_string = "PROVIDER=SQLOLEDB;DATA SOURCE=%s;UID=%s;PWD=%s;DATABASE=%s" % (DATABASE_HOST, DATABASE_USER, DATABASE_PASSWORD, DATABASE_NAME)
+ conn_string = "PROVIDER=SQLOLEDB;DATA SOURCE=%s;UID=%s;PWD=%s;DATABASE=%s" % (settings.DATABASE_HOST, settings.DATABASE_USER, settings.DATABASE_PASSWORD, settings.DATABASE_NAME)
self.connection = Database.connect(conn_string)
cursor = self.connection.cursor()
- if DEBUG:
+ if settings.DEBUG:
return base.CursorDebugWrapper(cursor, self)
return cursor
- def commit(self):
+ def _commit(self):
return self.connection.commit()
- def rollback(self):
+ def _rollback(self):
if self.connection:
return self.connection.rollback()
@@ -84,10 +83,16 @@ class DatabaseWrapper(local):
self.connection.close()
self.connection = None
- def quote_name(self, name):
- if name.startswith('[') and name.endswith(']'):
- return name # Quoting once is enough.
- return '[%s]' % name
+supports_constraints = True
+
+def quote_name(name):
+ if name.startswith('[') and name.endswith(']'):
+ return name # Quoting once is enough.
+ return '[%s]' % name
+
+dictfetchone = util.dictfetchone
+dictfetchmany = util.dictfetchmany
+dictfetchall = util.dictfetchall
def get_last_insert_id(cursor, table_name, pk_name):
cursor.execute("SELECT %s FROM %s WHERE %s = @@IDENTITY" % (pk_name, table_name, pk_name))
@@ -116,24 +121,14 @@ def get_limit_offset_sql(limit, offset=None):
def get_random_function_sql():
return "RAND()"
-def get_table_list(cursor):
- raise NotImplementedError
-
-def get_table_description(cursor, table_name):
- raise NotImplementedError
-
-def get_relations(cursor, table_name):
- raise NotImplementedError
-
-def get_indexes(cursor, table_name):
- raise NotImplementedError
+def get_drop_foreignkey_sql():
+ return "DROP CONSTRAINT"
OPERATOR_MAPPING = {
'exact': '= %s',
'iexact': 'LIKE %s',
'contains': 'LIKE %s',
'icontains': 'LIKE %s',
- 'ne': '!= %s',
'gt': '> %s',
'gte': '>= %s',
'lt': '< %s',
@@ -143,32 +138,3 @@ OPERATOR_MAPPING = {
'istartswith': 'LIKE %s',
'iendswith': 'LIKE %s',
}
-
-DATA_TYPES = {
- 'AutoField': 'int IDENTITY (1, 1)',
- 'BooleanField': 'bit',
- 'CharField': 'varchar(%(maxlength)s)',
- 'CommaSeparatedIntegerField': 'varchar(%(maxlength)s)',
- 'DateField': 'smalldatetime',
- 'DateTimeField': 'smalldatetime',
- 'FileField': 'varchar(100)',
- 'FilePathField': 'varchar(100)',
- 'FloatField': 'numeric(%(max_digits)s, %(decimal_places)s)',
- 'ImageField': 'varchar(100)',
- 'IntegerField': 'int',
- 'IPAddressField': 'char(15)',
- 'ManyToManyField': None,
- 'NullBooleanField': 'bit',
- 'OneToOneField': 'int',
- 'PhoneNumberField': 'varchar(20)',
- 'PositiveIntegerField': 'int CONSTRAINT [CK_int_pos_%(column)s] CHECK ([%(column)s] > 0)',
- 'PositiveSmallIntegerField': 'smallint CONSTRAINT [CK_smallint_pos_%(column)s] CHECK ([%(column)s] > 0)',
- 'SlugField': 'varchar(%(maxlength)s)',
- 'SmallIntegerField': 'smallint',
- 'TextField': 'text',
- 'TimeField': 'time',
- 'URLField': 'varchar(200)',
- 'USStateField': 'varchar(2)',
-}
-
-DATA_TYPES_REVERSE = {}
diff --git a/django/db/backends/ado_mssql/client.py b/django/db/backends/ado_mssql/client.py
new file mode 100644
index 0000000000..5c197cafa4
--- /dev/null
+++ b/django/db/backends/ado_mssql/client.py
@@ -0,0 +1,2 @@
+def runshell():
+ raise NotImplementedError
diff --git a/django/db/backends/ado_mssql/creation.py b/django/db/backends/ado_mssql/creation.py
new file mode 100644
index 0000000000..4d85d27ea5
--- /dev/null
+++ b/django/db/backends/ado_mssql/creation.py
@@ -0,0 +1,26 @@
+DATA_TYPES = {
+ 'AutoField': 'int IDENTITY (1, 1)',
+ 'BooleanField': 'bit',
+ 'CharField': 'varchar(%(maxlength)s)',
+ 'CommaSeparatedIntegerField': 'varchar(%(maxlength)s)',
+ 'DateField': 'smalldatetime',
+ 'DateTimeField': 'smalldatetime',
+ 'FileField': 'varchar(100)',
+ 'FilePathField': 'varchar(100)',
+ 'FloatField': 'numeric(%(max_digits)s, %(decimal_places)s)',
+ 'ImageField': 'varchar(100)',
+ 'IntegerField': 'int',
+ 'IPAddressField': 'char(15)',
+ 'ManyToManyField': None,
+ 'NullBooleanField': 'bit',
+ 'OneToOneField': 'int',
+ 'PhoneNumberField': 'varchar(20)',
+ 'PositiveIntegerField': 'int CONSTRAINT [CK_int_pos_%(column)s] CHECK ([%(column)s] > 0)',
+ 'PositiveSmallIntegerField': 'smallint CONSTRAINT [CK_smallint_pos_%(column)s] CHECK ([%(column)s] > 0)',
+ 'SlugField': 'varchar(%(maxlength)s)',
+ 'SmallIntegerField': 'smallint',
+ 'TextField': 'text',
+ 'TimeField': 'time',
+ 'URLField': 'varchar(200)',
+ 'USStateField': 'varchar(2)',
+}
diff --git a/django/db/backends/ado_mssql/introspection.py b/django/db/backends/ado_mssql/introspection.py
new file mode 100644
index 0000000000..b125cc995f
--- /dev/null
+++ b/django/db/backends/ado_mssql/introspection.py
@@ -0,0 +1,13 @@
+def get_table_list(cursor):
+ raise NotImplementedError
+
+def get_table_description(cursor, table_name):
+ raise NotImplementedError
+
+def get_relations(cursor, table_name):
+ raise NotImplementedError
+
+def get_indexes(cursor, table_name):
+ raise NotImplementedError
+
+DATA_TYPES_REVERSE = {}
diff --git a/django/parts/media/__init__.py b/django/db/backends/dummy/__init__.py
similarity index 100%
rename from django/parts/media/__init__.py
rename to django/db/backends/dummy/__init__.py
diff --git a/django/db/backends/dummy/base.py b/django/db/backends/dummy/base.py
new file mode 100644
index 0000000000..89fec00c1d
--- /dev/null
+++ b/django/db/backends/dummy/base.py
@@ -0,0 +1,37 @@
+"""
+Dummy database backend for Django.
+
+Django uses this if the DATABASE_ENGINE setting is empty (None or empty string).
+
+Each of these API functions, except connection.close(), raises
+ImproperlyConfigured.
+"""
+
+from django.core.exceptions import ImproperlyConfigured
+
+def complain(*args, **kwargs):
+ raise ImproperlyConfigured, "You haven't set the DATABASE_ENGINE setting yet."
+
+class DatabaseError(Exception):
+ pass
+
+class DatabaseWrapper:
+ cursor = complain
+ _commit = complain
+ _rollback = complain
+
+ def close(self):
+ pass # close()
+
+supports_constraints = False
+quote_name = complain
+dictfetchone = complain
+dictfetchmany = complain
+dictfetchall = complain
+get_last_insert_id = complain
+get_date_extract_sql = complain
+get_date_trunc_sql = complain
+get_limit_offset_sql = complain
+get_random_function_sql = complain
+get_drop_foreignkey_sql = complain
+OPERATOR_MAPPING = {}
diff --git a/django/db/backends/dummy/client.py b/django/db/backends/dummy/client.py
new file mode 100644
index 0000000000..e332987aa8
--- /dev/null
+++ b/django/db/backends/dummy/client.py
@@ -0,0 +1,3 @@
+from django.db.backends.dummy.base import complain
+
+runshell = complain
diff --git a/django/db/backends/dummy/creation.py b/django/db/backends/dummy/creation.py
new file mode 100644
index 0000000000..b82c4fe568
--- /dev/null
+++ b/django/db/backends/dummy/creation.py
@@ -0,0 +1 @@
+DATA_TYPES = {}
diff --git a/django/db/backends/dummy/introspection.py b/django/db/backends/dummy/introspection.py
new file mode 100644
index 0000000000..c52a812046
--- /dev/null
+++ b/django/db/backends/dummy/introspection.py
@@ -0,0 +1,8 @@
+from django.db.backends.dummy.base import complain
+
+get_table_list = complain
+get_table_description = complain
+get_relations = complain
+get_indexes = complain
+
+DATA_TYPES_REVERSE = {}
diff --git a/django/views/auth/__init__.py b/django/db/backends/mysql/__init__.py
similarity index 100%
rename from django/views/auth/__init__.py
rename to django/db/backends/mysql/__init__.py
diff --git a/django/db/backends/mysql/base.py b/django/db/backends/mysql/base.py
new file mode 100644
index 0000000000..e2d6cbfc5e
--- /dev/null
+++ b/django/db/backends/mysql/base.py
@@ -0,0 +1,167 @@
+"""
+MySQL database backend for Django.
+
+Requires MySQLdb: http://sourceforge.net/projects/mysql-python
+"""
+
+from django.db.backends import util
+import MySQLdb as Database
+from MySQLdb.converters import conversions
+from MySQLdb.constants import FIELD_TYPE
+import types
+
+DatabaseError = Database.DatabaseError
+
+django_conversions = conversions.copy()
+django_conversions.update({
+ types.BooleanType: util.rev_typecast_boolean,
+ FIELD_TYPE.DATETIME: util.typecast_timestamp,
+ FIELD_TYPE.DATE: util.typecast_date,
+ FIELD_TYPE.TIME: util.typecast_time,
+})
+
+# This is an extra debug layer over MySQL queries, to display warnings.
+# It's only used when DEBUG=True.
+class MysqlDebugWrapper:
+ def __init__(self, cursor):
+ self.cursor = cursor
+
+ def execute(self, sql, params=()):
+ try:
+ return self.cursor.execute(sql, params)
+ except Database.Warning, w:
+ self.cursor.execute("SHOW WARNINGS")
+ raise Database.Warning, "%s: %s" % (w, self.cursor.fetchall())
+
+ def executemany(self, sql, param_list):
+ try:
+ return self.cursor.executemany(sql, param_list)
+ except Database.Warning:
+ self.cursor.execute("SHOW WARNINGS")
+ raise Database.Warning, "%s: %s" % (w, self.cursor.fetchall())
+
+ def __getattr__(self, attr):
+ if self.__dict__.has_key(attr):
+ return self.__dict__[attr]
+ else:
+ return getattr(self.cursor, attr)
+
+try:
+ # Only exists in Python 2.4+
+ from threading import local
+except ImportError:
+ # Import copy of _thread_local.py from Python 2.4
+ from django.utils._threading_local import local
+
+class DatabaseWrapper(local):
+ def __init__(self):
+ self.connection = None
+ self.queries = []
+
+ def _valid_connection(self):
+ if self.connection is not None:
+ try:
+ self.connection.ping()
+ return True
+ except DatabaseError:
+ self.connection.close()
+ self.connection = None
+ return False
+
+ def cursor(self):
+ from django.conf import settings
+ if not self._valid_connection():
+ kwargs = {
+ 'user': settings.DATABASE_USER,
+ 'db': settings.DATABASE_NAME,
+ 'passwd': settings.DATABASE_PASSWORD,
+ 'conv': django_conversions,
+ }
+ if settings.DATABASE_HOST.startswith('/'):
+ kwargs['unix_socket'] = settings.DATABASE_HOST
+ else:
+ kwargs['host'] = settings.DATABASE_HOST
+ if settings.DATABASE_PORT:
+ kwargs['port'] = int(settings.DATABASE_PORT)
+ self.connection = Database.connect(**kwargs)
+ cursor = self.connection.cursor()
+ if self.connection.get_server_info() >= '4.1':
+ cursor.execute("SET NAMES 'utf8'")
+ if settings.DEBUG:
+ return util.CursorDebugWrapper(MysqlDebugWrapper(cursor), self)
+ return cursor
+
+ def _commit(self):
+ self.connection.commit()
+
+ def _rollback(self):
+ if self.connection:
+ try:
+ self.connection.rollback()
+ except Database.NotSupportedError:
+ pass
+
+ def close(self):
+ if self.connection is not None:
+ self.connection.close()
+ self.connection = None
+
+supports_constraints = True
+
+def quote_name(name):
+ if name.startswith("`") and name.endswith("`"):
+ return name # Quoting once is enough.
+ return "`%s`" % name
+
+dictfetchone = util.dictfetchone
+dictfetchmany = util.dictfetchmany
+dictfetchall = util.dictfetchall
+
+def get_last_insert_id(cursor, table_name, pk_name):
+ return cursor.lastrowid
+
+def get_date_extract_sql(lookup_type, table_name):
+ # lookup_type is 'year', 'month', 'day'
+ # http://dev.mysql.com/doc/mysql/en/date-and-time-functions.html
+ return "EXTRACT(%s FROM %s)" % (lookup_type.upper(), table_name)
+
+def get_date_trunc_sql(lookup_type, field_name):
+ # lookup_type is 'year', 'month', 'day'
+ fields = ['year', 'month', 'day', 'hour', 'minute', 'second']
+ format = ('%%Y-', '%%m', '-%%d', ' %%H:', '%%i', ':%%s') # Use double percents to escape.
+ format_def = ('0000-', '01', '-01', ' 00:', '00', ':00')
+ try:
+ i = fields.index(lookup_type) + 1
+ except ValueError:
+ sql = field_name
+ else:
+ format_str = ''.join([f for f in format[:i]] + [f for f in format_def[i:]])
+ sql = "CAST(DATE_FORMAT(%s, '%s') AS DATETIME)" % (field_name, format_str)
+ return sql
+
+def get_limit_offset_sql(limit, offset=None):
+ sql = "LIMIT "
+ if offset and offset != 0:
+ sql += "%s," % offset
+ return sql + str(limit)
+
+def get_random_function_sql():
+ return "RAND()"
+
+def get_drop_foreignkey_sql():
+ return "DROP FOREIGN KEY"
+
+OPERATOR_MAPPING = {
+ 'exact': '= %s',
+ 'iexact': 'LIKE %s',
+ 'contains': 'LIKE BINARY %s',
+ 'icontains': 'LIKE %s',
+ 'gt': '> %s',
+ 'gte': '>= %s',
+ 'lt': '< %s',
+ 'lte': '<= %s',
+ 'startswith': 'LIKE BINARY %s',
+ 'endswith': 'LIKE BINARY %s',
+ 'istartswith': 'LIKE %s',
+ 'iendswith': 'LIKE %s',
+}
diff --git a/django/db/backends/mysql/client.py b/django/db/backends/mysql/client.py
new file mode 100644
index 0000000000..f9d6297b8e
--- /dev/null
+++ b/django/db/backends/mysql/client.py
@@ -0,0 +1,14 @@
+from django.conf import settings
+import os
+
+def runshell():
+ args = ['']
+ args += ["--user=%s" % settings.DATABASE_USER]
+ if settings.DATABASE_PASSWORD:
+ args += ["--password=%s" % settings.DATABASE_PASSWORD]
+ if settings.DATABASE_HOST:
+ args += ["--host=%s" % settings.DATABASE_HOST]
+ if settings.DATABASE_PORT:
+ args += ["--port=%s" % settings.DATABASE_PORT]
+ args += [settings.DATABASE_NAME]
+ os.execvp('mysql', args)
diff --git a/django/db/backends/mysql/creation.py b/django/db/backends/mysql/creation.py
new file mode 100644
index 0000000000..116b490124
--- /dev/null
+++ b/django/db/backends/mysql/creation.py
@@ -0,0 +1,30 @@
+# This dictionary maps Field objects to their associated MySQL column
+# types, as strings. Column-type strings can contain format strings; they'll
+# be interpolated against the values of Field.__dict__ before being output.
+# If a column type is set to None, it won't be included in the output.
+DATA_TYPES = {
+ 'AutoField': 'integer AUTO_INCREMENT',
+ 'BooleanField': 'bool',
+ 'CharField': 'varchar(%(maxlength)s)',
+ 'CommaSeparatedIntegerField': 'varchar(%(maxlength)s)',
+ 'DateField': 'date',
+ 'DateTimeField': 'datetime',
+ 'FileField': 'varchar(100)',
+ 'FilePathField': 'varchar(100)',
+ 'FloatField': 'numeric(%(max_digits)s, %(decimal_places)s)',
+ 'ImageField': 'varchar(100)',
+ 'IntegerField': 'integer',
+ 'IPAddressField': 'char(15)',
+ 'ManyToManyField': None,
+ 'NullBooleanField': 'bool',
+ 'OneToOneField': 'integer',
+ 'PhoneNumberField': 'varchar(20)',
+ 'PositiveIntegerField': 'integer UNSIGNED',
+ 'PositiveSmallIntegerField': 'smallint UNSIGNED',
+ 'SlugField': 'varchar(%(maxlength)s)',
+ 'SmallIntegerField': 'smallint',
+ 'TextField': 'longtext',
+ 'TimeField': 'time',
+ 'URLField': 'varchar(200)',
+ 'USStateField': 'varchar(2)',
+}
diff --git a/django/db/backends/mysql/introspection.py b/django/db/backends/mysql/introspection.py
new file mode 100644
index 0000000000..a2eeb6de7b
--- /dev/null
+++ b/django/db/backends/mysql/introspection.py
@@ -0,0 +1,94 @@
+from django.db import transaction
+from django.db.backends.mysql.base import quote_name
+from MySQLdb import ProgrammingError, OperationalError
+from MySQLdb.constants import FIELD_TYPE
+import re
+
+foreign_key_re = re.compile(r"\sCONSTRAINT `[^`]*` FOREIGN KEY \(`([^`]*)`\) REFERENCES `([^`]*)` \(`([^`]*)`\)")
+
+def get_table_list(cursor):
+ "Returns a list of table names in the current database."
+ cursor.execute("SHOW TABLES")
+ return [row[0] for row in cursor.fetchall()]
+
+def get_table_description(cursor, table_name):
+ "Returns a description of the table, with the DB-API cursor.description interface."
+ cursor.execute("SELECT * FROM %s LIMIT 1" % quote_name(table_name))
+ return cursor.description
+
+def _name_to_index(cursor, table_name):
+ """
+ Returns a dictionary of {field_name: field_index} for the given table.
+ Indexes are 0-based.
+ """
+ return dict([(d[0], i) for i, d in enumerate(get_table_description(cursor, table_name))])
+
+def get_relations(cursor, table_name):
+ """
+ Returns a dictionary of {field_index: (field_index_other_table, other_table)}
+ representing all relationships to the given table. Indexes are 0-based.
+ """
+ my_field_dict = _name_to_index(cursor, table_name)
+ constraints = []
+ relations = {}
+ try:
+ # This should work for MySQL 5.0.
+ cursor.execute("""
+ SELECT column_name, referenced_table_name, referenced_column_name
+ FROM information_schema.key_column_usage
+ WHERE table_name = %s
+ AND referenced_table_name IS NOT NULL
+ AND referenced_column_name IS NOT NULL""", [table_name])
+ constraints.extend(cursor.fetchall())
+ except (ProgrammingError, OperationalError):
+ # Fall back to "SHOW CREATE TABLE", for previous MySQL versions.
+ # Go through all constraints and save the equal matches.
+ cursor.execute("SHOW CREATE TABLE %s" % table_name)
+ for row in cursor.fetchall():
+ pos = 0
+ while True:
+ match = foreign_key_re.search(row[1], pos)
+ if match == None:
+ break
+ pos = match.end()
+ constraints.append(match.groups())
+
+ for my_fieldname, other_table, other_field in constraints:
+ other_field_index = _name_to_index(cursor, other_table)[other_field]
+ my_field_index = my_field_dict[my_fieldname]
+ relations[my_field_index] = (other_field_index, other_table)
+
+ return relations
+
+def get_indexes(cursor, table_name):
+ """
+ Returns a dictionary of fieldname -> infodict for the given table,
+ where each infodict is in the format:
+ {'primary_key': boolean representing whether it's the primary key,
+ 'unique': boolean representing whether it's a unique index}
+ """
+ cursor.execute("SHOW INDEX FROM %s" % quote_name(table_name))
+ indexes = {}
+ for row in cursor.fetchall():
+ indexes[row[4]] = {'primary_key': (row[2] == 'PRIMARY'), 'unique': not bool(row[1])}
+ return indexes
+
+DATA_TYPES_REVERSE = {
+ FIELD_TYPE.BLOB: 'TextField',
+ FIELD_TYPE.CHAR: 'CharField',
+ FIELD_TYPE.DECIMAL: 'FloatField',
+ FIELD_TYPE.DATE: 'DateField',
+ FIELD_TYPE.DATETIME: 'DateTimeField',
+ FIELD_TYPE.DOUBLE: 'FloatField',
+ FIELD_TYPE.FLOAT: 'FloatField',
+ FIELD_TYPE.INT24: 'IntegerField',
+ FIELD_TYPE.LONG: 'IntegerField',
+ FIELD_TYPE.LONGLONG: 'IntegerField',
+ FIELD_TYPE.SHORT: 'IntegerField',
+ FIELD_TYPE.STRING: 'TextField',
+ FIELD_TYPE.TIMESTAMP: 'DateTimeField',
+ FIELD_TYPE.TINY_BLOB: 'TextField',
+ FIELD_TYPE.MEDIUM_BLOB: 'TextField',
+ FIELD_TYPE.LONG_BLOB: 'TextField',
+ FIELD_TYPE.VAR_STRING: 'CharField',
+}
diff --git a/django/views/registration/__init__.py b/django/db/backends/postgresql/__init__.py
similarity index 100%
rename from django/views/registration/__init__.py
rename to django/db/backends/postgresql/__init__.py
diff --git a/django/db/backends/postgresql/base.py b/django/db/backends/postgresql/base.py
new file mode 100644
index 0000000000..3c807f2120
--- /dev/null
+++ b/django/db/backends/postgresql/base.py
@@ -0,0 +1,128 @@
+"""
+PostgreSQL database backend for Django.
+
+Requires psycopg 1: http://initd.org/projects/psycopg1
+"""
+
+from django.db.backends import util
+import psycopg as Database
+
+DatabaseError = Database.DatabaseError
+
+try:
+ # Only exists in Python 2.4+
+ from threading import local
+except ImportError:
+ # Import copy of _thread_local.py from Python 2.4
+ from django.utils._threading_local import local
+
+class DatabaseWrapper(local):
+ def __init__(self):
+ self.connection = None
+ self.queries = []
+
+ def cursor(self):
+ from django.conf import settings
+ if self.connection is None:
+ if settings.DATABASE_NAME == '':
+ from django.core.exceptions import ImproperlyConfigured
+ raise ImproperlyConfigured, "You need to specify DATABASE_NAME in your Django settings file."
+ conn_string = "dbname=%s" % settings.DATABASE_NAME
+ if settings.DATABASE_USER:
+ conn_string = "user=%s %s" % (settings.DATABASE_USER, conn_string)
+ if settings.DATABASE_PASSWORD:
+ conn_string += " password='%s'" % settings.DATABASE_PASSWORD
+ if settings.DATABASE_HOST:
+ conn_string += " host=%s" % settings.DATABASE_HOST
+ if settings.DATABASE_PORT:
+ conn_string += " port=%s" % settings.DATABASE_PORT
+ self.connection = Database.connect(conn_string)
+ self.connection.set_isolation_level(1) # make transactions transparent to all cursors
+ cursor = self.connection.cursor()
+ cursor.execute("SET TIME ZONE %s", [settings.TIME_ZONE])
+ if settings.DEBUG:
+ return util.CursorDebugWrapper(cursor, self)
+ return cursor
+
+ def _commit(self):
+ return self.connection.commit()
+
+ def _rollback(self):
+ if self.connection:
+ return self.connection.rollback()
+
+ def close(self):
+ if self.connection is not None:
+ self.connection.close()
+ self.connection = None
+
+supports_constraints = True
+
+def quote_name(name):
+ if name.startswith('"') and name.endswith('"'):
+ return name # Quoting once is enough.
+ return '"%s"' % name
+
+def dictfetchone(cursor):
+ "Returns a row from the cursor as a dict"
+ return cursor.dictfetchone()
+
+def dictfetchmany(cursor, number):
+ "Returns a certain number of rows from a cursor as a dict"
+ return cursor.dictfetchmany(number)
+
+def dictfetchall(cursor):
+ "Returns all rows from a cursor as a dict"
+ return cursor.dictfetchall()
+
+def get_last_insert_id(cursor, table_name, pk_name):
+ cursor.execute("SELECT CURRVAL('\"%s_%s_seq\"')" % (table_name, pk_name))
+ return cursor.fetchone()[0]
+
+def get_date_extract_sql(lookup_type, table_name):
+ # lookup_type is 'year', 'month', 'day'
+ # http://www.postgresql.org/docs/8.0/static/functions-datetime.html#FUNCTIONS-DATETIME-EXTRACT
+ return "EXTRACT('%s' FROM %s)" % (lookup_type, table_name)
+
+def get_date_trunc_sql(lookup_type, field_name):
+ # lookup_type is 'year', 'month', 'day'
+ # http://www.postgresql.org/docs/8.0/static/functions-datetime.html#FUNCTIONS-DATETIME-TRUNC
+ return "DATE_TRUNC('%s', %s)" % (lookup_type, field_name)
+
+def get_limit_offset_sql(limit, offset=None):
+ sql = "LIMIT %s" % limit
+ if offset and offset != 0:
+ sql += " OFFSET %s" % offset
+ return sql
+
+def get_random_function_sql():
+ return "RANDOM()"
+
+def get_drop_foreignkey_sql():
+ return "DROP CONSTRAINT"
+
+# Register these custom typecasts, because Django expects dates/times to be
+# in Python's native (standard-library) datetime/time format, whereas psycopg
+# use mx.DateTime by default.
+try:
+ Database.register_type(Database.new_type((1082,), "DATE", util.typecast_date))
+except AttributeError:
+ raise Exception, "You appear to be using psycopg version 2, which isn't supported yet, because it's still in beta. Use psycopg version 1 instead: http://initd.org/projects/psycopg1"
+Database.register_type(Database.new_type((1083,1266), "TIME", util.typecast_time))
+Database.register_type(Database.new_type((1114,1184), "TIMESTAMP", util.typecast_timestamp))
+Database.register_type(Database.new_type((16,), "BOOLEAN", util.typecast_boolean))
+
+OPERATOR_MAPPING = {
+ 'exact': '= %s',
+ 'iexact': 'ILIKE %s',
+ 'contains': 'LIKE %s',
+ 'icontains': 'ILIKE %s',
+ 'gt': '> %s',
+ 'gte': '>= %s',
+ 'lt': '< %s',
+ 'lte': '<= %s',
+ 'startswith': 'LIKE %s',
+ 'endswith': 'LIKE %s',
+ 'istartswith': 'ILIKE %s',
+ 'iendswith': 'ILIKE %s',
+}
diff --git a/django/db/backends/postgresql/client.py b/django/db/backends/postgresql/client.py
new file mode 100644
index 0000000000..3d0d7a0d2a
--- /dev/null
+++ b/django/db/backends/postgresql/client.py
@@ -0,0 +1,14 @@
+from django.conf import settings
+import os
+
+def runshell():
+ args = ['']
+ args += ["-U%s" % settings.DATABASE_USER]
+ if settings.DATABASE_PASSWORD:
+ args += ["-W"]
+ if settings.DATABASE_HOST:
+ args += ["-h %s" % settings.DATABASE_HOST]
+ if settings.DATABASE_PORT:
+ args += ["-p %s" % settings.DATABASE_PORT]
+ args += [settings.DATABASE_NAME]
+ os.execvp('psql', args)
diff --git a/django/db/backends/postgresql/creation.py b/django/db/backends/postgresql/creation.py
new file mode 100644
index 0000000000..65a804ec40
--- /dev/null
+++ b/django/db/backends/postgresql/creation.py
@@ -0,0 +1,30 @@
+# This dictionary maps Field objects to their associated PostgreSQL column
+# types, as strings. Column-type strings can contain format strings; they'll
+# be interpolated against the values of Field.__dict__ before being output.
+# If a column type is set to None, it won't be included in the output.
+DATA_TYPES = {
+ 'AutoField': 'serial',
+ 'BooleanField': 'boolean',
+ 'CharField': 'varchar(%(maxlength)s)',
+ 'CommaSeparatedIntegerField': 'varchar(%(maxlength)s)',
+ 'DateField': 'date',
+ 'DateTimeField': 'timestamp with time zone',
+ 'FileField': 'varchar(100)',
+ 'FilePathField': 'varchar(100)',
+ 'FloatField': 'numeric(%(max_digits)s, %(decimal_places)s)',
+ 'ImageField': 'varchar(100)',
+ 'IntegerField': 'integer',
+ 'IPAddressField': 'inet',
+ 'ManyToManyField': None,
+ 'NullBooleanField': 'boolean',
+ 'OneToOneField': 'integer',
+ 'PhoneNumberField': 'varchar(20)',
+ 'PositiveIntegerField': 'integer CHECK ("%(column)s" >= 0)',
+ 'PositiveSmallIntegerField': 'smallint CHECK ("%(column)s" >= 0)',
+ 'SlugField': 'varchar(%(maxlength)s)',
+ 'SmallIntegerField': 'smallint',
+ 'TextField': 'text',
+ 'TimeField': 'time',
+ 'URLField': 'varchar(200)',
+ 'USStateField': 'varchar(2)',
+}
diff --git a/django/db/backends/postgresql/introspection.py b/django/db/backends/postgresql/introspection.py
new file mode 100644
index 0000000000..c4f759da10
--- /dev/null
+++ b/django/db/backends/postgresql/introspection.py
@@ -0,0 +1,85 @@
+from django.db import transaction
+from django.db.backends.postgresql.base import quote_name
+
+def get_table_list(cursor):
+ "Returns a list of table names in the current database."
+ cursor.execute("""
+ SELECT c.relname
+ FROM pg_catalog.pg_class c
+ LEFT JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace
+ WHERE c.relkind IN ('r', 'v', '')
+ AND n.nspname NOT IN ('pg_catalog', 'pg_toast')
+ AND pg_catalog.pg_table_is_visible(c.oid)""")
+ return [row[0] for row in cursor.fetchall()]
+
+def get_table_description(cursor, table_name):
+ "Returns a description of the table, with the DB-API cursor.description interface."
+ cursor.execute("SELECT * FROM %s LIMIT 1" % quote_name(table_name))
+ return cursor.description
+
+def get_relations(cursor, table_name):
+ """
+ Returns a dictionary of {field_index: (field_index_other_table, other_table)}
+ representing all relationships to the given table. Indexes are 0-based.
+ """
+ cursor.execute("""
+ SELECT con.conkey, con.confkey, c2.relname
+ FROM pg_constraint con, pg_class c1, pg_class c2
+ WHERE c1.oid = con.conrelid
+ AND c2.oid = con.confrelid
+ AND c1.relname = %s
+ AND con.contype = 'f'""", [table_name])
+ relations = {}
+ for row in cursor.fetchall():
+ try:
+ # row[0] and row[1] are like "{2}", so strip the curly braces.
+ relations[int(row[0][1:-1]) - 1] = (int(row[1][1:-1]) - 1, row[2])
+ except ValueError:
+ continue
+ return relations
+
+def get_indexes(cursor, table_name):
+ """
+ Returns a dictionary of fieldname -> infodict for the given table,
+ where each infodict is in the format:
+ {'primary_key': boolean representing whether it's the primary key,
+ 'unique': boolean representing whether it's a unique index}
+ """
+ # Get the table description because we only have the column indexes, and we
+ # need the column names.
+ desc = get_table_description(cursor, table_name)
+ # This query retrieves each index on the given table.
+ cursor.execute("""
+ SELECT idx.indkey, idx.indisunique, idx.indisprimary
+ FROM pg_catalog.pg_class c, pg_catalog.pg_class c2,
+ pg_catalog.pg_index idx
+ WHERE c.oid = idx.indrelid
+ AND idx.indexrelid = c2.oid
+ AND c.relname = %s""", [table_name])
+ indexes = {}
+ for row in cursor.fetchall():
+ # row[0] (idx.indkey) is stored in the DB as an array. It comes out as
+ # a string of space-separated integers. This designates the field
+ # indexes (1-based) of the fields that have indexes on the table.
+ # Here, we skip any indexes across multiple fields.
+ if ' ' in row[0]:
+ continue
+ col_name = desc[int(row[0])-1][0]
+ indexes[col_name] = {'primary_key': row[2], 'unique': row[1]}
+ return indexes
+
+# Maps type codes to Django Field types.
+DATA_TYPES_REVERSE = {
+ 16: 'BooleanField',
+ 21: 'SmallIntegerField',
+ 23: 'IntegerField',
+ 25: 'TextField',
+ 869: 'IPAddressField',
+ 1043: 'CharField',
+ 1082: 'DateField',
+ 1083: 'TimeField',
+ 1114: 'DateTimeField',
+ 1184: 'DateTimeField',
+ 1266: 'TimeField',
+ 1700: 'FloatField',
+}
diff --git a/tests/testapp/__init__.py b/django/db/backends/sqlite3/__init__.py
similarity index 100%
rename from tests/testapp/__init__.py
rename to django/db/backends/sqlite3/__init__.py
diff --git a/django/db/backends/sqlite3/base.py b/django/db/backends/sqlite3/base.py
new file mode 100644
index 0000000000..ecaf9b0c0d
--- /dev/null
+++ b/django/db/backends/sqlite3/base.py
@@ -0,0 +1,150 @@
+"""
+SQLite3 backend for django. Requires pysqlite2 (http://pysqlite.org/).
+"""
+
+from django.db.backends import util
+from pysqlite2 import dbapi2 as Database
+
+DatabaseError = Database.DatabaseError
+
+Database.register_converter("bool", lambda s: str(s) == '1')
+Database.register_converter("time", util.typecast_time)
+Database.register_converter("date", util.typecast_date)
+Database.register_converter("datetime", util.typecast_timestamp)
+
+def utf8rowFactory(cursor, row):
+ def utf8(s):
+ if type(s) == unicode:
+ return s.encode("utf-8")
+ else:
+ return s
+ return [utf8(r) for r in row]
+
+try:
+ # Only exists in Python 2.4+
+ from threading import local
+except ImportError:
+ # Import copy of _thread_local.py from Python 2.4
+ from django.utils._threading_local import local
+
+class DatabaseWrapper(local):
+ def __init__(self):
+ self.connection = None
+ self.queries = []
+
+ def cursor(self):
+ from django.conf import settings
+ if self.connection is None:
+ self.connection = Database.connect(settings.DATABASE_NAME, detect_types=Database.PARSE_DECLTYPES)
+ # register extract and date_trun functions
+ self.connection.create_function("django_extract", 2, _sqlite_extract)
+ self.connection.create_function("django_date_trunc", 2, _sqlite_date_trunc)
+ cursor = self.connection.cursor(factory=SQLiteCursorWrapper)
+ cursor.row_factory = utf8rowFactory
+ if settings.DEBUG:
+ return util.CursorDebugWrapper(cursor, self)
+ else:
+ return cursor
+
+ def _commit(self):
+ self.connection.commit()
+
+ def _rollback(self):
+ if self.connection:
+ self.connection.rollback()
+
+ def close(self):
+ if self.connection is not None:
+ self.connection.close()
+ self.connection = None
+
+class SQLiteCursorWrapper(Database.Cursor):
+ """
+ Django uses "format" style placeholders, but pysqlite2 uses "qmark" style.
+ This fixes it -- but note that if you want to use a literal "%s" in a query,
+ you'll need to use "%%s".
+ """
+ def execute(self, query, params=()):
+ query = self.convert_query(query, len(params))
+ return Database.Cursor.execute(self, query, params)
+
+ def executemany(self, query, param_list):
+ query = self.convert_query(query, len(param_list[0]))
+ return Database.Cursor.executemany(self, query, param_list)
+
+ def convert_query(self, query, num_params):
+ return query % tuple("?" * num_params)
+
+supports_constraints = False
+
+def quote_name(name):
+ if name.startswith('"') and name.endswith('"'):
+ return name # Quoting once is enough.
+ return '"%s"' % name
+
+dictfetchone = util.dictfetchone
+dictfetchmany = util.dictfetchmany
+dictfetchall = util.dictfetchall
+
+def get_last_insert_id(cursor, table_name, pk_name):
+ return cursor.lastrowid
+
+def get_date_extract_sql(lookup_type, table_name):
+ # lookup_type is 'year', 'month', 'day'
+ # sqlite doesn't support extract, so we fake it with the user-defined
+ # function _sqlite_extract that's registered in connect(), above.
+ return 'django_extract("%s", %s)' % (lookup_type.lower(), table_name)
+
+def _sqlite_extract(lookup_type, dt):
+ try:
+ dt = util.typecast_timestamp(dt)
+ except (ValueError, TypeError):
+ return None
+ return str(getattr(dt, lookup_type))
+
+def get_date_trunc_sql(lookup_type, field_name):
+ # lookup_type is 'year', 'month', 'day'
+ # sqlite doesn't support DATE_TRUNC, so we fake it as above.
+ return 'django_date_trunc("%s", %s)' % (lookup_type.lower(), field_name)
+
+def get_limit_offset_sql(limit, offset=None):
+ sql = "LIMIT %s" % limit
+ if offset and offset != 0:
+ sql += " OFFSET %s" % offset
+ return sql
+
+def get_random_function_sql():
+ return "RANDOM()"
+
+def get_drop_foreignkey_sql():
+ return ""
+
+def _sqlite_date_trunc(lookup_type, dt):
+ try:
+ dt = util.typecast_timestamp(dt)
+ except (ValueError, TypeError):
+ return None
+ if lookup_type == 'year':
+ return "%i-01-01 00:00:00" % dt.year
+ elif lookup_type == 'month':
+ return "%i-%02i-01 00:00:00" % (dt.year, dt.month)
+ elif lookup_type == 'day':
+ return "%i-%02i-%02i 00:00:00" % (dt.year, dt.month, dt.day)
+
+# SQLite requires LIKE statements to include an ESCAPE clause if the value
+# being escaped has a percent or underscore in it.
+# See http://www.sqlite.org/lang_expr.html for an explanation.
+OPERATOR_MAPPING = {
+ 'exact': '= %s',
+ 'iexact': "LIKE %s ESCAPE '\\'",
+ 'contains': "LIKE %s ESCAPE '\\'",
+ 'icontains': "LIKE %s ESCAPE '\\'",
+ 'gt': '> %s',
+ 'gte': '>= %s',
+ 'lt': '< %s',
+ 'lte': '<= %s',
+ 'startswith': "LIKE %s ESCAPE '\\'",
+ 'endswith': "LIKE %s ESCAPE '\\'",
+ 'istartswith': "LIKE %s ESCAPE '\\'",
+ 'iendswith': "LIKE %s ESCAPE '\\'",
+}
diff --git a/django/db/backends/sqlite3/client.py b/django/db/backends/sqlite3/client.py
new file mode 100644
index 0000000000..097218341f
--- /dev/null
+++ b/django/db/backends/sqlite3/client.py
@@ -0,0 +1,6 @@
+from django.conf import settings
+import os
+
+def runshell():
+ args = ['', settings.DATABASE_NAME]
+ os.execvp('sqlite3', args)
diff --git a/django/db/backends/sqlite3/creation.py b/django/db/backends/sqlite3/creation.py
new file mode 100644
index 0000000000..e845179e64
--- /dev/null
+++ b/django/db/backends/sqlite3/creation.py
@@ -0,0 +1,29 @@
+# SQLite doesn't actually support most of these types, but it "does the right
+# thing" given more verbose field definitions, so leave them as is so that
+# schema inspection is more useful.
+DATA_TYPES = {
+ 'AutoField': 'integer',
+ 'BooleanField': 'bool',
+ 'CharField': 'varchar(%(maxlength)s)',
+ 'CommaSeparatedIntegerField': 'varchar(%(maxlength)s)',
+ 'DateField': 'date',
+ 'DateTimeField': 'datetime',
+ 'FileField': 'varchar(100)',
+ 'FilePathField': 'varchar(100)',
+ 'FloatField': 'numeric(%(max_digits)s, %(decimal_places)s)',
+ 'ImageField': 'varchar(100)',
+ 'IntegerField': 'integer',
+ 'IPAddressField': 'char(15)',
+ 'ManyToManyField': None,
+ 'NullBooleanField': 'bool',
+ 'OneToOneField': 'integer',
+ 'PhoneNumberField': 'varchar(20)',
+ 'PositiveIntegerField': 'integer unsigned',
+ 'PositiveSmallIntegerField': 'smallint unsigned',
+ 'SlugField': 'varchar(%(maxlength)s)',
+ 'SmallIntegerField': 'smallint',
+ 'TextField': 'text',
+ 'TimeField': 'time',
+ 'URLField': 'varchar(200)',
+ 'USStateField': 'varchar(2)',
+}
diff --git a/django/db/backends/sqlite3/introspection.py b/django/db/backends/sqlite3/introspection.py
new file mode 100644
index 0000000000..c5fa738249
--- /dev/null
+++ b/django/db/backends/sqlite3/introspection.py
@@ -0,0 +1,50 @@
+from django.db import transaction
+from django.db.backends.sqlite3.base import quote_name
+
+def get_table_list(cursor):
+ cursor.execute("SELECT name FROM sqlite_master WHERE type='table' ORDER BY name")
+ return [row[0] for row in cursor.fetchall()]
+
+def get_table_description(cursor, table_name):
+ cursor.execute("PRAGMA table_info(%s)" % quote_name(table_name))
+ return [(row[1], row[2], None, None) for row in cursor.fetchall()]
+
+def get_relations(cursor, table_name):
+ raise NotImplementedError
+
+def get_indexes(cursor, table_name):
+ raise NotImplementedError
+
+# Maps SQL types to Django Field types. Some of the SQL types have multiple
+# entries here because SQLite allows for anything and doesn't normalize the
+# field type; it uses whatever was given.
+BASE_DATA_TYPES_REVERSE = {
+ 'bool': 'BooleanField',
+ 'boolean': 'BooleanField',
+ 'smallint': 'SmallIntegerField',
+ 'smallinteger': 'SmallIntegerField',
+ 'int': 'IntegerField',
+ 'integer': 'IntegerField',
+ 'text': 'TextField',
+ 'char': 'CharField',
+ 'date': 'DateField',
+ 'datetime': 'DateTimeField',
+ 'time': 'TimeField',
+}
+
+# This light wrapper "fakes" a dictionary interface, because some SQLite data
+# types include variables in them -- e.g. "varchar(30)" -- and can't be matched
+# as a simple dictionary lookup.
+class FlexibleFieldLookupDict:
+ def __getitem__(self, key):
+ key = key.lower()
+ try:
+ return BASE_DATA_TYPES_REVERSE[key]
+ except KeyError:
+ import re
+ m = re.search(r'^\s*(?:var)?char\s*\(\s*(\d+)\s*\)\s*$', key)
+ if m:
+ return ('CharField', {'maxlength': int(m.group(1))})
+ raise KeyError
+
+DATA_TYPES_REVERSE = FlexibleFieldLookupDict()
diff --git a/django/db/backends/util.py b/django/db/backends/util.py
new file mode 100644
index 0000000000..b9c6f573c9
--- /dev/null
+++ b/django/db/backends/util.py
@@ -0,0 +1,114 @@
+import datetime
+from time import time
+
+class CursorDebugWrapper:
+ def __init__(self, cursor, db):
+ self.cursor = cursor
+ self.db = db
+
+ def execute(self, sql, params=()):
+ start = time()
+ try:
+ return self.cursor.execute(sql, params)
+ finally:
+ stop = time()
+ self.db.queries.append({
+ 'sql': sql % tuple(params),
+ 'time': "%.3f" % (stop - start),
+ })
+
+ def executemany(self, sql, param_list):
+ start = time()
+ try:
+ return self.cursor.executemany(sql, param_list)
+ finally:
+ stop = time()
+ self.db.queries.append({
+ 'sql': 'MANY: ' + sql + ' ' + str(tuple(param_list)),
+ 'time': "%.3f" % (stop - start),
+ })
+
+ def __getattr__(self, attr):
+ if self.__dict__.has_key(attr):
+ return self.__dict__[attr]
+ else:
+ return getattr(self.cursor, attr)
+
+###############################################
+# Converters from database (string) to Python #
+###############################################
+
+def typecast_date(s):
+ return s and datetime.date(*map(int, s.split('-'))) or None # returns None if s is null
+
+def typecast_time(s): # does NOT store time zone information
+ if not s: return None
+ hour, minutes, seconds = s.split(':')
+ if '.' in seconds: # check whether seconds have a fractional part
+ seconds, microseconds = seconds.split('.')
+ else:
+ microseconds = '0'
+ return datetime.time(int(hour), int(minutes), int(seconds), int(float('.'+microseconds) * 1000000))
+
+def typecast_timestamp(s): # does NOT store time zone information
+ # "2005-07-29 15:48:00.590358-05"
+ # "2005-07-29 09:56:00-05"
+ if not s: return None
+ if not ' ' in s: return typecast_date(s)
+ d, t = s.split()
+ # Extract timezone information, if it exists. Currently we just throw
+ # it away, but in the future we may make use of it.
+ if '-' in t:
+ t, tz = t.split('-', 1)
+ tz = '-' + tz
+ elif '+' in t:
+ t, tz = t.split('+', 1)
+ tz = '+' + tz
+ else:
+ tz = ''
+ dates = d.split('-')
+ times = t.split(':')
+ seconds = times[2]
+ if '.' in seconds: # check whether seconds have a fractional part
+ seconds, microseconds = seconds.split('.')
+ else:
+ microseconds = '0'
+ return datetime.datetime(int(dates[0]), int(dates[1]), int(dates[2]),
+ int(times[0]), int(times[1]), int(seconds), int(float('.'+microseconds) * 1000000))
+
+def typecast_boolean(s):
+ if s is None: return None
+ if not s: return False
+ return str(s)[0].lower() == 't'
+
+###############################################
+# Converters from Python to database (string) #
+###############################################
+
+def rev_typecast_boolean(obj, d):
+ return obj and '1' or '0'
+
+##################################################################################
+# Helper functions for dictfetch* for databases that don't natively support them #
+##################################################################################
+
+def _dict_helper(desc, row):
+ "Returns a dictionary for the given cursor.description and result row."
+ return dict([(desc[col[0]][0], col[1]) for col in enumerate(row)])
+
+def dictfetchone(cursor):
+ "Returns a row from the cursor as a dict"
+ row = cursor.fetchone()
+ if not row:
+ return None
+ return _dict_helper(cursor.description, row)
+
+def dictfetchmany(cursor, number):
+ "Returns a certain number of rows from a cursor as a dict"
+ desc = cursor.description
+ return [_dict_helper(desc, row) for row in cursor.fetchmany(number)]
+
+def dictfetchall(cursor):
+ "Returns all rows from a cursor as a dict"
+ desc = cursor.description
+ return [_dict_helper(desc, row) for row in cursor.fetchall()]
diff --git a/django/db/models/__init__.py b/django/db/models/__init__.py
new file mode 100644
index 0000000000..d708fa60bc
--- /dev/null
+++ b/django/db/models/__init__.py
@@ -0,0 +1,40 @@
+from django.conf import settings
+from django.core.exceptions import ObjectDoesNotExist, ImproperlyConfigured
+from django.core import validators
+from django.db import backend, connection
+from django.db.models.loading import get_apps, get_app, get_models, get_model, register_models
+from django.db.models.query import Q
+from django.db.models.manager import Manager
+from django.db.models.base import Model, AdminOptions
+from django.db.models.fields import *
+from django.db.models.fields.related import ForeignKey, OneToOneField, ManyToManyField, ManyToOneRel, ManyToManyRel, OneToOneRel, TABULAR, STACKED
+from django.db.models import signals
+from django.utils.functional import curry
+from django.utils.text import capfirst
+
+# Admin stages.
+ADD, CHANGE, BOTH = 1, 2, 3
+
+class LazyDate:
+ """
+ Use in limit_choices_to to compare the field to dates calculated at run time
+ instead of when the model is loaded. For example::
+
+ ... limit_choices_to = {'date__gt' : models.LazyDate(days=-3)} ...
+
+ which will limit the choices to dates greater than three days ago.
+ """
+ def __init__(self, **kwargs):
+ self.delta = datetime.timedelta(**kwargs)
+
+ def __str__(self):
+ return str(self.__get_value__())
+
+ def __repr__(self):
+ return "" % self.delta
+
+ def __get_value__(self):
+ return datetime.datetime.now() + self.delta
+
+ def __getattr__(self, attr):
+ return getattr(self.__get_value__(), attr)
diff --git a/django/db/models/base.py b/django/db/models/base.py
new file mode 100644
index 0000000000..2185471e2b
--- /dev/null
+++ b/django/db/models/base.py
@@ -0,0 +1,401 @@
+import django.db.models.manipulators
+import django.db.models.manager
+from django.core import validators
+from django.core.exceptions import ObjectDoesNotExist
+from django.db.models.fields import AutoField, ImageField, FieldDoesNotExist
+from django.db.models.fields.related import OneToOneRel, ManyToOneRel
+from django.db.models.related import RelatedObject
+from django.db.models.query import orderlist2sql, delete_objects
+from django.db.models.options import Options, AdminOptions
+from django.db import connection, backend, transaction
+from django.db.models import signals
+from django.db.models.loading import register_models
+from django.dispatch import dispatcher
+from django.utils.datastructures import SortedDict
+from django.utils.functional import curry
+from django.conf import settings
+import types
+import sys
+import os
+
+class ModelBase(type):
+ "Metaclass for all models"
+ def __new__(cls, name, bases, attrs):
+ # If this isn't a subclass of Model, don't do anything special.
+ if not bases or bases == (object,):
+ return type.__new__(cls, name, bases, attrs)
+
+ # Create the class.
+ new_class = type.__new__(cls, name, bases, {'__module__': attrs.pop('__module__')})
+ new_class.add_to_class('_meta', Options(attrs.pop('Meta', None)))
+ new_class.add_to_class('DoesNotExist', types.ClassType('DoesNotExist', (ObjectDoesNotExist,), {}))
+
+ # Build complete list of parents
+ for base in bases:
+ # TODO: Checking for the presence of '_meta' is hackish.
+ if '_meta' in dir(base):
+ new_class._meta.parents.append(base)
+ new_class._meta.parents.extend(base._meta.parents)
+
+ model_module = sys.modules[new_class.__module__]
+
+ if getattr(new_class._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'.
+ new_class._meta.app_label = model_module.__name__.split('.')[-2]
+
+ # Add all attributes to the class.
+ for obj_name, obj in attrs.items():
+ new_class.add_to_class(obj_name, obj)
+
+ # Add Fields inherited from parents
+ for parent in new_class._meta.parents:
+ for field in parent._meta.fields:
+ # Only add parent fields if they aren't defined for this class.
+ try:
+ new_class._meta.get_field(field.name)
+ except FieldDoesNotExist:
+ field.contribute_to_class(new_class, field.name)
+
+ new_class._prepare()
+
+ register_models(new_class._meta.app_label, new_class)
+ return new_class
+
+class Model(object):
+ __metaclass__ = ModelBase
+
+ def _get_pk_val(self):
+ return getattr(self, self._meta.pk.attname)
+
+ def __repr__(self):
+ 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 __init__(self, *args, **kwargs):
+ dispatcher.send(signal=signals.pre_init, sender=self.__class__, args=args, kwargs=kwargs)
+ for f in self._meta.fields:
+ if isinstance(f.rel, ManyToOneRel):
+ try:
+ # Assume object instance was passed in.
+ rel_obj = kwargs.pop(f.name)
+ except KeyError:
+ try:
+ # Object instance wasn't passed in -- must be an ID.
+ val = kwargs.pop(f.attname)
+ except KeyError:
+ val = f.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 f.null:
+ val = None
+ else:
+ try:
+ val = getattr(rel_obj, f.rel.get_related_field().attname)
+ except AttributeError:
+ raise TypeError, "Invalid value: %r should be a %s instance, not a %s" % (f.name, f.rel.to, type(rel_obj))
+ setattr(self, f.attname, val)
+ else:
+ val = kwargs.pop(f.attname, f.get_default())
+ setattr(self, f.attname, val)
+ if kwargs:
+ raise TypeError, "'%s' is an invalid keyword argument for this function" % kwargs.keys()[0]
+ for i, arg in enumerate(args):
+ setattr(self, self._meta.fields[i].attname, arg)
+ dispatcher.send(signal=signals.post_init, sender=self.__class__, instance=self)
+
+ def add_to_class(cls, name, value):
+ if name == 'Admin':
+ assert type(value) == types.ClassType, "%r attribute of %s model must be a class, not a %s object" % (name, cls.__name__, type(value))
+ value = AdminOptions(**dict([(k, v) for k, v in value.__dict__.items() if not k.startswith('_')]))
+ if hasattr(value, 'contribute_to_class'):
+ value.contribute_to_class(cls, name)
+ else:
+ setattr(cls, name, value)
+ add_to_class = classmethod(add_to_class)
+
+ 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)
+ setattr(opts.order_with_respect_to.rel.to, 'get_%s_order' % cls.__name__.lower(), curry(method_get_order, cls))
+ setattr(opts.order_with_respect_to.rel.to, 'set_%s_order' % cls.__name__.lower(), curry(method_set_order, cls))
+
+ # 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 = curry(get_absolute_url, opts, cls.get_absolute_url)
+
+ dispatcher.send(signal=signals.class_prepared, sender=cls)
+
+ _prepare = classmethod(_prepare)
+
+ def save(self):
+ dispatcher.send(signal=signals.pre_save, sender=self.__class__, instance=self)
+
+ non_pks = [f for f in self._meta.fields if not f.primary_key]
+ cursor = connection.cursor()
+
+ # First, try an UPDATE. If that doesn't update anything, do an INSERT.
+ pk_val = self._get_pk_val()
+ pk_set = bool(pk_val)
+ record_exists = True
+ if pk_set:
+ # Determine whether a record with the primary key already exists.
+ cursor.execute("SELECT 1 FROM %s WHERE %s=%%s LIMIT 1" % \
+ (backend.quote_name(self._meta.db_table), backend.quote_name(self._meta.pk.column)), [pk_val])
+ # If it does already exist, do an UPDATE.
+ if cursor.fetchone():
+ db_values = [f.get_db_prep_save(f.pre_save(getattr(self, f.attname), False)) for f in non_pks]
+ cursor.execute("UPDATE %s SET %s WHERE %s=%%s" % \
+ (backend.quote_name(self._meta.db_table),
+ ','.join(['%s=%%s' % backend.quote_name(f.column) for f in non_pks]),
+ backend.quote_name(self._meta.pk.attname)),
+ db_values + [pk_val])
+ else:
+ record_exists = False
+ if not pk_set or not record_exists:
+ field_names = [backend.quote_name(f.column) for f in self._meta.fields if not isinstance(f, AutoField)]
+ db_values = [f.get_db_prep_save(f.pre_save(getattr(self, f.attname), True)) for f in self._meta.fields if not isinstance(f, AutoField)]
+ # If the PK has been manually set, respect that.
+ if pk_set:
+ field_names += [f.column for f in self._meta.fields if isinstance(f, AutoField)]
+ db_values += [f.get_db_prep_save(f.pre_save(getattr(self, f.column), True)) for f in self._meta.fields if isinstance(f, AutoField)]
+ placeholders = ['%s'] * len(field_names)
+ if self._meta.order_with_respect_to:
+ field_names.append(backend.quote_name('_order'))
+ # TODO: This assumes the database supports subqueries.
+ placeholders.append('(SELECT COUNT(*) FROM %s WHERE %s = %%s)' % \
+ (backend.quote_name(self._meta.db_table), backend.quote_name(self._meta.order_with_respect_to.column)))
+ db_values.append(getattr(self, self._meta.order_with_respect_to.attname))
+ cursor.execute("INSERT INTO %s (%s) VALUES (%s)" % \
+ (backend.quote_name(self._meta.db_table), ','.join(field_names),
+ ','.join(placeholders)), db_values)
+ if self._meta.has_auto_field and not pk_set:
+ setattr(self, self._meta.pk.attname, backend.get_last_insert_id(cursor, self._meta.db_table, self._meta.pk.column))
+ transaction.commit_unless_managed()
+
+ # Run any post-save hooks.
+ dispatcher.send(signal=signals.post_save, sender=self.__class__, instance=self)
+
+ save.alters_data = True
+
+ def validate(self):
+ """
+ First coerces all fields on this instance to their proper Python types.
+ Then runs validation on every field. Returns a dictionary of
+ field_name -> error_list.
+ """
+ error_dict = {}
+ invalid_python = {}
+ for f in self._meta.fields:
+ try:
+ setattr(self, f.attname, f.to_python(getattr(self, f.attname, f.get_default())))
+ except validators.ValidationError, e:
+ error_dict[f.name] = e.messages
+ invalid_python[f.name] = 1
+ for f in self._meta.fields:
+ if f.name in invalid_python:
+ continue
+ errors = f.validate_full(getattr(self, f.attname, f.get_default()), self.__dict__)
+ if errors:
+ error_dict[f.name] = errors
+ return error_dict
+
+ def _collect_sub_objects(self, seen_objs):
+ """
+ Recursively populates seen_objs with all objects related to this object.
+ When done, seen_objs will be in the format:
+ {model_class: {pk_val: obj, pk_val: obj, ...},
+ model_class: {pk_val: obj, pk_val: obj, ...}, ...}
+ """
+ pk_val = self._get_pk_val()
+ if pk_val in seen_objs.setdefault(self.__class__, {}):
+ return
+ seen_objs.setdefault(self.__class__, {})[pk_val] = self
+
+ for related in self._meta.get_all_related_objects():
+ rel_opts_name = related.get_accessor_name()
+ if isinstance(related.field.rel, OneToOneRel):
+ try:
+ sub_obj = getattr(self, rel_opts_name)
+ except ObjectDoesNotExist:
+ pass
+ else:
+ sub_obj._collect_sub_objects(seen_objs)
+ else:
+ for sub_obj in getattr(self, rel_opts_name).all():
+ sub_obj._collect_sub_objects(seen_objs)
+
+ def delete(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)
+
+ # Find all the objects than need to be deleted
+ seen_objs = SortedDict()
+ self._collect_sub_objects(seen_objs)
+
+ # Actually delete the objects
+ delete_objects(seen_objs)
+
+ delete.alters_data = True
+
+ def _get_FIELD_display(self, field):
+ value = getattr(self, field.attname)
+ return dict(field.choices).get(value, value)
+
+ def _get_next_or_previous_by_FIELD(self, field, is_next):
+ op = is_next and '>' or '<'
+ where = '(%s %s %%s OR (%s = %%s AND %s.%s %s %%s))' % \
+ (backend.quote_name(field.column), op, backend.quote_name(field.column),
+ backend.quote_name(self._meta.db_table), backend.quote_name(self._meta.pk.column), op)
+ param = str(getattr(self, field.attname))
+ q = self.__class__._default_manager.order_by((not is_next and '-' or '') + field.name, (not is_next and '-' or '') + self._meta.pk.name)
+ q._where.append(where)
+ q._params.extend([param, param, getattr(self, self._meta.pk.attname)])
+ return q[0]
+
+ def _get_next_or_previous_in_order(self, is_next):
+ cachename = "__%s_order_cache" % is_next
+ if not hasattr(self, cachename):
+ op = is_next and '>' or '<'
+ order_field = self._meta.order_with_respect_to
+ where = ['%s %s (SELECT %s FROM %s WHERE %s=%%s)' % \
+ (backend.quote_name('_order'), op, backend.quote_name('_order'),
+ backend.quote_name(opts.db_table), backend.quote_name(opts.pk.column)),
+ '%s=%%s' % backend.quote_name(order_field.column)]
+ params = [self._get_pk_val(), getattr(self, order_field.attname)]
+ obj = self._default_manager.order_by('_order').extra(where=where, params=params)[:1].get()
+ setattr(self, cachename, obj)
+ return getattr(self, cachename)
+
+ def _get_FIELD_filename(self, field):
+ return os.path.join(settings.MEDIA_ROOT, getattr(self, field.attname))
+
+ def _get_FIELD_url(self, field):
+ if getattr(self, field.attname): # value is not blank
+ import urlparse
+ return urlparse.urljoin(settings.MEDIA_URL, getattr(self, field.attname)).replace('\\', '/')
+ return ''
+
+ def _get_FIELD_size(self, field):
+ return os.path.getsize(self.__get_FIELD_filename(field))
+
+ def _save_FIELD_file(self, field, filename, raw_contents):
+ directory = field.get_directory_name()
+ try: # Create the date-based directory if it doesn't exist.
+ os.makedirs(os.path.join(settings.MEDIA_ROOT, directory))
+ except OSError: # Directory probably already exists.
+ pass
+ filename = field.get_filename(filename)
+
+ # If the filename already exists, keep adding an underscore to the name of
+ # the file until the filename doesn't exist.
+ while os.path.exists(os.path.join(settings.MEDIA_ROOT, filename)):
+ try:
+ dot_index = filename.rindex('.')
+ except ValueError: # filename has no dot
+ filename += '_'
+ else:
+ filename = filename[:dot_index] + '_' + filename[dot_index:]
+
+ # Write the file to disk.
+ setattr(self, field.attname, filename)
+
+ full_filename = self._get_FIELD_filename(field)
+ fp = open(full_filename, 'wb')
+ fp.write(raw_contents)
+ fp.close()
+
+ # Save the width and/or height, if applicable.
+ if isinstance(field, ImageField) and (field.width_field or field.height_field):
+ from django.utils.images import get_image_dimensions
+ width, height = get_image_dimensions(full_filename)
+ if field.width_field:
+ setattr(self, field.width_field, width)
+ if field.height_field:
+ setattr(self, field.height_field, height)
+
+ # Save the object, because it has changed.
+ self.save()
+
+ _save_FIELD_file.alters_data = True
+
+ def _get_FIELD_width(self, field):
+ return self.__get_image_dimensions(field)[0]
+
+ def _get_FIELD_height(self, field):
+ return self.__get_image_dimensions(field)[1]
+
+ def _get_image_dimensions(self, field):
+ cachename = "__%s_dimensions_cache" % field.name
+ if not hasattr(self, cachename):
+ from django.utils.images import get_image_dimensions
+ filename = self.__get_FIELD_filename(field)()
+ setattr(self, cachename, get_image_dimensions(filename))
+ return getattr(self, cachename)
+
+ # Handles setting many-to-many related objects.
+ # Example: Album.set_songs()
+ def _set_related_many_to_many(self, rel_class, rel_field, id_list):
+ id_list = map(int, id_list) # normalize to integers
+ rel = rel_field.rel.to
+ m2m_table = rel_field.m2m_db_table()
+ this_id = self._get_pk_val()
+ cursor = connection.cursor()
+ cursor.execute("DELETE FROM %s WHERE %s = %%s" % \
+ (backend.quote_name(m2m_table),
+ backend.quote_name(rel_field.m2m_column_name())), [this_id])
+ sql = "INSERT INTO %s (%s, %s) VALUES (%%s, %%s)" % \
+ (backend.quote_name(m2m_table),
+ backend.quote_name(rel_field.m2m_column_name()),
+ backend.quote_name(rel_field.m2m_reverse_name()))
+ cursor.executemany(sql, [(this_id, i) for i in id_list])
+ transaction.commit_unless_managed()
+
+############################################
+# HELPER FUNCTIONS (CURRIED MODEL METHODS) #
+############################################
+
+# ORDERING METHODS #########################
+
+def method_set_order(ordered_obj, self, id_list):
+ cursor = connection.cursor()
+ # Example: "UPDATE poll_choices SET _order = %s WHERE poll_id = %s AND id = %s"
+ sql = "UPDATE %s SET %s = %%s WHERE %s = %%s AND %s = %%s" % \
+ (backend.quote_name(ordered_obj.db_table), backend.quote_name('_order'),
+ backend.quote_name(ordered_obj.order_with_respect_to.column),
+ backend.quote_name(ordered_obj.pk.column))
+ rel_val = getattr(self, ordered_obj.order_with_respect_to.rel.field_name)
+ cursor.executemany(sql, [(i, rel_val, j) for i, j in enumerate(id_list)])
+ transaction.commit_unless_managed()
+
+def method_get_order(ordered_obj, self):
+ cursor = connection.cursor()
+ # Example: "SELECT id FROM poll_choices WHERE poll_id = %s ORDER BY _order"
+ sql = "SELECT %s FROM %s WHERE %s = %%s ORDER BY %s" % \
+ (backend.quote_name(ordered_obj._meta.pk.column),
+ backend.quote_name(ordered_obj._meta.db_table),
+ backend.quote_name(ordered_obj._meta.order_with_respect_to.column),
+ backend.quote_name('_order'))
+ rel_val = getattr(self, ordered_obj._meta.order_with_respect_to.rel.field_name)
+ cursor.execute(sql, [rel_val])
+ return [r[0] for r in cursor.fetchall()]
+
+##############################################
+# HELPER FUNCTIONS (CURRIED MODEL FUNCTIONS) #
+##############################################
+
+def get_absolute_url(opts, func, self):
+ return settings.ABSOLUTE_URL_OVERRIDES.get('%s.%s' % (opts.app_label, opts.module_name), func)(self)
diff --git a/django/core/meta/fields.py b/django/db/models/fields/__init__.py
similarity index 54%
rename from django/core/meta/fields.py
rename to django/db/models/fields/__init__.py
index 8eeb9550c6..8cc17079a9 100644
--- a/django/core/meta/fields.py
+++ b/django/db/models/fields/__init__.py
@@ -1,10 +1,13 @@
+from django.db.models import signals
+from django.dispatch import dispatcher
from django.conf import settings
-from django.core import formfields, validators
+from django.core import validators
+from django import forms
from django.core.exceptions import ObjectDoesNotExist
from django.utils.functional import curry, lazy
from django.utils.text import capfirst
-from django.utils.translation import gettext_lazy, ngettext
-import datetime, os
+from django.utils.translation import gettext, gettext_lazy, ngettext
+import datetime, os, time
class NOT_PROVIDED:
pass
@@ -16,71 +19,29 @@ HORIZONTAL, VERTICAL = 1, 2
BLANK_CHOICE_DASH = [("", "---------")]
BLANK_CHOICE_NONE = [("", "None")]
-# Values for Relation.edit_inline.
-TABULAR, STACKED = 1, 2
-
-RECURSIVE_RELATIONSHIP_CONSTANT = 'self'
-
# prepares a value for use in a LIKE query
prep_for_like_query = lambda x: str(x).replace("%", "\%").replace("_", "\_")
# returns the
+ b = Blog(name='Foo', tagline='Bar')
+ b.objects # AttributeError: "Manager isn't accessible via Blog instances."
+
+(``Managers`` are accessible only via model classes, rather than from model
+instances, to enforce a separation between "table-level" operations and
+"record-level" operations.)
+
+The ``Manager`` is the main source of ``QuerySets`` for a model. It acts as a
+"root" ``QuerySet`` that describes all objects in the model's database table.
+For example, ``Blog.objects`` is the initial ``QuerySet`` that contains all
+``Blog`` objects in the database.
+
+Retrieving all objects
+----------------------
+
+The simplest way to retrieve objects from a table is to get all of them.
+To do this, use the ``all()`` method on a ``Manager``.
+
+Example::
+
+ all_entries = Entry.objects.all()
+
+The ``all()`` method returns a ``QuerySet`` of all the objects in the database.
+
+(If ``Entry.objects`` is a ``QuerySet``, why can't we just do ``Entry.objects``?
+That's because ``Entry.objects``, the root ``QuerySet``, is a special case
+that cannot be evaluated. The ``all()`` method returns a ``QuerySet`` that
+*can* be evaluated.)
+
+Filtering objects
+-----------------
+
+The root ``QuerySet`` provided by the ``Manager`` describes all objects in the
+database table. Usually, though, you'll need to select only a subset of the
+complete set of objects.
+
+To create such a subset, you refine the initial ``QuerySet``, adding filter
+conditions. The two most common ways to refine a ``QuerySet`` are:
+
+``filter(**kwargs)``
+ Returns a new ``QuerySet`` containing objects that match the given lookup
+ parameters.
+
+``exclude(**kwargs)``
+ Returns a new ``QuerySet`` containing objects that do *not* match the given
+ lookup parameters.
+
+The lookup parameters (``**kwargs`` in the above function definitions) should
+be in the format described in _`Field lookups` below.
+
+For example, to get a ``QuerySet`` of blog entries from the year 2006, use
+``filter()`` like so::
+
+ Entry.objects.filter(pub_date__year=2006)
+
+(Note we don't have to add an ``all()`` -- ``Entry.objects.all().filter(...)``.
+That would still work, but you only need ``all()`` when you want all objects
+from the root ``QuerySet``.)
+
+Chaining filters
+~~~~~~~~~~~~~~~~
+
+The result of refining a ``QuerySet`` is itself a ``QuerySet``, so it's
+possible to chain refinements together. For example::
+
+ Entry.objects.filter(
+ headline__startswith='What').exclude(
+ pub_date__gte=datetime.now()).filter(
+ pub_date__gte=datetime(2005, 1, 1))
+
+...takes the initial ``QuerySet`` of all entries in the database, adds a
+filter, then an exclusion, then another filter. The final result is a
+``QuerySet`` containing all entries with a headline that starts with "What",
+that were published between January 1, 2005, and the current day.
+
+Filtered QuerySets are unique
+-----------------------------
+
+Each time you refine a ``QuerySet``, you get a brand-new ``QuerySet`` that is
+in no way bound to the previous ``QuerySet``. Each refinement creates a
+separate and distinct ``QuerySet`` that can be stored, used and reused.
+
+Example::
+
+ q1 = Entry.objects.filter(headline__startswith="What")
+ q2 = q1.exclude(pub_date__gte=datetime.now())
+ q3 = q1.filter(pub_date__gte=datetime.now())
+
+These three ``QuerySets`` are separate. The first is a base ``QuerySet``
+containing all entries that contain a headline starting with "What". The second
+is a subset of the first, with an additional criteria that excludes records
+whose ``pub_date`` is greater than now. The third is a subset of the first,
+with an additional criteria that selects only the records whose ``pub_date`` is
+greater than now. The initial ``QuerySet`` (``q1``) is unaffected by the
+refinement process.
+
+QuerySets are lazy
+------------------
+
+``QuerySets`` are lazy -- the act of creating a ``QuerySet`` doesn't involve
+any database activity. You can stack filters together all day long, and Django
+won't actually run the query until the ``QuerySet`` is *evaluated*.
+
+When QuerySets are evaluated
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+You can evaluate a ``QuerySet`` in the following ways:
+
+ * **Iteration.** A ``QuerySet`` is iterable, and it executes its database
+ query the first time you iterate over it. For example, this will print
+ the headline of all entries in the database::
+
+ for e in Entry.objects.all():
+ print e.headline
+
+ * **Slicing.** A ``QuerySet`` can be sliced, using Python's array-slicing
+ syntax, and it executes its database query the first time you slice it.
+ Examples::
+
+ fifth_entry = Entry.objects.all()[4]
+ all_entries_but_the_first_two = Entry.objects.all()[2:]
+ every_second_entry = Entry.objects.all()[::2]
+
+ * **repr().** A ``QuerySet`` is evaluated when you call ``repr()`` on it.
+ This is for convenience in the Python interactive interpreter, so you can
+ immediately see your results when using the API interactively.
+
+ * **len().** A ``QuerySet`` is evaluated when you call ``len()`` on it.
+ This, as you might expect, returns the length of the result list.
+
+ Note: *Don't* use ``len()`` on ``QuerySet``s if all you want to do is
+ determine the number of records in the set. It's much more efficient to
+ handle a count at the database level, using SQL's ``SELECT COUNT(*)``,
+ and Django provides a ``count()`` method for precisely this reason. See
+ ``count()`` below.
+
+ * **list().** Force evaluation of a ``QuerySet`` by calling ``list()`` on
+ it. For example::
+
+ entry_list = list(Entry.objects.all())
+
+ Be warned, though, that this could have a large memory overhead, because
+ Django will load each element of the list into memory. In contrast,
+ iterating over a ``QuerySet`` will take advantage of your database to
+ load data and instantiate objects only as you need them.
+
+QuerySet methods that return new QuerySets
+------------------------------------------
+
+Django provides a range of ``QuerySet`` refinement methods that modify either
+the types of results returned by the ``QuerySet`` or the way its SQL query is
+executed.
+
+filter(**kwargs)
+~~~~~~~~~~~~~~~~
+
+Returns a new ``QuerySet`` containing objects that match the given lookup
+parameters.
+
+The lookup parameters (``**kwargs``) should be in the format described in
+_`Field lookups` below. Multiple parameters are joined via ``AND`` in the
+underlying SQL statement.
+
+exclude(**kwargs)
+~~~~~~~~~~~~~~~~~
+
+Returns a new ``QuerySet`` containing objects that do *not* match the given
+lookup parameters.
+
+The lookup parameters (``**kwargs``) should be in the format described in
+_`Field lookups` below. Multiple parameters are joined via ``AND`` in the
+underlying SQL statement, and the whole thing is enclosed in a ``NOT()``.
+
+This example excludes all entries whose ``pub_date`` is the current date/time
+AND whose ``headline`` is "Hello"::
+
+ Entry.objects.exclude(pub_date__gt=datetime.date(2005, 1, 3), headline='Hello')
+
+In SQL terms, that evaluates to::
+
+ SELECT ...
+ WHERE NOT (pub_date > '2005-1-3' AND headline = 'Hello')
+
+This example excludes all entries whose ``pub_date`` is the current date/time
+OR whose ``headline`` is "Hello"::
+
+ Entry.objects.exclude(pub_date__gt=datetime.date(2005, 1, 3)).exclude(headline='Hello')
+
+In SQL terms, that evaluates to::
+
+ SELECT ...
+ WHERE NOT pub_date > '2005-1-3'
+ AND NOT headline = 'Hello'
+
+Note the second example is more restrictive.
+
+order_by(*fields)
+~~~~~~~~~~~~~~~~~
+
+By default, results returned by a ``QuerySet`` are ordered by the ordering
+tuple given by the ``ordering`` option in the model's ``Meta``. You can
+override this on a per-``QuerySet`` basis by using the ``order_by`` method.
+
+Example::
+
+ Entry.objects.filter(pub_date__year=2005).order_by('-pub_date', 'headline')
+
+The result above will be ordered by ``pub_date`` descending, then by
+``headline`` ascending. The negative sign in front of ``"-pub_date"`` indicates
+*descending* order. Ascending order is implied. To order randomly, use ``"?"``,
+like so::
+
+ Entry.objects.order_by('?')
To order by a field in a different table, add the other table's name and a dot,
like so::
- choices.get_list(order_by=('polls.pub_date', 'choice'))
+ Entry.objects.order_by('blogs_blog.name', 'headline')
There's no way to specify whether ordering should be case sensitive. With
respect to case-sensitivity, Django will order results however your database
backend normally orders them.
+distinct()
+~~~~~~~~~~
+
+Returns a new ``QuerySet`` that uses ``SELECT DISTINCT`` in its SQL query. This
+eliminates duplicate rows from the query results.
+
+By default, a ``QuerySet`` will not eliminate duplicate rows. In practice, this
+is rarely a problem, because simple queries such as ``Blog.objects.all()``
+don't introduce the possibility of duplicate result rows.
+
+However, if your query spans multiple tables, it's possible to get duplicate
+results when a ``QuerySet`` is evaluated. That's when you'd use ``distinct()``.
+
+values(*fields)
+~~~~~~~~~~~~~~~
+
+Returns a ``ValuesQuerySet`` -- a ``QuerySet`` that evaluates to a list of
+dictionaries instead of model-instance objects.
+
+Each of those dictionaries represents an object, with the keys corresponding to
+the attribute names of model objects.
+
+This example compares the dictionaries of ``values()`` with the normal model
+objects::
+
+ # This list contains a Blog object.
+ >>> Blog.objects.filter(name__startswith='Beatles')
+ [Beatles Blog]
+
+ # This list contains a dictionary.
+ >>> Blog.objects.filter(name__startswith='Beatles').values()
+ [{'id': 1, 'name': 'Beatles Blog', 'tagline': 'All the latest Beatles news.'}]
+
+``values()`` takes optional positional arguments, ``*fields``, which specify
+field names to which the ``SELECT`` should be limited. If you specify the
+fields, each dictionary will contain only the field keys/values for the fields
+you specify. If you don't specify the fields, each dictionary will contain a
+key and value for every field in the database table.
+
+Example::
+
+ >>> Blog.objects.values()
+ [{'id': 1, 'name': 'Beatles Blog', 'tagline': 'All the latest Beatles news.'}],
+ >>> Blog.objects.values('id', 'name')
+ [{'id': 1, 'name': 'Beatles Blog'}]
+
+A ``ValuesQuerySet`` is useful when you know you're only going to need values
+from a small number of the available fields and you won't need the
+functionality of a model instance object. It's more efficient to select only
+the fields you need to use.
+
+Finally, note a ``ValuesQuerySet`` is a subclass of ``QuerySet``, so it has all
+methods of ``QuerySet``. You can call ``filter()`` on it, or ``order_by()``, or
+whatever. Yes, that means these two calls are identical::
+
+ Blog.objects.values().order_by('id')
+ Blog.objects.order_by('id').values()
+
+The people who made Django prefer to put all the SQL-affecting methods first,
+followed (optionally) by any output-affecting methods (such as ``values()``),
+but it doesn't really matter. This is your chance to really flaunt your
+individualism.
+
+dates(field, kind, order='ASC')
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Returns a ``DateQuerySet`` -- a ``QuerySet`` that evaluates to a list of
+``datetime.datetime`` objects representing all available dates of a particular
+kind within the contents of the ``QuerySet``.
+
+``field`` should be the name of a ``DateField`` or ``DateTimeField`` of your
+model.
+
+``kind`` should be either ``"year"``, ``"month"`` or ``"day"``. Each
+``datetime.datetime`` object in the result list is "truncated" to the given
+``type``.
+
+ * ``"year"`` returns a list of all distinct year values for the field.
+ * ``"month"`` returns a list of all distinct year/month values for the field.
+ * ``"day"`` returns a list of all distinct year/month/day values for the field.
+
+``order``, which defaults to ``'ASC'``, should be either ``'ASC'`` or
+``'DESC'``. This specifies how to order the results.
+
+Examples::
+
+ >>> Entry.objects.dates('pub_date', 'year')
+ [datetime.datetime(2005, 1, 1)]
+ >>> Entry.objects.dates('pub_date', 'month')
+ [datetime.datetime(2005, 2, 1), datetime.datetime(2005, 3, 1)]
+ >>> Entry.objects.dates('pub_date', 'day')
+ [datetime.datetime(2005, 2, 20), datetime.datetime(2005, 3, 20)]
+ >>> Entry.objects.dates('pub_date', 'day', order='DESC')
+ [datetime.datetime(2005, 3, 20), datetime.datetime(2005, 2, 20)]
+ >>> Entry.objects.filter(headline__contains='Lennon').dates('pub_date', 'day')
+ [datetime.datetime(2005, 3, 20)]
+
+select_related()
+~~~~~~~~~~~~~~~~
+
+Returns a ``QuerySet`` that will automatically "follow" foreign-key
+relationships, selecting that additional related-object data when it executes
+its query. This is a performance booster which results in (sometimes much)
+larger queries but means later use of foreign-key relationships won't require
+database queries.
+
+The following examples illustrate the difference between plain lookups and
+``select_related()`` lookups. Here's standard lookup::
+
+ # Hits the database.
+ e = Entry.objects.get(id=5)
+
+ # Hits the database again to get the related Blog object.
+ b = e.blog
+
+And here's ``select_related`` lookup::
+
+ # Hits the database.
+ e = Entry.objects.select_related().get(id=5)
+
+ # Doesn't hit the database, because e.blog has been prepopulated
+ # in the previous query.
+ b = e.blog
+
+``select_related()`` follows foreign keys as far as possible. If you have the
+following models::
+
+ class City(models.Model):
+ # ...
+
+ class Person(models.Model):
+ # ...
+ hometown = models.ForeignKey(City)
+
+ class Book(meta.Model):
+ # ...
+ author = models.ForeignKey(Person)
+
+...then a call to ``Book.objects.select_related().get(id=4)`` will cache the
+related ``Person`` *and* the related ``City``::
+
+ b = Book.objects.select_related().get(id=4)
+ p = b.author # Doesn't hit the database.
+ c = p.hometown # Doesn't hit the database.
+
+ sv = Book.objects.get(id=4) # No select_related() in this example.
+ p = b.author # Hits the database.
+ c = p.hometown # Hits the database.
+
+extra(select=None, where=None, params=None, tables=None)
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Sometimes, the Django query syntax by itself can't easily express a complex
+``WHERE`` clause. For these edge cases, Django provides the ``extra()``
+``QuerySet`` modifier -- a hook for injecting specific clauses into the SQL
+generated by a ``QuerySet``.
+
+By definition, these extra lookups may not be portable to different database
+engines (because you're explicitly writing SQL code) and violate the DRY
+principle, so you should avoid them if possible.
+
+Specify one or more of ``params``, ``select``, ``where`` or ``tables``. None
+of the arguments is required, but you should use at least one of them.
+
+``select``
+ The ``select`` argument lets you put extra fields in the ``SELECT`` clause.
+ It should be a dictionary mapping attribute names to SQL clauses to use to
+ calculate that attribute.
+
+ Example::
+
+ Entry.objects.extra(select={'is_recent': "pub_date > '2006-01-01'"})
+
+ As a result, each ``Entry`` object will have an extra attribute,
+ ``is_recent``, a boolean representing whether the entry's ``pub_date`` is
+ greater than Jan. 1, 2006.
+
+ Django inserts the given SQL snippet directly into the ``SELECT``
+ statement, so the resulting SQL of the above example would be::
+
+ SELECT blog_entry.*, (pub_date > '2006-01-01')
+ FROM blog_entry;
+
+
+ The next example is more advanced; it does a subquery to give each
+ resulting ``Blog`` object an ``entry_count`` attribute, an integer count
+ of associated ``Entry`` objects.
+
+ Blog.objects.extra(
+ select={
+ 'entry_count': 'SELECT COUNT(*) FROM blog_entry WHERE blog_entry.blog_id = blog_blog.id'
+ },
+ )
+
+ (In this particular case, we're exploiting the fact that the query will
+ already contain the ``blog_blog`` table in its ``FROM`` clause.)
+
+ The resulting SQL of the above example would be::
+
+ SELECT blog_blog.*, (SELECT COUNT(*) FROM blog_entry WHERE blog_entry.blog_id = blog_blog.id)
+ FROM blog_blog;
+
+ Note that the parenthesis required by most database engines around
+ subqueries are not required in Django's ``select`` clauses. Also note that
+ some database backends, such as some MySQL versions, don't support
+ subqueries.
+
+``where`` / ``tables``
+ You can define explicit SQL ``WHERE`` clauses -- perhaps to perform
+ non-explicit joins -- by using ``where``. You can manually add tables to
+ the SQL ``FROM`` clause by using ``tables``.
+
+ ``where`` and ``tables`` both take a list of strings. All ``where``
+ parameters are "AND"ed to any other search criteria.
+
+ Example::
+
+ Entry.objects.extra(where=['id IN (3, 4, 5, 20)'])
+
+ ...translates (roughly) into the following SQL::
+
+ SELECT * FROM blog_entry WHERE id IN (3, 4, 5, 20);
+
+``params``
+ The ``select`` and ``where`` parameters described above may use standard
+ Python database string placeholders -- ``'%s'`` to indicate parameters the
+ database engine should automatically quote. The ``params`` argument is a
+ list of any extra parameters to be substituted.
+
+ Example::
+
+ Entry.objects.extra(where=['headline=%s'], params=['Lennon'])
+
+ Always use ``params`` instead of embedding values directly into ``select``
+ or ``where`` because ``params`` will ensure values are quoted correctly
+ according to your particular backend. (For example, quotes will be escaped
+ correctly.)
+
+ Bad::
+
+ Entry.objects.extra(where=["headline='Lennon'"])
+
+ Good::
+
+ Entry.objects.extra(where=['headline=%s'], params=['Lennon'])
+
+QuerySet methods that do not return QuerySets
+---------------------------------------------
+
+The following ``QuerySet`` methods evaluate the ``QuerySet`` and return
+something *other than* a ``QuerySet``.
+
+These methods do not use a cache (see _`Caching and QuerySets` below). Rather,
+they query the database each time they're called.
+
+get(**kwargs)
+~~~~~~~~~~~~~
+
+Returns the object matching the given lookup parameters, which should be in
+the format described in _`Field lookups`.
+
+``get()`` raises ``AssertionError`` if more than one object was found.
+
+``get()`` raises a ``DoesNotExist`` exception if an object wasn't found for the
+given parameters. The ``DoesNotExist`` exception is an attribute of the model
+class. Example::
+
+ Entry.objects.get(id='foo') # raises Entry.DoesNotExist
+
+The ``DoesNotExist`` exception inherits from
+``django.core.exceptions.ObjectDoesNotExist``, so you can target multiple
+``DoesNotExist`` exceptions. Example::
+
+ from django.core.exceptions import ObjectDoesNotExist
+ try:
+ e = Entry.objects.get(id=3)
+ b = Blog.objects.get(id=1)
+ except ObjectDoesNotExist:
+ print "Either the entry or blog doesn't exist."
+
+count()
+~~~~~~~
+
+Returns an integer representing the number of objects in the database matching
+the ``QuerySet``. ``count()`` never raises exceptions.
+
+Example::
+
+ # Returns the total number of entries in the database.
+ Entry.objects.count()
+
+ # Returns the number of entries whose headline contains 'Lennon'
+ Entry.objects.filter(headline__contains='Lennon').count()
+
+``count()`` performs a ``SELECT COUNT(*)`` behind the scenes, so you should
+always use ``count()`` rather than loading all of the record into Python
+objects and calling ``len()`` on the result.
+
+Depending on which database you're using (e.g. PostgreSQL vs. MySQL),
+``count()`` may return a long integer instead of a normal Python integer. This
+is an underlying implementation quirk that shouldn't pose any real-world
+problems.
+
+in_bulk(id_list)
+~~~~~~~~~~~~~~~~
+
+Takes a list of primary-key values and returns a dictionary mapping each
+primary-key value to an instance of the object with the given ID.
+
+Example::
+
+ >>> Blog.objects.in_bulk([1])
+ {1: Beatles Blog}
+ >>> Blog.objects.in_bulk([1, 2])
+ {1: Beatles Blog, 2: Cheddar Talk}
+ >>> Blog.objects.in_bulk([])
+ {}
+
+If you pass ``in_bulk()`` an empty list, you'll get an empty dictionary.
+
+latest(field_name=None)
+~~~~~~~~~~~~~~~~~~~~~~~
+
+Returns the latest object in the table, by date, using the ``field_name``
+provided as the date field.
+
+This example returns the latest ``Entry`` in the table, according to the
+``pub_date`` field::
+
+ Entry.objects.latest('pub_date')
+
+If your model's ``Meta`` specifies ``get_latest_by``, you can leave off the
+``field_name`` argument to ``latest()``. Django will use the field specified in
+``get_latest_by`` by default.
+
+Like ``get()``, ``latest()`` raises ``DoesNotExist`` if an object doesn't
+exist with the given parameters.
+
+Note ``latest()`` exists purely for convenience and readability.
+
+Field lookups
+-------------
+
+Field lookups are how you specify the meat of an SQL ``WHERE`` clause. They're
+specified as keyword arguments to the ``QuerySet`` methods ``filter()``,
+``exclude()`` and ``get()``.
+
+Basic lookups keyword arguments take the form ``field__lookuptype=value``.
+(That's a double-underscore). For example::
+
+ Entry.objects.filter(pub_date__lte='2006-01-01')
+
+translates (roughly) into the following SQL::
+
+ SELECT * FROM blog_entry WHERE pub_date <= '2006-01-01';
+
+.. admonition:: How this is possible
+
+ Python has the ability to define functions that accept arbitrary name-value
+ arguments whose names and values are evaluated at runtime. For more
+ information, see `Keyword Arguments`_ in the official Python tutorial.
+
+ .. _`Keyword Arguments`: http://docs.python.org/tut/node6.html#SECTION006720000000000000000
+
+If you pass an invalid keyword argument, a lookup function will raise
+``TypeError``.
+
+The database API supports the following lookup types:
+
+exact
+~~~~~
+
+Exact match.
+
+Example::
+
+ Entry.objects.get(id__exact=14)
+
+SQL equivalent::
+
+ SELECT ... WHERE id = 14;
+
+iexact
+~~~~~~
+
+Case-insensitive exact match.
+
+Example::
+
+ Blog.objects.get(name__iexact='beatles blog')
+
+SQL equivalent::
+
+ SELECT ... WHERE name ILIKE 'beatles blog';
+
+Note this will match ``'Beatles Blog'``, ``'beatles blog'``,
+``'BeAtLes BLoG'``, etc.
+
+contains
+~~~~~~~~
+
+Case-sensitive containment test.
+
+Example::
+
+ Entry.objects.get(headline__contains='Lennon')
+
+SQL equivalent::
+
+ SELECT ... WHERE headline LIKE '%Lennon%';
+
+Note this will match the headline ``'Today Lennon honored'`` but not
+``'today lennon honored'``.
+
+SQLite doesn't support case-sensitive ``LIKE`` statements; ``contains`` acts
+like ``icontains`` for SQLite.
+
+icontains
+~~~~~~~~~
+
+Case-insensitive containment test.
+
+Example::
+
+ Entry.objects.get(headline__icontains='Lennon')
+
+SQL equivalent::
+
+ SELECT ... WHERE headline ILIKE '%Lennon%';
+
+gt
+~~
+
+Greater than.
+
+Example::
+
+ Entry.objects.filter(id__gt=4)
+
+SQL equivalent::
+
+ SELECT ... WHERE id > 4;
+
+gte
+~~~
+
+Greater than or equal to.
+
+lt
+~~
+
+Less than.
+
+lte
+~~~
+
+Less than or equal to.
+
+in
+~~
+
+In a given list.
+
+Example::
+
+ Entry.objects.filter(id__in=[1, 3, 4])
+
+SQL equivalent::
+
+ SELECT ... WHERE id IN (1, 3, 4);
+
+startswith
+~~~~~~~~~~
+
+Case-sensitive starts-with.
+
+Example::
+
+ Entry.objects.filter(headline__startswith='Will')
+
+SQL equivalent::
+
+ SELECT ... WHERE headline LIKE 'Will%';
+
+SQLite doesn't support case-sensitive ``LIKE`` statements; ``startswith`` acts
+like ``istartswith`` for SQLite.
+
+istartswith
+~~~~~~~~~~~
+
+Case-insensitive starts-with.
+
+Example::
+
+ Entry.objects.filter(headline__istartswith='will')
+
+SQL equivalent::
+
+ SELECT ... WHERE headline ILIKE 'Will%';
+
+endswith
+~~~~~~~~
+
+Case-sensitive ends-with.
+
+Example::
+
+ Entry.objects.filter(headline__endswith='cats')
+
+SQL equivalent::
+
+ SELECT ... WHERE headline LIKE '%cats';
+
+SQLite doesn't support case-sensitive ``LIKE`` statements; ``endswith`` acts
+like ``iendswith`` for SQLite.
+
+iendswith
+~~~~~~~~~
+
+Case-insensitive ends-with.
+
+Example::
+
+ Entry.objects.filter(headline__iendswith='will')
+
+SQL equivalent::
+
+ SELECT ... WHERE headline ILIKE '%will'
+
+range
+~~~~~
+
+Range test (inclusive).
+
+Example::
+
+ start_date = datetime.date(2005, 1, 1)
+ end_date = datetime.date(2005, 3, 31)
+ Entry.objects.filter(pub_date__range=(start_date, end_date))
+
+SQL equivalent::
+
+ SELECT ... WHERE pub_date BETWEEN '2005-01-01' and '2005-03-31';
+
+You can use ``range`` anywhere you can use ``BETWEEN`` in SQL -- for dates,
+numbers and even characters.
+
+year
+~~~~
+
+For date/datetime fields, exact year match. Takes a four-digit year.
+
+Example::
+
+ Entry.objects.filter(pub_date__year=2005)
+
+SQL equivalent::
+
+ SELECT ... WHERE EXTRACT('year' FROM pub_date) = '2005';
+
+(The exact SQL syntax varies for each database engine.)
+
+month
+~~~~~
+
+For date/datetime fields, exact month match. Takes an integer 1 (January)
+through 12 (December).
+
+Example::
+
+ Entry.objects.filter(pub_date__month=12)
+
+SQL equivalent::
+
+ SELECT ... WHERE EXTRACT('month' FROM pub_date) = '12';
+
+(The exact SQL syntax varies for each database engine.)
+
+day
+~~~
+
+For date/datetime fields, exact day match.
+
+Example::
+
+ Entry.objects.filter(pub_date__day=3)
+
+SQL equivalent::
+
+ SELECT ... WHERE EXTRACT('day' FROM pub_date) = '3';
+
+(The exact SQL syntax varies for each database engine.)
+
+Note this will match any record with a pub_date on the third day of the month,
+such as January 3, July 3, etc.
+
+isnull
+~~~~~~
+
+``NULL`` or ``IS NOT NULL`` match. Takes either ``True`` or ``False``, which
+correspond to ``IS NULL`` and ``IS NOT NULL``, respectively.
+
+Example::
+
+ Entry.objects.filter(pub_date__isnull=True)
+
+SQL equivalent::
+
+ SELECT ... WHERE pub_date IS NULL;
+
+Default lookups are exact
+~~~~~~~~~~~~~~~~~~~~~~~~~
+
+If you don't provide a lookup type -- that is, if your keyword argument doesn't
+contain a double underscore -- the lookup type is assumed to be ``exact``.
+
+For example, the following two statements are equivalent::
+
+ Blog.objects.get(id=14)
+ Blog.objects.get(id__exact=14)
+
+This is for convenience, because ``exact`` lookups are the common case.
+
+The pk lookup shortcut
+~~~~~~~~~~~~~~~~~~~~~~
+
+For convenience, Django provides a ``pk`` lookup type, which stands for
+"primary_key". This is shorthand for "an exact lookup on the primary-key."
+
+In the example ``Blog`` model, the primary key is the ``id`` field, so these
+two statements are equivalent::
+
+ Blog.objects.get(id__exact=14)
+ Blog.objects.get(pk=14)
+
+``pk`` lookups also work across joins. For example, these two statements are
+equivalent::
+
+ Entry.objects.filter(blog__id__exact=3)
+ Entry.objects.filter(blog__pk=3)
+
+Escaping parenthesis and underscores in LIKE statements
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+The field lookups that equate to ``LIKE`` SQL statements (``iexact``,
+``contains``, ``icontains``, ``startswith``, ``istartswith``, ``endswith``
+and ``iendswith``) will automatically escape the two special characters used in
+``LIKE`` statements -- the percent sign and the underscore. (In a ``LIKE``
+statement, the percent sign signifies a multiple-character wildcard and the
+underscore signifies a single-character wildcard.)
+
+This means things should work intuitively, so the abstraction doesn't leak.
+For example, to retrieve all the entries that contain a percent sign, just use
+the percent sign as any other character::
+
+ Entry.objects.filter(headline__contains='%')
+
+Django takes care of the quoting for you; the resulting SQL will look something
+like this::
+
+ SELECT ... WHERE headline LIKE '%\%%';
+
+Same goes for underscores. Both percentage signs and underscores are handled
+for you transparently.
+
+Caching and QuerySets
+---------------------
+
+Each ``QuerySet`` contains a cache, to minimize database access. It's important
+to understand how it works, in order to write the most efficient code.
+
+In a newly created ``QuerySet``, the cache is empty. The first time a
+``QuerySet`` is evaluated -- and, hence, a database query happens -- Django
+saves the query results in the ``QuerySet``'s cache and returns the results
+that have been explicitly requested (e.g., the next element, if the
+``QuerySet`` is being iterated over). Subsequent evaluations of the
+``QuerySet`` reuse the cached results.
+
+Keep this caching behavior in mind, because it may bite you if you don't use
+your ``QuerySet``s correctly. For example, the following will create two
+``QuerySet``s, evaluate them, and throw them away::
+
+ print [e.headline for e in Entry.objects.all()]
+ print [e.pub_date for e in Entry.objects.all()]
+
+That means the same database query will be executed twice, effectively doubling
+your database load. Also, there's a possibility the two lists may not include
+the same database records, because an ``Entry`` may have been added or deleted
+in the split second between the two requests.
+
+To avoid this problem, simply save the ``QuerySet`` and reuse it::
+
+ queryset = Poll.objects.all()
+ print [p.headline for p in queryset] # Evaluate the query set.
+ print [p.pub_date for p in queryset] # Re-use the cache from the evaluation.
+
+Comparing objects
+=================
+
+To compare two model instances, just use the standard Python comparison operator,
+the double equals sign: ``==``. Behind the scenes, that compares the primary
+key values of two models.
+
+Using the ``Entry`` example above, the following two statements are equivalent::
+
+ some_entry == other_entry
+ some_entry.id == other_entry.id
+
+If a model's primary key isn't called ``id``, no problem. Comparisons will
+always use the primary key, whatever it's called. For example, if a model's
+primary key field is called ``name``, these two statements are equivalent::
+
+ some_obj == other_obj
+ some_obj.name == other_obj.name
+
+
+
+
+========================================
+THE REST OF THIS HAS NOT YET BEEN EDITED
+========================================
+
+
+OR lookups
+==========
+
+Keyword argument queries are "AND"ed together. If you have more
+complex query requirements (for example, you need to include an ``OR``
+statement in your query), you need to use ``Q`` objects.
+
+A ``Q`` object (``django.db.models.Q``) is an object used to encapsulate a
+collection of keyword arguments. These keyword arguments are specified in
+the same way as keyword arguments to the basic lookup functions like get()
+and filter(). For example::
+
+ Q(question__startswith='What')
+
+is a ``Q`` object encapsulating a single ``LIKE`` query. ``Q`` objects can be
+combined using the ``&`` and ``|`` operators. When an operator is used on two
+``Q`` objects, it yields a new ``Q`` object. For example the statement::
+
+ Q(question__startswith='Who') | Q(question__startswith='What')
+
+... yields a single ``Q`` object that represents the "OR" of two
+"question__startswith" queries, equivalent to the SQL WHERE clause::
+
+ ... WHERE question LIKE 'Who%' OR question LIKE 'What%'
+
+You can compose statements of arbitrary complexity by combining ``Q`` objects
+with the ``&`` and ``|`` operators. Parenthetical grouping can also be used.
+
+One or more ``Q`` objects can then provided as arguments to the lookup
+functions. If multiple ``Q`` object arguments are provided to a lookup
+function, they will be "AND"ed together. For example::
+
+ Poll.objects.get(
+ Q(question__startswith='Who'),
+ Q(pub_date=date(2005, 5, 2)) | Q(pub_date=date(2005, 5, 6))
+ )
+
+... roughly translates into the SQL::
+
+ SELECT * from polls WHERE question LIKE 'Who%'
+ AND (pub_date = '2005-05-02' OR pub_date = '2005-05-06')
+
+If necessary, lookup functions can mix the use of ``Q`` objects and keyword
+arguments. All arguments provided to a lookup function (be they keyword
+argument or ``Q`` object) are "AND"ed together. However, if a ``Q`` object is
+provided, it must precede the definition of any keyword arguments. For
+example::
+
+ Poll.objects.get(
+ Q(pub_date=date(2005, 5, 2)) | Q(pub_date=date(2005, 5, 6)),
+ question__startswith='Who')
+
+... would be a valid query, equivalent to the previous example; but::
+
+ # INVALID QUERY
+ Poll.objects.get(
+ question__startswith='Who',
+ Q(pub_date=date(2005, 5, 2)) | Q(pub_date=date(2005, 5, 6)))
+
+... would not be valid.
+
+A ``Q`` objects can also be provided to the ``complex`` keyword argument. For example::
+
+ Poll.objects.get(
+ complex=Q(question__startswith='Who') &
+ (Q(pub_date=date(2005, 5, 2)) |
+ Q(pub_date=date(2005, 5, 6))
+ )
+ )
+
+See the `OR lookups examples page`_ for more examples.
+
+.. _OR lookups examples page: http://www.djangoproject.com/documentation/models/or_lookups/
+
+
Relationships (joins)
=====================
-Joins may implicitly be performed by following relationships:
-``choices.get_list(poll__slug__exact="eggs")`` fetches a list of ``Choice``
-objects where the associated ``Poll`` has a slug of ``eggs``. Multiple levels
-of joins are allowed.
+When you define a relationship in a model (i.e., a ForeignKey,
+OneToOneField, or ManyToManyField), Django uses the name of the
+relationship to add a descriptor_ on every instance of the model.
+This descriptor behaves just like a normal attribute, providing
+access to the related object or objects. For example,
+``mychoice.poll`` will return the poll object associated with a specific
+instance of ``Choice``.
-Given an instance of an object, related objects can be looked-up directly using
-convenience functions. For example, if ``p`` is a ``Poll`` instance,
-``p.get_choice_list()`` will return a list of all associated choices. Astute
-readers will note that this is the same as
-``choices.get_list(poll__id__exact=p.id)``, except clearer.
+.. _descriptor: http://users.rcn.com/python/download/Descriptor.htm
-Each type of relationship creates a set of methods on each object in the
-relationship. These methods are created in both directions, so objects that are
-"related-to" need not explicitly define reverse relationships; that happens
-automatically.
+Django also adds a descriptor for the 'other' side of the relationship -
+the link from the related model to the model that defines the relationship.
+Since the related model has no explicit reference to the source model,
+Django will automatically derive a name for this descriptor. The name that
+Django chooses depends on the type of relation that is represented. However,
+if the definition of the relation has a `related_name` parameter, Django
+will use this name in preference to deriving a name.
-One-to-one relations
---------------------
+There are two types of descriptor that can be employed: Single Object
+Descriptors and Object Set Descriptors. The following table describes
+when each descriptor type is employed. The local model is the model on
+which the relation is defined; the related model is the model referred
+to by the relation.
-Each object in a one-to-one relationship will have a ``get_relatedobjectname()``
-method. For example::
+ =============== ============= =============
+ Relation Type Local Model Related Model
+ =============== ============= =============
+ OneToOneField Single Object Single Object
- class Place(meta.Model):
- # ...
+ ForeignKey Single Object Object Set
- class Restaurant(meta.Model):
- # ...
- the_place = meta.OneToOneField(places.Place)
+ ManyToManyField Object Set Object Set
+ =============== ============= =============
-In the above example, each ``Place`` will have a ``get_restaurant()`` method,
-and each ``Restaurant`` will have a ``get_the_place()`` method.
+Single object descriptor
+------------------------
-Many-to-one relations
+If the related object is a single object, the descriptor acts
+just as if the related object were an attribute::
+
+ # Obtain the existing poll
+ old_poll = mychoice.poll
+ # Set a new poll
+ mychoice.poll = new_poll
+ # Save the change
+ mychoice.save()
+
+Whenever a change is made to a Single Object Descriptor, save()
+must be called to commit the change to the database.
+
+If no `related_name` parameter is defined, Django will use the
+lower case version of the source model name as the name for the
+related descriptor. For example, if the ``Choice`` model had
+a field::
+
+ coordinator = models.OneToOneField(User)
+
+... instances of the model ``User`` would be able to call:
+
+ old_choice = myuser.choice
+ myuser.choice = new_choice
+
+By default, relations do not allow values of None; if you attempt
+to assign None to a Single Object Descriptor, an AttributeError
+will be thrown. However, if the relation has 'null=True' set
+(i.e., the database will allow NULLs for the relation), None can
+be assigned and returned by the descriptor to represent empty
+relations.
+
+Access to Single Object Descriptors is cached. The first time
+a descriptor on an instance is accessed, the database will be
+queried, and the result stored. Subsequent attempts to access
+the descriptor on the same instance will use the cached value.
+
+Object set descriptor
---------------------
-In each many-to-one relationship, the related object will have a
-``get_relatedobject()`` method, and the related-to object will have
-``get_relatedobject()``, ``get_relatedobject_list()``, and
-``get_relatedobject_count()`` methods (the same as the module-level
-``get_object()``, ``get_list()``, and ``get_count()`` methods).
+An Object Set Descriptor acts just like the Manager - as an initial Query
+Set describing the set of objects related to an instance. As such, any
+query refining technique (filter, exclude, etc) can be used on the Object
+Set descriptor. This also means that Object Set Descriptor cannot be evaluated
+directly - the ``all()`` method must be used to produce a Query Set that
+can be evaluated.
-In the poll example above, here are the available choice methods on a ``Poll`` object ``p``::
+If no ``related_name`` parameter is defined, Django will use the lower case
+version of the source model name appended with `_set` as the name for the
+related descriptor. For example, every ``Poll`` object has a ``choice_set``
+descriptor.
- p.get_choice()
- p.get_choice_list()
- p.get_choice_count()
+The Object Set Descriptor has utility methods to add objects to the
+related object set:
-And a ``Choice`` object ``c`` has the following method::
+``add(obj1, obj2, ...)``
+ Add the specified objects to the related object set.
- c.get_poll()
+``create(\**kwargs)``
+ Create a new object, and put it in the related object set. See
+ _`Creating new objects`
-Many-to-many relations
-----------------------
+The Object Set Descriptor may also have utility methods to remove objects
+from the related object set:
-Many-to-many relations result in the same set of methods as `Many-to-one relations`_,
-except that the ``get_relatedobject_list()`` function on the related object will
-return a list of instances instead of a single instance. So, if the relationship
-between ``Poll`` and ``Choice`` was many-to-many, ``choice.get_poll_list()`` would
-return a list.
+``remove(obj1, obj2, ...)``
+ Remove the specified objects from the related object set.
-Relationships across applications
----------------------------------
+``clear()``
+ Remove all objects from the related object set.
-If a relation spans applications -- if ``Place`` was had a ManyToOne relation to
-a ``geo.City`` object, for example -- the name of the other application will be
-added to the method, i.e. ``place.get_geo_city()`` and
-``city.get_places_place_list()``.
-
-Selecting related objects
--------------------------
-
-Relations are the bread and butter of databases, so there's an option to "follow"
-all relationships and pre-fill them in a simple cache so that later calls to
-objects with a one-to-many relationship don't have to hit the database. Do this by
-passing ``select_related=True`` to a lookup. This results in (sometimes much) larger
-queries, but it means that later use of relationships is much faster.
-
-For example, using the Poll and Choice models from above, if you do the following::
-
- c = choices.get_object(id__exact=5, select_related=True)
-
-Then subsequent calls to ``c.get_poll()`` won't hit the database.
-
-Note that ``select_related`` follows foreign keys as far as possible. If you have the
-following models::
-
- class Poll(meta.Model):
- # ...
-
- class Choice(meta.Model):
- # ...
- poll = meta.ForeignKey(Poll)
-
- class SingleVote(meta.Model):
- # ...
- choice = meta.ForeignKey(Choice)
-
-then a call to ``singlevotes.get_object(id__exact=4, select_related=True)`` will
-cache the related choice *and* the related poll::
-
- >>> sv = singlevotes.get_object(id__exact=4, select_related=True)
- >>> c = sv.get_choice() # Doesn't hit the database.
- >>> p = c.get_poll() # Doesn't hit the database.
-
- >>> sv = singlevotes.get_object(id__exact=4) # Note no "select_related".
- >>> c = sv.get_choice() # Hits the database.
- >>> p = c.get_poll() # Hits the database.
-
-Limiting selected rows
-======================
-
-The ``limit``, ``offset``, and ``distinct`` keywords can be used to control
-which rows are returned. Both ``limit`` and ``offset`` should be integers which
-will be directly passed to the SQL ``LIMIT``/``OFFSET`` commands.
-
-If ``distinct`` is True, only distinct rows will be returned. This is equivalent
-to a ``SELECT DISTINCT`` SQL clause. You can use this with ``get_values()`` to
-get distinct values. For example, this returns the distinct first_names::
-
- >>> people.get_values(fields=['first_name'], distinct=True)
- [{'first_name': 'Adrian'}, {'first_name': 'Jacob'}, {'first_name': 'Simon'}]
-
-Other lookup options
-====================
-
-There are a few other ways of more directly controlling the generated SQL
-for the lookup. Note that by definition these extra lookups may not be
-portable to different database engines (because you're explicitly writing
-SQL code) and should be avoided if possible.:
-
-``params``
-----------
-
-All the extra-SQL params described below may use standard Python string
-formatting codes to indicate parameters that the database engine will
-automatically quote. The ``params`` argument can contain any extra
-parameters to be substituted.
-
-``select``
-----------
-
-The ``select`` keyword allows you to select extra fields. This should be a
-dictionary mapping attribute names to a SQL clause to use to calculate that
-attribute. For example::
-
- polls.get_list(
- select={
- 'choice_count': 'SELECT COUNT(*) FROM choices WHERE poll_id = polls.id'
- }
- )
-
-Each of the resulting ``Poll`` objects will have an extra attribute, ``choice_count``,
-an integer count of associated ``Choice`` objects. Note that the parenthesis required by
-most database engines around sub-selects are not required in Django's ``select``
-clauses.
-
-``where`` / ``tables``
-----------------------
-
-If you need to explicitly pass extra ``WHERE`` clauses -- perhaps to perform
-non-explicit joins -- use the ``where`` keyword. If you need to
-join other tables into your query, you can pass their names to ``tables``.
-
-``where`` and ``tables`` both take a list of strings. All ``where`` parameters
-are "AND"ed to any other search criteria.
+These two removal methods will not exist on ForeignKeys where ``Null=False``
+(such as in the Poll example). This is to prevent database inconsistency - if
+the related field cannot be set to None, then an object cannot be removed
+from one relation without adding it to another.
+The members of a related object set can be assigned from any iterable object.
For example::
- polls.get_list(question__startswith='Who', where=['id IN (3, 4, 5, 20)'])
+ mypoll.choice_set = [choice1, choice2]
-...translates (roughly) into the following SQL:
+If the ``clear()`` method is available, any pre-existing objects will be removed
+from the Object Set before all objects in the iterable (in this case, a list)
+are added to the choice set. If the ``clear()`` method is not available, all
+objects in the iterable will be added without removing any existing elements.
- SELECT * FROM polls_polls WHERE question LIKE 'Who%' AND id IN (3, 4, 5, 20);
+Each of these operations on the Object Set Descriptor has immediate effect
+on the database - every add, create and remove is immediately and
+automatically saved to the database.
-Changing objects
-================
+Relationships and queries
+=========================
-Once you've retrieved an object from the database using any of the above
-options, changing it is extremely easy. Make changes directly to the
-objects fields, then call the object's ``save()`` method::
+When composing a ``filter`` or ``exclude`` refinement, it may be necessary to
+include conditions that span relationships. Relations can be followed as deep
+as required - just add descriptor names, separated by double underscores, to
+describe the full path to the query attribute. The query::
- >>> p = polls.get_object(id__exact=15)
- >>> p.slug = "new_slug"
- >>> p.pub_date = datetime.datetime.now()
- >>> p.save()
+ Foo.objects.filter(name1__name2__name3__attribute__lookup=value)
-Creating new objects
-====================
+... is interpreted as 'get every Foo that has a name1 that has a name2 that
+has a name3 that has an attribute with lookup matching value'. In the Poll
+example::
-Creating new objects (i.e. ``INSERT``) is done by creating new instances
-of objects then calling save() on them::
+ Choice.objects.filter(poll__slug__startswith="eggs")
- >>> p = polls.Poll(slug="eggs",
- ... question="How do you like your eggs?",
- ... pub_date=datetime.datetime.now(),
- ... expire_date=some_future_date)
- >>> p.save()
+... describes the set of choices for which the related poll has a slug
+attribute that starts with "eggs". Django automatically composes the joins
+and conditions required for the SQL query.
-Calling ``save()`` on an object with a primary key whose value is ``None``
-signifies to Django that the object is new and should be inserted.
+Creating new related objects
+============================
-Related objects (e.g. ``Choices``) are created using convenience functions::
+Related objects are created using the ``create()`` convenience function on
+the descriptor Manager for relation::
- >>> p.add_choice(choice="Over easy", votes=0)
- >>> p.add_choice(choice="Scrambled", votes=0)
- >>> p.add_choice(choice="Fertilized", votes=0)
- >>> p.add_choice(choice="Poached", votes=0)
- >>> p.get_choice_count()
+ >>> p.choice_set.create(choice="Over easy", votes=0)
+ >>> p.choice_set.create(choice="Scrambled", votes=0)
+ >>> p.choice_set.create(choice="Fertilized", votes=0)
+ >>> p.choice_set.create(choice="Poached", votes=0)
+ >>> p.choice_set.count()
4
-Each of those ``add_choice`` methods is equivalent to (but much simpler than)::
+Each of those ``create()`` methods is equivalent to (but much simpler than)::
- >>> c = polls.Choice(poll_id=p.id, choice="Over easy", votes=0)
+ >>> c = Choice(poll_id=p.id, choice="Over easy", votes=0)
>>> c.save()
-Note that when using the `add_foo()`` methods, you do not give any value
+Note that when using the `create()`` method, you do not give any value
for the ``id`` field, nor do you give a value for the field that stores
the relation (``poll_id`` in this case).
-The ``add_FOO()`` method always returns the newly created object.
+The ``create()`` method always returns the newly created object.
Deleting objects
================
@@ -514,31 +1371,27 @@ deletes the object and has no return value. Example::
>>> c.delete()
-Comparing objects
-=================
+Objects can also be deleted in bulk. Every Query Set has a ``delete()`` method
+that will delete all members of the query set. For example::
-To compare two model objects, just use the standard Python comparison operator,
-the double equals sign: ``==``. Behind the scenes, that compares the primary
-key values of two models.
+ >>> Polls.objects.filter(pub_date__year=2005).delete()
-Using the ``Poll`` example above, the following two statements are equivalent::
+would bulk delete all Polls with a year of 2005. Note that ``delete()`` is the
+only Query Set method that is not exposed on the Manager itself.
- some_poll == other_poll
- some_poll.id == other_poll.id
+This is a safety mechanism to prevent you from accidentally requesting
+``Polls.objects.delete()``, and deleting *all* the polls.
-If a model's primary key isn't called ID, no problem. Comparisons will always
-use the primary key, whatever it's called. For example, if a model's primary
-key field is called ``name``, these two statements are equivalent::
+If you *actually* want to delete all the objects, then you have to explicitly
+request a complete query set::
- some_obj == other_obj
- some_obj.name == other_obj.name
+ Polls.objects.all().delete()
Extra instance methods
======================
-In addition to ``save()``, ``delete()`` and all of the ``add_*`` and ``get_*``
-related-object methods, a model object might get any or all of the following
-methods:
+In addition to ``save()``, ``delete()``, a model object might get any or all
+of the following methods:
get_FOO_display()
-----------------
@@ -572,10 +1425,10 @@ For every ``DateField`` and ``DateTimeField`` that does not have ``null=True``,
the object will have ``get_next_by_FOO()`` and ``get_previous_by_FOO()``
methods, where ``FOO`` is the name of the field. This returns the next and
previous object with respect to the date field, raising the appropriate
-``*DoesNotExist`` exception when appropriate.
+``DoesNotExist`` exception when appropriate.
Both methods accept optional keyword arguments, which should be in the format
-described in "Field lookups" above.
+described in _`Field lookups` above.
Note that in the case of identical date values, these methods will use the ID
as a fallback check. This guarantees that no records are skipped or duplicated.
@@ -604,14 +1457,14 @@ returns an empty string.
get_FOO_size()
--------------
-For every ``FileField``, the object will have a ``get_FOO_size()`` method,
+For every ``FileField``, the object will have a ``get_FOO_filename()`` method,
where ``FOO`` is the name of the field. This returns the size of the file, in
bytes. (Behind the scenes, it uses ``os.path.getsize``.)
save_FOO_file(filename, raw_contents)
-------------------------------------
-For every ``FileField``, the object will have a ``save_FOO_file()`` method,
+For every ``FileField``, the object will have a ``get_FOO_filename()`` method,
where ``FOO`` is the name of the field. This saves the given file to the
filesystem, using the given filename. If a file with the given filename already
exists, Django adds an underscore to the end of the filename (but before the
@@ -623,48 +1476,3 @@ get_FOO_height() and get_FOO_width()
For every ``ImageField``, the object will have ``get_FOO_height()`` and
``get_FOO_width()`` methods, where ``FOO`` is the name of the field. This
returns the height (or width) of the image, as an integer, in pixels.
-
-Extra module functions
-======================
-
-In addition to every function described in "Basic lookup functions" above, a
-model module might get any or all of the following methods:
-
-get_FOO_list(kind, \**kwargs)
------------------------------
-
-For every ``DateField`` and ``DateTimeField``, the model module will have a
-``get_FOO_list()`` function, where ``FOO`` is the name of the field. This
-returns a list of ``datetime.datetime`` objects representing all available
-dates of the given scope, as defined by the ``kind`` argument. ``kind`` should
-be either ``"year"``, ``"month"`` or ``"day"``. Each ``datetime.datetime``
-object in the result list is "truncated" to the given ``type``.
-
- * ``"year"`` returns a list of all distinct year values for the field.
- * ``"month"`` returns a list of all distinct year/month values for the field.
- * ``"day"`` returns a list of all distinct year/month/day values for the field.
-
-Additional, optional keyword arguments, in the format described in
-"Field lookups" above, are also accepted.
-
-Here's an example, using the ``Poll`` model defined above::
-
- >>> from datetime import datetime
- >>> p1 = polls.Poll(slug='whatsup', question="What's up?",
- ... pub_date=datetime(2005, 2, 20), expire_date=datetime(2005, 3, 20))
- >>> p1.save()
- >>> p2 = polls.Poll(slug='name', question="What's your name?",
- ... pub_date=datetime(2005, 3, 20), expire_date=datetime(2005, 4, 20))
- >>> p2.save()
- >>> polls.get_pub_date_list('year')
- [datetime.datetime(2005, 1, 1)]
- >>> polls.get_pub_date_list('month')
- [datetime.datetime(2005, 2, 1), datetime.datetime(2005, 3, 1)]
- >>> polls.get_pub_date_list('day')
- [datetime.datetime(2005, 2, 20), datetime.datetime(2005, 3, 20)]
- >>> polls.get_pub_date_list('day', question__contains='name')
- [datetime.datetime(2005, 3, 20)]
-
-``get_FOO_list()`` also accepts an optional keyword argument ``order``, which
-should be either ``"ASC"`` or ``"DESC"``. This specifies how to order the
-results. Default is ``"ASC"``.
diff --git a/docs/design_philosophies.txt b/docs/design_philosophies.txt
index 89a537da17..17ed3ad6da 100644
--- a/docs/design_philosophies.txt
+++ b/docs/design_philosophies.txt
@@ -20,6 +20,9 @@ For example, the template system knows nothing about Web requests, the database
layer knows nothing about data display and the view system doesn't care which
template system a programmer uses.
+Although Django comes with a full stack for convenience, the pieces of the
+stack are independent of another wherever possible.
+
.. _`loose coupling and tight cohesion`: http://c2.com/cgi/wiki?CouplingAndCohesion
Less code
@@ -49,7 +52,10 @@ Explicit is better than implicit
--------------------------------
This, a `core Python principle`_, means Django shouldn't do too much "magic."
-Magic shouldn't happen unless there's a really good reason for it.
+Magic shouldn't happen unless there's a really good reason for it. Magic is
+worth using only if it creates a huge convenience unattainable in other ways,
+and it isn't implemented in a way that confuses developers who are trying to
+learn how to use the feature.
.. _`core Python principle`: http://www.python.org/doc/Humor.html#zen
@@ -96,8 +102,9 @@ optimize statements internally.
This is why developers need to call ``save()`` explicitly, rather than the
framework saving things behind the scenes silently.
-This is also why the ``select_related`` argument exists. It's an optional
-performance booster for the common case of selecting "every related object."
+This is also why the ``select_related()`` ``QuerySet`` method exists. It's an
+optional performance booster for the common case of selecting "every related
+object."
Terse, powerful syntax
----------------------
@@ -144,6 +151,8 @@ design pretty URLs than ugly ones.
File extensions in Web-page URLs should be avoided.
+Vignette-style commas in URLs deserve severe punishment.
+
Definitive URLs
---------------
@@ -186,6 +195,13 @@ The template system shouldn't be designed so that it only outputs HTML. It
should be equally good at generating other text-based formats, or just plain
text.
+XML should not be used for template languages
+---------------------------------------------
+
+Using an XML engine to parse templates introduces a whole new world of human
+error in editing templates -- and incurs an unacceptable level of overhead in
+template processing.
+
Assume designer competence
--------------------------
diff --git a/docs/django-admin.txt b/docs/django-admin.txt
index 45cc2363dc..b314366fee 100644
--- a/docs/django-admin.txt
+++ b/docs/django-admin.txt
@@ -1,15 +1,10 @@
-===========================
-The django-admin.py utility
-===========================
+=============================
+django-admin.py and manage.py
+=============================
``django-admin.py`` is Django's command-line utility for administrative tasks.
This document outlines all it can do.
-The ``django-admin.py`` script should be on your system path if you installed
-Django via its ``setup.py`` utility. If it's not on your path, you can find it in
-``site-packages/django/bin`` within your Python installation. Consider
-symlinking to it from some place on your path, such as ``/usr/local/bin``.
-
In addition, ``manage.py`` is automatically created in each Django project.
``manage.py`` is a thin wrapper around ``django-admin.py`` that takes care of
two things for you before delegating to ``django-admin.py``:
@@ -19,6 +14,11 @@ two things for you before delegating to ``django-admin.py``:
* It sets the ``DJANGO_SETTINGS_MODULE`` environment variable so that it
points to your project's ``settings.py`` file.
+The ``django-admin.py`` script should be on your system path if you installed
+Django via its ``setup.py`` utility. If it's not on your path, you can find it in
+``site-packages/django/bin`` within your Python installation. Consider
+symlinking to it from some place on your path, such as ``/usr/local/bin``.
+
Generally, when working on a single Django project, it's easier to use
``manage.py``. Use ``django-admin.py`` with ``DJANGO_SETTINGS_MODULE``, or the
``--settings`` command line option, if you need to switch between multiple
@@ -38,18 +38,17 @@ document.
Run ``django-admin.py --help`` to display a help message that includes a terse
list of all available actions and options.
-Most actions take a list of "modelmodule"s. A "modelmodule," in this case, is
-the name of a file containing Django models. For example, if you have a model
-module called ``myproject/apps/polls/pollmodels.py``, the "modelmodule" in this
-case would be ``"pollmodels"``.
+Most actions take a list of ``appname``s. An ``appname`` is the basename of the
+package containing your models. For example, if your ``INSTALLED_APPS``
+contains the string ``'mysite.blog'``, the ``appname`` is ``blog``.
Available actions
=================
-adminindex [modelmodule modelmodule ...]
-----------------------------------------
+adminindex [appname appname ...]
+--------------------------------
-Prints the admin-index template snippet for the given model module(s).
+Prints the admin-index template snippet for the given appnames.
Use admin-index template snippets if you want to customize the look and feel of
your admin's index page. See `Tutorial 2`_ for more information.
@@ -64,29 +63,41 @@ backend. See the `cache documentation`_ for more information.
.. _cache documentation: http://www.djangoproject.com/documentation/cache/
-createsuperuser
----------------
+dbshell
+-------
-Creates a superuser account interactively. It asks you for a username, e-mail
-address and password.
+Runs the command-line client for the database engine specified in your
+``DATABASE_ENGINE`` setting, with the connection parameters specified in your
+``DATABASE_USER``, ``DATABASE_PASSWORD``, etc., settings.
-You can specify ``username email password`` on the command line, for convenient
-use in shell scripts. Example::
+ * For PostgreSQL, this runs the ``psql`` command-line client.
+ * For MySQL, this runs the ``mysql`` command-line client.
+ * For SQLite, this runs the ``sqlite3`` command-line client.
- django-admin.py createsuperuser john john@example.com mypassword
+This command assumes the programs are on your ``PATH`` so that a simple call to
+the program name (``psql``, ``mysql``, ``sqlite3``) will find the program in
+the right place. There's no way to specify the location of the program
+manually.
-init
-----
+diffsettings
+------------
-Initializes the database with the tables and data Django needs by default.
-Specifically, these are the database tables from the ``auth`` and ``core``
-models.
+Displays differences between the current settings file and Django's default
+settings.
-inspectdb [dbname]
-------------------
+Settings that don't appear in the defaults are followed by ``"###"``. For
+example, the default settings don't define ``ROOT_URLCONF``, so
+``ROOT_URLCONF`` is followed by ``"###"`` in the output of ``diffsettings``.
-Introspects the database tables in the given database and outputs a Django
-model module to standard output.
+Note that Django's default settings live in ``django/conf/global_settings.py``,
+if you're ever curious to see the full list of defaults.
+
+inspectdb
+---------
+
+Introspects the database tables in the database pointed-to by the
+``DATABASE_NAME`` setting and outputs a Django model module (a ``models.py``
+file) to standard output.
Use this if you have a legacy database with which you'd like to use Django.
The script will inspect the database and create a model for each table within
@@ -101,12 +112,12 @@ output:
``'This field type is a guess.'`` next to the field in the generated
model.
- * **New in Django development version.** If the database column name is a
- Python reserved word (such as ``'pass'``, ``'class'`` or ``'for'``),
- ``inspectdb`` will append ``'_field'`` to the attribute name. For
- example, if a table has a column ``'for'``, the generated model will have
- a field ``'for_field'``, with the ``db_column`` attribute set to
- ``'for'``. ``inspectdb`` will insert the Python comment
+ * If the database column name is a Python reserved word (such as
+ ``'pass'``, ``'class'`` or ``'for'``), ``inspectdb`` will append
+ ``'_field'`` to the attribute name. For example, if a table has a column
+ ``'for'``, the generated model will have a field ``'for_field'``, with
+ the ``db_column`` attribute set to ``'for'``. ``inspectdb`` will insert
+ the Python comment
``'Field renamed because it was a Python reserved word.'`` next to the
field.
@@ -115,25 +126,16 @@ you run it, you'll want to look over the generated models yourself to make
customizations. In particular, you'll need to rearrange models' order, so that
models that refer to other models are ordered properly.
-If you're using Django 0.90 or 0.91, you'll need to add ``primary_key=True`` to
-one field in each model. In the Django development version, primary keys are
-automatically introspected for PostgreSQL and MySQL, and Django puts in the
-``primary_key=True`` where needed.
+Primary keys are automatically introspected for PostgreSQL and MySQL, in which
+case Django puts in the ``primary_key=True`` where needed.
``inspectdb`` works with PostgreSQL, MySQL and SQLite. Foreign-key detection
-only works in PostgreSQL.
+only works in PostgreSQL and with certain types of MySQL tables.
-install [modelmodule modelmodule ...]
--------------------------------------
+install [appname appname ...]
+-----------------------------
-Executes the equivalent of ``sqlall`` for the given model module(s).
-
-installperms [modelmodule modelmodule ...]
-------------------------------------------
-
-Installs any admin permissions for the given model module(s) that aren't
-already installed in the database. Outputs a message telling how many
-permissions were added, if any.
+Executes the equivalent of ``sqlall`` for the given appnames.
runserver [optional port number, or ipaddr:port]
------------------------------------------------
@@ -144,7 +146,7 @@ IP address and port number explicitly.
If you run this script as a user with normal privileges (recommended), you
might not have access to start a port on a low port number. Low port numbers
-are reserved for superusers (root).
+are reserved for the superuser (root).
DO NOT USE THIS SERVER IN A PRODUCTION SETTING.
@@ -153,7 +155,7 @@ needed. You don't need to restart the server for code changes to take effect.
When you start the server, and each time you change Python code while the
server is running, the server will validate all of your installed models. (See
-the "validate" option below.) If the validator finds errors, it will print
+the ``validate`` command below.) If the validator finds errors, it will print
them to standard output, but it won't stop the server.
You can run as many servers as you want, as long as they're on separate ports.
@@ -180,49 +182,49 @@ shell
Starts the Python interactive interpreter.
-**New in Django development version:** Uses IPython_, if it's installed. If you
-have IPython installed and want to force use of the "plain" Python interpreter,
-use the ``--plain`` option, like so::
+Django will use IPython_, if it's installed. If you have IPython installed and
+want to force use of the "plain" Python interpreter, use the ``--plain``
+option, like so::
django-admin.py shell --plain
.. _IPython: http://ipython.scipy.org/
-sql [modelmodule modelmodule ...]
----------------------------------
+sql [appname appname ...]
+-------------------------
-Prints the CREATE TABLE SQL statements for the given model module(s).
+Prints the CREATE TABLE SQL statements for the given appnames.
-sqlall [modelmodule modelmodule ...]
-------------------------------------
+sqlall [appname appname ...]
+----------------------------
-Prints the CREATE TABLE and initial-data SQL statements for the given model module(s).
+Prints the CREATE TABLE and initial-data SQL statements for the given appnames.
-sqlclear [modelmodule modelmodule ...]
+sqlclear [appname appname ...]
--------------------------------------
-Prints the DROP TABLE SQL statements for the given model module(s).
+Prints the DROP TABLE SQL statements for the given appnames.
-sqlindexes [modelmodule modelmodule ...]
+sqlindexes [appname appname ...]
----------------------------------------
-Prints the CREATE INDEX SQL statements for the given model module(s).
+Prints the CREATE INDEX SQL statements for the given appnames.
-sqlinitialdata [modelmodule modelmodule ...]
+sqlinitialdata [appname appname ...]
--------------------------------------------
-Prints the initial INSERT SQL statements for the given model module(s).
+Prints the initial INSERT SQL statements for the given appnames.
-sqlreset [modelmodule modelmodule ...]
+sqlreset [appname appname ...]
--------------------------------------
-Prints the DROP TABLE SQL, then the CREATE TABLE SQL, for the given model module(s).
+Prints the DROP TABLE SQL, then the CREATE TABLE SQL, for the given appnames.
-sqlsequencereset [modelmodule modelmodule ...]
+sqlsequencereset [appname appname ...]
----------------------------------------------
Prints the SQL statements for resetting PostgreSQL sequences for the given
-model module(s).
+appnames.
See http://simon.incutio.com/archive/2004/04/21/postgres for more information.
@@ -252,11 +254,12 @@ Available options
Example usage::
- django-admin.py init --settings=myproject.settings
+ django-admin.py syncdb --settings=mysite.settings
Explicitly specifies the settings module to use. The settings module should be
-in Python path syntax, e.g. "myproject.settings". If this isn't provided,
-``django-admin.py`` will use the DJANGO_SETTINGS_MODULE environment variable.
+in Python package syntax, e.g. ``mysite.settings``. If this isn't provided,
+``django-admin.py`` will use the ``DJANGO_SETTINGS_MODULE`` environment
+variable.
Note that this option is unnecessary in ``manage.py``, because it takes care of
setting ``DJANGO_SETTINGS_MODULE`` for you.
@@ -266,7 +269,7 @@ setting ``DJANGO_SETTINGS_MODULE`` for you.
Example usage::
- django-admin.py init --pythonpath='/home/djangoprojects/myproject'
+ django-admin.py syncdb --pythonpath='/home/djangoprojects/myproject'
Adds the given filesystem path to the Python `import search path`_. If this
isn't provided, ``django-admin.py`` will use the ``PYTHONPATH`` environment
@@ -282,3 +285,27 @@ setting the Python path for you.
Displays a help message that includes a terse list of all available actions and
options.
+
+Extra niceties
+==============
+
+Syntax coloring
+---------------
+
+The ``django-admin.py`` / ``manage.py`` commands that output SQL to standard
+output will use pretty color-coded output if your terminal supports
+ANSI-colored output. It won't use the color codes if you're piping the
+command's output to another program.
+
+Bash completion
+---------------
+
+If you use the Bash shell, consider installing the Django bash completion
+script, which lives in ``extras/django_bash_completion`` in the Django
+distribution. It enables tab-completion of ``django-admin.py`` and
+``manage.py`` commands, so you can, for instance...
+
+ * Type ``django-admin.py``.
+ * Press [TAB] to see all available options.
+ * Type ``sql``, then [TAB], to see all available options whose names start
+ with ``sql``.
diff --git a/docs/email.txt b/docs/email.txt
index ae55a51a14..b38b855cb3 100644
--- a/docs/email.txt
+++ b/docs/email.txt
@@ -20,11 +20,11 @@ In two lines::
send_mail('Subject here', 'Here is the message.', 'from@example.com',
['to@example.com'], fail_silently=False)
-The send_mail function
-======================
+send_mail()
+===========
The simplest way to send e-mail is using the function
-``django.core.mail.send_mail``. Here's its definition::
+``django.core.mail.send_mail()``. Here's its definition::
send_mail(subject, message, from_email, recipient_list,
fail_silently=False, auth_user=EMAIL_HOST_USER,
@@ -42,20 +42,19 @@ are required.
* ``fail_silently``: A boolean. If it's ``False``, ``send_mail`` will raise
an ``smtplib.SMTPException``. See the `smtplib docs`_ for a list of
possible exceptions, all of which are subclasses of ``SMTPException``.
- * ``auth_user``: **New in Django development version.** The optional
- username to use to authenticate to the SMTP server. If this isn't
- provided, Django will use the value of the ``EMAIL_HOST_USER`` setting.
- * ``auth_password``: **New in Django development version.** The optional
- password to use to authenticate to the SMTP server. If this isn't
- provided, Django will use the value of the ``EMAIL_HOST_PASSWORD``
- setting.
+ * ``auth_user``: The optional username to use to authenticate to the SMTP
+ server. If this isn't provided, Django will use the value of the
+ ``EMAIL_HOST_USER`` setting.
+ * ``auth_password``: The optional password to use to authenticate to the
+ SMTP server. If this isn't provided, Django will use the value of the
+ ``EMAIL_HOST_PASSWORD`` setting.
.. _smtplib docs: http://www.python.org/doc/current/lib/module-smtplib.html
-The send_mass_mail function
-===========================
+send_mass_mail()
+================
-``django.core.mail.send_mass_mail`` is intended to handle mass e-mailing.
+``django.core.mail.send_mass_mail()`` is intended to handle mass e-mailing.
Here's the definition::
send_mass_mail(datatuple, fail_silently=False,
@@ -66,25 +65,24 @@ Here's the definition::
(subject, message, from_email, recipient_list)
``fail_silently``, ``auth_user`` and ``auth_password`` have the same functions
-as in ``send_mail()``. Note that ``auth_user`` and ``auth_password`` are only
-available in the Django development version.
+as in ``send_mail()``.
Each separate element of ``datatuple`` results in a separate e-mail message.
As in ``send_mail()``, recipients in the same ``recipient_list`` will all see
the other addresses in the e-mail messages's "To:" field.
-send_mass_mail vs. send_mail
-----------------------------
+send_mass_mail() vs. send_mail()
+--------------------------------
The main difference between ``send_mass_mail()`` and ``send_mail()`` is that
``send_mail()`` opens a connection to the mail server each time it's executed,
while ``send_mass_mail()`` uses a single connection for all of its messages.
This makes ``send_mass_mail()`` slightly more efficient.
-The mail_admins function
-========================
+mail_admins()
+=============
-``django.core.mail.mail_admins`` is a shortcut for sending an e-mail to the
+``django.core.mail.mail_admins()`` is a shortcut for sending an e-mail to the
site admins, as defined in the `ADMINS setting`_. Here's the definition::
mail_admins(subject, message, fail_silently=False)
@@ -94,14 +92,16 @@ site admins, as defined in the `ADMINS setting`_. Here's the definition::
The "From:" header of the e-mail will be the value of the `SERVER_EMAIL setting`_.
+This method exists for convenience and readability.
+
.. _ADMINS setting: http://www.djangoproject.com/documentation/settings/#admins
.. _EMAIL_SUBJECT_PREFIX setting: http://www.djangoproject.com/documentation/settings/#email-subject-prefix
.. _SERVER_EMAIL setting: http://www.djangoproject.com/documentation/settings/#server-email
-The mail_managers function
-==========================
+mail_managers() function
+========================
-``django.core.mail.mail_managers`` is just like ``mail_admins``, except it
+``django.core.mail.mail_managers()`` is just like ``mail_admins()``, except it
sends an e-mail to the site managers, as defined in the `MANAGERS setting`_.
Here's the definition::
diff --git a/docs/faq.txt b/docs/faq.txt
index 977a3644fe..e8bf09a7d3 100644
--- a/docs/faq.txt
+++ b/docs/faq.txt
@@ -8,14 +8,20 @@ General questions
Why does this project exist?
----------------------------
-Django grew from a very practical need: in our fast-paced newsroom, we often
-have only a matter of hours to take a complicated Web application from
-concept to public launch. Django was designed to not only allow us to
-build Web applications quickly, but to allow us to build them right.
+Django grew from a very practical need: World Online, a newspaper Web
+operation, is responsible for building intensive Web applications on journalism
+deadlines. In the fast-paced newsroom, World Online often has only a matter of
+hours to take a complicated Web application from concept to public launch.
+
+At the same time, the World Online Web developers have consistently been
+perfectionists when it comes to following best practices of Web development.
+
+Thus, Django was designed not only to allow fast Web development, but
+*best-practice* Web development.
Django would not be possible without a whole host of open-source projects --
-`Apache`_, `Python`_, and `PostgreSQL`_ to name a few -- and we're thrilled to be
-able to give something back to the open-source community.
+`Apache`_, `Python`_, and `PostgreSQL`_ to name a few -- and we're thrilled to
+be able to give something back to the open-source community.
.. _Apache: http://httpd.apache.org/
.. _Python: http://www.python.org/
@@ -29,25 +35,28 @@ to early 1950s. To this day, he's considered one of the best guitarists of all t
Listen to his music. You'll like it.
-According to Wikipedia_, "Django is pronounced **zhane**-go (with a long 'a')."
+Django is pronounced **JANG**-oh. Rhymes with FANG-oh.
.. _Django Reinhardt: http://en.wikipedia.org/wiki/Django_Reinhardt
-.. _Wikipedia: http://en.wikipedia.org/wiki/Django_Reinhardt
Is Django stable?
-----------------
-We've been using Django for almost two years. Sites built on Django have
-weathered traffic spikes of over one million hits an hour, and at least
-one Slashdotting. Yes, it's quite stable.
+Yes. World Online has been using Django for more than two years. Sites built on
+Django have weathered traffic spikes of over one million hits an hour and at
+least one Slashdotting. Yes, it's quite stable.
Does Django scale?
------------------
Yes. Compared to development time, hardware is cheap, and so Django is
designed to take advantage of as much hardware as you can throw at it.
-Django ships with clean separation of the database layer from the
-application layer and a simple-yet-powerful `cache framework`_.
+
+Django uses a "shared-nothing" architecture, which means you can add hardware
+at any level -- database servers, caching servers or Web/application servers.
+
+The framework cleanly separates components such as its database layer and
+application layer. And it ships with a simple-yet-powerful `cache framework`_.
.. _`cache framework`: http://www.djangoproject.com/documentation/cache/
@@ -60,32 +69,34 @@ Lawrence, Kansas, USA.
`Adrian Holovaty`_
Adrian is a Web developer with a background in journalism. He was lead
developer at World Online for 2.5 years, during which time Django was
- developed and implemented on World Online's sites. Now he's editor of
- editorial innovations at washingtonpost.com, and he continues to oversee
- Django development. He likes playing guitar (Django Reinhardt style) and
- hacking on side projects such as `chicagocrime.org`_. He lives in Chicago.
+ developed and implemented on World Online's sites. Now he works for
+ washingtonpost.com building rich, database-backed information sites, and
+ continues to oversee Django development. He likes playing guitar (Django
+ Reinhardt style) and hacking on side projects such as `chicagocrime.org`_.
+ He lives in Chicago.
On IRC, Adrian goes by ``adrian_h``.
+`Jacob Kaplan-Moss`_
+ Jacob is a whipper-snapper from California who spends equal time coding and
+ cooking. He's lead developer at World Online and actively hacks on various
+ cool side projects. He's contributed to the Python-ObjC bindings and was
+ the first guy to figure out how to write Tivo apps in Python. Lately he's
+ been messing with Python on the PSP. He lives in Lawrence, Kansas.
+
+ On IRC, Jacob goes by ``jacobkm``.
+
`Simon Willison`_
Simon is a well-respected Web developer from England. He had a one-year
internship at World Online, during which time he and Adrian developed
- Django from scratch. He's enthusiastic, he's passionate about best
- practices in Web development, and he really likes squirrels. Probably to a
- fault. He went back to university to finish his degree and is poised to
- continue doing big, exciting things on the Web. He lives in England.
+ Django from scratch. The most enthusiastic Brit you'll ever meet, he's
+ passionate about best practices in Web development and has maintained a
+ well-read Web-development blog for years at http://simon.incutio.com.
+ He works for Yahoo UK, where he managed to score the title "Hacker Liason."
+ He lives in London.
On IRC, Simon goes by ``SimonW``.
-`Jacob Kaplan-Moss`_
- Jacob is a whipper-snapper from California who spends equal time coding and
- cooking. He does Web development for World Online and actively hacks on
- various cool side projects. He's contributed to the Python-ObjC bindings and
- was the first guy to figure out how to write Tivo apps in Python. Lately
- he's been messing with Python on the PSP. He lives in Lawrence, Kansas.
-
- On IRC, Jacob goes by ``jacobkm``.
-
`Wilson Miner`_
Wilson's design-fu makes us all look like rock stars. When not sneaking
into apartment complex swimming pools, he's the Commercial Development
@@ -106,18 +117,17 @@ Lawrence, Kansas, USA.
Which sites use Django?
-----------------------
-The Django wiki features a `list of Django-powered sites`_. Feel free to add
-your Django-powered site to the list.
+The Django wiki features a consistently growing `list of Django-powered sites`_.
+Feel free to add your Django-powered site to the list.
.. _list of Django-powered sites: http://code.djangoproject.com/wiki/DjangoPoweredSites
Django appears to be a MVC framework, but you call the Controller the "view", and the View the "template". How come you don't use the standard names?
-----------------------------------------------------------------------------------------------------------------------------------------------------
-That's because Django isn't strictly a MVC framework. We don't really believe in
-any capital-M Methodologies; we do what "feels" right. If you squint the right
-way, you can call Django's ORM the "Model", the view functions the "View", and
-the dynamically-generated API the "Controller" -- but not really.
+That's because Django isn't strictly a MVC framework. If you squint the right
+way, you can call Django's database layer the "Model", the view functions the
+"View", and the URL dispatcher the "Controller" -- but not really.
In fact, you might say that Django is a "MTV" framework -- that is, Model,
Template, and View make much more sense to us.
@@ -183,9 +193,13 @@ begin maintaining backwards compatibility. This should happen in a couple of
months or so, although it's entirely possible that it could happen earlier.
That translates into summer 2006.
+The merging of Django's `magic-removal branch`_ went a long way toward Django
+1.0.
+
Of course, you should note that `quite a few production sites`_ use Django in
its current status. Don't let the lack of a 1.0 turn you off.
+.. _magic-removal branch: http://code.djangoproject.com/wiki/RemovingTheMagic
.. _quite a few production sites: http://code.djangoproject.com/wiki/DjangoPoweredSites
How can I download the Django documentation to read it offline?
@@ -225,12 +239,12 @@ How do I get started?
How do I fix the "install a later version of setuptools" error?
---------------------------------------------------------------
-Just run the ``ex_setup.py`` script in the Django distribution.
+Just run the ``ez_setup.py`` script in the Django distribution.
What are Django's prerequisites?
--------------------------------
-Django requires Python_ 2.3 or later.
+Django requires Python_ 2.3 or later. No other Python libraries are required.
For a development environment -- if you just want to experiment with Django --
you don't need to have a separate Web server installed; Django comes with its
@@ -256,7 +270,7 @@ Not if you just want to play around and develop things on your local computer.
Django comes with its own Web server, and things should Just Work.
For production use, though, we recommend mod_python. The Django developers have
-been running it on mod_python for about two years, and it's quite stable.
+been running it on mod_python for more than two years, and it's quite stable.
However, if you don't want to use mod_python, you can use a different server,
as long as that server has WSGI_ hooks. See the `server arrangements wiki page`_.
@@ -325,6 +339,14 @@ but we recognize that choosing a template language runs close to religion.
There's nothing about Django that requires using the template language, so
if you're attached to ZPT, Cheetah, or whatever, feel free to use those.
+Do I have to use your model/database layer?
+-------------------------------------------
+
+Nope. Just like the template system, the model/database layer is decoupled from
+the rest of the framework. The one exception is: If you use a different
+database library, you won't get to use Django's automatically-generated admin
+site. That app is coupled to the Django database layer.
+
How do I use image and file fields?
-----------------------------------
@@ -367,9 +389,8 @@ input.
If you do care about deleting data, you'll have to execute the ``ALTER TABLE``
statements manually in your database. That's the way we've always done it,
because dealing with data is a very sensitive operation that we've wanted to
-avoid automating. That said, there's some work being done to add a
-``django-admin.py updatedb`` command, which would output the necessary
-``ALTER TABLE`` statements, if any.
+avoid automating. That said, there's some work being done to add partially
+automated database-upgrade functionality.
Do Django models support multiple-column primary keys?
------------------------------------------------------
@@ -392,19 +413,19 @@ How can I see the raw SQL queries Django is running?
Make sure your Django ``DEBUG`` setting is set to ``True``. Then, just do
this::
- >>> from django.core.db import db
- >>> db.queries
+ >>> from django.db import connection
+ >>> connection.queries
[{'sql': 'SELECT polls_polls.id,polls_polls.question,polls_polls.pub_date FROM polls_polls',
'time': '0.002'}]
-``db.queries`` is only available if ``DEBUG`` is ``True``. It's a list of
-dictionaries in order of query execution. Each dictionary has the following::
+``connection.queries`` is only available if ``DEBUG`` is ``True``. It's a list
+of dictionaries in order of query execution. Each dictionary has the following::
``sql`` -- The raw SQL statement
``time`` -- How long the statement took to execute, in seconds.
-``db.queries`` includes all SQL statements -- INSERTs, UPDATES, SELECTs, etc.
-Each time your app hits the database, the query will be recorded.
+``connection.queries`` includes all SQL statements -- INSERTs, UPDATES,
+SELECTs, etc. Each time your app hits the database, the query will be recorded.
Can I use Django with a pre-existing database?
----------------------------------------------
@@ -465,8 +486,8 @@ documentation.
My "list_filter" contains a ManyToManyField, but the filter doesn't display.
----------------------------------------------------------------------------
-Django won't bother displaying the filter for a ManyToManyField if there are
-fewer than two related objects.
+Django won't bother displaying the filter for a ``ManyToManyField`` if there
+are fewer than two related objects.
For example, if your ``list_filter`` includes ``sites``, and there's only one
site in your database, it won't display a "Site" filter. In that case,
@@ -477,9 +498,9 @@ How can I customize the functionality of the admin interface?
You've got several options. If you want to piggyback on top of an add/change
form that Django automatically generates, you can attach arbitrary JavaScript
-modules to the page via the model's ``admin.js`` parameter. That parameter is
-a list of URLs, as strings, pointing to JavaScript modules that will be
-included within the admin form via a disallowed ![]()
tags', 'script img')
@@ -133,19 +133,15 @@ u'\\xcb'
>>> striptags('some html with disallowed ![]()
tags')
'some html with alert("You smell") disallowed tags'
->>> dictsort([{'age': 23, 'name': 'Barbara-Ann'},\
- {'age': 63, 'name': 'Ra Ra Rasputin'},\
- {'name': 'Jonny B Goode', 'age': 18}], 'age')
-[{'age': 18, 'name': 'Jonny B Goode'},\
- {'age': 23, 'name': 'Barbara-Ann'},\
- {'age': 63, 'name': 'Ra Ra Rasputin'}]
+>>> dictsort([{'age': 23, 'name': 'Barbara-Ann'},
+... {'age': 63, 'name': 'Ra Ra Rasputin'},
+... {'name': 'Jonny B Goode', 'age': 18}], 'age')
+[{'age': 18, 'name': 'Jonny B Goode'}, {'age': 23, 'name': 'Barbara-Ann'}, {'age': 63, 'name': 'Ra Ra Rasputin'}]
->>> dictsortreversed([{'age': 23, 'name': 'Barbara-Ann'},\
- {'age': 63, 'name': 'Ra Ra Rasputin'},\
- {'name': 'Jonny B Goode', 'age': 18}], 'age')
-[{'age': 63, 'name': 'Ra Ra Rasputin'},\
- {'age': 23, 'name': 'Barbara-Ann'},\
- {'age': 18, 'name': 'Jonny B Goode'}]
+>>> dictsortreversed([{'age': 23, 'name': 'Barbara-Ann'},
+... {'age': 63, 'name': 'Ra Ra Rasputin'},
+... {'name': 'Jonny B Goode', 'age': 18}], 'age')
+[{'age': 63, 'name': 'Ra Ra Rasputin'}, {'age': 23, 'name': 'Barbara-Ann'}, {'age': 18, 'name': 'Jonny B Goode'}]
>>> first([0,1,2])
0
@@ -196,13 +192,13 @@ False
'aceg'
>>> unordered_list(['item 1', []])
-'\\titem 1 '
+'\titem 1 '
>>> unordered_list(['item 1', [['item 1.1', []]]])
-'\\titem 1\\n\\t '
+'\titem 1\n\t '
>>> unordered_list(['item 1', [['item 1.1', []], ['item 1.2', []]]])
-'\\titem 1\\n\\t '
+'\titem 1\n\t '
>>> add('1', '2')
3
@@ -228,6 +224,8 @@ False
# real testing of date() is in dateformat.py
>>> date(datetime.datetime(2005, 12, 29), "d F Y")
'29 December 2005'
+>>> date(datetime.datetime(2005, 12, 29), r'jS o\f F')
+'29th of December'
# real testing of time() is done in dateformat.py
>>> time(datetime.time(13), "h")
@@ -322,7 +320,7 @@ False
"""
-from django.core.template.defaultfilters import *
+from django.template.defaultfilters import *
import datetime
if __name__ == '__main__':
diff --git a/tests/othertests/httpwrappers.py b/tests/othertests/httpwrappers.py
index e3aa7c4e42..385c3048d9 100644
--- a/tests/othertests/httpwrappers.py
+++ b/tests/othertests/httpwrappers.py
@@ -351,7 +351,7 @@ AttributeError: This QueryDict instance is immutable
"""
-from django.utils.httpwrappers import QueryDict
+from django.http import QueryDict
if __name__ == "__main__":
import doctest
diff --git a/tests/othertests/markup.py b/tests/othertests/markup.py
index 5a8f9e1cdc..3fa5a3a883 100644
--- a/tests/othertests/markup.py
+++ b/tests/othertests/markup.py
@@ -1,6 +1,6 @@
# Quick tests for the markup templatetags (django.contrib.markup)
-from django.core.template import Template, Context, add_to_builtins
+from django.template import Template, Context, add_to_builtins
add_to_builtins('django.contrib.markup.templatetags.markup')
diff --git a/tests/othertests/templates.py b/tests/othertests/templates.py
index bfb62c7bd1..6d8487c67a 100644
--- a/tests/othertests/templates.py
+++ b/tests/othertests/templates.py
@@ -1,11 +1,10 @@
from django.conf import settings
-# Turn TEMPLATE_DEBUG off, because tests assume that.
-settings.TEMPLATE_DEBUG = False
-from django.core import template
-from django.core.template import loader
+from django import template
+from django.template import loader
from django.utils.translation import activate, deactivate, install
+from datetime import datetime
import traceback
#################################
@@ -32,6 +31,12 @@ template.libraries['django.templatetags.testtags'] = register
# Helper objects for template tests #
#####################################
+class SomeException(Exception):
+ silent_variable_failure = True
+
+class SomeOtherException(Exception):
+ pass
+
class SomeClass:
def __init__(self):
self.otherclass = OtherClass()
@@ -42,6 +47,12 @@ class SomeClass:
def method2(self, o):
return o
+ def method3(self):
+ raise SomeException
+
+ def method4(self):
+ raise SomeOtherException
+
class OtherClass:
def method(self):
return "OtherClass.method"
@@ -133,12 +144,20 @@ TEMPLATE_TESTS = {
'basic-syntax31': (r'{{ var|default_if_none:var2 }}', {"var": None, "var2": "happy"}, 'happy'),
# Default argument testing
- 'basic-syntax32' : (r'{{ var|yesno:"yup,nup,mup" }} {{ var|yesno }}', {"var": True}, 'yup yes'),
+ 'basic-syntax32': (r'{{ var|yesno:"yup,nup,mup" }} {{ var|yesno }}', {"var": True}, 'yup yes'),
- ### IF TAG ################################################################
- 'if-tag01': ("{% if foo %}yes{% else %}no{% endif %}", {"foo": True}, "yes"),
- 'if-tag02': ("{% if foo %}yes{% else %}no{% endif %}", {"foo": False}, "no"),
- 'if-tag03': ("{% if foo %}yes{% else %}no{% endif %}", {}, "no"),
+ # Fail silently for methods that raise an exception with a "silent_variable_failure" attribute
+ 'basic-syntax33': (r'1{{ var.method3 }}2', {"var": SomeClass()}, "12"),
+
+ # In methods that raise an exception without a "silent_variable_attribute" set to True,
+ # the exception propogates
+ 'basic-syntax34': (r'1{{ var.method4 }}2', {"var": SomeClass()}, SomeOtherException),
+
+ # Escaped backslash in argument
+ 'basic-syntax35': (r'{{ var|default_if_none:"foo\bar" }}', {"var": None}, r'foo\bar'),
+
+ # Escaped backslash using known escape char
+ 'basic-syntax35': (r'{{ var|default_if_none:"foo\now" }}', {"var": None}, r'foo\now'),
### COMMENT TAG ###########################################################
'comment-tag01': ("{% comment %}this is hidden{% endcomment %}hello", {}, "hello"),
@@ -149,6 +168,45 @@ TEMPLATE_TESTS = {
'comment-tag04': ("foo{% comment %} {% endblock %} {% endcomment %}", {}, "foo"),
'comment-tag05': ("foo{% comment %} {% somerandomtag %} {% endcomment %}", {}, "foo"),
+ ### CYCLE TAG #############################################################
+ #'cycleXX': ('', {}, ''),
+ 'cycle01': ('{% cycle a, %}', {}, 'a'),
+ 'cycle02': ('{% cycle a,b,c as abc %}{% cycle abc %}', {}, 'ab'),
+ 'cycle03': ('{% cycle a,b,c as abc %}{% cycle abc %}{% cycle abc %}', {}, 'abc'),
+ 'cycle04': ('{% cycle a,b,c as abc %}{% cycle abc %}{% cycle abc %}{% cycle abc %}', {}, 'abca'),
+ 'cycle05': ('{% cycle %}', {}, template.TemplateSyntaxError),
+ 'cycle06': ('{% cycle a %}', {}, template.TemplateSyntaxError),
+ 'cycle07': ('{% cycle a,b,c as foo %}{% cycle bar %}', {}, template.TemplateSyntaxError),
+
+ ### EXCEPTIONS ############################################################
+
+ # Raise exception for invalid template name
+ 'exception01': ("{% extends 'nonexistent' %}", {}, template.TemplateSyntaxError),
+
+ # Raise exception for invalid template name (in variable)
+ 'exception02': ("{% extends nonexistent %}", {}, template.TemplateSyntaxError),
+
+ # Raise exception for extra {% extends %} tags
+ 'exception03': ("{% extends 'inheritance01' %}{% block first %}2{% endblock %}{% extends 'inheritance16' %}", {}, template.TemplateSyntaxError),
+
+ # Raise exception for custom tags used in child with {% load %} tag in parent, not in child
+ 'exception04': ("{% extends 'inheritance17' %}{% block first %}{% echo 400 %}5678{% endblock %}", {}, template.TemplateSyntaxError),
+
+ ### FILTER TAG ############################################################
+ #'filterXX': ('', {}, ''),
+ 'filter01': ('{% filter upper %}{% endfilter %}', {}, ''),
+ 'filter02': ('{% filter upper %}django{% endfilter %}', {}, 'DJANGO'),
+ 'filter03': ('{% filter upper|lower %}django{% endfilter %}', {}, 'django'),
+
+ ### FIRSTOF TAG ###########################################################
+ #'firstofXX': ('', {}, ''),
+ 'firstof01': ('{% firstof a b c %}', {'a':0,'b':0,'c':0}, ''),
+ 'firstof02': ('{% firstof a b c %}', {'a':1,'b':0,'c':0}, '1'),
+ 'firstof03': ('{% firstof a b c %}', {'a':0,'b':2,'c':0}, '2'),
+ 'firstof04': ('{% firstof a b c %}', {'a':0,'b':0,'c':3}, '3'),
+ 'firstof05': ('{% firstof a b c %}', {'a':1,'b':2,'c':3}, '1'),
+ 'firstof06': ('{% firstof %}', {}, template.TemplateSyntaxError),
+
### FOR TAG ###############################################################
'for-tag01': ("{% for val in values %}{{ val }}{% endfor %}", {"values": [1, 2, 3]}, "123"),
'for-tag02': ("{% for val in values reversed %}{{ val }}{% endfor %}", {"values": [1, 2, 3]}, "321"),
@@ -157,6 +215,17 @@ TEMPLATE_TESTS = {
'for-tag-vars03': ("{% for val in values %}{{ forloop.revcounter }}{% endfor %}", {"values": [6, 6, 6]}, "321"),
'for-tag-vars04': ("{% for val in values %}{{ forloop.revcounter0 }}{% endfor %}", {"values": [6, 6, 6]}, "210"),
+ ### IF TAG ################################################################
+ 'if-tag01': ("{% if foo %}yes{% else %}no{% endif %}", {"foo": True}, "yes"),
+ 'if-tag02': ("{% if foo %}yes{% else %}no{% endif %}", {"foo": False}, "no"),
+ 'if-tag03': ("{% if foo %}yes{% else %}no{% endif %}", {}, "no"),
+
+ ### IFCHANGED TAG #########################################################
+ #'ifchangedXX': ('', {}, ''),
+ 'ifchanged01': ('{% for n in num %}{% ifchanged %}{{ n }}{% endifchanged %}{% endfor %}', { 'num': (1,2,3) }, '123'),
+ 'ifchanged02': ('{% for n in num %}{% ifchanged %}{{ n }}{% endifchanged %}{% endfor %}', { 'num': (1,1,3) }, '13'),
+ 'ifchanged03': ('{% for n in num %}{% ifchanged %}{{ n }}{% endifchanged %}{% endfor %}', { 'num': (1,1,1) }, '1'),
+
### IFEQUAL TAG ###########################################################
'ifequal01': ("{% ifequal a b %}yes{% endifequal %}", {"a": 1, "b": 2}, ""),
'ifequal02': ("{% ifequal a b %}yes{% endifequal %}", {"a": 1, "b": 1}, "yes"),
@@ -169,20 +238,6 @@ TEMPLATE_TESTS = {
'ifequal09': ('{% ifequal a "test" %}yes{% else %}no{% endifequal %}', {}, "no"),
'ifequal10': ('{% ifequal a b %}yes{% else %}no{% endifequal %}', {}, "yes"),
- # Integers
- 'ifequal11': ('{% ifequal a 1 %}yes{% else %}no{% endifequal %}', {}, "no"),
- 'ifequal12': ('{% ifequal a 1 %}yes{% else %}no{% endifequal %}', {"a": 1}, "yes"),
- 'ifequal13': ('{% ifequal a 1 %}yes{% else %}no{% endifequal %}', {"a": "1"}, "no"),
- 'ifequal14': ('{% ifequal a "1" %}yes{% else %}no{% endifequal %}', {"a": 1}, "no"),
- 'ifequal15': ('{% ifequal a "1" %}yes{% else %}no{% endifequal %}', {"a": "1"}, "yes"),
-
- # Floats
- 'ifequal16': ('{% ifequal a 1.2 %}yes{% else %}no{% endifequal %}', {}, "no"),
- 'ifequal17': ('{% ifequal a 1.2 %}yes{% else %}no{% endifequal %}', {"a": 1.2}, "yes"),
- 'ifequal18': ('{% ifequal a 1.2 %}yes{% else %}no{% endifequal %}', {"a": "1.2"}, "no"),
- 'ifequal19': ('{% ifequal a "1.2" %}yes{% else %}no{% endifequal %}', {"a": 1.2}, "no"),
- 'ifequal20': ('{% ifequal a "1.2" %}yes{% else %}no{% endifequal %}', {"a": "1.2"}, "yes"),
-
### IFNOTEQUAL TAG ########################################################
'ifnotequal01': ("{% ifnotequal a b %}yes{% endifnotequal %}", {"a": 1, "b": 2}, "yes"),
'ifnotequal02': ("{% ifnotequal a b %}yes{% endifnotequal %}", {"a": 1, "b": 1}, ""),
@@ -266,37 +321,7 @@ TEMPLATE_TESTS = {
# Three-level inheritance with {{ block.super }} from parent and grandparent
'inheritance23': ("{% extends 'inheritance20' %}{% block first %}{{ block.super }}b{% endblock %}", {}, '1_ab3_'),
- ### EXCEPTIONS ############################################################
-
- # Raise exception for invalid template name
- 'exception01': ("{% extends 'nonexistent' %}", {}, template.TemplateSyntaxError),
-
- # Raise exception for invalid template name (in variable)
- 'exception02': ("{% extends nonexistent %}", {}, template.TemplateSyntaxError),
-
- # Raise exception for extra {% extends %} tags
- 'exception03': ("{% extends 'inheritance01' %}{% block first %}2{% endblock %}{% extends 'inheritance16' %}", {}, template.TemplateSyntaxError),
-
- # Raise exception for custom tags used in child with {% load %} tag in parent, not in child
- 'exception04': ("{% extends 'inheritance17' %}{% block first %}{% echo 400 %}5678{% endblock %}", {}, template.TemplateSyntaxError),
-
- 'multiline01': ("""
- Hello,
- boys.
- How
- are
- you
- gentlemen.
- """,
- {},
- """
- Hello,
- boys.
- How
- are
- you
- gentlemen.
- """),
+ ### I18N ##################################################################
# {% spaceless %} tag
'spaceless01': ("{% spaceless %} text {% endspaceless %}", {}, " text "),
@@ -341,6 +366,89 @@ TEMPLATE_TESTS = {
# translation of a constant string
'i18n13': ('{{ _("Page not found") }}', {'LANGUAGE_CODE': 'de'}, 'Seite nicht gefunden'),
+
+ ### MULTILINE #############################################################
+
+ 'multiline01': ("""
+ Hello,
+ boys.
+ How
+ are
+ you
+ gentlemen.
+ """,
+ {},
+ """
+ Hello,
+ boys.
+ How
+ are
+ you
+ gentlemen.
+ """),
+
+ ### REGROUP TAG ###########################################################
+ #'regroupXX': ('', {}, ''),
+ 'regroup01': ('{% regroup data by bar as grouped %}' + \
+ '{% for group in grouped %}' + \
+ '{{ group.grouper }}:' + \
+ '{% for item in group.list %}' + \
+ '{{ item.foo }}' + \
+ '{% endfor %},' + \
+ '{% endfor %}',
+ {'data': [ {'foo':'c', 'bar':1},
+ {'foo':'d', 'bar':1},
+ {'foo':'a', 'bar':2},
+ {'foo':'b', 'bar':2},
+ {'foo':'x', 'bar':3} ]},
+ '1:cd,2:ab,3:x,'),
+
+ # Test for silent failure when target variable isn't found
+ 'regroup02': ('{% regroup data by bar as grouped %}' + \
+ '{% for group in grouped %}' + \
+ '{{ group.grouper }}:' + \
+ '{% for item in group.list %}' + \
+ '{{ item.foo }}' + \
+ '{% endfor %},' + \
+ '{% endfor %}',
+ {}, ''),
+
+ ### TEMPLATETAG TAG #######################################################
+ #'templatetagXX': ('', {}, ''),
+ 'templatetag01': ('{% templatetag openblock %}', {}, '{%'),
+ 'templatetag02': ('{% templatetag closeblock %}', {}, '%}'),
+ 'templatetag03': ('{% templatetag openvariable %}', {}, '{{'),
+ 'templatetag04': ('{% templatetag closevariable %}', {}, '}}'),
+ 'templatetag05': ('{% templatetag %}', {}, template.TemplateSyntaxError),
+ 'templatetag06': ('{% templatetag foo %}', {}, template.TemplateSyntaxError),
+
+ ### WIDTHRATIO TAG ########################################################
+ #'widthratioXX': ('', {}, ''),
+ 'widthratio01': ('{% widthratio a b 0 %}', {'a':50,'b':100}, '0'),
+ 'widthratio02': ('{% widthratio a b 100 %}', {'a':0,'b':0}, ''),
+ 'widthratio03': ('{% widthratio a b 100 %}', {'a':0,'b':100}, '0'),
+ 'widthratio04': ('{% widthratio a b 100 %}', {'a':50,'b':100}, '50'),
+ 'widthratio05': ('{% widthratio a b 100 %}', {'a':100,'b':100}, '100'),
+
+ # 62.5 should round to 63
+ 'widthratio06': ('{% widthratio a b 100 %}', {'a':50,'b':80}, '63'),
+
+ # 71.4 should round to 71
+ 'widthratio07': ('{% widthratio a b 100 %}', {'a':50,'b':70}, '71'),
+
+ # Raise exception if we don't have 3 args, last one an integer
+ 'widthratio08': ('{% widthratio %}', {}, template.TemplateSyntaxError),
+ 'widthratio09': ('{% widthratio a b %}', {'a':50,'b':100}, template.TemplateSyntaxError),
+ 'widthratio10': ('{% widthratio a b 100.0 %}', {'a':50,'b':100}, template.TemplateSyntaxError),
+
+ ### NOW TAG ########################################################
+ # Simple case
+ 'now01' : ('{% now "j n Y"%}', {}, str(datetime.now().day) + ' ' + str(datetime.now().month) + ' ' + str(datetime.now().year)),
+
+ # Check parsing of escaped and special characters
+ 'now02' : ('{% now "j "n" Y"%}', {}, template.TemplateSyntaxError),
+# 'now03' : ('{% now "j \"n\" Y"%}', {}, str(datetime.now().day) + '"' + str(datetime.now().month) + '"' + str(datetime.now().year)),
+# 'now04' : ('{% now "j \nn\n Y"%}', {}, str(datetime.now().day) + '\n' + str(datetime.now().month) + '\n' + str(datetime.now().year))
}
def test_template_loader(template_name, template_dirs=None):
@@ -358,6 +466,9 @@ def run_tests(verbosity=0, standalone=False):
failed_tests = []
tests = TEMPLATE_TESTS.items()
tests.sort()
+
+ # Turn TEMPLATE_DEBUG off, because tests assume that.
+ old_td, settings.TEMPLATE_DEBUG = settings.TEMPLATE_DEBUG, False
for name, vals in tests:
install()
if 'LANGUAGE_CODE' in vals[1]:
@@ -387,6 +498,8 @@ def run_tests(verbosity=0, standalone=False):
failed_tests.append(name)
loader.template_source_loaders = old_template_loaders
deactivate()
+ settings.TEMPLATE_DEBUG = old_td
+
if failed_tests and not standalone:
msg = "Template tests %s failed." % failed_tests
if not verbosity:
diff --git a/tests/runtests.py b/tests/runtests.py
index 9226361090..3f8eda6ab4 100755
--- a/tests/runtests.py
+++ b/tests/runtests.py
@@ -7,7 +7,7 @@ import os, re, sys, time, traceback
# and Django aims to work with Python 2.3+.
import doctest
-APP_NAME = 'testapp'
+MODEL_TESTS_DIR_NAME = 'modeltests'
OTHER_TESTS_DIR = "othertests"
TEST_DATABASE_NAME = 'django_test_db'
@@ -18,10 +18,10 @@ def log_error(model_name, title, description):
'description': description,
})
-MODEL_DIR = os.path.join(os.path.dirname(__file__), APP_NAME, 'models')
+MODEL_TEST_DIR = os.path.join(os.path.dirname(__file__), MODEL_TESTS_DIR_NAME)
def get_test_models():
- return [f[:-3] for f in os.listdir(MODEL_DIR) if f.endswith('.py') and not f.startswith('__init__')]
+ return [f for f in os.listdir(MODEL_TEST_DIR) if not f.startswith('__init__') and not f.startswith('.')]
class DjangoDoctestRunner(doctest.DocTestRunner):
def __init__(self, verbosity_level, *args, **kwargs):
@@ -39,9 +39,13 @@ class DjangoDoctestRunner(doctest.DocTestRunner):
"Code: %r\nLine: %s\nExpected: %r\nGot: %r" % (example.source.strip(), example.lineno, example.want, got))
def report_unexpected_exception(self, out, test, example, exc_info):
+ from django.db import transaction
tb = ''.join(traceback.format_exception(*exc_info)[1:])
log_error(test.name, "API test raised an exception",
"Code: %r\nLine: %s\nException: %s" % (example.source.strip(), example.lineno, tb))
+ # Rollback, in case of database errors. Otherwise they'd have
+ # side effects on other tests.
+ transaction.rollback_unless_managed()
normalize_long_ints = lambda s: re.sub(r'(?>> articles.get_list()
-[]
-
-# Create an Article.
->>> from datetime import datetime
->>> a = articles.Article(id=None, headline='Area man programs in Python',
-... pub_date=datetime(2005, 7, 28))
-
-# Save it into the database. You have to call save() explicitly.
->>> a.save()
-
-# Now it has an ID. Note it's a long integer, as designated by the trailing "L".
->>> a.id
-1L
-
-# Access database columns via Python attributes.
->>> a.headline
-'Area man programs in Python'
->>> a.pub_date
-datetime.datetime(2005, 7, 28, 0, 0)
-
-# Change values by changing the attributes, then calling save().
->>> a.headline = 'Area woman programs in Python'
->>> a.save()
-
-# get_list() displays all the articles in the database. Note that the article
-# is represented by "", because we haven't given the Article
-# model a __repr__() method.
->>> articles.get_list()
-[]
-
-# Django provides a rich database lookup API that's entirely driven by
-# keyword arguments.
->>> articles.get_object(id__exact=1)
-
->>> articles.get_object(headline__startswith='Area woman')
-
->>> articles.get_object(pub_date__year=2005)
-
->>> articles.get_object(pub_date__year=2005, pub_date__month=7)
-
->>> articles.get_object(pub_date__year=2005, pub_date__month=7, pub_date__day=28)
-
-
->>> articles.get_list(pub_date__year=2005)
-[]
->>> articles.get_list(pub_date__year=2004)
-[]
->>> articles.get_list(pub_date__year=2005, pub_date__month=7)
-[]
-
-# Django raises an ArticleDoesNotExist exception for get_object()
->>> articles.get_object(id__exact=2)
-Traceback (most recent call last):
- ...
-ArticleDoesNotExist: Article does not exist for {'order_by': (), 'id__exact': 2}
-
->>> articles.get_object(pub_date__year=2005, pub_date__month=8)
-Traceback (most recent call last):
- ...
-ArticleDoesNotExist: Article does not exist for ...
-
-# Lookup by a primary key is the most common case, so Django provides a
-# shortcut for primary-key exact lookups.
-# The following is identical to articles.get_object(id__exact=1).
->>> articles.get_object(pk=1)
-
-
-# Model instances of the same type and same ID are considered equal.
->>> a = articles.get_object(pk=1)
->>> b = articles.get_object(pk=1)
->>> a == b
-True
-
-# You can initialize a model instance using positional arguments, which should
-# match the field order as defined in the model...
->>> a2 = articles.Article(None, 'Second article', datetime(2005, 7, 29))
->>> a2.save()
->>> a2.id
-2L
->>> a2.headline
-'Second article'
->>> a2.pub_date
-datetime.datetime(2005, 7, 29, 0, 0)
-
-# ...or, you can use keyword arguments.
->>> a3 = articles.Article(id=None, headline='Third article',
-... pub_date=datetime(2005, 7, 30))
->>> a3.save()
->>> a3.id
-3L
->>> a3.headline
-'Third article'
->>> a3.pub_date
-datetime.datetime(2005, 7, 30, 0, 0)
-
-# You can also mix and match position and keyword arguments, but be sure not to
-# duplicate field information.
->>> a4 = articles.Article(None, 'Fourth article', pub_date=datetime(2005, 7, 31))
->>> a4.save()
->>> a4.headline
-'Fourth article'
-
-# Don't use invalid keyword arguments.
->>> a5 = articles.Article(id=None, headline='Invalid', pub_date=datetime(2005, 7, 31), foo='bar')
-Traceback (most recent call last):
- ...
-TypeError: 'foo' is an invalid keyword argument for this function
-
-# You can leave off the ID.
->>> a5 = articles.Article(headline='Article 6', pub_date=datetime(2005, 7, 31))
->>> a5.save()
->>> a5.id
-5L
->>> a5.headline
-'Article 6'
-
-# If you leave off a field with "default" set, Django will use the default.
->>> a6 = articles.Article(pub_date=datetime(2005, 7, 31))
->>> a6.save()
->>> a6.headline
-'Default headline'
-
-# For DateTimeFields, Django saves as much precision (in seconds) as you
-# give it.
->>> a7 = articles.Article(headline='Article 7', pub_date=datetime(2005, 7, 31, 12, 30))
->>> a7.save()
->>> articles.get_object(id__exact=7).pub_date
-datetime.datetime(2005, 7, 31, 12, 30)
-
->>> a8 = articles.Article(headline='Article 8', pub_date=datetime(2005, 7, 31, 12, 30, 45))
->>> a8.save()
->>> articles.get_object(id__exact=8).pub_date
-datetime.datetime(2005, 7, 31, 12, 30, 45)
->>> a8.id
-8L
-
-# Saving an object again shouldn't create a new object -- it just saves the old one.
->>> a8.save()
->>> a8.id
-8L
->>> a8.headline = 'Updated article 8'
->>> a8.save()
->>> a8.id
-8L
-
->>> a7 == a8
-False
->>> a8 == articles.get_object(id__exact=8)
-True
->>> a7 != a8
-True
->>> articles.get_object(id__exact=8) != articles.get_object(id__exact=7)
-True
->>> articles.get_object(id__exact=8) == articles.get_object(id__exact=7)
-False
-"""
-
-from django.conf import settings
-
-building_docs = getattr(settings, 'BUILDING_DOCS', False)
-
-if building_docs or settings.DATABASE_ENGINE == 'postgresql':
- API_TESTS += """
-# In PostgreSQL, microsecond-level precision is available.
->>> a9 = articles.Article(headline='Article 9', pub_date=datetime(2005, 7, 31, 12, 30, 45, 180))
->>> a9.save()
->>> articles.get_object(id__exact=9).pub_date
-datetime.datetime(2005, 7, 31, 12, 30, 45, 180)
-"""
-
-if building_docs or settings.DATABASE_ENGINE == 'mysql':
- API_TESTS += """
-# In MySQL, microsecond-level precision isn't available. You'll lose
-# microsecond-level precision once the data is saved.
->>> a9 = articles.Article(headline='Article 9', pub_date=datetime(2005, 7, 31, 12, 30, 45, 180))
->>> a9.save()
->>> articles.get_object(id__exact=9).pub_date
-datetime.datetime(2005, 7, 31, 12, 30, 45)
-"""
-
-API_TESTS += """
-
-# You can manually specify the primary key when creating a new object
->>> a101 = articles.Article(id=101, headline='Article 101', pub_date=datetime(2005, 7, 31, 12, 30, 45))
->>> a101.save()
->>> a101 = articles.get_object(pk=101)
->>> a101.headline
-'Article 101'
-"""
diff --git a/tests/testapp/models/custom_methods.py b/tests/testapp/models/custom_methods.py
deleted file mode 100644
index 4f175752b4..0000000000
--- a/tests/testapp/models/custom_methods.py
+++ /dev/null
@@ -1,72 +0,0 @@
-"""
-3. Giving models custom methods and custom module-level functions
-
-Any method you add to a model will be available to instances.
-
-Custom methods have the same namespace as if the model class were defined
-in the dynamically-generated module. That is, methods can access
-``get_list()``, ``get_object()``, ``AddManipulator``, and all other
-module-level objects.
-
-Also, custom methods have access to a few commonly-used objects for
-convenience:
-
- * The ``datetime`` module from Python's standard library.
- * The ``db`` object from ``django.core.db``. This represents the database
- connection, so you can do custom queries via a cursor object.
-
-If your model method starts with "_module_", it'll be a module-level function
-instead of a method. Otherwise, custom module-level functions have the same
-namespace as custom methods.
-"""
-
-from django.core import meta
-
-class Article(meta.Model):
- headline = meta.CharField(maxlength=100)
- pub_date = meta.DateField()
-
- def __repr__(self):
- return self.headline
-
- def was_published_today(self):
- return self.pub_date == datetime.date.today()
-
- def get_articles_from_same_day_1(self):
- return get_list(id__ne=self.id, pub_date__exact=self.pub_date)
-
- def get_articles_from_same_day_2(self):
- """
- Verbose version of get_articles_from_same_day_1, which does a custom
- database query for the sake of demonstration.
- """
- cursor = db.cursor()
- cursor.execute("""
- SELECT id, headline, pub_date
- FROM custom_methods_articles
- WHERE pub_date = %s
- AND id != %s""", [str(self.pub_date), self.id])
- # The asterisk in "Article(*row)" tells Python to expand the list into
- # positional arguments to Article().
- return [Article(*row) for row in cursor.fetchall()]
-
-API_TESTS = """
-# Create a couple of Articles.
->>> from datetime import date
->>> a = articles.Article(id=None, headline='Area man programs in Python', pub_date=date(2005, 7, 27))
->>> a.save()
->>> b = articles.Article(id=None, headline='Beatles reunite', pub_date=date(2005, 7, 27))
->>> b.save()
-
-# Test the custom methods.
->>> a.was_published_today()
-False
->>> a.get_articles_from_same_day_1()
-[Beatles reunite]
->>> a.get_articles_from_same_day_2()
-[Beatles reunite]
->>> b.get_articles_from_same_day_1()
-[Area man programs in Python]
->>> b.get_articles_from_same_day_2()
-[Area man programs in Python]
-"""
diff --git a/tests/testapp/models/custom_pk.py b/tests/testapp/models/custom_pk.py
deleted file mode 100644
index 24041d64cd..0000000000
--- a/tests/testapp/models/custom_pk.py
+++ /dev/null
@@ -1,69 +0,0 @@
-"""
-14. Using a custom primary key
-
-By default, Django adds an ``"id"`` field to each model. But you can override
-this behavior by explicitly adding ``primary_key=True`` to a field.
-"""
-
-from django.core import meta
-
-class Employee(meta.Model):
- employee_code = meta.CharField(maxlength=10, primary_key=True)
- first_name = meta.CharField(maxlength=20)
- last_name = meta.CharField(maxlength=20)
- class META:
- ordering = ('last_name', 'first_name')
-
- def __repr__(self):
- return "%s %s" % (self.first_name, self.last_name)
-
-class Business(meta.Model):
- name = meta.CharField(maxlength=20, primary_key=True)
- employees = meta.ManyToManyField(Employee)
- class META:
- verbose_name_plural = 'businesses'
- module_name = 'businesses'
-
- def __repr__(self):
- return self.name
-
-API_TESTS = """
->>> dan = employees.Employee(employee_code='ABC123', first_name='Dan', last_name='Jones')
->>> dan.save()
->>> employees.get_list()
-[Dan Jones]
-
->>> fran = employees.Employee(employee_code='XYZ456', first_name='Fran', last_name='Bones')
->>> fran.save()
->>> employees.get_list()
-[Fran Bones, Dan Jones]
-
->>> employees.get_object(pk='ABC123')
-Dan Jones
->>> employees.get_object(pk='XYZ456')
-Fran Bones
->>> employees.get_object(pk='foo')
-Traceback (most recent call last):
- ...
-EmployeeDoesNotExist: Employee does not exist for {'pk': 'foo', 'order_by': ()}
-
-# Fran got married and changed her last name.
->>> fran = employees.get_object(pk='XYZ456')
->>> fran.last_name = 'Jones'
->>> fran.save()
->>> employees.get_list(last_name__exact='Jones')
-[Dan Jones, Fran Jones]
->>> employees.get_in_bulk(['ABC123', 'XYZ456'])
-{'XYZ456': Fran Jones, 'ABC123': Dan Jones}
-
->>> b = businesses.Business(name='Sears')
->>> b.save()
->>> b.set_employees([dan.employee_code, fran.employee_code])
-True
->>> b.get_employee_list()
-[Dan Jones, Fran Jones]
->>> fran.get_business_list()
-[Sears]
->>> businesses.get_in_bulk(['Sears'])
-{'Sears': Sears}
-"""
diff --git a/tests/testapp/models/get_latest.py b/tests/testapp/models/get_latest.py
deleted file mode 100644
index 86697e85a7..0000000000
--- a/tests/testapp/models/get_latest.py
+++ /dev/null
@@ -1,43 +0,0 @@
-"""
-8. get_latest_by
-
-Models can have a ``get_latest_by`` attribute, which should be set to the name
-of a DateField or DateTimeField. If ``get_latest_by`` exists, the model's
-module will get a ``get_latest()`` function, which will return the latest
-object in the database according to that field. "Latest" means "having the
-date farthest into the future."
-"""
-
-from django.core import meta
-
-class Article(meta.Model):
- headline = meta.CharField(maxlength=100)
- pub_date = meta.DateTimeField()
- class META:
- get_latest_by = 'pub_date'
-
- def __repr__(self):
- return self.headline
-
-API_TESTS = """
-# Because no Articles exist yet, get_latest() raises ArticleDoesNotExist.
->>> articles.get_latest()
-Traceback (most recent call last):
- ...
-ArticleDoesNotExist: Article does not exist for {'order_by': ('-pub_date',), 'limit': 1}
-
-# Create a couple of Articles.
->>> from datetime import datetime
->>> a1 = articles.Article(id=None, headline='Article 1', pub_date=datetime(2005, 7, 26))
->>> a1.save()
->>> a2 = articles.Article(id=None, headline='Article 2', pub_date=datetime(2005, 7, 27))
->>> a2.save()
->>> a3 = articles.Article(id=None, headline='Article 3', pub_date=datetime(2005, 7, 27))
->>> a3.save()
->>> a4 = articles.Article(id=None, headline='Article 4', pub_date=datetime(2005, 7, 28))
->>> a4.save()
-
-# Get the latest Article.
->>> articles.get_latest()
-Article 4
-"""
diff --git a/tests/testapp/models/lookup.py b/tests/testapp/models/lookup.py
deleted file mode 100644
index 03f5c7ff71..0000000000
--- a/tests/testapp/models/lookup.py
+++ /dev/null
@@ -1,153 +0,0 @@
-"""
-7. The lookup API
-
-This demonstrates features of the database API.
-"""
-
-from django.core import meta
-
-class Article(meta.Model):
- headline = meta.CharField(maxlength=100)
- pub_date = meta.DateTimeField()
- class META:
- ordering = ('-pub_date', 'headline')
-
- def __repr__(self):
- return self.headline
-
-API_TESTS = """
-# Create a couple of Articles.
->>> from datetime import datetime
->>> a1 = articles.Article(headline='Article 1', pub_date=datetime(2005, 7, 26))
->>> a1.save()
->>> a2 = articles.Article(headline='Article 2', pub_date=datetime(2005, 7, 27))
->>> a2.save()
->>> a3 = articles.Article(headline='Article 3', pub_date=datetime(2005, 7, 27))
->>> a3.save()
->>> a4 = articles.Article(headline='Article 4', pub_date=datetime(2005, 7, 28))
->>> a4.save()
->>> a5 = articles.Article(headline='Article 5', pub_date=datetime(2005, 8, 1, 9, 0))
->>> a5.save()
->>> a6 = articles.Article(headline='Article 6', pub_date=datetime(2005, 8, 1, 8, 0))
->>> a6.save()
->>> a7 = articles.Article(headline='Article 7', pub_date=datetime(2005, 7, 27))
->>> a7.save()
-
-# get_iterator() is just like get_list(), but it's a generator.
->>> for a in articles.get_iterator():
-... print a.headline
-Article 5
-Article 6
-Article 4
-Article 2
-Article 3
-Article 7
-Article 1
-
-# get_iterator() takes the same lookup arguments as get_list().
->>> for a in articles.get_iterator(headline__endswith='4'):
-... print a.headline
-Article 4
-
-# get_count() returns the number of objects matching search criteria.
->>> articles.get_count()
-7L
->>> articles.get_count(pub_date__exact=datetime(2005, 7, 27))
-3L
->>> articles.get_count(headline__startswith='Blah blah')
-0L
-
-# get_in_bulk() takes a list of IDs and returns a dictionary mapping IDs
-# to objects.
->>> articles.get_in_bulk([1, 2])
-{1: Article 1, 2: Article 2}
->>> articles.get_in_bulk([3])
-{3: Article 3}
->>> articles.get_in_bulk([1000])
-{}
->>> articles.get_in_bulk([])
-Traceback (most recent call last):
- ...
-AssertionError: get_in_bulk() cannot be passed an empty list.
-
-# get_values() is just like get_list(), except it returns a list of
-# dictionaries instead of object instances -- and you can specify which fields
-# you want to retrieve.
->>> articles.get_values(fields=['headline'])
-[{'headline': 'Article 5'}, {'headline': 'Article 6'}, {'headline': 'Article 4'}, {'headline': 'Article 2'}, {'headline': 'Article 3'}, {'headline': 'Article 7'}, {'headline': 'Article 1'}]
->>> articles.get_values(pub_date__exact=datetime(2005, 7, 27), fields=['id'])
-[{'id': 2}, {'id': 3}, {'id': 7}]
->>> articles.get_values(fields=['id', 'headline']) == [{'id': 5, 'headline': 'Article 5'}, {'id': 6, 'headline': 'Article 6'}, {'id': 4, 'headline': 'Article 4'}, {'id': 2, 'headline': 'Article 2'}, {'id': 3, 'headline': 'Article 3'}, {'id': 7, 'headline': 'Article 7'}, {'id': 1, 'headline': 'Article 1'}]
-True
-
-# get_values_iterator() is just like get_values(), but it's a generator.
->>> for d in articles.get_values_iterator(fields=['id', 'headline']):
-... i = d.items()
-... i.sort()
-... i
-[('headline', 'Article 5'), ('id', 5)]
-[('headline', 'Article 6'), ('id', 6)]
-[('headline', 'Article 4'), ('id', 4)]
-[('headline', 'Article 2'), ('id', 2)]
-[('headline', 'Article 3'), ('id', 3)]
-[('headline', 'Article 7'), ('id', 7)]
-[('headline', 'Article 1'), ('id', 1)]
-
-# Every DateField and DateTimeField creates get_next_by_FOO() and
-# get_previous_by_FOO() methods.
-# In the case of identical date values, these methods will use the ID as a
-# fallback check. This guarantees that no records are skipped or duplicated.
->>> a1.get_next_by_pub_date()
-Article 2
->>> a2.get_next_by_pub_date()
-Article 3
->>> a3.get_next_by_pub_date()
-Article 7
->>> a4.get_next_by_pub_date()
-Article 6
->>> a5.get_next_by_pub_date()
-Traceback (most recent call last):
- ...
-ArticleDoesNotExist: Article does not exist for ...
->>> a6.get_next_by_pub_date()
-Article 5
->>> a7.get_next_by_pub_date()
-Article 4
-
->>> a7.get_previous_by_pub_date()
-Article 3
->>> a6.get_previous_by_pub_date()
-Article 4
->>> a5.get_previous_by_pub_date()
-Article 6
->>> a4.get_previous_by_pub_date()
-Article 7
->>> a3.get_previous_by_pub_date()
-Article 2
->>> a2.get_previous_by_pub_date()
-Article 1
-
-# Every DateField and DateTimeField give their model module a get_FOO_list
-# function.
->>> articles.get_pub_date_list('year')
-[datetime.datetime(2005, 1, 1, 0, 0)]
->>> articles.get_pub_date_list('month')
-[datetime.datetime(2005, 7, 1, 0, 0), datetime.datetime(2005, 8, 1, 0, 0)]
->>> articles.get_pub_date_list('day')
-[datetime.datetime(2005, 7, 26, 0, 0), datetime.datetime(2005, 7, 27, 0, 0), datetime.datetime(2005, 7, 28, 0, 0), datetime.datetime(2005, 8, 1, 0, 0)]
-
-# Underscores and percent signs have special meaning in the underlying
-# database library, but Django handles the quoting of them automatically.
->>> a8 = articles.Article(headline='Article_ with underscore', pub_date=datetime(2005, 11, 20))
->>> a8.save()
->>> articles.get_list(headline__startswith='Article')
-[Article_ with underscore, Article 5, Article 6, Article 4, Article 2, Article 3, Article 7, Article 1]
->>> articles.get_list(headline__startswith='Article_')
-[Article_ with underscore]
->>> a9 = articles.Article(headline='Article% with percent sign', pub_date=datetime(2005, 11, 21))
->>> a9.save()
->>> articles.get_list(headline__startswith='Article')
-[Article% with percent sign, Article_ with underscore, Article 5, Article 6, Article 4, Article 2, Article 3, Article 7, Article 1]
->>> articles.get_list(headline__startswith='Article%')
-[Article% with percent sign]
-"""
diff --git a/tests/testapp/models/m2m_intermediary.py b/tests/testapp/models/m2m_intermediary.py
deleted file mode 100644
index 2a20072e03..0000000000
--- a/tests/testapp/models/m2m_intermediary.py
+++ /dev/null
@@ -1,68 +0,0 @@
-"""
-9. Many-to-many relationships via an intermediary table
-
-For many-to-many relationships that need extra fields on the intermediary
-table, use an intermediary model.
-
-In this example, an ``Article`` can have multiple ``Reporter``s, and each
-``Article``-``Reporter`` combination (a ``Writer``) has a ``position`` field,
-which specifies the ``Reporter``'s position for the given article (e.g. "Staff
-writer").
-"""
-
-from django.core import meta
-
-class Reporter(meta.Model):
- first_name = meta.CharField(maxlength=30)
- last_name = meta.CharField(maxlength=30)
-
- def __repr__(self):
- return "%s %s" % (self.first_name, self.last_name)
-
-class Article(meta.Model):
- headline = meta.CharField(maxlength=100)
- pub_date = meta.DateField()
-
- def __repr__(self):
- return self.headline
-
-class Writer(meta.Model):
- reporter = meta.ForeignKey(Reporter)
- article = meta.ForeignKey(Article)
- position = meta.CharField(maxlength=100)
-
- def __repr__(self):
- return '%r (%s)' % (self.get_reporter(), self.position)
-
-API_TESTS = """
-# Create a few Reporters.
->>> r1 = reporters.Reporter(first_name='John', last_name='Smith')
->>> r1.save()
->>> r2 = reporters.Reporter(first_name='Jane', last_name='Doe')
->>> r2.save()
-
-# Create an Article.
->>> from datetime import datetime
->>> a = articles.Article(headline='This is a test', pub_date=datetime(2005, 7, 27))
->>> a.save()
-
-# Create a few Writers.
->>> w1 = writers.Writer(reporter=r1, article=a, position='Main writer')
->>> w1.save()
->>> w2 = writers.Writer(reporter=r2, article=a, position='Contributor')
->>> w2.save()
-
-# Play around with the API.
->>> a.get_writer_list(order_by=['-position'], select_related=True)
-[John Smith (Main writer), Jane Doe (Contributor)]
->>> w1.get_reporter()
-John Smith
->>> w2.get_reporter()
-Jane Doe
->>> w1.get_article()
-This is a test
->>> w2.get_article()
-This is a test
->>> r1.get_writer_list()
-[John Smith (Main writer)]
-"""
diff --git a/tests/testapp/models/m2m_multiple.py b/tests/testapp/models/m2m_multiple.py
deleted file mode 100644
index d8793acb73..0000000000
--- a/tests/testapp/models/m2m_multiple.py
+++ /dev/null
@@ -1,99 +0,0 @@
-"""
-20. Multiple many-to-many relationships between the same two tables
-
-In this example, an Article can have many Categories (as "primary") and many
-Categories (as "secondary").
-
-Set ``related_name`` to designate what the reverse relationship is called.
-
-Set ``singular`` to designate what the category object is called. This is
-required if a model has multiple ``ManyToManyFields`` to the same object.
-"""
-
-from django.core import meta
-
-class Category(meta.Model):
- name = meta.CharField(maxlength=20)
- class META:
- module_name = 'categories'
- ordering = ('name',)
-
- def __repr__(self):
- return self.name
-
-class Article(meta.Model):
- headline = meta.CharField(maxlength=50)
- pub_date = meta.DateTimeField()
- primary_categories = meta.ManyToManyField(Category,
- singular='primary_category', related_name='primary_article')
- secondary_categories = meta.ManyToManyField(Category,
- singular='secondary_category', related_name='secondary_article')
- class META:
- ordering = ('pub_date',)
-
- def __repr__(self):
- return self.headline
-
-API_TESTS = """
->>> from datetime import datetime
-
->>> c1 = categories.Category(name='Sports')
->>> c1.save()
->>> c2 = categories.Category(name='News')
->>> c2.save()
->>> c3 = categories.Category(name='Crime')
->>> c3.save()
->>> c4 = categories.Category(name='Life')
->>> c4.save()
-
->>> a1 = articles.Article(headline='Area man steals', pub_date=datetime(2005, 11, 27))
->>> a1.save()
->>> a1.set_primary_categories([c2.id, c3.id])
-True
->>> a1.set_secondary_categories([c4.id])
-True
-
->>> a2 = articles.Article(headline='Area man runs', pub_date=datetime(2005, 11, 28))
->>> a2.save()
->>> a2.set_primary_categories([c1.id, c2.id])
-True
->>> a2.set_secondary_categories([c4.id])
-True
-
-# The "primary_category" here comes from the "singular" parameter. If we hadn't
-# specified the "singular" parameter, Django would just use "category", which
-# would cause a conflict because the "primary_categories" and
-# "secondary_categories" fields both relate to Category.
->>> a1.get_primary_category_list()
-[Crime, News]
-
-# Ditto for the "primary_category" here.
->>> a2.get_primary_category_list()
-[News, Sports]
-
-# Ditto for the "secondary_category" here.
->>> a1.get_secondary_category_list()
-[Life]
-
-# Ditto for the "secondary_category" here.
->>> a2.get_secondary_category_list()
-[Life]
-
-
->>> c1.get_primary_article_list()
-[Area man runs]
->>> c1.get_secondary_article_list()
-[]
->>> c2.get_primary_article_list()
-[Area man steals, Area man runs]
->>> c2.get_secondary_article_list()
-[]
->>> c3.get_primary_article_list()
-[Area man steals]
->>> c3.get_secondary_article_list()
-[]
->>> c4.get_primary_article_list()
-[]
->>> c4.get_secondary_article_list()
-[Area man steals, Area man runs]
-"""
diff --git a/tests/testapp/models/m2o_recursive.py b/tests/testapp/models/m2o_recursive.py
deleted file mode 100644
index 27d13b4e7e..0000000000
--- a/tests/testapp/models/m2o_recursive.py
+++ /dev/null
@@ -1,44 +0,0 @@
-"""
-11. Relating an object to itself, many-to-one
-
-To define a many-to-one relationship between a model and itself, use
-``ForeignKey('self')``.
-
-In this example, a ``Category`` is related to itself. That is, each
-``Category`` has a parent ``Category``.
-
-Set ``related_name`` to designate what the reverse relationship is called.
-"""
-
-from django.core import meta
-
-class Category(meta.Model):
- name = meta.CharField(maxlength=20)
- parent = meta.ForeignKey('self', null=True, related_name='child')
- class META:
- module_name = 'categories'
-
- def __repr__(self):
- return self.name
-
-API_TESTS = """
-# Create a few Category objects.
->>> r = categories.Category(id=None, name='Root category', parent=None)
->>> r.save()
->>> c = categories.Category(id=None, name='Child category', parent=r)
->>> c.save()
-
->>> r.get_child_list()
-[Child category]
->>> r.get_child(name__startswith='Child')
-Child category
->>> r.get_parent()
-Traceback (most recent call last):
- ...
-CategoryDoesNotExist
-
->>> c.get_child_list()
-[]
->>> c.get_parent()
-Root category
-"""
diff --git a/tests/testapp/models/m2o_recursive2.py b/tests/testapp/models/m2o_recursive2.py
deleted file mode 100644
index 52aa0f8b69..0000000000
--- a/tests/testapp/models/m2o_recursive2.py
+++ /dev/null
@@ -1,43 +0,0 @@
-"""
-12. Relating a model to another model more than once
-
-In this example, a ``Person`` can have a ``mother`` and ``father`` -- both of
-which are other ``Person`` objects.
-
-Set ``related_name`` to designate what the reverse relationship is called.
-"""
-
-from django.core import meta
-
-class Person(meta.Model):
- full_name = meta.CharField(maxlength=20)
- mother = meta.ForeignKey('self', null=True, related_name='mothers_child')
- father = meta.ForeignKey('self', null=True, related_name='fathers_child')
-
- def __repr__(self):
- return self.full_name
-
-API_TESTS = """
-# Create two Person objects -- the mom and dad in our family.
->>> dad = persons.Person(full_name='John Smith Senior', mother=None, father=None)
->>> dad.save()
->>> mom = persons.Person(full_name='Jane Smith', mother=None, father=None)
->>> mom.save()
-
-# Give mom and dad a kid.
->>> kid = persons.Person(full_name='John Smith Junior', mother=mom, father=dad)
->>> kid.save()
-
->>> kid.get_mother()
-Jane Smith
->>> kid.get_father()
-John Smith Senior
->>> dad.get_fathers_child_list()
-[John Smith Junior]
->>> mom.get_mothers_child_list()
-[John Smith Junior]
->>> kid.get_mothers_child_list()
-[]
->>> kid.get_fathers_child_list()
-[]
-"""
diff --git a/tests/testapp/models/many_to_many.py b/tests/testapp/models/many_to_many.py
deleted file mode 100644
index 91addafe9b..0000000000
--- a/tests/testapp/models/many_to_many.py
+++ /dev/null
@@ -1,82 +0,0 @@
-"""
-5. Many-to-many relationships
-
-To define a many-to-many relationship, use ManyToManyField().
-
-In this example, an article can be published in multiple publications,
-and a publication has multiple articles.
-"""
-
-from django.core import meta
-
-class Publication(meta.Model):
- title = meta.CharField(maxlength=30)
-
- def __repr__(self):
- return self.title
-
-class Article(meta.Model):
- headline = meta.CharField(maxlength=100)
- publications = meta.ManyToManyField(Publication)
-
- def __repr__(self):
- return self.headline
-
-API_TESTS = """
-# Create a couple of Publications.
->>> p1 = publications.Publication(id=None, title='The Python Journal')
->>> p1.save()
->>> p2 = publications.Publication(id=None, title='Science News')
->>> p2.save()
-
-# Create an Article.
->>> a1 = articles.Article(id=None, headline='Django lets you build Web apps easily')
->>> a1.save()
-
-# Associate the Article with one Publication. set_publications() returns a
-# boolean, representing whether any records were added or deleted.
->>> a1.set_publications([p1.id])
-True
-
-# If we set it again, it'll return False, because the list of Publications
-# hasn't changed.
->>> a1.set_publications([p1.id])
-False
-
-# Create another Article, and set it to appear in both Publications.
->>> a2 = articles.Article(id=None, headline='NASA uses Python')
->>> a2.save()
->>> a2.set_publications([p1.id, p2.id])
-True
->>> a2.set_publications([p1.id])
-True
->>> a2.set_publications([p1.id, p2.id])
-True
-
-# Article objects have access to their related Publication objects.
->>> a1.get_publication_list()
-[The Python Journal]
->>> a2.get_publication_list()
-[The Python Journal, Science News]
-
-# Publication objects have access to their related Article objects.
->>> p2.get_article_list()
-[NASA uses Python]
->>> p1.get_article_list(order_by=['headline'])
-[Django lets you build Web apps easily, NASA uses Python]
-
-# If we delete a Publication, its Articles won't be able to access it.
->>> p1.delete()
->>> publications.get_list()
-[Science News]
->>> a1 = articles.get_object(pk=1)
->>> a1.get_publication_list()
-[]
-
-# If we delete an Article, its Publications won't be able to access it.
->>> a2.delete()
->>> articles.get_list()
-[Django lets you build Web apps easily]
->>> p1.get_article_list(order_by=['headline'])
-[Django lets you build Web apps easily]
-"""
diff --git a/tests/testapp/models/many_to_one.py b/tests/testapp/models/many_to_one.py
deleted file mode 100644
index 37828b6d82..0000000000
--- a/tests/testapp/models/many_to_one.py
+++ /dev/null
@@ -1,98 +0,0 @@
-"""
-4. Many-to-one relationships
-
-To define a many-to-one relationship, use ``ForeignKey()`` .
-"""
-
-from django.core import meta
-
-class Reporter(meta.Model):
- first_name = meta.CharField(maxlength=30)
- last_name = meta.CharField(maxlength=30)
- email = meta.EmailField()
-
- def __repr__(self):
- return "%s %s" % (self.first_name, self.last_name)
-
-class Article(meta.Model):
- headline = meta.CharField(maxlength=100)
- pub_date = meta.DateField()
- reporter = meta.ForeignKey(Reporter)
-
- def __repr__(self):
- return self.headline
-
-API_TESTS = """
-# Create a Reporter.
->>> r = reporters.Reporter(first_name='John', last_name='Smith', email='john@example.com')
->>> r.save()
-
-# Create an Article.
->>> from datetime import datetime
->>> a = articles.Article(id=None, headline="This is a test", pub_date=datetime(2005, 7, 27), reporter=r)
->>> a.save()
-
->>> a.reporter_id
-1
-
->>> a.get_reporter()
-John Smith
-
-# Article objects have access to their related Reporter objects.
->>> r = a.get_reporter()
->>> r.first_name, r.last_name
-('John', 'Smith')
-
-# Create an Article via the Reporter object.
->>> new_article = r.add_article(headline="John's second story", pub_date=datetime(2005, 7, 29))
->>> new_article
-John's second story
->>> new_article.reporter_id
-1
-
-# Reporter objects have access to their related Article objects.
->>> r.get_article_list(order_by=['pub_date'])
-[This is a test, John's second story]
-
->>> r.get_article(headline__startswith='This')
-This is a test
-
->>> r.get_article_count()
-2
-
-# The API automatically follows relationships as far as you need.
-# Use double underscores to separate relationships.
-# This works as many levels deep as you want. There's no limit.
-# Find all Articles for any Reporter whose first name is "John".
->>> articles.get_list(reporter__first_name__exact='John', order_by=['pub_date'])
-[This is a test, John's second story]
-
-# Find all Articles for the Reporter whose ID is 1.
->>> articles.get_list(reporter__id__exact=1, order_by=['pub_date'])
-[This is a test, John's second story]
-
-# Note you need two underscores between "reporter" and "id" -- not one.
->>> articles.get_list(reporter_id__exact=1)
-Traceback (most recent call last):
- ...
-TypeError: got unexpected keyword argument 'reporter_id__exact'
-
-# "pk" shortcut syntax works in a related context, too.
->>> articles.get_list(reporter__pk=1, order_by=['pub_date'])
-[This is a test, John's second story]
-
-# You can also instantiate an Article by passing
-# the Reporter's ID instead of a Reporter object.
->>> a3 = articles.Article(id=None, headline="This is a test", pub_date=datetime(2005, 7, 27), reporter_id=r.id)
->>> a3.save()
->>> a3.reporter_id
-1
->>> a3.get_reporter()
-John Smith
-
-# Similarly, the reporter ID can be a string.
->>> a4 = articles.Article(id=None, headline="This is a test", pub_date=datetime(2005, 7, 27), reporter_id="1")
->>> a4.save()
->>> a4.get_reporter()
-John Smith
-"""
diff --git a/tests/testapp/models/many_to_one_null.py b/tests/testapp/models/many_to_one_null.py
deleted file mode 100644
index c3c92601f7..0000000000
--- a/tests/testapp/models/many_to_one_null.py
+++ /dev/null
@@ -1,78 +0,0 @@
-"""
-16. Many-to-one relationships that can be null
-
-To define a many-to-one relationship that can have a null foreign key, use
-``ForeignKey()`` with ``null=True`` .
-"""
-
-from django.core import meta
-
-class Reporter(meta.Model):
- name = meta.CharField(maxlength=30)
-
- def __repr__(self):
- return self.name
-
-class Article(meta.Model):
- headline = meta.CharField(maxlength=100)
- reporter = meta.ForeignKey(Reporter, null=True)
-
- def __repr__(self):
- return self.headline
-
-API_TESTS = """
-# Create a Reporter.
->>> r = reporters.Reporter(name='John Smith')
->>> r.save()
-
-# Create an Article.
->>> a = articles.Article(headline="First", reporter=r)
->>> a.save()
-
->>> a.reporter_id
-1
-
->>> a.get_reporter()
-John Smith
-
-# Article objects have access to their related Reporter objects.
->>> r = a.get_reporter()
-
-# Create an Article via the Reporter object.
->>> a2 = r.add_article(headline="Second")
->>> a2
-Second
->>> a2.reporter_id
-1
-
-# Reporter objects have access to their related Article objects.
->>> r.get_article_list(order_by=['headline'])
-[First, Second]
->>> r.get_article(headline__startswith='Fir')
-First
->>> r.get_article_count()
-2
-
-# Create an Article with no Reporter by passing "reporter=None".
->>> a3 = articles.Article(headline="Third", reporter=None)
->>> a3.save()
->>> a3.id
-3
->>> a3.reporter_id
->>> print a3.reporter_id
-None
->>> a3 = articles.get_object(pk=3)
->>> print a3.reporter_id
-None
-
-# An article's get_reporter() method throws ReporterDoesNotExist
-# if the reporter is set to None.
->>> a3.get_reporter()
-Traceback (most recent call last):
- ...
-ReporterDoesNotExist
-
-# To retrieve the articles with no reporters set, use "reporter__isnull=True".
->>> articles.get_list(reporter__isnull=True)
-[Third]
-"""
diff --git a/tests/testapp/models/one_to_one.py b/tests/testapp/models/one_to_one.py
deleted file mode 100644
index b5d749c25d..0000000000
--- a/tests/testapp/models/one_to_one.py
+++ /dev/null
@@ -1,80 +0,0 @@
-"""
-10. One-to-one relationships
-
-To define a one-to-one relationship, use ``OneToOneField()``.
-
-In this example, a ``Place`` optionally can be a ``Restaurant``.
-"""
-
-from django.core import meta
-
-class Place(meta.Model):
- name = meta.CharField(maxlength=50)
- address = meta.CharField(maxlength=80)
-
- def __repr__(self):
- return "%s the place" % self.name
-
-class Restaurant(meta.Model):
- place = meta.OneToOneField(Place)
- serves_hot_dogs = meta.BooleanField()
- serves_pizza = meta.BooleanField()
-
- def __repr__(self):
- return "%s the restaurant" % self.get_place().name
-
-class Waiter(meta.Model):
- restaurant = meta.ForeignKey(Restaurant)
- name = meta.CharField(maxlength=50)
-
- def __repr__(self):
- return "%s the waiter at %r" % (self.name, self.get_restaurant())
-
-API_TESTS = """
-# Create a couple of Places.
->>> p1 = places.Place(name='Demon Dogs', address='944 W. Fullerton')
->>> p1.save()
->>> p2 = places.Place(name='Ace Hardware', address='1013 N. Ashland')
->>> p2.save()
-
-# Create a Restaurant. Pass the ID of the "parent" object as this object's ID.
->>> r = restaurants.Restaurant(place=p1, serves_hot_dogs=True, serves_pizza=False)
->>> r.save()
-
-# A Restaurant can access its place.
->>> r.get_place()
-Demon Dogs the place
-
-# A Place can access its restaurant, if available.
->>> p1.get_restaurant()
-Demon Dogs the restaurant
-
-# p2 doesn't have an associated restaurant.
->>> p2.get_restaurant()
-Traceback (most recent call last):
- ...
-RestaurantDoesNotExist: Restaurant does not exist for {'order_by': (), 'place__id__exact': ...}
-
-# restaurants.get_list() just returns the Restaurants, not the Places.
->>> restaurants.get_list()
-[Demon Dogs the restaurant]
-
-# places.get_list() returns all Places, regardless of whether they have
-# Restaurants.
->>> places.get_list(order_by=['name'])
-[Ace Hardware the place, Demon Dogs the place]
-
->>> restaurants.get_object(place__id__exact=1)
-Demon Dogs the restaurant
->>> restaurants.get_object(pk=1)
-Demon Dogs the restaurant
-
-# Add a Waiter to the Restaurant.
->>> w = r.add_waiter(name='Joe')
->>> w.save()
->>> w
-Joe the waiter at Demon Dogs the restaurant
-
->>> r = restaurants.get_object(pk=1)
->>> r.delete()
-"""
diff --git a/tests/testapp/models/or_lookups.py b/tests/testapp/models/or_lookups.py
deleted file mode 100644
index 0bf554e408..0000000000
--- a/tests/testapp/models/or_lookups.py
+++ /dev/null
@@ -1,57 +0,0 @@
-"""
-19. OR lookups
-
-To perform an OR lookup, or a lookup that combines ANDs and ORs, use the
-``complex`` keyword argument, and pass it an expression of clauses using the
-variable ``django.core.meta.Q``.
-"""
-
-from django.core import meta
-
-class Article(meta.Model):
- headline = meta.CharField(maxlength=50)
- pub_date = meta.DateTimeField()
- class META:
- ordering = ('pub_date',)
-
- def __repr__(self):
- return self.headline
-
-API_TESTS = """
->>> from datetime import datetime
->>> from django.core.meta import Q
-
->>> a1 = articles.Article(headline='Hello', pub_date=datetime(2005, 11, 27))
->>> a1.save()
-
->>> a2 = articles.Article(headline='Goodbye', pub_date=datetime(2005, 11, 28))
->>> a2.save()
-
->>> a3 = articles.Article(headline='Hello and goodbye', pub_date=datetime(2005, 11, 29))
->>> a3.save()
-
->>> articles.get_list(complex=(Q(headline__startswith='Hello') | Q(headline__startswith='Goodbye')))
-[Hello, Goodbye, Hello and goodbye]
-
->>> articles.get_list(complex=(Q(headline__startswith='Hello') & Q(headline__startswith='Goodbye')))
-[]
-
->>> articles.get_list(complex=(Q(headline__startswith='Hello') & Q(headline__contains='bye')))
-[Hello and goodbye]
-
->>> articles.get_list(headline__startswith='Hello', complex=Q(headline__contains='bye'))
-[Hello and goodbye]
-
->>> articles.get_list(complex=(Q(headline__contains='Hello') | Q(headline__contains='bye')))
-[Hello, Goodbye, Hello and goodbye]
-
->>> articles.get_list(complex=(Q(headline__iexact='Hello') | Q(headline__contains='ood')))
-[Hello, Goodbye, Hello and goodbye]
-
->>> articles.get_list(complex=(Q(pk=1) | Q(pk=2)))
-[Hello, Goodbye]
-
->>> articles.get_list(complex=(Q(pk=1) | Q(pk=2) | Q(pk=3)))
-[Hello, Goodbye, Hello and goodbye]
-
-"""
diff --git a/tests/testapp/models/reserved_names.py b/tests/testapp/models/reserved_names.py
deleted file mode 100644
index eabe41e5bd..0000000000
--- a/tests/testapp/models/reserved_names.py
+++ /dev/null
@@ -1,47 +0,0 @@
-"""
-18. Using SQL reserved names
-
-Need to use a reserved SQL name as a column name or table name? Need to include
-a hyphen in a column or table name? No problem. Django quotes names
-appropriately behind the scenes, so your database won't complain about
-reserved-name usage.
-"""
-
-from django.core import meta
-
-class Thing(meta.Model):
- when = meta.CharField(maxlength=1, primary_key=True)
- join = meta.CharField(maxlength=1)
- like = meta.CharField(maxlength=1)
- drop = meta.CharField(maxlength=1)
- alter = meta.CharField(maxlength=1)
- having = meta.CharField(maxlength=1)
- where = meta.CharField(maxlength=1)
- has_hyphen = meta.CharField(maxlength=1, db_column='has-hyphen')
- class META:
- db_table = 'select'
-
- def __repr__(self):
- return self.when
-
-API_TESTS = """
->>> t = things.Thing(when='a', join='b', like='c', drop='d', alter='e', having='f', where='g', has_hyphen='h')
->>> t.save()
->>> print t.when
-a
-
->>> u = things.Thing(when='h', join='i', like='j', drop='k', alter='l', having='m', where='n')
->>> u.save()
->>> print u.when
-h
-
->>> things.get_list(order_by=['when'])
-[a, h]
->>> v = things.get_object(pk='a')
->>> print v.join
-b
->>> print v.where
-g
->>> things.get_list(order_by=['select.when'])
-[a, h]
-"""
diff --git a/tests/testapp/models/save_delete_hooks.py b/tests/testapp/models/save_delete_hooks.py
deleted file mode 100644
index f0fa836f71..0000000000
--- a/tests/testapp/models/save_delete_hooks.py
+++ /dev/null
@@ -1,49 +0,0 @@
-"""
-13. Adding hooks before/after saving and deleting
-
-Django provides hooks for executing arbitrary code around ``save()`` and
-``delete()``. Just add any of the following methods to your model:
-
- * ``_pre_save()`` is called before an object is saved.
- * ``_post_save()`` is called after an object is saved.
- * ``_pre_delete()`` is called before an object is deleted.
- * ``_post_delete()`` is called after an object is deleted.
-"""
-
-from django.core import meta
-
-class Person(meta.Model):
- first_name = meta.CharField(maxlength=20)
- last_name = meta.CharField(maxlength=20)
-
- def __repr__(self):
- return "%s %s" % (self.first_name, self.last_name)
-
- def _pre_save(self):
- print "Before save"
-
- def _post_save(self):
- print "After save"
-
- def _pre_delete(self):
- print "Before deletion"
-
- def _post_delete(self):
- print "After deletion"
-
-API_TESTS = """
->>> p1 = persons.Person(first_name='John', last_name='Smith')
->>> p1.save()
-Before save
-After save
-
->>> persons.get_list()
-[John Smith]
-
->>> p1.delete()
-Before deletion
-After deletion
-
->>> persons.get_list()
-[]
-"""
diff --git a/tests/testapp/models/subclassing.py b/tests/testapp/models/subclassing.py
deleted file mode 100644
index e0dad26acb..0000000000
--- a/tests/testapp/models/subclassing.py
+++ /dev/null
@@ -1,180 +0,0 @@
-"""
-15. Subclassing models
-
-You can subclass another model to create a copy of it that behaves slightly
-differently.
-"""
-
-from django.core import meta
-
-# From the "Bare-bones model" example
-from django.models.basic import Article
-
-# From the "Adding __repr__()" example
-from django.models.repr import Article as ArticleWithRepr
-
-# From the "Specifying ordering" example
-from django.models.ordering import Article as ArticleWithOrdering
-
-# This uses all fields and metadata from Article and
-# adds a "section" field.
-class ArticleWithSection(Article):
- section = meta.CharField(maxlength=30)
- class META:
- module_name = 'subarticles1'
-
-# This uses all fields and metadata from Article but
-# removes the "pub_date" field.
-class ArticleWithoutPubDate(Article):
- class META:
- module_name = 'subarticles2'
- remove_fields = ('pub_date',)
-
-# This uses all fields and metadata from Article but
-# overrides the "pub_date" field.
-class ArticleWithFieldOverride(Article):
- pub_date = meta.DateField() # overrides the old field, a DateTimeField
- class META:
- module_name = 'subarticles3'
- # No need to add remove_fields = ('pub_date',)
-
-# This uses all fields and metadata from ArticleWithRepr and
-# makes a few additions/changes.
-class ArticleWithManyChanges(ArticleWithRepr):
- section = meta.CharField(maxlength=30)
- is_popular = meta.BooleanField()
- pub_date = meta.DateField() # overrides the old field, a DateTimeField
- class META:
- module_name = 'subarticles4'
-
-# This uses all fields from ArticleWithOrdering but
-# changes the ordering parameter.
-class ArticleWithChangedMeta(ArticleWithOrdering):
- class META:
- module_name = 'subarticles5'
- ordering = ('headline', 'pub_date')
-
-# These two models don't define a module_name.
-class NoModuleNameFirst(Article):
- section = meta.CharField(maxlength=30)
-
-class NoModuleNameSecond(Article):
- section = meta.CharField(maxlength=30)
-
-API_TESTS = """
-# No data is in the system yet.
->>> subarticles1.get_list()
-[]
->>> subarticles2.get_list()
-[]
->>> subarticles3.get_list()
-[]
-
-# Create an ArticleWithSection.
->>> from datetime import date, datetime
->>> a1 = subarticles1.ArticleWithSection(headline='First', pub_date=datetime(2005, 8, 22), section='News')
->>> a1.save()
->>> a1
-
->>> a1.id
-1
->>> a1.headline
-'First'
->>> a1.pub_date
-datetime.datetime(2005, 8, 22, 0, 0)
-
-# Retrieve it again, to prove the fields have been saved.
->>> a1 = subarticles1.get_object(pk=1)
->>> a1.headline
-'First'
->>> a1.pub_date
-datetime.datetime(2005, 8, 22, 0, 0)
->>> a1.section
-'News'
-
-# Create an ArticleWithoutPubDate.
->>> a2 = subarticles2.ArticleWithoutPubDate(headline='Second')
->>> a2.save()
->>> a2
-
->>> a2.id
-1
->>> a2.pub_date
-Traceback (most recent call last):
- ...
-AttributeError: 'ArticleWithoutPubDate' object has no attribute 'pub_date'
-
-# Retrieve it again, to prove the fields have been saved.
->>> a2 = subarticles2.get_object(pk=1)
->>> a2.headline
-'Second'
->>> a2.pub_date
-Traceback (most recent call last):
- ...
-AttributeError: 'ArticleWithoutPubDate' object has no attribute 'pub_date'
-
-# Create an ArticleWithFieldOverride.
->>> a3 = subarticles3.ArticleWithFieldOverride(headline='Third', pub_date=date(2005, 8, 22))
->>> a3.save()
->>> a3
-
->>> a3.id
-1
->>> a3.pub_date
-datetime.date(2005, 8, 22)
-
-# Retrieve it again, to prove the fields have been saved.
->>> a3 = subarticles3.get_object(pk=1)
->>> a3.headline
-'Third'
->>> a3.pub_date
-datetime.date(2005, 8, 22)
-
-# Create an ArticleWithManyChanges.
->>> a4 = subarticles4.ArticleWithManyChanges(headline='Fourth', section='Arts',
-... is_popular=True, pub_date=date(2005, 8, 22))
->>> a4.save()
-
-# a4 inherits __repr__() from its parent model (ArticleWithRepr).
->>> a4
-Fourth
-
-# Retrieve it again, to prove the fields have been saved.
->>> a4 = subarticles4.get_object(pk=1)
->>> a4.headline
-'Fourth'
->>> a4.section
-'Arts'
->>> a4.is_popular == True
-True
->>> a4.pub_date
-datetime.date(2005, 8, 22)
-
-# Test get_list().
->>> subarticles1.get_list()
-[]
->>> subarticles2.get_list()
-[]
->>> subarticles3.get_list()
-[]
->>> subarticles4.get_list()
-[Fourth]
-
-# Create a couple of ArticleWithChangedMeta objects.
->>> a5 = subarticles5.ArticleWithChangedMeta(headline='A', pub_date=datetime(2005, 3, 1))
->>> a5.save()
->>> a6 = subarticles5.ArticleWithChangedMeta(headline='B', pub_date=datetime(2005, 4, 1))
->>> a6.save()
->>> a7 = subarticles5.ArticleWithChangedMeta(headline='C', pub_date=datetime(2005, 5, 1))
->>> a7.save()
-
-# Ordering has been overridden, so objects are ordered
-# by headline ASC instead of pub_date DESC.
->>> subarticles5.get_list()
-[A, B, C]
-
->>> nomodulenamefirsts.get_list()
-[]
->>> nomodulenameseconds.get_list()
-[]
-"""
{{ app.name }}
-| {{ model.name }} | +{{ model.name }} | {% else %} -{{ model.name }} | +{{ model.name }} | {% endif %} {% if model.perms.add %} @@ -57,7 +58,7 @@ {% else %}
|---|
- class for a given radio_admin value
get_ul_class = lambda x: 'radiolist%s' % ((x == HORIZONTAL) and ' inline' or '')
-def string_concat(*strings):
- """"
- lazy variant of string concatenation, needed for translations that are
- constructed from multiple parts. Handles lazy strings and non-strings by
- first turning all arguments to strings, before joining them.
- """
- return ''.join([str(el) for el in strings])
-
-string_concat = lazy(string_concat, str)
-
-def manipulator_valid_rel_key(f, self, field_data, all_data):
- "Validates that the value is a valid foreign key"
- mod = f.rel.to.get_model_module()
- try:
- mod.get_object(pk=field_data)
- except ObjectDoesNotExist:
- raise validators.ValidationError, _("Please enter a valid %s.") % f.verbose_name
+class FieldDoesNotExist(Exception):
+ pass
def manipulator_validator_unique(f, opts, self, field_data, all_data):
"Validates that the value is unique for this field."
- if f.rel and isinstance(f.rel, ManyToOneRel):
- lookup_type = '%s__%s__exact' % (f.name, f.rel.get_related_field().name)
- else:
- lookup_type = '%s__exact' % f.name
+ lookup_type = f.get_validator_unique_lookup_type()
try:
- old_obj = opts.get_model_module().get_object(**{lookup_type: field_data})
+ old_obj = self.manager.get(**{lookup_type: field_data})
except ObjectDoesNotExist:
return
- if hasattr(self, 'original_object') and getattr(self.original_object, opts.pk.attname) == getattr(old_obj, opts.pk.attname):
+ if getattr(self, 'original_object', None) and self.original_object._get_pk_val() == old_obj._get_pk_val():
return
- raise validators.ValidationError, _("%(optname)s with this %(fieldname)s already exists.") % {'optname': capfirst(opts.verbose_name), 'fieldname': f.verbose_name}
-
-class BoundField(object):
- def __init__(self, field, field_mapping, original):
- self.field = field
- self.original = original
- self.form_fields = self.resolve_form_fields(field_mapping)
-
- def resolve_form_fields(self, field_mapping):
- return [field_mapping[name] for name in self.field.get_manipulator_field_names('')]
-
- def as_field_list(self):
- return [self.field]
-
- def original_value(self):
- if self.original:
- return self.original.__dict__[self.field.column]
-
- def __repr__(self):
- return "BoundField:(%s, %s)" % (self.field.name, self.form_fields)
+ raise validators.ValidationError, gettext("%(optname)s with this %(fieldname)s already exists.") % {'optname': capfirst(opts.verbose_name), 'fieldname': f.verbose_name}
# A guide to Field parameters:
#
-# * name: The name of the field specified in the model.
+# * name: The name of the field specifed in the model.
# * attname: The attribute to use on the model object. This is the same as
# "name", except in the case of ForeignKeys, where "_id" is
# appended.
@@ -103,13 +64,13 @@ class Field(object):
creation_counter = 0
def __init__(self, verbose_name=None, name=None, primary_key=False,
- maxlength=None, unique=False, blank=False, null=False, db_index=None,
+ maxlength=None, unique=False, blank=False, null=False, db_index=False,
core=False, rel=None, default=NOT_PROVIDED, editable=True,
prepopulate_from=None, unique_for_date=None, unique_for_month=None,
unique_for_year=None, validator_list=None, choices=None, radio_admin=None,
help_text='', db_column=None):
self.name = name
- self.verbose_name = verbose_name or (name and name.replace('_', ' '))
+ self.verbose_name = verbose_name
self.primary_key = primary_key
self.maxlength, self.unique = maxlength, unique
self.blank, self.null = blank, null
@@ -123,39 +84,70 @@ class Field(object):
self.radio_admin = radio_admin
self.help_text = help_text
self.db_column = db_column
- if rel and isinstance(rel, ManyToManyRel):
- if rel.raw_id_admin:
- self.help_text = string_concat(self.help_text,
- gettext_lazy(' Separate multiple IDs with commas.'))
- else:
- self.help_text = string_concat(self.help_text,
- gettext_lazy(' Hold down "Control", or "Command" on a Mac, to select more than one.'))
# Set db_index to True if the field has a relationship and doesn't explicitly set db_index.
- if db_index is None:
- if isinstance(rel, OneToOneRel) or isinstance(rel, ManyToOneRel):
- self.db_index = True
- else:
- self.db_index = False
- else:
- self.db_index = db_index
+ self.db_index = db_index
# Increase the creation counter, and save our local copy.
self.creation_counter = Field.creation_counter
Field.creation_counter += 1
+ def __cmp__(self, other):
+ # This is needed because bisect does not take a comparison function.
+ return cmp(self.creation_counter, other.creation_counter)
+
+ def to_python(self, value):
+ """
+ Converts the input value into the expected Python data type, raising
+ validators.ValidationError if the data can't be converted. Returns the
+ converted value. Subclasses should override this.
+ """
+ return value
+
+ def validate_full(self, field_data, all_data):
+ """
+ Returns a list of errors for this field. This is the main interface,
+ as it encapsulates some basic validation logic used by all fields.
+ Subclasses should implement validate(), not validate_full().
+ """
+ if not self.blank and not field_data:
+ return [gettext_lazy('This field is required.')]
+ try:
+ self.validate(field_data, all_data)
+ except validators.ValidationError, e:
+ return e.messages
+ return []
+
+ def validate(self, field_data, all_data):
+ """
+ Raises validators.ValidationError if field_data has any errors.
+ Subclasses should override this to specify field-specific validation
+ logic. This method should assume field_data has already been converted
+ into the appropriate data type by Field.to_python().
+ """
+ pass
+
+ def set_attributes_from_name(self, name):
+ self.name = name
self.attname, self.column = self.get_attname_column()
+ self.verbose_name = self.verbose_name or (name and name.replace('_', ' '))
+
+ def contribute_to_class(self, cls, name):
+ self.set_attributes_from_name(name)
+ cls._meta.add_field(self)
+ if self.choices:
+ setattr(cls, 'get_%s_display' % self.name, curry(cls._get_FIELD_display, field=self))
def set_name(self, name):
self.name = name
self.verbose_name = self.verbose_name or name.replace('_', ' ')
self.attname, self.column = self.get_attname_column()
+ def get_attname(self):
+ return self.name
+
def get_attname_column(self):
- if isinstance(self.rel, ManyToOneRel):
- attname = '%s_id' % self.name
- else:
- attname = self.name
+ attname = self.get_attname()
column = self.db_column or attname
return attname, column
@@ -198,8 +190,8 @@ class Field(object):
def get_default(self):
"Returns the default value for this field."
if self.default is not NOT_PROVIDED:
- if hasattr(self.default, '__get_value__'):
- return self.default.__get_value__()
+ if callable(self.default):
+ return self.default()
return self.default
if not self.empty_strings_allowed or self.null:
return None
@@ -211,42 +203,32 @@ class Field(object):
"""
return [name_prefix + self.name]
- def get_manipulator_fields(self, opts, manipulator, change, name_prefix='', rel=False):
+ def prepare_field_objs_and_params(self, manipulator, name_prefix):
+ params = {'validator_list': self.validator_list[:]}
+ if self.maxlength and not self.choices: # Don't give SelectFields a maxlength parameter.
+ params['maxlength'] = self.maxlength
+
+ if self.choices:
+ if self.radio_admin:
+ field_objs = [forms.RadioSelectField]
+ params['ul_class'] = get_ul_class(self.radio_admin)
+ else:
+ field_objs = [forms.SelectField]
+
+ params['choices'] = self.get_choices_default()
+ else:
+ field_objs = self.get_manipulator_field_objs()
+ return (field_objs, params)
+
+ def get_manipulator_fields(self, opts, manipulator, change, name_prefix='', rel=False, follow=True):
"""
- Returns a list of formfields.FormField instances for this field. It
+ Returns a list of forms.FormField instances for this field. It
calculates the choices at runtime, not at compile time.
name_prefix is a prefix to prepend to the "field_name" argument.
rel is a boolean specifying whether this field is in a related context.
"""
- params = {'validator_list': self.validator_list[:]}
- if self.maxlength and not self.choices: # Don't give SelectFields a maxlength parameter.
- params['maxlength'] = self.maxlength
- if isinstance(self.rel, ManyToOneRel):
- params['member_name'] = name_prefix + self.attname
- if self.rel.raw_id_admin:
- field_objs = self.get_manipulator_field_objs()
- params['validator_list'].append(curry(manipulator_valid_rel_key, self, manipulator))
- else:
- if self.radio_admin:
- field_objs = [formfields.RadioSelectField]
- params['ul_class'] = get_ul_class(self.radio_admin)
- else:
- if self.null:
- field_objs = [formfields.NullSelectField]
- else:
- field_objs = [formfields.SelectField]
- params['choices'] = self.get_choices_default()
- elif self.choices:
- if self.radio_admin:
- field_objs = [formfields.RadioSelectField]
- params['ul_class'] = get_ul_class(self.radio_admin)
- else:
- field_objs = [formfields.SelectField]
-
- params['choices'] = self.get_choices_default()
- else:
- field_objs = self.get_manipulator_field_objs()
+ field_objs, params = self.prepare_field_objs_and_params(manipulator, name_prefix)
# Add the "unique" validator(s).
for field_name_list in opts.unique_together:
@@ -269,6 +251,11 @@ class Field(object):
# RequiredIfOtherFieldGiven.
params['is_required'] = not self.blank and not self.primary_key and not rel
+ # BooleanFields (CheckboxFields) are a special case. They don't take
+ # is_required or validator_list.
+ if isinstance(self, BooleanField):
+ del params['validator_list'], params['is_required']
+
# If this field is in a related context, check whether any other fields
# in the related object have core=True. If so, add a validator --
# RequiredIfOtherFieldsGiven -- to this FormField.
@@ -282,15 +269,13 @@ class Field(object):
if core_field_names:
params['validator_list'].append(validators.RequiredIfOtherFieldsGiven(core_field_names, gettext_lazy("This field is required.")))
- # BooleanFields (CheckboxFields) are a special case. They don't take
- # is_required or validator_list.
- if isinstance(self, BooleanField):
- del params['validator_list'], params['is_required']
-
# Finally, add the field_names.
field_names = self.get_manipulator_field_names(name_prefix)
return [man(field_name=field_names[i], **params) for i, man in enumerate(field_objs)]
+ def get_validator_unique_lookup_type(self):
+ return '%s__exact' % self.name
+
def get_manipulator_new_data(self, new_data, rel=False):
"""
Given the full new_data dictionary (from the manipulator), returns this
@@ -298,32 +283,31 @@ class Field(object):
"""
if rel:
return new_data.get(self.name, [self.get_default()])[0]
- else:
- val = new_data.get(self.name, self.get_default())
- if not self.empty_strings_allowed and val == '' and self.null:
- val = None
- return val
+ val = new_data.get(self.name, self.get_default())
+ if not self.empty_strings_allowed and val == '' and self.null:
+ val = None
+ return val
def get_choices(self, include_blank=True, blank_choice=BLANK_CHOICE_DASH):
"Returns a list of tuples used as SelectField choices for this field."
first_choice = include_blank and blank_choice or []
if self.choices:
return first_choice + list(self.choices)
- rel_obj = self.rel.to
- return first_choice + [(getattr(x, rel_obj.pk.attname), str(x))
- for x in rel_obj.get_model_module().get_list(**self.rel.limit_choices_to)]
+ rel_model = self.rel.to
+ return first_choice + [(x._get_pk_val(), str(x))
+ for x in rel_model._default_manager.filter(**self.rel.limit_choices_to)]
def get_choices_default(self):
- if(self.radio_admin):
+ if self.radio_admin:
return self.get_choices(include_blank=self.blank, blank_choice=BLANK_CHOICE_NONE)
else:
return self.get_choices()
def _get_val_from_obj(self, obj):
if obj:
- return getattr(obj, self.attname)
+ return getattr(obj, self.attname)
else:
- return self.get_default()
+ return self.get_default()
def flatten_data(self, follow, obj=None):
"""
@@ -339,57 +323,101 @@ class Field(object):
else:
return self.editable
- def bind(self, fieldmapping, original, bound_field_class=BoundField):
+ def bind(self, fieldmapping, original, bound_field_class):
return bound_field_class(self, fieldmapping, original)
class AutoField(Field):
empty_strings_allowed = False
def __init__(self, *args, **kwargs):
assert kwargs.get('primary_key', False) is True, "%ss must have primary_key=True." % self.__class__.__name__
+ kwargs['blank'] = True
Field.__init__(self, *args, **kwargs)
- def get_manipulator_fields(self, opts, manipulator, change, name_prefix='', rel=False):
+ def to_python(self, value):
+ if value is None:
+ return value
+ try:
+ return int(value)
+ except (TypeError, ValueError):
+ raise validators.ValidationError, gettext("This value must be an integer.")
+
+ def get_manipulator_fields(self, opts, manipulator, change, name_prefix='', rel=False, follow=True):
if not rel:
return [] # Don't add a FormField unless it's in a related context.
- return Field.get_manipulator_fields(self, opts, manipulator, change, name_prefix, rel)
+ return Field.get_manipulator_fields(self, opts, manipulator, change, name_prefix, rel, follow)
def get_manipulator_field_objs(self):
- return [formfields.HiddenField]
+ return [forms.HiddenField]
def get_manipulator_new_data(self, new_data, rel=False):
+ # Never going to be called
+ # Not in main change pages
+ # ignored in related context
if not rel:
return None
return Field.get_manipulator_new_data(self, new_data, rel)
+ def contribute_to_class(self, cls, name):
+ assert not cls._meta.has_auto_field, "A model can't have more than one AutoField."
+ super(AutoField, self).contribute_to_class(cls, name)
+ cls._meta.has_auto_field = True
+
class BooleanField(Field):
def __init__(self, *args, **kwargs):
kwargs['blank'] = True
Field.__init__(self, *args, **kwargs)
+ def to_python(self, value):
+ if value in (True, False): return value
+ if value is 't': return True
+ if value is 'f': return False
+ raise validators.ValidationError, gettext("This value must be either True or False.")
+
def get_manipulator_field_objs(self):
- return [formfields.CheckboxField]
+ return [forms.CheckboxField]
class CharField(Field):
def get_manipulator_field_objs(self):
- return [formfields.TextField]
+ return [forms.TextField]
+ def to_python(self, value):
+ if isinstance(value, basestring):
+ return value
+ if value is None:
+ if self.null:
+ return value
+ else:
+ raise validators.ValidationError, gettext_lazy("This field cannot be null.")
+ return str(value)
+
+# TODO: Maybe move this into contrib, because it's specialized.
class CommaSeparatedIntegerField(CharField):
def get_manipulator_field_objs(self):
- return [formfields.CommaSeparatedIntegerField]
+ return [forms.CommaSeparatedIntegerField]
class DateField(Field):
empty_strings_allowed = False
def __init__(self, verbose_name=None, name=None, auto_now=False, auto_now_add=False, **kwargs):
self.auto_now, self.auto_now_add = auto_now, auto_now_add
- #HACKs : auto_now_add/auto_now should be done as a default or a pre_save...
+ #HACKs : auto_now_add/auto_now should be done as a default or a pre_save.
if auto_now or auto_now_add:
kwargs['editable'] = False
kwargs['blank'] = True
Field.__init__(self, verbose_name, name, **kwargs)
+ def to_python(self, value):
+ if isinstance(value, datetime.datetime):
+ return value.date()
+ if isinstance(value, datetime.date):
+ return value
+ validators.isValidANSIDate(value, None)
+ return datetime.date(*time.strptime(value, '%Y-%m-%d')[:3])
+
def get_db_prep_lookup(self, lookup_type, value):
if lookup_type == 'range':
value = [str(v) for v in value]
+ elif lookup_type in ('exact', 'gt', 'gte', 'lt', 'lte', 'ne'):
+ value = value.strftime('%Y-%m-%d')
else:
value = str(value)
return Field.get_db_prep_lookup(self, lookup_type, value)
@@ -399,6 +427,14 @@ class DateField(Field):
return datetime.datetime.now()
return value
+ def contribute_to_class(self, cls, name):
+ super(DateField,self).contribute_to_class(cls, name)
+ if not self.null:
+ setattr(cls, 'get_next_by_%s' % self.name,
+ curry(cls._get_next_or_previous_by_FIELD, field=self, is_next=True))
+ setattr(cls, 'get_previous_by_%s' % self.name,
+ curry(cls._get_next_or_previous_by_FIELD, field=self, is_next=False))
+
# Needed because of horrible auto_now[_add] behaviour wrt. editable
def get_follow(self, override=None):
if override != None:
@@ -413,13 +449,29 @@ class DateField(Field):
return Field.get_db_prep_save(self, value)
def get_manipulator_field_objs(self):
- return [formfields.DateField]
+ return [forms.DateField]
def flatten_data(self, follow, obj = None):
val = self._get_val_from_obj(obj)
return {self.attname: (val is not None and val.strftime("%Y-%m-%d") or '')}
class DateTimeField(DateField):
+ def to_python(self, value):
+ if isinstance(value, datetime.datetime):
+ return value
+ if isinstance(value, datetime.date):
+ return datetime.datetime(value.year, value.month, value.day)
+ try: # Seconds are optional, so try converting seconds first.
+ return datetime.datetime(*time.strptime(value, '%Y-%m-%d %H:%M:%S')[:6])
+ except ValueError:
+ try: # Try without seconds.
+ return datetime.datetime(*time.strptime(value, '%Y-%m-%d %H:%M')[:5])
+ except ValueError: # Try without hour/minutes/seconds.
+ try:
+ return datetime.datetime(*time.strptime(value, '%Y-%m-%d')[:3])
+ except ValueError:
+ raise validators.ValidationError, gettext('Enter a valid date/time in YYYY-MM-DD HH:MM format.')
+
def get_db_prep_save(self, value):
# Casts dates into string format for entry into database.
if value is not None:
@@ -430,8 +482,15 @@ class DateTimeField(DateField):
value = str(value)
return Field.get_db_prep_save(self, value)
+ def get_db_prep_lookup(self, lookup_type, value):
+ if lookup_type == 'range':
+ value = [str(v) for v in value]
+ else:
+ value = str(value)
+ return Field.get_db_prep_lookup(self, lookup_type, value)
+
def get_manipulator_field_objs(self):
- return [formfields.DateField, formfields.TimeField]
+ return [forms.DateField, forms.TimeField]
def get_manipulator_field_names(self, name_prefix):
return [name_prefix + self.name + '_date', name_prefix + self.name + '_time']
@@ -454,25 +513,27 @@ class DateTimeField(DateField):
return {date_field: (val is not None and val.strftime("%Y-%m-%d") or ''),
time_field: (val is not None and val.strftime("%H:%M:%S") or '')}
-class EmailField(Field):
+class EmailField(CharField):
def __init__(self, *args, **kwargs):
kwargs['maxlength'] = 75
- Field.__init__(self, *args, **kwargs)
+ CharField.__init__(self, *args, **kwargs)
def get_internal_type(self):
return "CharField"
def get_manipulator_field_objs(self):
- return [formfields.EmailField]
+ return [forms.EmailField]
+
+ def validate(self, field_data, all_data):
+ validators.isValidEmail(field_data, all_data)
class FileField(Field):
def __init__(self, verbose_name=None, name=None, upload_to='', **kwargs):
self.upload_to = upload_to
Field.__init__(self, verbose_name, name, **kwargs)
- def get_manipulator_fields(self, opts, manipulator, change, name_prefix='', rel=False):
- field_list = Field.get_manipulator_fields(self, opts, manipulator, change, name_prefix, rel)
-
+ def get_manipulator_fields(self, opts, manipulator, change, name_prefix='', rel=False, follow=True):
+ field_list = Field.get_manipulator_fields(self, opts, manipulator, change, name_prefix, rel, follow)
if not self.blank:
if rel:
# This validator makes sure FileFields work in a related context.
@@ -507,8 +568,25 @@ class FileField(Field):
field_list[1].validator_list.append(isWithinMediaRoot)
return field_list
+ def contribute_to_class(self, cls, name):
+ super(FileField, self).contribute_to_class(cls, name)
+ setattr(cls, 'get_%s_filename' % self.name, curry(cls._get_FIELD_filename, field=self))
+ setattr(cls, 'get_%s_url' % self.name, curry(cls._get_FIELD_url, field=self))
+ setattr(cls, 'get_%s_size' % self.name, curry(cls._get_FIELD_size, field=self))
+ setattr(cls, 'save_%s_file' % self.name, lambda instance, filename, raw_contents: instance._save_FIELD_file(self, filename, raw_contents))
+ dispatcher.connect(self.delete_file, signal=signals.post_delete, sender=cls)
+
+ def delete_file(self, instance):
+ if getattr(instance, self.attname):
+ file_name = getattr(instance, 'get_%s_filename' % self.name)()
+ # If the file exists and no other object of this type references it,
+ # delete it from the filesystem.
+ if os.path.exists(file_name) and \
+ not instance.__class__._default_manager.filter(**{'%s__exact' % self.name: getattr(instance, self.attname)}):
+ os.remove(file_name)
+
def get_manipulator_field_objs(self):
- return [formfields.FileUploadField, formfields.HiddenField]
+ return [forms.FileUploadField, forms.HiddenField]
def get_manipulator_field_names(self, name_prefix):
return [name_prefix + self.name + '_file', name_prefix + self.name]
@@ -536,7 +614,7 @@ class FilePathField(Field):
Field.__init__(self, verbose_name, name, **kwargs)
def get_manipulator_field_objs(self):
- return [curry(formfields.FilePathField, path=self.path, match=self.match, recursive=self.recursive)]
+ return [curry(forms.FilePathField, path=self.path, match=self.match, recursive=self.recursive)]
class FloatField(Field):
empty_strings_allowed = False
@@ -545,7 +623,7 @@ class FloatField(Field):
Field.__init__(self, verbose_name, name, **kwargs)
def get_manipulator_field_objs(self):
- return [curry(formfields.FloatField, max_digits=self.max_digits, decimal_places=self.decimal_places)]
+ return [curry(forms.FloatField, max_digits=self.max_digits, decimal_places=self.decimal_places)]
class ImageField(FileField):
def __init__(self, verbose_name=None, name=None, width_field=None, height_field=None, **kwargs):
@@ -553,7 +631,16 @@ class ImageField(FileField):
FileField.__init__(self, verbose_name, name, **kwargs)
def get_manipulator_field_objs(self):
- return [formfields.ImageUploadField, formfields.HiddenField]
+ return [forms.ImageUploadField, forms.HiddenField]
+
+ def contribute_to_class(self, cls, name):
+ super(ImageField, self).contribute_to_class(cls, name)
+ # Add get_BLAH_width and get_BLAH_height methods, but only if the
+ # image field doesn't have width and height cache fields.
+ if not self.width_field:
+ setattr(cls, 'get_%s_width' % self.name, curry(cls._get_FIELD_width, field=self))
+ if not self.height_field:
+ setattr(cls, 'get_%s_height' % self.name, curry(cls._get_FIELD_height, field=self))
def save_file(self, new_data, new_object, original_object, change, rel):
FileField.save_file(self, new_data, new_object, original_object, change, rel)
@@ -570,7 +657,7 @@ class ImageField(FileField):
class IntegerField(Field):
empty_strings_allowed = False
def get_manipulator_field_objs(self):
- return [formfields.IntegerField]
+ return [forms.IntegerField]
class IPAddressField(Field):
def __init__(self, *args, **kwargs):
@@ -578,7 +665,10 @@ class IPAddressField(Field):
Field.__init__(self, *args, **kwargs)
def get_manipulator_field_objs(self):
- return [formfields.IPAddressField]
+ return [forms.IPAddressField]
+
+ def validate(self, field_data, all_data):
+ validators.isValidIPAddress4(field_data, None)
class NullBooleanField(Field):
def __init__(self, *args, **kwargs):
@@ -586,23 +676,25 @@ class NullBooleanField(Field):
Field.__init__(self, *args, **kwargs)
def get_manipulator_field_objs(self):
- return [formfields.NullBooleanField]
+ return [forms.NullBooleanField]
class PhoneNumberField(IntegerField):
def get_manipulator_field_objs(self):
- return [formfields.PhoneNumberField]
+ return [forms.PhoneNumberField]
+
+ def validate(self, field_data, all_data):
+ validators.isValidPhone(field_data, all_data)
class PositiveIntegerField(IntegerField):
def get_manipulator_field_objs(self):
- return [formfields.PositiveIntegerField]
+ return [forms.PositiveIntegerField]
class PositiveSmallIntegerField(IntegerField):
def get_manipulator_field_objs(self):
- return [formfields.PositiveSmallIntegerField]
+ return [forms.PositiveSmallIntegerField]
class SlugField(Field):
def __init__(self, *args, **kwargs):
- # Default to a maxlength of 50 but allow overrides.
kwargs['maxlength'] = kwargs.get('maxlength', 50)
kwargs.setdefault('validator_list', []).append(validators.isSlug)
# Set db_index=True unless it's been set manually.
@@ -611,20 +703,20 @@ class SlugField(Field):
Field.__init__(self, *args, **kwargs)
def get_manipulator_field_objs(self):
- return [formfields.TextField]
+ return [forms.TextField]
class SmallIntegerField(IntegerField):
def get_manipulator_field_objs(self):
- return [formfields.SmallIntegerField]
+ return [forms.SmallIntegerField]
class TextField(Field):
def get_manipulator_field_objs(self):
- return [formfields.LargeTextField]
+ return [forms.LargeTextField]
class TimeField(Field):
empty_strings_allowed = False
def __init__(self, verbose_name=None, name=None, auto_now=False, auto_now_add=False, **kwargs):
- self.auto_now, self.auto_now_add = auto_now, auto_now_add
+ self.auto_now, self.auto_now_add = auto_now, auto_now_add
if auto_now or auto_now_add:
kwargs['editable'] = False
Field.__init__(self, verbose_name, name, **kwargs)
@@ -652,7 +744,7 @@ class TimeField(Field):
return Field.get_db_prep_save(self, value)
def get_manipulator_field_objs(self):
- return [formfields.TimeField]
+ return [forms.TimeField]
def flatten_data(self,follow, obj = None):
val = self._get_val_from_obj(obj)
@@ -665,11 +757,11 @@ class URLField(Field):
Field.__init__(self, verbose_name, name, **kwargs)
def get_manipulator_field_objs(self):
- return [formfields.URLField]
+ return [forms.URLField]
class USStateField(Field):
def get_manipulator_field_objs(self):
- return [formfields.USStateField]
+ return [forms.USStateField]
class XMLField(TextField):
def __init__(self, verbose_name=None, name=None, schema_path=None, **kwargs):
@@ -680,277 +772,17 @@ class XMLField(TextField):
return "TextField"
def get_manipulator_field_objs(self):
- return [curry(formfields.XMLLargeTextField, schema_path=self.schema_path)]
+ return [curry(forms.XMLLargeTextField, schema_path=self.schema_path)]
-class ForeignKey(Field):
- empty_strings_allowed = False
- def __init__(self, to, to_field=None, **kwargs):
- try:
- to_name = to._meta.object_name.lower()
- except AttributeError: # to._meta doesn't exist, so it must be RECURSIVE_RELATIONSHIP_CONSTANT
- assert to == 'self', "ForeignKey(%r) is invalid. First parameter to ForeignKey must be either a model or the string %r" % (to, RECURSIVE_RELATIONSHIP_CONSTANT)
- else:
- to_field = to_field or to._meta.pk.name
- kwargs['verbose_name'] = kwargs.get('verbose_name', '')
+class OrderingField(IntegerField):
+ empty_strings_allowed=False
+ def __init__(self, with_respect_to, **kwargs):
+ self.wrt = with_respect_to
+ kwargs['null'] = True
+ IntegerField.__init__(self, **kwargs )
- if kwargs.has_key('edit_inline_type'):
- import warnings
- warnings.warn("edit_inline_type is deprecated. Use edit_inline instead.")
- kwargs['edit_inline'] = kwargs.pop('edit_inline_type')
+ def get_internal_type(self):
+ return "IntegerField"
- kwargs['rel'] = ManyToOneRel(to, to_field,
- num_in_admin=kwargs.pop('num_in_admin', 3),
- min_num_in_admin=kwargs.pop('min_num_in_admin', None),
- max_num_in_admin=kwargs.pop('max_num_in_admin', None),
- num_extra_on_change=kwargs.pop('num_extra_on_change', 1),
- edit_inline=kwargs.pop('edit_inline', False),
- related_name=kwargs.pop('related_name', None),
- limit_choices_to=kwargs.pop('limit_choices_to', None),
- lookup_overrides=kwargs.pop('lookup_overrides', None),
- raw_id_admin=kwargs.pop('raw_id_admin', False))
- Field.__init__(self, **kwargs)
-
- def get_manipulator_field_objs(self):
- rel_field = self.rel.get_related_field()
- if self.rel.raw_id_admin and not isinstance(rel_field, AutoField):
- return rel_field.get_manipulator_field_objs()
- else:
- return [formfields.IntegerField]
-
- def get_db_prep_save(self,value):
- if value == '' or value == None:
- return None
- else:
- return self.rel.get_related_field().get_db_prep_save(value)
-
- def flatten_data(self, follow, obj=None):
- if not obj:
- # In required many-to-one fields with only one available choice,
- # select that one available choice. Note: For SelectFields
- # (radio_admin=False), we have to check that the length of choices
- # is *2*, not 1, because SelectFields always have an initial
- # "blank" value. Otherwise (radio_admin=True), we check that the
- # length is 1.
- if not self.blank and (not self.rel.raw_id_admin or self.choices):
- choice_list = self.get_choices_default()
- if self.radio_admin and len(choice_list) == 1:
- return {self.attname: choice_list[0][0]}
- if not self.radio_admin and len(choice_list) == 2:
- return {self.attname: choice_list[1][0]}
- return Field.flatten_data(self, follow, obj)
-
-class ManyToManyField(Field):
- def __init__(self, to, **kwargs):
- kwargs['verbose_name'] = kwargs.get('verbose_name', to._meta.verbose_name_plural)
- kwargs['rel'] = ManyToManyRel(to, kwargs.pop('singular', None),
- num_in_admin=kwargs.pop('num_in_admin', 0),
- related_name=kwargs.pop('related_name', None),
- filter_interface=kwargs.pop('filter_interface', None),
- limit_choices_to=kwargs.pop('limit_choices_to', None),
- raw_id_admin=kwargs.pop('raw_id_admin', False))
- if kwargs["rel"].raw_id_admin:
- kwargs.setdefault("validator_list", []).append(self.isValidIDList)
- Field.__init__(self, **kwargs)
-
- def get_manipulator_field_objs(self):
- if self.rel.raw_id_admin:
- return [formfields.RawIdAdminField]
- else:
- choices = self.get_choices_default()
- return [curry(formfields.SelectMultipleField, size=min(max(len(choices), 5), 15), choices=choices)]
-
- def get_choices_default(self):
- return Field.get_choices(self, include_blank=False)
-
- def get_m2m_db_table(self, original_opts):
- "Returns the name of the many-to-many 'join' table."
- return '%s_%s' % (original_opts.db_table, self.name)
-
- def isValidIDList(self, field_data, all_data):
- "Validates that the value is a valid list of foreign keys"
- mod = self.rel.to.get_model_module()
- try:
- pks = map(int, field_data.split(','))
- except ValueError:
- # the CommaSeparatedIntegerField validator will catch this error
- return
- objects = mod.get_in_bulk(pks)
- if len(objects) != len(pks):
- badkeys = [k for k in pks if k not in objects]
- raise validators.ValidationError, ngettext("Please enter valid %(self)s IDs. The value %(value)r is invalid.",
- "Please enter valid %(self)s IDs. The values %(value)r are invalid.", len(badkeys)) % {
- 'self': self.verbose_name,
- 'value': len(badkeys) == 1 and badkeys[0] or tuple(badkeys),
- }
-
- def flatten_data(self, follow, obj = None):
- new_data = {}
- if obj:
- get_list_func = getattr(obj, 'get_%s_list' % self.rel.singular)
- instance_ids = [getattr(instance, self.rel.to.pk.attname) for instance in get_list_func()]
- if self.rel.raw_id_admin:
- new_data[self.name] = ",".join([str(id) for id in instance_ids])
- else:
- new_data[self.name] = instance_ids
- else:
- # In required many-to-many fields with only one available choice,
- # select that one available choice.
- if not self.blank and not self.rel.edit_inline and not self.rel.raw_id_admin:
- choices_list = self.get_choices_default()
- if len(choices_list) == 1:
- new_data[self.name] = [choices_list[0][0]]
- return new_data
-
-class OneToOneField(IntegerField):
- def __init__(self, to, to_field=None, **kwargs):
- kwargs['verbose_name'] = kwargs.get('verbose_name', 'ID')
- to_field = to_field or to._meta.pk.name
-
- if kwargs.has_key('edit_inline_type'):
- import warnings
- warnings.warn("edit_inline_type is deprecated. Use edit_inline instead.")
- kwargs['edit_inline'] = kwargs.pop('edit_inline_type')
-
- kwargs['rel'] = OneToOneRel(to, to_field,
- num_in_admin=kwargs.pop('num_in_admin', 0),
- edit_inline=kwargs.pop('edit_inline', False),
- related_name=kwargs.pop('related_name', None),
- limit_choices_to=kwargs.pop('limit_choices_to', None),
- lookup_overrides=kwargs.pop('lookup_overrides', None),
- raw_id_admin=kwargs.pop('raw_id_admin', False))
- kwargs['primary_key'] = True
- IntegerField.__init__(self, **kwargs)
-
-class ManyToOneRel:
- def __init__(self, to, field_name, num_in_admin=3, min_num_in_admin=None,
- max_num_in_admin=None, num_extra_on_change=1, edit_inline=False,
- related_name=None, limit_choices_to=None, lookup_overrides=None, raw_id_admin=False):
- try:
- self.to = to._meta
- except AttributeError: # to._meta doesn't exist, so it must be RECURSIVE_RELATIONSHIP_CONSTANT
- assert to == RECURSIVE_RELATIONSHIP_CONSTANT, "'to' must be either a model or the string '%s'" % RECURSIVE_RELATIONSHIP_CONSTANT
- self.to = to
- self.field_name = field_name
- self.num_in_admin, self.edit_inline = num_in_admin, edit_inline
- self.min_num_in_admin, self.max_num_in_admin = min_num_in_admin, max_num_in_admin
- self.num_extra_on_change, self.related_name = num_extra_on_change, related_name
- self.limit_choices_to = limit_choices_to or {}
- self.lookup_overrides = lookup_overrides or {}
- self.raw_id_admin = raw_id_admin
-
- def get_related_field(self):
- "Returns the Field in the 'to' object to which this relationship is tied."
- return self.to.get_field(self.field_name)
-
-class ManyToManyRel:
- def __init__(self, to, singular=None, num_in_admin=0, related_name=None,
- filter_interface=None, limit_choices_to=None, raw_id_admin=False):
- self.to = to._meta
- self.singular = singular or to._meta.object_name.lower()
- self.num_in_admin = num_in_admin
- self.related_name = related_name
- self.filter_interface = filter_interface
- self.limit_choices_to = limit_choices_to or {}
- self.edit_inline = False
- self.raw_id_admin = raw_id_admin
- assert not (self.raw_id_admin and self.filter_interface), "ManyToManyRels may not use both raw_id_admin and filter_interface"
-
-class OneToOneRel(ManyToOneRel):
- def __init__(self, to, field_name, num_in_admin=0, edit_inline=False,
- related_name=None, limit_choices_to=None, lookup_overrides=None,
- raw_id_admin=False):
- self.to, self.field_name = to._meta, field_name
- self.num_in_admin, self.edit_inline = num_in_admin, edit_inline
- self.related_name = related_name
- self.limit_choices_to = limit_choices_to or {}
- self.lookup_overrides = lookup_overrides or {}
- self.raw_id_admin = raw_id_admin
-
-class BoundFieldLine(object):
- def __init__(self, field_line, field_mapping, original, bound_field_class=BoundField):
- self.bound_fields = [field.bind(field_mapping, original, bound_field_class) for field in field_line]
-
- def __iter__(self):
- for bound_field in self.bound_fields:
- yield bound_field
-
- def __len__(self):
- return len(self.bound_fields)
-
-class FieldLine(object):
- def __init__(self, field_locator_func, linespec):
- if isinstance(linespec, basestring):
- self.fields = [field_locator_func(linespec)]
- else:
- self.fields = [field_locator_func(field_name) for field_name in linespec]
-
- def bind(self, field_mapping, original, bound_field_line_class=BoundFieldLine):
- return bound_field_line_class(self, field_mapping, original)
-
- def __iter__(self):
- for field in self.fields:
- yield field
-
- def __len__(self):
- return len(self.fields)
-
-class BoundFieldSet(object):
- def __init__(self, field_set, field_mapping, original, bound_field_line_class=BoundFieldLine):
- self.name = field_set.name
- self.classes = field_set.classes
- self.bound_field_lines = [field_line.bind(field_mapping,original, bound_field_line_class) for field_line in field_set]
-
- def __iter__(self):
- for bound_field_line in self.bound_field_lines:
- yield bound_field_line
-
- def __len__(self):
- return len(self.bound_field_lines)
-
-class FieldSet(object):
- def __init__(self, name, classes, field_locator_func, line_specs):
- self.name = name
- self.field_lines = [FieldLine(field_locator_func, line_spec) for line_spec in line_specs]
- self.classes = classes
-
- def __repr__(self):
- return "FieldSet:(%s,%s)" % (self.name, self.field_lines)
-
- def bind(self, field_mapping, original, bound_field_set_class=BoundFieldSet):
- return bound_field_set_class(self, field_mapping, original)
-
- def __iter__(self):
- for field_line in self.field_lines:
- yield field_line
-
- def __len__(self):
- return len(self.field_lines)
-
-class Admin:
- def __init__(self, fields=None, js=None, list_display=None, list_filter=None, date_hierarchy=None,
- save_as=False, ordering=None, search_fields=None, save_on_top=False, list_select_related=False):
- self.fields = fields
- self.js = js or []
- self.list_display = list_display or ['__repr__']
- self.list_filter = list_filter or []
- self.date_hierarchy = date_hierarchy
- self.save_as, self.ordering = save_as, ordering
- self.search_fields = search_fields or []
- self.save_on_top = save_on_top
- self.list_select_related = list_select_related
-
- def get_field_sets(self, opts):
- if self.fields is None:
- field_struct = ((None, {
- 'fields': [f.name for f in opts.fields + opts.many_to_many if f.editable and not isinstance(f, AutoField)]
- }),)
- else:
- field_struct = self.fields
- new_fieldset_list = []
- for fieldset in field_struct:
- name = fieldset[0]
- fs_options = fieldset[1]
- classes = fs_options.get('classes', ())
- line_specs = fs_options['fields']
- new_fieldset_list.append(FieldSet(name, classes, opts.get_field, line_specs))
- return new_fieldset_list
+ def get_manipulator_fields(self, opts, manipulator, change, name_prefix='', rel=False, follow=True):
+ return [forms.HiddenField(name_prefix + self.name)]
diff --git a/django/db/models/fields/related.py b/django/db/models/fields/related.py
new file mode 100644
index 0000000000..908aa75207
--- /dev/null
+++ b/django/db/models/fields/related.py
@@ -0,0 +1,718 @@
+from django.db import backend, connection, transaction
+from django.db.models import signals
+from django.db.models.fields import AutoField, Field, IntegerField, get_ul_class
+from django.db.models.related import RelatedObject
+from django.utils.translation import gettext_lazy, string_concat
+from django.utils.functional import curry
+from django.core import validators
+from django import forms
+from django.dispatch import dispatcher
+
+# For Python 2.3
+if not hasattr(__builtins__, 'set'):
+ from sets import Set as set
+
+# Values for Relation.edit_inline.
+TABULAR, STACKED = 1, 2
+
+RECURSIVE_RELATIONSHIP_CONSTANT = 'self'
+
+pending_lookups = {}
+
+def add_lookup(rel_cls, field):
+ name = field.rel.to
+ module = rel_cls.__module__
+ key = (module, name)
+ pending_lookups.setdefault(key, []).append((rel_cls, field))
+
+def do_pending_lookups(sender):
+ other_cls = sender
+ key = (other_cls.__module__, other_cls.__name__)
+ for rel_cls, field in pending_lookups.setdefault(key, []):
+ field.rel.to = other_cls
+ field.do_related_class(other_cls, rel_cls)
+
+dispatcher.connect(do_pending_lookups, signal=signals.class_prepared)
+
+def manipulator_valid_rel_key(f, self, field_data, all_data):
+ "Validates that the value is a valid foreign key"
+ klass = f.rel.to
+ try:
+ klass._default_manager.get(pk=field_data)
+ except klass.DoesNotExist:
+ raise validators.ValidationError, _("Please enter a valid %s.") % f.verbose_name
+
+#HACK
+class RelatedField(object):
+ def contribute_to_class(self, cls, name):
+ sup = super(RelatedField, self)
+
+ # Add an accessor to allow easy determination of the related query path for this field
+ self.related_query_name = curry(self._get_related_query_name, cls._meta)
+
+ if hasattr(sup, 'contribute_to_class'):
+ sup.contribute_to_class(cls, name)
+ other = self.rel.to
+ if isinstance(other, basestring):
+ if other == RECURSIVE_RELATIONSHIP_CONSTANT:
+ self.rel.to = cls.__name__
+ add_lookup(cls, self)
+ else:
+ self.do_related_class(other, cls)
+
+ def set_attributes_from_rel(self):
+ self.name = self.name or (self.rel.to._meta.object_name.lower() + '_' + self.rel.to._meta.pk.name)
+ self.verbose_name = self.verbose_name or self.rel.to._meta.verbose_name
+ self.rel.field_name = self.rel.field_name or self.rel.to._meta.pk.name
+
+ def do_related_class(self, other, cls):
+ self.set_attributes_from_rel()
+ related = RelatedObject(other, cls, self)
+ self.contribute_to_related_class(other, related)
+
+ def _get_related_query_name(self, opts):
+ # This method defines the name that can be used to identify this related object
+ # in a table-spanning query. It uses the lower-cased object_name by default,
+ # but this can be overridden with the "related_name" option.
+ return self.rel.related_name or opts.object_name.lower()
+
+class SingleRelatedObjectDescriptor(object):
+ # This class provides the functionality that makes the related-object
+ # managers available as attributes on a model class, for fields that have
+ # a single "remote" value, on the class pointed to by a related field.
+ # In the example "place.restaurant", the restaurant attribute is a
+ # SingleRelatedObjectDescriptor instance.
+ def __init__(self, related):
+ self.related = related
+
+ def __get__(self, instance, instance_type=None):
+ if instance is None:
+ raise AttributeError, "%s must be accessed via instance" % self.related.opts.object_name
+
+ params = {'%s__pk' % self.related.field.name: instance._get_pk_val()}
+ rel_obj = self.related.model._default_manager.get(**params)
+ return rel_obj
+
+ def __set__(self, instance, value):
+ if instance is None:
+ raise AttributeError, "%s must be accessed via instance" % self.related.opts.object_name
+ # Set the value of the related field
+ setattr(value, self.related.field.rel.get_related_field().attname, instance)
+
+ # Clear the cache, if it exists
+ try:
+ delattr(value, self.related.field.get_cache_name())
+ except AttributeError:
+ pass
+
+class ReverseSingleRelatedObjectDescriptor(object):
+ # This class provides the functionality that makes the related-object
+ # managers available as attributes on a model class, for fields that have
+ # a single "remote" value, on the class that defines the related field.
+ # In the example "choice.poll", the poll attribute is a
+ # ReverseSingleRelatedObjectDescriptor instance.
+ def __init__(self, field_with_rel):
+ self.field = field_with_rel
+
+ def __get__(self, instance, instance_type=None):
+ if instance is None:
+ raise AttributeError, "%s must be accessed via instance" % self.field.name
+ cache_name = self.field.get_cache_name()
+ try:
+ return getattr(instance, cache_name)
+ except AttributeError:
+ val = getattr(instance, self.field.attname)
+ if val is None:
+ # If NULL is an allowed value, return it.
+ if self.field.null:
+ return None
+ raise self.field.rel.to.DoesNotExist
+ other_field = self.field.rel.get_related_field()
+ if other_field.rel:
+ params = {'%s__pk' % self.field.rel.field_name: val}
+ else:
+ params = {'%s__exact' % self.field.rel.field_name: val}
+ rel_obj = self.field.rel.to._default_manager.get(**params)
+ setattr(instance, cache_name, rel_obj)
+ return rel_obj
+
+ def __set__(self, instance, value):
+ if instance is None:
+ raise AttributeError, "%s must be accessed via instance" % self._field.name
+ # Set the value of the related field
+ try:
+ val = getattr(value, self.field.rel.get_related_field().attname)
+ except AttributeError:
+ val = None
+ setattr(instance, self.field.attname, val)
+
+ # Clear the cache, if it exists
+ try:
+ delattr(instance, self.field.get_cache_name())
+ except AttributeError:
+ pass
+
+class ForeignRelatedObjectsDescriptor(object):
+ # This class provides the functionality that makes the related-object
+ # managers available as attributes on a model class, for fields that have
+ # multiple "remote" values and have a ForeignKey pointed at them by
+ # some other model. In the example "poll.choice_set", the choice_set
+ # attribute is a ForeignRelatedObjectsDescriptor instance.
+ def __init__(self, related):
+ self.related = related # RelatedObject instance
+
+ def __get__(self, instance, instance_type=None):
+ if instance is None:
+ raise AttributeError, "Manager must be accessed via instance"
+
+ rel_field = self.related.field
+ rel_model = self.related.model
+
+ # Dynamically create a class that subclasses the related
+ # model's default manager.
+ superclass = self.related.model._default_manager.__class__
+
+ class RelatedManager(superclass):
+ def get_query_set(self):
+ return superclass.get_query_set(self).filter(**(self.core_filters))
+
+ def add(self, *objs):
+ for obj in objs:
+ setattr(obj, rel_field.name, instance)
+ obj.save()
+ add.alters_data = True
+
+ def create(self, **kwargs):
+ new_obj = self.model(**kwargs)
+ self.add(new_obj)
+ return new_obj
+ create.alters_data = True
+
+ # remove() and clear() are only provided if the ForeignKey can have a value of null.
+ if rel_field.null:
+ def remove(self, *objs):
+ val = getattr(instance, rel_field.rel.get_related_field().attname)
+ for obj in objs:
+ # Is obj actually part of this descriptor set?
+ if getattr(obj, rel_field.attname) == val:
+ setattr(obj, rel_field.name, None)
+ obj.save()
+ else:
+ raise rel_field.rel.to.DoesNotExist, "'%s' is not related to '%s'." % (obj, instance)
+ remove.alters_data = True
+
+ def clear(self):
+ for obj in self.all():
+ setattr(obj, rel_field.name, None)
+ obj.save()
+ clear.alters_data = True
+
+ manager = RelatedManager()
+ manager.core_filters = {'%s__pk' % rel_field.name: getattr(instance, rel_field.rel.get_related_field().attname)}
+ manager.model = self.related.model
+
+ return manager
+
+ def __set__(self, instance, value):
+ if instance is None:
+ raise AttributeError, "Manager must be accessed via instance"
+
+ manager = self.__get__(instance)
+ # If the foreign key can support nulls, then completely clear the related set.
+ # Otherwise, just move the named objects into the set.
+ if self.related.field.null:
+ manager.clear()
+ for obj in value:
+ manager.add(obj)
+
+def create_many_related_manager(superclass):
+ """Creates a manager that subclasses 'superclass' (which is a Manager)
+ and adds behavior for many-to-many related objects."""
+ class ManyRelatedManager(superclass):
+ def __init__(self, model=None, core_filters=None, instance=None, symmetrical=None,
+ join_table=None, source_col_name=None, target_col_name=None):
+ super(ManyRelatedManager, self).__init__()
+ self.core_filters = core_filters
+ self.model = model
+ self.symmetrical = symmetrical
+ self.instance = instance
+ self.join_table = join_table
+ self.source_col_name = source_col_name
+ self.target_col_name = target_col_name
+ if instance:
+ self._pk_val = self.instance._get_pk_val()
+
+ def get_query_set(self):
+ return superclass.get_query_set(self).filter(**(self.core_filters))
+
+ def add(self, *objs):
+ self._add_items(self.source_col_name, self.target_col_name, *objs)
+
+ # If this is a symmetrical m2m relation to self, add the mirror entry in the m2m table
+ if self.symmetrical:
+ self._add_items(self.target_col_name, self.source_col_name, *objs)
+ add.alters_data = True
+
+ def remove(self, *objs):
+ self._remove_items(self.source_col_name, self.target_col_name, *objs)
+
+ # If this is a symmetrical m2m relation to self, remove the mirror entry in the m2m table
+ if self.symmetrical:
+ self._remove_items(self.target_col_name, self.source_col_name, *objs)
+ remove.alters_data = True
+
+ def clear(self):
+ self._clear_items(self.source_col_name)
+
+ # If this is a symmetrical m2m relation to self, clear the mirror entry in the m2m table
+ if self.symmetrical:
+ self._clear_items(self.target_col_name)
+ clear.alters_data = True
+
+ def create(self, **kwargs):
+ new_obj = self.model(**kwargs)
+ new_obj.save()
+ self.add(new_obj)
+ return new_obj
+ create.alters_data = True
+
+ def _add_items(self, source_col_name, target_col_name, *objs):
+ # join_table: name of the m2m link table
+ # source_col_name: the PK colname in join_table for the source object
+ # target_col_name: the PK colname in join_table for the target object
+ # *objs - objects to add
+ from django.db import connection
+
+ # Add the newly created or already existing objects to the join table.
+ # First find out which items are already added, to avoid adding them twice
+ new_ids = set([obj._get_pk_val() for obj in objs])
+ cursor = connection.cursor()
+ cursor.execute("SELECT %s FROM %s WHERE %s = %%s AND %s IN (%s)" % \
+ (target_col_name, self.join_table, source_col_name,
+ target_col_name, ",".join(['%s'] * len(new_ids))),
+ [self._pk_val] + list(new_ids))
+ if cursor.rowcount is not None and cursor.rowcount != 0:
+ existing_ids = set([row[0] for row in cursor.fetchmany(cursor.rowcount)])
+ else:
+ existing_ids = set()
+
+ # Add the ones that aren't there already
+ for obj_id in (new_ids - existing_ids):
+ cursor.execute("INSERT INTO %s (%s, %s) VALUES (%%s, %%s)" % \
+ (self.join_table, source_col_name, target_col_name),
+ [self._pk_val, obj_id])
+ transaction.commit_unless_managed()
+
+ def _remove_items(self, source_col_name, target_col_name, *objs):
+ # source_col_name: the PK colname in join_table for the source object
+ # target_col_name: the PK colname in join_table for the target object
+ # *objs - objects to remove
+ from django.db import connection
+
+ for obj in objs:
+ if not isinstance(obj, self.model):
+ raise ValueError, "objects to remove() must be %s instances" % self.model._meta.object_name
+ # Remove the specified objects from the join table
+ cursor = connection.cursor()
+ for obj in objs:
+ cursor.execute("DELETE FROM %s WHERE %s = %%s AND %s = %%s" % \
+ (self.join_table, source_col_name, target_col_name),
+ [self._pk_val, obj._get_pk_val()])
+ transaction.commit_unless_managed()
+
+ def _clear_items(self, source_col_name):
+ # source_col_name: the PK colname in join_table for the source object
+ from django.db import connection
+ cursor = connection.cursor()
+ cursor.execute("DELETE FROM %s WHERE %s = %%s" % \
+ (self.join_table, source_col_name),
+ [self._pk_val])
+ transaction.commit_unless_managed()
+
+ return ManyRelatedManager
+
+class ManyRelatedObjectsDescriptor(object):
+ # This class provides the functionality that makes the related-object
+ # managers available as attributes on a model class, for fields that have
+ # multiple "remote" values and have a ManyToManyField pointed at them by
+ # some other model (rather than having a ManyToManyField themselves).
+ # In the example "publication.article_set", the article_set attribute is a
+ # ManyRelatedObjectsDescriptor instance.
+ def __init__(self, related):
+ self.related = related # RelatedObject instance
+
+ def __get__(self, instance, instance_type=None):
+ if instance is None:
+ raise AttributeError, "Manager must be accessed via instance"
+
+ # Dynamically create a class that subclasses the related
+ # model's default manager.
+ rel_model = self.related.model
+ superclass = rel_model._default_manager.__class__
+ RelatedManager = create_many_related_manager(superclass)
+
+ qn = backend.quote_name
+ manager = RelatedManager(
+ model=rel_model,
+ core_filters={'%s__pk' % self.related.field.name: instance._get_pk_val()},
+ instance=instance,
+ symmetrical=False,
+ join_table=qn(self.related.field.m2m_db_table()),
+ source_col_name=qn(self.related.field.m2m_reverse_name()),
+ target_col_name=qn(self.related.field.m2m_column_name())
+ )
+
+ return manager
+
+ def __set__(self, instance, value):
+ if instance is None:
+ raise AttributeError, "Manager must be accessed via instance"
+
+ manager = self.__get__(instance)
+ manager.clear()
+ for obj in value:
+ manager.add(obj)
+
+class ReverseManyRelatedObjectsDescriptor(object):
+ # This class provides the functionality that makes the related-object
+ # managers available as attributes on a model class, for fields that have
+ # multiple "remote" values and have a ManyToManyField defined in their
+ # model (rather than having another model pointed *at* them).
+ # In the example "article.publications", the publications attribute is a
+ # ReverseManyRelatedObjectsDescriptor instance.
+ def __init__(self, m2m_field):
+ self.field = m2m_field
+
+ def __get__(self, instance, instance_type=None):
+ if instance is None:
+ raise AttributeError, "Manager must be accessed via instance"
+
+ # Dynamically create a class that subclasses the related
+ # model's default manager.
+ rel_model=self.field.rel.to
+ superclass = rel_model._default_manager.__class__
+ RelatedManager = create_many_related_manager(superclass)
+
+ qn = backend.quote_name
+ manager = RelatedManager(
+ model=rel_model,
+ core_filters={'%s__pk' % self.field.related_query_name(): instance._get_pk_val()},
+ instance=instance,
+ symmetrical=(self.field.rel.symmetrical and instance.__class__ == rel_model),
+ join_table=qn(self.field.m2m_db_table()),
+ source_col_name=qn(self.field.m2m_column_name()),
+ target_col_name=qn(self.field.m2m_reverse_name())
+ )
+
+ return manager
+
+ def __set__(self, instance, value):
+ if instance is None:
+ raise AttributeError, "Manager must be accessed via instance"
+
+ manager = self.__get__(instance)
+ manager.clear()
+ for obj in value:
+ manager.add(obj)
+
+class ForeignKey(RelatedField, Field):
+ empty_strings_allowed = False
+ def __init__(self, to, to_field=None, **kwargs):
+ try:
+ to_name = to._meta.object_name.lower()
+ except AttributeError: # to._meta doesn't exist, so it must be RECURSIVE_RELATIONSHIP_CONSTANT
+ assert isinstance(to, basestring), "ForeignKey(%r) is invalid. First parameter to ForeignKey must be either a model, a model name, or the string %r" % (to, RECURSIVE_RELATIONSHIP_CONSTANT)
+ else:
+ to_field = to_field or to._meta.pk.name
+ kwargs['verbose_name'] = kwargs.get('verbose_name', '')
+
+ if kwargs.has_key('edit_inline_type'):
+ import warnings
+ warnings.warn("edit_inline_type is deprecated. Use edit_inline instead.")
+ kwargs['edit_inline'] = kwargs.pop('edit_inline_type')
+
+ kwargs['rel'] = ManyToOneRel(to, to_field,
+ num_in_admin=kwargs.pop('num_in_admin', 3),
+ min_num_in_admin=kwargs.pop('min_num_in_admin', None),
+ max_num_in_admin=kwargs.pop('max_num_in_admin', None),
+ num_extra_on_change=kwargs.pop('num_extra_on_change', 1),
+ edit_inline=kwargs.pop('edit_inline', False),
+ related_name=kwargs.pop('related_name', None),
+ limit_choices_to=kwargs.pop('limit_choices_to', None),
+ lookup_overrides=kwargs.pop('lookup_overrides', None),
+ raw_id_admin=kwargs.pop('raw_id_admin', False))
+ Field.__init__(self, **kwargs)
+
+ self.db_index = True
+
+ def get_attname(self):
+ return '%s_id' % self.name
+
+ def get_validator_unique_lookup_type(self):
+ return '%s__%s__exact' % (self.name, self.rel.get_related_field().name)
+
+ def prepare_field_objs_and_params(self, manipulator, name_prefix):
+ params = {'validator_list': self.validator_list[:], 'member_name': name_prefix + self.attname}
+ if self.rel.raw_id_admin:
+ field_objs = self.get_manipulator_field_objs()
+ params['validator_list'].append(curry(manipulator_valid_rel_key, self, manipulator))
+ else:
+ if self.radio_admin:
+ field_objs = [forms.RadioSelectField]
+ params['ul_class'] = get_ul_class(self.radio_admin)
+ else:
+ if self.null:
+ field_objs = [forms.NullSelectField]
+ else:
+ field_objs = [forms.SelectField]
+ params['choices'] = self.get_choices_default()
+ return field_objs, params
+
+ def get_manipulator_field_objs(self):
+ rel_field = self.rel.get_related_field()
+ if self.rel.raw_id_admin and not isinstance(rel_field, AutoField):
+ return rel_field.get_manipulator_field_objs()
+ else:
+ return [forms.IntegerField]
+
+ def get_db_prep_save(self, value):
+ if value == '' or value == None:
+ return None
+ else:
+ return self.rel.get_related_field().get_db_prep_save(value)
+
+ def flatten_data(self, follow, obj=None):
+ if not obj:
+ # In required many-to-one fields with only one available choice,
+ # select that one available choice. Note: For SelectFields
+ # (radio_admin=False), we have to check that the length of choices
+ # is *2*, not 1, because SelectFields always have an initial
+ # "blank" value. Otherwise (radio_admin=True), we check that the
+ # length is 1.
+ if not self.blank and (not self.rel.raw_id_admin or self.choices):
+ choice_list = self.get_choices_default()
+ if self.radio_admin and len(choice_list) == 1:
+ return {self.attname: choice_list[0][0]}
+ if not self.radio_admin and len(choice_list) == 2:
+ return {self.attname: choice_list[1][0]}
+ return Field.flatten_data(self, follow, obj)
+
+ def contribute_to_class(self, cls, name):
+ super(ForeignKey, self).contribute_to_class(cls, name)
+ setattr(cls, self.name, ReverseSingleRelatedObjectDescriptor(self))
+
+ def contribute_to_related_class(self, cls, related):
+ setattr(cls, related.get_accessor_name(), ForeignRelatedObjectsDescriptor(related))
+
+class OneToOneField(RelatedField, IntegerField):
+ def __init__(self, to, to_field=None, **kwargs):
+ kwargs['verbose_name'] = kwargs.get('verbose_name', '')
+ to_field = to_field or to._meta.pk.name
+
+ if kwargs.has_key('edit_inline_type'):
+ import warnings
+ warnings.warn("edit_inline_type is deprecated. Use edit_inline instead.")
+ kwargs['edit_inline'] = kwargs.pop('edit_inline_type')
+
+ kwargs['rel'] = OneToOneRel(to, to_field,
+ num_in_admin=kwargs.pop('num_in_admin', 0),
+ edit_inline=kwargs.pop('edit_inline', False),
+ related_name=kwargs.pop('related_name', None),
+ limit_choices_to=kwargs.pop('limit_choices_to', None),
+ lookup_overrides=kwargs.pop('lookup_overrides', None),
+ raw_id_admin=kwargs.pop('raw_id_admin', False))
+ kwargs['primary_key'] = True
+ IntegerField.__init__(self, **kwargs)
+
+ self.db_index = True
+
+ def get_attname(self):
+ return '%s_id' % self.name
+
+ def get_validator_unique_lookup_type(self):
+ return '%s__%s__exact' % (self.name, self.rel.get_related_field().name)
+
+ # TODO: Copied from ForeignKey... putting this in RelatedField adversely affects
+ # ManyToManyField. This works for now.
+ def prepare_field_objs_and_params(self, manipulator, name_prefix):
+ params = {'validator_list': self.validator_list[:], 'member_name': name_prefix + self.attname}
+ if self.rel.raw_id_admin:
+ field_objs = self.get_manipulator_field_objs()
+ params['validator_list'].append(curry(manipulator_valid_rel_key, self, manipulator))
+ else:
+ if self.radio_admin:
+ field_objs = [forms.RadioSelectField]
+ params['ul_class'] = get_ul_class(self.radio_admin)
+ else:
+ if self.null:
+ field_objs = [forms.NullSelectField]
+ else:
+ field_objs = [forms.SelectField]
+ params['choices'] = self.get_choices_default()
+ return field_objs, params
+
+ def contribute_to_class(self, cls, name):
+ super(OneToOneField, self).contribute_to_class(cls, name)
+ setattr(cls, self.name, ReverseSingleRelatedObjectDescriptor(self))
+
+ def contribute_to_related_class(self, cls, related):
+ setattr(cls, related.get_accessor_name(), SingleRelatedObjectDescriptor(related))
+ if not cls._meta.one_to_one_field:
+ cls._meta.one_to_one_field = self
+
+class ManyToManyField(RelatedField, Field):
+ def __init__(self, to, **kwargs):
+ kwargs['verbose_name'] = kwargs.get('verbose_name', None)
+ kwargs['rel'] = ManyToManyRel(to, kwargs.pop('singular', None),
+ num_in_admin=kwargs.pop('num_in_admin', 0),
+ related_name=kwargs.pop('related_name', None),
+ filter_interface=kwargs.pop('filter_interface', None),
+ limit_choices_to=kwargs.pop('limit_choices_to', None),
+ raw_id_admin=kwargs.pop('raw_id_admin', False),
+ symmetrical=kwargs.pop('symmetrical', True))
+ if kwargs["rel"].raw_id_admin:
+ kwargs.setdefault("validator_list", []).append(self.isValidIDList)
+ Field.__init__(self, **kwargs)
+
+ if self.rel.raw_id_admin:
+ msg = gettext_lazy('Separate multiple IDs with commas.')
+ else:
+ msg = gettext_lazy('Hold down "Control", or "Command" on a Mac, to select more than one.')
+ self.help_text = string_concat(self.help_text, msg)
+
+ def get_manipulator_field_objs(self):
+ if self.rel.raw_id_admin:
+ return [forms.RawIdAdminField]
+ else:
+ choices = self.get_choices_default()
+ return [curry(forms.SelectMultipleField, size=min(max(len(choices), 5), 15), choices=choices)]
+
+ def get_choices_default(self):
+ return Field.get_choices(self, include_blank=False)
+
+ def _get_m2m_db_table(self, opts):
+ "Function that can be curried to provide the m2m table name for this relation"
+ return '%s_%s' % (opts.db_table, self.name)
+
+ def _get_m2m_column_name(self, related):
+ "Function that can be curried to provide the source column name for the m2m table"
+ # If this is an m2m relation to self, avoid the inevitable name clash
+ if related.model == related.parent_model:
+ return 'from_' + related.model._meta.object_name.lower() + '_id'
+ else:
+ return related.model._meta.object_name.lower() + '_id'
+
+ def _get_m2m_reverse_name(self, related):
+ "Function that can be curried to provide the related column name for the m2m table"
+ # If this is an m2m relation to self, avoid the inevitable name clash
+ if related.model == related.parent_model:
+ return 'to_' + related.parent_model._meta.object_name.lower() + '_id'
+ else:
+ return related.parent_model._meta.object_name.lower() + '_id'
+
+ def isValidIDList(self, field_data, all_data):
+ "Validates that the value is a valid list of foreign keys"
+ mod = self.rel.to
+ try:
+ pks = map(int, field_data.split(','))
+ except ValueError:
+ # the CommaSeparatedIntegerField validator will catch this error
+ return
+ objects = mod._default_manager.in_bulk(pks)
+ if len(objects) != len(pks):
+ badkeys = [k for k in pks if k not in objects]
+ raise validators.ValidationError, ngettext("Please enter valid %(self)s IDs. The value %(value)r is invalid.",
+ "Please enter valid %(self)s IDs. The values %(value)r are invalid.", len(badkeys)) % {
+ 'self': self.verbose_name,
+ 'value': len(badkeys) == 1 and badkeys[0] or tuple(badkeys),
+ }
+
+ def flatten_data(self, follow, obj = None):
+ new_data = {}
+ if obj:
+ instance_ids = [instance._get_pk_val() for instance in getattr(obj, self.name).all()]
+ if self.rel.raw_id_admin:
+ new_data[self.name] = ",".join([str(id) for id in instance_ids])
+ else:
+ new_data[self.name] = instance_ids
+ else:
+ # In required many-to-many fields with only one available choice,
+ # select that one available choice.
+ if not self.blank and not self.rel.edit_inline and not self.rel.raw_id_admin:
+ choices_list = self.get_choices_default()
+ if len(choices_list) == 1:
+ new_data[self.name] = [choices_list[0][0]]
+ return new_data
+
+ def contribute_to_class(self, cls, name):
+ super(ManyToManyField, self).contribute_to_class(cls, name)
+ # Add the descriptor for the m2m relation
+ setattr(cls, self.name, ReverseManyRelatedObjectsDescriptor(self))
+
+ # Set up the accessor for the m2m table name for the relation
+ self.m2m_db_table = curry(self._get_m2m_db_table, cls._meta)
+
+ def contribute_to_related_class(self, cls, related):
+ # m2m relations to self do not have a ManyRelatedObjectsDescriptor,
+ # as it would be redundant - unless the field is non-symmetrical.
+ if related.model != related.parent_model or not self.rel.symmetrical:
+ # Add the descriptor for the m2m relation
+ setattr(cls, related.get_accessor_name(), ManyRelatedObjectsDescriptor(related))
+
+ self.rel.singular = self.rel.singular or self.rel.to._meta.object_name.lower()
+
+ # Set up the accessors for the column names on the m2m table
+ self.m2m_column_name = curry(self._get_m2m_column_name, related)
+ self.m2m_reverse_name = curry(self._get_m2m_reverse_name, related)
+
+ def set_attributes_from_rel(self):
+ pass
+
+class ManyToOneRel:
+ def __init__(self, to, field_name, num_in_admin=3, min_num_in_admin=None,
+ max_num_in_admin=None, num_extra_on_change=1, edit_inline=False,
+ related_name=None, limit_choices_to=None, lookup_overrides=None, raw_id_admin=False):
+ try:
+ to._meta
+ except AttributeError: # to._meta doesn't exist, so it must be RECURSIVE_RELATIONSHIP_CONSTANT
+ assert isinstance(to, basestring), "'to' must be either a model, a model name or the string %r" % RECURSIVE_RELATIONSHIP_CONSTANT
+ self.to, self.field_name = to, field_name
+ self.num_in_admin, self.edit_inline = num_in_admin, edit_inline
+ self.min_num_in_admin, self.max_num_in_admin = min_num_in_admin, max_num_in_admin
+ self.num_extra_on_change, self.related_name = num_extra_on_change, related_name
+ self.limit_choices_to = limit_choices_to or {}
+ self.lookup_overrides = lookup_overrides or {}
+ self.raw_id_admin = raw_id_admin
+ self.multiple = True
+
+ def get_related_field(self):
+ "Returns the Field in the 'to' object to which this relationship is tied."
+ return self.to._meta.get_field(self.field_name)
+
+class OneToOneRel(ManyToOneRel):
+ def __init__(self, to, field_name, num_in_admin=0, edit_inline=False,
+ related_name=None, limit_choices_to=None, lookup_overrides=None,
+ raw_id_admin=False):
+ self.to, self.field_name = to, field_name
+ self.num_in_admin, self.edit_inline = num_in_admin, edit_inline
+ self.related_name = related_name
+ self.limit_choices_to = limit_choices_to or {}
+ self.lookup_overrides = lookup_overrides or {}
+ self.raw_id_admin = raw_id_admin
+ self.multiple = False
+
+class ManyToManyRel:
+ def __init__(self, to, singular=None, num_in_admin=0, related_name=None,
+ filter_interface=None, limit_choices_to=None, raw_id_admin=False, symmetrical=True):
+ self.to = to
+ self.singular = singular or None
+ self.num_in_admin = num_in_admin
+ self.related_name = related_name
+ self.filter_interface = filter_interface
+ self.limit_choices_to = limit_choices_to or {}
+ self.edit_inline = False
+ self.raw_id_admin = raw_id_admin
+ self.symmetrical = symmetrical
+ self.multiple = True
+
+ assert not (self.raw_id_admin and self.filter_interface), "ManyToManyRels may not use both raw_id_admin and filter_interface"
diff --git a/django/db/models/loading.py b/django/db/models/loading.py
new file mode 100644
index 0000000000..a9e0348f8e
--- /dev/null
+++ b/django/db/models/loading.py
@@ -0,0 +1,71 @@
+"Utilities for loading models and the modules that contain them."
+
+from django.conf import settings
+from django.core.exceptions import ImproperlyConfigured
+
+__all__ = ('get_apps', 'get_app', 'get_models', 'get_model', 'register_models')
+
+_app_list = None # Cache of installed apps.
+_app_models = {} # Dictionary of models against app label
+ # Each value is a dictionary of model name: model class
+
+def get_apps():
+ "Returns a list of all installed modules that contain models."
+ global _app_list
+ if _app_list is not None:
+ return _app_list
+ _app_list = []
+ for app_name in settings.INSTALLED_APPS:
+ try:
+ _app_list.append(__import__(app_name, '', '', ['models']).models)
+ except (ImportError, AttributeError), e:
+ pass
+ return _app_list
+
+def get_app(app_label):
+ "Returns the module containing the models for the given app_label."
+ for app_name in settings.INSTALLED_APPS:
+ if app_label == app_name.split('.')[-1]:
+ return __import__(app_name, '', '', ['models']).models
+ raise ImproperlyConfigured, "App with label %s could not be found" % app_label
+
+def get_models(app_mod=None):
+ """
+ Given a module containing models, returns a list of the models. Otherwise
+ returns a list of all installed models.
+ """
+ app_list = get_apps() # Run get_apps() to populate the _app_list cache. Slightly hackish.
+ if app_mod:
+ return _app_models.get(app_mod.__name__.split('.')[-2], {}).values()
+ else:
+ model_list = []
+ for app_mod in app_list:
+ model_list.extend(get_models(app_mod))
+ return model_list
+
+def get_model(app_label, model_name):
+ """
+ Returns the model matching the given app_label and case-insensitive model_name.
+ Returns None if no model is found.
+ """
+ get_apps() # Run get_apps() to populate the _app_list cache. Slightly hackish.
+ try:
+ model_dict = _app_models[app_label]
+ except KeyError:
+ return None
+
+ try:
+ return model_dict[model_name.lower()]
+ except KeyError:
+ return None
+
+def register_models(app_label, *models):
+ """
+ Register a set of models as belonging to an app.
+ """
+ for model in models:
+ # Store as 'name: model' pair in a dictionary
+ # in the _app_models dictionary
+ model_name = model._meta.object_name.lower()
+ model_dict = _app_models.setdefault(app_label, {})
+ model_dict[model_name] = model
diff --git a/django/db/models/manager.py b/django/db/models/manager.py
new file mode 100644
index 0000000000..d847631c82
--- /dev/null
+++ b/django/db/models/manager.py
@@ -0,0 +1,101 @@
+from django.utils.functional import curry
+from django.db import backend, connection
+from django.db.models.query import QuerySet
+from django.dispatch import dispatcher
+from django.db.models import signals
+from django.utils.datastructures import SortedDict
+
+# Size of each "chunk" for get_iterator calls.
+# Larger values are slightly faster at the expense of more storage space.
+GET_ITERATOR_CHUNK_SIZE = 100
+
+def ensure_default_manager(sender):
+ cls = sender
+ if not hasattr(cls, '_default_manager'):
+ # Create the default manager, if needed.
+ if hasattr(cls, 'objects'):
+ raise ValueError, "Model %s must specify a custom Manager, because it has a field named 'objects'" % name
+ cls.add_to_class('objects', Manager())
+
+dispatcher.connect(ensure_default_manager, signal=signals.class_prepared)
+
+class Manager(object):
+ # Tracks each time a Manager instance is created. Used to retain order.
+ creation_counter = 0
+
+ def __init__(self):
+ super(Manager, self).__init__()
+ # Increase the creation counter, and save our local copy.
+ self.creation_counter = Manager.creation_counter
+ Manager.creation_counter += 1
+ self.model = None
+
+ def contribute_to_class(self, model, name):
+ # TODO: Use weakref because of possible memory leak / circular reference.
+ self.model = model
+ setattr(model, name, ManagerDescriptor(self))
+ if not hasattr(model, '_default_manager') or self.creation_counter < model._default_manager.creation_counter:
+ model._default_manager = self
+
+ #######################
+ # PROXIES TO QUERYSET #
+ #######################
+
+ def get_query_set(self):
+ """Returns a new QuerySet object. Subclasses can override this method
+ to easily customise the behaviour of the Manager.
+ """
+ return QuerySet(self.model)
+
+ def all(self):
+ return self.get_query_set()
+
+ def count(self):
+ return self.get_query_set().count()
+
+ def dates(self, *args, **kwargs):
+ return self.get_query_set().dates(*args, **kwargs)
+
+ def distinct(self, *args, **kwargs):
+ return self.get_query_set().distinct(*args, **kwargs)
+
+ def extra(self, *args, **kwargs):
+ return self.get_query_set().extra(*args, **kwargs)
+
+ def get(self, *args, **kwargs):
+ return self.get_query_set().get(*args, **kwargs)
+
+ def filter(self, *args, **kwargs):
+ return self.get_query_set().filter(*args, **kwargs)
+
+ def exclude(self, *args, **kwargs):
+ return self.get_query_set().exclude(*args, **kwargs)
+
+ def in_bulk(self, *args, **kwargs):
+ return self.get_query_set().in_bulk(*args, **kwargs)
+
+ def iterator(self, *args, **kwargs):
+ return self.get_query_set().iterator(*args, **kwargs)
+
+ def latest(self, *args, **kwargs):
+ return self.get_query_set().latest(*args, **kwargs)
+
+ def order_by(self, *args, **kwargs):
+ return self.get_query_set().order_by(*args, **kwargs)
+
+ def select_related(self, *args, **kwargs):
+ return self.get_query_set().select_related(*args, **kwargs)
+
+ def values(self, *args, **kwargs):
+ return self.get_query_set().values(*args, **kwargs)
+
+class ManagerDescriptor(object):
+ # This class ensures managers aren't accessible via model instances.
+ # For example, Poll.objects works, but poll_obj.objects raises AttributeError.
+ def __init__(self, manager):
+ self.manager = manager
+
+ def __get__(self, instance, type=None):
+ if instance != None:
+ raise AttributeError, "Manager isn't accessible via %s instances" % type.__name__
+ return self.manager
diff --git a/django/db/models/manipulators.py b/django/db/models/manipulators.py
new file mode 100644
index 0000000000..fc553bc90c
--- /dev/null
+++ b/django/db/models/manipulators.py
@@ -0,0 +1,330 @@
+from django.core.exceptions import ObjectDoesNotExist
+from django import forms
+from django.core import validators
+from django.db.models.fields import FileField, AutoField
+from django.dispatch import dispatcher
+from django.db.models import signals
+from django.utils.functional import curry
+from django.utils.datastructures import DotExpandedDict, MultiValueDict
+from django.utils.text import capfirst
+import types
+
+def add_manipulators(sender):
+ cls = sender
+ cls.add_to_class('AddManipulator', AutomaticAddManipulator)
+ cls.add_to_class('ChangeManipulator', AutomaticChangeManipulator)
+
+dispatcher.connect(add_manipulators, signal=signals.class_prepared)
+
+class ManipulatorDescriptor(object):
+ # This class provides the functionality that makes the default model
+ # manipulators (AddManipulator and ChangeManipulator) available via the
+ # model class.
+ def __init__(self, name, base):
+ self.man = None # Cache of the manipulator class.
+ self.name = name
+ self.base = base
+
+ def __get__(self, instance, model=None):
+ if instance != None:
+ raise AttributeError, "Manipulator cannot be accessed via instance"
+ else:
+ if not self.man:
+ # Create a class that inherits from the "Manipulator" class
+ # given in the model class (if specified) and the automatic
+ # manipulator.
+ bases = [self.base]
+ if hasattr(model, 'Manipulator'):
+ bases = [model.Manipulator] + bases
+ self.man = types.ClassType(self.name, tuple(bases), {})
+ self.man._prepare(model)
+ return self.man
+
+class AutomaticManipulator(forms.Manipulator):
+ def _prepare(cls, model):
+ cls.model = model
+ cls.manager = model._default_manager
+ cls.opts = model._meta
+ for field_name_list in cls.opts.unique_together:
+ setattr(cls, 'isUnique%s' % '_'.join(field_name_list), curry(manipulator_validator_unique_together, field_name_list, cls.opts))
+ for f in cls.opts.fields:
+ if f.unique_for_date:
+ setattr(cls, 'isUnique%sFor%s' % (f.name, f.unique_for_date), curry(manipulator_validator_unique_for_date, f, cls.opts.get_field(f.unique_for_date), cls.opts, 'date'))
+ if f.unique_for_month:
+ setattr(cls, 'isUnique%sFor%s' % (f.name, f.unique_for_month), curry(manipulator_validator_unique_for_date, f, cls.opts.get_field(f.unique_for_month), cls.opts, 'month'))
+ if f.unique_for_year:
+ setattr(cls, 'isUnique%sFor%s' % (f.name, f.unique_for_year), curry(manipulator_validator_unique_for_date, f, cls.opts.get_field(f.unique_for_year), cls.opts, 'year'))
+ _prepare = classmethod(_prepare)
+
+ def contribute_to_class(cls, other_cls, name):
+ setattr(other_cls, name, ManipulatorDescriptor(name, cls))
+ contribute_to_class = classmethod(contribute_to_class)
+
+ def __init__(self, follow=None):
+ self.follow = self.opts.get_follow(follow)
+ self.fields = []
+
+ for f in self.opts.fields + self.opts.many_to_many:
+ if self.follow.get(f.name, False):
+ self.fields.extend(f.get_manipulator_fields(self.opts, self, self.change))
+
+ # Add fields for related objects.
+ for f in self.opts.get_all_related_objects():
+ if self.follow.get(f.name, False):
+ fol = self.follow[f.name]
+ self.fields.extend(f.get_manipulator_fields(self.opts, self, self.change, fol))
+
+ # Add field for ordering.
+ if self.change and self.opts.get_ordered_objects():
+ self.fields.append(formfields.CommaSeparatedIntegerField(field_name="order_"))
+
+ def save(self, new_data):
+ # TODO: big cleanup when core fields go -> use recursive manipulators.
+ params = {}
+ for f in self.opts.fields:
+ # Fields with auto_now_add should keep their original value in the change stage.
+ auto_now_add = self.change and getattr(f, 'auto_now_add', False)
+ if self.follow.get(f.name, None) and not auto_now_add:
+ param = f.get_manipulator_new_data(new_data)
+ else:
+ if self.change:
+ param = getattr(self.original_object, f.attname)
+ else:
+ param = f.get_default()
+ params[f.attname] = param
+
+ if self.change:
+ params[self.opts.pk.attname] = self.obj_key
+
+ # First, save the basic object itself.
+ new_object = self.model(**params)
+ new_object.save()
+
+ # Now that the object's been saved, save any uploaded files.
+ for f in self.opts.fields:
+ if isinstance(f, FileField):
+ f.save_file(new_data, new_object, self.change and self.original_object or None, self.change, rel=False)
+
+ # Calculate which primary fields have changed.
+ if self.change:
+ self.fields_added, self.fields_changed, self.fields_deleted = [], [], []
+ for f in self.opts.fields:
+ if not f.primary_key and str(getattr(self.original_object, f.attname)) != str(getattr(new_object, f.attname)):
+ self.fields_changed.append(f.verbose_name)
+
+ # Save many-to-many objects. Example: Set sites for a poll.
+ for f in self.opts.many_to_many:
+ if self.follow.get(f.name, None):
+ if not f.rel.edit_inline:
+ if f.rel.raw_id_admin:
+ new_vals = new_data.get(f.name, ())
+ else:
+ new_vals = new_data.getlist(f.name)
+ # First, clear the existing values.
+ rel_manager = getattr(new_object, f.name)
+ rel_manager.clear()
+ # Then, set the new values.
+ for n in new_vals:
+ rel_manager.add(f.rel.to._default_manager.get(pk=n))
+ # TODO: Add to 'fields_changed'
+
+ expanded_data = DotExpandedDict(dict(new_data))
+ # Save many-to-one objects. Example: Add the Choice objects for a Poll.
+ for related in self.opts.get_all_related_objects():
+ # Create obj_list, which is a DotExpandedDict such as this:
+ # [('0', {'id': ['940'], 'choice': ['This is the first choice']}),
+ # ('1', {'id': ['941'], 'choice': ['This is the second choice']}),
+ # ('2', {'id': [''], 'choice': ['']})]
+ child_follow = self.follow.get(related.name, None)
+
+ if child_follow:
+ obj_list = expanded_data[related.var_name].items()
+ if not obj_list:
+ continue
+
+ obj_list.sort(lambda x, y: cmp(int(x[0]), int(y[0])))
+
+ # For each related item...
+ for _, rel_new_data in obj_list:
+
+ params = {}
+
+ # Keep track of which core=True fields were provided.
+ # If all core fields were given, the related object will be saved.
+ # If none of the core fields were given, the object will be deleted.
+ # If some, but not all, of the fields were given, the validator would
+ # have caught that.
+ all_cores_given, all_cores_blank = True, True
+
+ # Get a reference to the old object. We'll use it to compare the
+ # old to the new, to see which fields have changed.
+ old_rel_obj = None
+ if self.change:
+ if rel_new_data[related.opts.pk.name][0]:
+ try:
+ old_rel_obj = getattr(self.original_object, related.get_accessor_name()).get(**{'%s__exact' % related.opts.pk.name: rel_new_data[related.opts.pk.attname][0]})
+ except ObjectDoesNotExist:
+ pass
+
+ for f in related.opts.fields:
+ if f.core and not isinstance(f, FileField) and f.get_manipulator_new_data(rel_new_data, rel=True) in (None, ''):
+ all_cores_given = False
+ elif f.core and not isinstance(f, FileField) and f.get_manipulator_new_data(rel_new_data, rel=True) not in (None, ''):
+ all_cores_blank = False
+ # If this field isn't editable, give it the same value it had
+ # previously, according to the given ID. If the ID wasn't
+ # given, use a default value. FileFields are also a special
+ # case, because they'll be dealt with later.
+
+ if f == related.field:
+ param = getattr(new_object, related.field.rel.field_name)
+ elif (not self.change) and isinstance(f, AutoField):
+ param = None
+ elif self.change and (isinstance(f, FileField) or not child_follow.get(f.name, None)):
+ if old_rel_obj:
+ param = getattr(old_rel_obj, f.column)
+ else:
+ param = f.get_default()
+ else:
+ param = f.get_manipulator_new_data(rel_new_data, rel=True)
+ if param != None:
+ params[f.attname] = param
+
+ # Create the related item.
+ new_rel_obj = related.model(**params)
+
+ # If all the core fields were provided (non-empty), save the item.
+ if all_cores_given:
+ new_rel_obj.save()
+
+ # Save any uploaded files.
+ for f in related.opts.fields:
+ if child_follow.get(f.name, None):
+ if isinstance(f, FileField) and rel_new_data.get(f.name, False):
+ f.save_file(rel_new_data, new_rel_obj, self.change and old_rel_obj or None, old_rel_obj is not None, rel=True)
+
+ # Calculate whether any fields have changed.
+ if self.change:
+ if not old_rel_obj: # This object didn't exist before.
+ self.fields_added.append('%s "%s"' % (related.opts.verbose_name, new_rel_obj))
+ else:
+ for f in related.opts.fields:
+ if not f.primary_key and f != related.field and str(getattr(old_rel_obj, f.attname)) != str(getattr(new_rel_obj, f.attname)):
+ self.fields_changed.append('%s for %s "%s"' % (f.verbose_name, related.opts.verbose_name, new_rel_obj))
+
+ # Save many-to-many objects.
+ for f in related.opts.many_to_many:
+ if child_follow.get(f.name, None) and not f.rel.edit_inline:
+ was_changed = getattr(new_rel_obj, 'set_%s' % f.name)(rel_new_data[f.attname])
+ if self.change and was_changed:
+ self.fields_changed.append('%s for %s "%s"' % (f.verbose_name, related.opts.verbose_name, new_rel_obj))
+
+ # If, in the change stage, all of the core fields were blank and
+ # the primary key (ID) was provided, delete the item.
+ if self.change and all_cores_blank and old_rel_obj:
+ new_rel_obj.delete()
+ self.fields_deleted.append('%s "%s"' % (related.opts.verbose_name, old_rel_obj))
+
+ # Save the order, if applicable.
+ if self.change and self.opts.get_ordered_objects():
+ order = new_data['order_'] and map(int, new_data['order_'].split(',')) or []
+ for rel_opts in self.opts.get_ordered_objects():
+ getattr(new_object, 'set_%s_order' % rel_opts.object_name.lower())(order)
+ return new_object
+
+ def get_related_objects(self):
+ return self.opts.get_followed_related_objects(self.follow)
+
+ def flatten_data(self):
+ new_data = {}
+ obj = self.change and self.original_object or None
+ for f in self.opts.get_data_holders(self.follow):
+ fol = self.follow.get(f.name)
+ new_data.update(f.flatten_data(fol, obj))
+ return new_data
+
+class AutomaticAddManipulator(AutomaticManipulator):
+ change = False
+
+class AutomaticChangeManipulator(AutomaticManipulator):
+ change = True
+ def __init__(self, obj_key, follow=None):
+ self.obj_key = obj_key
+ try:
+ self.original_object = self.manager.get(pk=obj_key)
+ except ObjectDoesNotExist:
+ # If the object doesn't exist, this might be a manipulator for a
+ # one-to-one related object that hasn't created its subobject yet.
+ # For example, this might be a Restaurant for a Place that doesn't
+ # yet have restaurant information.
+ if self.opts.one_to_one_field:
+ # Sanity check -- Make sure the "parent" object exists.
+ # For example, make sure the Place exists for the Restaurant.
+ # Let the ObjectDoesNotExist exception propagate up.
+ lookup_kwargs = self.opts.one_to_one_field.rel.limit_choices_to
+ lookup_kwargs['%s__exact' % self.opts.one_to_one_field.rel.field_name] = obj_key
+ self.opts.one_to_one_field.rel.to.get_model_module().get(**lookup_kwargs)
+ params = dict([(f.attname, f.get_default()) for f in self.opts.fields])
+ params[self.opts.pk.attname] = obj_key
+ self.original_object = self.opts.get_model_module().Klass(**params)
+ else:
+ raise
+ super(AutomaticChangeManipulator, self).__init__(follow=follow)
+
+def manipulator_validator_unique_together(field_name_list, opts, self, field_data, all_data):
+ from django.db.models.fields.related import ManyToOneRel
+ from django.utils.text import get_text_list
+ field_list = [opts.get_field(field_name) for field_name in field_name_list]
+ if isinstance(field_list[0].rel, ManyToOneRel):
+ kwargs = {'%s__%s__iexact' % (field_name_list[0], field_list[0].rel.field_name): field_data}
+ else:
+ kwargs = {'%s__iexact' % field_name_list[0]: field_data}
+ for f in field_list[1:]:
+ # This is really not going to work for fields that have different
+ # form fields, e.g. DateTime.
+ # This validation needs to occur after html2python to be effective.
+ field_val = all_data.get(f.attname, None)
+ if field_val is None:
+ # This will be caught by another validator, assuming the field
+ # doesn't have blank=True.
+ return
+ if isinstance(f.rel, ManyToOneRel):
+ kwargs['%s__pk' % f.name] = field_val
+ else:
+ kwargs['%s__iexact' % f.name] = field_val
+ try:
+ old_obj = self.manager.get(**kwargs)
+ except ObjectDoesNotExist:
+ return
+ if hasattr(self, 'original_object') and self.original_object._get_pk_val() == old_obj._get_pk_val():
+ pass
+ else:
+ raise validators.ValidationError, _("%(object)s with this %(type)s already exists for the given %(field)s.") % \
+ {'object': capfirst(opts.verbose_name), 'type': field_list[0].verbose_name, 'field': get_text_list(field_name_list[1:], 'and')}
+
+def manipulator_validator_unique_for_date(from_field, date_field, opts, lookup_type, self, field_data, all_data):
+ from django.db.models.fields.related import ManyToOneRel
+ date_str = all_data.get(date_field.get_manipulator_field_names('')[0], None)
+ date_val = forms.DateField.html2python(date_str)
+ if date_val is None:
+ return # Date was invalid. This will be caught by another validator.
+ lookup_kwargs = {'%s__year' % date_field.name: date_val.year}
+ if isinstance(from_field.rel, ManyToOneRel):
+ lookup_kwargs['%s__pk' % from_field.name] = field_data
+ else:
+ lookup_kwargs['%s__iexact' % from_field.name] = field_data
+ if lookup_type in ('month', 'date'):
+ lookup_kwargs['%s__month' % date_field.name] = date_val.month
+ if lookup_type == 'date':
+ lookup_kwargs['%s__day' % date_field.name] = date_val.day
+ try:
+ old_obj = self.manager.get(**lookup_kwargs)
+ except ObjectDoesNotExist:
+ return
+ else:
+ if hasattr(self, 'original_object') and self.original_object._get_pk_val() == old_obj._get_pk_val():
+ pass
+ else:
+ format_string = (lookup_type == 'date') and '%B %d, %Y' or '%B %Y'
+ raise validators.ValidationError, "Please enter a different %s. The one you entered is already being used for %s." % \
+ (from_field.verbose_name, date_val.strftime(format_string))
diff --git a/django/db/models/options.py b/django/db/models/options.py
new file mode 100644
index 0000000000..d1f5eeb756
--- /dev/null
+++ b/django/db/models/options.py
@@ -0,0 +1,269 @@
+from django.conf import settings
+from django.db.models.related import RelatedObject
+from django.db.models.fields.related import ManyToManyRel
+from django.db.models.fields import AutoField, FieldDoesNotExist
+from django.db.models.loading import get_models
+from django.db.models.query import orderlist2sql
+from django.db.models import Manager
+from bisect import bisect
+import re
+
+# Calculate the verbose_name by converting from InitialCaps to "lowercase with spaces".
+get_verbose_name = lambda class_name: re.sub('([A-Z])', ' \\1', class_name).lower().strip()
+
+DEFAULT_NAMES = ('verbose_name', 'db_table', 'ordering',
+ 'unique_together', 'permissions', 'get_latest_by',
+ 'order_with_respect_to', 'app_label')
+
+class Options:
+ def __init__(self, meta):
+ self.fields, self.many_to_many = [], []
+ self.module_name, self.verbose_name = None, None
+ self.verbose_name_plural = None
+ self.db_table = ''
+ self.ordering = []
+ self.unique_together = []
+ self.permissions = []
+ self.object_name, self.app_label = None, None
+ self.get_latest_by = None
+ self.order_with_respect_to = None
+ self.admin = None
+ self.meta = meta
+ self.pk = None
+ self.has_auto_field = False
+ self.one_to_one_field = None
+ self.parents = []
+
+ def contribute_to_class(self, cls, name):
+ cls._meta = self
+ self.installed = re.sub('\.models$', '', cls.__module__) in settings.INSTALLED_APPS
+ # First, construct the default values for these options.
+ self.object_name = cls.__name__
+ self.module_name = self.object_name.lower()
+ self.verbose_name = get_verbose_name(self.object_name)
+ # Next, apply any overridden values from 'class Meta'.
+ if self.meta:
+ meta_attrs = self.meta.__dict__
+ del meta_attrs['__module__']
+ del meta_attrs['__doc__']
+ for attr_name in DEFAULT_NAMES:
+ setattr(self, attr_name, meta_attrs.pop(attr_name, getattr(self, attr_name)))
+ # verbose_name_plural is a special case because it uses a 's'
+ # by default.
+ setattr(self, 'verbose_name_plural', meta_attrs.pop('verbose_name_plural', self.verbose_name + 's'))
+ # Any leftover attributes must be invalid.
+ if meta_attrs != {}:
+ raise TypeError, "'class Meta' got invalid attribute(s): %s" % ','.join(meta_attrs.keys())
+ else:
+ self.verbose_name_plural = self.verbose_name + 's'
+ del self.meta
+
+ def _prepare(self, model):
+ if self.order_with_respect_to:
+ self.order_with_respect_to = self.get_field(self.order_with_respect_to)
+ self.ordering = ('_order',)
+ else:
+ self.order_with_respect_to = None
+
+ if self.pk is None:
+ auto = AutoField(verbose_name='ID', primary_key=True)
+ auto.creation_counter = -1
+ model.add_to_class('id', auto)
+
+ # If the db_table wasn't provided, use the app_label + module_name.
+ if not self.db_table:
+ self.db_table = "%s_%s" % (self.app_label, self.module_name)
+
+ def add_field(self, field):
+ # Insert the given field in the order in which it was created, using
+ # the "creation_counter" attribute of the field.
+ # Move many-to-many related fields from self.fields into self.many_to_many.
+ if field.rel and isinstance(field.rel, ManyToManyRel):
+ self.many_to_many.insert(bisect(self.many_to_many, field), field)
+ else:
+ self.fields.insert(bisect(self.fields, field), field)
+ if not self.pk and field.primary_key:
+ self.pk = field
+
+ def __repr__(self):
+ return '
- Edit the
DATABASE_*settings in{{ project_name }}/settings.py.
- - Start your first app by running
{{ project_name }}/manage.py startapp [appname].
+ - If you plan to use a database, edit the
DATABASE_*settings in{{ project_name }}/settings.py.
+ - Start your first app by running
python {{ project_name }}/manage.py startapp [appname].
Forbidden
') + return http.HttpResponseForbidden('Forbidden
') # Check for a redirect based on settings.APPEND_SLASH and settings.PREPEND_WWW - old_url = [request.META.get('HTTP_HOST', ''), request.path] + host = http.get_host(request) + old_url = [host, request.path] new_url = old_url[:] if settings.PREPEND_WWW and old_url[0] and not old_url[0].startswith('www.'): new_url[0] = 'www.' + old_url[0] @@ -46,7 +47,7 @@ class CommonMiddleware: newurl = new_url[1] if request.GET: newurl += '?' + request.GET.urlencode() - return httpwrappers.HttpResponsePermanentRedirect(newurl) + return http.HttpResponsePermanentRedirect(newurl) return None @@ -56,7 +57,7 @@ class CommonMiddleware: if settings.SEND_BROKEN_LINK_EMAILS: # If the referrer was from an internal link or a non-search-engine site, # send a note to the managers. - domain = request.META['HTTP_HOST'] + domain = http.get_host(request) referer = request.META.get('HTTP_REFERER', None) is_internal = referer and (domain in referer) path = request.get_full_path() @@ -69,7 +70,7 @@ class CommonMiddleware: if settings.USE_ETAGS: etag = md5.new(response.content).hexdigest() if request.META.get('HTTP_IF_NONE_MATCH') == etag: - response = httpwrappers.HttpResponseNotModified() + response = http.HttpResponseNotModified() else: response['ETag'] = etag diff --git a/django/middleware/doc.py b/django/middleware/doc.py index c96be2c0f6..6376fe4d5c 100644 --- a/django/middleware/doc.py +++ b/django/middleware/doc.py @@ -1,5 +1,5 @@ from django.conf import settings -from django.utils import httpwrappers +from django import http class XViewMiddleware: """ @@ -12,6 +12,6 @@ class XViewMiddleware: documentation module to lookup the view function for an arbitrary page. """ if request.META['REQUEST_METHOD'] == 'HEAD' and request.META.get('REMOTE_ADDR') in settings.INTERNAL_IPS: - response = httpwrappers.HttpResponse() + response = http.HttpResponse() response['X-View'] = "%s.%s" % (view_func.__module__, view_func.__name__) return response diff --git a/django/middleware/transaction.py b/django/middleware/transaction.py new file mode 100644 index 0000000000..da218ac31a --- /dev/null +++ b/django/middleware/transaction.py @@ -0,0 +1,28 @@ +from django.conf import settings +from django.db import transaction + +class TransactionMiddleware: + """ + Transaction middleware. If this is enabled, each view function will be run + with commit_on_response activated - that way a save() doesn't do a direct + commit, the commit is done when a successful response is created. If an + exception happens, the database is rolled back. + """ + def process_request(self, request): + """Enters transaction management""" + transaction.enter_transaction_management() + transaction.managed(True) + + def process_exception(self, request, exception): + """Rolls back the database and leaves transaction management""" + if transaction.is_dirty(): + transaction.rollback() + transaction.leave_transaction_management() + + def process_response(self, request, response): + """Commits and leaves transaction management.""" + if transaction.is_managed(): + if transaction.is_dirty(): + transaction.commit() + transaction.leave_transaction_management() + return response diff --git a/django/models/__init__.py b/django/models/__init__.py deleted file mode 100644 index ea0c66f2ae..0000000000 --- a/django/models/__init__.py +++ /dev/null @@ -1,95 +0,0 @@ -from django.core import meta -from django.utils.functional import curry - -__all__ = ['auth', 'core'] - -# Alter this package's __path__ variable so that calling code can import models -# from "django.models" even though the model code doesn't physically live -# within django.models. -for mod in meta.get_installed_models(): - __path__.extend(mod.__path__) - -# First, import all models so the metaclasses run. -modules = meta.get_installed_model_modules(__all__) - -# Now, create the extra methods that we couldn't create earlier because -# relationships hadn't been known until now. -for mod in modules: - for klass in mod._MODELS: - - # Add "get_thingie", "get_thingie_count" and "get_thingie_list" methods - # for all related objects. - for related in klass._meta.get_all_related_objects(): - # Determine whether this related object is in another app. - # If it's in another app, the method names will have the app - # label prepended, and the add_BLAH() method will not be - # generated. - rel_mod = related.opts.get_model_module() - rel_obj_name = related.get_method_name_part() - if isinstance(related.field.rel, meta.OneToOneRel): - # Add "get_thingie" methods for one-to-one related objects. - # EXAMPLE: Place.get_restaurants_restaurant() - func = curry(meta.method_get_related, 'get_object', rel_mod, related.field) - func.__doc__ = "Returns the associated `%s.%s` object." % (related.opts.app_label, related.opts.module_name) - setattr(klass, 'get_%s' % rel_obj_name, func) - elif isinstance(related.field.rel, meta.ManyToOneRel): - # Add "get_thingie" methods for many-to-one related objects. - # EXAMPLE: Poll.get_choice() - func = curry(meta.method_get_related, 'get_object', rel_mod, related.field) - func.__doc__ = "Returns the associated `%s.%s` object matching the given criteria." % \ - (related.opts.app_label, related.opts.module_name) - setattr(klass, 'get_%s' % rel_obj_name, func) - # Add "get_thingie_count" methods for many-to-one related objects. - # EXAMPLE: Poll.get_choice_count() - func = curry(meta.method_get_related, 'get_count', rel_mod, related.field) - func.__doc__ = "Returns the number of associated `%s.%s` objects." % \ - (related.opts.app_label, related.opts.module_name) - setattr(klass, 'get_%s_count' % rel_obj_name, func) - # Add "get_thingie_list" methods for many-to-one related objects. - # EXAMPLE: Poll.get_choice_list() - func = curry(meta.method_get_related, 'get_list', rel_mod, related.field) - func.__doc__ = "Returns a list of associated `%s.%s` objects." % \ - (related.opts.app_label, related.opts.module_name) - setattr(klass, 'get_%s_list' % rel_obj_name, func) - # Add "add_thingie" methods for many-to-one related objects, - # but only for related objects that are in the same app. - # EXAMPLE: Poll.add_choice() - if related.opts.app_label == klass._meta.app_label: - func = curry(meta.method_add_related, related.opts, rel_mod, related.field) - func.alters_data = True - setattr(klass, 'add_%s' % rel_obj_name, func) - del func - del rel_obj_name, rel_mod, related # clean up - - # Do the same for all related many-to-many objects. - for related in klass._meta.get_all_related_many_to_many_objects(): - rel_mod = related.opts.get_model_module() - rel_obj_name = related.get_method_name_part() - setattr(klass, 'get_%s' % rel_obj_name, curry(meta.method_get_related_many_to_many, 'get_object', klass._meta, rel_mod, related.field)) - setattr(klass, 'get_%s_count' % rel_obj_name, curry(meta.method_get_related_many_to_many, 'get_count', klass._meta, rel_mod, related.field)) - setattr(klass, 'get_%s_list' % rel_obj_name, curry(meta.method_get_related_many_to_many, 'get_list', klass._meta, rel_mod, related.field)) - if related.opts.app_label == klass._meta.app_label: - func = curry(meta.method_set_related_many_to_many, related.opts, related.field) - func.alters_data = True - setattr(klass, 'set_%s' % related.opts.module_name, func) - del func - del rel_obj_name, rel_mod, related # clean up - - # Add "set_thingie_order" and "get_thingie_order" methods for objects - # that are ordered with respect to this. - for obj in klass._meta.get_ordered_objects(): - func = curry(meta.method_set_order, obj) - func.__doc__ = "Sets the order of associated `%s.%s` objects to the given ID list." % (obj.app_label, obj.module_name) - func.alters_data = True - setattr(klass, 'set_%s_order' % obj.object_name.lower(), func) - - func = curry(meta.method_get_order, obj) - func.__doc__ = "Returns the order of associated `%s.%s` objects as a list of IDs." % (obj.app_label, obj.module_name) - setattr(klass, 'get_%s_order' % obj.object_name.lower(), func) - del func, obj # clean up - del klass # clean up - del mod -del modules - -# Expose get_app and get_module. -from django.core.meta import get_app, get_module diff --git a/django/models/auth.py b/django/models/auth.py deleted file mode 100644 index 2595727ad0..0000000000 --- a/django/models/auth.py +++ /dev/null @@ -1,219 +0,0 @@ -from django.core import meta, validators -from django.models import core -from django.utils.translation import gettext_lazy as _ - -class Permission(meta.Model): - name = meta.CharField(_('name'), maxlength=50) - package = meta.ForeignKey(core.Package, db_column='package') - codename = meta.CharField(_('codename'), maxlength=100) - class META: - verbose_name = _('Permission') - verbose_name_plural = _('Permissions') - unique_together = (('package', 'codename'),) - ordering = ('package', 'codename') - - def __repr__(self): - return "%s | %s" % (self.package_id, self.name) - -class Group(meta.Model): - name = meta.CharField(_('name'), maxlength=80, unique=True) - permissions = meta.ManyToManyField(Permission, blank=True, filter_interface=meta.HORIZONTAL) - class META: - verbose_name = _('Group') - verbose_name_plural = _('Groups') - ordering = ('name',) - admin = meta.Admin( - search_fields = ('name',), - ) - - def __repr__(self): - return self.name - -class User(meta.Model): - username = meta.CharField(_('username'), maxlength=30, unique=True, validator_list=[validators.isAlphaNumeric]) - first_name = meta.CharField(_('first name'), maxlength=30, blank=True) - last_name = meta.CharField(_('last name'), maxlength=30, blank=True) - email = meta.EmailField(_('e-mail address'), blank=True) - password = meta.CharField(_('password'), maxlength=128, help_text=_("Use '[algo]$[salt]$[hexdigest]'")) - is_staff = meta.BooleanField(_('staff status'), help_text=_("Designates whether the user can log into this admin site.")) - is_active = meta.BooleanField(_('active'), default=True) - is_superuser = meta.BooleanField(_('superuser status')) - last_login = meta.DateTimeField(_('last login'), default=meta.LazyDate()) - date_joined = meta.DateTimeField(_('date joined'), default=meta.LazyDate()) - groups = meta.ManyToManyField(Group, blank=True, - help_text=_("In addition to the permissions manually assigned, this user will also get all permissions granted to each group he/she is in.")) - user_permissions = meta.ManyToManyField(Permission, blank=True, filter_interface=meta.HORIZONTAL) - class META: - verbose_name = _('User') - verbose_name_plural = _('Users') - module_constants = { - 'SESSION_KEY': '_auth_user_id', - } - ordering = ('username',) - exceptions = ('SiteProfileNotAvailable',) - admin = meta.Admin( - fields = ( - (None, {'fields': ('username', 'password')}), - (_('Personal info'), {'fields': ('first_name', 'last_name', 'email')}), - (_('Permissions'), {'fields': ('is_staff', 'is_active', 'is_superuser', 'user_permissions')}), - (_('Important dates'), {'fields': ('last_login', 'date_joined')}), - (_('Groups'), {'fields': ('groups',)}), - ), - list_display = ('username', 'email', 'first_name', 'last_name', 'is_staff'), - list_filter = ('is_staff', 'is_superuser'), - search_fields = ('username', 'first_name', 'last_name', 'email'), - ) - - def __repr__(self): - return self.username - - def get_absolute_url(self): - return "/users/%s/" % self.username - - def is_anonymous(self): - return False - - def get_full_name(self): - full_name = '%s %s' % (self.first_name, self.last_name) - return full_name.strip() - - def set_password(self, raw_password): - import sha, random - algo = 'sha1' - salt = sha.new(str(random.random())).hexdigest()[:5] - hsh = sha.new(salt+raw_password).hexdigest() - self.password = '%s$%s$%s' % (algo, salt, hsh) - - def check_password(self, raw_password): - """ - Returns a boolean of whether the raw_password was correct. Handles - encryption formats behind the scenes. - """ - # Backwards-compatibility check. Older passwords won't include the - # algorithm or salt. - if '$' not in self.password: - import md5 - is_correct = (self.password == md5.new(raw_password).hexdigest()) - if is_correct: - # Convert the password to the new, more secure format. - self.set_password(raw_password) - self.save() - return is_correct - algo, salt, hsh = self.password.split('$') - if algo == 'md5': - import md5 - return hsh == md5.new(salt+raw_password).hexdigest() - elif algo == 'sha1': - import sha - return hsh == sha.new(salt+raw_password).hexdigest() - raise ValueError, "Got unknown password algorithm type in password." - - def get_group_permissions(self): - "Returns a list of permission strings that this user has through his/her groups." - if not hasattr(self, '_group_perm_cache'): - import sets - cursor = db.cursor() - # The SQL below works out to the following, after DB quoting: - # cursor.execute(""" - # SELECT p.package, p.codename - # FROM auth_permissions p, auth_groups_permissions gp, auth_users_groups ug - # WHERE p.id = gp.permission_id - # AND gp.group_id = ug.group_id - # AND ug.user_id = %s""", [self.id]) - sql = """ - SELECT p.%s, p.%s - FROM %s p, %s gp, %s ug - WHERE p.%s = gp.%s - AND gp.%s = ug.%s - AND ug.%s = %%s""" % ( - db.quote_name('package'), db.quote_name('codename'), - db.quote_name('auth_permissions'), db.quote_name('auth_groups_permissions'), - db.quote_name('auth_users_groups'), db.quote_name('id'), - db.quote_name('permission_id'), db.quote_name('group_id'), - db.quote_name('group_id'), db.quote_name('user_id')) - cursor.execute(sql, [self.id]) - self._group_perm_cache = sets.Set(["%s.%s" % (row[0], row[1]) for row in cursor.fetchall()]) - return self._group_perm_cache - - def get_all_permissions(self): - if not hasattr(self, '_perm_cache'): - import sets - self._perm_cache = sets.Set(["%s.%s" % (p.package_id, p.codename) for p in self.get_permission_list()]) - self._perm_cache.update(self.get_group_permissions()) - return self._perm_cache - - def has_perm(self, perm): - "Returns True if the user has the specified permission." - if not self.is_active: - return False - if self.is_superuser: - return True - return perm in self.get_all_permissions() - - def has_perms(self, perm_list): - "Returns True if the user has each of the specified permissions." - for perm in perm_list: - if not self.has_perm(perm): - return False - return True - - def has_module_perms(self, package_name): - "Returns True if the user has any permissions in the given package." - if self.is_superuser: - return True - return bool(len([p for p in self.get_all_permissions() if p[:p.index('.')] == package_name])) - - def get_and_delete_messages(self): - messages = [] - for m in self.get_message_list(): - messages.append(m.message) - m.delete() - return messages - - def email_user(self, subject, message, from_email=None): - "Sends an e-mail to this User." - from django.core.mail import send_mail - send_mail(subject, message, from_email, [self.email]) - - def get_profile(self): - """ - Returns site-specific profile for this user. Raises - SiteProfileNotAvailable if this site does not allow profiles. - """ - if not hasattr(self, '_profile_cache'): - from django.conf.settings import AUTH_PROFILE_MODULE - if not AUTH_PROFILE_MODULE: - raise SiteProfileNotAvailable - try: - app, mod = AUTH_PROFILE_MODULE.split('.') - module = __import__('ellington.%s.apps.%s' % (app, mod), [], [], ['']) - self._profile_cache = module.get_object(user_id=self.id) - except ImportError: - try: - module = __import__('django.models.%s' % AUTH_PROFILE_MODULE, [], [], ['']) - self._profile_cache = module.get_object(user__id__exact=self.id) - except ImportError: - raise SiteProfileNotAvailable - return self._profile_cache - - def _module_create_user(username, email, password): - "Creates and saves a User with the given username, e-mail and password." - now = datetime.datetime.now() - user = User(None, username, '', '', email.strip().lower(), 'placeholder', False, True, False, now, now) - user.set_password(password) - user.save() - return user - - def _module_make_random_password(length=10, allowed_chars='abcdefghjkmnpqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ23456789'): - "Generates a random password with the given length and given allowed_chars" - # Note that default value of allowed_chars does not have "I" or letters - # that look like it -- just to avoid confusion. - from random import choice - return ''.join([choice(allowed_chars) for i in range(length)]) - -class Message(meta.Model): - user = meta.ForeignKey(User) - message = meta.TextField(_('Message')) - - def __repr__(self): - return self.message diff --git a/django/models/core.py b/django/models/core.py deleted file mode 100644 index f78f23f265..0000000000 --- a/django/models/core.py +++ /dev/null @@ -1,121 +0,0 @@ -import base64, md5, random, sys -import cPickle as pickle -from django.core import meta -from django.utils.translation import gettext_lazy as _ - -class Site(meta.Model): - domain = meta.CharField(_('domain name'), maxlength=100) - name = meta.CharField(_('display name'), maxlength=50) - class META: - verbose_name = _('site') - verbose_name_plural = _('sites') - db_table = 'sites' - ordering = ('domain',) - admin = meta.Admin( - list_display = ('domain', 'name'), - search_fields = ('domain', 'name'), - ) - - def __repr__(self): - return self.domain - - def _module_get_current(): - "Returns the current site, according to the SITE_ID constant." - from django.conf.settings import SITE_ID - return get_object(pk=SITE_ID) - -class Package(meta.Model): - label = meta.CharField(_('label'), maxlength=20, primary_key=True) - name = meta.CharField(_('name'), maxlength=30, unique=True) - class META: - verbose_name = _('package') - verbose_name_plural = _('packages') - db_table = 'packages' - ordering = ('name',) - - def __repr__(self): - return self.name - -class ContentType(meta.Model): - name = meta.CharField(_('name'), maxlength=100) - package = meta.ForeignKey(Package, db_column='package') - python_module_name = meta.CharField(_('python module name'), maxlength=50) - class META: - verbose_name = _('content type') - verbose_name_plural = _('content types') - db_table = 'content_types' - ordering = ('package', 'name') - unique_together = (('package', 'python_module_name'),) - - def __repr__(self): - return "%s | %s" % (self.package_id, self.name) - - def get_model_module(self): - "Returns the Python model module for accessing this type of content." - return __import__('django.models.%s.%s' % (self.package_id, self.python_module_name), '', '', ['']) - - def get_object_for_this_type(self, **kwargs): - """ - Returns an object of this type for the keyword arguments given. - Basically, this is a proxy around this object_type's get_object() model - method. The ObjectNotExist exception, if thrown, will not be caught, - so code that calls this method should catch it. - """ - return self.get_model_module().get_object(**kwargs) - -class Session(meta.Model): - session_key = meta.CharField(_('session key'), maxlength=40, primary_key=True) - session_data = meta.TextField(_('session data')) - expire_date = meta.DateTimeField(_('expire date')) - class META: - verbose_name = _('session') - verbose_name_plural = _('sessions') - module_constants = { - 'base64': base64, - 'md5': md5, - 'pickle': pickle, - 'random': random, - 'sys': sys, - } - - def get_decoded(self): - from django.conf.settings import SECRET_KEY - encoded_data = base64.decodestring(self.session_data) - pickled, tamper_check = encoded_data[:-32], encoded_data[-32:] - if md5.new(pickled + SECRET_KEY).hexdigest() != tamper_check: - from django.core.exceptions import SuspiciousOperation - raise SuspiciousOperation, "User tampered with session cookie." - try: - return pickle.loads(pickled) - # Unpickling can cause a variety of exceptions. If something happens, - # just return an empty dictionary (an empty session). - except: - return {} - - def _module_encode(session_dict): - "Returns the given session dictionary pickled and encoded as a string." - from django.conf.settings import SECRET_KEY - pickled = pickle.dumps(session_dict) - pickled_md5 = md5.new(pickled + SECRET_KEY).hexdigest() - return base64.encodestring(pickled + pickled_md5) - - def _module_get_new_session_key(): - "Returns session key that isn't being used." - from django.conf.settings import SECRET_KEY - # The random module is seeded when this Apache child is created. - # Use person_id and SECRET_KEY as added salt. - while 1: - session_key = md5.new(str(random.randint(0, sys.maxint - 1)) + str(random.randint(0, sys.maxint - 1)) + SECRET_KEY).hexdigest() - try: - get_object(session_key__exact=session_key) - except SessionDoesNotExist: - break - return session_key - - def _module_save(session_key, session_dict, expire_date): - s = Session(session_key, encode(session_dict), expire_date) - if session_dict: - s.save() - else: - s.delete() # Clear sessions with no data. - return s diff --git a/django/parts/auth/anonymoususers.py b/django/parts/auth/anonymoususers.py deleted file mode 100644 index fea93e2f5a..0000000000 --- a/django/parts/auth/anonymoususers.py +++ /dev/null @@ -1,44 +0,0 @@ -class AnonymousUser: - id = None - - def __init__(self): - pass - - def __repr__(self): - return 'AnonymousUser' - - def save(self): - raise NotImplementedError - - def delete(self): - raise NotImplementedError - - def set_password(self, raw_password): - raise NotImplementedError - - def check_password(self, raw_password): - raise NotImplementedError - - def get_group_list(self): - return [] - - def set_groups(self, group_id_list): - raise NotImplementedError - - def get_permission_list(self): - return [] - - def set_permissions(self, permission_id_list): - raise NotImplementedError - - def has_perm(self, perm): - return False - - def has_module_perms(self, module): - return False - - def get_and_delete_messages(self): - return [] - - def is_anonymous(self): - return True diff --git a/django/parts/auth/formfields.py b/django/parts/auth/formfields.py deleted file mode 100644 index cfbad248da..0000000000 --- a/django/parts/auth/formfields.py +++ /dev/null @@ -1,46 +0,0 @@ -from django.models.auth import users -from django.core import formfields, validators - -class AuthenticationForm(formfields.Manipulator): - """ - Base class for authenticating users. Extend this to get a form that accepts - username/password logins. - """ - def __init__(self, request=None): - """ - If request is passed in, the manipulator will validate that cookies are - enabled. Note that the request (a HttpRequest object) must have set a - cookie with the key TEST_COOKIE_NAME and value TEST_COOKIE_VALUE before - running this validator. - """ - self.request = request - self.fields = [ - formfields.TextField(field_name="username", length=15, maxlength=30, is_required=True, - validator_list=[self.isValidUser, self.hasCookiesEnabled]), - formfields.PasswordField(field_name="password", length=15, maxlength=30, is_required=True, - validator_list=[self.isValidPasswordForUser]), - ] - self.user_cache = None - - def hasCookiesEnabled(self, field_data, all_data): - if self.request and not self.request.session.test_cookie_worked(): - raise validators.ValidationError, _("Your Web browser doesn't appear to have cookies enabled. Cookies are required for logging in.") - - def isValidUser(self, field_data, all_data): - try: - self.user_cache = users.get_object(username__exact=field_data) - except users.UserDoesNotExist: - raise validators.ValidationError, _("Please enter a correct username and password. Note that both fields are case-sensitive.") - - def isValidPasswordForUser(self, field_data, all_data): - if self.user_cache is not None and not self.user_cache.check_password(field_data): - self.user_cache = None - raise validators.ValidationError, _("Please enter a correct username and password. Note that both fields are case-sensitive.") - - def get_user_id(self): - if self.user_cache: - return self.user_cache.id - return None - - def get_user(self): - return self.user_cache diff --git a/django/parts/media/photos.py b/django/parts/media/photos.py deleted file mode 100644 index a14b3de19b..0000000000 --- a/django/parts/media/photos.py +++ /dev/null @@ -1,6 +0,0 @@ -import re - -def get_thumbnail_url(photo_url, width): - bits = photo_url.split('/') - bits[-1] = re.sub(r'(?i)\.(gif|jpg)$', '_t%s.\\1' % width, bits[-1]) - return '/'.join(bits) diff --git a/django/shortcuts/__init__.py b/django/shortcuts/__init__.py new file mode 100644 index 0000000000..b42ede0339 --- /dev/null +++ b/django/shortcuts/__init__.py @@ -0,0 +1,23 @@ +# This module collects helper functions and classes that "span" multiple levels +# of MVC. In other words, these functions/classes introduce controlled coupling +# for convenience's sake. + +from django.template import loader +from django.http import HttpResponse, Http404 + + +def render_to_response(*args, **kwargs): + return HttpResponse(loader.render_to_string(*args, **kwargs)) +load_and_render = render_to_response # For backwards compatibility. + +def get_object_or_404(klass, **kwargs): + try: + return klass._default_manager.get(**kwargs) + except klass.DoesNotExist: + raise Http404 + +def get_list_or_404(klass, **kwargs): + obj_list = list(klass._default_manager.filter(**kwargs)) + if not obj_list: + raise Http404 + return obj_list diff --git a/django/core/template/__init__.py b/django/template/__init__.py similarity index 90% rename from django/core/template/__init__.py rename to django/template/__init__.py index fe1a9cb338..e32200cccb 100644 --- a/django/core/template/__init__.py +++ b/django/template/__init__.py @@ -57,9 +57,10 @@ times with multiple contexts) import re from inspect import getargspec from django.utils.functional import curry -from django.conf.settings import DEFAULT_CHARSET, TEMPLATE_DEBUG, TEMPLATE_STRING_IF_INVALID +from django.conf import settings +from django.template.context import Context, RequestContext, ContextPopException -__all__ = ('Template','Context','compile_string') +__all__ = ('Template', 'Context', 'RequestContext', 'compile_string') TOKEN_TEXT = 0 TOKEN_VAR = 1 @@ -92,20 +93,12 @@ builtins = [] class TemplateSyntaxError(Exception): pass -class ContextPopException(Exception): - "pop() has been called more times than push()" - pass - class TemplateDoesNotExist(Exception): pass class VariableDoesNotExist(Exception): pass -class SilentVariableFailure(Exception): - "Any function raising this exception will be ignored by resolve_variable" - pass - class InvalidTemplateLibrary(Exception): pass @@ -130,7 +123,7 @@ class StringOrigin(Origin): class Template: def __init__(self, template_string, origin=None): "Compilation stage" - if TEMPLATE_DEBUG and origin == None: + if settings.TEMPLATE_DEBUG and origin == None: origin = StringOrigin(template_string) # Could do some crazy stack-frame stuff to record where this string # came from... @@ -151,58 +144,6 @@ def compile_string(template_string, origin): parser = parser_factory(lexer.tokenize()) return parser.parse() -class Context: - "A stack container for variable context" - def __init__(self, dict=None): - dict = dict or {} - self.dicts = [dict] - - def __repr__(self): - return repr(self.dicts) - - def __iter__(self): - for d in self.dicts: - yield d - - def push(self): - self.dicts = [{}] + self.dicts - - def pop(self): - if len(self.dicts) == 1: - raise ContextPopException - del self.dicts[0] - - def __setitem__(self, key, value): - "Set a variable in the current context" - self.dicts[0][key] = value - - def __getitem__(self, key): - "Get a variable's value, starting at the current context and going upward" - for dict in self.dicts: - if dict.has_key(key): - return dict[key] - return TEMPLATE_STRING_IF_INVALID - - def __delitem__(self, key): - "Delete a variable from the current context" - del self.dicts[0][key] - - def has_key(self, key): - for dict in self.dicts: - if dict.has_key(key): - return True - return False - - def get(self, key, otherwise): - for dict in self.dicts: - if dict.has_key(key): - return dict[key] - return otherwise - - def update(self, other_dict): - "Like dict.update(). Pushes an entire dictionary's keys and values onto the context." - self.dicts = [other_dict] + self.dicts - class Token: def __init__(self, token_type, contents): "The token_type must be TOKEN_TEXT, TOKEN_VAR or TOKEN_BLOCK" @@ -257,7 +198,7 @@ class DebugLexer(Lexer): upto = end last_bit = self.template_string[upto:] if last_bit: - token_tups.append( (last_bit, (upto, upto + len(last_bit))) ) + token_tups.append( (last_bit, (upto, upto + len(last_bit))) ) return [self.create_token(tok, (self.origin, loc)) for tok, loc in token_tups] def create_token(self, token_string, source): @@ -304,7 +245,7 @@ class Parser(object): compiled_result = compile_func(self, token) except TemplateSyntaxError, e: if not self.compile_function_error(token, e): - raise + raise self.extend_nodelist(nodelist, compiled_result, token) self.exit_command() if parse_until: @@ -412,12 +353,19 @@ class DebugParser(Parser): if not hasattr(e, 'source'): e.source = token.source -if TEMPLATE_DEBUG: - lexer_factory = DebugLexer - parser_factory = DebugParser -else: - lexer_factory = Lexer - parser_factory = Parser + +def lexer_factory(*args, **kwargs): + if settings.TEMPLATE_DEBUG: + return DebugLexer(*args, **kwargs) + else: + return Lexer(*args, **kwargs) + +def parser_factory(*args, **kwargs): + if settings.TEMPLATE_DEBUG: + return DebugParser(*args, **kwargs) + else: + return Parser(*args, **kwargs) + class TokenParser: """ @@ -571,9 +519,9 @@ class FilterExpression(object): args = [] constant_arg, i18n_arg, var_arg = match.group("constant_arg", "i18n_arg", "var_arg") if i18n_arg: - args.append((False, _(i18n_arg.replace('\\', '')))) + args.append((False, _(i18n_arg.replace(r'\"', '"')))) elif constant_arg: - args.append((False, constant_arg.replace('\\', ''))) + args.append((False, constant_arg.replace(r'\"', '"'))) elif var_arg: args.append((True, var_arg)) filter_func = parser.find_filter(filter_name) @@ -588,7 +536,7 @@ class FilterExpression(object): try: obj = resolve_variable(self.var, context) except VariableDoesNotExist: - obj = TEMPLATE_STRING_IF_INVALID + obj = settings.TEMPLATE_STRING_IF_INVALID for func, args in self.filters: arg_vals = [] for lookup, arg in args: @@ -636,7 +584,7 @@ def resolve_variable(path, context): """ Returns the resolved variable, which may contain attribute syntax, within the given context. The variable may be a hard-coded string (if it begins - and ends with single or double quote marks), or an integer or float literal. + and ends with single or double quote marks). >>> c = {'article': {'section':'News'}} >>> resolve_variable('article.section', c) @@ -655,9 +603,9 @@ def resolve_variable(path, context): if path[0] in '0123456789': number_type = '.' in path and float or int try: - current = number_type(path) + current = number_type(path) except ValueError: - current = TEMPLATE_STRING_IF_INVALID + current = settings.TEMPLATE_STRING_IF_INVALID elif path[0] in ('"', "'") and path[0] == path[-1]: current = path[1:-1] else: @@ -671,21 +619,29 @@ def resolve_variable(path, context): current = getattr(current, bits[0]) if callable(current): if getattr(current, 'alters_data', False): - current = TEMPLATE_STRING_IF_INVALID + current = settings.TEMPLATE_STRING_IF_INVALID else: try: # method call (assuming no args required) current = current() - except SilentVariableFailure: - current = TEMPLATE_STRING_IF_INVALID except TypeError: # arguments *were* required # GOTCHA: This will also catch any TypeError # raised in the function itself. - current = TEMPLATE_STRING_IF_INVALID # invalid method call + current = settings.TEMPLATE_STRING_IF_INVALID # invalid method call + except Exception, e: + if getattr(e, 'silent_variable_failure', False): + current = settings.TEMPLATE_STRING_IF_INVALID + else: + raise except (TypeError, AttributeError): try: # list-index lookup current = current[int(bits[0])] except (IndexError, ValueError, KeyError): raise VariableDoesNotExist, "Failed lookup for key [%s] in %r" % (bits[0], current) # missing attribute + except Exception, e: + if getattr(e, 'silent_variable_failure', False): + current = settings.TEMPLATE_STRING_IF_INVALID + else: + raise del bits[0] return current @@ -764,7 +720,7 @@ class VariableNode(Node): if not isinstance(output, basestring): return str(output) elif isinstance(output, unicode): - return output.encode(DEFAULT_CHARSET) + return output.encode(settings.DEFAULT_CHARSET) else: return output @@ -775,7 +731,7 @@ class VariableNode(Node): class DebugVariableNode(VariableNode): def render(self, context): try: - output = self.filter_expression.resolve(context) + output = self.filter_expression.resolve(context) except TemplateSyntaxError, e: if not hasattr(e, 'source'): e.source = self.source @@ -888,7 +844,7 @@ class Library(object): dict = func(*args) if not getattr(self, 'nodelist', False): - from django.core.template_loader import get_template + from django.template.loader import get_template t = get_template(file_name) self.nodelist = t.nodelist return self.nodelist.render(context_class(dict)) @@ -916,5 +872,5 @@ def get_library(module_name): def add_to_builtins(module_name): builtins.append(get_library(module_name)) -add_to_builtins('django.core.template.defaulttags') -add_to_builtins('django.core.template.defaultfilters') +add_to_builtins('django.template.defaulttags') +add_to_builtins('django.template.defaultfilters') diff --git a/django/template/context.py b/django/template/context.py new file mode 100644 index 0000000000..f50fb07598 --- /dev/null +++ b/django/template/context.py @@ -0,0 +1,97 @@ +from django.conf import settings +from django.core.exceptions import ImproperlyConfigured + +_standard_context_processors = None + +class ContextPopException(Exception): + "pop() has been called more times than push()" + pass + +class Context: + "A stack container for variable context" + def __init__(self, dict_=None): + dict_ = dict_ or {} + self.dicts = [dict_] + + def __repr__(self): + return repr(self.dicts) + + def __iter__(self): + for d in self.dicts: + yield d + + def push(self): + self.dicts = [{}] + self.dicts + + def pop(self): + if len(self.dicts) == 1: + raise ContextPopException + del self.dicts[0] + + def __setitem__(self, key, value): + "Set a variable in the current context" + self.dicts[0][key] = value + + def __getitem__(self, key): + "Get a variable's value, starting at the current context and going upward" + for d in self.dicts: + if d.has_key(key): + return d[key] + return settings.TEMPLATE_STRING_IF_INVALID + + def __delitem__(self, key): + "Delete a variable from the current context" + del self.dicts[0][key] + + def has_key(self, key): + for d in self.dicts: + if d.has_key(key): + return True + return False + + def get(self, key, otherwise): + for d in self.dicts: + if d.has_key(key): + return d[key] + return otherwise + + def update(self, other_dict): + "Like dict.update(). Pushes an entire dictionary's keys and values onto the context." + self.dicts = [other_dict] + self.dicts + +# This is a function rather than module-level procedural code because we only +# want it to execute if somebody uses RequestContext. +def get_standard_processors(): + global _standard_context_processors + if _standard_context_processors is None: + processors = [] + for path in settings.TEMPLATE_CONTEXT_PROCESSORS: + i = path.rfind('.') + module, attr = path[:i], path[i+1:] + try: + mod = __import__(module, '', '', [attr]) + except ImportError, e: + raise ImproperlyConfigured, 'Error importing request processor module %s: "%s"' % (module, e) + try: + func = getattr(mod, attr) + except AttributeError: + raise ImproperlyConfigured, 'Module "%s" does not define a "%s" callable request processor' % (module, attr) + processors.append(func) + _standard_context_processors = tuple(processors) + return _standard_context_processors + +class RequestContext(Context): + """ + This subclass of template.Context automatically populates itself using + the processors defined in TEMPLATE_CONTEXT_PROCESSORS. + Additional processors can be specified as a list of callables + using the "processors" keyword argument. + """ + def __init__(self, request, dict=None, processors=None): + Context.__init__(self, dict) + if processors is None: + processors = () + else: + processors = tuple(processors) + for processor in get_standard_processors() + processors: + self.update(processor(request)) diff --git a/django/core/template/defaultfilters.py b/django/template/defaultfilters.py similarity index 97% rename from django/core/template/defaultfilters.py rename to django/template/defaultfilters.py index b82d54a31c..fa4975e643 100644 --- a/django/core/template/defaultfilters.py +++ b/django/template/defaultfilters.py @@ -1,7 +1,7 @@ "Default variable filters" -from django.core.template import resolve_variable, Library -from django.conf.settings import DATE_FORMAT, TIME_FORMAT +from django.template import resolve_variable, Library +from django.conf import settings from django.utils.translation import gettext import re import random as random_module @@ -133,7 +133,7 @@ def wordwrap(value, arg): """ Wraps words at specified line length - Argument: number of characters at which to wrap the text + Argument: number of words to wrap the text at. """ from django.utils.text import wrap return wrap(str(value), int(arg)) @@ -327,12 +327,12 @@ def get_digit(value, arg): # DATES # ################### -def date(value, arg=DATE_FORMAT): +def date(value, arg=settings.DATE_FORMAT): "Formats a date according to the given format" from django.utils.dateformat import format return format(value, arg) -def time(value, arg=TIME_FORMAT): +def time(value, arg=settings.TIME_FORMAT): "Formats a time according to the given format" from django.utils.dateformat import time_format return time_format(value, arg) @@ -431,8 +431,11 @@ def phone2numeric(value): def pprint(value): "A wrapper around pprint.pprint -- for debugging, really" from pprint import pformat - return pformat(value) - + try: + return pformat(value) + except Exception, e: + return "Error in formatting:%s" % e + # Syntax: register.filter(name of filter, callback) register.filter(add) register.filter(addslashes) diff --git a/django/core/template/defaulttags.py b/django/template/defaulttags.py similarity index 97% rename from django/core/template/defaulttags.py rename to django/template/defaulttags.py index 1438b9f74a..18f1b9ab30 100644 --- a/django/core/template/defaulttags.py +++ b/django/template/defaulttags.py @@ -1,8 +1,9 @@ "Default tags used by the template system, available to all templates." -from django.core.template import Node, NodeList, Template, Context, resolve_variable -from django.core.template import TemplateSyntaxError, VariableDoesNotExist, BLOCK_TAG_START, BLOCK_TAG_END, VARIABLE_TAG_START, VARIABLE_TAG_END -from django.core.template import get_library, Library, InvalidTemplateLibrary +from django.template import Node, NodeList, Template, Context, resolve_variable +from django.template import TemplateSyntaxError, VariableDoesNotExist, BLOCK_TAG_START, BLOCK_TAG_END, VARIABLE_TAG_START, VARIABLE_TAG_END +from django.template import get_library, Library, InvalidTemplateLibrary +from django.conf import settings import sys register = Library() @@ -121,7 +122,12 @@ class IfChangedNode(Node): def render(self, context): content = self.nodelist.render(context) if content != self._last_seen: + firstloop = (self._last_seen == None) self._last_seen = content + context.push() + context['ifchanged'] = {'firstloop': firstloop} + content = self.nodelist.render(context) + context.pop() return content else: return '' @@ -196,8 +202,7 @@ class RegroupNode(Node): return '' def include_is_allowed(filepath): - from django.conf.settings import ALLOWED_INCLUDE_ROOTS - for root in ALLOWED_INCLUDE_ROOTS: + for root in settings.ALLOWED_INCLUDE_ROOTS: if filepath.startswith(root): return True return False @@ -207,9 +212,8 @@ class SsiNode(Node): self.filepath, self.parsed = filepath, parsed def render(self, context): - from django.conf.settings import DEBUG if not include_is_allowed(self.filepath): - if DEBUG: + if settings.DEBUG: return "[Didn't have permission to include file]" else: return '' # Fail silently for invalid includes. @@ -224,7 +228,7 @@ class SsiNode(Node): t = Template(output) return t.render(context) except TemplateSyntaxError, e: - if DEBUG: + if settings.DEBUG: return "[Included template had syntax error: %s]" % e else: return '' # Fail silently for invalid included templates. @@ -340,6 +344,8 @@ def cycle(parser, token): elif len(args) == 2: name = args[1] + if not hasattr(parser, '_namedCycleNodes'): + raise TemplateSyntaxError("No named cycles in template: '%s' is not defined" % name) if not parser._namedCycleNodes.has_key(name): raise TemplateSyntaxError("Named cycle '%s' does not exist" % name) return parser._namedCycleNodes[name] diff --git a/django/core/template/loader.py b/django/template/loader.py similarity index 94% rename from django/core/template/loader.py rename to django/template/loader.py index 3d83a1494f..ebca582ef9 100644 --- a/django/core/template/loader.py +++ b/django/template/loader.py @@ -21,8 +21,8 @@ # installed, because pkg_resources is necessary to read eggs. from django.core.exceptions import ImproperlyConfigured -from django.core.template import Origin, StringOrigin, Template, Context, TemplateDoesNotExist, add_to_builtins -from django.conf.settings import TEMPLATE_LOADERS, TEMPLATE_DEBUG +from django.template import Origin, StringOrigin, Template, Context, TemplateDoesNotExist, add_to_builtins +from django.conf import settings template_source_loaders = None @@ -35,7 +35,7 @@ class LoaderOrigin(Origin): return self.loader(self.loadname, self.dirs)[0] def make_origin(display_name, loader, name, dirs): - if TEMPLATE_DEBUG: + if settings.TEMPLATE_DEBUG: return LoaderOrigin(display_name, loader, name, dirs) else: return None @@ -47,7 +47,7 @@ def find_template_source(name, dirs=None): global template_source_loaders if template_source_loaders is None: template_source_loaders = [] - for path in TEMPLATE_LOADERS: + for path in settings.TEMPLATE_LOADERS: i = path.rfind('.') module, attr = path[:i], path[i+1:] try: @@ -113,4 +113,4 @@ def select_template(template_name_list): # If we get here, none of the templates could be loaded raise TemplateDoesNotExist, ', '.join(template_name_list) -add_to_builtins('django.core.template.loader_tags') +add_to_builtins('django.template.loader_tags') diff --git a/django/core/template/loader_tags.py b/django/template/loader_tags.py similarity index 89% rename from django/core/template/loader_tags.py rename to django/template/loader_tags.py index 238ece348c..e0d9a70a98 100644 --- a/django/core/template/loader_tags.py +++ b/django/template/loader_tags.py @@ -1,7 +1,8 @@ -from django.core.template import TemplateSyntaxError, TemplateDoesNotExist, resolve_variable -from django.core.template import Library, Context, Node -from django.core.template.loader import get_template, get_template_from_string, find_template_source -from django.conf.settings import TEMPLATE_DEBUG +from django.template import TemplateSyntaxError, TemplateDoesNotExist, resolve_variable +from django.template import Library, Context, Node +from django.template.loader import get_template, get_template_from_string, find_template_source +from django.conf import settings + register = Library() class ExtendsError(Exception): @@ -84,8 +85,8 @@ class ConstantIncludeNode(Node): t = get_template(template_path) self.template = t except: - if TEMPLATE_DEBUG: - raise + if settings.TEMPLATE_DEBUG: + raise self.template = None def render(self, context): @@ -99,16 +100,16 @@ class IncludeNode(Node): self.template_name = template_name def render(self, context): - try: - template_name = resolve_variable(self.template_name, context) - t = get_template(template_name) - return t.render(context) - except TemplateSyntaxError, e: - if TEMPLATE_DEBUG: + try: + template_name = resolve_variable(self.template_name, context) + t = get_template(template_name) + return t.render(context) + except TemplateSyntaxError, e: + if settings.TEMPLATE_DEBUG: raise - return '' - except: - return '' # Fail silently for invalid included templates. + return '' + except: + return '' # Fail silently for invalid included templates. def do_block(parser, token): """ diff --git a/django/template/loaders/__init__.py b/django/template/loaders/__init__.py new file mode 100644 index 0000000000..e69de29bb2 diff --git a/django/core/template/loaders/app_directories.py b/django/template/loaders/app_directories.py similarity index 84% rename from django/core/template/loaders/app_directories.py rename to django/template/loaders/app_directories.py index 390e47852e..8a9bfef4b6 100644 --- a/django/core/template/loaders/app_directories.py +++ b/django/template/loaders/app_directories.py @@ -1,13 +1,13 @@ # Wrapper for loading templates from "template" directories in installed app packages. -from django.conf.settings import INSTALLED_APPS, TEMPLATE_FILE_EXTENSION +from django.conf import settings from django.core.exceptions import ImproperlyConfigured -from django.core.template import TemplateDoesNotExist +from django.template import TemplateDoesNotExist import os # At compile time, cache the directories to search. app_template_dirs = [] -for app in INSTALLED_APPS: +for app in settings.INSTALLED_APPS: i = app.rfind('.') if i == -1: m, a = app, None @@ -29,7 +29,7 @@ app_template_dirs = tuple(app_template_dirs) def get_template_sources(template_name, template_dirs=None): for template_dir in app_template_dirs: - yield os.path.join(template_dir, template_name) + TEMPLATE_FILE_EXTENSION + yield os.path.join(template_dir, template_name) def load_template_source(template_name, template_dirs=None): for filepath in get_template_sources(template_name, template_dirs): diff --git a/django/core/template/loaders/eggs.py b/django/template/loaders/eggs.py similarity index 74% rename from django/core/template/loaders/eggs.py rename to django/template/loaders/eggs.py index 5d48326dce..6184aeaccf 100644 --- a/django/core/template/loaders/eggs.py +++ b/django/template/loaders/eggs.py @@ -5,8 +5,8 @@ try: except ImportError: resource_string = None -from django.core.template import TemplateDoesNotExist -from django.conf.settings import INSTALLED_APPS, TEMPLATE_FILE_EXTENSION +from django.template import TemplateDoesNotExist +from django.conf import settings def load_template_source(template_name, template_dirs=None): """ @@ -15,8 +15,8 @@ def load_template_source(template_name, template_dirs=None): For every installed app, it tries to get the resource (app, template_name). """ if resource_string is not None: - pkg_name = 'templates/' + template_name + TEMPLATE_FILE_EXTENSION - for app in INSTALLED_APPS: + pkg_name = 'templates/' + template_name + for app in settings.INSTALLED_APPS: try: return (resource_string(app, pkg_name), 'egg:%s:%s ' % (app, pkg_name)) except: diff --git a/django/core/template/loaders/filesystem.py b/django/template/loaders/filesystem.py similarity index 74% rename from django/core/template/loaders/filesystem.py rename to django/template/loaders/filesystem.py index 23ce6cd9e4..0c94021fb8 100644 --- a/django/core/template/loaders/filesystem.py +++ b/django/template/loaders/filesystem.py @@ -1,14 +1,14 @@ # Wrapper for loading templates from the filesystem. -from django.conf.settings import TEMPLATE_DIRS, TEMPLATE_FILE_EXTENSION -from django.core.template import TemplateDoesNotExist +from django.conf import settings +from django.template import TemplateDoesNotExist import os def get_template_sources(template_name, template_dirs=None): if not template_dirs: - template_dirs = TEMPLATE_DIRS + template_dirs = settings.TEMPLATE_DIRS for template_dir in template_dirs: - yield os.path.join(template_dir, template_name) + TEMPLATE_FILE_EXTENSION + yield os.path.join(template_dir, template_name) def load_template_source(template_name, template_dirs=None): tried = [] diff --git a/django/templatetags/__init__.py b/django/templatetags/__init__.py index 538da5b354..62374577ea 100644 --- a/django/templatetags/__init__.py +++ b/django/templatetags/__init__.py @@ -1,6 +1,6 @@ -from django.conf.settings import INSTALLED_APPS +from django.conf import settings -for a in INSTALLED_APPS: +for a in settings.INSTALLED_APPS: try: __path__.extend(__import__(a + '.templatetags', '', '', ['']).__path__) except ImportError: diff --git a/django/templatetags/i18n.py b/django/templatetags/i18n.py index 7c2019cac0..0c601535af 100644 --- a/django/templatetags/i18n.py +++ b/django/templatetags/i18n.py @@ -1,6 +1,6 @@ -from django.core.template import Node, NodeList, Template, Context, resolve_variable -from django.core.template import TemplateSyntaxError, TokenParser, Library -from django.core.template import TOKEN_BLOCK, TOKEN_TEXT, TOKEN_VAR +from django.template import Node, NodeList, Template, Context, resolve_variable +from django.template import TemplateSyntaxError, TokenParser, Library +from django.template import TOKEN_BLOCK, TOKEN_TEXT, TOKEN_VAR from django.utils import translation import re, sys @@ -11,8 +11,8 @@ class GetAvailableLanguagesNode(Node): self.variable = variable def render(self, context): - from django.conf.settings import LANGUAGES - context[self.variable] = LANGUAGES + from django.conf import settings + context[self.variable] = settings.LANGUAGES return '' class GetCurrentLanguageNode(Node): diff --git a/django/utils/cache.py b/django/utils/cache.py index b888cef179..5eba302ebe 100644 --- a/django/utils/cache.py +++ b/django/utils/cache.py @@ -80,8 +80,17 @@ def patch_response_headers(response, cache_timeout=None): if not response.has_header('Expires'): expires = now + datetime.timedelta(0, cache_timeout) response['Expires'] = expires.strftime('%a, %d %b %Y %H:%M:%S GMT') + if cache_timeout < 0: + cache_timeout = 0 # Can't have max-age negative patch_cache_control(response, max_age=cache_timeout) +def add_never_cache_headers(response): + """ + Add headers to a response to indicate that + a page should never be cached. + """ + patch_response_headers(response, cache_timeout=-1) + def patch_vary_headers(response, newheaders): """ Adds (or updates) the "Vary" header in the given HttpResponse object. diff --git a/django/utils/datastructures.py b/django/utils/datastructures.py index 20aa30bcff..bc8fb07ef5 100644 --- a/django/utils/datastructures.py +++ b/django/utils/datastructures.py @@ -40,6 +40,43 @@ class MergeDict: return True return False +class SortedDict(dict): + "A dictionary that keeps its keys in the order in which they're inserted." + def __init__(self, data={}): + dict.__init__(self, data) + self.keyOrder = data.keys() + + def __setitem__(self, key, value): + dict.__setitem__(self, key, value) + if key not in self.keyOrder: + self.keyOrder.append(key) + + def __delitem__(self, key): + dict.__delitem__(self, key) + self.keyOrder.remove(key) + + def __iter__(self): + for k in self.keyOrder: + yield k + + def items(self): + return zip(self.keyOrder, self.values()) + + def keys(self): + return self.keyOrder[:] + + def values(self): + return [dict.__getitem__(self,k) for k in self.keyOrder] + + def update(self, dict): + for k, v in dict.items(): + self.__setitem__(k, v) + + def setdefault(self, key, default): + if key not in self.keyOrder: + self.keyOrder.append(key) + return dict.setdefault(self, key, default) + class MultiValueDictKeyError(KeyError): pass @@ -193,4 +230,4 @@ class DotExpandedDict(dict): try: current[bits[-1]] = v except TypeError: # Special-case if current isn't a dict. - current = {bits[-1]: v} + current = {bits[-1] : v} diff --git a/django/utils/feedgenerator.py b/django/utils/feedgenerator.py index 22db5abe7f..f7c25f2933 100644 --- a/django/utils/feedgenerator.py +++ b/django/utils/feedgenerator.py @@ -21,8 +21,6 @@ http://diveintomark.org/archives/2004/02/04/incompatible-rss from django.utils.xmlutils import SimplerXMLGenerator import datetime, re, time import email.Utils -from xml.dom import minidom -from xml.parsers.expat import ExpatError def rfc2822_date(date): return email.Utils.formatdate(time.mktime(date.timetuple())) @@ -158,9 +156,11 @@ class Rss201rev2Feed(RssFeed): handler.addQuickElement(u"description", item['description']) # Author information. - if item['author_email'] is not None and item['author_name'] is not None: - handler.addQuickElement(u"author", u"%s (%s)" % \ + if item["author_name"] and item["author_email"]: + handler.addQuickElement(u"author", "%s (%s)" % \ (item['author_email'], item['author_name'])) + elif item["author_email"]: + handler.addQuickElement(u"author", item["author_email"]) if item['pubdate'] is not None: handler.addQuickElement(u"pubDate", rfc2822_date(item['pubdate']).decode('ascii')) diff --git a/django/utils/functional.py b/django/utils/functional.py index 69aeb81850..d1514d5728 100644 --- a/django/utils/functional.py +++ b/django/utils/functional.py @@ -24,14 +24,14 @@ def lazy(func, *resultclasses): # the evaluation and store the result. Afterwards, the result # is delivered directly. So the result is memoized. def __init__(self, args, kw): - self.__func = func - self.__args = args - self.__kw = kw - self.__dispatch = {} - for resultclass in resultclasses: - self.__dispatch[resultclass] = {} - for (k, v) in resultclass.__dict__.items(): - setattr(self, k, self.__promise__(resultclass, k, v)) + self.__func = func + self.__args = args + self.__kw = kw + self.__dispatch = {} + for resultclass in resultclasses: + self.__dispatch[resultclass] = {} + for (k, v) in resultclass.__dict__.items(): + setattr(self, k, self.__promise__(resultclass, k, v)) def __promise__(self, klass, funcname, func): # Builds a wrapper around some magic method and registers that magic diff --git a/django/utils/html.py b/django/utils/html.py index 6c9779a156..a0d1e82dcf 100644 --- a/django/utils/html.py +++ b/django/utils/html.py @@ -25,7 +25,7 @@ def escape(html): "Returns the given HTML with ampersands, quotes and carets encoded" if not isinstance(html, basestring): html = str(html) - return html.replace('&', '&').replace('<', '<').replace('>', '>').replace('"', '"') + return html.replace('&', '&').replace('<', '<').replace('>', '>').replace('"', '"').replace("'", ''') def linebreaks(value): "Converts newlines into and
s"
diff --git a/django/utils/termcolors.py b/django/utils/termcolors.py
new file mode 100644
index 0000000000..3ce1d5bb6b
--- /dev/null
+++ b/django/utils/termcolors.py
@@ -0,0 +1,70 @@
+"""
+termcolors.py
+"""
+
+import types
+
+color_names = ('black', 'red', 'green', 'yellow', 'blue', 'magenta', 'cyan', 'white')
+foreground = dict([(color_names[x], '3%s' % x) for x in range(8)])
+background = dict([(color_names[x], '4%s' % x) for x in range(8)])
+del color_names
+
+RESET = '0'
+opt_dict = {'bold': '1', 'underscore': '4', 'blink': '5', 'reverse': '7', 'conceal': '8'}
+
+def colorize(text='', opts=(), **kwargs):
+ """
+ Returns your text, enclosed in ANSI graphics codes.
+
+ Depends on the keyword arguments 'fg' and 'bg', and the contents of
+ the opts tuple/list.
+
+ Returns the RESET code if no parameters are given.
+
+ Valid colors:
+ 'black', 'red', 'green', 'yellow', 'blue', 'magenta', 'cyan', 'white'
+
+ Valid options:
+ 'bold'
+ 'underscore'
+ 'blink'
+ 'reverse'
+ 'conceal'
+ 'noreset' - string will not be auto-terminated with the RESET code
+
+ Examples:
+ colorize('hello', fg='red', bg='blue', opts=('blink',))
+ colorize()
+ colorize('goodbye', opts=('underscore',))
+ print colorize('first line', fg='red', opts=('noreset',))
+ print 'this should be red too'
+ print colorize('and so should this')
+ print 'this should not be red'
+ """
+ text = str(text)
+ code_list = []
+ if text == '' and len(opts) == 1 and opts[0] == 'reset':
+ return '\x1b[%sm' % RESET
+ for k, v in kwargs.iteritems():
+ if k == 'fg':
+ code_list.append(foreground[v])
+ elif k == 'bg':
+ code_list.append(background[v])
+ for o in opts:
+ if o in opt_dict:
+ code_list.append(opt_dict[o])
+ if 'noreset' not in opts:
+ text = text + '\x1b[%sm' % RESET
+ return ('\x1b[%sm' % ';'.join(code_list)) + text
+
+def make_style(opts=(), **kwargs):
+ """
+ Returns a function with default parameters for colorize()
+
+ Example:
+ bold_red = make_style(opts=('bold',), fg='red')
+ print bold_red('hello')
+ KEYWORD = make_style(fg='yellow')
+ COMMENT = make_style(fg='blue', opts=('bold',))
+ """
+ return lambda text: colorize(text, opts, **kwargs)
diff --git a/django/utils/text.py b/django/utils/text.py
index ce1225b83c..7b6e1182ab 100644
--- a/django/utils/text.py
+++ b/django/utils/text.py
@@ -1,6 +1,6 @@
import re
-from django.conf.settings import DEFAULT_CHARSET
+from django.conf import settings
# Capitalizes the first letter of a string.
capfirst = lambda x: x and x[0].upper() + x[1:]
@@ -100,7 +100,7 @@ def javascript_quote(s):
return r"\u%04x" % ord(match.group(1))
if type(s) == str:
- s = s.decode(DEFAULT_CHARSET)
+ s = s.decode(settings.DEFAULT_CHARSET)
elif type(s) != unicode:
raise TypeError, s
s = s.replace('\\', '\\\\')
diff --git a/django/utils/timesince.py b/django/utils/timesince.py
index a16616584b..bc4f969dc4 100644
--- a/django/utils/timesince.py
+++ b/django/utils/timesince.py
@@ -11,6 +11,7 @@ def timesince(d, now=None):
chunks = (
(60 * 60 * 24 * 365, lambda n: ngettext('year', 'years', n)),
(60 * 60 * 24 * 30, lambda n: ngettext('month', 'months', n)),
+ (60 * 60 * 24 * 7, lambda n : ngettext('week', 'weeks', n)),
(60 * 60 * 24, lambda n : ngettext('day', 'days', n)),
(60 * 60, lambda n: ngettext('hour', 'hours', n)),
(60, lambda n: ngettext('minute', 'minutes', n))
diff --git a/django/utils/translation.py b/django/utils/translation.py
index 56cd5426f0..a877f60009 100644
--- a/django/utils/translation.py
+++ b/django/utils/translation.py
@@ -115,7 +115,7 @@ def translation(language):
if sys.version_info < (2, 4):
klass = DjangoTranslation23
- globalpath = os.path.join(os.path.dirname(settings.__file__), 'locale')
+ globalpath = os.path.join(os.path.dirname(sys.modules[settings.__module__].__file__), 'locale')
parts = settings.SETTINGS_MODULE.split('.')
project = __import__(parts[0], {}, {}, [])
@@ -209,8 +209,8 @@ def get_language():
except AttributeError:
pass
# If we don't have a real translation object, assume it's the default language.
- from django.conf.settings import LANGUAGE_CODE
- return LANGUAGE_CODE
+ from django.conf import settings
+ return settings.LANGUAGE_CODE
def catalog():
"""
@@ -275,7 +275,7 @@ def check_for_language(lang_code):
only used for language codes from either the cookies or session.
"""
from django.conf import settings
- globalpath = os.path.join(os.path.dirname(settings.__file__), 'locale')
+ globalpath = os.path.join(os.path.dirname(sys.modules[settings.__module__].__file__), 'locale')
if gettext_module.find('django', globalpath, [to_locale(lang_code)]) is not None:
return True
else:
@@ -289,7 +289,7 @@ def get_language_from_request(request):
"""
global _accepted
from django.conf import settings
- globalpath = os.path.join(os.path.dirname(settings.__file__), 'locale')
+ globalpath = os.path.join(os.path.dirname(sys.modules[settings.__module__].__file__), 'locale')
supported = dict(settings.LANGUAGES)
if hasattr(request, 'session'):
@@ -346,16 +346,16 @@ def get_date_formats():
technical message ID to store date and time formats. If it doesn't contain
one, the formats provided in the settings will be used.
"""
- from django.conf.settings import DATE_FORMAT, DATETIME_FORMAT, TIME_FORMAT
+ from django.conf import settings
date_format = _('DATE_FORMAT')
datetime_format = _('DATETIME_FORMAT')
time_format = _('TIME_FORMAT')
if date_format == 'DATE_FORMAT':
- date_format = DATE_FORMAT
+ date_format = settings.DATE_FORMAT
if datetime_format == 'DATETIME_FORMAT':
- datetime_format = DATETIME_FORMAT
+ datetime_format = settings.DATETIME_FORMAT
if time_format == 'TIME_FORMAT':
- time_format = TIME_FORMAT
+ time_format = settings.TIME_FORMAT
return (date_format, datetime_format, time_format)
def install():
@@ -384,7 +384,7 @@ def templatize(src):
does so by translating the Django translation tags into standard gettext
function invocations.
"""
- from django.core.template import Lexer, TOKEN_TEXT, TOKEN_VAR, TOKEN_BLOCK
+ from django.template import Lexer, TOKEN_TEXT, TOKEN_VAR, TOKEN_BLOCK
out = StringIO()
intrans = False
inplural = False
@@ -457,3 +457,13 @@ def templatize(src):
else:
out.write(blankout(t.contents, 'X'))
return out.getvalue()
+
+def string_concat(*strings):
+ """"
+ lazy variant of string concatenation, needed for translations that are
+ constructed from multiple parts. Handles lazy strings and non-strings by
+ first turning all arguments to strings, before joining them.
+ """
+ return ''.join([str(el) for el in strings])
+
+string_concat = lazy(string_concat, str)
diff --git a/django/views/auth/login.py b/django/views/auth/login.py
deleted file mode 100644
index 3f2bd43015..0000000000
--- a/django/views/auth/login.py
+++ /dev/null
@@ -1,49 +0,0 @@
-from django.parts.auth.formfields import AuthenticationForm
-from django.core import formfields
-from django.core.extensions import DjangoContext, render_to_response
-from django.models.auth import users
-from django.models.core import sites
-from django.utils.httpwrappers import HttpResponse, HttpResponseRedirect
-
-REDIRECT_FIELD_NAME = 'next'
-LOGIN_URL = '/accounts/login/'
-
-def login(request):
- "Displays the login form and handles the login action."
- manipulator = AuthenticationForm(request)
- redirect_to = request.REQUEST.get(REDIRECT_FIELD_NAME, '')
- if request.POST:
- errors = manipulator.get_validation_errors(request.POST)
- if not errors:
- # Light security check -- make sure redirect_to isn't garbage.
- if not redirect_to or '://' in redirect_to or ' ' in redirect_to:
- redirect_to = '/accounts/profile/'
- request.session[users.SESSION_KEY] = manipulator.get_user_id()
- request.session.delete_test_cookie()
- return HttpResponseRedirect(redirect_to)
- else:
- errors = {}
- request.session.set_test_cookie()
- return render_to_response('registration/login', {
- 'form': formfields.FormWrapper(manipulator, request.POST, errors),
- REDIRECT_FIELD_NAME: redirect_to,
- 'site_name': sites.get_current().name,
- }, context_instance=DjangoContext(request))
-
-def logout(request, next_page=None):
- "Logs out the user and displays 'You are logged out' message."
- try:
- del request.session[users.SESSION_KEY]
- except KeyError:
- return render_to_response('registration/logged_out', context_instance=DjangoContext(request))
- else:
- # Redirect to this page until the session has been cleared.
- return HttpResponseRedirect(next_page or request.path)
-
-def logout_then_login(request, login_url=LOGIN_URL):
- "Logs out the user if he is logged in. Then redirects to the log-in page."
- return logout(request, login_url)
-
-def redirect_to_login(next, login_url=LOGIN_URL):
- "Redirects the user to the login page, passing the given 'next' page"
- return HttpResponseRedirect('%s?%s=%s' % (login_url, REDIRECT_FIELD_NAME, next))
diff --git a/django/views/debug.py b/django/views/debug.py
index b08a56a524..aa0a93b863 100644
--- a/django/views/debug.py
+++ b/django/views/debug.py
@@ -1,7 +1,7 @@
from django.conf import settings
-from django.core.template import Template, Context, TemplateDoesNotExist
+from django.template import Template, Context, TemplateDoesNotExist
from django.utils.html import escape
-from django.utils.httpwrappers import HttpResponseServerError, HttpResponseNotFound
+from django.http import HttpResponseServerError, HttpResponseNotFound
import os, re
from itertools import count, izip
from os.path import dirname, join as pathjoin
@@ -72,7 +72,7 @@ def technical_500_response(request, exc_type, exc_value, tb):
template_does_not_exist = False
loader_debug_info = None
if issubclass(exc_type, TemplateDoesNotExist):
- from django.core.template.loader import template_source_loaders
+ from django.template.loader import template_source_loaders
template_does_not_exist = True
loader_debug_info = []
for loader in template_source_loaders:
@@ -641,8 +641,8 @@ EMPTY_URLCONF_TEMPLATE = """
Of course, you haven't actually done any work yet. Here's what to do next:
-
-
- \\n\\t\\t
- item 1.1 \\n\\t
- \n\t\t
- item 1.1 \n\t
- \\n\\t\\t
- item 1.1 \\n\\t\\t
- item 1.2 \\n\\t
- \n\t\t
- item 1.1 \n\t\t
- item 1.2 \n\t