pymiele 0.2.0__py3-none-any.whl → 0.3.0__py3-none-any.whl

pymiele/__init__.py

@@ -1,5 +1,6 @@
 """Library for Miele integration with Home Assistant."""
 
-from .const import *  # noqa: F401, F403
+from .const import *  # noqa: F403
 from .const import VERSION as __version__  # noqa: F401
-from .pymiele import *  # noqa: F401, F403
+from .model import *  # noqa: F403
+from .pymiele import *  # noqa: F403

pymiele/const.py

@@ -1,4 +1,6 @@
-VERSION = "0.2.0"
+"""Constants for pymiele."""
+
+VERSION = "0.3.0"
 
 MIELE_API = "https://api.mcs3.miele.com/v1"
 OAUTH2_AUTHORIZE = "https://api.mcs3.miele.com/thirdparty/login"

pymiele/model.py

@@ -0,0 +1,698 @@
+"""Data models for Miele API."""
+# Todo: Move to pymiele when complete and stable
+
+from __future__ import annotations
+
+
+class MieleDevices:
+    """Data for all devices from API."""
+
+    def __init__(self, raw_data: dict) -> None:
+        """Initialize MieleDevices."""
+        self.raw_data = raw_data
+
+    @property
+    def devices(self) -> list[str]:
+        """Return list of all devices."""
+
+        return list(self.raw_data.keys())
+
+
+class MieleDevice:
+    """Data for a single device from API."""
+
+    def __init__(self, raw_data: dict) -> None:
+        """Initialize MieleDevice."""
+        self.raw_data = raw_data
+
+    @property
+    def raw(self) -> dict:
+        """Return raw data."""
+        return self.raw_data
+
+    @property
+    def fab_number(self) -> str:
+        """Return the ID of the device."""
+        return str(self.raw_data["ident"]["deviceIdentLabel"]["fabNumber"])
+
+    @property
+    def device_type(self) -> int:
+        """Return the type of the device."""
+        return self.raw_data["ident"]["type"]["value_raw"]
+
+    @property
+    def device_type_localized(self) -> int:
+        """Return the type of the device."""
+        return self.raw_data["ident"]["type"]["value_localized"]
+
+    @property
+    def device_name(self) -> str:
+        """Return the name of the device."""
+        return self.raw_data["ident"]["deviceName"]
+
+    @property
+    def tech_type(self) -> str:
+        """Return the tech type of the device."""
+        return self.raw_data["ident"]["deviceIdentLabel"]["techType"]
+
+    @property
+    def xkm_tech_type(self) -> str:
+        """Return the xkm tech type of the device."""
+        return self.raw_data["ident"]["xkmIdentLabel"]["techType"]
+
+    @property
+    def xkm_release_version(self) -> str:
+        """Return the xkm release version of the device."""
+        return self.raw_data["ident"]["xkmIdentLabel"]["releaseVersion"]
+
+    @property
+    def state_program_id(self) -> int:
+        """Return the program ID of the device."""
+        return self.raw_data["state"]["ProgramID"]["value_raw"]
+
+    @property
+    def state_status(self) -> int:
+        """Return the status of the device."""
+        return self.raw_data["state"]["status"]["value_raw"]
+
+    @property
+    def state_program_type(self) -> int:
+        """Return the program type of the device."""
+        return self.raw_data["state"]["programType"]["value_raw"]
+
+    @property
+    def state_program_phase(self) -> int:
+        """Return the program phase of the device."""
+        return self.raw_data["state"]["programPhase"]["value_raw"]
+
+    @property
+    def state_remaining_time(self) -> list[int]:
+        """Return the remaining time of the device."""
+        return self.raw_data["state"]["remainingTime"]
+
+    @property
+    def state_start_time(self) -> list[int]:
+        """Return the start time of the device."""
+        return self.raw_data["state"]["startTime"]
+
+    @property
+    def state_target_temperature(self) -> list[dict]:
+        """Return the target temperature of the device."""
+        return self.raw_data["state"]["targetTemperature"]
+
+    @property
+    def state_core_target_temperature(self) -> list[dict]:
+        """Return the core target temperature of the device."""
+        return self.raw_data["state"]["coreTargetTemperature"]
+
+    @property
+    def state_temperature(self) -> list[int]:
+        """Return the temperature of the device."""
+        return [temp["value_raw"] for temp in self.raw_data["state"]["temperature"]]
+
+    @property
+    def state_temperature_1(self) -> int:
+        """Return the temperature in zone 1 of the device."""
+        return self.raw_data["state"]["temperature"][0]["value_raw"]
+
+    @property
+    def state_temperature_2(self) -> int:
+        """Return the temperature in zone 2 of the device."""
+        return self.raw_data["state"]["temperature"][1]["value_raw"]
+
+    @property
+    def state_temperature_3(self) -> int:
+        """Return the temperature in zone 3 of the device."""
+        return self.raw_data["state"]["temperature"][2]["value_raw"]
+
+    @property
+    def state_core_temperature(self) -> list[dict]:
+        """Return the core temperature of the device."""
+        return self.raw_data["state"]["coreTemperature"]
+
+    @property
+    def state_core_temperature_1(self) -> list[dict]:
+        """Return the core temperature in zone 1 of the device."""
+        return self.raw_data["state"]["coreTemperature"][0]["value_raw"]
+
+    @property
+    def state_core_temperature_2(self) -> list[dict]:
+        """Return the core temperature in zone 2 of the device."""
+        return self.raw_data["state"]["coreTemperature"][1]["value_raw"]
+
+    @property
+    def state_signal_info(self) -> bool:
+        """Return the signal info of the device."""
+        return self.raw_data["state"]["signalInfo"]
+
+    @property
+    def state_signal_failure(self) -> bool:
+        """Return the signal failure of the device."""
+        return self.raw_data["state"]["signalFailure"]
+
+    @property
+    def state_signal_door(self) -> bool:
+        """Return the signal door of the device."""
+        return self.raw_data["state"]["signalDoor"]
+
+    @property
+    def state_full_remote_control(self) -> bool:
+        """Return the remote control enable of the device."""
+        return self.raw_data["state"]["remoteEnable"]["fullRemoteControl"]
+
+    @property
+    def state_smart_grid(self) -> bool:
+        """Return the smart grid of the device."""
+        return self.raw_data["state"]["remoteEnable"]["smartGrid"]
+
+    @property
+    def state_mobile_start(self) -> bool:
+        """Return the mobile start of the device."""
+        return self.raw_data["state"]["remoteEnable"]["mobileStart"]
+
+    @property
+    def state_ambient_light(self) -> bool:
+        """Return the ambient light of the device."""
+        return self.raw_data["state"]["ambientLight"]
+
+    @property
+    def state_light(self) -> bool:
+        """Return the light of the device."""
+        return self.raw_data["state"]["light"]
+
+    @property
+    def state_elapsed_time(self) -> list[int]:
+        """Return the elapsed time of the device."""
+        return self.raw_data["state"]["elapsedTime"]
+
+    @property
+    def state_spinning_speed(self) -> int | None:
+        """Return the spinning speed of the device."""
+        return self.raw_data["state"]["spinningSpeed"]
+
+    @property
+    def state_drying_step(self) -> int | None:
+        """Return the drying step of the device."""
+        return self.raw_data["state"]["dryingStep"]
+
+    @property
+    def state_ventilation_step(self) -> int | None:
+        """Return the ventilation step of the device."""
+        return self.raw_data["state"]["ventilationStep"]
+
+    @property
+    def state_plate_step(self) -> list[dict]:
+        """Return the plate step of the device."""
+        return self.raw_data["state"]["plateStep"]
+
+    @property
+    def state_eco_feedback(self) -> dict | None:
+        """Return the eco feedback of the device."""
+        return self.raw_data["state"]["ecoFeedback"]
+
+    @property
+    def state_battery_level(self) -> int | None:
+        """Return the battery level of the device."""
+        return self.raw_data["state"]["batteryLevel"]
+
+
+class MieleAction:
+    """Actions for Miele devices."""
+
+    def __init__(self, raw_data: dict) -> None:
+        """Initialize MieleAction."""
+        self.raw_data = raw_data
+
+    # Todo : Add process actions
+    @property
+    def raw(self) -> dict:
+        """Return raw data."""
+        return self.raw_data
+
+    @property
+    def actions(self) -> list[str]:
+        """Return list of all actions."""
+        return list(self.raw_data.keys())
+
+    @property
+    def modes(self) -> list[int]:
+        """Return list of modes."""
+        return list(self.raw_data["modes"])
+
+    @property
+    def process_actions(self) -> list[int]:
+        """Return list of process actions."""
+        return list(self.raw_data["processAction"])
+
+    @property
+    def light(self) -> list[int]:
+        """Return list of light actions."""
+        return list(self.raw_data["light"])
+
+    @property
+    def ambient_light(self) -> list[int]:
+        """Return list of ambient light actions."""
+        return list(self.raw_data["ambientLight"])
+
+    @property
+    def start_time(self) -> list[int]:
+        """Return list of start time actions."""
+        return list(self.raw_data["start_time"])
+
+    @property
+    def ventilation_setp(self) -> list[int]:
+        """Return list of ventilation step actions."""
+        return list(self.raw_data["ventilationStep"])
+
+    @property
+    def program_id(self) -> list[int]:
+        """Return list of program id actions."""
+        return list(self.raw_data["programId"])
+
+    @property
+    def runOnTime(self) -> list[int]:
+        """Return list of run on time actions."""
+        return list(self.raw_data["runOnTime"])
+
+    @property
+    def target_temperature(self) -> list[dict]:
+        """Return list of target temperature actions."""
+        return list(self.raw_data["targetTemperature"])
+
+    @property
+    def power_on_enabled(self) -> bool:
+        """Return powerOn enabled."""
+        return self.raw_data["powerOn"]
+
+    @property
+    def power_off_enabled(self) -> bool:
+        """Return powerOff enabled."""
+        return self.raw_data["powerOff"]
+
+    @property
+    def device_name_enabled(self) -> bool:
+        """Return deviceName enabled."""
+        return self.raw_data["deviceName"]
+
+
+# Todo: Remove reference data
+# TEST_DATA = """
+#     {    "711934968": {
+#         "ident": {
+#         "type": {
+#             "key_localized": "Device type",
+#             "value_raw": 20,
+#             "value_localized": "Freezer"
+#         },
+#         "deviceName": "",
+#         "protocolVersion": 201,
+#         "deviceIdentLabel": {
+#             "fabNumber": "711934968",
+#             "fabIndex": "21",
+#             "techType": "FNS 28463 E ed/",
+#             "matNumber": "10805070",
+#             "swids": [
+#             "4497"
+#             ]
+#         },
+#         "xkmIdentLabel": {
+#             "techType": "EK042",
+#             "releaseVersion": "31.17"
+#         }
+#         },
+#         "state": {
+#         "ProgramID": {
+#             "value_raw": 0,
+#             "value_localized": "",
+#             "key_localized": "Program name"
+#         },
+#         "status": {
+#             "value_raw": 5,
+#             "value_localized": "In use",
+#             "key_localized": "status"
+#         },
+#         "programType": {
+#             "value_raw": 0,
+#             "value_localized": "",
+#             "key_localized": "Program type"
+#         },
+#         "programPhase": {
+#             "value_raw": 0,
+#             "value_localized": "",
+#             "key_localized": "Program phase"
+#         },
+#         "remainingTime": [
+#             0,
+#             0
+#         ],
+#         "startTime": [
+#             0,
+#             0
+#         ],
+#         "targetTemperature": [
+#             {
+#             "value_raw": -1800,
+#             "value_localized": -18,
+#             "unit": "Celsius"
+#             },
+#             {
+#             "value_raw": -32768,
+#             "value_localized": null,
+#             "unit": "Celsius"
+#             },
+#             {
+#             "value_raw": -32768,
+#             "value_localized": null,
+#             "unit": "Celsius"
+#             }
+#         ],
+#         "coreTargetTemperature": [],
+#         "temperature": [
+#             {
+#             "value_raw": -1800,
+#             "value_localized": -18,
+#             "unit": "Celsius"
+#             },
+#             {
+#             "value_raw": -32768,
+#             "value_localized": null,
+#             "unit": "Celsius"
+#             },
+#             {
+#             "value_raw": -32768,
+#             "value_localized": null,
+#             "unit": "Celsius"
+#             }
+#         ],
+#         "coreTemperature": [],
+#         "signalInfo": false,
+#         "signalFailure": false,
+#         "signalDoor": false,
+#         "remoteEnable": {
+#             "fullRemoteControl": true,
+#             "smartGrid": false,
+#             "mobileStart": false
+#         },
+#         "ambientLight": null,
+#         "light": null,
+#         "elapsedTime": [],
+#         "spinningSpeed": {
+#             "unit": "rpm",
+#             "value_raw": null,
+#             "value_localized": null,
+#             "key_localized": "Spin speed"
+#         },
+#         "dryingStep": {
+#             "value_raw": null,
+#             "value_localized": "",
+#             "key_localized": "Drying level"
+#         },
+#         "ventilationStep": {
+#             "value_raw": null,
+#             "value_localized": "",
+#             "key_localized": "Fan level"
+#         },
+#         "plateStep": [],
+#         "ecoFeedback": null,
+#         "batteryLevel": null
+#         }
+#     },
+#     "711944869": {
+#         "ident": {
+#         "type": {
+#             "key_localized": "Device type",
+#             "value_raw": 19,
+#             "value_localized": "Refrigerator"
+#         },
+#         "deviceName": "",
+#         "protocolVersion": 201,
+#         "deviceIdentLabel": {
+#             "fabNumber": "711944869",
+#             "fabIndex": "17",
+#             "techType": "KS 28423 D ed/c",
+#             "matNumber": "10804770",
+#             "swids": [
+#             "4497"
+#             ]
+#         },
+#         "xkmIdentLabel": {
+#             "techType": "EK042",
+#             "releaseVersion": "31.17"
+#         }
+#         },
+#         "state": {
+#         "ProgramID": {
+#             "value_raw": 0,
+#             "value_localized": "",
+#             "key_localized": "Program name"
+#         },
+#         "status": {
+#             "value_raw": 5,
+#             "value_localized": "In use",
+#             "key_localized": "status"
+#         },
+#         "programType": {
+#             "value_raw": 0,
+#             "value_localized": "",
+#             "key_localized": "Program type"
+#         },
+#         "programPhase": {
+#             "value_raw": 0,
+#             "value_localized": "",
+#             "key_localized": "Program phase"
+#         },
+#         "remainingTime": [
+#             0,
+#             0
+#         ],
+#         "startTime": [
+#             0,
+#             0
+#         ],
+#         "targetTemperature": [
+#             {
+#             "value_raw": 400,
+#             "value_localized": 4,
+#             "unit": "Celsius"
+#             },
+#             {
+#             "value_raw": -32768,
+#             "value_localized": null,
+#             "unit": "Celsius"
+#             },
+#             {
+#             "value_raw": -32768,
+#             "value_localized": null,
+#             "unit": "Celsius"
+#             }
+#         ],
+#         "coreTargetTemperature": [],
+#         "temperature": [
+#             {
+#             "value_raw": 400,
+#             "value_localized": 4,
+#             "unit": "Celsius"
+#             },
+#             {
+#             "value_raw": -32768,
+#             "value_localized": null,
+#             "unit": "Celsius"
+#             },
+#             {
+#             "value_raw": -32768,
+#             "value_localized": null,
+#             "unit": "Celsius"
+#             }
+#         ],
+#         "coreTemperature": [],
+#         "signalInfo": false,
+#         "signalFailure": false,
+#         "signalDoor": false,
+#         "remoteEnable": {
+#             "fullRemoteControl": true,
+#             "smartGrid": false,
+#             "mobileStart": false
+#         },
+#         "ambientLight": null,
+#         "light": null,
+#         "elapsedTime": [],
+#         "spinningSpeed": {
+#             "unit": "rpm",
+#             "value_raw": null,
+#             "value_localized": null,
+#             "key_localized": "Spin speed"
+#         },
+#         "dryingStep": {
+#             "value_raw": null,
+#             "value_localized": "",
+#             "key_localized": "Drying level"
+#         },
+#         "ventilationStep": {
+#             "value_raw": null,
+#             "value_localized": "",
+#             "key_localized": "Fan level"
+#         },
+#         "plateStep": [],
+#         "ecoFeedback": null,
+#         "batteryLevel": null
+#         }
+#     },
+#     "000186528088": {
+#         "ident": {
+#         "type": {
+#             "key_localized": "Device type",
+#             "value_raw": 1,
+#             "value_localized": "Washing machine"
+#         },
+#         "deviceName": "",
+#         "protocolVersion": 4,
+#         "deviceIdentLabel": {
+#             "fabNumber": "000186528088",
+#             "fabIndex": "44",
+#             "techType": "WCI870",
+#             "matNumber": "11387290",
+#             "swids": [
+#             "5975",
+#             "20456",
+#             "25213",
+#             "25191",
+#             "25446",
+#             "25205",
+#             "25447",
+#             "25319"
+#             ]
+#         },
+#         "xkmIdentLabel": {
+#             "techType": "EK057",
+#             "releaseVersion": "08.32"
+#         }
+#         },
+#         "state": {
+#         "ProgramID": {
+#             "value_raw": 0,
+#             "value_localized": "",
+#             "key_localized": "Program name"
+#         },
+#         "status": {
+#             "value_raw": 1,
+#             "value_localized": "Off",
+#             "key_localized": "status"
+#         },
+#         "programType": {
+#             "value_raw": 0,
+#             "value_localized": "",
+#             "key_localized": "Program type"
+#         },
+#         "programPhase": {
+#             "value_raw": 0,
+#             "value_localized": "",
+#             "key_localized": "Program phase"
+#         },
+#         "remainingTime": [
+#             0,
+#             0
+#         ],
+#         "startTime": [
+#             0,
+#             0
+#         ],
+#         "targetTemperature": [
+#             {
+#             "value_raw": -32768,
+#             "value_localized": null,
+#             "unit": "Celsius"
+#             },
+#             {
+#             "value_raw": -32768,
+#             "value_localized": null,
+#             "unit": "Celsius"
+#             },
+#             {
+#             "value_raw": -32768,
+#             "value_localized": null,
+#             "unit": "Celsius"
+#             }
+#         ],
+#         "coreTargetTemperature": [
+#             {
+#             "value_raw": -32768,
+#             "value_localized": null,
+#             "unit": "Celsius"
+#             }
+#         ],
+#         "temperature": [
+#             {
+#             "value_raw": -32768,
+#             "value_localized": null,
+#             "unit": "Celsius"
+#             },
+#             {
+#             "value_raw": -32768,
+#             "value_localized": null,
+#             "unit": "Celsius"
+#             },
+#             {
+#             "value_raw": -32768,
+#             "value_localized": null,
+#             "unit": "Celsius"
+#             }
+#         ],
+#         "coreTemperature": [
+#             {
+#             "value_raw": -32768,
+#             "value_localized": null,
+#             "unit": "Celsius"
+#             }
+#         ],
+#         "signalInfo": false,
+#         "signalFailure": false,
+#         "signalDoor": true,
+#         "remoteEnable": {
+#             "fullRemoteControl": true,
+#             "smartGrid": false,
+#             "mobileStart": false
+#         },
+#         "ambientLight": null,
+#         "light": null,
+#         "elapsedTime": [
+#             0,
+#             0
+#         ],
+#         "spinningSpeed": {
+#             "unit": "rpm",
+#             "value_raw": null,
+#             "value_localized": null,
+#             "key_localized": "Spin speed"
+#         },
+#         "dryingStep": {
+#             "value_raw": null,
+#             "value_localized": "",
+#             "key_localized": "Drying level"
+#         },
+#         "ventilationStep": {
+#             "value_raw": null,
+#             "value_localized": "",
+#             "key_localized": "Fan level"
+#         },
+#         "plateStep": [],
+#         "ecoFeedback": null,
+#         "batteryLevel": null
+#         }
+#     }
+#     }
+# """
+
+# raw = json.loads(TEST_DATA)
+
+# data = MieleDevices(raw)
+# print(data.devices)
+# print(data.raw_data[data.devices[0]])
+
+# machine = MieleDevice(data.raw_data[data.devices[0]])
+# print(machine.fab_number)
+# print(machine.device_type)
+# print(machine.device_name)
+# print(machine.tech_type)
+# print(machine.xkm_tech_type)
+# print(machine.xkm_release_version)
+# print(machine.state_program_id)

pymiele/pymiele.py

@@ -1,17 +1,16 @@
 """Library for Miele API."""
 
-# TODO
-# Should be moved to pypi.org when reasonably stable
 from __future__ import annotations
 
+from abc import ABC, abstractmethod
 import asyncio
+from collections.abc import Callable, Coroutine
 import json
-import logging
-from abc import ABC, abstractmethod
 from json.decoder import JSONDecodeError
-from typing import Any, Callable, Coroutine
+import logging
+from typing import Any
 
-from aiohttp import ClientError, ClientResponse, ClientSession, ClientTimeout
+from aiohttp import ClientResponse, ClientResponseError, ClientSession, ClientTimeout
 
 from .const import MIELE_API, VERSION
 
@@ -24,7 +23,7 @@ _LOGGER = logging.getLogger(__name__)
 class AbstractAuth(ABC):
     """Abstract class to make authenticated requests."""
 
-    def __init__(self, websession: ClientSession, host: str):
+    def __init__(self, websession: ClientSession, host: str) -> None:
         """Initialize the auth."""
         self.websession = websession
         self.host = host
@@ -33,19 +32,12 @@ class AbstractAuth(ABC):
     async def async_get_access_token(self) -> str:
         """Return a valid access token."""
 
-    async def request(self, method, url, **kwargs) -> ClientResponse:
+    async def request(self, method: str, url: str, **kwargs: Any) -> ClientResponse:
         """Make a request."""
-        headers = kwargs.get("headers")
-
-        if headers is None:
-            headers = {}
-        else:
+        if headers := kwargs.pop("headers", {}):
             headers = dict(headers)
-            kwargs.pop("headers")
 
-        agent_suffix = kwargs.get("agent_suffix")
-        if "agent_suffix" in kwargs:
-            kwargs.pop("agent_suffix")
+        agent_suffix = kwargs.pop("agent_suffix", None)
         user_agent = (
             USER_AGENT_BASE
             if agent_suffix is None
@@ -65,9 +57,51 @@ class AbstractAuth(ABC):
             headers=headers,
         )
 
+    async def get_devices(self) -> dict:
+        """Get all devices."""
+        async with asyncio.timeout(10):
+            res = await self.request(
+                "GET", "/devices", headers={"Accept": "application/json"}
+            )
+            res.raise_for_status()
+        return await res.json()
+
+    async def get_actions(self, serial: str) -> dict:
+        """Get actions for a device."""
+        async with asyncio.timeout(10):
+            res = await self.request(
+                "GET",
+                f"/devices/{serial}/actions",
+                headers={"Accept": "application/json"},
+            )
+            res.raise_for_status()
+        return await res.json()
+
+    async def get_programs(self, serial: str) -> dict:
+        """Get programs for a device."""
+        async with asyncio.timeout(10):
+            res = await self.request(
+                "GET",
+                f"/devices/{serial}/programs",
+                headers={"Accept": "application/json"},
+            )
+            res.raise_for_status()
+        return await res.json()
+
+    async def get_rooms(self, serial: str) -> dict:
+        """Get rooms for a device."""
+        async with asyncio.timeout(10):
+            res = await self.request(
+                "GET",
+                f"/devices/{serial}/rooms",
+                headers={"Accept": "application/json"},
+            )
+            res.raise_for_status()
+        return await res.json()
+
     async def set_target_temperature(
         self, serial: str, temperature: float, zone: int = 1
-    ):
+    ) -> ClientResponse:
         """Set target temperature."""
         temp = round(temperature)
         async with asyncio.timeout(10):
@@ -85,7 +119,9 @@ class AbstractAuth(ABC):
         _LOGGER.debug("set_target res: %s", res.status)
         return res
 
-    async def send_action(self, serial: str, data):
+    async def send_action(
+        self, serial: str, data: dict[str, str | int | bool]
+    ) -> ClientResponse:
         """Send action command."""
 
         _LOGGER.debug("send_action serial: %s, data: %s", serial, data)
@@ -103,7 +139,9 @@ class AbstractAuth(ABC):
         _LOGGER.debug("send_action res: %s", res.status)
         return res
 
-    async def set_program(self, serial: str, data):
+    async def set_program(
+        self, serial: str, data: dict[str, int | list[int]]
+    ) -> ClientResponse:
         """Send start program command."""
 
         _LOGGER.debug("set_program serial: %s, data: %s", serial, data)
@@ -161,18 +199,18 @@ class AbstractAuth(ABC):
                         if event_type == "event: devices":
                             data = json.loads(data_line[6:])
                             if data_callback is not None:
-                                asyncio.create_task(data_callback(data))
+                                asyncio.create_task(data_callback(data))  # noqa: RUF006
                         elif event_type == "event: actions":
                             data = json.loads(data_line[6:])
                             if actions_callback is not None:
-                                asyncio.create_task(actions_callback(data))
+                                asyncio.create_task(actions_callback(data))  # noqa: RUF006
                         elif event_type == "event: ping":
                             # _LOGGER.debug("Ping SSE")
                             pass
                         else:
                             _LOGGER.error("Unknown event type: %s", event_type)
 
-            except ClientError as ex:
+            except ClientResponseError as ex:
                 _LOGGER.error("SSE: %s - %s", ex.status, ex.message)
                 await asyncio.sleep(5)
             except JSONDecodeError as ex:
@@ -180,8 +218,8 @@ class AbstractAuth(ABC):
                     "JSON decode error: %s, Pos: %s, Doc: %s", ex.msg, ex.pos, ex.doc
                 )
                 await asyncio.sleep(5)
-            except Exception as ex:
-                _LOGGER.error("Listen_event: %s - %s", ex.status, ex.message)
+            except Exception as ex:  # pylint: disable=broad-except
+                _LOGGER.error("Listen_event: %s", ex)
                 await asyncio.sleep(5)
 
 

{pymiele-0.2.0.dist-info → pymiele-0.3.0.dist-info}/METADATA

@@ -1,18 +1,18 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: pymiele
-Version: 0.2.0
+Version: 0.3.0
 Summary: Python library for Miele integration with Home Assistant
-Home-page: https://github.com/astrandb/pymiele
-Author: Ake Strandberg
-Author-email: ake@strandberg.eu
+Author-email: Ake Strandberg <ake@strandberg.eu>
+License: MIT
+Project-URL: Repository, https://github.com/astrandb/pymiele
 Classifier: Programming Language :: Python :: 3
-Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
-Classifier: Development Status :: 5 - Production/Stable
-Requires-Python: >=3.12
+Classifier: Development Status :: 4 - Beta
+Requires-Python: >=3.12.0
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: aiohttp
+Dynamic: license-file
 
 ## pymiele
 

pymiele-0.3.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+pymiele/__init__.py,sha256=w_JvyaBHVGM7eo-FFwIWFbQUeAowoA_fbnAfCWJFGek,221
+pymiele/const.py,sha256=SD-qXopiDyTfVk4SGzsjtyIZ_ljsd_IkBICDJyDxAww,219
+pymiele/model.py,sha256=APWDLqc7TGEAc5QkRtEpJj84cvSVwSIpHYJJDSNBTO8,20458
+pymiele/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pymiele/pymiele.py,sha256=3edghDZLPDg4KBV7AVTUGNeeyDPAAegyzRfBG9pFgeU,8647
+pymiele-0.3.0.dist-info/licenses/LICENSE,sha256=scGm4_U2pd-rsGa6Edf6zsXFebrMT4RoyQz7-904_Wg,1072
+pymiele-0.3.0.dist-info/METADATA,sha256=7VXYWAqBrBMWjvhxN1J7r3sYpqBanVlPLeMqnsb1-eU,675
+pymiele-0.3.0.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+pymiele-0.3.0.dist-info/top_level.txt,sha256=BwkHrSO2w_Bfxh6s8Ikcao5enEuQOpQhJ3SwUXBqY10,8
+pymiele-0.3.0.dist-info/RECORD,,

{pymiele-0.2.0.dist-info → pymiele-0.3.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.4.0)
+Generator: setuptools (78.1.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

pymiele-0.2.0.dist-info/RECORD

@@ -1,8 +0,0 @@
-pymiele/__init__.py,sha256=ktGXAWddn6Rz8-Drh1ka6SPj3b3lIhlZ4015K1Hin04,198
-pymiele/const.py,sha256=jmbdbXIq_MkL9naquxpShmqAXKZzswZQEf5zV2mZLbk,189
-pymiele/pymiele.py,sha256=z7iD6uQZ8Z7paBs5XgvB6k6jkFo0cSB7ZYAUqPL7ECk,7185
-pymiele-0.2.0.dist-info/LICENSE,sha256=scGm4_U2pd-rsGa6Edf6zsXFebrMT4RoyQz7-904_Wg,1072
-pymiele-0.2.0.dist-info/METADATA,sha256=uDied5T_kAmplJefJRBcxqV00QdgI-ZmK0ciknra9dA,694
-pymiele-0.2.0.dist-info/WHEEL,sha256=a7TGlA-5DaHMRrarXjVbQagU3Man_dCnGIWMJr5kRWo,91
-pymiele-0.2.0.dist-info/top_level.txt,sha256=BwkHrSO2w_Bfxh6s8Ikcao5enEuQOpQhJ3SwUXBqY10,8
-pymiele-0.2.0.dist-info/RECORD,,