class MultipleObjectMixin

def get_allow_empty(self):
    """
    Return ``True`` if the view should display empty lists and ``False``
    if a 404 should be raised instead.
    """
    return self.allow_empty

def get_context_object_name(self, object_list):
    """Get the name of the item to be used in the context."""
    if self.context_object_name:
        return self.context_object_name
    elif hasattr(object_list, 'model'):
        return '%s_list' % object_list.model._meta.model_name
    else:
        return None

def get_ordering(self):
    """Return the field or fields to use for ordering the queryset."""
    return self.ordering

def get_paginate_by(self, queryset):
    """
    Get the number of items to paginate by, or ``None`` for no pagination.
    """
    return self.paginate_by

def get_paginate_orphans(self):
    """
    Return the maximum number of orphans extend the last page by when
    paginating.
    """
    return self.paginate_orphans

def get_paginator(self, queryset, per_page, orphans=0,
                  allow_empty_first_page=True, **kwargs):
    """Return an instance of the paginator for this view."""
    return self.paginator_class(
        queryset, per_page, orphans=orphans,
        allow_empty_first_page=allow_empty_first_page, **kwargs)

def get_queryset(self):
    """
    Return the list of items for this view.
    The return value must be an iterable and may be an instance of
    `QuerySet` in which case `QuerySet` specific behavior will be enabled.
    """
    if self.queryset is not None:
        queryset = self.queryset
        if isinstance(queryset, QuerySet):
            queryset = queryset.all()
    elif self.model is not None:
        queryset = self.model._default_manager.all()
    else:
        raise ImproperlyConfigured(
            "%(cls)s is missing a QuerySet. Define "
            "%(cls)s.model, %(cls)s.queryset, or override "
            "%(cls)s.get_queryset()." % {
                'cls': self.__class__.__name__
            }
        )
    ordering = self.get_ordering()
    if ordering:
        if isinstance(ordering, str):
            ordering = (ordering,)
        queryset = queryset.order_by(*ordering)
    return queryset

def paginate_queryset(self, queryset, page_size):
    """Paginate the queryset, if needed."""
    paginator = self.get_paginator(
        queryset, page_size, orphans=self.get_paginate_orphans(),
        allow_empty_first_page=self.get_allow_empty())
    page_kwarg = self.page_kwarg
    page = self.kwargs.get(page_kwarg) or self.request.GET.get(page_kwarg) or 1
    try:
        page_number = int(page)
    except ValueError:
        if page == 'last':
            page_number = paginator.num_pages
        else:
            raise Http404(_('Page is not “last”, nor can it be converted to an int.'))
    try:
        page = paginator.page(page_number)
        return (paginator, page, page.object_list, page.has_other_pages())
    except InvalidPage as e:
        raise Http404(_('Invalid page (%(page_number)s): %(message)s') % {
            'page_number': page_number,
            'message': str(e)
        })