Intermediate fetching
        
        Args:
            pageNum (int): Page number
            itemsPerPage (int): Number of Users per Page
            
        Returns:
            dict: Response payload
348963
def fetch(self, pageNum, itemsPerPage):
        
        return self.get_all_alerts(self.status, pageNum, itemsPerPage)
1144836
def api_get_collection(path, collection, *args)
      Enumerator.new do |enum|
        args[0] = {} unless args[0]
        page_size = (args[0].delete(:page_size) { 100 }).to_i
        page_number = (args[0].delete(:page_number) { 1 }).to_i

        loop do
          uri = URI::HTTP.build(path: "/#{path}", query: URI.encode_www_form(pageSize: page_size, pageNumber: page_number)).request_uri

          res = api_get(uri, *args)
          raise TableauError, res if res.code.to_s != '200'

          # ensure the result is an array because it will not be an array if there is only one element
          [collection.split('.').reduce(res['tsResponse']) { |acc, elem| acc && acc[elem] }].flatten.compact.each do |obj|
            enum.yield obj
          end

          break if res['tsResponse']['pagination'].nil?
          break if page_number >= (res['tsResponse']['pagination']['totalAvailable'].to_i / page_size.to_f).ceil

          page_number += 1
        end
      end
    end
254700
def get_offers_per_page(self, per_page=1000, page=1, params=None):
        
        return self._get_resource_per_page(resource=OFFERS, per_page=per_page, page=page, params=params)
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
910645
def page(self, page_number=0) -> list:
        
        # workaround flask-sqlalchemy/issues/516
        offset = page_number * self.limit
        sql = 'SELECT * FROM %s {} LIMIT :li OFFSET :o' \
            % (self.model.__tablename__)
        filter_query = self.__filter_query()
        if filter_query is None:
            sql = text(sql.format(''))
            result = self.model.db.engine.execute(
                sql, li=self.limit, o=offset)
        else:
            filter_query['binds']['li'] = self.limit
            filter_query['binds']['o'] = offset
            sql = text(sql.format(filter_query['query']))
            result = self.model.db.engine.execute(
                sql, **filter_query['binds'])
        result_keys = result.keys()
        result_models = []
        for row in result:
            model = self.model()
            key_count = 0
            for key in result_keys:
                setattr(model, key, row[key_count])
                key_count = key_count + 1
            result_models.append(model)
        return result_models
1278514
def get_children_for_page(self, page):
        """"""
        if self.max_levels == 1:
            # If there's only a single level of pages to display, skip the
            # dict creation / lookup and just return the QuerySet result
            return self.pages_for_display
        return super().get_children_for_page(page)
378437
function (pageNum) {
            var svgPath = util.template(config.template.svg, { page: pageNum });
            return config.url + svgPath + config.queryString;
        }
422731
def compat_get_paginated_response(view, page):
    
    if DRFVLIST[0] == 3 and DRFVLIST[1] >= 1:
        from rest_messaging.serializers import ComplexMessageSerializer  # circular import
        serializer = ComplexMessageSerializer(page, many=True)
        return view.get_paginated_response(serializer.data)
    else:
        serializer = view.get_pagination_serializer(page)
        return Response(serializer.data)
363957
def get_incomings_per_page(self, per_page=1000, page=1, params=None):
        
        return self._get_resource_per_page(resource=INCOMINGS, per_page=per_page, page=page, params=params)
503567
def get_items_of_recurring_per_page(self, recurring_id, per_page=1000, page=1):
        
        return self._get_resource_per_page(
            resource=RECURRING_ITEMS,
            per_page=per_page,
            page=page,
            params={'recurring_id': recurring_id},
        )
662643
def _next_page(self):
        
        if self._has_next_page():
            response = self._get_next_page_response()
            items = response.get(self._items_key, ())
            page = Page(self, items, self.item_to_value)
            self._page_start(self, page, response)
            self.next_page_token = response.get(self._next_token)
            return page
        else:
            return None
1327829
def get_items_of_invoice_per_page(self, invoice_id, per_page=1000, page=1):
        
        return self._get_resource_per_page(
            resource=INVOICE_ITEMS,
            per_page=per_page,
            page=page,
            params={'invoice_id': invoice_id},
        )
491465
def checkAndRaise(pageNum, itemsPerPage):
        
        if pageNum < 1:
            raise ErrPaginationLimits(ErrPaginationLimits.ERR_PAGE_NUM)
        
        if itemsPerPage < Settings.itemsPerPageMin or itemsPerPage > Settings.itemsPerPageMax:
            raise ErrPaginationLimits(ErrPaginationLimits.ERR_ITEMS_PER_PAGE)
360165
def get_client_properties_per_page(self, per_page=1000, page=1, params=None):
        
        return self._get_resource_per_page(
            resource=CLIENT_PROPERTIES,
            per_page=per_page,
            page=page,
            params=params
        )
614240
def page(self, number):
        
        number = self.validate_number(number)
        bottom = (number - 1) * self.per_page
        top = bottom + self.per_page
        page_items = self.object_list[bottom:top]
        # check moved from validate_number
        if not page_items:
            if number == 1 and self.allow_empty_first_page:
                pass
            else:
                raise EmptyPage('That page contains no results')
        return InfinitePage(page_items, number, self)
345808
def get_recurrings_per_page(self, per_page=1000, page=1, params=None):
        
        return self._get_resource_per_page(resource=RECURRINGS, per_page=per_page, page=page, params=params)
517556
def load_page(page_num)
      params = @query.merge(pagination_params(page_num))
      response = @client.api_request(:get, @path, :params => params)

      metadata = parse_metadata(response)
      @num_records, @num_pages = metadata['records'], metadata['pages']

      Page.new(@resource_class, response.parsed, metadata['links'])
    end