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

Author: angelomelonas

bunq/sdk/model/core/anchor_object_interface.py

@@ -1,3 +1,3 @@
 class AnchorObjectInterface:
-    def is_all_field_none(self):
+    def is_all_field_none(self) -> None:
         pass

bunq/sdk/model/core/bunq_model.py

@@ -1,5 +1,11 @@
+from __future__ import annotations
+
+from typing import Dict, List
+
 from bunq import Pagination
+from bunq.sdk.context.api_context import ApiContext
 from bunq.sdk.http.bunq_response import BunqResponse
+from bunq.sdk.http.bunq_response_raw import BunqResponseRaw
 from bunq.sdk.json import converter
 
 
@@ -17,39 +23,24 @@ class BunqModel:
     __STRING_FORMAT_FIELD_FOR_REQUEST_ONE_UNDERSCORE = '_field_for_request'
     __STRING_FORMAT_FIELD_FOR_REQUEST_TWO_UNDERSCORE = '__field_for_request'
 
-    def is_all_field_none(self):
+    def is_all_field_none(self) -> None:
         raise NotImplementedError
 
-    def to_json(self):
-        """
-        :rtype: str
-        """
-
+    def to_json(self) -> str:
         return converter.class_to_json(self)
 
     @classmethod
-    def _from_json_array_nested(cls, response_raw):
-        """
-        :type response_raw: BunqResponseRaw
-
-        :rtype: BunqResponse[cls]
-        """
-
+    def _from_json_array_nested(cls, response_raw: BunqResponseRaw) -> BunqResponse[BunqModel]:
         json = response_raw.body_bytes.decode()
         obj = converter.json_to_class(dict, json)
         value = converter.deserialize(cls, obj[cls._FIELD_RESPONSE])
 
         return BunqResponse(value, response_raw.headers)
 
     @classmethod
-    def _from_json(cls, response_raw, wrapper=None):
-        """
-        :type response_raw: BunqResponseRaw
-        :type wrapper: str|None
-
-        :rtype: BunqResponse[cls]
-        """
-
+    def _from_json(cls,
+                   response_raw: BunqResponseRaw,
+                   wrapper: str = None) -> BunqResponse[BunqModel]:
         json = response_raw.body_bytes.decode()
         obj = converter.json_to_class(dict, json)
         value = converter.deserialize(
@@ -60,27 +51,16 @@ def _from_json(cls, response_raw, wrapper=None):
         return BunqResponse(value, response_raw.headers)
 
     @classmethod
-    def _unwrap_response_single(cls, obj, wrapper=None):
-        """
-        :type obj: dict
-        :type wrapper: str|None
-
-        :rtype: dict
-        """
-
+    def _unwrap_response_single(cls,
+                                obj: Dict,
+                                wrapper: str = None) -> Dict:
         if wrapper is not None:
             return obj[cls._FIELD_RESPONSE][cls._INDEX_FIRST][wrapper]
 
         return obj[cls._FIELD_RESPONSE][cls._INDEX_FIRST]
 
     @classmethod
-    def _process_for_id(cls, response_raw):
-        """
-        :type response_raw: BunqResponseRaw
-
-        :rtype: BunqResponse[int]
-        """
-
+    def _process_for_id(cls, response_raw: BunqResponseRaw) -> BunqResponse[int]:
         from bunq.sdk.model.core.id import Id
 
         json = response_raw.body_bytes.decode()
@@ -93,13 +73,7 @@ def _process_for_id(cls, response_raw):
         return BunqResponse(id_.id_, response_raw.headers)
 
     @classmethod
-    def _process_for_uuid(cls, response_raw):
-        """
-        :type response_raw: BunqResponseRaw
-
-        :rtype: BunqResponse[str]
-        """
-
+    def _process_for_uuid(cls, response_raw: BunqResponseRaw) -> BunqResponse[str]:
         from bunq.sdk.model.core.uuid import Uuid
 
         json = response_raw.body_bytes.decode()
@@ -112,14 +86,9 @@ def _process_for_uuid(cls, response_raw):
         return BunqResponse(uuid.uuid, response_raw.headers)
 
     @classmethod
-    def _from_json_list(cls, response_raw, wrapper=None):
-        """
-        :type response_raw: BunqResponseRaw
-        :type wrapper: str|None
-
-        :rtype: BunqResponse[list[cls]]
-        """
-
+    def _from_json_list(cls,
+                        response_raw: BunqResponseRaw,
+                        wrapper: str = None) -> BunqResponse[List[BunqModel]]:
         json = response_raw.body_bytes.decode()
         obj = converter.json_to_class(dict, json)
         array = obj[cls._FIELD_RESPONSE]
@@ -135,33 +104,19 @@ def _from_json_list(cls, response_raw, wrapper=None):
         return BunqResponse(array_deserialized, response_raw.headers, pagination)
 
     @classmethod
-    def _get_api_context(cls):
-        """
-        :rtype: ApiContext
-        """
-
+    def _get_api_context(cls) -> ApiContext:
         from bunq.sdk.context.bunq_context import BunqContext
 
         return BunqContext.api_context()
 
     @classmethod
-    def _determine_user_id(cls):
-        """
-        :rtype: int
-        """
-
+    def _determine_user_id(cls) -> int:
         from bunq.sdk.context.bunq_context import BunqContext
 
         return BunqContext.user_context().user_id
 
     @classmethod
-    def _determine_monetary_account_id(cls, monetary_account_id=None):
-        """
-        :type monetary_account_id: int
-
-        :rtype: int
-        """
-
+    def _determine_monetary_account_id(cls, monetary_account_id: int = None) -> int:
         from bunq.sdk.context.bunq_context import BunqContext
 
         if monetary_account_id is None:
@@ -170,7 +125,7 @@ def _determine_monetary_account_id(cls, monetary_account_id=None):
         return monetary_account_id
 
     @classmethod
-    def _remove_field_for_request(cls, json_str: str):
+    def _remove_field_for_request(cls, json_str: str) -> str:
         return json_str.replace(
             cls.__STRING_FORMAT_FIELD_FOR_REQUEST_TWO_UNDERSCORE,
             cls.__STRING_FORMAT_EMPTY

bunq/sdk/model/core/device_server_internal.py

@@ -1,3 +1,6 @@
+from typing import List, Dict
+
+from bunq.sdk.context.api_context import ApiContext
 from bunq.sdk.exception.bunq_exception import BunqException
 from bunq.sdk.http.api_client import ApiClient
 from bunq.sdk.json import converter
@@ -6,12 +9,15 @@
 
 
 class DeviceServerInternal(DeviceServer):
-    _ERROR_API_CONTEXT_IS_NULL = 'ApiContext should not be None,' \
-                                 ' use the generated class instead.'
+    _ERROR_API_CONTEXT_IS_NULL = 'ApiContext should not be None, use the generated class instead.'
 
     @classmethod
-    def create(cls, description, secret, permitted_ips=None,
-               custom_headers=None, api_context=None):
+    def create(cls,
+               api_context: ApiContext,
+               description: str,
+               secret: str,
+               permitted_ips: List[str] = None,
+               custom_headers: Dict[str, str] = None) -> BunqResponseInt: # TODO: The generated bass class needs to be updated?
         """
         Create a new DeviceServer providing the installation token in the header
         and signing the request with the private part of the key you used to
@@ -32,7 +38,7 @@ def create(cls, description, secret, permitted_ips=None,
         be able to do calls from. These will be linked to the API key.
         :type permitted_ips: list[str]
         :type custom_headers: dict[str, str]|None
-        :type api_context: context.ApiContext
+        :type api_context: ApiContext
 
         :rtype: BunqResponseInt
         """

bunq/sdk/model/core/id.py

@@ -6,18 +6,14 @@ class Id(BunqModel):
     :type _id_: int
     """
 
-    def __init__(self):
+    def __init__(self) -> None:
         self._id_ = None
 
     @property
-    def id_(self):
-        """
-        :rtype: int
-        """
-
+    def id_(self) -> int:
         return self._id_
 
-    def is_all_field_none(self):
+    def is_all_field_none(self) -> bool:
         if self.id_ is not None:
             return False
 

bunq/sdk/model/core/installation.py

@@ -1,6 +1,11 @@
+from bunq.sdk.context.api_context import ApiContext
 from bunq.sdk.http.api_client import ApiClient
+from bunq.sdk.http.bunq_response import BunqResponse
 from bunq.sdk.json import converter
 from bunq.sdk.model.core.bunq_model import BunqModel
+from bunq.sdk.model.core.id import Id
+from bunq.sdk.model.core.public_key_server import PublicKeyServer
+from bunq.sdk.model.core.session_token import SessionToken
 
 
 class Installation(BunqModel):
@@ -16,37 +21,27 @@ class Installation(BunqModel):
     # Field constants.
     FIELD_CLIENT_PUBLIC_KEY = "client_public_key"
 
-    def __init__(self):
+    def __init__(self) -> None:
         self._id_ = None
         self._token = None
         self._server_public_key = None
 
     @property
-    def id_(self):
-        """
-        :rtype: Id
-        """
-
+    def id_(self) -> Id:
         return self._id_
 
     @property
-    def token(self):
-        """
-        :rtype: SessionToken
-        """
-
+    def token(self) -> SessionToken:
         return self._token
 
     @property
-    def server_public_key(self):
-        """
-        :rtype: PublicKeyServer
-        """
-
+    def server_public_key(self) -> PublicKeyServer:
         return self._server_public_key
 
     @classmethod
-    def create(cls, api_context, public_key_string):
+    def create(cls,
+               api_context: ApiContext,
+               public_key_string: str) -> BunqResponse:  # TODO: Check
         """
         :type api_context: ApiContext
         :type public_key_string: str
@@ -55,28 +50,20 @@ def create(cls, api_context, public_key_string):
         """
 
         api_client = ApiClient(api_context)
-        body_bytes = cls.generate_request_body_bytes(
-            public_key_string
-        )
+        body_bytes = cls.generate_request_body_bytes(public_key_string)
         response_raw = api_client.post(cls._ENDPOINT_URL_POST, body_bytes, {})
 
         return cls._from_json_array_nested(response_raw)
 
     @classmethod
-    def generate_request_body_bytes(cls, public_key_string):
-        """
-        :type public_key_string: str
-
-        :rtype: bytes
-        """
-
+    def generate_request_body_bytes(cls, public_key_string: str) -> bytes:
         return converter.class_to_json(
             {
                 cls.FIELD_CLIENT_PUBLIC_KEY: public_key_string,
             }
         ).encode()
 
-    def is_all_field_none(self):
+    def is_all_field_none(self) -> bool:
         if self.id_ is not None:
             return False
 

bunq/sdk/model/core/public_key_server.py

@@ -6,18 +6,14 @@ class PublicKeyServer(BunqModel):
     :type _server_public_key: str
     """
 
-    def __init__(self):
+    def __init__(self) -> None:
         self._server_public_key = None
 
     @property
-    def server_public_key(self):
-        """
-        :rtype: str
-        """
-
+    def server_public_key(self) -> str:
         return self._server_public_key
 
-    def is_all_field_none(self):
+    def is_all_field_none(self) -> bool:
         if self.server_public_key is not None:
             return False