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

qolsys_controller/state.py

@@ -3,6 +3,12 @@ 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 .weather import QolsysWeather
 from .zwave_device import QolsysZWaveDevice
@@ -28,11 +34,14 @@ class QolsysState(QolsysObservable):
         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
@@ -43,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
@@ -79,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
@@ -98,6 +130,10 @@ class QolsysState(QolsysObservable):
     def state_scene_observer(self) -> QolsysObservable:
         return self._state_scene_observer
 
+    @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:
@@ -195,7 +231,12 @@ class QolsysState(QolsysObservable):
         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:
@@ -220,6 +261,61 @@ class QolsysState(QolsysObservable):
         self.zwave_devices.remove(zwave)
         self.state_zwave_observer.notify()
 
+    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:
@@ -254,6 +350,11 @@ class QolsysState(QolsysObservable):
                             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
                         if isinstance(state_zwave, QolsysGeneric) and isinstance(db_zwave, QolsysGeneric):
                             state_zwave.update_base(db_zwave.to_dict_base())
@@ -370,6 +471,29 @@ class QolsysState(QolsysObservable):
     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
             name = partition.name
@@ -410,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):
@@ -422,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) - 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):
@@ -437,8 +583,24 @@ 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

qolsys_controller/task_manager.py

@@ -20,10 +20,11 @@ class QolsysTaskManager:
             except asyncio.CancelledError:
                 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

qolsys_controller/zone.py

@@ -391,7 +391,8 @@ class QolsysZone(QolsysObservable):
     @property
     def powerg_temperature(self) -> float | None:
         try:
-            return float(self._powerg_temperature)
+            temp = float(self._powerg_temperature)
+            return round(temp, 1)
         except ValueError:
             return None
 

qolsys_controller/zwave_device.py

@@ -1,6 +1,10 @@
+import json
 import logging
 
-from .enum_zwave import ZwaveDeviceClass
+from qolsys_controller.zwave_service_meter import QolsysZwaveServiceMeter
+from qolsys_controller.zwave_service_multilevelsensor import QolsysZwaveMultilevelSensor, QolsysZwaveServiceMultilevelSensor
+
+from .enum_zwave import ZwaveDeviceClass, ZWaveMultilevelSensorScale
 from .observable import QolsysObservable
 
 LOGGER = logging.getLogger(__name__)
@@ -35,6 +39,19 @@ class QolsysZWaveDevice(QolsysObservable):
         self._is_device_hidden: str = zwave_dict.get("is_device_hidden", "")
         self._last_updated_date: str = zwave_dict.get("last_updated_date", "")
         self._command_class_list: str = zwave_dict.get("command_class_list", "")
+        self._meter_capabilities: str = ""
+        self._multisensor_capabilities: str = ""
+        self._notification_capabilities = zwave_dict.get("notification_capabilities", "")
+        self._multi_channel_details = zwave_dict.get("multi_channel_details", "")
+
+        # Set Meter and MutilevelSensor Services if available
+        self._meter_endpoints: list[QolsysZwaveServiceMeter] = []
+        self._multilevelsensor_endpoints: list[QolsysZwaveServiceMultilevelSensor] = []
+        self.meter_capabilities = zwave_dict.get("meter_capabilities", "")
+        self.multisensor_capabilities = zwave_dict.get("multisensor_capabilities", "")
+
+    def update_raw(self, payload: bytes) -> None:
+        LOGGER.debug("Raw Update (node%s) - payload: %s", self.node_id, payload.hex())
 
     def update_base(self, data: dict[str, str]) -> None:  # noqa: C901, PLR0912, PLR0915
         # Check if we are updating same node_id
@@ -98,6 +115,14 @@ class QolsysZWaveDevice(QolsysObservable):
             self._last_updated_date = data.get("last_updated_date", "")
         if "command_class_list" in data:
             self._last_updated_date = data.get("command_class_list", "")
+        if "multisensor_capabilities" in data:
+            self.multisensor_capabilities = data.get("multisensor_capabilities", "")
+        if "meter_capabilities" in data:
+            self.meter_capabilities = data.get("meter_capabilities", "")
+        if "notification_capabilities" in data:
+            self._notification_capabilities = data.get("notification_capabilities", "")
+        if "multi_channel_details" in data:
+            self._multi_channel_details = data.get("multi_channel_details", "")
 
         self.end_batch_update()
 
@@ -136,8 +161,82 @@ class QolsysZWaveDevice(QolsysObservable):
             self.notify()
 
     @property
-    def node_battery_level_value(self) -> str:
-        return self._node_battery_level_value
+    def meter_capabilities(self) -> str:
+        return self._meter_capabilities
+
+    @meter_capabilities.setter
+    def meter_capabilities(self, value: str) -> None:
+        if self._meter_capabilities != value:
+            self._meter_capabilities = value
+
+            # Update Meter Service
+            try:
+                meter_services = json.loads(value)
+                for endpoint, service in meter_services.items():
+                    # Check if we already have this meter service
+                    meter_endpoint = None
+                    for meter in self._meter_endpoints:
+                        if meter.endpoint == endpoint:
+                            meter_endpoint = meter
+                            meter_endpoint.update_iq2medi(service)
+                            break
+
+                    # Create new meter service if not found
+                    if meter_endpoint is None:
+                        LOGGER.debug("ZWave%s (%s) - Adding new meter endpoint: %s", self.node_id, self.node_name, endpoint)
+                        meter_endpoint = QolsysZwaveServiceMeter(self, endpoint, service)
+                        self._meter_endpoints.append(meter_endpoint)
+
+            except json.JSONDecodeError:
+                LOGGER.error("ZWave%s (%s) - Error parsing meter_capabilities:%s", self.node_id, self.node_name, value)
+                return
+
+    @property
+    def multisensor_capabilities(self) -> str:
+        return self._multisensor_capabilities
+
+    @multisensor_capabilities.setter
+    def multisensor_capabilities(self, value: str) -> None:
+        if self._multisensor_capabilities != value:
+            self._multisensor_capabilities = value
+
+            # Update Multilevel Sensor Service
+            try:
+                sensor_services = json.loads(value)
+                for endpoint, service in sensor_services.items():
+                    # Check if we already have this meter service
+                    sensor_endpoint = None
+                    for sensor in self._multilevelsensor_endpoints:
+                        if sensor.endpoint == endpoint:
+                            sensor_endpoint = sensor
+                            sensor_endpoint.update_iq2medi(service)
+                            break
+
+                    # Create new meter service if not found
+                    if sensor_endpoint is None:
+                        LOGGER.debug(
+                            "ZWave%s (%s) - Adding new multilevelsensor endpoint: %s", self.node_id, self.node_name, endpoint
+                        )
+                        sensor_endpoint = QolsysZwaveServiceMultilevelSensor(self, endpoint, service)
+                        self.multilevelsensor_endpoints.append(sensor_endpoint)
+
+            except json.JSONDecodeError:
+                LOGGER.error(
+                    "ZWave%s (%s) - Error parsing multilevelsensor_capabilities:%s", self.node_id, self.node_name, value
+                )
+                return
+
+    @property
+    def node_battery_level_value(self) -> int | None:
+        try:
+            value = int(self._node_battery_level_value)
+            if value >= 0 and value <= 100:
+                return value
+            else:
+                return None
+
+        except ValueError:
+            return None
 
     @node_battery_level_value.setter
     def node_battery_level_value(self, value: str) -> None:
@@ -190,6 +289,14 @@ class QolsysZWaveDevice(QolsysObservable):
             self._partition_id = value
             self.notify()
 
+    @property
+    def meter_endpoints(self) -> list[QolsysZwaveServiceMeter]:
+        return self._meter_endpoints
+
+    @property
+    def multilevelsensor_endpoints(self) -> list[QolsysZwaveServiceMultilevelSensor]:
+        return self._multilevelsensor_endpoints
+
     @property
     def generic_device_type(self) -> ZwaveDeviceClass:
         try:
@@ -197,6 +304,23 @@ class QolsysZWaveDevice(QolsysObservable):
         except ValueError:
             return ZwaveDeviceClass.Unknown
 
+    def is_battery_enabled(self) -> bool:
+        return self.node_battery_level_value is not None
+
+    def is_service_meter_enabled(self) -> bool:
+        return self._meter_endpoints != []
+
+    def is_service_multilevelsensor_enabled(self) -> bool:
+        return self._multilevelsensor_endpoints != []
+
+    def multilevelsensor_value(self, scale: ZWaveMultilevelSensorScale) -> list[QolsysZwaveMultilevelSensor]:
+        result: list[QolsysZwaveMultilevelSensor] = []
+        for endpoint in self.multilevelsensor_endpoints:
+            sensor = endpoint.get_sensor(scale)
+            if sensor is not None:
+                result.append(sensor)
+        return result
+
     def to_dict_base(self) -> dict[str, str]:
         return {
             "_id": self._id,
@@ -206,7 +330,7 @@ class QolsysZWaveDevice(QolsysObservable):
             "node_status": self.node_status,
             "partition_id": self._partition_id,
             "node_battery_level": self.node_battery_level,
-            "node_battery_level_value": self.node_battery_level_value,
+            "node_battery_level_value": self._node_battery_level_value,
             "paired_status": self.paired_status,
             "node_secure_cmd_cls": self._node_secure_cmd_cls,
             "is_node_listening_node": self._is_node_listening_node,
@@ -224,4 +348,8 @@ class QolsysZWaveDevice(QolsysObservable):
             "is_device_hidden": self._is_device_hidden,
             "last_updated_date": self._last_updated_date,
             "command_class_list": self._command_class_list,
+            "multisensor_capabilities": self.multisensor_capabilities,
+            "meter_capabilities": self.meter_capabilities,
+            "notification_capabilities": self._notification_capabilities,
+            "multi_channel_details": self._multi_channel_details,
         }

qolsys_controller/zwave_dimmer.py

@@ -69,6 +69,9 @@ class QolsysDimmer(QolsysZWaveDevice):
             self._dimmer_level = value
             self.notify()
 
+    def update_raw(self, payload: bytes) -> None:
+        pass
+
     def update_dimmer(self, content_values: dict[str, str]) -> None:  # noqa: PLR0912
         # Check if we are updating same none_id
         node_id_update = content_values.get("node_id", "")

qolsys_controller/zwave_energy_clamp.py

@@ -0,0 +1,15 @@
+import logging
+
+from .zwave_device import QolsysZWaveDevice
+
+LOGGER = logging.getLogger(__name__)
+
+
+class QolsysEnergyClamp(QolsysZWaveDevice):
+    def __init__(self, zwave_dict: dict[str, str]) -> None:
+        super().__init__(zwave_dict)
+
+    # Energy clamp only enables meter seter in base zwave_device class
+
+    def update_raw(self, payload: bytes) -> None:
+        pass

qolsys_controller/zwave_garagedoor.py

@@ -8,3 +8,6 @@ LOGGER = logging.getLogger(__name__)
 class QolsysGarageDoor(QolsysZWaveDevice):
     def __init__(self) -> None:
         pass
+
+    def update_raw(self, payload: bytes) -> None:
+        LOGGER.debug("Raw Update (node%s) - payload: %s", self.node_id, payload.hex())

qolsys_controller/zwave_generic.py

@@ -8,3 +8,6 @@ LOGGER = logging.getLogger(__name__)
 class QolsysGeneric(QolsysZWaveDevice):
     def __init__(self, zwave_dict: dict[str, str]) -> None:
         super().__init__(zwave_dict)
+
+    def update_raw(self, payload: bytes) -> None:
+        LOGGER.debug("Raw Update (node%s) - payload: %s", self.node_id, payload.hex())

qolsys_controller/zwave_lock.py

@@ -69,6 +69,9 @@ class QolsysLock(QolsysZWaveDevice):
             self._lock_paired_status = value
             self.notify()
 
+    def update_raw(self, payload: bytes) -> None:
+        pass
+
     def update_lock(self, data: dict[str, str]) -> None:  # noqa: PLR0912
         # Check if we are updating same zoneid
         node_id_update = data.get("node_id", "")
@@ -118,6 +121,7 @@ class QolsysLock(QolsysZWaveDevice):
             "opr": self._lock_opr,
             "partition_id": self._lock_partition_id,
             "doorlock_name": self.lock_name,
+            "node_id": self.lock_node_id,
             "status": self.lock_status,
             "created_by": self._lock_created_by,
             "created_date": self._lock_created_date,

qolsys_controller/zwave_outlet.py

@@ -8,3 +8,6 @@ LOGGER = logging.getLogger(__name__)
 class QolsysOutlet(QolsysZWaveDevice):
     def __init__(self) -> None:
         pass
+
+    def update_raw(self, payload: bytes) -> None:
+        LOGGER.debug("Raw Update (node%s) - payload: %s", self.node_id, payload.hex())