From fe407193c200e03070928c1e2c1a6e067d32893d Mon Sep 17 00:00:00 2001
From: coderick14
Date: Wed, 17 May 2017 15:40:18 +0530
Subject: Upgrade to Django 1.11

- Database integration yet to be tested
---
 .../site-packages/django/contrib/admin/options.py  | 1718 --------------------
 1 file changed, 1718 deletions(-)
 delete mode 100644 lib/python2.7/site-packages/django/contrib/admin/options.py

(limited to 'lib/python2.7/site-packages/django/contrib/admin/options.py')

diff --git a/lib/python2.7/site-packages/django/contrib/admin/options.py b/lib/python2.7/site-packages/django/contrib/admin/options.py
deleted file mode 100644
index 9dddcb0..0000000
--- a/lib/python2.7/site-packages/django/contrib/admin/options.py
+++ /dev/null
@@ -1,1718 +0,0 @@
-import copy
-import operator
-from functools import partial, reduce, update_wrapper
-
-from django import forms
-from django.conf import settings
-from django.contrib import messages
-from django.contrib.admin import widgets, helpers
-from django.contrib.admin.util import (unquote, flatten_fieldsets, get_deleted_objects,
-    model_format_dict, NestedObjects, lookup_needs_distinct)
-from django.contrib.admin import validation
-from django.contrib.admin.templatetags.admin_static import static
-from django.contrib.admin.templatetags.admin_urls import add_preserved_filters
-from django.contrib.auth import get_permission_codename
-from django.contrib.contenttypes.models import ContentType
-from django.core.exceptions import PermissionDenied, ValidationError, FieldError
-from django.core.paginator import Paginator
-from django.core.urlresolvers import reverse
-from django.db import models, transaction, router
-from django.db.models.constants import LOOKUP_SEP
-from django.db.models.related import RelatedObject
-from django.db.models.fields import BLANK_CHOICE_DASH, FieldDoesNotExist
-from django.db.models.sql.constants import QUERY_TERMS
-from django.forms.formsets import all_valid, DELETION_FIELD_NAME
-from django.forms.models import (modelform_factory, modelformset_factory,
-    inlineformset_factory, BaseInlineFormSet, modelform_defines_fields)
-from django.http import Http404, HttpResponseRedirect
-from django.http.response import HttpResponseBase
-from django.shortcuts import get_object_or_404
-from django.template.response import SimpleTemplateResponse, TemplateResponse
-from django.utils.decorators import method_decorator
-from django.utils.datastructures import SortedDict
-from django.utils.html import escape, escapejs
-from django.utils.safestring import mark_safe
-from django.utils import six
-from django.utils.deprecation import RenameMethodsBase
-from django.utils.http import urlencode
-from django.utils.text import capfirst, get_text_list
-from django.utils.translation import ugettext as _
-from django.utils.translation import ungettext
-from django.utils.encoding import force_text
-from django.views.decorators.csrf import csrf_protect
-
-
-IS_POPUP_VAR = '_popup'
-
-HORIZONTAL, VERTICAL = 1, 2
-# returns the <ul> class for a given radio_admin field
-get_ul_class = lambda x: 'radiolist%s' % (' inline' if x == HORIZONTAL else '')
-
-
-class IncorrectLookupParameters(Exception):
-    pass
-
-# Defaults for formfield_overrides. ModelAdmin subclasses can change this
-# by adding to ModelAdmin.formfield_overrides.
-
-FORMFIELD_FOR_DBFIELD_DEFAULTS = {
-    models.DateTimeField: {
-        'form_class': forms.SplitDateTimeField,
-        'widget': widgets.AdminSplitDateTime
-    },
-    models.DateField: {'widget': widgets.AdminDateWidget},
-    models.TimeField: {'widget': widgets.AdminTimeWidget},
-    models.TextField: {'widget': widgets.AdminTextareaWidget},
-    models.URLField: {'widget': widgets.AdminURLFieldWidget},
-    models.IntegerField: {'widget': widgets.AdminIntegerFieldWidget},
-    models.BigIntegerField: {'widget': widgets.AdminBigIntegerFieldWidget},
-    models.CharField: {'widget': widgets.AdminTextInputWidget},
-    models.ImageField: {'widget': widgets.AdminFileWidget},
-    models.FileField: {'widget': widgets.AdminFileWidget},
-    models.EmailField: {'widget': widgets.AdminEmailInputWidget},
-}
-
-csrf_protect_m = method_decorator(csrf_protect)
-
-
-class RenameBaseModelAdminMethods(forms.MediaDefiningClass, RenameMethodsBase):
-    renamed_methods = (
-        ('queryset', 'get_queryset', PendingDeprecationWarning),
-    )
-
-
-class BaseModelAdmin(six.with_metaclass(RenameBaseModelAdminMethods)):
-    """Functionality common to both ModelAdmin and InlineAdmin."""
-
-    raw_id_fields = ()
-    fields = None
-    exclude = None
-    fieldsets = None
-    form = forms.ModelForm
-    filter_vertical = ()
-    filter_horizontal = ()
-    radio_fields = {}
-    prepopulated_fields = {}
-    formfield_overrides = {}
-    readonly_fields = ()
-    ordering = None
-
-    # validation
-    validator_class = validation.BaseValidator
-
-    @classmethod
-    def validate(cls, model):
-        validator = cls.validator_class()
-        validator.validate(cls, model)
-
-    def __init__(self):
-        overrides = FORMFIELD_FOR_DBFIELD_DEFAULTS.copy()
-        overrides.update(self.formfield_overrides)
-        self.formfield_overrides = overrides
-
-    def formfield_for_dbfield(self, db_field, **kwargs):
-        """
-        Hook for specifying the form Field instance for a given database Field
-        instance.
-
-        If kwargs are given, they're passed to the form Field's constructor.
-        """
-        request = kwargs.pop("request", None)
-
-        # If the field specifies choices, we don't need to look for special
-        # admin widgets - we just need to use a select widget of some kind.
-        if db_field.choices:
-            return self.formfield_for_choice_field(db_field, request, **kwargs)
-
-        # ForeignKey or ManyToManyFields
-        if isinstance(db_field, (models.ForeignKey, models.ManyToManyField)):
-            # Combine the field kwargs with any options for formfield_overrides.
-            # Make sure the passed in **kwargs override anything in
-            # formfield_overrides because **kwargs is more specific, and should
-            # always win.
-            if db_field.__class__ in self.formfield_overrides:
-                kwargs = dict(self.formfield_overrides[db_field.__class__], **kwargs)
-
-            # Get the correct formfield.
-            if isinstance(db_field, models.ForeignKey):
-                formfield = self.formfield_for_foreignkey(db_field, request, **kwargs)
-            elif isinstance(db_field, models.ManyToManyField):
-                formfield = self.formfield_for_manytomany(db_field, request, **kwargs)
-
-            # For non-raw_id fields, wrap the widget with a wrapper that adds
-            # extra HTML -- the "add other" interface -- to the end of the
-            # rendered output. formfield can be None if it came from a
-            # OneToOneField with parent_link=True or a M2M intermediary.
-            if formfield and db_field.name not in self.raw_id_fields:
-                related_modeladmin = self.admin_site._registry.get(
-                                                            db_field.rel.to)
-                can_add_related = bool(related_modeladmin and
-                            related_modeladmin.has_add_permission(request))
-                formfield.widget = widgets.RelatedFieldWidgetWrapper(
-                            formfield.widget, db_field.rel, self.admin_site,
-                            can_add_related=can_add_related)
-
-            return formfield
-
-        # If we've got overrides for the formfield defined, use 'em. **kwargs
-        # passed to formfield_for_dbfield override the defaults.
-        for klass in db_field.__class__.mro():
-            if klass in self.formfield_overrides:
-                kwargs = dict(copy.deepcopy(self.formfield_overrides[klass]), **kwargs)
-                return db_field.formfield(**kwargs)
-
-        # For any other type of field, just call its formfield() method.
-        return db_field.formfield(**kwargs)
-
-    def formfield_for_choice_field(self, db_field, request=None, **kwargs):
-        """
-        Get a form Field for a database Field that has declared choices.
-        """
-        # If the field is named as a radio_field, use a RadioSelect
-        if db_field.name in self.radio_fields:
-            # Avoid stomping on custom widget/choices arguments.
-            if 'widget' not in kwargs:
-                kwargs['widget'] = widgets.AdminRadioSelect(attrs={
-                    'class': get_ul_class(self.radio_fields[db_field.name]),
-                })
-            if 'choices' not in kwargs:
-                kwargs['choices'] = db_field.get_choices(
-                    include_blank=db_field.blank,
-                    blank_choice=[('', _('None'))]
-                )
-        return db_field.formfield(**kwargs)
-
-    def get_field_queryset(self, db, db_field, request):
-        """
-        If the ModelAdmin specifies ordering, the queryset should respect that
-        ordering.  Otherwise don't specify the queryset, let the field decide
-        (returns None in that case).
-        """
-        related_admin = self.admin_site._registry.get(db_field.rel.to, None)
-        if related_admin is not None:
-            ordering = related_admin.get_ordering(request)
-            if ordering is not None and ordering != ():
-                return db_field.rel.to._default_manager.using(db).order_by(*ordering).complex_filter(db_field.rel.limit_choices_to)
-        return None
-
-    def formfield_for_foreignkey(self, db_field, request=None, **kwargs):
-        """
-        Get a form Field for a ForeignKey.
-        """
-        db = kwargs.get('using')
-        if db_field.name in self.raw_id_fields:
-            kwargs['widget'] = widgets.ForeignKeyRawIdWidget(db_field.rel,
-                                    self.admin_site, using=db)
-        elif db_field.name in self.radio_fields:
-            kwargs['widget'] = widgets.AdminRadioSelect(attrs={
-                'class': get_ul_class(self.radio_fields[db_field.name]),
-            })
-            kwargs['empty_label'] = _('None') if db_field.blank else None
-
-        if not 'queryset' in kwargs:
-            queryset = self.get_field_queryset(db, db_field, request)
-            if queryset is not None:
-                kwargs['queryset'] = queryset
-
-        return db_field.formfield(**kwargs)
-
-    def formfield_for_manytomany(self, db_field, request=None, **kwargs):
-        """
-        Get a form Field for a ManyToManyField.
-        """
-        # If it uses an intermediary model that isn't auto created, don't show
-        # a field in admin.
-        if not db_field.rel.through._meta.auto_created:
-            return None
-        db = kwargs.get('using')
-
-        if db_field.name in self.raw_id_fields:
-            kwargs['widget'] = widgets.ManyToManyRawIdWidget(db_field.rel,
-                                    self.admin_site, using=db)
-            kwargs['help_text'] = ''
-        elif db_field.name in (list(self.filter_vertical) + list(self.filter_horizontal)):
-            kwargs['widget'] = widgets.FilteredSelectMultiple(db_field.verbose_name, (db_field.name in self.filter_vertical))
-
-        if not 'queryset' in kwargs:
-            queryset = self.get_field_queryset(db, db_field, request)
-            if queryset is not None:
-                kwargs['queryset'] = queryset
-
-        return db_field.formfield(**kwargs)
-
-    def _declared_fieldsets(self):
-        if self.fieldsets:
-            return self.fieldsets
-        elif self.fields:
-            return [(None, {'fields': self.fields})]
-        return None
-    declared_fieldsets = property(_declared_fieldsets)
-
-    def get_ordering(self, request):
-        """
-        Hook for specifying field ordering.
-        """
-        return self.ordering or ()  # otherwise we might try to *None, which is bad ;)
-
-    def get_readonly_fields(self, request, obj=None):
-        """
-        Hook for specifying custom readonly fields.
-        """
-        return self.readonly_fields
-
-    def get_prepopulated_fields(self, request, obj=None):
-        """
-        Hook for specifying custom prepopulated fields.
-        """
-        return self.prepopulated_fields
-
-    def get_queryset(self, request):
-        """
-        Returns a QuerySet of all model instances that can be edited by the
-        admin site. This is used by changelist_view.
-        """
-        qs = self.model._default_manager.get_queryset()
-        # TODO: this should be handled by some parameter to the ChangeList.
-        ordering = self.get_ordering(request)
-        if ordering:
-            qs = qs.order_by(*ordering)
-        return qs
-
-    def lookup_allowed(self, lookup, value):
-        model = self.model
-        # Check FKey lookups that are allowed, so that popups produced by
-        # ForeignKeyRawIdWidget, on the basis of ForeignKey.limit_choices_to,
-        # are allowed to work.
-        for l in model._meta.related_fkey_lookups:
-            for k, v in widgets.url_params_from_lookup_dict(l).items():
-                if k == lookup and v == value:
-                    return True
-
-        parts = lookup.split(LOOKUP_SEP)
-
-        # Last term in lookup is a query term (__exact, __startswith etc)
-        # This term can be ignored.
-        if len(parts) > 1 and parts[-1] in QUERY_TERMS:
-            parts.pop()
-
-        # Special case -- foo__id__exact and foo__id queries are implied
-        # if foo has been specifically included in the lookup list; so
-        # drop __id if it is the last part. However, first we need to find
-        # the pk attribute name.
-        rel_name = None
-        for part in parts[:-1]:
-            try:
-                field, _, _, _ = model._meta.get_field_by_name(part)
-            except FieldDoesNotExist:
-                # Lookups on non-existent fields are ok, since they're ignored
-                # later.
-                return True
-            if hasattr(field, 'rel'):
-                if field.rel is None:
-                    # This property or relation doesn't exist, but it's allowed
-                    # since it's ignored in ChangeList.get_filters().
-                    return True
-                model = field.rel.to
-                rel_name = field.rel.get_related_field().name
-            elif isinstance(field, RelatedObject):
-                model = field.model
-                rel_name = model._meta.pk.name
-            else:
-                rel_name = None
-        if rel_name and len(parts) > 1 and parts[-1] == rel_name:
-            parts.pop()
-
-        if len(parts) == 1:
-            return True
-        clean_lookup = LOOKUP_SEP.join(parts)
-        return clean_lookup in self.list_filter or clean_lookup == self.date_hierarchy
-
-    def has_add_permission(self, request):
-        """
-        Returns True if the given request has permission to add an object.
-        Can be overridden by the user in subclasses.
-        """
-        opts = self.opts
-        codename = get_permission_codename('add', opts)
-        return request.user.has_perm("%s.%s" % (opts.app_label, codename))
-
-    def has_change_permission(self, request, obj=None):
-        """
-        Returns True if the given request has permission to change the given
-        Django model instance, the default implementation doesn't examine the
-        `obj` parameter.
-
-        Can be overridden by the user in subclasses. In such case it should
-        return True if the given request has permission to change the `obj`
-        model instance. If `obj` is None, this should return True if the given
-        request has permission to change *any* object of the given type.
-        """
-        opts = self.opts
-        codename = get_permission_codename('change', opts)
-        return request.user.has_perm("%s.%s" % (opts.app_label, codename))
-
-    def has_delete_permission(self, request, obj=None):
-        """
-        Returns True if the given request has permission to change the given
-        Django model instance, the default implementation doesn't examine the
-        `obj` parameter.
-
-        Can be overridden by the user in subclasses. In such case it should
-        return True if the given request has permission to delete the `obj`
-        model instance. If `obj` is None, this should return True if the given
-        request has permission to delete *any* object of the given type.
-        """
-        opts = self.opts
-        codename = get_permission_codename('delete', opts)
-        return request.user.has_perm("%s.%s" % (opts.app_label, codename))
-
-
-class ModelAdmin(BaseModelAdmin):
-    "Encapsulates all admin options and functionality for a given model."
-
-    list_display = ('__str__',)
-    list_display_links = ()
-    list_filter = ()
-    list_select_related = False
-    list_per_page = 100
-    list_max_show_all = 200
-    list_editable = ()
-    search_fields = ()
-    date_hierarchy = None
-    save_as = False
-    save_on_top = False
-    paginator = Paginator
-    preserve_filters = True
-    inlines = []
-
-    # Custom templates (designed to be over-ridden in subclasses)
-    add_form_template = None
-    change_form_template = None
-    change_list_template = None
-    delete_confirmation_template = None
-    delete_selected_confirmation_template = None
-    object_history_template = None
-
-    # Actions
-    actions = []
-    action_form = helpers.ActionForm
-    actions_on_top = True
-    actions_on_bottom = False
-    actions_selection_counter = True
-
-    # validation
-    validator_class = validation.ModelAdminValidator
-
-    def __init__(self, model, admin_site):
-        self.model = model
-        self.opts = model._meta
-        self.admin_site = admin_site
-        super(ModelAdmin, self).__init__()
-
-    def get_inline_instances(self, request, obj=None):
-        inline_instances = []
-        for inline_class in self.inlines:
-            inline = inline_class(self.model, self.admin_site)
-            if request:
-                if not (inline.has_add_permission(request) or
-                        inline.has_change_permission(request, obj) or
-                        inline.has_delete_permission(request, obj)):
-                    continue
-                if not inline.has_add_permission(request):
-                    inline.max_num = 0
-            inline_instances.append(inline)
-
-        return inline_instances
-
-    def get_urls(self):
-        from django.conf.urls import patterns, url
-
-        def wrap(view):
-            def wrapper(*args, **kwargs):
-                return self.admin_site.admin_view(view)(*args, **kwargs)
-            return update_wrapper(wrapper, view)
-
-        info = self.model._meta.app_label, self.model._meta.model_name
-
-        urlpatterns = patterns('',
-            url(r'^$',
-                wrap(self.changelist_view),
-                name='%s_%s_changelist' % info),
-            url(r'^add/$',
-                wrap(self.add_view),
-                name='%s_%s_add' % info),
-            url(r'^(.+)/history/$',
-                wrap(self.history_view),
-                name='%s_%s_history' % info),
-            url(r'^(.+)/delete/$',
-                wrap(self.delete_view),
-                name='%s_%s_delete' % info),
-            url(r'^(.+)/$',
-                wrap(self.change_view),
-                name='%s_%s_change' % info),
-        )
-        return urlpatterns
-
-    def urls(self):
-        return self.get_urls()
-    urls = property(urls)
-
-    @property
-    def media(self):
-        extra = '' if settings.DEBUG else '.min'
-        js = [
-            'core.js',
-            'admin/RelatedObjectLookups.js',
-            'jquery%s.js' % extra,
-            'jquery.init.js'
-        ]
-        if self.actions is not None:
-            js.append('actions%s.js' % extra)
-        if self.prepopulated_fields:
-            js.extend(['urlify.js', 'prepopulate%s.js' % extra])
-        return forms.Media(js=[static('admin/js/%s' % url) for url in js])
-
-    def get_model_perms(self, request):
-        """
-        Returns a dict of all perms for this model. This dict has the keys
-        ``add``, ``change``, and ``delete`` mapping to the True/False for each
-        of those actions.
-        """
-        return {
-            'add': self.has_add_permission(request),
-            'change': self.has_change_permission(request),
-            'delete': self.has_delete_permission(request),
-        }
-
-    def get_fieldsets(self, request, obj=None):
-        "Hook for specifying fieldsets for the add form."
-        if self.declared_fieldsets:
-            return self.declared_fieldsets
-        form = self.get_form(request, obj, fields=None)
-        fields = list(form.base_fields) + list(self.get_readonly_fields(request, obj))
-        return [(None, {'fields': fields})]
-
-    def get_form(self, request, obj=None, **kwargs):
-        """
-        Returns a Form class for use in the admin add view. This is used by
-        add_view and change_view.
-        """
-        if 'fields' in kwargs:
-            fields = kwargs.pop('fields')
-        else:
-            fields = flatten_fieldsets(self.get_fieldsets(request, obj))
-        if self.exclude is None:
-            exclude = []
-        else:
-            exclude = list(self.exclude)
-        exclude.extend(self.get_readonly_fields(request, obj))
-        if self.exclude is None and hasattr(self.form, '_meta') and self.form._meta.exclude:
-            # Take the custom ModelForm's Meta.exclude into account only if the
-            # ModelAdmin doesn't define its own.
-            exclude.extend(self.form._meta.exclude)
-        # if exclude is an empty list we pass None to be consistent with the
-        # default on modelform_factory
-        exclude = exclude or None
-        defaults = {
-            "form": self.form,
-            "fields": fields,
-            "exclude": exclude,
-            "formfield_callback": partial(self.formfield_for_dbfield, request=request),
-        }
-        defaults.update(kwargs)
-
-        if defaults['fields'] is None and not modelform_defines_fields(defaults['form']):
-            defaults['fields'] = forms.ALL_FIELDS
-
-        try:
-            return modelform_factory(self.model, **defaults)
-        except FieldError as e:
-            raise FieldError('%s. Check fields/fieldsets/exclude attributes of class %s.'
-                             % (e, self.__class__.__name__))
-
-    def get_changelist(self, request, **kwargs):
-        """
-        Returns the ChangeList class for use on the changelist page.
-        """
-        from django.contrib.admin.views.main import ChangeList
-        return ChangeList
-
-    def get_object(self, request, object_id):
-        """
-        Returns an instance matching the primary key provided. ``None``  is
-        returned if no match is found (or the object_id failed validation
-        against the primary key field).
-        """
-        queryset = self.get_queryset(request)
-        model = queryset.model
-        try:
-            object_id = model._meta.pk.to_python(object_id)
-            return queryset.get(pk=object_id)
-        except (model.DoesNotExist, ValidationError, ValueError):
-            return None
-
-    def get_changelist_form(self, request, **kwargs):
-        """
-        Returns a Form class for use in the Formset on the changelist page.
-        """
-        defaults = {
-            "formfield_callback": partial(self.formfield_for_dbfield, request=request),
-        }
-        defaults.update(kwargs)
-        if (defaults.get('fields') is None
-            and not modelform_defines_fields(defaults.get('form'))):
-            defaults['fields'] = forms.ALL_FIELDS
-
-        return modelform_factory(self.model, **defaults)
-
-    def get_changelist_formset(self, request, **kwargs):
-        """
-        Returns a FormSet class for use on the changelist page if list_editable
-        is used.
-        """
-        defaults = {
-            "formfield_callback": partial(self.formfield_for_dbfield, request=request),
-        }
-        defaults.update(kwargs)
-        return modelformset_factory(self.model,
-            self.get_changelist_form(request), extra=0,
-            fields=self.list_editable, **defaults)
-
-    def get_formsets(self, request, obj=None):
-        for inline in self.get_inline_instances(request, obj):
-            yield inline.get_formset(request, obj)
-
-    def get_paginator(self, request, queryset, per_page, orphans=0, allow_empty_first_page=True):
-        return self.paginator(queryset, per_page, orphans, allow_empty_first_page)
-
-    def log_addition(self, request, object):
-        """
-        Log that an object has been successfully added.
-
-        The default implementation creates an admin LogEntry object.
-        """
-        from django.contrib.admin.models import LogEntry, ADDITION
-        LogEntry.objects.log_action(
-            user_id=request.user.pk,
-            content_type_id=ContentType.objects.get_for_model(object).pk,
-            object_id=object.pk,
-            object_repr=force_text(object),
-            action_flag=ADDITION
-        )
-
-    def log_change(self, request, object, message):
-        """
-        Log that an object has been successfully changed.
-
-        The default implementation creates an admin LogEntry object.
-        """
-        from django.contrib.admin.models import LogEntry, CHANGE
-        LogEntry.objects.log_action(
-            user_id=request.user.pk,
-            content_type_id=ContentType.objects.get_for_model(object).pk,
-            object_id=object.pk,
-            object_repr=force_text(object),
-            action_flag=CHANGE,
-            change_message=message
-        )
-
-    def log_deletion(self, request, object, object_repr):
-        """
-        Log that an object will be deleted. Note that this method is called
-        before the deletion.
-
-        The default implementation creates an admin LogEntry object.
-        """
-        from django.contrib.admin.models import LogEntry, DELETION
-        LogEntry.objects.log_action(
-            user_id=request.user.pk,
-            content_type_id=ContentType.objects.get_for_model(self.model).pk,
-            object_id=object.pk,
-            object_repr=object_repr,
-            action_flag=DELETION
-        )
-
-    def action_checkbox(self, obj):
-        """
-        A list_display column containing a checkbox widget.
-        """
-        return helpers.checkbox.render(helpers.ACTION_CHECKBOX_NAME, force_text(obj.pk))
-    action_checkbox.short_description = mark_safe('<input type="checkbox" id="action-toggle" />')
-    action_checkbox.allow_tags = True
-
-    def get_actions(self, request):
-        """
-        Return a dictionary mapping the names of all actions for this
-        ModelAdmin to a tuple of (callable, name, description) for each action.
-        """
-        # If self.actions is explicitly set to None that means that we don't
-        # want *any* actions enabled on this page.
-        from django.contrib.admin.views.main import _is_changelist_popup
-        if self.actions is None or _is_changelist_popup(request):
-            return SortedDict()
-
-        actions = []
-
-        # Gather actions from the admin site first
-        for (name, func) in self.admin_site.actions:
-            description = getattr(func, 'short_description', name.replace('_', ' '))
-            actions.append((func, name, description))
-
-        # Then gather them from the model admin and all parent classes,
-        # starting with self and working back up.
-        for klass in self.__class__.mro()[::-1]:
-            class_actions = getattr(klass, 'actions', [])
-            # Avoid trying to iterate over None
-            if not class_actions:
-                continue
-            actions.extend([self.get_action(action) for action in class_actions])
-
-        # get_action might have returned None, so filter any of those out.
-        actions = filter(None, actions)
-
-        # Convert the actions into a SortedDict keyed by name.
-        actions = SortedDict([
-            (name, (func, name, desc))
-            for func, name, desc in actions
-        ])
-
-        return actions
-
-    def get_action_choices(self, request, default_choices=BLANK_CHOICE_DASH):
-        """
-        Return a list of choices for use in a form object.  Each choice is a
-        tuple (name, description).
-        """
-        choices = [] + default_choices
-        for func, name, description in six.itervalues(self.get_actions(request)):
-            choice = (name, description % model_format_dict(self.opts))
-            choices.append(choice)
-        return choices
-
-    def get_action(self, action):
-        """
-        Return a given action from a parameter, which can either be a callable,
-        or the name of a method on the ModelAdmin.  Return is a tuple of
-        (callable, name, description).
-        """
-        # If the action is a callable, just use it.
-        if callable(action):
-            func = action
-            action = action.__name__
-
-        # Next, look for a method. Grab it off self.__class__ to get an unbound
-        # method instead of a bound one; this ensures that the calling
-        # conventions are the same for functions and methods.
-        elif hasattr(self.__class__, action):
-            func = getattr(self.__class__, action)
-
-        # Finally, look for a named method on the admin site
-        else:
-            try:
-                func = self.admin_site.get_action(action)
-            except KeyError:
-                return None
-
-        if hasattr(func, 'short_description'):
-            description = func.short_description
-        else:
-            description = capfirst(action.replace('_', ' '))
-        return func, action, description
-
-    def get_list_display(self, request):
-        """
-        Return a sequence containing the fields to be displayed on the
-        changelist.
-        """
-        return self.list_display
-
-    def get_list_display_links(self, request, list_display):
-        """
-        Return a sequence containing the fields to be displayed as links
-        on the changelist. The list_display parameter is the list of fields
-        returned by get_list_display().
-        """
-        if self.list_display_links or not list_display:
-            return self.list_display_links
-        else:
-            # Use only the first item in list_display as link
-            return list(list_display)[:1]
-
-    def get_list_filter(self, request):
-        """
-        Returns a sequence containing the fields to be displayed as filters in
-        the right sidebar of the changelist page.
-        """
-        return self.list_filter
-
-    def get_search_results(self, request, queryset, search_term):
-        """
-        Returns a tuple containing a queryset to implement the search,
-        and a boolean indicating if the results may contain duplicates.
-        """
-        # Apply keyword searches.
-        def construct_search(field_name):
-            if field_name.startswith('^'):
-                return "%s__istartswith" % field_name[1:]
-            elif field_name.startswith('='):
-                return "%s__iexact" % field_name[1:]
-            elif field_name.startswith('@'):
-                return "%s__search" % field_name[1:]
-            else:
-                return "%s__icontains" % field_name
-
-        use_distinct = False
-        if self.search_fields and search_term:
-            orm_lookups = [construct_search(str(search_field))
-                           for search_field in self.search_fields]
-            for bit in search_term.split():
-                or_queries = [models.Q(**{orm_lookup: bit})
-                              for orm_lookup in orm_lookups]
-                queryset = queryset.filter(reduce(operator.or_, or_queries))
-            if not use_distinct:
-                for search_spec in orm_lookups:
-                    if lookup_needs_distinct(self.opts, search_spec):
-                        use_distinct = True
-                        break
-
-        return queryset, use_distinct
-
-    def get_preserved_filters(self, request):
-        """
-        Returns the preserved filters querystring.
-        """
-        match = request.resolver_match
-        if self.preserve_filters and match:
-            opts = self.model._meta
-            current_url = '%s:%s' % (match.app_name, match.url_name)
-            changelist_url = 'admin:%s_%s_changelist' % (opts.app_label, opts.model_name)
-            if current_url == changelist_url:
-                preserved_filters = request.GET.urlencode()
-            else:
-                preserved_filters = request.GET.get('_changelist_filters')
-
-            if preserved_filters:
-                return urlencode({'_changelist_filters': preserved_filters})
-        return ''
-
-    def construct_change_message(self, request, form, formsets):
-        """
-        Construct a change message from a changed object.
-        """
-        change_message = []
-        if form.changed_data:
-            change_message.append(_('Changed %s.') % get_text_list(form.changed_data, _('and')))
-
-        if formsets:
-            for formset in formsets:
-                for added_object in formset.new_objects:
-                    change_message.append(_('Added %(name)s "%(object)s".')
-                                          % {'name': force_text(added_object._meta.verbose_name),
-                                             'object': force_text(added_object)})
-                for changed_object, changed_fields in formset.changed_objects:
-                    change_message.append(_('Changed %(list)s for %(name)s "%(object)s".')
-                                          % {'list': get_text_list(changed_fields, _('and')),
-                                             'name': force_text(changed_object._meta.verbose_name),
-                                             'object': force_text(changed_object)})
-                for deleted_object in formset.deleted_objects:
-                    change_message.append(_('Deleted %(name)s "%(object)s".')
-                                          % {'name': force_text(deleted_object._meta.verbose_name),
-                                             'object': force_text(deleted_object)})
-        change_message = ' '.join(change_message)
-        return change_message or _('No fields changed.')
-
-    def message_user(self, request, message, level=messages.INFO, extra_tags='',
-                     fail_silently=False):
-        """
-        Send a message to the user. The default implementation
-        posts a message using the django.contrib.messages backend.
-
-        Exposes almost the same API as messages.add_message(), but accepts the
-        positional arguments in a different order to maintain backwards
-        compatibility. For convenience, it accepts the `level` argument as
-        a string rather than the usual level number.
-        """
-
-        if not isinstance(level, int):
-            # attempt to get the level if passed a string
-            try:
-                level = getattr(messages.constants, level.upper())
-            except AttributeError:
-                levels = messages.constants.DEFAULT_TAGS.values()
-                levels_repr = ', '.join('`%s`' % l for l in levels)
-                raise ValueError('Bad message level string: `%s`. '
-                        'Possible values are: %s' % (level, levels_repr))
-
-        messages.add_message(request, level, message, extra_tags=extra_tags,
-                fail_silently=fail_silently)
-
-    def save_form(self, request, form, change):
-        """
-        Given a ModelForm return an unsaved instance. ``change`` is True if
-        the object is being changed, and False if it's being added.
-        """
-        return form.save(commit=False)
-
-    def save_model(self, request, obj, form, change):
-        """
-        Given a model instance save it to the database.
-        """
-        obj.save()
-
-    def delete_model(self, request, obj):
-        """
-        Given a model instance delete it from the database.
-        """
-        obj.delete()
-
-    def save_formset(self, request, form, formset, change):
-        """
-        Given an inline formset save it to the database.
-        """
-        formset.save()
-
-    def save_related(self, request, form, formsets, change):
-        """
-        Given the ``HttpRequest``, the parent ``ModelForm`` instance, the
-        list of inline formsets and a boolean value based on whether the
-        parent is being added or changed, save the related objects to the
-        database. Note that at this point save_form() and save_model() have
-        already been called.
-        """
-        form.save_m2m()
-        for formset in formsets:
-            self.save_formset(request, form, formset, change=change)
-
-    def render_change_form(self, request, context, add=False, change=False, form_url='', obj=None):
-        opts = self.model._meta
-        app_label = opts.app_label
-        preserved_filters = self.get_preserved_filters(request)
-        form_url = add_preserved_filters({'preserved_filters': preserved_filters, 'opts': opts}, form_url)
-        context.update({
-            'add': add,
-            'change': change,
-            'has_add_permission': self.has_add_permission(request),
-            'has_change_permission': self.has_change_permission(request, obj),
-            'has_delete_permission': self.has_delete_permission(request, obj),
-            'has_file_field': True,  # FIXME - this should check if form or formsets have a FileField,
-            'has_absolute_url': hasattr(self.model, 'get_absolute_url'),
-            'form_url': form_url,
-            'opts': opts,
-            'content_type_id': ContentType.objects.get_for_model(self.model).id,
-            'save_as': self.save_as,
-            'save_on_top': self.save_on_top,
-        })
-        if add and self.add_form_template is not None:
-            form_template = self.add_form_template
-        else:
-            form_template = self.change_form_template
-
-        return TemplateResponse(request, form_template or [
-            "admin/%s/%s/change_form.html" % (app_label, opts.model_name),
-            "admin/%s/change_form.html" % app_label,
-            "admin/change_form.html"
-        ], context, current_app=self.admin_site.name)
-
-    def response_add(self, request, obj, post_url_continue=None):
-        """
-        Determines the HttpResponse for the add_view stage.
-        """
-        opts = obj._meta
-        pk_value = obj._get_pk_val()
-        preserved_filters = self.get_preserved_filters(request)
-
-        msg_dict = {'name': force_text(opts.verbose_name), 'obj': force_text(obj)}
-        # Here, we distinguish between different save types by checking for
-        # the presence of keys in request.POST.
-        if IS_POPUP_VAR in request.POST:
-            return SimpleTemplateResponse('admin/popup_response.html', {
-                'pk_value': escape(pk_value),
-                'obj': escapejs(obj)
-            })
-
-        elif "_continue" in request.POST:
-            msg = _('The %(name)s "%(obj)s" was added successfully. You may edit it again below.') % msg_dict
-            self.message_user(request, msg, messages.SUCCESS)
-            if post_url_continue is None:
-                post_url_continue = reverse('admin:%s_%s_change' %
-                                            (opts.app_label, opts.model_name),
-                                            args=(pk_value,),
-                                            current_app=self.admin_site.name)
-            post_url_continue = add_preserved_filters({'preserved_filters': preserved_filters, 'opts': opts}, post_url_continue)
-            return HttpResponseRedirect(post_url_continue)
-
-        elif "_addanother" in request.POST:
-            msg = _('The %(name)s "%(obj)s" was added successfully. You may add another %(name)s below.') % msg_dict
-            self.message_user(request, msg, messages.SUCCESS)
-            redirect_url = request.path
-            redirect_url = add_preserved_filters({'preserved_filters': preserved_filters, 'opts': opts}, redirect_url)
-            return HttpResponseRedirect(redirect_url)
-
-        else:
-            msg = _('The %(name)s "%(obj)s" was added successfully.') % msg_dict
-            self.message_user(request, msg, messages.SUCCESS)
-            return self.response_post_save_add(request, obj)
-
-    def response_change(self, request, obj):
-        """
-        Determines the HttpResponse for the change_view stage.
-        """
-        opts = self.model._meta
-        pk_value = obj._get_pk_val()
-        preserved_filters = self.get_preserved_filters(request)
-
-        msg_dict = {'name': force_text(opts.verbose_name), 'obj': force_text(obj)}
-        if "_continue" in request.POST:
-            msg = _('The %(name)s "%(obj)s" was changed successfully. You may edit it again below.') % msg_dict
-            self.message_user(request, msg, messages.SUCCESS)
-            redirect_url = request.path
-            redirect_url = add_preserved_filters({'preserved_filters': preserved_filters, 'opts': opts}, redirect_url)
-            return HttpResponseRedirect(redirect_url)
-
-        elif "_saveasnew" in request.POST:
-            msg = _('The %(name)s "%(obj)s" was added successfully. You may edit it again below.') % msg_dict
-            self.message_user(request, msg, messages.SUCCESS)
-            redirect_url = reverse('admin:%s_%s_change' %
-                                   (opts.app_label, opts.model_name),
-                                   args=(pk_value,),
-                                   current_app=self.admin_site.name)
-            redirect_url = add_preserved_filters({'preserved_filters': preserved_filters, 'opts': opts}, redirect_url)
-            return HttpResponseRedirect(redirect_url)
-
-        elif "_addanother" in request.POST:
-            msg = _('The %(name)s "%(obj)s" was changed successfully. You may add another %(name)s below.') % msg_dict
-            self.message_user(request, msg, messages.SUCCESS)
-            redirect_url = reverse('admin:%s_%s_add' %
-                                   (opts.app_label, opts.model_name),
-                                   current_app=self.admin_site.name)
-            redirect_url = add_preserved_filters({'preserved_filters': preserved_filters, 'opts': opts}, redirect_url)
-            return HttpResponseRedirect(redirect_url)
-
-        else:
-            msg = _('The %(name)s "%(obj)s" was changed successfully.') % msg_dict
-            self.message_user(request, msg, messages.SUCCESS)
-            return self.response_post_save_change(request, obj)
-
-    def response_post_save_add(self, request, obj):
-        """
-        Figure out where to redirect after the 'Save' button has been pressed
-        when adding a new object.
-        """
-        opts = self.model._meta
-        if self.has_change_permission(request, None):
-            post_url = reverse('admin:%s_%s_changelist' %
-                               (opts.app_label, opts.model_name),
-                               current_app=self.admin_site.name)
-            preserved_filters = self.get_preserved_filters(request)
-            post_url = add_preserved_filters({'preserved_filters': preserved_filters, 'opts': opts}, post_url)
-        else:
-            post_url = reverse('admin:index',
-                               current_app=self.admin_site.name)
-        return HttpResponseRedirect(post_url)
-
-    def response_post_save_change(self, request, obj):
-        """
-        Figure out where to redirect after the 'Save' button has been pressed
-        when editing an existing object.
-        """
-        opts = self.model._meta
-
-        if self.has_change_permission(request, None):
-            post_url = reverse('admin:%s_%s_changelist' %
-                               (opts.app_label, opts.model_name),
-                               current_app=self.admin_site.name)
-            preserved_filters = self.get_preserved_filters(request)
-            post_url = add_preserved_filters({'preserved_filters': preserved_filters, 'opts': opts}, post_url)
-        else:
-            post_url = reverse('admin:index',
-                               current_app=self.admin_site.name)
-        return HttpResponseRedirect(post_url)
-
-    def response_action(self, request, queryset):
-        """
-        Handle an admin action. This is called if a request is POSTed to the
-        changelist; it returns an HttpResponse if the action was handled, and
-        None otherwise.
-        """
-
-        # There can be multiple action forms on the page (at the top
-        # and bottom of the change list, for example). Get the action
-        # whose button was pushed.
-        try:
-            action_index = int(request.POST.get('index', 0))
-        except ValueError:
-            action_index = 0
-
-        # Construct the action form.
-        data = request.POST.copy()
-        data.pop(helpers.ACTION_CHECKBOX_NAME, None)
-        data.pop("index", None)
-
-        # Use the action whose button was pushed
-        try:
-            data.update({'action': data.getlist('action')[action_index]})
-        except IndexError:
-            # If we didn't get an action from the chosen form that's invalid
-            # POST data, so by deleting action it'll fail the validation check
-            # below. So no need to do anything here
-            pass
-
-        action_form = self.action_form(data, auto_id=None)
-        action_form.fields['action'].choices = self.get_action_choices(request)
-
-        # If the form's valid we can handle the action.
-        if action_form.is_valid():
-            action = action_form.cleaned_data['action']
-            select_across = action_form.cleaned_data['select_across']
-            func = self.get_actions(request)[action][0]
-
-            # Get the list of selected PKs. If nothing's selected, we can't
-            # perform an action on it, so bail. Except we want to perform
-            # the action explicitly on all objects.
-            selected = request.POST.getlist(helpers.ACTION_CHECKBOX_NAME)
-            if not selected and not select_across:
-                # Reminder that something needs to be selected or nothing will happen
-                msg = _("Items must be selected in order to perform "
-                        "actions on them. No items have been changed.")
-                self.message_user(request, msg, messages.WARNING)
-                return None
-
-            if not select_across:
-                # Perform the action only on the selected objects
-                queryset = queryset.filter(pk__in=selected)
-
-            response = func(self, request, queryset)
-
-            # Actions may return an HttpResponse-like object, which will be
-            # used as the response from the POST. If not, we'll be a good
-            # little HTTP citizen and redirect back to the changelist page.
-            if isinstance(response, HttpResponseBase):
-                return response
-            else:
-                return HttpResponseRedirect(request.get_full_path())
-        else:
-            msg = _("No action selected.")
-            self.message_user(request, msg, messages.WARNING)
-            return None
-
-    @csrf_protect_m
-    @transaction.atomic
-    def add_view(self, request, form_url='', extra_context=None):
-        "The 'add' admin view for this model."
-        model = self.model
-        opts = model._meta
-
-        if not self.has_add_permission(request):
-            raise PermissionDenied
-
-        ModelForm = self.get_form(request)
-        formsets = []
-        inline_instances = self.get_inline_instances(request, None)
-        if request.method == 'POST':
-            form = ModelForm(request.POST, request.FILES)
-            if form.is_valid():
-                new_object = self.save_form(request, form, change=False)
-                form_validated = True
-            else:
-                form_validated = False
-                new_object = self.model()
-            prefixes = {}
-            for FormSet, inline in zip(self.get_formsets(request), inline_instances):
-                prefix = FormSet.get_default_prefix()
-                prefixes[prefix] = prefixes.get(prefix, 0) + 1
-                if prefixes[prefix] != 1 or not prefix:
-                    prefix = "%s-%s" % (prefix, prefixes[prefix])
-                formset = FormSet(data=request.POST, files=request.FILES,
-                                  instance=new_object,
-                                  save_as_new="_saveasnew" in request.POST,
-                                  prefix=prefix, queryset=inline.get_queryset(request))
-                formsets.append(formset)
-            if all_valid(formsets) and form_validated:
-                self.save_model(request, new_object, form, False)
-                self.save_related(request, form, formsets, False)
-                self.log_addition(request, new_object)
-                return self.response_add(request, new_object)
-        else:
-            # Prepare the dict of initial data from the request.
-            # We have to special-case M2Ms as a list of comma-separated PKs.
-            initial = dict(request.GET.items())
-            for k in initial:
-                try:
-                    f = opts.get_field(k)
-                except models.FieldDoesNotExist:
-                    continue
-                if isinstance(f, models.ManyToManyField):
-                    initial[k] = initial[k].split(",")
-            form = ModelForm(initial=initial)
-            prefixes = {}
-            for FormSet, inline in zip(self.get_formsets(request), inline_instances):
-                prefix = FormSet.get_default_prefix()
-                prefixes[prefix] = prefixes.get(prefix, 0) + 1
-                if prefixes[prefix] != 1 or not prefix:
-                    prefix = "%s-%s" % (prefix, prefixes[prefix])
-                formset = FormSet(instance=self.model(), prefix=prefix,
-                                  queryset=inline.get_queryset(request))
-                formsets.append(formset)
-
-        adminForm = helpers.AdminForm(form, list(self.get_fieldsets(request)),
-            self.get_prepopulated_fields(request),
-            self.get_readonly_fields(request),
-            model_admin=self)
-        media = self.media + adminForm.media
-
-        inline_admin_formsets = []
-        for inline, formset in zip(inline_instances, formsets):
-            fieldsets = list(inline.get_fieldsets(request))
-            readonly = list(inline.get_readonly_fields(request))
-            prepopulated = dict(inline.get_prepopulated_fields(request))
-            inline_admin_formset = helpers.InlineAdminFormSet(inline, formset,
-                fieldsets, prepopulated, readonly, model_admin=self)
-            inline_admin_formsets.append(inline_admin_formset)
-            media = media + inline_admin_formset.media
-
-        context = {
-            'title': _('Add %s') % force_text(opts.verbose_name),
-            'adminform': adminForm,
-            'is_popup': IS_POPUP_VAR in request.REQUEST,
-            'media': media,
-            'inline_admin_formsets': inline_admin_formsets,
-            'errors': helpers.AdminErrorList(form, formsets),
-            'app_label': opts.app_label,
-            'preserved_filters': self.get_preserved_filters(request),
-        }
-        context.update(extra_context or {})
-        return self.render_change_form(request, context, form_url=form_url, add=True)
-
-    @csrf_protect_m
-    @transaction.atomic
-    def change_view(self, request, object_id, form_url='', extra_context=None):
-        "The 'change' admin view for this model."
-        model = self.model
-        opts = model._meta
-
-        obj = self.get_object(request, unquote(object_id))
-
-        if not self.has_change_permission(request, obj):
-            raise PermissionDenied
-
-        if obj is None:
-            raise Http404(_('%(name)s object with primary key %(key)r does not exist.') % {'name': force_text(opts.verbose_name), 'key': escape(object_id)})
-
-        if request.method == 'POST' and "_saveasnew" in request.POST:
-            return self.add_view(request, form_url=reverse('admin:%s_%s_add' %
-                                    (opts.app_label, opts.model_name),
-                                    current_app=self.admin_site.name))
-
-        ModelForm = self.get_form(request, obj)
-        formsets = []
-        inline_instances = self.get_inline_instances(request, obj)
-        if request.method == 'POST':
-            form = ModelForm(request.POST, request.FILES, instance=obj)
-            if form.is_valid():
-                form_validated = True
-                new_object = self.save_form(request, form, change=True)
-            else:
-                form_validated = False
-                new_object = obj
-            prefixes = {}
-            for FormSet, inline in zip(self.get_formsets(request, new_object), inline_instances):
-                prefix = FormSet.get_default_prefix()
-                prefixes[prefix] = prefixes.get(prefix, 0) + 1
-                if prefixes[prefix] != 1 or not prefix:
-                    prefix = "%s-%s" % (prefix, prefixes[prefix])
-                formset = FormSet(request.POST, request.FILES,
-                                  instance=new_object, prefix=prefix,
-                                  queryset=inline.get_queryset(request))
-
-                formsets.append(formset)
-
-            if all_valid(formsets) and form_validated:
-                self.save_model(request, new_object, form, True)
-                self.save_related(request, form, formsets, True)
-                change_message = self.construct_change_message(request, form, formsets)
-                self.log_change(request, new_object, change_message)
-                return self.response_change(request, new_object)
-
-        else:
-            form = ModelForm(instance=obj)
-            prefixes = {}
-            for FormSet, inline in zip(self.get_formsets(request, obj), inline_instances):
-                prefix = FormSet.get_default_prefix()
-                prefixes[prefix] = prefixes.get(prefix, 0) + 1
-                if prefixes[prefix] != 1 or not prefix:
-                    prefix = "%s-%s" % (prefix, prefixes[prefix])
-                formset = FormSet(instance=obj, prefix=prefix,
-                                  queryset=inline.get_queryset(request))
-                formsets.append(formset)
-
-        adminForm = helpers.AdminForm(form, self.get_fieldsets(request, obj),
-            self.get_prepopulated_fields(request, obj),
-            self.get_readonly_fields(request, obj),
-            model_admin=self)
-        media = self.media + adminForm.media
-
-        inline_admin_formsets = []
-        for inline, formset in zip(inline_instances, formsets):
-            fieldsets = list(inline.get_fieldsets(request, obj))
-            readonly = list(inline.get_readonly_fields(request, obj))
-            prepopulated = dict(inline.get_prepopulated_fields(request, obj))
-            inline_admin_formset = helpers.InlineAdminFormSet(inline, formset,
-                fieldsets, prepopulated, readonly, model_admin=self)
-            inline_admin_formsets.append(inline_admin_formset)
-            media = media + inline_admin_formset.media
-
-        context = {
-            'title': _('Change %s') % force_text(opts.verbose_name),
-            'adminform': adminForm,
-            'object_id': object_id,
-            'original': obj,
-            'is_popup': IS_POPUP_VAR in request.REQUEST,
-            'media': media,
-            'inline_admin_formsets': inline_admin_formsets,
-            'errors': helpers.AdminErrorList(form, formsets),
-            'app_label': opts.app_label,
-            'preserved_filters': self.get_preserved_filters(request),
-        }
-        context.update(extra_context or {})
-        return self.render_change_form(request, context, change=True, obj=obj, form_url=form_url)
-
-    @csrf_protect_m
-    def changelist_view(self, request, extra_context=None):
-        """
-        The 'change list' admin view for this model.
-        """
-        from django.contrib.admin.views.main import ERROR_FLAG
-        opts = self.model._meta
-        app_label = opts.app_label
-        if not self.has_change_permission(request, None):
-            raise PermissionDenied
-
-        list_display = self.get_list_display(request)
-        list_display_links = self.get_list_display_links(request, list_display)
-        list_filter = self.get_list_filter(request)
-
-        # Check actions to see if any are available on this changelist
-        actions = self.get_actions(request)
-        if actions:
-            # Add the action checkboxes if there are any actions available.
-            list_display = ['action_checkbox'] + list(list_display)
-
-        ChangeList = self.get_changelist(request)
-        try:
-            cl = ChangeList(request, self.model, list_display,
-                list_display_links, list_filter, self.date_hierarchy,
-                self.search_fields, self.list_select_related,
-                self.list_per_page, self.list_max_show_all, self.list_editable,
-                self)
-        except IncorrectLookupParameters:
-            # Wacky lookup parameters were given, so redirect to the main
-            # changelist page, without parameters, and pass an 'invalid=1'
-            # parameter via the query string. If wacky parameters were given
-            # and the 'invalid=1' parameter was already in the query string,
-            # something is screwed up with the database, so display an error
-            # page.
-            if ERROR_FLAG in request.GET.keys():
-                return SimpleTemplateResponse('admin/invalid_setup.html', {
-                    'title': _('Database error'),
-                })
-            return HttpResponseRedirect(request.path + '?' + ERROR_FLAG + '=1')
-
-        # If the request was POSTed, this might be a bulk action or a bulk
-        # edit. Try to look up an action or confirmation first, but if this
-        # isn't an action the POST will fall through to the bulk edit check,
-        # below.
-        action_failed = False
-        selected = request.POST.getlist(helpers.ACTION_CHECKBOX_NAME)
-
-        # Actions with no confirmation
-        if (actions and request.method == 'POST' and
-                'index' in request.POST and '_save' not in request.POST):
-            if selected:
-                response = self.response_action(request, queryset=cl.get_queryset(request))
-                if response:
-                    return response
-                else:
-                    action_failed = True
-            else:
-                msg = _("Items must be selected in order to perform "
-                        "actions on them. No items have been changed.")
-                self.message_user(request, msg, messages.WARNING)
-                action_failed = True
-
-        # Actions with confirmation
-        if (actions and request.method == 'POST' and
-                helpers.ACTION_CHECKBOX_NAME in request.POST and
-                'index' not in request.POST and '_save' not in request.POST):
-            if selected:
-                response = self.response_action(request, queryset=cl.get_queryset(request))
-                if response:
-                    return response
-                else:
-                    action_failed = True
-
-        # If we're allowing changelist editing, we need to construct a formset
-        # for the changelist given all the fields to be edited. Then we'll
-        # use the formset to validate/process POSTed data.
-        formset = cl.formset = None
-
-        # Handle POSTed bulk-edit data.
-        if (request.method == "POST" and cl.list_editable and
-                '_save' in request.POST and not action_failed):
-            FormSet = self.get_changelist_formset(request)
-            formset = cl.formset = FormSet(request.POST, request.FILES, queryset=cl.result_list)
-            if formset.is_valid():
-                changecount = 0
-                for form in formset.forms:
-                    if form.has_changed():
-                        obj = self.save_form(request, form, change=True)
-                        self.save_model(request, obj, form, change=True)
-                        self.save_related(request, form, formsets=[], change=True)
-                        change_msg = self.construct_change_message(request, form, None)
-                        self.log_change(request, obj, change_msg)
-                        changecount += 1
-
-                if changecount:
-                    if changecount == 1:
-                        name = force_text(opts.verbose_name)
-                    else:
-                        name = force_text(opts.verbose_name_plural)
-                    msg = ungettext("%(count)s %(name)s was changed successfully.",
-                                    "%(count)s %(name)s were changed successfully.",
-                                    changecount) % {'count': changecount,
-                                                    'name': name,
-                                                    'obj': force_text(obj)}
-                    self.message_user(request, msg, messages.SUCCESS)
-
-                return HttpResponseRedirect(request.get_full_path())
-
-        # Handle GET -- construct a formset for display.
-        elif cl.list_editable:
-            FormSet = self.get_changelist_formset(request)
-            formset = cl.formset = FormSet(queryset=cl.result_list)
-
-        # Build the list of media to be used by the formset.
-        if formset:
-            media = self.media + formset.media
-        else:
-            media = self.media
-
-        # Build the action form and populate it with available actions.
-        if actions:
-            action_form = self.action_form(auto_id=None)
-            action_form.fields['action'].choices = self.get_action_choices(request)
-        else:
-            action_form = None
-
-        selection_note_all = ungettext('%(total_count)s selected',
-            'All %(total_count)s selected', cl.result_count)
-
-        context = {
-            'module_name': force_text(opts.verbose_name_plural),
-            'selection_note': _('0 of %(cnt)s selected') % {'cnt': len(cl.result_list)},
-            'selection_note_all': selection_note_all % {'total_count': cl.result_count},
-            'title': cl.title,
-            'is_popup': cl.is_popup,
-            'cl': cl,
-            'media': media,
-            'has_add_permission': self.has_add_permission(request),
-            'opts': cl.opts,
-            'app_label': app_label,
-            'action_form': action_form,
-            'actions_on_top': self.actions_on_top,
-            'actions_on_bottom': self.actions_on_bottom,
-            'actions_selection_counter': self.actions_selection_counter,
-            'preserved_filters': self.get_preserved_filters(request),
-        }
-        context.update(extra_context or {})
-
-        return TemplateResponse(request, self.change_list_template or [
-            'admin/%s/%s/change_list.html' % (app_label, opts.model_name),
-            'admin/%s/change_list.html' % app_label,
-            'admin/change_list.html'
-        ], context, current_app=self.admin_site.name)
-
-    @csrf_protect_m
-    @transaction.atomic
-    def delete_view(self, request, object_id, extra_context=None):
-        "The 'delete' admin view for this model."
-        opts = self.model._meta
-        app_label = opts.app_label
-
-        obj = self.get_object(request, unquote(object_id))
-
-        if not self.has_delete_permission(request, obj):
-            raise PermissionDenied
-
-        if obj is None:
-            raise Http404(
-                _('%(name)s object with primary key %(key)r does not exist.') %
-                    {'name': force_text(opts.verbose_name), 'key': escape(object_id)}
-            )
-
-        using = router.db_for_write(self.model)
-
-        # Populate deleted_objects, a data structure of all related objects that
-        # will also be deleted.
-        (deleted_objects, perms_needed, protected) = get_deleted_objects(
-            [obj], opts, request.user, self.admin_site, using)
-
-        if request.POST:  # The user has already confirmed the deletion.
-            if perms_needed:
-                raise PermissionDenied
-            obj_display = force_text(obj)
-            self.log_deletion(request, obj, obj_display)
-            self.delete_model(request, obj)
-
-            self.message_user(request, _(
-                'The %(name)s "%(obj)s" was deleted successfully.') % {
-                                       'name': force_text(opts.verbose_name),
-                                       'obj': force_text(obj_display)},
-                              messages.SUCCESS)
-
-            if self.has_change_permission(request, None):
-                post_url = reverse('admin:%s_%s_changelist' %
-                                   (opts.app_label, opts.model_name),
-                                   current_app=self.admin_site.name)
-                preserved_filters = self.get_preserved_filters(request)
-                post_url = add_preserved_filters(
-                    {'preserved_filters': preserved_filters, 'opts': opts}, post_url
-                )
-            else:
-                post_url = reverse('admin:index',
-                                   current_app=self.admin_site.name)
-            return HttpResponseRedirect(post_url)
-
-        object_name = force_text(opts.verbose_name)
-
-        if perms_needed or protected:
-            title = _("Cannot delete %(name)s") % {"name": object_name}
-        else:
-            title = _("Are you sure?")
-
-        context = {
-            "title": title,
-            "object_name": object_name,
-            "object": obj,
-            "deleted_objects": deleted_objects,
-            "perms_lacking": perms_needed,
-            "protected": protected,
-            "opts": opts,
-            "app_label": app_label,
-            'preserved_filters': self.get_preserved_filters(request),
-        }
-        context.update(extra_context or {})
-
-        return TemplateResponse(request, self.delete_confirmation_template or [
-            "admin/%s/%s/delete_confirmation.html" % (app_label, opts.model_name),
-            "admin/%s/delete_confirmation.html" % app_label,
-            "admin/delete_confirmation.html"
-        ], context, current_app=self.admin_site.name)
-
-    def history_view(self, request, object_id, extra_context=None):
-        "The 'history' admin view for this model."
-        from django.contrib.admin.models import LogEntry
-        # First check if the user can see this history.
-        model = self.model
-        obj = get_object_or_404(model, pk=unquote(object_id))
-
-        if not self.has_change_permission(request, obj):
-            raise PermissionDenied
-
-        # Then get the history for this object.
-        opts = model._meta
-        app_label = opts.app_label
-        action_list = LogEntry.objects.filter(
-            object_id=unquote(object_id),
-            content_type__id__exact=ContentType.objects.get_for_model(model).id
-        ).select_related().order_by('action_time')
-
-        context = {
-            'title': _('Change history: %s') % force_text(obj),
-            'action_list': action_list,
-            'module_name': capfirst(force_text(opts.verbose_name_plural)),
-            'object': obj,
-            'app_label': app_label,
-            'opts': opts,
-            'preserved_filters': self.get_preserved_filters(request),
-        }
-        context.update(extra_context or {})
-        return TemplateResponse(request, self.object_history_template or [
-            "admin/%s/%s/object_history.html" % (app_label, opts.model_name),
-            "admin/%s/object_history.html" % app_label,
-            "admin/object_history.html"
-        ], context, current_app=self.admin_site.name)
-
-
-class InlineModelAdmin(BaseModelAdmin):
-    """
-    Options for inline editing of ``model`` instances.
-
-    Provide ``name`` to specify the attribute name of the ``ForeignKey`` from
-    ``model`` to its parent. This is required if ``model`` has more than one
-    ``ForeignKey`` to its parent.
-    """
-    model = None
-    fk_name = None
-    formset = BaseInlineFormSet
-    extra = 3
-    max_num = None
-    template = None
-    verbose_name = None
-    verbose_name_plural = None
-    can_delete = True
-
-    # validation
-    validator_class = validation.InlineValidator
-
-    def __init__(self, parent_model, admin_site):
-        self.admin_site = admin_site
-        self.parent_model = parent_model
-        self.opts = self.model._meta
-        super(InlineModelAdmin, self).__init__()
-        if self.verbose_name is None:
-            self.verbose_name = self.model._meta.verbose_name
-        if self.verbose_name_plural is None:
-            self.verbose_name_plural = self.model._meta.verbose_name_plural
-
-    @property
-    def media(self):
-        extra = '' if settings.DEBUG else '.min'
-        js = ['jquery%s.js' % extra, 'jquery.init.js', 'inlines%s.js' % extra]
-        if self.prepopulated_fields:
-            js.extend(['urlify.js', 'prepopulate%s.js' % extra])
-        if self.filter_vertical or self.filter_horizontal:
-            js.extend(['SelectBox.js', 'SelectFilter2.js'])
-        return forms.Media(js=[static('admin/js/%s' % url) for url in js])
-
-    def get_extra(self, request, obj=None, **kwargs):
-        """Hook for customizing the number of extra inline forms."""
-        return self.extra
-
-    def get_max_num(self, request, obj=None, **kwargs):
-        """Hook for customizing the max number of extra inline forms."""
-        return self.max_num
-
-    def get_formset(self, request, obj=None, **kwargs):
-        """Returns a BaseInlineFormSet class for use in admin add/change views."""
-        if 'fields' in kwargs:
-            fields = kwargs.pop('fields')
-        else:
-            fields = flatten_fieldsets(self.get_fieldsets(request, obj))
-        if self.exclude is None:
-            exclude = []
-        else:
-            exclude = list(self.exclude)
-        exclude.extend(self.get_readonly_fields(request, obj))
-        if self.exclude is None and hasattr(self.form, '_meta') and self.form._meta.exclude:
-            # Take the custom ModelForm's Meta.exclude into account only if the
-            # InlineModelAdmin doesn't define its own.
-            exclude.extend(self.form._meta.exclude)
-        # if exclude is an empty list we use None, since that's the actual
-        # default
-        exclude = exclude or None
-        can_delete = self.can_delete and self.has_delete_permission(request, obj)
-        defaults = {
-            "form": self.form,
-            "formset": self.formset,
-            "fk_name": self.fk_name,
-            "fields": fields,
-            "exclude": exclude,
-            "formfield_callback": partial(self.formfield_for_dbfield, request=request),
-            "extra": self.get_extra(request, obj, **kwargs),
-            "max_num": self.get_max_num(request, obj, **kwargs),
-            "can_delete": can_delete,
-        }
-
-        defaults.update(kwargs)
-        base_model_form = defaults['form']
-
-        class DeleteProtectedModelForm(base_model_form):
-            def hand_clean_DELETE(self):
-                """
-                We don't validate the 'DELETE' field itself because on
-                templates it's not rendered using the field information, but
-                just using a generic "deletion_field" of the InlineModelAdmin.
-                """
-                if self.cleaned_data.get(DELETION_FIELD_NAME, False):
-                    using = router.db_for_write(self._meta.model)
-                    collector = NestedObjects(using=using)
-                    collector.collect([self.instance])
-                    if collector.protected:
-                        objs = []
-                        for p in collector.protected:
-                            objs.append(
-                                # Translators: Model verbose name and instance representation, suitable to be an item in a list
-                                _('%(class_name)s %(instance)s') % {
-                                    'class_name': p._meta.verbose_name,
-                                    'instance': p}
-                            )
-                        params = {'class_name': self._meta.model._meta.verbose_name,
-                                  'instance': self.instance,
-                                  'related_objects': get_text_list(objs, _('and'))}
-                        msg = _("Deleting %(class_name)s %(instance)s would require "
-                                "deleting the following protected related objects: "
-                                "%(related_objects)s")
-                        raise ValidationError(msg, code='deleting_protected', params=params)
-
-            def is_valid(self):
-                result = super(DeleteProtectedModelForm, self).is_valid()
-                self.hand_clean_DELETE()
-                return result
-
-        defaults['form'] = DeleteProtectedModelForm
-
-        if defaults['fields'] is None and not modelform_defines_fields(defaults['form']):
-            defaults['fields'] = forms.ALL_FIELDS
-
-        return inlineformset_factory(self.parent_model, self.model, **defaults)
-
-    def get_fieldsets(self, request, obj=None):
-        if self.declared_fieldsets:
-            return self.declared_fieldsets
-        form = self.get_formset(request, obj, fields=None).form
-        fields = list(form.base_fields) + list(self.get_readonly_fields(request, obj))
-        return [(None, {'fields': fields})]
-
-    def get_queryset(self, request):
-        queryset = super(InlineModelAdmin, self).get_queryset(request)
-        if not self.has_change_permission(request):
-            queryset = queryset.none()
-        return queryset
-
-    def has_add_permission(self, request):
-        if self.opts.auto_created:
-            # We're checking the rights to an auto-created intermediate model,
-            # which doesn't have its own individual permissions. The user needs
-            # to have the change permission for the related model in order to
-            # be able to do anything with the intermediate model.
-            return self.has_change_permission(request)
-        return super(InlineModelAdmin, self).has_add_permission(request)
-
-    def has_change_permission(self, request, obj=None):
-        opts = self.opts
-        if opts.auto_created:
-            # The model was auto-created as intermediary for a
-            # ManyToMany-relationship, find the target model
-            for field in opts.fields:
-                if field.rel and field.rel.to != self.parent_model:
-                    opts = field.rel.to._meta
-                    break
-        codename = get_permission_codename('change', opts)
-        return request.user.has_perm("%s.%s" % (opts.app_label, codename))
-
-    def has_delete_permission(self, request, obj=None):
-        if self.opts.auto_created:
-            # We're checking the rights to an auto-created intermediate model,
-            # which doesn't have its own individual permissions. The user needs
-            # to have the change permission for the related model in order to
-            # be able to do anything with the intermediate model.
-            return self.has_change_permission(request, obj)
-        return super(InlineModelAdmin, self).has_delete_permission(request, obj)
-
-
-class StackedInline(InlineModelAdmin):
-    template = 'admin/edit_inline/stacked.html'
-
-
-class TabularInline(InlineModelAdmin):
-    template = 'admin/edit_inline/tabular.html'
-- 
cgit