qolsys-controller 0.0.44__py3-none-any.whl → 0.0.87__py3-none-any.whl

qolsys_controller/state.py

@@ -1,9 +1,16 @@
+from __future__ import annotations
+
 import logging
+from typing import TYPE_CHECKING
+
+from qolsys_controller.adc_service import QolsysAdcService
+from qolsys_controller.adc_service_garagedoor import QolsysAdcGarageDoorService
+from qolsys_controller.zwave_energy_clamp import QolsysEnergyClamp
+from qolsys_controller.zwave_thermometer import QolsysThermometer
 
+from .adc_device import QolsysAdcDevice
 from .observable import QolsysObservable
-from .partition import QolsysPartition
-from .scene import QolsysScene
-from .zone import QolsysZone
+from .weather import QolsysWeather
 from .zwave_device import QolsysZWaveDevice
 from .zwave_dimmer import QolsysDimmer
 from .zwave_generic import QolsysGeneric
@@ -12,20 +19,29 @@ from .zwave_thermostat import QolsysThermostat
 
 LOGGER = logging.getLogger(__name__)
 
+if TYPE_CHECKING:
+    from .controller import QolsysController
+    from .partition import QolsysPartition
+    from .scene import QolsysScene
+    from .zone import QolsysZone
+    from .zwave_device import QolsysZWaveDevice
 
-class QolsysState(QolsysObservable):
 
-    def __init__(self) -> None:
+class QolsysState(QolsysObservable):
+    def __init__(self, controller: QolsysController) -> None:
         super().__init__()
-
-        self._partitions = []
-        self._zones = []
-        self._zwave_devices = []
-        self._scenes = []
+        self._controller: QolsysController = controller
+        self._weather: QolsysWeather = QolsysWeather()
+        self._partitions: list[QolsysPartition] = []
+        self._zones: list[QolsysZone] = []
+        self._adc_devices: list[QolsysAdcDevice] = []
+        self._zwave_devices: list[QolsysZWaveDevice] = []
+        self._scenes: list[QolsysScene] = []
 
         self._state_partition_observer = QolsysObservable()
         self._state_zone_observer = QolsysObservable()
         self._state_zwave_observer = QolsysObservable()
+        self._state_adc_observer = QolsysObservable()
         self._state_scene_observer = QolsysObservable()
 
     @property
@@ -36,6 +52,10 @@ class QolsysState(QolsysObservable):
     def zwave_devices(self) -> list[QolsysZWaveDevice]:
         return self._zwave_devices
 
+    @property
+    def adc_devices(self) -> list[QolsysAdcDevice]:
+        return self._adc_devices
+
     @property
     def zones(self) -> list[QolsysZone]:
         return self._zones
@@ -44,6 +64,10 @@ class QolsysState(QolsysObservable):
     def scenes(self) -> list[QolsysScene]:
         return self._scenes
 
+    @property
+    def weather(self) -> QolsysWeather:
+        return self._weather
+
     @property
     def zwave_dimmers(self) -> list[QolsysDimmer]:
         dimmers = []
@@ -68,9 +92,28 @@ class QolsysState(QolsysObservable):
         for device in self.zwave_devices:
             if isinstance(device, QolsysThermostat):
                 thermostats.append(device)
-
         return thermostats
 
+    @property
+    def zwave_meters(self) -> list[QolsysEnergyClamp]:
+        meters = []
+        for device in self.zwave_devices:
+            if isinstance(device, QolsysEnergyClamp):
+                meters.append(device)
+        return meters
+
+    @property
+    def zwave_thermometers(self) -> list[QolsysThermometer]:
+        thermometer = []
+        for device in self.zwave_devices:
+            if isinstance(device, QolsysThermometer):
+                thermometer.append(device)
+        return thermometer
+
+    @property
+    def zwave_other_devices(self) -> list[dict[str, str]]:
+        return self._controller.panel.db.get_zwave_other_devices()
+
     @property
     def state_partition_observer(self) -> QolsysObservable:
         return self._state_partition_observer
@@ -87,7 +130,11 @@ class QolsysState(QolsysObservable):
     def state_scene_observer(self) -> QolsysObservable:
         return self._state_scene_observer
 
-    def partition(self, partition_id: str) -> QolsysPartition:
+    @property
+    def state_adc_observer(self) -> QolsysObservable:
+        return self._state_adc_observer
+
+    def partition(self, partition_id: str) -> QolsysPartition | None:
         for partition in self.partitions:
             if partition.id == partition_id:
                 return partition
@@ -97,8 +144,11 @@ class QolsysState(QolsysObservable):
     def partition_add(self, new_partition: QolsysPartition) -> None:
         for partition in self.partitions:
             if new_partition.id == partition.id:
-                LOGGER.debug("Adding Partition to State, Partition%s (%s) - Allready in Partitions List",
-                             new_partition.id, partition.name)
+                LOGGER.debug(
+                    "Adding Partition to State, Partition%s (%s) - Allready in Partitions List",
+                    new_partition.id,
+                    partition.name,
+                )
                 return
 
         self.partitions.append(new_partition)
@@ -115,7 +165,7 @@ class QolsysState(QolsysObservable):
         self.partitions.remove(partition)
         self.state_partition_observer.notify()
 
-    def scene(self, scene_id: str) -> QolsysScene:
+    def scene(self, scene_id: str) -> QolsysScene | None:
         for scene in self.scenes:
             if scene.scene_id == scene_id:
                 return scene
@@ -125,7 +175,7 @@ class QolsysState(QolsysObservable):
     def scene_add(self, new_scene: QolsysScene) -> None:
         for scene in self.scenes:
             if new_scene.scene_id == scene.scene_id:
-                LOGGER.debug("Adding Scene to State, Scene%s (%s) - Allready in Scene List", new_scene.scene_id, scene.name )
+                LOGGER.debug("Adding Scene to State, Scene%s (%s) - Allready in Scene List", new_scene.scene_id, scene.name)
                 return
 
         self.scenes.append(new_scene)
@@ -143,7 +193,7 @@ class QolsysState(QolsysObservable):
         self.scenes.remove(scene)
         self.state_scene_observer.notify()
 
-    def zone(self, zone_id: str) -> QolsysZone:
+    def zone(self, zone_id: str) -> QolsysZone | None:
         for zone in self.zones:
             if zone.zone_id == zone_id:
                 return zone
@@ -151,14 +201,16 @@ class QolsysState(QolsysObservable):
 
     def zone_from_short_id(self, short_id: int) -> QolsysZone | None:
         for zone in self.zones:
-            if zone.shortID == short_id:
+            if zone.shortID == str(short_id):
                 return zone
         return None
 
     def zone_add(self, new_zone: QolsysZone) -> None:
         for zone in self.zones:
             if new_zone.zone_id == zone.zone_id:
-                LOGGER.debug("Adding Zone to State, zone%s (%s) - Allready in Zone List", new_zone.zone_id, self.sensorname)
+                LOGGER.debug(
+                    "Adding Zone to State, zone%s (%s) - Allready in Zone List", new_zone.zone_id, new_zone.sensorname
+                )
                 return
 
         self.zones.append(new_zone)
@@ -175,18 +227,24 @@ class QolsysState(QolsysObservable):
         self.zones.remove(zone)
         self.state_zone_observer.notify()
 
-    def zwave_device(self, node_id: str) -> QolsysZWaveDevice:
+    def zwave_device(self, node_id: str) -> QolsysZWaveDevice | None:
         for zwave_device in self.zwave_devices:
             if zwave_device.node_id == node_id:
                 return zwave_device
+        return None
 
+    def zwave_thermostat(self, node_id: str) -> QolsysThermostat | None:
+        thermostat = self.zwave_device(node_id)
+        if isinstance(thermostat, QolsysThermostat):
+            return thermostat
         return None
 
     def zwave_add(self, new_zwave: QolsysZWaveDevice) -> None:
         for zwave_device in self.zwave_devices:
             if new_zwave.node_id == zwave_device.node_id:
-                LOGGER.debug("Adding ZWave to State, ZWave%s (%s) - Allready in ZWave List",
-                             new_zwave.node_id, zwave_device.node_name)
+                LOGGER.debug(
+                    "Adding ZWave to State, ZWave%s (%s) - Allready in ZWave List", new_zwave.node_id, zwave_device.node_name
+                )
                 return
 
         self.zwave_devices.append(new_zwave)
@@ -203,8 +261,62 @@ class QolsysState(QolsysObservable):
         self.zwave_devices.remove(zwave)
         self.state_zwave_observer.notify()
 
-    def sync_zwave_devices_data(self, db_zwaves: list[QolsysZWaveDevice]) -> None:  # noqa: PLR0912
+    def adc_device(self, device_id: str) -> QolsysAdcDevice | None:
+        for adc_device in self.adc_devices:
+            if adc_device.device_id == device_id:
+                return adc_device
+        return None
 
+    def adc_add(self, new_adc: QolsysAdcDevice) -> None:
+        for adc_device in self.adc_devices:
+            if new_adc.device_id == adc_device.device_id:
+                LOGGER.debug("Adding ADC to State, ADC%s (%s) - Allready in ADC List", new_adc.device_id, new_adc.name)
+                return
+
+        self.adc_devices.append(new_adc)
+        self.adc_devices.sort(key=lambda x: x.device_id, reverse=False)
+        self.state_adc_observer.notify()
+
+    def adc_delete(self, device_id: str) -> None:
+        adc = self.adc_device(device_id)
+
+        if adc is None:
+            LOGGER.debug("Deleting ADC from State, ADC%s not found", device_id)
+            return
+
+        self.adc_devices.remove(adc)
+        self.state_adc_observer.notify()
+
+    def sync_adc_devices_data(self, db_adcs: list[QolsysAdcDevice]) -> None:
+        db_adc_list = []
+        for db_adc in db_adcs:
+            db_adc_list.append(db_adc.device_id)
+
+        state_adc_list = []
+        for state_adc in self.adc_devices:
+            state_adc_list.append(state_adc.device_id)
+
+        # Update existing ADC devices
+        for state_adc in self.adc_devices:
+            if state_adc.device_id in db_adc_list:
+                for db_adc in db_adcs:
+                    if state_adc.device_id == db_adc.device_id:
+                        LOGGER.debug("sync_data - update ADC%s", state_adc.device_id)
+                        state_adc.update_adc_device(db_adc.to_dict_adc())
+
+        # Add new ADC devices
+        for db_adc in db_adcs:
+            if db_adc.device_id not in state_adc_list:
+                LOGGER.debug("sync_data - add ADC%s", db_adc.device_id)
+                self.adc_add(db_adc)
+
+        # Delete ADC device
+        for state_adc in self.adc_devices:
+            if state_adc.device_id not in db_adc_list:
+                LOGGER.debug("sync_data - delete ADC%s", state_adc.device_id)
+                self.adc_delete(state_adc.device_id)
+
+    def sync_zwave_devices_data(self, db_zwaves: list[QolsysZWaveDevice]) -> None:  # noqa: PLR0912
         db_zwave_list = []
         for db_zwave in db_zwaves:
             db_zwave_list.append(db_zwave.node_id)
@@ -229,13 +341,18 @@ class QolsysState(QolsysObservable):
                         # Update Thermostat
                         if isinstance(state_zwave, QolsysThermostat) and isinstance(db_zwave, QolsysThermostat):
                             state_zwave.update_base(db_zwave.to_dict_base())
-                            state_zwave.update_thermostat(db_zwave.to_dict_thermostat)
+                            state_zwave.update_thermostat(db_zwave.to_dict_thermostat())
                             break
 
                         # Update Lock
                         if isinstance(state_zwave, QolsysLock) and isinstance(db_zwave, QolsysLock):
                             state_zwave.update_base(db_zwave.to_dict_base())
-                            state_zwave.update_lock(db_zwave.to_dict_lock)
+                            state_zwave.update_lock(db_zwave.to_dict_lock())
+                            break
+
+                        # Update Energy Clamp
+                        if isinstance(state_zwave, QolsysEnergyClamp) and isinstance(db_zwave, QolsysEnergyClamp):
+                            state_zwave.update_base(db_zwave.to_dict_base())
                             break
 
                         # Generic Z-Wave Device
@@ -243,10 +360,6 @@ class QolsysState(QolsysObservable):
                             state_zwave.update_base(db_zwave.to_dict_base())
                             break
 
-                        # zwave node_id has changed of node_type, delete and add again
-                        # self.zwave_delete(int(state_zwave.node_id))
-                        # self.zwave_add(db_zwave)
-
         # Add new zwave device
         for db_zwave in db_zwaves:
             if db_zwave.node_id not in state_zwave_list:
@@ -256,9 +369,13 @@ class QolsysState(QolsysObservable):
         # Delete zwave device
         for state_zwave in self.zwave_devices:
             if state_zwave.node_id not in db_zwave_list:
-                LOGGER.debug("sync_data - delete ZWave%s", state_zwave.none_id)
+                LOGGER.debug("sync_data - delete ZWave%s", state_zwave.node_id)
                 self.zwave_delete(state_zwave.node_id)
 
+    def sync_weather_data(self, db_weather: QolsysWeather) -> None:
+        LOGGER.debug("sync_data - update Weather")
+        self._weather.update(db_weather.forecasts)
+
     def sync_scenes_data(self, db_scenes: list[QolsysScene]) -> None:
         db_scene_list = []
         for db_scene in db_scenes:
@@ -351,8 +468,31 @@ class QolsysState(QolsysObservable):
                 LOGGER.debug("sync_data - Add Partition%s", db_partition.id)
                 self.partition_add(db_partition)
 
-    def dump(self) -> None:  # noqa: PLR0915
-        LOGGER.debug("*** Information ***")
+    def dump(self) -> None:  # noqa: PLR0912, PLR0915
+        LOGGER.debug("*** Device Information ***")
+
+        def dump_meter(self: QolsysState, device: QolsysZWaveDevice) -> None:
+            for endpoint in device.meter_endpoints:
+                for meter_sensor in endpoint.sensors:
+                    LOGGER.debug(
+                        " Meter%s Endpoint%s - %s - value: %.2f (%s)",
+                        device.node_id,
+                        endpoint.endpoint,
+                        endpoint._meter_type.name,
+                        meter_sensor.value,
+                        meter_sensor.scale.name,
+                    )
+
+        def dump_multilevelsensor(self: QolsysState, device: QolsysZWaveDevice) -> None:
+            for endpoint in device.multilevelsensor_endpoints:
+                for sensor in endpoint.sensors:
+                    LOGGER.debug(
+                        " Multilevelsensor%s Endpoint%s - value: %.2f (%s)",
+                        device.node_id,
+                        endpoint.endpoint,
+                        sensor.value,
+                        sensor.unit.name,
+                    )
 
         for partition in self.partitions:
             pid = partition.id
@@ -394,6 +534,8 @@ class QolsysState(QolsysObservable):
                 LOGGER.debug("Dimmer%s (%s) - node_status: %s", nid, name, zwave.node_status)
                 LOGGER.debug("Dimmer%s (%s) - battery_level: %s", nid, name, zwave.node_battery_level)
                 LOGGER.debug("Dimmer%s (%s) - battery_level_value: %s", nid, name, zwave.node_battery_level_value)
+                dump_meter(self, zwave)
+                dump_multilevelsensor(self, zwave)
                 continue
 
             if isinstance(zwave, QolsysThermostat):
@@ -406,12 +548,32 @@ class QolsysState(QolsysObservable):
                 LOGGER.debug("Thermostat%s (%s) - target_cool_temp: %s", zid, name, zwave.thermostat_target_cool_temp)
                 LOGGER.debug("Thermostat%s (%s) - target_heat_temp: %s", zid, name, zwave.thermostat_target_heat_temp)
                 LOGGER.debug("Thermostat%s (%s) - set_point_mode: %s", zid, name, zwave.thermostat_set_point_mode)
+                dump_meter(self, zwave)
+                dump_multilevelsensor(self, zwave)
                 continue
 
             if isinstance(zwave, QolsysLock):
                 zid = zwave.lock_node_id
                 name = zwave.lock_name
-                LOGGER.debug("Lock%s (%s) - current_temp: %s", zid, name, zwave.lock_status)
+                LOGGER.debug("Lock%s (%s) - lock_status: %s", zid, name, zwave.lock_status)
+                dump_meter(self, zwave)
+                dump_multilevelsensor(self, zwave)
+                continue
+
+            if isinstance(zwave, QolsysEnergyClamp):
+                nid = zwave.node_id
+                name = zwave.node_name
+                LOGGER.debug("EnergyClamp%s (%s)", nid, name)
+                dump_meter(self, zwave)
+                dump_multilevelsensor(self, zwave)
+                continue
+
+            if isinstance(zwave, QolsysThermometer):
+                nid = zwave.node_id
+                name = zwave.node_name
+                LOGGER.debug("Thermometer%s (%s)", nid, name)
+                dump_meter(self, zwave)
+                dump_multilevelsensor(self, zwave)
                 continue
 
             if isinstance(zwave, QolsysGeneric):
@@ -421,9 +583,34 @@ class QolsysState(QolsysObservable):
                 LOGGER.debug("Generic%s (%s) - status: %s", zid, name, zwave.node_status)
                 LOGGER.debug("Generic%s (%s) - battery_level: %s", zid, name, zwave.node_battery_level)
                 LOGGER.debug("Generic%s (%s) - battery_level_vale: %s", zid, name, zwave.node_battery_level_value)
+                dump_meter(self, zwave)
+                dump_multilevelsensor(self, zwave)
                 continue
 
+        LOGGER.debug("Other Z-Wave devices information")
+        LOGGER.debug(self.zwave_other_devices)
+
+        for adc in self.adc_devices:
+            for service in adc.services:
+                if isinstance(service, QolsysAdcGarageDoorService):
+                    LOGGER.debug(
+                        "ADC%s GarageDoor%s (%s) - state: %s", adc.device_id, service.id, adc.name, service.func_state
+                    )
+                    continue
+
+                if isinstance(service, QolsysAdcService):
+                    LOGGER.debug("ADC%s Service%s (%s) - state: %s", adc.device_id, service.id, adc.name, service.func_state)
+
         for scene in self.scenes:
             sid = scene.scene_id
             name = scene.name
-            LOGGER.debug("Scene%s (%s)",sid, name)
+            LOGGER.debug("Scene%s (%s)", sid, name)
+
+        for forecast in self.weather.forecasts:
+            LOGGER.debug(
+                "Weather - %s - High: %s, Low:%s, Condition: %s",
+                forecast.day_of_week[0:3],
+                forecast.high_temp,
+                forecast.low_temp,
+                forecast.condition,
+            )

qolsys_controller/task_manager.py

@@ -7,32 +7,32 @@ LOGGER = logging.getLogger(__name__)
 
 class QolsysTaskManager:
     def __init__(self) -> None:
-        self._tasks = set()
+        self._tasks: set[asyncio.Task] = set()  # type: ignore[type-arg]
 
-    def run(self, coro: Coroutine, label: str) -> asyncio.Task:
+    def run(self, coro: Coroutine, label: str) -> asyncio.Task:  # type: ignore[type-arg]
         task = asyncio.create_task(coro, name=label)
         self._tasks.add(task)
 
-        def _done_callback(task: asyncio.Task) -> None:
-
+        def _done_callback(task: asyncio.Task) -> None:  # type: ignore[type-arg]
             try:
                 task.result()
 
             except asyncio.CancelledError:
-                LOGGER.debug("Task Cancelled: %s",task.get_name())
+                LOGGER.debug("Task Cancelled: %s", task.get_name())
 
-            except Exception as e:  # noqa: BLE001
-                LOGGER.debug("[Callback] Task failed with: %s",e)
+            except Exception:  # noqa: BLE001
+                LOGGER.exception("[Callback] Task failed: %s", task.get_name())
 
-            self._tasks.discard(task)
+            finally:
+                self._tasks.discard(task)
 
         task.add_done_callback(_done_callback)
         return task
 
-    def get_task(self, label:str) -> asyncio.Task | None:
+    def get_task(self, label: str) -> asyncio.Task | None:  # type: ignore[type-arg]
         for task in self._tasks:
-             if task.get_name() == label:
-                 return task
+            if task.get_name() == label:
+                return task
         return None
 
     def cancel(self, label: str) -> None:
@@ -49,9 +49,6 @@ class QolsysTaskManager:
         if self._tasks:
             await asyncio.gather(*self._tasks, return_exceptions=True)
 
-    def pending(self) -> None:
-        return {t for t in self._tasks if not t.done()}
-
     def dump(self) -> None:
         for task in self._tasks:
             LOGGER.debug("Task: %s, Done: %s, Cancelled: %s", task.get_name(), task.done(), task.cancelled())

qolsys_controller/users.py

@@ -0,0 +1,25 @@
+import logging
+
+LOGGER = logging.getLogger(__name__)
+
+
+class QolsysUser:
+    def __init__(self) -> None:
+        self._id: int = 0
+        self._user_code = ""
+
+    @property
+    def id(self) -> int:
+        return self._id
+
+    @id.setter
+    def id(self, value: int) -> None:
+        self._id = value
+
+    @property
+    def user_code(self) -> str:
+        return self._user_code
+
+    @user_code.setter
+    def user_code(self, value: str) -> None:
+        self._user_code = value

qolsys_controller/utils_mqtt.py

@@ -1,24 +1,16 @@
 import logging
 import random
-import re
 
 LOGGER = logging.getLogger(__name__)
 
 
-def fix_json_string(json_string):
-    def replace_escape(match):
-        hex_value = match.group(1)
-        decimal_value = int(hex_value, 16)
-        return f"\\u{decimal_value:04x}"
-
-    return re.sub(r"\\x([0-9a-fA-F]{2})", replace_escape, json_string)
-
-
-def generate_random_mac() -> str:
+def generate_random_mac() -> str:  # noqa: D103
     mac = [
-        0xf2, 0x16, 0x3e,
-        random.randint(0x00, 0x7f),
-        random.randint(0x00, 0xff),
-        random.randint(0x00, 0xff),
+        0xF2,
+        0x16,
+        0x3E,
+        random.randint(0x00, 0x7F),
+        random.randint(0x00, 0xFF),
+        random.randint(0x00, 0xFF),
     ]
-    return ":".join(map(lambda x: "%02x" % x, mac))
+    return ":".join(map(lambda x: "%02x" % x, mac))  # noqa: C417, UP031

qolsys_controller/weather.py

@@ -0,0 +1,71 @@
+import logging
+
+from .observable import QolsysObservable
+
+LOGGER = logging.getLogger(__name__)
+
+
+class QolsysForecast:
+    def __init__(self, data: dict[str, str]) -> None:
+        self._high_temp: str = data.get("high_temp", "")
+        self._low_temp: str = data.get("low_temp", "")
+        self._day_of_week: str = data.get("day_of_week", "")
+        self._condition: str = data.get("condition", "")
+        self._icon: str = data.get("icon", "")
+        self._precipitation: str = data.get("precipitation", "")
+        self._current_weather_date: str = data.get("current_weather_date", "")
+
+    @property
+    def high_temp(self) -> float | None:
+        try:
+            return float(self._high_temp)
+        except ValueError:
+            return None
+
+    @property
+    def low_temp(self) -> float | None:
+        try:
+            return float(self._low_temp)
+        except ValueError:
+            return None
+
+    @property
+    def day_of_week(self) -> str:
+        return self._day_of_week
+
+    @property
+    def condition(self) -> str:
+        return self._condition
+
+    @property
+    def precipitation(self) -> int | None:
+        try:
+            return int(self._precipitation)
+        except ValueError:
+            return None
+
+    @property
+    def current_weather_date(self) -> str:
+        return self._current_weather_date
+
+
+class QolsysWeather(QolsysObservable):
+    def __init__(self) -> None:
+        super().__init__()
+        self._forecasts: list[QolsysForecast] = []
+
+    def current_weather(self) -> QolsysForecast | None:
+        if self._forecasts:
+            return self._forecasts[0]
+        return None
+
+    def update(self, data: list[QolsysForecast]) -> None:
+        self._forecasts.clear()
+        for forecast_data in data:
+            self._forecasts.append(forecast_data)
+
+        self.notify()
+
+    @property
+    def forecasts(self) -> list[QolsysForecast]:
+        return self._forecasts