Add strictly typed responses; fix circular dependencies; fix converter; cleanup code [#27]

Author: dnl-blkv

.gitignore

@@ -89,6 +89,6 @@ bunq.conf
 bunq-test.conf
 **/tmp
 config.json
-tests/connectQr.png
+connectQr.png
 .DS_Store
 bunq_sdk.egg-info

bunq/__init__.py

@@ -1,3 +1,54 @@
-from bunq.sdk.json import registry
+from bunq.sdk.json import converter
 
-registry.initialize()
+
+def create_converter_initializer():
+    """
+    :rtype: None
+    """
+
+    import datetime
+
+    from bunq.sdk import client
+    from bunq.sdk import context
+    from bunq.sdk.model import core
+    from bunq.sdk.json import adapters
+    from bunq.sdk.json import converter
+    from bunq.sdk.model.generated import object_
+
+    is_initialized = False
+
+    if not is_initialized:
+        converter.register_adapter(core.Installation,
+                                   adapters.InstallationAdapter)
+        converter.register_adapter(
+            core.SessionServer,
+            adapters.SessionServerAdapter
+        )
+        converter.register_adapter(
+            context.InstallationContext,
+            adapters.InstallationContextAdapter
+        )
+        converter.register_adapter(
+            context.ApiEnvironmentType,
+            adapters.ApiEnvironmentTypeAdapter
+        )
+        converter.register_adapter(float, adapters.FloatAdapter)
+        converter.register_adapter(
+            object_.Geolocation,
+            adapters.GeolocationAdapter
+        )
+        converter.register_adapter(
+            object_.MonetaryAccountReference,
+            adapters.MonetaryAccountReferenceAdapter
+        )
+        converter.register_adapter(object_.ShareDetail,
+                                   adapters.ShareDetailAdapter)
+        converter.register_adapter(datetime.datetime,
+                                   adapters.DateTimeAdapter)
+        converter.register_adapter(client.Pagination,
+                                   adapters.PaginationAdapter)
+        is_initialized = True
+
+    yield is_initialized
+
+converter.set_initializer(create_converter_initializer())

bunq/sdk/client.py

@@ -4,15 +4,14 @@
 
 import requests
 
-from bunq.sdk import context
 from bunq.sdk import exception
 from bunq.sdk import security
 from bunq.sdk.json import converter
 
 
 class ApiClient(object):
     """
-    :type _api_context: context.ApiContext
+    :type _api_context: bunq.sdk.context.ApiContext
     """
 
     # HTTPS type of proxy, the only used at bunq
@@ -372,6 +371,18 @@ def pagination(self):
 
         return self._pagination
 
+    @classmethod
+    def cast_from_bunq_response(cls, bunq_response):
+        """
+        :type bunq_response: BunqResponse
+        """
+
+        return cls(
+            bunq_response.value,
+            bunq_response.headers,
+            bunq_response.pagination
+        )
+
 
 class Pagination(object):
     """

bunq/sdk/context.py

@@ -3,10 +3,10 @@
 import aenum
 from Cryptodome.PublicKey import RSA
 
-from bunq.sdk import model
+from bunq.sdk.model import core
 from bunq.sdk import security
 from bunq.sdk.json import converter
-from bunq.sdk.model import generated
+from bunq.sdk.model.generated import endpoint
 
 
 class ApiEnvironmentType(aenum.AutoNumberEnum):
@@ -95,7 +95,7 @@ def _initialize_installation(self):
         """
 
         private_key_client = security.generate_rsa_private_key()
-        installation = model.Installation.create(
+        installation = core.Installation.create(
             self,
             security.public_key_to_string(private_key_client.publickey())
         ).value
@@ -119,12 +119,12 @@ def _register_device(self, device_description,
         :rtype: None
         """
 
-        generated.DeviceServer.create(
+        endpoint.DeviceServer.create(
             self,
             {
-                generated.DeviceServer.FIELD_DESCRIPTION: device_description,
-                generated.DeviceServer.FIELD_SECRET: self.api_key,
-                generated.DeviceServer.FIELD_PERMITTED_IPS: permitted_ips,
+                endpoint.DeviceServer.FIELD_DESCRIPTION: device_description,
+                endpoint.DeviceServer.FIELD_SECRET: self.api_key,
+                endpoint.DeviceServer.FIELD_PERMITTED_IPS: permitted_ips,
             }
         )
 
@@ -133,7 +133,7 @@ def _initialize_session(self):
         :rtype: None
         """
 
-        session_server = model.SessionServer.create(self).value
+        session_server = core.SessionServer.create(self).value
         token = session_server.token.token
         expiry_time = self._get_expiry_timestamp(session_server)
 
@@ -142,7 +142,7 @@ def _initialize_session(self):
     @classmethod
     def _get_expiry_timestamp(cls, session_server):
         """
-        :type session_server: model.SessionServer
+        :type session_server: core.SessionServer
 
         :rtype: datetime.datetime
         """
@@ -155,7 +155,7 @@ def _get_expiry_timestamp(cls, session_server):
     @classmethod
     def _get_session_timeout_seconds(cls, session_server):
         """
-        :type session_server: model.SessionServer
+        :type session_server: core.SessionServer
 
         :rtype: int
         """
@@ -210,7 +210,7 @@ def _delete_session(self):
         :rtype: None
         """
 
-        generated.Session.delete(self, self._SESSION_ID_DUMMY)
+        endpoint.Session.delete(self, self._SESSION_ID_DUMMY)
 
     @property
     def environment_type(self):
@@ -300,7 +300,7 @@ def restore(cls, path=None):
 
         with open(path, cls._FILE_MODE_READ) as file_:
             return cls.from_json(file_.read())
-        
+
     @classmethod
     def from_json(cls, json_str):
         """

bunq/sdk/json/adapters.py

@@ -3,10 +3,10 @@
 
 from bunq.sdk import client
 from bunq.sdk import context
-from bunq.sdk import model
+from bunq.sdk.model import core
 from bunq.sdk import security
 from bunq.sdk.json import converter
-from bunq.sdk.model import generated
+from bunq.sdk.model.generated import endpoint
 from bunq.sdk.model.generated import object_
 
 
@@ -29,25 +29,25 @@ class InstallationAdapter(converter.JsonAdapter):
     @classmethod
     def deserialize(cls, target_class, array):
         """
-        :type target_class: model.Installation|type
+        :type target_class: core.Installation|type
         :type array: list
 
-        :rtype: model.Installation
+        :rtype: core.Installation
         """
 
         installation = target_class.__new__(target_class)
         server_public_key_wrapped = array[cls._INDEX_SERVER_PUBLIC_KEY]
         installation.__dict__ = {
             cls._ATTRIBUTE_ID: converter.deserialize(
-                model.Id,
+                core.Id,
                 array[cls._INDEX_ID][cls._FIELD_ID]
             ),
             cls._ATTRIBUTE_TOKEN: converter.deserialize(
-                model.SessionToken,
+                core.SessionToken,
                 array[cls._INDEX_TOKEN][cls._FIELD_TOKEN]
             ),
             cls._ATTRIBUTE_SERVER_PUBLIC_KEY: converter.deserialize(
-                model.PublicKeyServer,
+                core.PublicKeyServer,
                 server_public_key_wrapped[cls._FIELD_SERVER_PUBLIC_KEY]
             ),
         }
@@ -57,7 +57,7 @@ def deserialize(cls, target_class, array):
     @classmethod
     def serialize(cls, installation):
         """
-        :type installation: model.Installation
+        :type installation: core.Installation
 
         :rtype: list
         """
@@ -98,20 +98,20 @@ class SessionServerAdapter(converter.JsonAdapter):
     @classmethod
     def deserialize(cls, target_class, array):
         """
-        :type target_class: model.SessionServer|type
+        :type target_class: core.SessionServer|type
         :type array: list
 
-        :rtype: model.SessionServer
+        :rtype: core.SessionServer
         """
 
         session_server = target_class.__new__(target_class)
         session_server.__dict__ = {
             cls._ATTRIBUTE_ID: converter.deserialize(
-                model.Id,
+                core.Id,
                 array[cls._INDEX_ID][cls._FIELD_ID]
             ),
             cls._ATTRIBUTE_TOKEN: converter.deserialize(
-                model.SessionToken,
+                core.SessionToken,
                 array[cls._INDEX_TOKEN][cls._FIELD_TOKEN]
             ),
             cls._ATTRIBUTE_USER_COMPANY: None,
@@ -123,13 +123,13 @@ def deserialize(cls, target_class, array):
         if cls._FIELD_USER_COMPANY in user_dict_wrapped:
             session_server.__dict__[cls._ATTRIBUTE_USER_COMPANY] = \
                 converter.deserialize(
-                    generated.UserCompany,
+                    endpoint.UserCompany,
                     user_dict_wrapped[cls._FIELD_USER_COMPANY]
                 )
         elif cls._FIELD_USER_PERSON in user_dict_wrapped:
             session_server.__dict__[cls._ATTRIBUTE_USER_PERSON] = \
                 converter.deserialize(
-                    generated.UserPerson,
+                    endpoint.UserPerson,
                     user_dict_wrapped[cls._FIELD_USER_PERSON]
                 )
 
@@ -138,7 +138,7 @@ def deserialize(cls, target_class, array):
     @classmethod
     def serialize(cls, session_server):
         """
-        :type session_server: model.SessionServer
+        :type session_server: core.SessionServer
 
         :rtype: list
         """
@@ -545,4 +545,4 @@ def serialize(cls, pagination):
 
         _ = pagination
 
-        raise NotImplementedError()
+        raise NotImplementedError()

bunq/sdk/json/converter.py

@@ -18,6 +18,9 @@ class JsonAdapter(object):
     _custom_serializers = {}
     _custom_deserializers = {}
 
+    # Initializer
+    _initializer = None
+
     # Warning for when a key from raw object is unknown
     _WARNING_KEY_UNKNOWN = '[bunq SDK beta] Key "{}" in "{}" is unknown.'
 
@@ -29,7 +32,8 @@ class JsonAdapter(object):
     _PREFIX_KEY_PROTECTED = '_'
 
     # Constants to fetch param types from the docstrings
-    _TEMPLATE_PATTERN_PARAM_TYPES = ':type (_?{}): ([\w.]+)(?:\[([\w.]+)\])?'
+    _TEMPLATE_PATTERN_PARAM_TYPES = \
+        ':type (_?{}):[\s\n\r]+([\w.]+)(?:\[([\w.]+)\])?'
     _PATTERN_PARAM_NAME_TYPED_ANY = ':type (\w+):'
     _SUBMATCH_INDEX_NAME = 1
     _SUBMATCH_INDEX_TYPE_MAIN = 2
@@ -45,6 +49,14 @@ class JsonAdapter(object):
     # List of byte-array type names
     _TYPE_NAMES_BYTES = {'bytes', 'unicode'}
 
+    @classmethod
+    def set_initializer(cls, initializer):
+        """
+        :type initializer: function
+        """
+
+        cls._initializer = initializer
+
     @classmethod
     def register_custom_adapter(cls, target_class, adapter):
         """
@@ -105,13 +117,22 @@ def deserialize(cls, cls_target, obj_raw):
         :rtype: T
         """
 
+        cls._initialize()
         deserializer = cls._get_deserializer(cls_target)
 
         if deserializer == cls:
             return cls._deserialize_default(cls_target, obj_raw)
         else:
             return deserializer.deserialize(cls_target, obj_raw)
 
+    @classmethod
+    def _initialize(cls):
+        """
+        :rtype: None
+        """
+
+        next(cls._initializer, None)
+
     @classmethod
     def _deserialize_default(cls, cls_target, obj_raw):
         """
@@ -404,6 +425,7 @@ def serialize(cls, obj):
         :rtype: int|str|bool|list|dict
         """
 
+        cls._initialize()
         serializer = cls._get_serializer(type(obj))
 
         if serializer == cls:
@@ -581,6 +603,14 @@ def types(self):
         return self._types
 
 
+def set_initializer(initializer):
+    """
+    :type initializer: callable
+    """
+
+    JsonAdapter.set_initializer(initializer)
+
+
 def register_adapter(target_class, adapter):
     """
     :type target_class: type