Fix Pagination usability [#20]

Author: dnl-blkv

bunq/sdk/client.py

@@ -383,10 +383,10 @@ def pagination(self):
 
 class Pagination(object):
     """
-    :type _older_id: int|None
-    :type _newer_id: int|None
-    :type _future_id: int|None
-    :type _count: int|None
+    :type older_id: int|None
+    :type newer_id: int|None
+    :type future_id: int|None
+    :type count: int|None
     """
 
     # Error constants
@@ -399,10 +399,10 @@ class Pagination(object):
     URL_PARAM_COUNT = 'count'
 
     def __init__(self):
-        self._older_id = None
-        self._newer_id = None
-        self._future_id = None
-        self._count = None
+        self.older_id = None
+        self.newer_id = None
+        self.future_id = None
+        self.count = None
 
     @property
     def url_params_previous_page(self):
@@ -415,18 +415,29 @@ def url_params_previous_page(self):
             raise exception.BunqException(self._ERROR_NO_PREVIOUS_PAGE)
 
         params = {
-            self.URL_PARAM_OLDER_ID: str(self._older_id),
+            self.URL_PARAM_OLDER_ID: str(self.older_id),
         }
         self._add_count_to_params_if_needed(params)
 
         return params
 
+    @property
+    def url_params_count_only(self):
+        """
+        :rtype: dict[str, str]
+        """
+
+        params = {}
+        self._add_count_to_params_if_needed(params)
+
+        return params
+
     def has_previous_item(self):
         """
         :rtype: bool
         """
 
-        return self._older_id is not None
+        return self.older_id is not None
 
     def _add_count_to_params_if_needed(self, params):
         """
@@ -435,8 +446,8 @@ def _add_count_to_params_if_needed(self, params):
         :rtype: None
         """
 
-        if self._count is not None:
-            params[self.URL_PARAM_COUNT] = str(self._count)
+        if self.count is not None:
+            params[self.URL_PARAM_COUNT] = str(self.count)
 
     @property
     def _next_id(self):
@@ -445,16 +456,16 @@ def _next_id(self):
         """
 
         if self.has_next_item_assured():
-            return self._newer_id
+            return self.newer_id
 
-        return self._future_id
+        return self.future_id
 
     def has_next_item_assured(self):
         """
         :rtype: bool
         """
 
-        return self._newer_id is not None
+        return self.newer_id is not None
 
     @property
     def url_params_next_page(self):

bunq/sdk/json/adapters.py

@@ -468,8 +468,10 @@ def deserialize(cls, target_class, pagination_response):
         :rtype: client.Pagination
         """
 
-        pagination = client.Pagination.__new__(client.Pagination)
-        pagination.__dict__ = cls.parse_pagination_dict(pagination_response)
+        pagination = client.Pagination()
+        pagination.__dict__.update(
+            cls.parse_pagination_dict(pagination_response)
+        )
 
         return pagination
 

bunq/sdk/json/registry.py

@@ -1,5 +1,6 @@
 import datetime
 
+from bunq.sdk import client
 from bunq.sdk import context
 from bunq.sdk import model
 from bunq.sdk.json import adapters
@@ -36,3 +37,4 @@ def initialize():
     )
     converter.register_adapter(object_.ShareDetail, adapters.ShareDetailAdapter)
     converter.register_adapter(datetime.datetime, adapters.DateTimeAdapter)
+    converter.register_adapter(client.Pagination, adapters.PaginationAdapter)

bunq/sdk/model/model.py

@@ -1,12 +1,12 @@
 from bunq.sdk import client
 from bunq.sdk import context
-from bunq.sdk.client import BunqResponse
 from bunq.sdk.json import converter
 
 
 class BunqModel(object):
     # Field constants
     _FIELD_RESPONSE = 'Response'
+    _FIELD_PAGINATION = 'Pagination'
     _FIELD_ID = 'Id'
     _FIELD_UUID = 'Uuid'
 
@@ -32,15 +32,15 @@ def _from_json_array_nested(cls, response_raw):
         obj = converter.json_to_class(dict, json)
         value = converter.deserialize(cls, obj[cls._FIELD_RESPONSE])
 
-        return BunqResponse(value, response_raw.headers)
+        return client.BunqResponse(value, response_raw.headers)
 
     @classmethod
     def _from_json(cls, response_raw, wrapper=None):
         """
         :type response_raw: client.BunqResponseRaw
         :type wrapper: str|None
 
-        :rtype: BunqResponse[cls]
+        :rtype: client.BunqResponse[cls]
         """
 
         json = response_raw.body_bytes.decode()
@@ -50,7 +50,7 @@ def _from_json(cls, response_raw, wrapper=None):
             cls._unwrap_response_single(obj, wrapper)
         )
 
-        return BunqResponse(value, response_raw.headers)
+        return client.BunqResponse(value, response_raw.headers)
 
     @classmethod
     def _unwrap_response_single(cls, obj, wrapper=None):
@@ -71,7 +71,7 @@ def _process_for_id(cls, response_raw):
         """
         :type response_raw: client.BunqResponseRaw
 
-        :rtype: BunqResponse[int]
+        :rtype: client.BunqResponse[int]
         """
 
         json = response_raw.body_bytes.decode()
@@ -81,14 +81,14 @@ def _process_for_id(cls, response_raw):
             cls._unwrap_response_single(obj, cls._FIELD_ID)
         )
 
-        return BunqResponse(id_.id_, response_raw.headers)
+        return client.BunqResponse(id_.id_, response_raw.headers)
 
     @classmethod
     def _process_for_uuid(cls, response_raw):
         """
         :type response_raw: client.BunqResponseRaw
 
-        :rtype: BunqResponse[str]
+        :rtype: client.BunqResponse[str]
         """
 
         json = response_raw.body_bytes.decode()
@@ -98,15 +98,15 @@ def _process_for_uuid(cls, response_raw):
             cls._unwrap_response_single(obj, cls._FIELD_UUID)
         )
 
-        return BunqResponse(uuid.uuid, response_raw.headers)
+        return client.BunqResponse(uuid.uuid, response_raw.headers)
 
     @classmethod
     def _from_json_list(cls, response_raw, wrapper=None):
         """
         :type response_raw: client.BunqResponseRaw
         :type wrapper: str|None
 
-        :rtype: BunqResponse[list[cls]]
+        :rtype: client.BunqResponse[list[cls]]
         """
 
         json = response_raw.body_bytes.decode()
@@ -119,7 +119,11 @@ def _from_json_list(cls, response_raw, wrapper=None):
             item_deserialized = converter.deserialize(cls, item_unwrapped)
             array_deserialized.append(item_deserialized)
 
-        return BunqResponse(array_deserialized, response_raw.headers)
+        pagination = converter.deserialize(client.Pagination,
+                                           obj[cls._FIELD_PAGINATION])
+
+        return client.BunqResponse(array_deserialized, response_raw.headers,
+                                   pagination)
 
 
 class Id(BunqModel):
@@ -158,12 +162,42 @@ def uuid(self):
 
 class SessionToken(BunqModel):
     """
+    :type _id_: int
+    :type _created: str
+    :type _updated: str
     :type _token: str
     """
 
     def __init__(self):
+        self._id_ = None
+        self._created = None
+        self._updated = None
         self._token = None
 
+    @property
+    def id_(self):
+        """
+        :rtype: int
+        """
+
+        return self._id_
+
+    @property
+    def created(self):
+        """
+        :rtype: str
+        """
+
+        return self._created
+
+    @property
+    def updated(self):
+        """
+        :rtype: str
+        """
+
+        return self._updated
+
     @property
     def token(self):
         """
@@ -238,7 +272,7 @@ def create(cls, api_context, public_key_string):
         :type api_context: context.ApiContext
         :type public_key_string: str
 
-        :rtype: BunqResponse[Installation]
+        :rtype: client.BunqResponse[Installation]
         """
 
         api_client = client.ApiClient(api_context)
@@ -321,7 +355,7 @@ def create(cls, api_context):
         """
         :type api_context: context.ApiContext
 
-        :rtype: BunqResponse[SessionServer]
+        :rtype: client.BunqResponse[SessionServer]
         """
 
         api_client = client.ApiClient(api_context)

examples/payment_list_example.py

@@ -1,19 +1,44 @@
 #!/usr/bin/env python3
 
+from bunq.sdk import client
 from bunq.sdk import context
 from bunq.sdk.model import generated
 
+# Console messages
+_MESSAGE_LATEST_PAGE_IDS = 'Latest page IDs:'
+_MESSAGE_SECOND_LATEST_PAGE_IDS = 'Second latest page IDs:'
+
+# Size of page of payments to list
+_PAGE_SIZE = 3
+
 _USER_ITEM_ID = 0  # Put your user ID here
 _MONETARY_ACCOUNT_ITEM_ID = 0  # Put your monetary account ID here
 
 
 def run():
     api_context = context.ApiContext.restore()
-    payments = generated.Payment.list(
+    pagination = client.Pagination()
+    pagination.count = _PAGE_SIZE
+    payments_response = generated.Payment.list(
+        api_context,
+        _USER_ITEM_ID,
+        _MONETARY_ACCOUNT_ITEM_ID,
+        pagination.url_params_count_only
+    )
+
+    print(_MESSAGE_LATEST_PAGE_IDS)
+
+    for payment in payments_response.value:
+        print(payment.id_)
+
+    payments_response_previous = generated.Payment.list(
         api_context,
         _USER_ITEM_ID,
         _MONETARY_ACCOUNT_ITEM_ID,
-    ).value
+        payments_response.pagination.url_params_previous_page
+    )
+
+    print(_MESSAGE_SECOND_LATEST_PAGE_IDS)
 
-    for payment in payments:
+    for payment in payments_response_previous.value:
         print(payment.id_)