Upgrade to Django 1.11

- Database integration yet to be tested

1 files changed, 0 insertions, 427 deletions

diff --git a/lib/python2.7/site-packages/django/contrib/admin/views/main.py b/lib/python2.7/site-packages/django/contrib/admin/views/main.py
deleted file mode 100644
index e7b2391..0000000
--- a/lib/python2.7/site-packages/django/contrib/admin/views/main.py
+++ /dev/null
@@ -1,427 +0,0 @@
-import sys
-import warnings
-
-from django.core.exceptions import SuspiciousOperation, ImproperlyConfigured
-from django.core.paginator import InvalidPage
-from django.core.urlresolvers import reverse
-from django.db import models
-from django.db.models.fields import FieldDoesNotExist
-from django.utils import six
-from django.utils.datastructures import SortedDict
-from django.utils.deprecation import RenameMethodsBase
-from django.utils.encoding import force_str, force_text
-from django.utils.translation import ugettext, ugettext_lazy
-from django.utils.http import urlencode
-
-from django.contrib.admin import FieldListFilter
-from django.contrib.admin.exceptions import DisallowedModelAdminLookup
-from django.contrib.admin.options import IncorrectLookupParameters, IS_POPUP_VAR
-from django.contrib.admin.util import (quote, get_fields_from_path,
-    lookup_needs_distinct, prepare_lookup_value)
-
-# Changelist settings
-ALL_VAR = 'all'
-ORDER_VAR = 'o'
-ORDER_TYPE_VAR = 'ot'
-PAGE_VAR = 'p'
-SEARCH_VAR = 'q'
-TO_FIELD_VAR = 't'
-ERROR_FLAG = 'e'
-
-IGNORED_PARAMS = (
-    ALL_VAR, ORDER_VAR, ORDER_TYPE_VAR, SEARCH_VAR, IS_POPUP_VAR, TO_FIELD_VAR)
-
-# Text to display within change-list table cells if the value is blank.
-EMPTY_CHANGELIST_VALUE = ugettext_lazy('(None)')
-
-
-def _is_changelist_popup(request):
-    """
-    Returns True if the popup GET parameter is set.
-
-    This function is introduced to facilitate deprecating the legacy
-    value for IS_POPUP_VAR and should be removed at the end of the
-    deprecation cycle.
-    """
-
-    if IS_POPUP_VAR in request.GET:
-        return True
-
-    IS_LEGACY_POPUP_VAR = 'pop'
-    if IS_LEGACY_POPUP_VAR in request.GET:
-        warnings.warn(
-        "The `%s` GET parameter has been renamed to `%s`." %
-        (IS_LEGACY_POPUP_VAR, IS_POPUP_VAR),
-        PendingDeprecationWarning, 2)
-        return True
-
-    return False
-
-
-class RenameChangeListMethods(RenameMethodsBase):
-    renamed_methods = (
-        ('get_query_set', 'get_queryset', PendingDeprecationWarning),
-    )
-
-
-class ChangeList(six.with_metaclass(RenameChangeListMethods)):
-    def __init__(self, request, model, list_display, list_display_links,
-            list_filter, date_hierarchy, search_fields, list_select_related,
-            list_per_page, list_max_show_all, list_editable, model_admin):
-        self.model = model
-        self.opts = model._meta
-        self.lookup_opts = self.opts
-        self.root_queryset = model_admin.get_queryset(request)
-        self.list_display = list_display
-        self.list_display_links = list_display_links
-        self.list_filter = list_filter
-        self.date_hierarchy = date_hierarchy
-        self.search_fields = search_fields
-        self.list_select_related = list_select_related
-        self.list_per_page = list_per_page
-        self.list_max_show_all = list_max_show_all
-        self.model_admin = model_admin
-        self.preserved_filters = model_admin.get_preserved_filters(request)
-
-        # Get search parameters from the query string.
-        try:
-            self.page_num = int(request.GET.get(PAGE_VAR, 0))
-        except ValueError:
-            self.page_num = 0
-        self.show_all = ALL_VAR in request.GET
-        self.is_popup = _is_changelist_popup(request)
-        self.to_field = request.GET.get(TO_FIELD_VAR)
-        self.params = dict(request.GET.items())
-        if PAGE_VAR in self.params:
-            del self.params[PAGE_VAR]
-        if ERROR_FLAG in self.params:
-            del self.params[ERROR_FLAG]
-
-        if self.is_popup:
-            self.list_editable = ()
-        else:
-            self.list_editable = list_editable
-        self.query = request.GET.get(SEARCH_VAR, '')
-        self.queryset = self.get_queryset(request)
-        self.get_results(request)
-        if self.is_popup:
-            title = ugettext('Select %s')
-        else:
-            title = ugettext('Select %s to change')
-        self.title = title % force_text(self.opts.verbose_name)
-        self.pk_attname = self.lookup_opts.pk.attname
-
-    @property
-    def root_query_set(self):
-        warnings.warn("`ChangeList.root_query_set` is deprecated, "
-                      "use `root_queryset` instead.",
-                      PendingDeprecationWarning, 2)
-        return self.root_queryset
-
-    @property
-    def query_set(self):
-        warnings.warn("`ChangeList.query_set` is deprecated, "
-                      "use `queryset` instead.",
-                      PendingDeprecationWarning, 2)
-        return self.queryset
-
-    def get_filters_params(self, params=None):
-        """
-        Returns all params except IGNORED_PARAMS
-        """
-        if not params:
-            params = self.params
-        lookup_params = params.copy() # a dictionary of the query string
-        # Remove all the parameters that are globally and systematically
-        # ignored.
-        for ignored in IGNORED_PARAMS:
-            if ignored in lookup_params:
-                del lookup_params[ignored]
-        return lookup_params
-
-    def get_filters(self, request):
-        lookup_params = self.get_filters_params()
-        use_distinct = False
-
-        # Normalize the types of keys
-        for key, value in lookup_params.items():
-            if not isinstance(key, str):
-                # 'key' will be used as a keyword argument later, so Python
-                # requires it to be a string.
-                del lookup_params[key]
-                lookup_params[force_str(key)] = value
-
-            if not self.model_admin.lookup_allowed(key, value):
-                raise DisallowedModelAdminLookup("Filtering by %s not allowed" % key)
-
-        filter_specs = []
-        if self.list_filter:
-            for list_filter in self.list_filter:
-                if callable(list_filter):
-                    # This is simply a custom list filter class.
-                    spec = list_filter(request, lookup_params,
-                        self.model, self.model_admin)
-                else:
-                    field_path = None
-                    if isinstance(list_filter, (tuple, list)):
-                        # This is a custom FieldListFilter class for a given field.
-                        field, field_list_filter_class = list_filter
-                    else:
-                        # This is simply a field name, so use the default
-                        # FieldListFilter class that has been registered for
-                        # the type of the given field.
-                        field, field_list_filter_class = list_filter, FieldListFilter.create
-                    if not isinstance(field, models.Field):
-                        field_path = field
-                        field = get_fields_from_path(self.model, field_path)[-1]
-                    spec = field_list_filter_class(field, request, lookup_params,
-                        self.model, self.model_admin, field_path=field_path)
-                    # Check if we need to use distinct()
-                    use_distinct = (use_distinct or
-                                    lookup_needs_distinct(self.lookup_opts,
-                                                          field_path))
-                if spec and spec.has_output():
-                    filter_specs.append(spec)
-
-        # At this point, all the parameters used by the various ListFilters
-        # have been removed from lookup_params, which now only contains other
-        # parameters passed via the query string. We now loop through the
-        # remaining parameters both to ensure that all the parameters are valid
-        # fields and to determine if at least one of them needs distinct(). If
-        # the lookup parameters aren't real fields, then bail out.
-        try:
-            for key, value in lookup_params.items():
-                lookup_params[key] = prepare_lookup_value(key, value)
-                use_distinct = (use_distinct or
-                                lookup_needs_distinct(self.lookup_opts, key))
-            return filter_specs, bool(filter_specs), lookup_params, use_distinct
-        except FieldDoesNotExist as e:
-            six.reraise(IncorrectLookupParameters, IncorrectLookupParameters(e), sys.exc_info()[2])
-
-    def get_query_string(self, new_params=None, remove=None):
-        if new_params is None: new_params = {}
-        if remove is None: remove = []
-        p = self.params.copy()
-        for r in remove:
-            for k in list(p):
-                if k.startswith(r):
-                    del p[k]
-        for k, v in new_params.items():
-            if v is None:
-                if k in p:
-                    del p[k]
-            else:
-                p[k] = v
-        return '?%s' % urlencode(sorted(p.items()))
-
-    def get_results(self, request):
-        paginator = self.model_admin.get_paginator(request, self.queryset, self.list_per_page)
-        # Get the number of objects, with admin filters applied.
-        result_count = paginator.count
-
-        # Get the total number of objects, with no admin filters applied.
-        # Perform a slight optimization:
-        # full_result_count is equal to paginator.count if no filters
-        # were applied
-        if self.get_filters_params() or self.params.get(SEARCH_VAR):
-            full_result_count = self.root_queryset.count()
-        else:
-            full_result_count = result_count
-        can_show_all = result_count <= self.list_max_show_all
-        multi_page = result_count > self.list_per_page
-
-        # Get the list of objects to display on this page.
-        if (self.show_all and can_show_all) or not multi_page:
-            result_list = self.queryset._clone()
-        else:
-            try:
-                result_list = paginator.page(self.page_num+1).object_list
-            except InvalidPage:
-                raise IncorrectLookupParameters
-
-        self.result_count = result_count
-        self.full_result_count = full_result_count
-        self.result_list = result_list
-        self.can_show_all = can_show_all
-        self.multi_page = multi_page
-        self.paginator = paginator
-
-    def _get_default_ordering(self):
-        ordering = []
-        if self.model_admin.ordering:
-            ordering = self.model_admin.ordering
-        elif self.lookup_opts.ordering:
-            ordering = self.lookup_opts.ordering
-        return ordering
-
-    def get_ordering_field(self, field_name):
-        """
-        Returns the proper model field name corresponding to the given
-        field_name to use for ordering. field_name may either be the name of a
-        proper model field or the name of a method (on the admin or model) or a
-        callable with the 'admin_order_field' attribute. Returns None if no
-        proper model field name can be matched.
-        """
-        try:
-            field = self.lookup_opts.get_field(field_name)
-            return field.name
-        except models.FieldDoesNotExist:
-            # See whether field_name is a name of a non-field
-            # that allows sorting.
-            if callable(field_name):
-                attr = field_name
-            elif hasattr(self.model_admin, field_name):
-                attr = getattr(self.model_admin, field_name)
-            else:
-                attr = getattr(self.model, field_name)
-            return getattr(attr, 'admin_order_field', None)
-
-    def get_ordering(self, request, queryset):
-        """
-        Returns the list of ordering fields for the change list.
-        First we check the get_ordering() method in model admin, then we check
-        the object's default ordering. Then, any manually-specified ordering
-        from the query string overrides anything. Finally, a deterministic
-        order is guaranteed by ensuring the primary key is used as the last
-        ordering field.
-        """
-        params = self.params
-        ordering = list(self.model_admin.get_ordering(request)
-                        or self._get_default_ordering())
-        if ORDER_VAR in params:
-            # Clear ordering and used params
-            ordering = []
-            order_params = params[ORDER_VAR].split('.')
-            for p in order_params:
-                try:
-                    none, pfx, idx = p.rpartition('-')
-                    field_name = self.list_display[int(idx)]
-                    order_field = self.get_ordering_field(field_name)
-                    if not order_field:
-                        continue # No 'admin_order_field', skip it
-                    ordering.append(pfx + order_field)
-                except (IndexError, ValueError):
-                    continue # Invalid ordering specified, skip it.
-
-        # Add the given query's ordering fields, if any.
-        ordering.extend(queryset.query.order_by)
-
-        # Ensure that the primary key is systematically present in the list of
-        # ordering fields so we can guarantee a deterministic order across all
-        # database backends.
-        pk_name = self.lookup_opts.pk.name
-        if not (set(ordering) & set(['pk', '-pk', pk_name, '-' + pk_name])):
-            # The two sets do not intersect, meaning the pk isn't present. So
-            # we add it.
-            ordering.append('-pk')
-
-        return ordering
-
-    def get_ordering_field_columns(self):
-        """
-        Returns a SortedDict of ordering field column numbers and asc/desc
-        """
-
-        # We must cope with more than one column having the same underlying sort
-        # field, so we base things on column numbers.
-        ordering = self._get_default_ordering()
-        ordering_fields = SortedDict()
-        if ORDER_VAR not in self.params:
-            # for ordering specified on ModelAdmin or model Meta, we don't know
-            # the right column numbers absolutely, because there might be more
-            # than one column associated with that ordering, so we guess.
-            for field in ordering:
-                if field.startswith('-'):
-                    field = field[1:]
-                    order_type = 'desc'
-                else:
-                    order_type = 'asc'
-                for index, attr in enumerate(self.list_display):
-                    if self.get_ordering_field(attr) == field:
-                        ordering_fields[index] = order_type
-                        break
-        else:
-            for p in self.params[ORDER_VAR].split('.'):
-                none, pfx, idx = p.rpartition('-')
-                try:
-                    idx = int(idx)
-                except ValueError:
-                    continue # skip it
-                ordering_fields[idx] = 'desc' if pfx == '-' else 'asc'
-        return ordering_fields
-
-    def get_queryset(self, request):
-        # First, we collect all the declared list filters.
-        (self.filter_specs, self.has_filters, remaining_lookup_params,
-         filters_use_distinct) = self.get_filters(request)
-
-        # Then, we let every list filter modify the queryset to its liking.
-        qs = self.root_queryset
-        for filter_spec in self.filter_specs:
-            new_qs = filter_spec.queryset(request, qs)
-            if new_qs is not None:
-                qs = new_qs
-
-        try:
-            # Finally, we apply the remaining lookup parameters from the query
-            # string (i.e. those that haven't already been processed by the
-            # filters).
-            qs = qs.filter(**remaining_lookup_params)
-        except (SuspiciousOperation, ImproperlyConfigured):
-            # Allow certain types of errors to be re-raised as-is so that the
-            # caller can treat them in a special way.
-            raise
-        except Exception as e:
-            # Every other error is caught with a naked except, because we don't
-            # have any other way of validating lookup parameters. They might be
-            # invalid if the keyword arguments are incorrect, or if the values
-            # are not in the correct type, so we might get FieldError,
-            # ValueError, ValidationError, or ?.
-            raise IncorrectLookupParameters(e)
-
-        if not qs.query.select_related:
-            qs = self.apply_select_related(qs)
-
-        # Set ordering.
-        ordering = self.get_ordering(request, qs)
-        qs = qs.order_by(*ordering)
-
-        # Apply search results
-        qs, search_use_distinct = self.model_admin.get_search_results(
-            request, qs, self.query)
-
-        # Remove duplicates from results, if necessary
-        if filters_use_distinct | search_use_distinct:
-            return qs.distinct()
-        else:
-            return qs
-
-    def apply_select_related(self, qs):
-        if self.list_select_related is True:
-            return qs.select_related()
-
-        if self.list_select_related is False:
-            if self.has_related_field_in_list_display():
-                return qs.select_related()
-
-        if self.list_select_related:
-            return qs.select_related(*self.list_select_related)
-        return qs
-
-    def has_related_field_in_list_display(self):
-        for field_name in self.list_display:
-            try:
-                field = self.lookup_opts.get_field(field_name)
-            except models.FieldDoesNotExist:
-                pass
-            else:
-                if isinstance(field.rel, models.ManyToOneRel):
-                    return True
-        return False
-
-    def url_for_result(self, result):
-        pk = getattr(result, self.pk_attname)
-        return reverse('admin:%s_%s_change' % (self.opts.app_label,
-                                               self.opts.model_name),
-                       args=(quote(pk),),
-                       current_app=self.model_admin.admin_site.name)