feature/python-sdk-refactor Updated Type Annotations for all the Http classes (missed api_client).

Author: angelomelonas

bunq/sdk/http/api_client.py

@@ -1,15 +1,23 @@
+from __future__ import annotations
+
+import typing
 import uuid
+from typing import Dict, List
 from urllib.parse import urlencode
 
 import requests
+from requests import Response
 
 from bunq.sdk.exception.exception_factory import ExceptionFactory
 from bunq.sdk.http.bunq_response_raw import BunqResponseRaw
 from bunq.sdk.json import converter
 from bunq.sdk.security import security
 
+if typing.TYPE_CHECKING:
+    from bunq.sdk.context.api_context import ApiContext
+
 
-class ApiClient(object):
+class ApiClient:
     """
     :type _api_context: ApiContext
     """
@@ -77,16 +85,23 @@ class ApiClient(object):
     # Empty bytes
     BYTES_EMPTY = b''
 
-    def __init__(self, api_context):
+    def __init__(self, api_context: ApiContext) -> None:
+        """
+
+        :param api_context:
+        """
+
         self._api_context = api_context
 
-    def post(self, uri_relative, request_bytes, custom_headers):
+    def post(self,
+             uri_relative: str,
+             request_bytes: bytes,
+             custom_headers: Dict[str, str]) -> BunqResponseRaw:
         """
-        :type uri_relative: str
-        :type request_bytes: bytes
-        :type custom_headers: dict[str, str]
 
-        :return: BunqResponseRaw
+        :param uri_relative:
+        :param request_bytes:
+        :param custom_headers:
         """
 
         return self._request(
@@ -97,15 +112,19 @@ def post(self, uri_relative, request_bytes, custom_headers):
             custom_headers
         )
 
-    def _request(self, method, uri_relative, request_bytes, params, custom_headers):
+    def _request(self,
+                 method: str,
+                 uri_relative: str,
+                 request_bytes: bytes,
+                 params: Dict[str, str],
+                 custom_headers: Dict[str, str]) -> BunqResponseRaw:
         """
-        :type method: str
-        :type uri_relative: str
-        :type request_bytes: bytes
-        :type params: dict[str, str]
-        :type custom_headers: dict[str, str]
 
-        :return: BunqResponseRaw
+        :param method:
+        :param uri_relative:
+        :param request_bytes:
+        :param params:
+        :param custom_headers:
         """
 
         from bunq.sdk.context.bunq_context import BunqContext
@@ -143,27 +162,31 @@ def _request(self, method, uri_relative, request_bytes, params, custom_headers):
         return self._create_bunq_response_raw(response)
 
     @classmethod
-    def _append_params_to_uri(cls, uri, params):
+    def _append_params_to_uri(cls,
+                              uri: str,
+                              params: Dict[str, str]) -> str:
         """
-        :type uri: str
-        :type params: dict[str, str]
 
-        :rtype: str
+        :param uri:
+        :param params:
         """
 
         if params:
             return uri + cls.DELIMITER_URL_QUERY + urlencode(params)
 
         return uri
 
-    def _get_all_headers(self, method, endpoint, request_bytes, custom_headers):
+    def _get_all_headers(self,
+                         method: str,
+                         endpoint: str,
+                         request_bytes: bytes,
+                         custom_headers: Dict[str, str]) -> Dict[str, str]:
         """
-        :type method: str
-        :type endpoint: str
-        :type request_bytes: bytes
-        :type custom_headers: dict[str, str]
 
-        :rtype: dict[str, str]
+        :param method:
+        :param endpoint:
+        :param request_bytes:
+        :param custom_headers:
         """
 
         headers = self._get_default_headers()
@@ -182,11 +205,7 @@ def _get_all_headers(self, method, endpoint, request_bytes, custom_headers):
         return headers
 
     @classmethod
-    def _get_default_headers(cls):
-        """
-        :rtype: dict[str, str]
-        """
-
+    def _get_default_headers(cls) -> Dict[str, str]:
         return {
             cls.HEADER_USER_AGENT: cls.USER_AGENT_BUNQ,
             cls.HEADER_REQUEST_ID: cls._generate_random_request_id(),
@@ -197,27 +216,22 @@ def _get_default_headers(cls):
         }
 
     @staticmethod
-    def _generate_random_request_id():
-        """
-        :rtype: str
-        """
-
+    def _generate_random_request_id() -> str:
         return str(uuid.uuid4())
 
-    def _get_uri_full(self, uri_relative):
+    def _get_uri_full(self, uri_relative: str) -> str:
         """
-        :type uri_relative: str
 
-        :rtype: str
+        :param uri_relative:
         """
 
         return self._api_context.environment_type.uri_base + uri_relative
 
-    def _assert_response_success(self, response):
+    def _assert_response_success(self, response: Response) -> None:
         """
-        :type response: requests.Response
 
-        :rtype: None
+        :type response:
+
         :raise ApiException: When the response is not successful.
         """
 
@@ -229,20 +243,19 @@ def _assert_response_success(self, response):
             )
 
     @classmethod
-    def _create_bunq_response_raw(cls, response):
+    def _create_bunq_response_raw(cls, response: Response) -> BunqResponseRaw:
         """
-        :type response: requests.Response
 
-        :rtype: BunqResponseRaw
+        :param response:
+        :return:
         """
 
         return BunqResponseRaw(response.content, response.headers)
 
-    def _fetch_all_error_message(self, response):
+    def _fetch_all_error_message(self, response: Response) -> List[str]:
         """
-        :type response: requests.Response
 
-        :rtype: list[str]
+        :param response:
         """
 
         response_content_string = response.content.decode()
@@ -254,11 +267,11 @@ def _fetch_all_error_message(self, response):
         except ValueError:
             return [response_content_string]
 
-    def _fetch_error_descriptions(self, error_dict):
+    def _fetch_error_descriptions(self, error_dict: Dict[str, List[Dict[str, str]]]) -> List[str]:
         """
-        :type error_dict: dict[str, list[dict[str, str]]
 
-        :rtype: list[str]
+        :param error_dict:
+        :return:
         """
 
         error_descriptions = []
@@ -269,11 +282,10 @@ def _fetch_error_descriptions(self, error_dict):
 
         return error_descriptions
 
-    def _fetch_response_id(self, response):
+    def _fetch_response_id(self, response: Response) -> str:
         """
-        :type response: requests.Response
 
-        :rtype: str
+        :param response:
         """
 
         headers = response.headers
@@ -286,13 +298,15 @@ def _fetch_response_id(self, response):
 
         return self._ERROR_COULD_NOT_DETERMINE_RESPONSE_ID_HEADER
 
-    def put(self, uri_relative, request_bytes, custom_headers):
+    def put(self,
+            uri_relative: str,
+            request_bytes: bytes,
+            custom_headers: Dict) -> BunqResponseRaw:
         """
-        :type uri_relative: str
-        :type request_bytes: bytes
-        :type custom_headers: dict[str, str]
 
-        :rtype: BunqResponseRaw
+        :param uri_relative:
+        :param request_bytes:
+        :param custom_headers:
         """
 
         return self._request(
@@ -303,13 +317,15 @@ def put(self, uri_relative, request_bytes, custom_headers):
             custom_headers
         )
 
-    def get(self, uri_relative, params, custom_headers):
+    def get(self,
+            uri_relative: str,
+            params: Dict[str, str],
+            custom_headers: Dict[str, str]) -> BunqResponseRaw:
         """
-        :type uri_relative: str
-        :type params: dict[str, str]
-        :type custom_headers: dict[str, str]
 
-        :rtype: BunqResponseRaw
+        :param uri_relative:
+        :param params:
+        :param custom_headers:
         """
 
         return self._request(
@@ -320,12 +336,13 @@ def get(self, uri_relative, params, custom_headers):
             custom_headers
         )
 
-    def delete(self, uri_relative, custom_headers):
+    def delete(self,
+               uri_relative: str,
+               custom_headers: Dict[str, str]) -> BunqResponseRaw:
         """
-        :type uri_relative: str
-        :type custom_headers: dict[str, str]
 
-        :rtype: BunqResponseRaw
+        :param uri_relative:
+        :param custom_headers:
         """
 
         return self._request(