pymiele 0.3.1__py3-none-any.whl → 0.3.2__py3-none-any.whl

pymiele/const.py

@@ -1,7 +1,9 @@
 """Constants for pymiele."""
 
-VERSION = "0.3.1"
+VERSION = "0.3.2"
 
 MIELE_API = "https://api.mcs3.miele.com/v1"
 OAUTH2_AUTHORIZE = "https://api.mcs3.miele.com/thirdparty/login"
 OAUTH2_TOKEN = "https://api.mcs3.miele.com/thirdparty/token"
+
+AIO_TIMEOUT = 15

pymiele/model.py

@@ -1,5 +1,4 @@
 """Data models for Miele API."""
-# Todo: Move to pymiele when complete and stable
 
 from __future__ import annotations
 
@@ -18,6 +17,52 @@ class MieleDevices:
         return list(self.raw_data.keys())
 
 
+class MieleTemperature:
+    """A model of temperature data."""
+
+    def __init__(self, raw_data: dict) -> None:
+        """Initialize MieleTemperature."""
+        self.raw_data = raw_data
+
+    @property
+    def raw(self) -> dict:
+        """Return raw data."""
+        return self.raw_data
+
+    @property
+    def temperature(self) -> int | None:
+        """Return temperature object."""
+        return self.raw_data["value_raw"]
+
+
+class MieleActionTargetTemperature:
+    """A model of target temperature data."""
+
+    def __init__(self, raw_data: dict) -> None:
+        """Initialize MieleActionTargetTemperature."""
+        self.raw_data = raw_data
+
+    @property
+    def raw(self) -> dict:
+        """Return raw data."""
+        return self.raw_data
+
+    @property
+    def zone(self) -> int | None:
+        """Return zone value."""
+        return self.raw_data["zone"]
+
+    @property
+    def min(self) -> int | None:
+        """Return min value."""
+        return self.raw_data["min"]
+
+    @property
+    def max(self) -> int | None:
+        """Return max value."""
+        return self.raw_data["max"]
+
+
 class MieleDevice:
     """Data for a single device from API."""
 
@@ -96,49 +141,35 @@ class MieleDevice:
         return self.raw_data["state"]["startTime"]
 
     @property
-    def state_target_temperature(self) -> list[dict]:
+    def state_target_temperature(self) -> list[MieleTemperature]:
         """Return the target temperature of the device."""
-        return self.raw_data["state"]["targetTemperature"]
+        return [
+            MieleTemperature(temp)
+            for temp in 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"]
+        return [
+            MieleTemperature(temp)
+            for temp in self.raw_data["state"]["coretargetTemperature"]
+        ]
 
     @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"]
+    def state_temperatures(self) -> list[MieleTemperature]:
+        """Return list of all temperatures."""
 
-    @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"]
+        return [
+            MieleTemperature(temp) for temp in self.raw_data["state"]["temperature"]
+        ]
 
     @property
-    def state_core_temperature(self) -> list[dict]:
+    def state_core_temperature(self) -> list[MieleTemperature]:
         """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"]
+        return [
+            MieleTemperature(temp) for temp in self.raw_data["state"]["coreTemperature"]
+        ]
 
     @property
     def state_signal_info(self) -> bool:
@@ -171,15 +202,25 @@ class MieleDevice:
         return self.raw_data["state"]["remoteEnable"]["mobileStart"]
 
     @property
-    def state_ambient_light(self) -> bool:
+    def state_ambient_light(self) -> int:
         """Return the ambient light of the device."""
         return self.raw_data["state"]["ambientLight"]
 
+    @state_ambient_light.setter
+    def state_ambient_light(self, new_value: bool) -> None:
+        """Set the ambient light state."""
+        self.raw_data["state"]["ambientLight"] = new_value
+
     @property
-    def state_light(self) -> bool:
+    def state_light(self) -> int:
         """Return the light of the device."""
         return self.raw_data["state"]["light"]
 
+    @state_light.setter
+    def state_light(self, new_value: int) -> None:
+        """Set the light state."""
+        self.raw_data["state"]["light"] = new_value
+
     @property
     def state_elapsed_time(self) -> list[int]:
         """Return the elapsed time of the device."""
@@ -188,17 +229,27 @@ class MieleDevice:
     @property
     def state_spinning_speed(self) -> int | None:
         """Return the spinning speed of the device."""
-        return self.raw_data["state"]["spinningSpeed"]
+        return self.raw_data["state"]["spinningSpeed"]["value_raw"]
 
     @property
     def state_drying_step(self) -> int | None:
         """Return the drying step of the device."""
-        return self.raw_data["state"]["dryingStep"]
+        return self.raw_data["state"]["dryingStep"]["value_raw"]
+
+    @state_drying_step.setter
+    def state_drying_step(self, new_value: int) -> None:
+        """Set the drying state."""
+        self.raw_data["state"]["dryingStep"]["value_raw"] = new_value
 
     @property
     def state_ventilation_step(self) -> int | None:
         """Return the ventilation step of the device."""
-        return self.raw_data["state"]["ventilationStep"]
+        return self.raw_data["state"]["ventilationStep"]["value_raw"]
+
+    @state_ventilation_step.setter
+    def state_ventilation_step(self, new_value: int) -> None:
+        """Set the ventilation state."""
+        self.raw_data["state"]["ventilationStep"]["value_raw"] = new_value
 
     @property
     def state_plate_step(self) -> list[dict]:
@@ -210,6 +261,38 @@ class MieleDevice:
         """Return the eco feedback of the device."""
         return self.raw_data["state"]["ecoFeedback"]
 
+    @property
+    def current_water_consumption(self) -> float | None:
+        """Return the current water consumption of the device."""
+        if self.state_eco_feedback is None:
+            return None
+        return self.raw_data["state"]["ecoFeedback"].get("currentWaterConsumption")[
+            "value"
+        ]
+
+    @property
+    def current_energy_consumption(self) -> float | None:
+        """Return the current energy consumption of the device."""
+        if self.state_eco_feedback is None:
+            return None
+        return self.raw_data["state"]["ecoFeedback"]["currentEnergyConsumption"][
+            "value"
+        ]
+
+    @property
+    def water_forecast(self) -> float | None:
+        """Return the water forecast of the device."""
+        if self.state_eco_feedback is None:
+            return None
+        return self.raw_data["state"]["ecoFeedback"].get("waterForecast")
+
+    @property
+    def energy_forecast(self) -> float | None:
+        """Return the energy forecast of the device."""
+        if self.state_eco_feedback is None:
+            return None
+        return self.raw_data["state"]["ecoFeedback"].get("energyForecast")
+
     @property
     def state_battery_level(self) -> int | None:
         """Return the battery level of the device."""
@@ -223,7 +306,6 @@ class MieleAction:
         """Initialize MieleAction."""
         self.raw_data = raw_data
 
-    # Todo : Add process actions
     @property
     def raw(self) -> dict:
         """Return raw data."""
@@ -277,19 +359,113 @@ class MieleAction:
     @property
     def target_temperature(self) -> list[dict]:
         """Return list of target temperature actions."""
-        return list(self.raw_data["targetTemperature"])
+        return [
+            MieleActionTargetTemperature(temp)
+            for temp in self.raw_data["state"]["targetTemperature"]
+        ]
 
     @property
     def power_on_enabled(self) -> bool:
         """Return powerOn enabled."""
         return self.raw_data["powerOn"]
 
+    @power_on_enabled.setter
+    def power_on_enabled(self, value: bool) -> None:
+        """Return powerOn enabled."""
+        self.raw_data["powerOn"] = value
+
     @property
     def power_off_enabled(self) -> bool:
         """Return powerOff enabled."""
         return self.raw_data["powerOff"]
 
+    @power_off_enabled.setter
+    def power_off_enabled(self, value: bool) -> None:
+        """Return powerOff enabled."""
+        self.raw_data["powerOff"] = value
+
     @property
     def device_name_enabled(self) -> bool:
         """Return deviceName enabled."""
         return self.raw_data["deviceName"]
+
+
+class MieleProgramsAvailable:
+    """Model for available programs."""
+
+    def __init__(self, raw_data: dict) -> None:
+        """Initialize MieleProgramsAvailable."""
+        self.raw_data = raw_data
+
+    @property
+    def programs(self) -> list[MieleProgramAvailable]:
+        """Return list of all available programs."""
+        return [MieleProgramAvailable(program) for program in self.raw_data]
+
+
+class MieleProgramAvailable:
+    """Model for available programs."""
+
+    def __init__(self, raw_data: dict) -> None:
+        """Initialize MieleProgramAvailable."""
+        self.raw_data = raw_data
+
+    @property
+    def raw(self) -> dict:
+        """Return raw data."""
+        return self.raw_data
+
+    @property
+    def program_id(self) -> int | None:
+        """Return the ID of the program."""
+        return self.raw_data["programId"]
+
+    @property
+    def program_name(self) -> str | None:
+        """Return the name of the program."""
+        return self.raw_data["program"]
+
+    @property
+    def parameters(self) -> dict | None:
+        """Return the parameters of the program."""
+        return self.raw_data["parameters"]
+
+    @property
+    def temperature(self) -> dict | None:
+        """Return the temperature parameter of the program."""
+        return self.raw_data["parameters"].get("temperature")
+
+    @property
+    def temperature_min(self) -> int | None:
+        """Return the min temperature parameter of the program."""
+        return self.raw_data["parameters"]["temperature"]["min"]
+
+    @property
+    def temperature_max(self) -> int | None:
+        """Return the max temperature parameter of the program."""
+        return self.raw_data["parameters"]["temperature"]["max"]
+
+    @property
+    def temperature_step(self) -> int | None:
+        """Return the step temperature parameter of the program."""
+        return self.raw_data["parameters"]["temperature"]["step"]
+
+    @property
+    def temperature_mandatory(self) -> bool | None:
+        """Return the mandatory temperature parameter of the program."""
+        return self.raw_data["parameters"]["temperature"]["mandatory"]
+
+    @property
+    def duration_min(self) -> list[int] | None:
+        """Return the mandatory min parameter of the program."""
+        return self.raw_data["parameters"]["duration"]["min"]
+
+    @property
+    def duration_max(self) -> list[int] | None:
+        """Return the duration max parameter of the program."""
+        return self.raw_data["parameters"]["duration"]["max"]
+
+    @property
+    def duration_mandatory(self) -> bool | None:
+        """Return the mandatory duration parameter of the program."""
+        return self.raw_data["parameters"]["duration"]["mandatory"]

pymiele/pymiele.py

@@ -12,7 +12,7 @@ from typing import Any
 
 from aiohttp import ClientResponse, ClientResponseError, ClientSession, ClientTimeout
 
-from .const import MIELE_API, VERSION
+from .const import AIO_TIMEOUT, MIELE_API, VERSION
 
 CONTENT_TYPE = "application/json"
 USER_AGENT_BASE = f"Pymiele/{VERSION}"
@@ -59,7 +59,7 @@ class AbstractAuth(ABC):
 
     async def get_devices(self) -> dict:
         """Get all devices."""
-        async with asyncio.timeout(10):
+        async with asyncio.timeout(AIO_TIMEOUT):
             res = await self.request(
                 "GET", "/devices", headers={"Accept": "application/json"}
             )
@@ -68,7 +68,7 @@ class AbstractAuth(ABC):
 
     async def get_actions(self, serial: str) -> dict:
         """Get actions for a device."""
-        async with asyncio.timeout(10):
+        async with asyncio.timeout(AIO_TIMEOUT):
             res = await self.request(
                 "GET",
                 f"/devices/{serial}/actions",
@@ -79,7 +79,7 @@ class AbstractAuth(ABC):
 
     async def get_programs(self, serial: str) -> dict:
         """Get programs for a device."""
-        async with asyncio.timeout(10):
+        async with asyncio.timeout(AIO_TIMEOUT):
             res = await self.request(
                 "GET",
                 f"/devices/{serial}/programs",
@@ -90,7 +90,7 @@ class AbstractAuth(ABC):
 
     async def get_rooms(self, serial: str) -> dict:
         """Get rooms for a device."""
-        async with asyncio.timeout(10):
+        async with asyncio.timeout(AIO_TIMEOUT):
             res = await self.request(
                 "GET",
                 f"/devices/{serial}/rooms",
@@ -104,7 +104,7 @@ class AbstractAuth(ABC):
     ) -> ClientResponse:
         """Set target temperature."""
         temp = round(temperature)
-        async with asyncio.timeout(10):
+        async with asyncio.timeout(AIO_TIMEOUT):
             data = {"targetTemperature": [{"zone": zone, "value": temp}]}
             res = await self.request(
                 "PUT",
@@ -125,7 +125,7 @@ class AbstractAuth(ABC):
         """Send action command."""
 
         _LOGGER.debug("send_action serial: %s, data: %s", serial, data)
-        async with asyncio.timeout(10):
+        async with asyncio.timeout(AIO_TIMEOUT):
             res = await self.request(
                 "PUT",
                 f"/devices/{serial}/actions",
@@ -145,7 +145,7 @@ class AbstractAuth(ABC):
         """Send start program command."""
 
         _LOGGER.debug("set_program serial: %s, data: %s", serial, data)
-        async with asyncio.timeout(10):
+        async with asyncio.timeout(AIO_TIMEOUT):
             res = await self.request(
                 "PUT",
                 f"/devices/{serial}/programs",

{pymiele-0.3.1.dist-info → pymiele-0.3.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pymiele
-Version: 0.3.1
+Version: 0.3.2
 Summary: Python library for Miele integration with Home Assistant
 Author-email: Ake Strandberg <ake@strandberg.eu>
 License: MIT

pymiele-0.3.2.dist-info/RECORD

@@ -0,0 +1,10 @@
+pymiele/__init__.py,sha256=w_JvyaBHVGM7eo-FFwIWFbQUeAowoA_fbnAfCWJFGek,221
+pymiele/const.py,sha256=tQ4KYDdMAlp4qWvwseOUfUpngPyRzsKlfVEtXG3H-ek,237
+pymiele/model.py,sha256=0MNzVw6gG7o9EJlPjDp8isaNmuigRZtz-6ka-ij33-8,14816
+pymiele/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pymiele/pymiele.py,sha256=M5P_rW61XZV06aelw5i9-qzJ9exabMYgLcehzuKd7-Y,8723
+pymiele-0.3.2.dist-info/licenses/LICENSE,sha256=scGm4_U2pd-rsGa6Edf6zsXFebrMT4RoyQz7-904_Wg,1072
+pymiele-0.3.2.dist-info/METADATA,sha256=AWxGU1nbL90SZUx91_55a72lew-BqMlVIiODSF-lnL8,675
+pymiele-0.3.2.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+pymiele-0.3.2.dist-info/top_level.txt,sha256=BwkHrSO2w_Bfxh6s8Ikcao5enEuQOpQhJ3SwUXBqY10,8
+pymiele-0.3.2.dist-info/RECORD,,

pymiele-0.3.1.dist-info/RECORD

@@ -1,10 +0,0 @@
-pymiele/__init__.py,sha256=w_JvyaBHVGM7eo-FFwIWFbQUeAowoA_fbnAfCWJFGek,221
-pymiele/const.py,sha256=GNfH7v747oYiA1E-eQZeLVHJr70PPM5wkJqUhB6lGbw,219
-pymiele/model.py,sha256=PTMJ-9F_r3Hb4Zs96TFESSZ-r39cLCNIcSmFV5DrDjw,9442
-pymiele/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pymiele/pymiele.py,sha256=3edghDZLPDg4KBV7AVTUGNeeyDPAAegyzRfBG9pFgeU,8647
-pymiele-0.3.1.dist-info/licenses/LICENSE,sha256=scGm4_U2pd-rsGa6Edf6zsXFebrMT4RoyQz7-904_Wg,1072
-pymiele-0.3.1.dist-info/METADATA,sha256=8gerA20pt0tKdijbYGzMsJm20pVbUxgW1iInKA-OlJo,675
-pymiele-0.3.1.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
-pymiele-0.3.1.dist-info/top_level.txt,sha256=BwkHrSO2w_Bfxh6s8Ikcao5enEuQOpQhJ3SwUXBqY10,8
-pymiele-0.3.1.dist-info/RECORD,,