python-homely 0.1.0__tar.gz → 0.1.1__tar.gz

{python_homely-0.1.0 → python_homely-0.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-homely
-Version: 0.1.0
+Version: 0.1.1
 Summary: Async Python client for the Homely cloud API, built for Home Assistant but usable anywhere.
 Author: Ludvik Blichfeldt Rød
 License-Expression: MIT

{python_homely-0.1.0 → python_homely-0.1.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "python-homely"
-version = "0.1.0"
+version = "0.1.1"
 description = "Async Python client for the Homely cloud API, built for Home Assistant but usable anywhere."
 readme = "README.md"
 requires-python = ">=3.12"

{python_homely-0.1.0 → python_homely-0.1.1}/src/homely/__init__.py

@@ -1,6 +1,6 @@
 """Reusable Homely client package extracted from the integration."""
 
-__version__ = "0.1.0"
+__version__ = "0.1.1"
 
 from .client import (
     BASE_URL,

python_homely-0.1.1/src/homely/client.py

@@ -0,0 +1,349 @@
+"""Async Homely API client."""
+from __future__ import annotations
+
+import logging
+from typing import Any
+
+import aiohttp
+
+from .exceptions import (
+    HomelyAuthError,
+    HomelyConnectionError,
+    HomelyResponseError,
+)
+from .models import TokenResponse
+
+_LOGGER = logging.getLogger(__name__)
+
+BASE_URL = "https://sdk.iotiliti.cloud/homely/"
+REQUEST_TIMEOUT = aiohttp.ClientTimeout(total=20)
+
+
+def _log_identifier(value: str | int | None) -> str | None:
+    """Return a shortened identifier suitable for debug logs."""
+    if value is None:
+        return None
+
+    text = str(value)
+    if len(text) <= 8:
+        return text
+    return f"{text[:8]}..."
+
+
+def auth_header_value(token: str | None) -> str:
+    """Return normalized Authorization header value."""
+    normalized = (token or "").strip()
+    if normalized.lower().startswith("bearer "):
+        return normalized
+    return f"Bearer {normalized}"
+
+
+def _response_preview(payload: Any) -> str:
+    """Return a short safe preview of a response payload for exceptions."""
+    text = repr(payload)
+    if len(text) <= 200:
+        return text
+    return f"{text[:200]}..."
+
+
+class HomelyClient:
+    """Small reusable async client for the Homely cloud API."""
+
+    def __init__(
+        self,
+        session: aiohttp.ClientSession,
+        *,
+        base_url: str = BASE_URL,
+        timeout: aiohttp.ClientTimeout = REQUEST_TIMEOUT,
+    ) -> None:
+        """Initialize the client with a caller-managed aiohttp session."""
+        self._session = session
+        self._base_url = base_url
+        self._timeout = timeout
+
+    @property
+    def base_url(self) -> str:
+        """Return the configured API base URL."""
+        return self._base_url
+
+    @property
+    def timeout(self) -> aiohttp.ClientTimeout:
+        """Return the configured request timeout."""
+        return self._timeout
+
+    async def authenticate(
+        self,
+        username: str,
+        password: str,
+    ) -> TokenResponse:
+        """Authenticate and return a typed token response.
+
+        Raises a typed SDK exception on failure.
+        """
+        response, status = await self._fetch_token_payload(username, password)
+        if response is not None:
+            try:
+                return TokenResponse.from_dict(response)
+            except (KeyError, TypeError, ValueError) as err:
+                raise HomelyResponseError(
+                    "Homely authentication response missing required fields",
+                    status=status,
+                    body=_response_preview(response),
+                ) from err
+        if status in (400, 401, 403):
+            raise HomelyAuthError("Invalid Homely username or password")
+        if status in (200, 201):
+            raise HomelyResponseError(
+                "Homely authentication response could not be parsed",
+                status=status,
+            )
+        raise HomelyConnectionError("Could not connect to Homely")
+
+    async def _fetch_token_payload(
+        self,
+        username: str,
+        password: str,
+    ) -> tuple[dict[str, Any] | None, int | None]:
+        """Fetch access token payload and include HTTP status when available."""
+        url = f"{self._base_url}oauth/token"
+        payload = {
+            "username": username,
+            "password": password,
+        }
+
+        try:
+            async with self._session.post(url, json=payload, timeout=self._timeout) as response:
+                if response.status in (200, 201):
+                    try:
+                        parsed = await response.json()
+                    except (aiohttp.ContentTypeError, TypeError, ValueError) as err:
+                        _LOGGER.debug(
+                            "Token fetch returned invalid JSON status=%s: %s",
+                            response.status,
+                            err,
+                        )
+                        return None, response.status
+                    if not isinstance(parsed, dict):
+                        _LOGGER.debug(
+                            "Token fetch returned unexpected payload type status=%s payload_type=%s",
+                            response.status,
+                            type(parsed).__name__,
+                        )
+                        return None, response.status
+                    _LOGGER.debug("Token fetch successful")
+                    return parsed, response.status
+
+                _LOGGER.debug("Token fetch failed with status=%s", response.status)
+                return None, response.status
+        except (aiohttp.ClientError, TimeoutError) as err:
+            _LOGGER.debug("Token fetch network error: %s", err)
+            return None, None
+
+    async def fetch_token_with_reason(
+        self,
+        username: str,
+        password: str,
+    ) -> tuple[dict[str, Any] | None, str | None]:
+        """Fetch access token and return optional reason key on failure."""
+        response, status = await self._fetch_token_payload(username, password)
+        if response is not None:
+            return response, None
+        if status in (400, 401, 403):
+            return None, "invalid_auth"
+        return None, "cannot_connect"
+
+    async def fetch_token(
+        self,
+        username: str,
+        password: str,
+    ) -> dict[str, Any] | None:
+        """Fetch access token from API."""
+        response, _reason = await self.fetch_token_with_reason(username, password)
+        return response
+
+    async def _fetch_refresh_token_payload(
+        self,
+        refresh_token: str,
+    ) -> tuple[dict[str, Any] | None, int | None]:
+        """Refresh access token payload and include HTTP status when available."""
+        url = f"{self._base_url}oauth/refresh-token"
+        payload = {
+            "refresh_token": refresh_token,
+        }
+
+        try:
+            async with self._session.post(url, json=payload, timeout=self._timeout) as response:
+                if response.status in (200, 201):
+                    try:
+                        parsed = await response.json()
+                    except (aiohttp.ContentTypeError, TypeError, ValueError) as err:
+                        _LOGGER.debug(
+                            "Token refresh returned invalid JSON status=%s: %s",
+                            response.status,
+                            err,
+                        )
+                        return None, response.status
+                    if not isinstance(parsed, dict):
+                        _LOGGER.debug(
+                            "Token refresh returned unexpected payload type status=%s payload_type=%s",
+                            response.status,
+                            type(parsed).__name__,
+                        )
+                        return None, response.status
+                    _LOGGER.debug("Token refresh successful")
+                    return parsed, response.status
+                _LOGGER.debug("Token refresh failed with status=%s", response.status)
+                return None, response.status
+        except (aiohttp.ClientError, TimeoutError) as err:
+            _LOGGER.debug("Token refresh network error: %s", err)
+            return None, None
+
+    async def fetch_refresh_token(self, refresh_token: str) -> dict[str, Any] | None:
+        """Refresh access token using refresh token."""
+        response, _status = await self._fetch_refresh_token_payload(refresh_token)
+        return response
+
+    async def refresh_access_token(self, refresh_token: str) -> TokenResponse:
+        """Refresh access token and return a typed token response."""
+        response, status = await self._fetch_refresh_token_payload(refresh_token)
+        if response is not None:
+            try:
+                return TokenResponse.from_dict(response)
+            except (KeyError, TypeError, ValueError) as err:
+                raise HomelyResponseError(
+                    "Homely refresh response missing required fields",
+                    status=status,
+                    body=_response_preview(response),
+                ) from err
+        if status in (400, 401, 403):
+            raise HomelyAuthError("Homely rejected the supplied refresh token")
+        if status in (200, 201):
+            raise HomelyResponseError(
+                "Homely refresh response could not be parsed",
+                status=status,
+            )
+        raise HomelyConnectionError("Could not refresh Homely access token")
+
+    async def _get_locations_payload(
+        self,
+        token: str,
+    ) -> tuple[list[dict[str, Any]] | None, int | None]:
+        """Get locations payload and include HTTP status when available."""
+        url = f"{self._base_url}locations"
+        headers = {"Authorization": auth_header_value(token)}
+
+        try:
+            async with self._session.get(url, headers=headers, timeout=self._timeout) as response:
+                if response.status == 200:
+                    try:
+                        parsed = await response.json()
+                    except (aiohttp.ContentTypeError, TypeError, ValueError) as err:
+                        _LOGGER.debug(
+                            "Locations fetch returned invalid JSON status=%s: %s",
+                            response.status,
+                            err,
+                        )
+                        return None, response.status
+                    if not isinstance(parsed, list):
+                        _LOGGER.debug(
+                            "Locations fetch returned unexpected payload type status=%s payload_type=%s",
+                            response.status,
+                            type(parsed).__name__,
+                        )
+                        return None, response.status
+                    _LOGGER.debug("Locations fetch successful")
+                    return parsed, response.status
+                _LOGGER.debug("Locations fetch failed with status=%s", response.status)
+                return None, response.status
+        except (aiohttp.ClientError, TimeoutError) as err:
+            _LOGGER.debug("Locations fetch network error: %s", err)
+            return None, None
+
+    async def get_locations(self, token: str) -> list[dict[str, Any]] | None:
+        """Get locations from API."""
+        locations, _status = await self._get_locations_payload(token)
+        return locations
+
+    async def get_locations_or_raise(self, token: str) -> list[dict[str, Any]]:
+        """Get locations from API or raise a typed exception."""
+        locations, status = await self._get_locations_payload(token)
+        if locations is not None:
+            return locations
+        if status in (401, 403):
+            raise HomelyAuthError("Homely rejected the supplied access token")
+        if status == 200:
+            raise HomelyResponseError(
+                "Homely locations response could not be parsed",
+                status=status,
+            )
+        raise HomelyConnectionError("Could not fetch Homely locations")
+
+    async def get_home_data(
+        self,
+        token: str,
+        location_id: str | int,
+    ) -> dict[str, Any] | None:
+        """Get location data from API."""
+        data, _status = await self.get_home_data_with_status(token, location_id)
+        return data
+
+    async def get_home_data_with_status(
+        self,
+        token: str,
+        location_id: str | int,
+    ) -> tuple[dict[str, Any] | None, int | None]:
+        """Get location data from API and include HTTP status when available."""
+        url = f"{self._base_url}home/{location_id}"
+        headers = {"Authorization": auth_header_value(token)}
+
+        try:
+            async with self._session.get(url, headers=headers, timeout=self._timeout) as response:
+                if response.status == 200:
+                    try:
+                        parsed = await response.json()
+                    except (aiohttp.ContentTypeError, TypeError, ValueError) as err:
+                        _LOGGER.debug(
+                            "Location data fetch returned invalid JSON status=%s location_id=%s: %s",
+                            response.status,
+                            _log_identifier(location_id),
+                            err,
+                        )
+                        return None, response.status
+                    if not isinstance(parsed, dict):
+                        _LOGGER.debug(
+                            "Location data fetch returned unexpected payload type status=%s location_id=%s payload_type=%s",
+                            response.status,
+                            _log_identifier(location_id),
+                            type(parsed).__name__,
+                        )
+                        return None, response.status
+                    return parsed, response.status
+                _LOGGER.debug(
+                    "Location data fetch failed with status=%s location_id=%s",
+                    response.status,
+                    _log_identifier(location_id),
+                )
+                return None, response.status
+        except (aiohttp.ClientError, TimeoutError) as err:
+            _LOGGER.debug(
+                "Location data fetch network error location_id=%s: %s",
+                _log_identifier(location_id),
+                err,
+            )
+            return None, None
+
+    async def get_home_data_or_raise(
+        self,
+        token: str,
+        location_id: str | int,
+    ) -> dict[str, Any]:
+        """Get location data from API or raise a typed exception."""
+        data, status = await self.get_home_data_with_status(token, location_id)
+        if data is not None:
+            return data
+        if status in (401, 403):
+            raise HomelyAuthError("Homely rejected the supplied access token")
+        raise HomelyResponseError(
+            "Could not fetch Homely location data",
+            status=status,
+        )

{python_homely-0.1.0 → python_homely-0.1.1}/src/homely/websocket.py

@@ -14,6 +14,17 @@ from .exceptions import HomelyWebSocketError
 _LOGGER = logging.getLogger(__name__)
 
 
+def _log_identifier(value: str | int | None) -> str | None:
+    """Return a shortened identifier suitable for logs."""
+    if value is None:
+        return None
+
+    text = str(value)
+    if len(text) <= 8:
+        return text
+    return f"{text[:8]}..."
+
+
 class HomelyWebSocket:
     """WebSocket client for Homely using Socket.IO."""
 
@@ -45,9 +56,12 @@ class HomelyWebSocket:
 
     def _ctx(self, device_id: str | None = None) -> str:
         """Build consistent log context."""
-        base = f"context_id={self.context_id} location_id={self.location_id}"
+        base = (
+            f"context_id={_log_identifier(self.context_id)} "
+            f"location_id={_log_identifier(self.location_id)}"
+        )
         if device_id:
-            return f"{base} device_id={device_id}"
+            return f"{base} device_id={_log_identifier(device_id)}"
         return base
 
     @property
@@ -82,14 +96,14 @@ class HomelyWebSocket:
 
         if status_changed:
             if status == "Connected":
-                _LOGGER.info("WebSocket connected %s", self._ctx())
+                _LOGGER.debug("WebSocket connected %s", self._ctx())
             elif status == "Disconnected":
                 if reason and self._should_warn_disconnect(reason):
-                    _LOGGER.warning("WebSocket disconnected %s (%s)", self._ctx(), reason)
+                    _LOGGER.info("WebSocket disconnected %s (%s)", self._ctx(), reason)
                 elif reason:
                     _LOGGER.debug("WebSocket disconnected %s (%s)", self._ctx(), reason)
                 else:
-                    _LOGGER.warning("WebSocket disconnected %s", self._ctx())
+                    _LOGGER.info("WebSocket disconnected %s", self._ctx())
             else:
                 if reason:
                     _LOGGER.debug(
@@ -198,14 +212,14 @@ class HomelyWebSocket:
 
         self._reconnect_task = loop.create_task(self._reconnect_loop())
         if reason:
-            _LOGGER.info(
+            _LOGGER.debug(
                 "Started reconnect loop %s (%s). interval=%ss, retries=infinite",
                 self._ctx(),
                 reason,
                 self._reconnect_interval,
             )
         else:
-            _LOGGER.info(
+            _LOGGER.debug(
                 "Started reconnect loop %s. interval=%ss, retries=infinite",
                 self._ctx(),
                 self._reconnect_interval,
@@ -228,11 +242,11 @@ class HomelyWebSocket:
             _LOGGER.debug("WebSocket reconnect attempt %s started %s", attempt, self._ctx())
             success = await self.connect(from_reconnect_loop=True)
             if success:
-                _LOGGER.info("WebSocket reconnect attempt %s succeeded %s", attempt, self._ctx())
+                _LOGGER.debug("WebSocket reconnect attempt %s succeeded %s", attempt, self._ctx())
                 return
 
-            if attempt == 1 or attempt % self._reconnect_warn_every == 0:
-                _LOGGER.warning(
+            if attempt % self._reconnect_warn_every == 0:
+                _LOGGER.info(
                     "WebSocket reconnect attempt %s failed %s. Retrying in %s seconds",
                     attempt,
                     self._ctx(),

{python_homely-0.1.0 → python_homely-0.1.1}/src/python_homely.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-homely
-Version: 0.1.0
+Version: 0.1.1
 Summary: Async Python client for the Homely cloud API, built for Home Assistant but usable anywhere.
 Author: Ludvik Blichfeldt Rød
 License-Expression: MIT

{python_homely-0.1.0 → python_homely-0.1.1}/tests/test_sdk.py

@@ -19,10 +19,18 @@ from homely import (
 class _FakeResponse:
     """Simple async HTTP response stub."""
 
-    def __init__(self, *, status: int, json_data=None, text_data: str = "") -> None:
+    def __init__(
+        self,
+        *,
+        status: int,
+        json_data=None,
+        text_data: str = "",
+        json_exc: Exception | None = None,
+    ) -> None:
         self.status = status
         self._json_data = json_data
         self._text_data = text_data
+        self._json_exc = json_exc
 
     async def __aenter__(self):
         return self
@@ -31,6 +39,8 @@ class _FakeResponse:
         return False
 
     async def json(self):
+        if self._json_exc is not None:
+            raise self._json_exc
         return self._json_data
 
     async def text(self):
@@ -77,7 +87,7 @@ class _FakeAsyncCallable:
 async def test_sdk_exports_public_symbols():
     """The SDK should expose a clean public surface."""
     assert auth_header_value("token") == "Bearer token"
-    assert __version__ == "0.1.0"
+    assert __version__ == "0.1.1"
 
 
 async def test_authenticate_returns_typed_token():
@@ -133,6 +143,18 @@ async def test_refresh_access_token_raises_connection_error_on_timeout():
         raise AssertionError("Expected HomelyConnectionError")
 
 
+async def test_refresh_access_token_raises_auth_error_on_expired_refresh_token():
+    """Refresh auth failures should surface as HomelyAuthError."""
+    client = HomelyClient(_FakeSession(post_response=_FakeResponse(status=400)))
+
+    try:
+        await client.refresh_access_token("refresh-token")
+    except HomelyAuthError:
+        pass
+    else:
+        raise AssertionError("Expected HomelyAuthError")
+
+
 async def test_get_locations_or_raise_raises_connection_error():
     """Location lookup failures should raise HomelyConnectionError."""
     client = HomelyClient(_FakeSession(get_exc=aiohttp.ClientError("boom")))
@@ -145,6 +167,18 @@ async def test_get_locations_or_raise_raises_connection_error():
         raise AssertionError("Expected HomelyConnectionError")
 
 
+async def test_get_locations_or_raise_raises_auth_error_on_unauthorized():
+    """Unauthorized location lookups should raise HomelyAuthError."""
+    client = HomelyClient(_FakeSession(get_response=_FakeResponse(status=401)))
+
+    try:
+        await client.get_locations_or_raise("token")
+    except HomelyAuthError:
+        pass
+    else:
+        raise AssertionError("Expected HomelyAuthError")
+
+
 async def test_get_home_data_or_raise_raises_response_error():
     """Unexpected data fetch failures should carry response metadata."""
     client = HomelyClient(
@@ -161,20 +195,67 @@ async def test_get_home_data_or_raise_raises_response_error():
         raise AssertionError("Expected HomelyResponseError")
 
 
+async def test_authenticate_raises_response_error_on_malformed_success_payload():
+    """Malformed successful auth responses should raise HomelyResponseError."""
+    client = HomelyClient(
+        _FakeSession(post_response=_FakeResponse(status=200, json_data={"refresh_token": "refresh"}))
+    )
+
+    try:
+        await client.authenticate("user", "pass")
+    except HomelyResponseError as err:
+        assert err.status == 200
+    else:
+        raise AssertionError("Expected HomelyResponseError")
+
+
+async def test_get_locations_or_raise_raises_response_error_on_malformed_success_payload():
+    """Malformed successful location responses should raise HomelyResponseError."""
+    client = HomelyClient(_FakeSession(get_response=_FakeResponse(status=200, json_data={"bad": "payload"})))
+
+    try:
+        await client.get_locations_or_raise("token")
+    except HomelyResponseError as err:
+        assert err.status == 200
+    else:
+        raise AssertionError("Expected HomelyResponseError")
+
+
+async def test_get_home_data_or_raise_raises_response_error_on_invalid_json():
+    """Malformed successful location payloads should raise HomelyResponseError."""
+    client = HomelyClient(
+        _FakeSession(
+            get_response=_FakeResponse(status=200, json_exc=ValueError("bad json"))
+        )
+    )
+
+    try:
+        await client.get_home_data_or_raise("token", "loc-1")
+    except HomelyResponseError as err:
+        assert err.status == 200
+    else:
+        raise AssertionError("Expected HomelyResponseError")
+
+
 async def test_websocket_public_aliases_cover_package_api():
     """The websocket client should expose package-friendly aliases."""
     ws = HomelyWebSocket(
-        location_id="loc-1",
+        location_id="11111111-2222-3333-4444-555555555555",
         token="token",
         on_data_update=lambda _data: None,
-        context_id="ctx-1",
+        context_id="aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee",
     )
 
-    assert ws.context_id == "ctx-1"
-    assert ws.entry_id == "ctx-1"
+    assert ws.context_id == "aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee"
+    assert ws.entry_id == "aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee"
 
     ws.set_token("new-token")
     assert ws.token == "new-token"
+    assert ws._ctx("99999999-8888-7777-6666-555555555555") == (
+        "context_id=aaaaaaaa... "
+        "location_id=11111111... "
+        "device_id=99999999..."
+    )
 
 
 async def test_websocket_connect_or_raise_uses_typed_exception():

python_homely-0.1.0/src/homely/client.py

@@ -1,209 +0,0 @@
-"""Async Homely API client."""
-from __future__ import annotations
-
-import logging
-from typing import Any
-
-import aiohttp
-
-from .exceptions import (
-    HomelyAuthError,
-    HomelyConnectionError,
-    HomelyResponseError,
-)
-from .models import TokenResponse
-
-_LOGGER = logging.getLogger(__name__)
-
-BASE_URL = "https://sdk.iotiliti.cloud/homely/"
-REQUEST_TIMEOUT = aiohttp.ClientTimeout(total=20)
-
-
-def auth_header_value(token: str | None) -> str:
-    """Return normalized Authorization header value."""
-    normalized = (token or "").strip()
-    if normalized.lower().startswith("bearer "):
-        return normalized
-    return f"Bearer {normalized}"
-
-
-class HomelyClient:
-    """Small reusable async client for the Homely cloud API."""
-
-    def __init__(
-        self,
-        session: aiohttp.ClientSession,
-        *,
-        base_url: str = BASE_URL,
-        timeout: aiohttp.ClientTimeout = REQUEST_TIMEOUT,
-    ) -> None:
-        """Initialize the client with a caller-managed aiohttp session."""
-        self._session = session
-        self._base_url = base_url
-        self._timeout = timeout
-
-    @property
-    def base_url(self) -> str:
-        """Return the configured API base URL."""
-        return self._base_url
-
-    @property
-    def timeout(self) -> aiohttp.ClientTimeout:
-        """Return the configured request timeout."""
-        return self._timeout
-
-    async def authenticate(
-        self,
-        username: str,
-        password: str,
-    ) -> TokenResponse:
-        """Authenticate and return a typed token response.
-
-        Raises a typed SDK exception on failure.
-        """
-        response, reason = await self.fetch_token_with_reason(username, password)
-        if response:
-            return TokenResponse.from_dict(response)
-        if reason == "invalid_auth":
-            raise HomelyAuthError("Invalid Homely username or password")
-        raise HomelyConnectionError("Could not connect to Homely")
-
-    async def fetch_token_with_reason(
-        self,
-        username: str,
-        password: str,
-    ) -> tuple[dict[str, Any] | None, str | None]:
-        """Fetch access token and return optional reason key on failure."""
-        url = f"{self._base_url}oauth/token"
-        payload = {
-            "username": username,
-            "password": password,
-        }
-
-        try:
-            async with self._session.post(url, json=payload, timeout=self._timeout) as response:
-                if response.status in (200, 201):
-                    _LOGGER.debug("Token fetch successful")
-                    return await response.json(), None
-
-                if response.status in (400, 401, 403):
-                    _LOGGER.debug("Token fetch rejected with status=%s", response.status)
-                    return None, "invalid_auth"
-
-                _LOGGER.warning("Token fetch failed with status=%s", response.status)
-                return None, "cannot_connect"
-        except (aiohttp.ClientError, TimeoutError) as err:
-            _LOGGER.warning("Token fetch network error: %s", err)
-            return None, "cannot_connect"
-
-    async def fetch_token(
-        self,
-        username: str,
-        password: str,
-    ) -> dict[str, Any] | None:
-        """Fetch access token from API."""
-        response, _reason = await self.fetch_token_with_reason(username, password)
-        return response
-
-    async def fetch_refresh_token(self, refresh_token: str) -> dict[str, Any] | None:
-        """Refresh access token using refresh token."""
-        url = f"{self._base_url}oauth/refresh-token"
-        payload = {
-            "refresh_token": refresh_token,
-        }
-
-        try:
-            async with self._session.post(url, json=payload, timeout=self._timeout) as response:
-                if response.status in (200, 201):
-                    _LOGGER.debug("Token refresh successful")
-                    return await response.json()
-                _LOGGER.debug("Token refresh failed with status=%s", response.status)
-                return None
-        except (aiohttp.ClientError, TimeoutError) as err:
-            _LOGGER.debug("Token refresh network error: %s", err)
-            return None
-
-    async def refresh_access_token(self, refresh_token: str) -> TokenResponse:
-        """Refresh access token and return a typed token response."""
-        response = await self.fetch_refresh_token(refresh_token)
-        if response:
-            return TokenResponse.from_dict(response)
-        raise HomelyConnectionError("Could not refresh Homely access token")
-
-    async def get_locations(self, token: str) -> list[dict[str, Any]] | None:
-        """Get locations from API."""
-        url = f"{self._base_url}locations"
-        headers = {"Authorization": auth_header_value(token)}
-
-        try:
-            async with self._session.get(url, headers=headers, timeout=self._timeout) as response:
-                if response.status == 200:
-                    _LOGGER.debug("Locations fetch successful")
-                    return await response.json()
-                _LOGGER.debug("Locations fetch failed with status=%s", response.status)
-                return None
-        except (aiohttp.ClientError, TimeoutError) as err:
-            _LOGGER.debug("Locations fetch network error: %s", err)
-            return None
-
-    async def get_locations_or_raise(self, token: str) -> list[dict[str, Any]]:
-        """Get locations from API or raise a typed exception."""
-        locations = await self.get_locations(token)
-        if locations is not None:
-            return locations
-        raise HomelyConnectionError("Could not fetch Homely locations")
-
-    async def get_home_data(
-        self,
-        token: str,
-        location_id: str | int,
-    ) -> dict[str, Any] | None:
-        """Get location data from API."""
-        data, _status = await self.get_home_data_with_status(token, location_id)
-        return data
-
-    async def get_home_data_with_status(
-        self,
-        token: str,
-        location_id: str | int,
-    ) -> tuple[dict[str, Any] | None, int | None]:
-        """Get location data from API and include HTTP status when available."""
-        url = f"{self._base_url}home/{location_id}"
-        headers = {"Authorization": auth_header_value(token)}
-
-        try:
-            async with self._session.get(url, headers=headers, timeout=self._timeout) as response:
-                if response.status == 200:
-                    return await response.json(), response.status
-                body = await response.text()
-                body_preview = body.replace("\n", " ")[:200]
-                _LOGGER.debug(
-                    "Location data fetch failed with status=%s location_id=%s body_preview=%r",
-                    response.status,
-                    location_id,
-                    body_preview,
-                )
-                return None, response.status
-        except (aiohttp.ClientError, TimeoutError) as err:
-            _LOGGER.debug(
-                "Location data fetch network error location_id=%s: %s",
-                location_id,
-                err,
-            )
-            return None, None
-
-    async def get_home_data_or_raise(
-        self,
-        token: str,
-        location_id: str | int,
-    ) -> dict[str, Any]:
-        """Get location data from API or raise a typed exception."""
-        data, status = await self.get_home_data_with_status(token, location_id)
-        if data is not None:
-            return data
-        if status in (401, 403):
-            raise HomelyAuthError("Homely rejected the supplied access token")
-        raise HomelyResponseError(
-            "Could not fetch Homely location data",
-            status=status,
-        )