python-daynest 0.1.1__tar.gz → 0.1.3__tar.gz

{python_daynest-0.1.1 → python_daynest-0.1.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-daynest
-Version: 0.1.1
+Version: 0.1.3
 Summary: Python client library for the Daynest API
 License: MIT
 Requires-Python: >=3.12

{python_daynest-0.1.1 → python_daynest-0.1.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "python-daynest"
-version = "0.1.1"
+version = "0.1.3"
 description = "Python client library for the Daynest API"
 requires-python = ">=3.12"
 license = { text = "MIT" }

{python_daynest-0.1.1 → python_daynest-0.1.3}/src/daynest/client.py

@@ -3,7 +3,9 @@
 from __future__ import annotations
 
 import logging
-from collections.abc import Callable
+import inspect
+import time
+from collections.abc import Awaitable, Callable, Mapping
 from datetime import date
 from typing import Any, TypeVar
 from urllib.parse import urljoin
@@ -22,6 +24,7 @@ from daynest.models import DaynestApiResponse, DaynestDashboard, DaynestSummary
 
 DEFAULT_API_BASE_URL = "http://localhost:8000"
 REQUEST_TIMEOUT = aiohttp.ClientTimeout(total=10)
+TOKEN_EXPIRY_BUFFER = 30  # seconds before expiry to refresh proactively
 
 logger = logging.getLogger(__name__)
 
@@ -51,12 +54,22 @@ class DaynestClient:
         *,
         session: aiohttp.ClientSession | None = None,
         password: str | None = None,
+        client_id: str | None = None,
+        client_secret: str | None = None,
+        token_url: str | None = None,
+        access_token_getter: Callable[[], str | None | Awaitable[str | None]] | None = None,
     ) -> None:
         if base_url is not None and not base_url.strip():
             msg = "A base URL is required to initialize DaynestClient"
             raise ValueError(msg)
         self._base_url = (base_url or DEFAULT_API_BASE_URL).strip().rstrip("/")
         self._integration_key = integration_key if integration_key is not None else password
+        self._client_id = client_id
+        self._client_secret = client_secret
+        self._token_url = token_url
+        self._access_token_getter = access_token_getter
+        self._cached_token: str | None = None
+        self._token_expires_at: float = 0.0
         self._session = session
         self._owned_session = session is None
         self._context_depth = 0
@@ -78,6 +91,75 @@ class DaynestClient:
         """Return whether the client has an integration key configured."""
         return bool(self._integration_key)
 
+    @property
+    def has_oauth_credentials(self) -> bool:
+        """Return whether the client has OAuth client credentials configured."""
+        return bool(self._client_id and self._client_secret and self._token_url)
+
+    async def _get_external_access_token(self) -> str | None:
+        """Return an externally managed OAuth access token, if configured."""
+        if self._access_token_getter is None:
+            return None
+        token = self._access_token_getter()
+        if inspect.isawaitable(token):
+            token = await token
+        if not token:
+            return None
+        return token
+
+    async def _fetch_oauth_token(self) -> str:
+        """Exchange client credentials for an access token."""
+        session = self._session_or_raise()
+        data = {
+            "grant_type": "client_credentials",
+            "client_id": self._client_id,
+            "client_secret": self._client_secret,
+        }
+        try:
+            async with session.post(
+                self._token_url,  # type: ignore[arg-type]
+                data=data,
+                timeout=REQUEST_TIMEOUT,
+            ) as response:
+                if response.status in (401, 403):
+                    msg = "OAuth client credentials rejected by token endpoint"
+                    raise DaynestAuthError(msg)
+                response.raise_for_status()
+                try:
+                    body = await response.json(content_type=None)
+                    if not isinstance(body, Mapping):
+                        msg = "Token endpoint response was not a JSON object"
+                        raise ValueError(msg)
+                    token = body.get("access_token")
+                    if not isinstance(token, str) or not token:
+                        msg = "Token endpoint returned no access_token"
+                        raise ValueError(msg)
+                    try:
+                        expires_in = int(body.get("expires_in", 300))
+                    except (TypeError, ValueError):
+                        expires_in = 300
+                except ValueError as err:
+                    msg = f"Token endpoint returned malformed payload: {err}"
+                    raise DaynestAuthError(msg) from err
+                self._cached_token = token
+                self._token_expires_at = time.monotonic() + expires_in - TOKEN_EXPIRY_BUFFER
+                return token
+        except aiohttp.ClientError as err:
+            msg = f"Failed to reach token endpoint: {err}"
+            raise DaynestCommunicationError(msg) from err
+
+    async def _get_auth_headers(self) -> dict[str, str]:
+        """Return auth headers for an API request."""
+        if external_token := await self._get_external_access_token():
+            return {"Authorization": f"Bearer {external_token}"}
+        if self.has_oauth_credentials:
+            if not self._cached_token or time.monotonic() >= self._token_expires_at:
+                await self._fetch_oauth_token()
+            return {"Authorization": f"Bearer {self._cached_token}"}
+        if self._integration_key:
+            return {"X-Integration-Key": self._integration_key}
+        return {}
+
     async def async_get_data(self) -> dict[str, Any]:
         """Fetch summary data as the coordinator's primary payload."""
         response = await self.async_get_summary()
@@ -218,9 +300,7 @@ class DaynestClient:
     ) -> DaynestApiResponse[ModelT]:
         session = self._session_or_raise()
         url = urljoin(f"{self._base_url}/", path.lstrip("/"))
-        headers = {"Accept": "application/json"}
-        if self._integration_key:
-            headers["X-Integration-Key"] = self._integration_key
+        headers = {"Accept": "application/json", **await self._get_auth_headers()}
 
         try:
             async with session.get(url, headers=headers, timeout=REQUEST_TIMEOUT) as response:
@@ -251,9 +331,7 @@ class DaynestClient:
     async def _request_list(self, path: str) -> list[dict[str, Any]]:
         session = self._session_or_raise()
         url = urljoin(f"{self._base_url}/", path.lstrip("/"))
-        headers = {"Accept": "application/json"}
-        if self._integration_key:
-            headers["X-Integration-Key"] = self._integration_key
+        headers = {"Accept": "application/json", **await self._get_auth_headers()}
 
         try:
             async with session.get(url, headers=headers, timeout=REQUEST_TIMEOUT) as response:
@@ -301,11 +379,9 @@ class DaynestClient:
     ) -> dict[str, Any]:
         session = self._session_or_raise()
         url = urljoin(f"{self._base_url}/", path.lstrip("/"))
-        headers = {"Accept": "application/json"}
+        headers = {"Accept": "application/json", **await self._get_auth_headers()}
         if payload is not None:
             headers["Content-Type"] = "application/json"
-        if self._integration_key:
-            headers["X-Integration-Key"] = self._integration_key
 
         if method.lower() not in {"post", "put", "delete"}:
             msg = f"Unsupported write method: {method}"

{python_daynest-0.1.1 → python_daynest-0.1.3}/tests/test_client.py

@@ -255,6 +255,79 @@ class TestDaynestClientRequests:
         call_kwargs = session.get.call_args[1]
         assert "X-Integration-Key" not in call_kwargs["headers"]
 
+    async def test_oauth_token_response_builds_bearer_header(self) -> None:
+        response = _make_mock_response(200, {"access_token": "access-token", "expires_in": "300"})
+        session = MagicMock(spec=aiohttp.ClientSession)
+        session.post = MagicMock(return_value=response)
+        client = DaynestClient(
+            base_url="https://api.example",
+            client_id="integration-client",
+            client_secret="client-secret",
+            token_url="https://auth.example/token",
+            session=session,
+        )
+
+        assert await client._get_auth_headers() == {"Authorization": "Bearer access-token"}
+
+    async def test_oauth_token_non_object_response_raises_auth_error(self) -> None:
+        response = _make_mock_response(200, ["not", "an", "object"])
+        session = MagicMock(spec=aiohttp.ClientSession)
+        session.post = MagicMock(return_value=response)
+        client = DaynestClient(
+            base_url="https://api.example",
+            client_id="integration-client",
+            client_secret="client-secret",
+            token_url="https://auth.example/token",
+            session=session,
+        )
+
+        with pytest.raises(DaynestAuthError, match="malformed payload"):
+            await client._get_auth_headers()
+
+    async def test_oauth_token_invalid_expires_in_falls_back_to_default(self) -> None:
+        response = _make_mock_response(200, {"access_token": "access-token", "expires_in": "soon"})
+        session = MagicMock(spec=aiohttp.ClientSession)
+        session.post = MagicMock(return_value=response)
+        client = DaynestClient(
+            base_url="https://api.example",
+            client_id="integration-client",
+            client_secret="client-secret",
+            token_url="https://auth.example/token",
+            session=session,
+        )
+
+        assert await client._get_auth_headers() == {"Authorization": "Bearer access-token"}
+
+    async def test_external_access_token_getter_is_used_before_other_auth_modes(self) -> None:
+        response = _make_mock_response(200, {"access_token": "ignored-token", "expires_in": "300"})
+        session = MagicMock(spec=aiohttp.ClientSession)
+        session.post = MagicMock(return_value=response)
+        client = DaynestClient(
+            base_url="https://api.example",
+            integration_key="legacy-key",
+            client_id="integration-client",
+            client_secret="client-secret",
+            token_url="https://auth.example/token",
+            access_token_getter=lambda: "oidc-access-token",
+            session=session,
+        )
+
+        assert await client._get_auth_headers() == {"Authorization": "Bearer oidc-access-token"}
+        session.post.assert_not_called()
+
+    async def test_external_access_token_getter_supports_async_callback(self) -> None:
+        async def _token() -> str:
+            return "async-token"
+
+        session = MagicMock(spec=aiohttp.ClientSession)
+        client = DaynestClient(
+            base_url="https://api.example",
+            access_token_getter=_token,
+            session=session,
+        )
+
+        assert await client._get_auth_headers() == {"Authorization": "Bearer async-token"}
+
     async def test_client_error_raises_communication_error(self) -> None:
         session = MagicMock(spec=aiohttp.ClientSession)
         mock_ctx = MagicMock()