class PageNumberPagination

from rest_framework.pagination import PageNumberPagination
Documentation Source code
    A simple page number based style that supports page numbers as
    query parameters. For example:

    http://api.example.org/accounts/?page=4
    http://api.example.org/accounts/?page=4&page_size=100
    

Ancestors (MRO)

  1. PageNumberPagination
  2. BasePagination

Attributes

  Defined in
display_page_controls = False BasePagination
invalid_page_message = Invalid page "{page_number}": {message}. PageNumberPagination
last_page_strings = ('last',) PageNumberPagination
max_page_size = None PageNumberPagination
page_query_param = page PageNumberPagination
page_size = None PageNumberPagination
page_size_query_param = None PageNumberPagination
template = rest_framework/pagination/numbers.html PageNumberPagination
Expand Collapse

Methods

def _handle_backwards_compat(self, view): PageNumberPagination

        Prior to version 3.1, pagination was handled in the view, and the
        attributes were set there. The attributes should now be set on
        the pagination class, but the old style is still pending deprecation.
        
    def _handle_backwards_compat(self, view):
        """
        Prior to version 3.1, pagination was handled in the view, and the
        attributes were set there. The attributes should now be set on
        the pagination class, but the old style is still pending deprecation.
        """
        assert not (
            getattr(view, 'pagination_serializer_class', None) or
            getattr(api_settings, 'DEFAULT_PAGINATION_SERIALIZER_CLASS', None)
        ), (
            "The pagination_serializer_class attribute and "
            "DEFAULT_PAGINATION_SERIALIZER_CLASS setting have been removed as "
            "part of the 3.1 pagination API improvement. See the pagination "
            "documentation for details on the new API."
        )

        for (settings_key, attr_name) in (
            ('PAGINATE_BY', 'page_size'),
            ('PAGINATE_BY_PARAM', 'page_size_query_param'),
            ('MAX_PAGINATE_BY', 'max_page_size')
        ):
            value = getattr(api_settings, settings_key, None)
            if value is not None:
                setattr(self, attr_name, value)
                warnings.warn(
                    "The `%s` settings key is pending deprecation. "
                    "Use the `%s` attribute on the pagination class instead." % (
                        settings_key, attr_name
                    ),
                    PendingDeprecationWarning,
                )

        for (view_attr, attr_name) in (
            ('paginate_by', 'page_size'),
            ('page_query_param', 'page_query_param'),
            ('paginate_by_param', 'page_size_query_param'),
            ('max_paginate_by', 'max_page_size')
        ):
            value = getattr(view, view_attr, None)
            if value is not None:
                setattr(self, attr_name, value)
                warnings.warn(
                    "The `%s` view attribute is pending deprecation. "
                    "Use the `%s` attribute on the pagination class instead." % (
                        view_attr, attr_name
                    ),
                    PendingDeprecationWarning,
                )

def get_html_context(self): PageNumberPagination

    def get_html_context(self):
        base_url = self.request.build_absolute_uri()

        def page_number_to_url(page_number):
            if page_number == 1:
                return remove_query_param(base_url, self.page_query_param)
            else:
                return replace_query_param(base_url, self.page_query_param, page_number)

        current = self.page.number
        final = self.page.paginator.num_pages
        page_numbers = _get_displayed_page_numbers(current, final)
        page_links = _get_page_links(page_numbers, current, page_number_to_url)

        return {
            'previous_url': self.get_previous_link(),
            'next_url': self.get_next_link(),
            'page_links': page_links
        }

def get_next_link(self): PageNumberPagination

def get_page_size(self, request): PageNumberPagination

    def get_page_size(self, request):
        if self.page_size_query_param:
            try:
                return _positive_int(
                    request.query_params[self.page_size_query_param],
                    strict=True,
                    cutoff=self.max_page_size
                )
            except (KeyError, ValueError):
                pass

        return self.page_size

def get_paginated_response(self, data):

PageNumberPagination

    def get_paginated_response(self, data):
        return Response(OrderedDict([
            ('count', self.page.paginator.count),
            ('next', self.get_next_link()),
            ('previous', self.get_previous_link()),
            ('results', data)
        ]))

BasePagination

    def get_paginated_response(self, data):  # pragma: no cover
        raise NotImplementedError('get_paginated_response() must be implemented.')

def get_previous_link(self): PageNumberPagination

def paginate_queryset(self, queryset, request, view=None):

PageNumberPagination

        Paginate a queryset if required, either returning a
        page object, or `None` if pagination is not configured for this view.
        
    def paginate_queryset(self, queryset, request, view=None):
        """
        Paginate a queryset if required, either returning a
        page object, or `None` if pagination is not configured for this view.
        """
        self._handle_backwards_compat(view)

        page_size = self.get_page_size(request)
        if not page_size:
            return None

        paginator = DjangoPaginator(queryset, page_size)
        page_number = request.query_params.get(self.page_query_param, 1)
        if page_number in self.last_page_strings:
            page_number = paginator.num_pages

        try:
            self.page = paginator.page(page_number)
        except InvalidPage as exc:
            msg = self.invalid_page_message.format(
                page_number=page_number, message=six.text_type(exc)
            )
            raise NotFound(msg)

        if paginator.count > 1 and self.template is not None:
            # The browsable API should display pagination controls.
            self.display_page_controls = True

        self.request = request
        return list(self.page)

BasePagination

    def paginate_queryset(self, queryset, request, view=None):  # pragma: no cover
        raise NotImplementedError('paginate_queryset() must be implemented.')

def to_html(self):

PageNumberPagination

    def to_html(self):
        template = loader.get_template(self.template)
        context = Context(self.get_html_context())
        return template.render(context)

BasePagination

    def to_html(self):  # pragma: no cover
        raise NotImplementedError('to_html() must be implemented to display page controls.')