kleinkram 0.38.1.dev20241120100707__py3-none-any.whl → 0.38.1.dev20241125112529__py3-none-any.whl

kleinkram/api/client.py

@@ -1,13 +1,13 @@
 from __future__ import annotations
 
 import logging
+from threading import Lock
 from typing import Any
 
 import httpx
 from kleinkram.auth import Config
 from kleinkram.config import Credentials
-from kleinkram.errors import LOGIN_MESSAGE
-from kleinkram.errors import NotAuthenticatedException
+from kleinkram.errors import NotAuthenticated
 
 logger = logging.getLogger(__name__)
 
@@ -21,31 +21,35 @@ class NotLoggedInException(Exception): ...
 
 
 class AuthenticatedClient(httpx.Client):
+    _config: Config
+    _config_lock: Lock
+
     def __init__(self, *args: Any, **kwargs: Any) -> None:
         super().__init__(*args, **kwargs)
-        self.config = Config()
 
-        if self.config.has_cli_key:
-            assert self.config.cli_key, "unreachable"
+        self._config = Config()
+        self._config_lock = Lock()
+
+        if self._config.has_cli_key:
+            assert self._config.cli_key, "unreachable"
             logger.info("using cli key...")
-            self.cookies.set(COOKIE_CLI_KEY, self.config.cli_key)
+            self.cookies.set(COOKIE_CLI_KEY, self._config.cli_key)
 
-        elif self.config.has_refresh_token:
+        elif self._config.has_refresh_token:
             logger.info("using refresh token...")
-            assert self.config.auth_token is not None, "unreachable"
-            self.cookies.set(COOKIE_AUTH_TOKEN, self.config.auth_token)
+            assert self._config.auth_token is not None, "unreachable"
+            self.cookies.set(COOKIE_AUTH_TOKEN, self._config.auth_token)
         else:
             logger.info("not authenticated...")
-            raise NotAuthenticatedException(self.config.endpoint)
+            raise NotAuthenticated
 
     def _refresh_token(self) -> None:
-        if self.config.has_cli_key:
-            raise RuntimeError
-
-        refresh_token = self.config.refresh_token
-        if not refresh_token:
-            raise RuntimeError
+        if self._config.has_cli_key:
+            raise RuntimeError("cannot refresh token when using cli key auth")
 
+        refresh_token = self._config.refresh_token
+        if refresh_token is None:
+            raise RuntimeError("no refresh token found")
         self.cookies.set(COOKIE_REFRESH_TOKEN, refresh_token)
 
         logger.info("refreshing token...")
@@ -53,30 +57,35 @@ class AuthenticatedClient(httpx.Client):
             "/auth/refresh-token",
         )
         response.raise_for_status()
-
         new_access_token = response.cookies[COOKIE_AUTH_TOKEN]
         creds = Credentials(auth_token=new_access_token, refresh_token=refresh_token)
 
         logger.info("saving new tokens...")
-        self.config.save_credentials(creds)
+
+        with self._config_lock:
+            self._config.save_credentials(creds)
+
         self.cookies.set(COOKIE_AUTH_TOKEN, new_access_token)
 
     def request(
         self, method: str, url: str | httpx.URL, *args: Any, **kwargs: Any
     ) -> httpx.Response:
         if isinstance(url, httpx.URL):
-            raise ValueError("url must be a slug")
+            raise NotImplementedError(f"`httpx.URL` is not supported {url!r}")
+        if not url.startswith("/"):
+            url = f"/{url}"
 
         # try to do a request
-        full_url = f"{self.config.endpoint}{url}"
+        full_url = f"{self._config.endpoint}{url}"
         logger.info(f"requesting {method} {full_url}")
         response = super().request(method, full_url, *args, **kwargs)
+
         logger.info(f"got response {response}")
 
         # if the requesting a refresh token fails, we are not logged in
         if (url == "/auth/refresh-token") and response.status_code == 401:
             logger.info("got 401, not logged in...")
-            raise NotLoggedInException(LOGIN_MESSAGE)
+            raise NotAuthenticated
 
         # otherwise we try to refresh the token
         if response.status_code == 401:
@@ -84,12 +93,11 @@ class AuthenticatedClient(httpx.Client):
             try:
                 self._refresh_token()
             except Exception:
-                raise NotLoggedInException(LOGIN_MESSAGE)
+                raise NotAuthenticated
 
             logger.info(f"retrying request {method} {full_url}")
             resp = super().request(method, full_url, *args, **kwargs)
             logger.info(f"got response {resp}")
             return resp
-
         else:
             return response