Update .gitignore to include examples/secrets.json

Update `requirements.txt` to remove `authlib` dependency

Update `setup.py` to bump version to `1.2.0`

Add `authlib_cloud_client.py` file

Update `run.py` to use `LaMarzoccoAuthlibCloudClient` instead of `LaMarzoccoCloudClient`

Commit message: Update `.gitignore`, `requirements.txt`, `setup.py`, add `authlib_cloud_client.py`, and update `run.py`

Author: zweckj

.gitignore

@@ -130,6 +130,7 @@ dmypy.json
 
 #local config
 secrets.json
+examples/secrets.json
 bleak_device_info.py
 bleak_discover.py
 .gitignore

authlib_cloud_client.py

@@ -0,0 +1,44 @@
+"""Example implementation of a La Marzocco Cloud Client using Authlib."""
+
+from authlib.common.errors import AuthlibHTTPError  # type: ignore[import]
+from authlib.integrations.base_client.errors import OAuthError  # type: ignore[import]
+from authlib.integrations.httpx_client import AsyncOAuth2Client  # type: ignore[import]
+
+from lmcloud.client_cloud import LaMarzoccoCloudClient
+from lmcloud.const import DEFAULT_CLIENT_ID, DEFAULT_CLIENT_SECRET, TOKEN_URL
+from lmcloud.exceptions import AuthFail, RequestNotSuccessful
+
+
+class LaMarzoccoAuthlibCloudClient(LaMarzoccoCloudClient):
+    """La Marzocco Cloud Client using Authlib."""
+
+    _client: AsyncOAuth2Client
+
+    def __init__(self, username: str, password: str) -> None:
+        self.username = username
+        self.password = password
+        client = AsyncOAuth2Client(
+            client_id=DEFAULT_CLIENT_ID,
+            client_secret=DEFAULT_CLIENT_SECRET,
+            token_endpoint=TOKEN_URL,
+        )
+        super().__init__(client)
+
+    async def async_get_access_token(self) -> str:
+        try:
+            await self._client.fetch_token(
+                url=TOKEN_URL,
+                username=self.username,
+                password=self.password,
+            )
+        except OAuthError as exc:
+            raise AuthFail(f"Authorization failure: {exc}") from exc
+        except AuthlibHTTPError as exc:
+            raise RequestNotSuccessful(
+                f"Exception during token request: {exc}"
+            ) from exc
+
+        # make sure oauth token is still valid
+        if self._client.token.is_expired():
+            await self._client.refresh_token(TOKEN_URL)
+        return ""

lmcloud/client_cloud.py

@@ -3,30 +3,25 @@
 from __future__ import annotations
 
 import asyncio
+from abc import abstractmethod
 from datetime import datetime
 import logging
 from http import HTTPMethod
 from typing import Any
 
-from authlib.common.errors import AuthlibHTTPError  # type: ignore[import]
-from authlib.integrations.base_client.errors import OAuthError  # type: ignore[import]
-from authlib.integrations.httpx_client import AsyncOAuth2Client  # type: ignore[import]
-from httpx import RequestError
+from httpx import AsyncClient, RequestError
 
 from .const import (
     CUSTOMER_URL,
-    DEFAULT_CLIENT_ID,
-    DEFAULT_CLIENT_SECRET,
     GW_AWS_PROXY_BASE_URL,
     GW_MACHINE_BASE_URL,
-    TOKEN_URL,
     BoilerType,
     FirmwareType,
     PhysicalKey,
     PrebrewMode,
     SmartStandbyMode,
 )
-from .exceptions import AuthFail, RequestNotSuccessful
+from .exceptions import RequestNotSuccessful
 from .models import LaMarzoccoFirmware, LaMarzoccoDeviceInfo, LaMarzoccoWakeUpSleepEntry
 
 _LOGGER = logging.getLogger(__name__)
@@ -35,49 +30,31 @@
 class LaMarzoccoCloudClient:
     """La Marzocco Cloud Client."""
 
-    def __init__(self, username: str, password: str):
-        self._oauth_client: AsyncOAuth2Client | None = None
-        self.username = username
-        self.password = password
+    _client: AsyncClient
 
-    async def _connect(self) -> AsyncOAuth2Client:
-        """Establish connection by building the OAuth client and requesting the token"""
+    def __init__(self, client: AsyncClient) -> None:
+        self._client = client
 
-        client = AsyncOAuth2Client(
-            client_id=DEFAULT_CLIENT_ID,
-            client_secret=DEFAULT_CLIENT_SECRET,
-            token_endpoint=TOKEN_URL,
-        )
-
-        try:
-            await client.fetch_token(
-                url=TOKEN_URL,
-                username=self.username,
-                password=self.password,
-            )
-        except OAuthError as exc:
-            raise AuthFail(f"Authorization failure: {exc}") from exc
-        except AuthlibHTTPError as exc:
-            raise RequestNotSuccessful(
-                f"Exception during token request: {exc}"
-            ) from exc
-
-        return client
+    @abstractmethod
+    async def async_get_access_token(self) -> str:
+        """Return a valid access token."""
 
     async def _rest_api_call(
-        self, url: str, method: HTTPMethod, data: dict[str, Any] | None = None, timeout: int = 5,
+        self,
+        url: str,
+        method: HTTPMethod,
+        data: dict[str, Any] | None = None,
+        timeout: int = 5,
     ) -> Any:
         """Wrapper for the API call."""
 
-        if self._oauth_client is None:
-            self._oauth_client = await self._connect()
-
-        # make sure oauth token is still valid
-        if self._oauth_client.token.is_expired():
-            await self._oauth_client.refresh_token(TOKEN_URL)
+        access_token = await self.async_get_access_token()
+        headers = {"Authorization": f"Bearer {access_token}"}
 
         try:
-            response = await self._oauth_client.request(method, url, json=data, timeout=timeout)
+            response = await self._client.request(
+                method=method, url=url, json=data, timeout=timeout, headers=headers
+            )
         except RequestError as ecx:
             raise RequestNotSuccessful(
                 f"Error during HTTP request. Request to endpoint {url} failed with error: {ecx}"
@@ -420,7 +397,14 @@ async def get_statistics(self, serial_number: str) -> list[dict[str, Any]]:
 
         return await self._rest_api_call(url=url, method=HTTPMethod.GET)
 
-    async def get_daily_statistics(self, serial_number: str, start_date: datetime, end_date: datetime, timezone_offset: int, timezone: str) -> list[dict[str, Any]]:
+    async def get_daily_statistics(
+        self,
+        serial_number: str,
+        start_date: datetime,
+        end_date: datetime,
+        timezone_offset: int,
+        timezone: str,
+    ) -> list[dict[str, Any]]:
         """Get daily statistics from cloud."""
 
         _LOGGER.debug("Getting daily statistics from cloud")

requirements.txt

@@ -1,4 +1,3 @@
 httpx >=0.16.1
-authlib >=0.15.5
 websockets >= 11.0.2
 bleak >= 0.20.2

run.py

@@ -2,34 +2,35 @@
 
 import json
 import asyncio
-
 from pathlib import Path
 
-from lmcloud.client_cloud import LaMarzoccoCloudClient
+
 from lmcloud.lm_device import LaMarzoccoDevice
 from lmcloud.lm_machine import LaMarzoccoMachine
 from lmcloud.const import MachineModel
 from lmcloud.client_bluetooth import LaMarzoccoBluetoothClient
 from lmcloud.client_local import LaMarzoccoLocalClient
 
+from authlib_cloud_client import LaMarzoccoAuthlibCloudClient
+
 
 async def main():
     """Main function."""
     with open(f"{Path(__file__).parent}/secrets.json", encoding="utf-8") as f:
         data = json.load(f)
 
-    cloud_client = LaMarzoccoCloudClient(
+    cloud_client = LaMarzoccoAuthlibCloudClient(
         username=data["username"],
         password=data["password"],
     )
     fleet = await cloud_client.get_customer_fleet()
 
     # serial = list(fleet.keys())[0]
 
-    local_client = LaMarzoccoLocalClient(
-        host=data["host"],
-        local_bearer=data["token"],
-    )
+    # local_client = LaMarzoccoLocalClient(
+    #     host=data["host"],
+    #     local_bearer=data["token"],
+    # )
 
     # bluetooth_devices = await LaMarzoccoBluetoothClient.discover_devices()
     # bluetooth_client = None
@@ -55,11 +56,13 @@ async def main():
         serial_number=data["serial"],
         name=data["serial"],
         cloud_client=cloud_client,
-        local_client=local_client,
+        # local_client=local_client,
         # bluetooth_client=bluetooth_client,
     )
 
-    await machine.websocket_connect()
+    await machine.get_config()
+
+    # await machine.websocket_connect()
     # await asyncio.sleep(300)
 
     # lmcloud = await LMCloud.create_with_local_api(creds, data["host"], data["port"])
@@ -89,9 +92,9 @@ async def main():
     #         print("Brewing")
     #     await asyncio.sleep(1)
 
-    await machine.set_power(True)
-    await asyncio.sleep(5)
-    await machine.set_power(False)
+    # await machine.set_power(True)
+    # await asyncio.sleep(5)
+    # await machine.set_power(False)
 
     # while True:
     #     print("waiting...")

setup.py

@@ -7,7 +7,7 @@
 
 setuptools.setup(
     name="lmcloud",
-    version="1.1.13",
+    version="1.2.0",
     description="A Python implementation of the new La Marzocco API",
     long_description=readme,
     long_description_content_type="text/markdown",
@@ -27,7 +27,6 @@
     packages=setuptools.find_packages(),
     install_requires=[
         "httpx>=0.16.1",
-        "authlib>=0.15.5",
         "websockets>=11.0.2",
         "bleak>=0.20.2",
     ],

tests/conftest.py

@@ -22,6 +22,13 @@
 )
 
 
+class ImplementedLaMarzoccoCloudClient(LaMarzoccoCloudClient):
+    """Implemented La Marzocco Cloud Client."""
+
+    async def async_get_access_token(self) -> str:
+        return "token"
+
+
 def load_fixture(device_type: str, file_name: str) -> dict:
     """Load a fixture."""
     with open(
@@ -32,8 +39,8 @@ def load_fixture(device_type: str, file_name: str) -> dict:
 
 def get_mock_response(*args, **kwargs) -> Response:
     """Get a mock response from HTTP request."""
-    method: HTTPMethod = args[0]
-    url: str = str(args[1])
+    method: HTTPMethod = kwargs["method"]
+    url: str = str(kwargs["url"])
 
     if MACHINE_SERIAL in url:
         device_type = "machine"
@@ -76,13 +83,11 @@ def get_local_machine_mock_response(*args, **kwargs) -> Response:
 def cloud_client() -> Generator[LaMarzoccoCloudClient, None, None]:
     """Fixture for a cloud client."""
 
-    client = LaMarzoccoCloudClient("username", "password")
+    client = AsyncMock()
+    client.request.side_effect = get_mock_response
+    _cloud_client = ImplementedLaMarzoccoCloudClient(client=client)
 
-    oauth_client = AsyncMock()
-    oauth_client.request.side_effect = get_mock_response
-
-    client._oauth_client = oauth_client
-    yield client
+    yield _cloud_client
 
 
 @pytest.fixture

tests/test_machine.py

@@ -107,11 +107,12 @@ async def test_set_power(
         "050b7847-e12b-09a8-b04b-8e0922a9abab",
         b'{"name":"MachineChangeMode","parameter":{"mode":"BrewingMode"}}\x00',
     )
-    cloud_client._oauth_client.request.assert_any_call(  # type: ignore[union-attr]
-        HTTPMethod.POST,
-        "https://gw-lmz.lamarzocco.io/v1/home/machines/GS01234/status",
+    cloud_client._client.request.assert_any_call(  # type: ignore[attr-defined]
+        method=HTTPMethod.POST,
+        url="https://gw-lmz.lamarzocco.io/v1/home/machines/GS01234/status",
         json={"status": "BrewingMode"},
         timeout=5,
+        headers={"Authorization": "Bearer token"},
     )
 
 
@@ -127,11 +128,12 @@ async def test_set_steam(
         "050b7847-e12b-09a8-b04b-8e0922a9abab",
         b'{"name":"SettingBoilerEnable","parameter":{"identifier":"SteamBoiler","state":true}}\x00',
     )
-    cloud_client._oauth_client.request.assert_any_call(  # type: ignore[union-attr]
-        HTTPMethod.POST,
-        "https://gw-lmz.lamarzocco.io/v1/home/machines/GS01234/enable-boiler",
+    cloud_client._client.request.assert_any_call(  # type: ignore[attr-defined]
+        method=HTTPMethod.POST,
+        url="https://gw-lmz.lamarzocco.io/v1/home/machines/GS01234/enable-boiler",
         json={"identifier": "SteamBoiler", "state": True},
         timeout=5,
+        headers={"Authorization": "Bearer token"},
     )
 
 
@@ -147,11 +149,12 @@ async def test_set_temperature(
         "050b7847-e12b-09a8-b04b-8e0922a9abab",
         b'{"name":"SettingBoilerTarget","parameter":{"identifier":"SteamBoiler","value":131}}\x00',
     )
-    cloud_client._oauth_client.request.assert_any_call(  # type: ignore[union-attr]
-        HTTPMethod.POST,
-        "https://gw-lmz.lamarzocco.io/v1/home/machines/GS01234/target-boiler",
+    cloud_client._client.request.assert_any_call(  # type: ignore[attr-defined]
+        method=HTTPMethod.POST,
+        url="https://gw-lmz.lamarzocco.io/v1/home/machines/GS01234/target-boiler",
         json={"identifier": "SteamBoiler", "value": 131},
         timeout=5,
+        headers={"Authorization": "Bearer token"},
     )
 
 
@@ -163,27 +166,29 @@ async def test_set_prebrew_time(cloud_client: LaMarzoccoCloudClient):
 
     assert await machine.set_prebrew_time(1.0, 3.5)
 
-    cloud_client._oauth_client.request.assert_any_call(  # type: ignore[union-attr]
-        HTTPMethod.POST,
-        "https://gw-lmz.lamarzocco.io/v1/home/machines/GS01234/setting-preinfusion",
+    cloud_client._client.request.assert_any_call(  # type: ignore[attr-defined]
+        method=HTTPMethod.POST,
+        url="https://gw-lmz.lamarzocco.io/v1/home/machines/GS01234/setting-preinfusion",
         json={
             "button": "DoseA",
             "group": "Group1",
             "holdTimeMs": 3500,
             "wetTimeMs": 1000,
         },
         timeout=5,
+        headers={"Authorization": "Bearer token"},
     )
 
     assert machine.config.prebrew_configuration[PhysicalKey.A].on_time == 1.0
     assert machine.config.prebrew_configuration[PhysicalKey.A].off_time == 3.5
 
     assert await machine.set_preinfusion_time(4.5)
-    cloud_client._oauth_client.request.assert_any_call(  # type: ignore[union-attr]
-        HTTPMethod.POST,
-        "https://gw-lmz.lamarzocco.io/v1/home/machines/GS01234/setting-preinfusion",
+    cloud_client._client.request.assert_any_call(  # type: ignore[attr-defined]
+        method=HTTPMethod.POST,
+        url="https://gw-lmz.lamarzocco.io/v1/home/machines/GS01234/setting-preinfusion",
         json={"button": "DoseA", "group": "Group1", "holdTimeMs": 4500, "wetTimeMs": 0},
         timeout=5,
+        headers={"Authorization": "Bearer token"},
     )
 
     assert machine.config.prebrew_configuration[PhysicalKey.A].off_time == 4.5