added backoff to requests

e2e_tests/event_test.py

@@ -4,7 +4,8 @@
 from unit import Unit
 
 token = os.environ.get("TOKEN")
-client = Unit("https://api.s.unit.sh", token)
+# client = Unit("https://api.s.unit.sh", token)
+client = Unit("http://localhost:3000", token)
 
 def test_list_and_get_events():
     event_ids = []
@@ -23,3 +24,5 @@ def test_fire_event():
     assert response.data == []
 
 
+test_list_and_get_events()
+

requirements-dev.txt

@@ -1,2 +1,3 @@
 requests==2.26.0
 pytest
+backoff

requirements.txt

@@ -0,0 +1,3 @@
+requests~=2.28.0
+backoff~=2.1.2c
+pytest

setup.py

@@ -12,7 +12,7 @@
     keywords=['unit', 'finance', 'banking',
               'banking-as-a-service', 'API', 'SDK'],
     install_requires=[
-        'requests'
+        'requests', 'backoff'
     ],
     classifiers=[
         'Development Status :: 4 - Beta',

unit/api/base_resource.py

@@ -1,33 +1,86 @@
 import json
-from typing import Optional, Dict
 import requests
+import backoff
+
+from typing import Optional, Dict
 from unit.models.codecs import UnitEncoder
 
+retries = 3
+max_time = 300
+
+
+def fatal_code(e):
+    code = e.response.status_code
+    print(code)
+    return not 500 <= code < 600 or code == 408 or code == 429
+
 
 class BaseResource(object):
-    def __init__(self, api_url, token):
+    def __init__(self, api_url, token, retries_amount=3):
+        global retries
+
         self.api_url = api_url.rstrip("/")
         self.token = token
         self.headers = {
             "content-type": "application/vnd.api+json",
             "authorization": f"Bearer {self.token}",
             "user-agent": "unit-python-sdk"
         }
+        retries = retries_amount
 
+    @backoff.on_exception(backoff.expo,
+                          requests.exceptions.RequestException)
+                          # max_tries=retries)
+                          # max_time=300,
+                          # giveup=fatal_code,
+                          # jitter=backoff.random_jitter)
     def get(self, resource: str, params: Dict = None, headers: Optional[Dict[str, str]] = None):
-        return requests.get(f"{self.api_url}/{resource}", params=params, headers=self.__merge_headers(headers))
+        print("try")
+        # try:
+        ans = requests.get(f"{self.api_url}/{resource}", params=params, headers=self.__merge_headers(headers))
+        # ans.raise_for_status()
+        # except requests.exceptions.RequestException as e:
+        #     print("except")
+        #     print(e)
+        #
+        # print('good to go')
+        return ans
 
+    @backoff.on_exception(backoff.expo,
+                          requests.exceptions.RequestException,
+                          max_tries=retries,
+                          max_time=300,
+                          giveup=fatal_code,
+                          jitter=backoff.random_jitter)
     def post(self, resource: str, data: Optional[Dict] = None, headers: Optional[Dict[str, str]] = None):
         data = json.dumps(data, cls=UnitEncoder) if data is not None else None
         return requests.post(f"{self.api_url}/{resource}", data=data, headers=self.__merge_headers(headers))
 
+    @backoff.on_exception(backoff.expo,
+                          requests.exceptions.RequestException,
+                          max_tries=retries,
+                          max_time=300,
+                          giveup=fatal_code,
+                          jitter=backoff.random_jitter)
     def patch(self, resource: str, data: Optional[Dict] = None, headers: Optional[Dict[str, str]] = None):
         data = json.dumps(data, cls=UnitEncoder) if data is not None else None
         return requests.patch(f"{self.api_url}/{resource}", data=data, headers=self.__merge_headers(headers))
 
+    @backoff.on_exception(backoff.expo,
+                          requests.exceptions.RequestException,
+                          max_tries=retries,
+                          max_time=300,
+                          giveup=fatal_code,
+                          jitter=backoff.random_jitter)
     def delete(self, resource: str, params: Dict = None, headers: Optional[Dict[str, str]] = None):
         return requests.delete(f"{self.api_url}/{resource}", params=params, headers=self.__merge_headers(headers))
 
+    @backoff.on_exception(backoff.expo,
+                          requests.exceptions.RequestException,
+                          max_tries=retries,
+                          max_time=300,
+                          giveup=fatal_code,
+                          jitter=backoff.random_jitter)
     def put(self, resource: str, data: Optional[Dict] = None, headers: Optional[Dict[str, str]] = None):
         return requests.put(f"{self.api_url}/{resource}", data=data, headers=self.__merge_headers(headers))
 
@@ -42,3 +95,4 @@ def __merge_headers(self, headers: Optional[Dict[str, str]] = None):
     def is_20x(self, status: int):
         return status == 200 or status == 201 or status == 204
 
+

unit/api/event_resource.py

@@ -18,7 +18,8 @@ def get(self, event_id: str) -> Union[UnitResponse[EventDTO], UnitError]:
 
     def list(self, params: ListEventParams = None) -> Union[UnitResponse[List[EventDTO]], UnitError]:
         params = params or ListEventParams()
-        response = super().get(self.resource, params.to_dict())
+        response = super().get(self.resource)
+        # response = super().get(self.resource, params.to_dict())
         if super().is_20x(response.status_code):
             data = response.json().get("data")
             return UnitResponse[EventDTO](DtoDecoder.decode(data), None)