datacosmos 0.0.15__tar.gz → 0.0.17__tar.gz

{datacosmos-0.0.15 → datacosmos-0.0.17}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: datacosmos
-Version: 0.0.15
+Version: 0.0.17
 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.17/datacosmos/auth/base_authenticator.py

@@ -0,0 +1,62 @@
+"""Base authenticator class for DatacosmosClient."""
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from datetime import datetime
+from typing import TYPE_CHECKING, Optional
+
+if TYPE_CHECKING:
+    import requests
+
+    from datacosmos.config.config import Config
+
+
+class AuthResult:
+    """Authentication result object."""
+
+    def __init__(
+        self,
+        http_client: requests.Session,
+        token: Optional[str] = None,
+        token_expiry: Optional[datetime] = None,
+    ):
+        """Initializes an AuthResult object.
+
+        Args:
+            http_client (requests.Session): The HTTP client/session to use for requests.
+            token (Optional[str], optional): The authentication token, if available.
+            token_expiry (Optional[datetime], optional): The expiry time of the token, if available.
+        """
+        self.http_client = http_client
+        self.token = token
+        self.token_expiry = token_expiry
+
+
+class BaseAuthenticator(ABC):
+    """Abstract base class for all authenticators."""
+
+    def __init__(self, config: Config):
+        """Initializes the BaseAuthenticator with the given configuration.
+
+        Args:
+            config (Config): The configuration object containing authentication settings.
+        """
+        self.config = config
+
+    @abstractmethod
+    def authenticate_and_build_session(self) -> AuthResult:
+        """Authenticates and builds a requests.Session object.
+
+        Returns:
+            AuthResult: An object containing the authenticated session, token, and token expiry.
+        """
+        ...
+
+    @abstractmethod
+    def refresh_token(self) -> AuthResult:
+        """Refreshes the authentication token.
+
+        Returns:
+            AuthResult: An object with the new token and expiry.
+        """
+        ...

datacosmos-0.0.17/datacosmos/auth/local_authenticator.py

@@ -0,0 +1,72 @@
+"""Local (interactive/cached) authenticator for DatacosmosClient."""
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any
+
+import requests
+
+from datacosmos.auth.base_authenticator import AuthResult, BaseAuthenticator
+from datacosmos.auth.local_token_fetcher import LocalTokenFetcher
+from datacosmos.exceptions.datacosmos_exception import DatacosmosException
+
+
+class LocalAuthenticator(BaseAuthenticator):
+    """Handles authentication via the interactive local login flow."""
+
+    def __init__(self, config: Any):
+        """Initializes a LocalAuthenticator instance.
+
+        Args:
+            config (Any): Configuration object containing authentication settings.
+        """
+        super().__init__(config)
+        self._local_token_fetcher = self._init_fetcher()
+
+    def _init_fetcher(self) -> LocalTokenFetcher:
+        """Initializes the LocalTokenFetcher."""
+        auth = self.config.authentication
+        try:
+            return LocalTokenFetcher(
+                client_id=auth.client_id,
+                authorization_endpoint=auth.authorization_endpoint,
+                token_endpoint=auth.token_endpoint,
+                redirect_port=int(auth.redirect_port),
+                audience=auth.audience,
+                scopes=auth.scopes,
+                token_file=Path(auth.cache_file).expanduser(),
+            )
+        except Exception as e:
+            raise DatacosmosException(
+                f"Failed to initialize LocalTokenFetcher: {e}"
+            ) from e
+
+    def authenticate_and_build_session(self) -> AuthResult:
+        """Builds an authenticated session using the local token fetcher."""
+        try:
+            tok = self._local_token_fetcher.get_token()
+            token = tok.access_token
+            token_expiry = datetime.fromtimestamp(tok.expires_at, tz=timezone.utc)
+            http_client = requests.Session()
+            http_client.headers.update({"Authorization": f"Bearer {token}"})
+            return AuthResult(
+                http_client=http_client, token=token, token_expiry=token_expiry
+            )
+        except Exception as e:
+            raise DatacosmosException(f"Local authentication failed: {e}") from e
+
+    def refresh_token(self) -> AuthResult:
+        """Refreshes the local token non-interactively."""
+        try:
+            tok = self._local_token_fetcher.get_token()
+            token = tok.access_token
+            token_expiry = datetime.fromtimestamp(tok.expires_at, tz=timezone.utc)
+
+            # Create a new session with the new token
+            http_client = requests.Session()
+            http_client.headers.update({"Authorization": f"Bearer {token}"})
+
+            return AuthResult(
+                http_client=http_client, token=token, token_expiry=token_expiry
+            )
+        except Exception as e:
+            raise DatacosmosException(f"Local token refresh failed: {e}") from e

datacosmos-0.0.17/datacosmos/auth/m2m_authenticator.py

@@ -0,0 +1,63 @@
+"""M2M (Machine-to-Machine) authenticator for DatacosmosClient."""
+from datetime import datetime, timedelta, timezone
+
+import requests
+from oauthlib.oauth2 import BackendApplicationClient
+from requests.exceptions import ConnectionError, HTTPError, RequestException, Timeout
+from requests_oauthlib import OAuth2Session
+from tenacity import (
+    retry,
+    retry_if_exception_type,
+    stop_after_attempt,
+    wait_exponential,
+)
+
+from datacosmos.auth.base_authenticator import AuthResult, BaseAuthenticator
+from datacosmos.exceptions.datacosmos_exception import DatacosmosException
+
+
+class M2MAuthenticator(BaseAuthenticator):
+    """Handles authentication using the Client Credentials (M2M) flow."""
+
+    @retry(
+        stop=stop_after_attempt(3),
+        wait=wait_exponential(multiplier=1, min=2, max=10),
+        retry=retry_if_exception_type((ConnectionError, Timeout)),
+    )
+    def authenticate_and_build_session(self) -> AuthResult:
+        """Builds an authenticated session using the M2M flow."""
+        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,
+            )
+            token = token_response["access_token"]
+            expires_at = token_response.get("expires_at")
+            if isinstance(expires_at, (int, float)):
+                token_expiry = datetime.fromtimestamp(expires_at, tz=timezone.utc)
+            else:
+                expires_in = int(token_response.get("expires_in", 3600))
+                token_expiry = datetime.now(timezone.utc) + timedelta(
+                    seconds=expires_in
+                )
+
+            http_client = requests.Session()
+            http_client.headers.update({"Authorization": f"Bearer {token}"})
+            return AuthResult(
+                http_client=http_client, token=token, token_expiry=token_expiry
+            )
+        except (HTTPError, ConnectionError, Timeout) as e:
+            raise DatacosmosException(f"M2M authentication failed: {e}") from e
+        except RequestException as e:
+            raise DatacosmosException(
+                f"Unexpected request failure during M2M authentication: {e}"
+            ) from e
+
+    def refresh_token(self) -> AuthResult:
+        """Refreshes the M2M token by re-running the authentication flow."""
+        return self.authenticate_and_build_session()

{datacosmos-0.0.15 → datacosmos-0.0.17}/datacosmos/datacosmos_client.py

@@ -1,12 +1,12 @@
 """Client to interact with the Datacosmos API with authentication and request handling."""
+from __future__ import annotations
 
+import logging
 import threading
 from datetime import datetime, timedelta, timezone
-from pathlib import Path
-from typing import Any, Optional
+from typing import Any, Callable, List, Optional
 
 import requests
-from oauthlib.oauth2 import BackendApplicationClient
 from requests.exceptions import ConnectionError, HTTPError, RequestException, Timeout
 from requests_oauthlib import OAuth2Session
 from tenacity import (
@@ -16,9 +16,17 @@ from tenacity import (
     wait_exponential,
 )
 
+from datacosmos.auth.base_authenticator import BaseAuthenticator
+from datacosmos.auth.local_authenticator import LocalAuthenticator
+from datacosmos.auth.m2m_authenticator import M2MAuthenticator
 from datacosmos.config.config import Config
 from datacosmos.exceptions.datacosmos_exception import DatacosmosException
 
+_log = logging.getLogger(__name__)
+
+RequestHook = Callable[[str, str, Any, Any], None]
+ResponseHook = Callable[[requests.Response], None]
+
 
 class DatacosmosClient:
     """Client to interact with the Datacosmos API with authentication and request handling."""
@@ -29,17 +37,24 @@ class DatacosmosClient:
         self,
         config: Optional[Config | Any] = None,
         http_session: Optional[requests.Session | OAuth2Session] = None,
+        request_hooks: Optional[List[RequestHook]] = None,
+        response_hooks: Optional[List[ResponseHook]] = None,
     ):
         """Initialize the DatacosmosClient.
 
         Args:
             config (Optional[Config]): Configuration object (only needed when SDK creates its own session).
             http_session (Optional[requests.Session]): Pre-authenticated session.
+            request_hooks (Optional[List[RequestHook]]): A list of functions to be called before each request.
+            response_hooks (Optional[List[ResponseHook]]): A list of functions to be called after each successful response.
         """
         self.config = self._coerce_config(config)
         self.token: Optional[str] = None
         self.token_expiry: Optional[datetime] = None
         self._refresh_lock = threading.Lock()
+        self._authenticator: Optional[BaseAuthenticator] = None
+        self._request_hooks = request_hooks or []
+        self._response_hooks = response_hooks or []
 
         if http_session is not None:
             self._init_with_injected_session(http_session)
@@ -107,79 +122,26 @@ 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 ---------------------------
+    # --------------------------- auth/session (refactored) ---------------------------
 
     def _authenticate_and_initialize_client(self) -> requests.Session:
-        auth = self.config.authentication
-        auth_type = getattr(auth, "type", "m2m")
+        auth_type = getattr(self.config.authentication, "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 __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)):
-                self.token_expiry = datetime.fromtimestamp(expires_at, tz=timezone.utc)
-            else:
-                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:
-            raise DatacosmosException(
-                f"Unexpected request failure during authentication: {e}"
-            ) from e
+            self._authenticator = M2MAuthenticator(self.config)
+        elif auth_type == "local":
+            self._authenticator = LocalAuthenticator(self.config)
+        else:
+            raise DatacosmosException(f"Unsupported authentication type: {auth_type}")
 
-    def __build_local_session(self) -> requests.Session:
-        """Interactive local login via LocalTokenFetcher (cached + refresh)."""
-        auth = self.config.authentication
-        try:
-            from datacosmos.auth.local_token_fetcher import LocalTokenFetcher
-
-            fetcher = LocalTokenFetcher(
-                client_id=auth.client_id,
-                authorization_endpoint=auth.authorization_endpoint,
-                token_endpoint=auth.token_endpoint,
-                redirect_port=int(auth.redirect_port),
-                audience=auth.audience,
-                scopes=auth.scopes,
-                token_file=Path(auth.cache_file).expanduser(),
-            )
-            tok = fetcher.get_token()
-        except Exception as e:
-            raise DatacosmosException(f"Local authentication failed: {e}") from e
-
-        self.token = tok.access_token
-        self.token_expiry = datetime.fromtimestamp(tok.expires_at, tz=timezone.utc)
+        auth_result = self._authenticator.authenticate_and_build_session()
+        self.token = auth_result.token
+        self.token_expiry = auth_result.token_expiry
+        return auth_result.http_client
 
-        http_client = requests.Session()
-        http_client.headers.update({"Authorization": f"Bearer {self.token}"})
-        self._local_token_fetcher = fetcher
-        return http_client
-
-    # --------------------------- refresh logic ---------------------------
+    # --------------------------- refresh logic (refactored) ---------------------------
 
     def _needs_refresh(self) -> bool:
         if not getattr(self, "_owns_session", False):
@@ -191,29 +153,22 @@ class DatacosmosClient:
         )
 
     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.
-        """
+        """Force refresh using the delegated authenticator."""
         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
-                )
+            if self._authenticator:
+                auth_result = self._authenticator.refresh_token()
+                self.token = auth_result.token
+                self.token_expiry = auth_result.token_expiry
                 self._http_client.headers.update(
                     {"Authorization": f"Bearer {self.token}"}
                 )
-                return
-
-            # default/m2m:
-            self._http_client = self.__build_m2m_session()
+            else:
+                raise DatacosmosException(
+                    "Cannot refresh token, no authenticator initialized."
+                )
 
     def _refresh_token_if_needed(self) -> None:
         if self._needs_refresh():
@@ -229,16 +184,44 @@ class DatacosmosClient:
     def request(
         self, method: str, url: str, *args: Any, **kwargs: Any
     ) -> requests.Response:
-        """Send an HTTP request using the authenticated session (with auto-refresh and retries)."""
+        """Send an HTTP request using the authenticated session (with auto-refresh and retries).
+
+        Args:
+            method (str): The HTTP method (e.g., "GET", "POST").
+            url (str): The URL for the request.
+            *args: Positional arguments for requests.request().
+            **kwargs: Keyword arguments for requests.request().
+
+        Returns:
+            requests.Response: The HTTP response.
+
+        Raises:
+            DatacosmosException: For any HTTP or request-related errors.
+        """
         self._refresh_token_if_needed()
+
+        # Call pre-request hooks
+        for hook in self._request_hooks:
+            try:
+                hook(method, url, *args, **kwargs)
+            except Exception:
+                _log.error("Request hook failed.", exc_info=True)
+
         try:
             response = self._http_client.request(method, url, *args, **kwargs)
             response.raise_for_status()
+
+            # Call post-response hooks on success
+            for hook in self._response_hooks:
+                try:
+                    hook(response)
+                except Exception:
+                    _log.error("Response hook failed.", exc_info=True)
+
             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:

{datacosmos-0.0.15 → datacosmos-0.0.17}/datacosmos.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: datacosmos
-Version: 0.0.15
+Version: 0.0.17
 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.15 → datacosmos-0.0.17}/datacosmos.egg-info/SOURCES.txt

@@ -9,7 +9,10 @@ datacosmos.egg-info/dependency_links.txt
 datacosmos.egg-info/requires.txt
 datacosmos.egg-info/top_level.txt
 datacosmos/auth/__init__.py
+datacosmos/auth/base_authenticator.py
+datacosmos/auth/local_authenticator.py
 datacosmos/auth/local_token_fetcher.py
+datacosmos/auth/m2m_authenticator.py
 datacosmos/auth/token.py
 datacosmos/config/__init__.py
 datacosmos/config/config.py

{datacosmos-0.0.15 → datacosmos-0.0.17}/pyproject.toml

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