Get items of reminder per page

        :param reminder_id: the reminder id
        :param per_page: How many objects per page. Default: 1000
        :param page: Which page. Default: 1
        :return: list
960605
def get_items_of_reminder_per_page(self, reminder_id, per_page=1000, page=1):
        
        return self._get_resource_per_page(
            resource=REMINDER_ITEMS,
            per_page=per_page,
            page=page,
            params={'reminder_id': reminder_id},
        )
547752
def get_tags_of_supplier_per_page(self, supplier_id, per_page=1000, page=1):
        
        return self._get_resource_per_page(
            resource=SUPPLIER_TAGS,
            per_page=per_page,
            page=page,
            params={'supplier_id': supplier_id},
        )
1026719
def list(cls, state=None, page=None, per_page=None):
        
        conn = Qubole.agent()
        params = {}
        if page:
            params['page'] = page
        if per_page:
            params['per_page'] = per_page
        if (params.get('page') or params.get('per_page')) and Qubole.version == 'v1.2':
            log.warn("Pagination is not supported with API v1.2. Fetching all clusters.")
        params = None if not params else params
        cluster_list = conn.get(cls.rest_entity_path, params=params)
        if state is None:
            return cluster_list
        elif state is not None:
            result = []
            if Qubole.version == 'v1.2':
                for cluster in cluster_list:
                    if state.lower() == cluster['cluster']['state'].lower():
                        result.append(cluster)
            elif Qubole.version == 'v1.3':
                cluster_list = cluster_list['clusters']
                for cluster in cluster_list:
                    if state.lower() == cluster['state'].lower():
                        result.append(cluster)
            return result
801901
def get_all_tags_of_recurring(self, recurring_id):
        
        return self._iterate_through_pages(
            get_function=self.get_tags_of_recurring_per_page,
            resource=RECURRING_TAGS,
            **{'recurring_id': recurring_id}
        )
1356630
def list(self, page: int = None, pageSize: int = None, search: str = None, workspaceId: str = None) -> dict:
        
        return self.__client.request('get', '/forms', params={
            'page': page,
            'page_size': pageSize,
            'search': search,
            'workspace_id': workspaceId
        })
781935
def get_clients_per_page(self, per_page=1000, page=1, params=None):
        
        return self._get_resource_per_page(resource=CLIENTS, per_page=per_page, page=page, params=params)
185633
def get_comments_of_delivery_note_per_page(self, delivery_note_id, per_page=1000, page=1):
        
        return self._get_resource_per_page(
            resource=DELIVERY_NOTE_COMMENTS,
            per_page=per_page,
            page=page,
            params={'delivery_note_id': delivery_note_id},
        )
311053
def get_tags_of_letter_per_page(self, letter_id, per_page=1000, page=1):
        
        return self._get_resource_per_page(
            resource=LETTER_TAGS,
            per_page=per_page,
            page=page,
            params={'letter_id': letter_id},
        )
837155
def get_user_paginator(
        cls,
        instance,
        page=1,
        item_count=None,
        items_per_page=50,
        user_ids=None,
        GET_params=None,
    ):
        
        if not GET_params:
            GET_params = {}
        GET_params.pop("page", None)
        query = instance.users_dynamic
        if user_ids:
            query = query.filter(cls.models_proxy.UserGroup.user_id.in_(user_ids))
        return SqlalchemyOrmPage(
            query,
            page=page,
            item_count=item_count,
            items_per_page=items_per_page,
            **GET_params
        )
470701
def list_notes(self, page=0, since=None):
        
        from highton.models.note import Note
        params = {'n': int(page) * self.NOTES_OFFSET}
        if since:
            params['since'] = since.strftime(self.COLLECTION_DATETIME)

        return fields.ListField(
            name=self.ENDPOINT,
            init_class=Note
        ).decode(
            self.element_from_string(
                self._get_request(
                    endpoint=self.ENDPOINT + '/' + str(self.id) + '/' + Note.ENDPOINT,
                    params=params
                ).text
            )
        )
648620
def get_delivery_notes_per_page(self, per_page=1000, page=1, params=None):
        
        return self._get_resource_per_page(resource=DELIVERY_NOTES, per_page=per_page, page=page, params=params)
747897
def get_comments_of_letter_per_page(self, letter_id, per_page=1000, page=1):
        
        return self._get_resource_per_page(
            resource=LETTER_COMMENTS,
            per_page=per_page,
            page=page,
            params={'letter_id': letter_id},
        )
324158
def get_revisions(page, page_num=1):
    
    revisions   = page.revisions.order_by('-created_at')
    current     = page.get_latest_revision()

    if current:
        revisions.exclude(id=current.id)

    paginator = Paginator(revisions, 5)

    try:
        revisions = paginator.page(page_num)
    except PageNotAnInteger:
        revisions = paginator.page(1)
    except EmptyPage:
        revisions = paginator.page(paginator.num_pages)

    return revisions
137649
def get_reminder(self, reminder_key):
		'''
		'''
		#required sanity check
		if reminder_key:
			return requests.codes.bad_request, None
		
		uri = '/'.join([
						self.api_uri,
						self.reminders_suffix,
						reminder_key
						])

		return self._req('get', uri)
212448
def fetch_items(self):
        
        offset = self.per_page * (self.page - 1)
        items = self._query.limit(self.per_page).offset(offset).all()
        return items
407573
def list_parameters(self, parameter_type=None, page_size=None):
        
        params = {'details': True}

        if parameter_type is not None:
            params['type'] = parameter_type
        if page_size is not None:
            params['limit'] = page_size

        return pagination.Iterator(
            client=self._client,
            path='/mdb/{}/parameters'.format(self._instance),
            params=params,
            response_class=mdb_pb2.ListParametersResponse,
            items_key='parameter',
            item_mapper=Parameter,
        )
888307
def _get_resource_per_page(self, resource, per_page=1000, page=1, params=None):
        
        assert (isinstance(resource, str))

        common_params = {'per_page': per_page, 'page': page}
        if not params:
            params = common_params
        else:
            params.update(common_params)
        return self._create_get_request(resource=resource, params=params)