Fetches next page based on previously fetched data.
        Will get the next page url from data['paging']['next'].

        :param data: previously fetched API response.
        :type data: dict        
        :return: API response.
        :rtype: dict
338678
def fetch_next_page(self, data):
        '''
        
        '''
        next_url = data['paging']['next']
        if next_url != None:
            next_data = self.http._post_data(next_url, None, self.http._headers_with_access_token())
            return next_data
        else:
            return None
1177210
def next_page(self):
        
        if not self.next_page_url:
            return None

        response = self._version.domain.twilio.request('GET', self.next_page_url)
        cls = type(self)
        return cls(self._version, response, self._solution)
219555
def previous_page(self):
        
        if self.is_first_page():
            return False

        self.page -= 1
        self.items = self.fetch_items()
        return True
726406
def next(self, error_out=False):
        """"""
        assert self.query is not None, 'a query object is required ' \
                                       'for this method to work'
        return self.query.paginate(self.page + 1, self.per_page, error_out)
168252
def _nextPage(self, offset):
        """"""
        self.logger.debug("Iterator crecord=%s" % str(self.crecord))

        params = {
            'q': self.q,
            'rows': '0',
            'facet': 'true',
            'facet.field': self.field,
            'facet.limit': str(self.pagesize),
            'facet.offset': str(offset),
            'facet.zeros': 'false',
            'wt': 'python',
        }
        if self.fq is not None:
            params['fq'] = self.fq
        request = urllib.parse.urlencode(params, doseq=True)
        rsp = self.client.doPost(
            self.client.solrBase + '', request, self.client.formheaders
        )
        data = eval(rsp.read())
        try:
            self.res = data['facet_counts']['facet_fields'][self.field]
            self.logger.debug(self.res)
        except Exception:
            self.res = []
        self.index = 0
204170
def get_page(n)
            raise IndexError, "Page numbers are referenced starting from 1" if n < 1
            raise IndexError, "Page not found" if n > self.Count.to_i

            self.each_page.lazy.drop(n - 1).first or raise IndexError, "Page not found"
        end
553773
def get(self, request):
        
        sections = self.generate_sections()

        if self.paginated:
            p = Paginator(sections, 25)

            page = request.GET.get('page')

            try:
                sections = p.page(page)
            except PageNotAnInteger:
                # If page is not an integer, deliver first page.
                sections = p.page(1)
            except EmptyPage:
                # If page is out of range (e.g. 9999), return last page
                # of results.
                sections = p.page(p.num_pages)

            pageUpper = int(p.num_pages) / 2

            try:
                pageLower = int(page) / 2
            except TypeError:
                pageLower = -999
        else:
            pageUpper = None
            pageLower = None

        context = {
            'sections': sections,
            'page_title': self.generate_page_title(),
            'browse_type': self.browse_type,
            'pageUpper': pageUpper,
            'pageLower': pageLower
        }

        return render(
            request,
            self.template_path,
            context
        )
932689
def next_page(self):
        
        try:
            next_url = self.next_url
        except AttributeError:
            raise PageError("Page %r has no next page" % self)
        return self.page_for_url(next_url)
1309392
def list_records_next_page(self):
        
        uri = self._paging.get("record", {}).get("next_uri")
        if uri is None:
            raise exc.NoMoreResults("There are no more pages of records to list.")
        return self._list_records(uri)
246883
def accel_next(self, *args):
        
        if self.get_notebook().get_current_page() + 1 == self.get_notebook().get_n_pages():
            self.get_notebook().set_current_page(0)
        else:
            self.get_notebook().next_page()
        return True
880996
def next(self):
        
        try:
            return self.results.pop(0)
        except IndexError:
            if self.next_uri is None:
                raise StopIteration()
            else:
                if not self.next_uri:
                    if self.domain:
                        self.results = self.list_method(self.domain)
                    else:
                        self.results = self.list_method()
                else:
                    args = self.extra_args
                    self.results = self._list_method(self.next_uri, *args)
                self.next_uri = self.manager._paging.get(
                        self.paging_service, {}).get("next_uri")
        # We should have more results.
        try:
            return self.results.pop(0)
        except IndexError:
            raise StopIteration()
404512
def _next(self, **kwargs):
        
        spec = self._pagination_default_spec(kwargs)
        spec.update(kwargs)

        query = queries.build_query(spec)
        query = queries.where_after_entry(query, self._record)

        for record in query.order_by(model.Entry.local_date,
                                     model.Entry.id)[:1]:
            return Entry(record)
        return None
1010760
def _nextPage(self, offset):
        """"""
        self.logger.debug("Iterator crecord=%s" % str(self.crecord))
        params = {
            'q': self.q,
            'start': str(offset),
            'rows': str(self.pagesize),
            'fl': self.fields,
            'explainOther': '',
            'hl.fl': '',
        }
        if self.fq is not None:
            params['fq'] = self.fq
        self.res = self.client.search(params)
        self._numhits = int(self.res['response']['numFound'])
13735
async def async_get(self, url):
        
        self.reset()
        self.next_link = url
        return await self.async_advance_page()
466100
def paginate_response(self, queryset, serializers_kwargs={}):
        
        page = self.paginate_queryset(queryset)
        if page is not None:
            serializer = self.get_serializer(page, many=True, **serializers_kwargs)
            return self.get_paginated_response(serializer.data)

        serializer = self.get_serializer(queryset, many=True, **serializers_kwargs)
        return Response(serializer.data)
840022
def _fetch_features(self):
        
        if self.next_page_url is None:
            return

        response = get_json(self.next_page_url, post_values=self.query, headers=self.gpd_session.session_headers)

        self.features.extend(response['features'])
        self.next_page_url = response['pagination']['next']
        self.layer_size = response['pagination']['total']
273329
def decode_iter_request(data: dict) -> Optional[Union[str, int]]:
    
    if "response_metadata" in data:
        return data["response_metadata"].get("next_cursor")
    elif "paging" in data:
        current_page = int(data["paging"].get("page", 1))
        max_page = int(data["paging"].get("pages", 1))

        if current_page < max_page:
            return current_page + 1
    elif "has_more" in data and data["has_more"] and "latest" in data:
        return data["messages"][-1]["ts"]

    return None