datacosmos 0.0.13__tar.gz → 0.0.14__tar.gz

{datacosmos-0.0.13 → datacosmos-0.0.14}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: datacosmos
-Version: 0.0.13
+Version: 0.0.14
 Summary: A library for interacting with DataCosmos from Python code
 Author-email: Open Cosmos <support@open-cosmos.com>
 Classifier: Programming Language :: Python :: 3

{datacosmos-0.0.13 → datacosmos-0.0.14}/datacosmos/datacosmos_client.py

@@ -1,5 +1,6 @@
 """Client to interact with the Datacosmos API with authentication and request handling."""
 
+import threading
 from datetime import datetime, timedelta, timezone
 from pathlib import Path
 from typing import Any, Optional
@@ -16,6 +17,8 @@ from datacosmos.exceptions.datacosmos_exception import DatacosmosException
 class DatacosmosClient:
     """Client to interact with the Datacosmos API with authentication and request handling."""
 
+    TOKEN_EXPIRY_SKEW_SECONDS = 60
+
     def __init__(
         self,
         config: Optional[Config | Any] = None,
@@ -24,13 +27,13 @@ class DatacosmosClient:
         """Initialize the DatacosmosClient.
 
         Args:
-            config: SDK configuration (if omitted, Config() loads YAML + env).
-            http_session: Pre-authenticated session (OAuth2Session or requests.Session
-                          with 'Authorization: Bearer ...').
+            config (Optional[Config]): Configuration object (only needed when SDK creates its own session).
+            http_session (Optional[requests.Session]): Pre-authenticated session.
         """
         self.config = self._coerce_config(config)
         self.token: Optional[str] = None
         self.token_expiry: Optional[datetime] = None
+        self._refresh_lock = threading.Lock()
 
         if http_session is not None:
             self._init_with_injected_session(http_session)
@@ -42,7 +45,6 @@ class DatacosmosClient:
     # --------------------------- init helpers ---------------------------
 
     def _coerce_config(self, cfg: Optional[Config | Any]) -> Config:
-        """Normalize various config inputs into a Config instance."""
         if cfg is None:
             return Config()
         if isinstance(cfg, Config):
@@ -50,7 +52,7 @@ class DatacosmosClient:
         if isinstance(cfg, dict):
             return Config(**cfg)
         try:
-            return Config.model_validate(cfg)  # pydantic v2
+            return Config.model_validate(cfg)
         except Exception as e:
             raise DatacosmosException(
                 "Invalid config provided to DatacosmosClient"
@@ -59,7 +61,6 @@ class DatacosmosClient:
     def _init_with_injected_session(
         self, http_session: requests.Session | OAuth2Session
     ) -> None:
-        """Adopt a caller-provided session and extract token/expiry."""
         self._http_client = http_session
         self._owns_session = False
 
@@ -69,19 +70,15 @@ class DatacosmosClient:
             raise DatacosmosException(
                 "Failed to extract access token from injected session"
             )
-
         self.token_expiry = self._compute_expiry(
-            token_data.get("expires_at"),
-            token_data.get("expires_in"),
+            token_data.get("expires_at"), token_data.get("expires_in")
         )
 
     def _extract_token_data(
         self, http_session: requests.Session | OAuth2Session
     ) -> dict:
-        """Return {'access_token', 'expires_at'?, 'expires_in'?} from the session."""
         if isinstance(http_session, OAuth2Session):
             return getattr(http_session, "token", {}) or {}
-
         if isinstance(http_session, requests.Session):
             auth_header = http_session.headers.get("Authorization", "")
             if not auth_header.startswith("Bearer "):
@@ -89,7 +86,6 @@ class DatacosmosClient:
                     "Injected requests.Session must include a 'Bearer' token in its headers"
                 )
             return {"access_token": auth_header.split(" ", 1)[1]}
-
         raise DatacosmosException(f"Unsupported session type: {type(http_session)}")
 
     def _compute_expiry(
@@ -97,7 +93,6 @@ class DatacosmosClient:
         expires_at: Optional[datetime | int | float],
         expires_in: Optional[int | float],
     ) -> Optional[datetime]:
-        """Normalize expiry inputs to an absolute UTC datetime (or None)."""
         if isinstance(expires_at, datetime):
             return expires_at
         if isinstance(expires_at, (int, float)):
@@ -106,51 +101,33 @@ class DatacosmosClient:
             try:
                 return datetime.now(timezone.utc) + timedelta(seconds=int(expires_in))
             except (TypeError, ValueError):
+                # Unknown/invalid expiry -> mark as unknown so refresh logic kicks in
                 return None
         return None
 
     # --------------------------- auth/session ---------------------------
 
     def _authenticate_and_initialize_client(self) -> requests.Session:
-        """Authenticate and initialize the HTTP client with a valid token."""
         auth = self.config.authentication
         auth_type = getattr(auth, "type", "m2m")
-
         if auth_type == "m2m":
             return self.__build_m2m_session()
-
         if auth_type == "local":
             return self.__build_local_session()
-
         raise DatacosmosException(f"Unsupported authentication type: {auth_type}")
 
-    def _refresh_token_if_needed(self):
-        """Refresh the token if it has expired (only if SDK created it)."""
-        if not getattr(self, "_owns_session", False):
-            return
-        now = datetime.now(timezone.utc)
-        # Treat missing token or missing expiry as 'needs refresh'
-        if (
-            (not self.token)
-            or (self.token_expiry is None)
-            or (self.token_expiry <= now)
-        ):
-            self._http_client = self._authenticate_and_initialize_client()
-
     def __build_m2m_session(self) -> requests.Session:
         """Client Credentials (M2M) flow using requests-oauthlib."""
         auth = self.config.authentication
         try:
             client = BackendApplicationClient(client_id=auth.client_id)
             oauth_session = OAuth2Session(client=client)
-
             token_response = oauth_session.fetch_token(
                 token_url=auth.token_url,
                 client_id=auth.client_id,
                 client_secret=auth.client_secret,
                 audience=auth.audience,
             )
-
             self.token = token_response["access_token"]
             expires_at = token_response.get("expires_at")
             if isinstance(expires_at, (int, float)):
@@ -159,11 +136,9 @@ class DatacosmosClient:
                 self.token_expiry = datetime.now(timezone.utc) + timedelta(
                     seconds=int(token_response.get("expires_in", 3600))
                 )
-
             http_client = requests.Session()
             http_client.headers.update({"Authorization": f"Bearer {self.token}"})
             return http_client
-
         except (HTTPError, ConnectionError, Timeout) as e:
             raise DatacosmosException(f"Authentication failed: {e}") from e
         except RequestException as e:
@@ -195,38 +170,89 @@ class DatacosmosClient:
 
         http_client = requests.Session()
         http_client.headers.update({"Authorization": f"Bearer {self.token}"})
-
-        # keep for potential reuse in refresh path (optional)
         self._local_token_fetcher = fetcher
         return http_client
 
+    # --------------------------- refresh logic ---------------------------
+
+    def _needs_refresh(self) -> bool:
+        if not getattr(self, "_owns_session", False):
+            return False
+        if not self.token or self.token_expiry is None:
+            return True
+        return (self.token_expiry - datetime.now(timezone.utc)) <= timedelta(
+            seconds=self.TOKEN_EXPIRY_SKEW_SECONDS
+        )
+
+    def _refresh_now(self) -> None:
+        """Force refresh.
+
+        In case of local auth it uses LocalTokenFetcher (non-interactive refresh/cached token).
+        In case of m2m auth it re-runs client-credentials flow.
+        """
+        with self._refresh_lock:
+            if not self._needs_refresh():
+                return
+
+            auth_type = getattr(self.config.authentication, "type", "m2m")
+            if auth_type == "local" and hasattr(self, "_local_token_fetcher"):
+                tok = self._local_token_fetcher.get_token()
+                self.token = tok.access_token
+                self.token_expiry = datetime.fromtimestamp(
+                    tok.expires_at, tz=timezone.utc
+                )
+                self._http_client.headers.update(
+                    {"Authorization": f"Bearer {self.token}"}
+                )
+                return
+
+            # default/m2m:
+            self._http_client = self.__build_m2m_session()
+
+    def _refresh_token_if_needed(self) -> None:
+        if self._needs_refresh():
+            self._refresh_now()
+
     # --------------------------- request API ---------------------------
 
     def request(
         self, method: str, url: str, *args: Any, **kwargs: Any
     ) -> requests.Response:
-        """Send an HTTP request using the authenticated session."""
+        """Send an HTTP request using the authenticated session (with auto-refresh)."""
         self._refresh_token_if_needed()
         try:
             response = self._http_client.request(method, url, *args, **kwargs)
             response.raise_for_status()
             return response
         except HTTPError as e:
+            status = getattr(e.response, "status_code", None)
+            if status in (401, 403) and getattr(self, "_owns_session", False):
+                # token likely expired/invalid — refresh once and retry
+                self._refresh_now()
+                retry_response = self._http_client.request(method, url, *args, **kwargs)
+                try:
+                    retry_response.raise_for_status()
+                    return retry_response
+                except HTTPError as e:
+                    raise DatacosmosException(
+                        f"HTTP error during {method.upper()} request to {url} after refresh",
+                        response=e.response,
+                    ) from e
             raise DatacosmosException(
                 f"HTTP error during {method.upper()} request to {url}",
-                response=e.response,
+                response=getattr(e, "response", None),
             ) from e
         except ConnectionError as e:
             raise DatacosmosException(
-                f"Connection error during {method.upper()} request to {url}: {str(e)}"
+                f"Connection error during {method.upper()} request to {url}: {e}"
             ) from e
         except Timeout as e:
             raise DatacosmosException(
-                f"Request timeout during {method.upper()} request to {url}: {str(e)}"
+                f"Request timeout during {method.upper()} request to {url}: {e}"
             ) from e
         except RequestException as e:
             raise DatacosmosException(
-                f"Unexpected request failure during {method.upper()} request to {url}: {str(e)}"
+                f"Unexpected request failure during {method.upper()} request to {url}: {e}"
             ) from e
 
     def get(self, url: str, *args: Any, **kwargs: Any) -> requests.Response:

{datacosmos-0.0.13 → datacosmos-0.0.14}/datacosmos.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: datacosmos
-Version: 0.0.13
+Version: 0.0.14
 Summary: A library for interacting with DataCosmos from Python code
 Author-email: Open Cosmos <support@open-cosmos.com>
 Classifier: Programming Language :: Python :: 3

{datacosmos-0.0.13 → datacosmos-0.0.14}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "datacosmos"
-version = "0.0.13"
+version = "0.0.14"
 authors = [
     { name="Open Cosmos", email="support@open-cosmos.com" },
 ]