feat: introduce request retries to sync client (#9)

* feat: introduce request retries to sync client

* fix: remove debug print

* fix: make retries less amibigious to the original request

* docs: update docstring

Author: justanotherbyte

autumn/aio/client.py

@@ -19,7 +19,13 @@
 
 if TYPE_CHECKING:
     from typing_extensions import Self
-    from .shed import AttachParams, CheckParams, TrackParams, CheckoutParams, QueryParams
+    from .shed import (
+        AttachParams,
+        CheckParams,
+        TrackParams,
+        CheckoutParams,
+        QueryParams,
+    )
 
 __all__ = ("AsyncClient",)
 
@@ -59,8 +65,8 @@ class AsyncClient(Client):
     attach: AttachParams  # type: ignore
     check: CheckParams  # type: ignore
     track: TrackParams  # type: ignore
-    checkout: CheckoutParams # type: ignore
-    query: QueryParams # type: ignore
+    checkout: CheckoutParams  # type: ignore
+    query: QueryParams  # type: ignore
 
     def __init__(
         self,
@@ -75,8 +81,14 @@ def __init__(
         _base_url = base_url or BASE_URL
         _base_url = _base_url.rstrip("/")
 
+        attempts = max_retries + 1
         self.http = AsyncHTTPClient(
-            _base_url, VERSION, token, max_retries=max_retries, session=session)
+            _base_url,
+            VERSION,
+            token,
+            attempts=attempts,
+            session=session,
+        )
         self.customers = Customers(self.http)
         self.features = Features(self.http)
         self.products = Products(self.http)

autumn/aio/http.py

@@ -5,8 +5,8 @@
 from pydantic import BaseModel
 
 from ..error import AutumnError, AutumnHTTPError
-from ..http import HTTPClient
-from ..utils import _build_model, _check_response
+from ..http import HTTPClient, _RetryRequestError
+from ..utils import _build_model, _check_response, ExponentialBackoff
 
 
 try:
@@ -23,39 +23,33 @@
 __all__ = ("AsyncHTTPClient",)
 
 
-class _RetryRequestError(Exception):
-    pass
-
-
 class AsyncHTTPClient:
     def __init__(
         self,
         base_url: str,
         version: str,
         token: str,
-        max_retries: int = 3,
+        attempts: int,
         *,
         session: Optional[aiohttp.ClientSession] = None
     ):
         self.base_url = base_url
         self.version = version
         self.session = session  # type: ignore
         self._headers = HTTPClient._build_headers(token)
-        self.max_retries = max_retries
+        self.attempts = attempts
 
         self._build_url = HTTPClient._build_url
 
-        rand = random.Random()
-        rand.seed()
-        self._rand = rand
-
     async def request(self, method: str, path: str, type_: Type[T], **kwargs) -> T:
         if self.session is None:
             self.session = aiohttp.ClientSession()
 
         url = self._build_url(self.base_url, self.version, path)
 
-        for attempt in range(self.max_retries):
+        max_attempts = self.attempts
+        backoff = ExponentialBackoff()
+        for attempt in range(max_attempts):
             try:
                 async with self.session.request(
                     method, url, headers=self._headers, **kwargs
@@ -66,12 +60,16 @@ async def request(self, method: str, path: str, type_: Type[T], **kwargs) -> T:
                     data = await resp.json()
 
             except (_RetryRequestError, OSError, asyncio.TimeoutError):
-                sleep_time = (2 ** attempt) + self._rand.uniform(0, 1)
-                await asyncio.sleep(sleep_time)
+                if attempt == max_attempts - 1:
+                    raise
+
+                await asyncio.sleep(backoff.bedtime)
+                backoff.tick()
             else:
                 _check_response(resp.status, data)
                 return _build_model(type_, data)
-
+            
+        # We should never get here. This is to appease type checkers.
         msg = f"Max retries reached for {method} {path}"
         raise AutumnHTTPError(msg, "max_retries_reached", 500)
 

autumn/client.py

@@ -65,6 +65,8 @@ async def main():
     ----------
     token: str
         The API key to use for authentication.
+    max_retries: int
+        The maximum number of retries to attempt for failed requests.
     base_url: Optional[str]
         The base URL of the Autumn API. This is useful when you are self-hosting Autumn and need to point to your own instance.
 
@@ -78,13 +80,20 @@ async def main():
         An interface to Autumn's product API.
     """
 
-    def __init__(self, token: str, *, base_url: Optional[str] = None):
+    def __init__(
+        self,
+        token: str,
+        *,
+        base_url: Optional[str] = None,
+        max_retries: int = 5,
+    ):
         from . import BASE_URL, VERSION
 
         _base_url = base_url or BASE_URL
         _base_url = _base_url.rstrip("/")
 
-        self.http = HTTPClient(_base_url, VERSION, token)
+        attempts = max_retries + 1 # account for the original request
+        self.http = HTTPClient(_base_url, VERSION, token, attempts=attempts)
         self.customers = Customers(self.http)
         self.features = Features(self.http)
         self.products = Products(self.http)

autumn/http.py

@@ -1,24 +1,40 @@
 import sys
+import time
+import random
 from typing import Dict, Type, TypeVar
 
 import requests
 from pydantic import BaseModel
 
-from .utils import _build_model, _check_response
-from .error import AutumnError
+from .utils import _build_model, _check_response, ExponentialBackoff
+from .error import AutumnError, AutumnHTTPError
 
 __all__ = ("HTTPClient",)
 
 T = TypeVar("T", bound=BaseModel)
 
 
+class _RetryRequestError(Exception):
+    pass
+
 class HTTPClient:
-    def __init__(self, base_url: str, version: str, token: str):
+    def __init__(
+        self,
+        base_url: str,
+        version: str,
+        token: str,
+        attempts: int
+    ):
         self.base_url = base_url
         self.version = version
         self.session = requests.Session()
 
         self._headers = self._build_headers(token)
+        self.attempts = attempts
+
+        rand = random.Random()
+        rand.seed()
+        self._rand = rand
 
     @staticmethod
     def _build_url(base_url: str, version: str, path: str) -> str:
@@ -56,12 +72,39 @@ def request(
             )
 
         url = self._build_url(self.base_url, self.version, path)
-        resp = self.session.request(method, url, headers=self._headers, **kwargs)
 
-        data = resp.json()
+        max_attempts = self.attempts
+        backoff = ExponentialBackoff()
+        for attempt in range(max_attempts):
+            try:
+                resp = self.session.request(
+                    method,
+                    url,
+                    headers=self._headers,
+                    **kwargs
+                )
+                if 500 <= resp.status_code <= 504:
+                    raise _RetryRequestError()
+
+                data = resp.json()
+            except (
+                _RetryRequestError,
+                OSError,
+                requests.ConnectionError,
+                requests.ConnectTimeout
+            ):
+                if attempt == max_attempts - 1:
+                    raise
+
+                time.sleep(backoff.bedtime)
+                backoff.tick()
+            else:
+                _check_response(resp.status_code, data)
+                return _build_model(type_, data)
 
-        _check_response(resp.status_code, data)
-        return _build_model(type_, data)
+        # We should never get here. This is to appease type checkers.
+        msg = f"Max retries reached for {method} {path}"
+        raise AutumnHTTPError(msg, "max_retries_reached", 500)
 
     def close(self):
         if self.session is not None:

autumn/utils.py

@@ -1,3 +1,4 @@
+import random
 from typing import Dict, Any, Callable, Type, TypeVar, Set
 
 from pydantic import BaseModel, ValidationError
@@ -61,3 +62,22 @@ def _check_response(status_code: int, data: Dict[str, Any]) -> None:
             code,
             status_code,
         )
+
+
+class ExponentialBackoff:
+    def __init__(self):
+        rand = random.Random()
+        rand.seed()
+
+        self._rand = rand
+        self._base = 2
+        self._state = 0
+
+    def tick(self):
+        self._state += 1
+
+    @property
+    def bedtime(self):
+        raw_time = self._base ** self._state
+        jitter = self._rand.uniform(0, 1)
+        return raw_time + jitter