Merge branch 'release-0.10.0'

Author: dnl-blkv

README.md

@@ -1,5 +1,4 @@
 # bunq Python SDK
-Version 0.9.0 **BETA**
 
 ## Introduction
 Hi developers!
@@ -183,4 +182,4 @@ Please do not forget to set the `_API_KEY` constant in
 ## Running Tests
 
 Information regarding the test cases can be found in the [README.md](./tests/README.md)
-located in [test](/tests)
+located in [test](/tests)

VERSION

@@ -1 +1 @@
-0.9.0
+0.10.0

bunq/sdk/client.py

@@ -19,6 +19,9 @@ class ApiClient(object):
     :type _api_context: context.ApiContext
     """
 
+    # HTTPS type of proxy, the only used at bunq
+    _FIELD_PROXY_HTTPS = 'https'
+
     # Header constants
     HEADER_ATTACHMENT_DESCRIPTION = 'X-Bunq-Attachment-Description'
     HEADER_CONTENT_TYPE = 'Content-Type'
@@ -32,7 +35,7 @@ class ApiClient(object):
     HEADER_AUTHENTICATION = 'X-Bunq-Client-Authentication'
 
     # Default header values
-    _USER_AGENT_BUNQ = 'bunq-sdk-python/0.9'
+    _USER_AGENT_BUNQ = 'bunq-sdk-python/0.10.0'
     _GEOLOCATION_ZERO = '0 0 0 0 NL'
     _LANGUAGE_EN_US = 'en_US'
     _REGION_NL_NL = 'nl_NL'
@@ -66,7 +69,7 @@ def post(self, uri_relative, request_bytes, custom_headers):
         :type request_bytes: bytes
         :type custom_headers: dict[str, str]
 
-        :return: requests.Response
+        :return: BunqResponseRaw
         """
 
         return self._request(
@@ -83,7 +86,7 @@ def _request(self, method, uri_relative, request_bytes, custom_headers):
         :type request_bytes: bytes
         :type custom_headers: dict[str, str]
 
-        :return: requests.Response
+        :return: BunqResponseRaw
         """
 
         self._api_context.ensure_session_active()
@@ -98,7 +101,8 @@ def _request(self, method, uri_relative, request_bytes, custom_headers):
             method,
             self._get_uri_full(uri_relative),
             data=request_bytes,
-            headers=all_headers
+            headers=all_headers,
+            proxies={self._FIELD_PROXY_HTTPS: self._api_context.proxy_url}
         )
 
         self._assert_response_success(response)
@@ -111,7 +115,7 @@ def _request(self, method, uri_relative, request_bytes, custom_headers):
                 response.headers
             )
 
-        return response
+        return self._create_bunq_response_raw(response)
 
     def _get_all_headers(self, method, endpoint, request_bytes, custom_headers):
         """
@@ -184,6 +188,16 @@ def _assert_response_success(self, response):
                 self._fetch_error_messages(response)
             )
 
+    @classmethod
+    def _create_bunq_response_raw(cls, response):
+        """
+        :type response: requests.Response
+
+        :rtype: BunqResponseRaw
+        """
+
+        return BunqResponseRaw(response.content, response.headers)
+
     def _fetch_error_messages(self, response):
         """
         :type response: requests.Response
@@ -221,7 +235,7 @@ def put(self, uri_relative, request_bytes, custom_headers):
         :type request_bytes: bytes
         :type custom_headers: dict[str, str]
 
-        :rtype: requests.Response
+        :rtype: BunqResponseRaw
         """
 
         return self._request(
@@ -236,7 +250,7 @@ def get(self, uri_relative, custom_headers):
         :type uri_relative: str
         :type custom_headers: dict[str, str]
 
-        :rtype: requests.Response
+        :rtype: BunqResponseRaw
         """
 
         return self._request(
@@ -251,7 +265,7 @@ def delete(self, uri_relative, custom_headers):
         :type uri_relative: str
         :type custom_headers: dict[str, str]
 
-        :rtype: requests.Response
+        :rtype: BunqResponseRaw
         """
 
         return self._request(
@@ -260,3 +274,67 @@ def delete(self, uri_relative, custom_headers):
             self._BYTES_EMPTY,
             custom_headers
         )
+
+
+class BunqResponseRaw(object):
+    """
+    :type _body_bytes: bytes
+    :type _headers: dict[str, str]
+    """
+
+    def __init__(self, body_bytes, headers):
+        """
+        :type body_bytes: bytes
+        :type headers: dict[str, str]
+        """
+
+        self._body_bytes = body_bytes
+        self._headers = headers
+
+    @property
+    def body_bytes(self):
+        """
+        :rtype: bytes
+        """
+
+        return self._body_bytes
+
+    @property
+    def headers(self):
+        """
+        :rtype: dict[str, str]
+        """
+
+        return self._headers
+
+
+class BunqResponse(object):
+    """
+    :type _value: T
+    :type _headers: dict[str, str]
+    """
+
+    def __init__(self, value, headers):
+        """
+        :type value: T
+        :type headers: dict[str, str]
+        """
+
+        self._value = value
+        self._headers = headers
+
+    @property
+    def value(self):
+        """
+        :rtype: T
+        """
+
+        return self._value
+
+    @property
+    def headers(self):
+        """
+        :rtype: dict[str, str]
+        """
+
+        return self._headers

bunq/sdk/context.py

@@ -41,6 +41,7 @@ class ApiContext(object):
     :type _api_key: str
     :type _session_context: SessionContext
     :type _installation_context: InstallationContext
+    :type _proxy_url: str|None
     """
 
     # File mode for saving and restoring the context
@@ -57,12 +58,13 @@ class ApiContext(object):
     _PATH_API_CONTEXT_DEFAULT = 'bunq.conf'
 
     def __init__(self, environment_type, api_key, device_description,
-                 permitted_ips=None):
+                 permitted_ips=None, proxy_url=None):
         """
         :type environment_type: ApiEnvironmentType
         :type api_key: str
         :type device_description: str
         :type permitted_ips: list[str]|None
+        :type proxy_url: str|None
         """
 
         if permitted_ips is None:
@@ -72,6 +74,7 @@ def __init__(self, environment_type, api_key, device_description,
         self._api_key = api_key
         self._installation_context = None
         self._session_context = None
+        self._proxy_url = proxy_url
         self._initialize(device_description, permitted_ips)
 
     def _initialize(self, device_description, permitted_ips):
@@ -95,7 +98,7 @@ def _initialize_installation(self):
         installation = model.Installation.create(
             self,
             security.public_key_to_string(private_key_client.publickey())
-        )
+        ).value
         token = installation.token.token
         public_key_server_string = \
             installation.server_public_key.server_public_key
@@ -116,14 +119,21 @@ def _register_device(self, device_description,
         :rtype: None
         """
 
-        model.DeviceServer.create(self, device_description, permitted_ips)
+        generated.DeviceServer.create(
+            self,
+            {
+                generated.DeviceServer.FIELD_DESCRIPTION: device_description,
+                generated.DeviceServer.FIELD_SECRET: self.api_key,
+                generated.DeviceServer.FIELD_PERMITTED_IPS: permitted_ips,
+            }
+        )
 
     def _initialize_session(self):
         """
         :rtype: None
         """
 
-        session_server = model.SessionServer.create(self)
+        session_server = model.SessionServer.create(self).value
         token = session_server.token.token
         expiry_time = self._get_expiry_timestamp(session_server)
 
@@ -247,6 +257,14 @@ def session_context(self):
 
         return self._session_context
 
+    @property
+    def proxy_url(self):
+        """
+        :rtype: str
+        """
+
+        return self._proxy_url
+
     def save(self, path=None):
         """
         :type path: str
@@ -257,8 +275,17 @@ def save(self, path=None):
         if path is None:
             path = self._PATH_API_CONTEXT_DEFAULT
 
-        with open(path, self._FILE_MODE_WRITE) as file:
-            file.write(converter.class_to_json(self))
+        with open(path, self._FILE_MODE_WRITE) as file_:
+            file_.write(self.to_json())
+
+    def to_json(self):
+        """
+        Serializes an ApiContext to JSON string.
+
+        :rtype: str
+        """
+
+        return converter.class_to_json(self)
 
     @classmethod
     def restore(cls, path=None):
@@ -271,8 +298,25 @@ def restore(cls, path=None):
         if path is None:
             path = cls._PATH_API_CONTEXT_DEFAULT
 
-        with open(path, cls._FILE_MODE_READ) as file:
-            return converter.json_to_class(ApiContext, file.read())
+        with open(path, cls._FILE_MODE_READ) as file_:
+            return cls.from_json(file_.read())
+        
+    @classmethod
+    def from_json(cls, json_str):
+        """
+        Creates an ApiContext instance from JSON string.
+
+        :type json_str: str
+
+        :rtype: ApiContext
+        """
+
+        return converter.json_to_class(ApiContext, json_str)
+
+    def __eq__(self, other):
+        return (self.token == other.token and
+                self.api_key == other.api_key and
+                self.environment_type == other.environment_type)
 
 
 class InstallationContext(object):

bunq/sdk/json/converter.py

@@ -29,7 +29,8 @@ class JsonAdapter(object):
     _PREFIX_KEY_PROTECTED = '_'
 
     # Constants to fetch param types from the docstrings
-    _PATTERN_PARAM_TYPES = ':type (_?{}): ([\w.]+)(?:\[([\w.]+)\])?'
+    _TEMPLATE_PATTERN_PARAM_TYPES = ':type (_?{}): ([\w.]+)(?:\[([\w.]+)\])?'
+    _PATTERN_PARAM_NAME_TYPED_ANY = ':type (\w+):'
     _SUBMATCH_INDEX_NAME = 1
     _SUBMATCH_INDEX_TYPE_MAIN = 2
     _SUBMATCH_INDEX_TYPE_SUB = 3
@@ -163,7 +164,9 @@ def _deserialize_dict(cls, cls_target, dict_):
         """
 
         instance = cls_target.__new__(cls_target, cls_target)
-        instance.__dict__ = cls._deserialize_dict_attributes(cls_target, dict_)
+        dict_deserialized = cls._deserialize_dict_attributes(cls_target, dict_)
+        instance.__dict__ = cls._fill_default_values(cls_target,
+                                                     dict_deserialized)
 
         return instance
 
@@ -192,18 +195,6 @@ def _deserialize_dict_attributes(cls, cls_context, dict_):
 
         return dict_deserialized
 
-    @classmethod
-    def _warn_key_unknown(cls, cls_context, key):
-        """
-        :type cls_context: type
-        :type key: str
-
-        :rtype: None
-        """
-
-        context_name = cls_context.__name__
-        warnings.warn(cls._WARNING_KEY_UNKNOWN.format(key, context_name))
-
     @classmethod
     def _deserialize_key(cls, key):
         """
@@ -240,7 +231,7 @@ def _fetch_attribute_specs_from_doc(cls, cls_in, attribute_name):
         :rtype: ValueSpecs
         """
 
-        pattern = cls._PATTERN_PARAM_TYPES.format(attribute_name)
+        pattern = cls._TEMPLATE_PATTERN_PARAM_TYPES.format(attribute_name)
         match = re.search(pattern, cls_in.__doc__)
 
         if match is not None:
@@ -366,6 +357,37 @@ def _deserialize_list(cls, type_item, list_):
 
         return list_deserialized
 
+    @classmethod
+    def _warn_key_unknown(cls, cls_context, key):
+        """
+        :type cls_context: type
+        :type key: str
+
+        :rtype: None
+        """
+
+        context_name = cls_context.__name__
+        warnings.warn(cls._WARNING_KEY_UNKNOWN.format(key, context_name))
+
+    @classmethod
+    def _fill_default_values(cls, cls_context, dict_):
+        """
+        :type cls_context: type
+        :type dict_: dict
+
+        :rtype: dict
+        """
+
+        dict_with_default_values = dict(dict_)
+        params = re.findall(cls._PATTERN_PARAM_NAME_TYPED_ANY,
+                            cls_context.__doc__)
+
+        for param in params:
+            if param not in dict_with_default_values:
+                dict_with_default_values[param] = None
+
+        return dict_with_default_values
+
     @classmethod
     def can_serialize(cls):
         """