pymiele 0.1.7__tar.gz → 0.3.0__tar.gz

{pymiele-0.1.7 → pymiele-0.3.0}/PKG-INFO

@@ -1,19 +1,18 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: pymiele
-Version: 0.1.7
+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
-License: UNKNOWN
-Platform: UNKNOWN
+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.9
+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
 
@@ -24,5 +23,3 @@ The library is distributed via pypi.org.
 ```bash
 $ pip install pymiele
 ```
-
-

pymiele-0.3.0/pymiele/__init__.py

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

{pymiele-0.1.7 → pymiele-0.3.0}/pymiele/const.py

@@ -1,4 +1,6 @@
-VERSION = "0.1.7"
+"""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-0.3.0/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-0.1.7 → pymiele-0.3.0}/pymiele/pymiele.py

@@ -1,18 +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
 
-import async_timeout
-from aiohttp import ClientError, ClientResponse, ClientSession, ClientTimeout
+from aiohttp import ClientResponse, ClientResponseError, ClientSession, ClientTimeout
 
 from .const import MIELE_API, VERSION
 
@@ -25,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
@@ -34,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
@@ -66,12 +57,54 @@ 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 async_timeout.timeout(10):
+        async with asyncio.timeout(10):
             data = {"targetTemperature": [{"zone": zone, "value": temp}]}
             res = await self.request(
                 "PUT",
@@ -86,11 +119,13 @@ 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)
-        async with async_timeout.timeout(10):
+        async with asyncio.timeout(10):
             res = await self.request(
                 "PUT",
                 f"/devices/{serial}/actions",
@@ -104,11 +139,13 @@ 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)
-        async with async_timeout.timeout(10):
+        async with asyncio.timeout(10):
             res = await self.request(
                 "PUT",
                 f"/devices/{serial}/programs",
@@ -162,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:
@@ -181,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.1.7 → pymiele-0.3.0}/pymiele.egg-info/PKG-INFO

@@ -1,19 +1,18 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: pymiele
-Version: 0.1.7
+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
-License: UNKNOWN
-Platform: UNKNOWN
+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.9
+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
 
@@ -24,5 +23,3 @@ The library is distributed via pypi.org.
 ```bash
 $ pip install pymiele
 ```
-
-

{pymiele-0.1.7 → pymiele-0.3.0}/pymiele.egg-info/SOURCES.txt

@@ -1,9 +1,11 @@
 LICENSE
 README.md
+pyproject.toml
 setup.cfg
-setup.py
 pymiele/__init__.py
 pymiele/const.py
+pymiele/model.py
+pymiele/py.typed
 pymiele/pymiele.py
 pymiele.egg-info/PKG-INFO
 pymiele.egg-info/SOURCES.txt

pymiele-0.3.0/pymiele.egg-info/requires.txt

@@ -0,0 +1 @@
+aiohttp

pymiele-0.3.0/pyproject.toml

@@ -0,0 +1,68 @@
+[build-system]
+requires = ["setuptools>=66.1"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "pymiele"
+license = { text = "MIT" }
+dynamic = ["version"]
+authors = [{ name = "Ake Strandberg", email = "ake@strandberg.eu" }]
+description = "Python library for Miele integration with Home Assistant"
+readme = "README.md"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Operating System :: OS Independent",
+    "Development Status :: 4 - Beta",
+]
+dependencies = ["aiohttp"]
+requires-python = ">=3.12.0"
+
+[project.urls]
+Repository = "https://github.com/astrandb/pymiele"
+
+[tool.setuptools.dynamic]
+version = { attr = "pymiele.const.VERSION" }
+
+[tool.setuptools.packages.find]
+include = ["pymiele*"]
+
+[tool.mypy]
+python_version = "3.13"
+strict = true
+
+[tool.ruff]
+lint.select = [
+    "A",     # builtins shadowing
+    "ANN",   # annotations
+    "ASYNC", # async
+    "B",     # bugbear
+    "C4",    # comprehensions
+    "D",     # pydocstyle
+    "E",     # pycodestyle
+    "F",     # pyflakes
+    "FLY",   # flynt
+    "FURB",  # refurb
+    "G",     # logging
+    "I",     # isort
+    "LOG",   # logging
+    "PTH",   # pathlib
+    "RUF",   # ruff specific
+    "SLF",   # private member access
+    "SIM",   # simplify
+    "T20",   # print
+    "UP",    # pyupgrade
+    "W",     # pydocstyle warning
+]
+lint.ignore = [
+    "ANN401", # any-type
+    "D202",   # blank-line-after-function
+    "D203",   # incorrect-blank-line-before-class
+    "D212",   # multi-line-summary-first-line
+    "E501",   # line too long
+    "SIM102", # collapsible-if
+    "SIM105", # suppressible-exception
+]
+
+[tool.ruff.lint.isort]
+force-sort-within-sections = true
+combine-as-imports = true

pymiele-0.3.0/setup.cfg

@@ -0,0 +1,7 @@
+[bumpversion]
+current_version = 0.3.0
+
+[egg_info]
+tag_build = 
+tag_date = 0
+

pymiele-0.1.7/pymiele/__init__.py

@@ -1,3 +0,0 @@
-"""Library for Miele integration with Home Assistant."""
-from .const import *  # noqa: F401, F403
-from .pymiele import *  # noqa: F401, F403

pymiele-0.1.7/pymiele.egg-info/requires.txt

@@ -1,2 +0,0 @@
-aiohttp
-async_timeout

pymiele-0.1.7/setup.cfg

@@ -1,26 +0,0 @@
-[bumpversion]
-current_version = 0.1.7
-
-[flake8]
-exclude = .venv,.git,.tox,docs,venv,bin,lib,deps,build
-doctests = True
-max-line-length = 88
-ignore = 
-	E501,
-	W503,
-	E203,
-	D202,
-	W504
-
-[isort]
-multi_line_output = 3
-include_trailing_comma = True
-force_grid_wrap = 0
-use_parentheses = True
-ensure_newline_before_comments = True
-line_length = 88
-
-[egg_info]
-tag_build = 
-tag_date = 0
-

pymiele-0.1.7/setup.py

@@ -1,47 +0,0 @@
-import setuptools
-import codecs
-import re
-import os
-
-with open("README.md", "r") as fh:
-    long_description = fh.read()
-
-here = os.path.abspath(os.path.dirname(__file__))
-
-def read(*parts):
-    with codecs.open(os.path.join(here, *parts), 'r') as fp:
-        return fp.read()
-
-def find_version(*file_paths):
-    version_file = read(*file_paths)
-    version_match = re.search(r"^VERSION = ['\"]([^'\"]*)['\"]",
-                              version_file, re.M)
-    if version_match:
-        return version_match.group(1)
-    raise RuntimeError("Unable to find version string.")
-
-
-setuptools.setup(
-    name="pymiele",
-    version=find_version('pymiele', 'const.py'),
-    author="Ake Strandberg",
-    author_email="ake@strandberg.eu",
-    description="Python library for Miele integration with Home Assistant",
-    long_description=long_description,
-    long_description_content_type="text/markdown",
-    url="https://github.com/astrandb/pymiele",
-    # packages=setuptools.find_packages(),
-    packages=["pymiele"],
-    classifiers=[
-        "Programming Language :: Python :: 3",
-        "License :: OSI Approved :: MIT License",
-        "Operating System :: OS Independent",
-    # How mature is this project? Common values are
-    #   3 - Alpha
-    #   4 - Beta
-    #   5 - Production/Stable
-        "Development Status :: 5 - Production/Stable",
-    ],
-    python_requires='>=3.9',
-    install_requires=["aiohttp", "async_timeout",],
-)