pymiele 0.3.0__tar.gz → 0.3.2__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pymiele
-Version: 0.3.0
+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.0 → pymiele-0.3.2}/pymiele/const.py

@@ -1,7 +1,9 @@
 """Constants for pymiele."""
 
-VERSION = "0.3.0"
+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-0.3.2/pymiele/model.py

@@ -0,0 +1,471 @@
+"""Data models for Miele API."""
+
+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 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."""
+
+    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) -> str:
+        """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[MieleTemperature]:
+        """Return the target temperature of the device."""
+        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 [
+            MieleTemperature(temp)
+            for temp in self.raw_data["state"]["coretargetTemperature"]
+        ]
+
+    @property
+    def state_temperatures(self) -> list[MieleTemperature]:
+        """Return list of all temperatures."""
+
+        return [
+            MieleTemperature(temp) for temp in self.raw_data["state"]["temperature"]
+        ]
+
+    @property
+    def state_core_temperature(self) -> list[MieleTemperature]:
+        """Return the core temperature of the device."""
+        return [
+            MieleTemperature(temp) for temp in self.raw_data["state"]["coreTemperature"]
+        ]
+
+    @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) -> 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) -> 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."""
+        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"]["value_raw"]
+
+    @property
+    def state_drying_step(self) -> int | None:
+        """Return the drying step of the device."""
+        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"]["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]:
+        """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 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."""
+        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
+
+    @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 [
+            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-0.3.0 → pymiele-0.3.2}/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.0 → pymiele-0.3.2}/pymiele.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pymiele
-Version: 0.3.0
+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.0 → pymiele-0.3.2}/setup.cfg

@@ -1,5 +1,5 @@
 [bumpversion]
-current_version = 0.3.0
+current_version = 0.3.2
 
 [egg_info]
 tag_build = 

pymiele-0.3.0/pymiele/model.py

@@ -1,698 +0,0 @@
-"""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)