feature/python-sdk-refactor Updated Type Annotations for all the Http classes.

Author: angelomelonas

bunq/sdk/context/api_context.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import datetime
+import typing
 from typing import List, Optional
 
 from Cryptodome.PublicKey import RSA
@@ -10,10 +11,12 @@
 from bunq.sdk.context.session_context import SessionContext
 from bunq.sdk.exception.bunq_exception import BunqException
 from bunq.sdk.json import converter
-from bunq.sdk.model.core.session_server import SessionServer
 from bunq.sdk.model.generated import endpoint
 from bunq.sdk.security import security
 
+if typing.TYPE_CHECKING:
+    from bunq.sdk.model.core.session_server import SessionServer
+
 
 class ApiContext(object):
     """
@@ -124,7 +127,8 @@ def _initialize_session(self) -> None:
         self._session_context = SessionContext(token, expiry_time, user_id)
 
     @classmethod
-    def _get_expiry_timestamp(cls, session_server: SessionServer) -> datetime.datetime:
+    def _get_expiry_timestamp(cls,
+                              session_server: SessionServer) -> datetime.datetime:
         """
 
         :param session_server:
@@ -254,7 +258,7 @@ def to_json(self) -> str:
         return converter.class_to_json(self)
 
     @classmethod
-    def restore(cls, path: str = None) -> ApiContext:
+    def restore(cls, path: str = None) -> 'ApiContext':
         """
 
         :param path:
@@ -267,7 +271,7 @@ def restore(cls, path: str = None) -> ApiContext:
             return cls.from_json(file_.read())
 
     @classmethod
-    def from_json(cls, json_str: str) -> ApiContext:
+    def from_json(cls, json_str: str) -> 'ApiContext':
         """
         Creates an ApiContext instance from JSON string.
 
@@ -276,7 +280,7 @@ def from_json(cls, json_str: str) -> ApiContext:
 
         return converter.json_to_class(ApiContext, json_str)
 
-    def __eq__(self, other: ApiContext) -> bool:
+    def __eq__(self, other: 'ApiContext') -> bool:
         """
 
         :param other:

bunq/sdk/http/bunq_response.py

@@ -1,47 +1,49 @@
-class BunqResponse(object):
+from __future__ import annotations
+
+# from types import ModuleType
+from typing import Dict, TypeVar
+
+from bunq import Pagination
+
+
+class BunqResponse:
     """
     :type _value: T
     :type _headers: dict[str, str]
     :type _pagination: Pagination|None
     """
 
-    def __init__(self, value, headers, pagination=None):
+    T = TypeVar('T')
+
+    def __init__(self,
+                 value: T,
+                 headers: Dict[str, str],
+                 pagination: Pagination = None) -> None:
         """
-        :type value: T
-        :type headers: dict[str, str]
-        :type pagination Pagination|None
+
+        :param value:
+        :param headers:
+        :param pagination:
         """
 
         self._value = value
         self._headers = headers
         self._pagination = pagination
 
     @property
-    def value(self):
-        """
-        :rtype: T
-        """
-
+    def value(self) -> T:
         return self._value
 
     @property
-    def headers(self):
-        """
-        :rtype: dict[str, str]
-        """
-
+    def headers(self) -> Dict[str, str]:
         return self._headers
 
     @property
-    def pagination(self):
-        """
-        :rtype: Pagination
-        """
-
+    def pagination(self) -> Pagination:
         return self._pagination
 
     @classmethod
-    def cast_from_bunq_response(cls, bunq_response):
+    def cast_from_bunq_response(cls, bunq_response: BunqResponse) -> BunqResponse:
         """
         :type bunq_response: BunqResponse
         """

bunq/sdk/http/bunq_response_raw.py

@@ -1,30 +1,28 @@
-class BunqResponseRaw(object):
+from typing import Dict
+
+
+class BunqResponseRaw:
     """
     :type _body_bytes: bytes
     :type _headers: dict[str, str]
     """
 
-    def __init__(self, body_bytes, headers):
+    def __init__(self,
+                 body_bytes: bytes,
+                 headers: Dict[str, str]) -> None:
         """
-        :type body_bytes: bytes
-        :type headers: dict[str, str]
+
+        :param body_bytes:
+        :param headers:
         """
 
         self._body_bytes = body_bytes
         self._headers = headers
 
     @property
-    def body_bytes(self):
-        """
-        :rtype: bytes
-        """
-
+    def body_bytes(self) -> bytes:
         return self._body_bytes
 
     @property
-    def headers(self):
-        """
-        :rtype: dict[str, str]
-        """
-
+    def headers(self) -> Dict[str, str]:
         return self._headers

bunq/sdk/http/pagination.py

@@ -1,7 +1,9 @@
+from typing import Dict
+
 from bunq.sdk.exception.bunq_exception import BunqException
 
 
-class Pagination(object):
+class Pagination:
     """
     :type older_id: int|None
     :type newer_id: int|None
@@ -10,84 +12,57 @@ class Pagination(object):
     """
 
     # Error constants
-    _ERROR_NO_PREVIOUS_PAGE = 'Could not generate previous page URL params: ' \
-                              'there is no previous page.'
-    _ERROR_NO_NEXT_PAGE = 'Could not generate next page URL params: ' \
-                          'there is no next page.'
+    _ERROR_NO_PREVIOUS_PAGE = 'Could not generate previous page URL params: there is no previous page.'
+    _ERROR_NO_NEXT_PAGE = 'Could not generate next page URL params: there is no next page.'
 
     # URL Param constants
     PARAM_OLDER_ID = 'older_id'
     PARAM_NEWER_ID = 'newer_id'
     PARAM_COUNT = 'count'
 
-    def __init__(self):
+    def __init__(self) -> None:
         self.older_id = None
         self.newer_id = None
         self.future_id = None
         self.count = None
 
     @property
-    def url_params_previous_page(self):
-        """
-        :rtype: dict[str, str]
-        """
-
+    def url_params_previous_page(self) -> Dict[str, str]:
         self.assert_has_previous_page()
 
         params = {self.PARAM_OLDER_ID: str(self.older_id)}
         self._add_count_to_params_if_needed(params)
 
         return params
 
-    def assert_has_previous_page(self):
+    def assert_has_previous_page(self) -> None:
         """
+
         :raise: exception.BunqException
         """
 
         if not self.has_previous_page():
             raise BunqException(self._ERROR_NO_PREVIOUS_PAGE)
 
-    def has_previous_page(self):
-        """
-        :rtype: bool
-        """
-
+    def has_previous_page(self) -> bool:
         return self.older_id is not None
 
     @property
-    def url_params_count_only(self):
-        """
-        :rtype: dict[str, str]
-        """
-
+    def url_params_count_only(self) -> Dict[str, str]:
         params = {}
         self._add_count_to_params_if_needed(params)
 
         return params
 
-    def _add_count_to_params_if_needed(self, params):
-        """
-        :type params: dict[str, str]
-
-        :rtype: None
-        """
-
+    def _add_count_to_params_if_needed(self, params: Dict[str, str]) -> None:
         if self.count is not None:
             params[self.PARAM_COUNT] = str(self.count)
 
-    def has_next_page_assured(self):
-        """
-        :rtype: bool
-        """
-
+    def has_next_page_assured(self) -> bool:
         return self.newer_id is not None
 
     @property
-    def url_params_next_page(self):
-        """
-        :rtype: dict[str, str]
-        """
-
+    def url_params_next_page(self) -> Dict[str, str]:
         self.assert_has_next_page()
 
         params = {self.PARAM_NEWER_ID: str(self._next_id)}
@@ -97,18 +72,15 @@ def url_params_next_page(self):
 
     def assert_has_next_page(self):
         """
+
         :raise: exception.BunqException
         """
 
         if self._next_id is None:
             raise BunqException(self._ERROR_NO_NEXT_PAGE)
 
     @property
-    def _next_id(self):
-        """
-        :rtype: int
-        """
-
+    def _next_id(self) -> int:
         if self.has_next_page_assured():
             return self.newer_id