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

qolsys_controller/zwave_lock.py

@@ -6,29 +6,31 @@ LOGGER = logging.getLogger(__name__)
 
 
 class QolsysLock(QolsysZWaveDevice):
-
     LOCK_STATUS_ARRAY = ["Locked"]  # noqa: RUF012
 
-    def __init__(self, lock_dict: dict, zwave_dict: dict) -> None:
-
+    def __init__(self, lock_dict: dict[str, str], zwave_dict: dict[str, str]) -> None:
         super().__init__(zwave_dict)
 
-        self._lock_id = lock_dict.get("_id")
-        self._lock_version = lock_dict.get("version", "")
-        self._lock_opr = lock_dict.get("opr", "")
-        self._lock_partition_id = lock_dict.get("partition_id", "")
-        self._lock_name = lock_dict.get("doorlock_name", "")
-        self._lock_status = lock_dict.get("status", "")
-        self._lock_node_id = lock_dict.get("node_id", "")
-        self._lock_created_by = lock_dict.get("created_by", "")
-        self._lock_created_date = lock_dict.get("created_date", "")
-        self._lock_updated_by = lock_dict.get("updated_by", "")
-        self._lock_last_updated_date = lock_dict.get("last_updated_date", "")
-        self._lock_remote_arming = lock_dict.get("remote_arming", "")
-        self._lock_keyfob_arming = lock_dict.get("keyfob_arming", "")
-        self._lock_panel_arming = lock_dict.get("panel_arming", "")
-        self._lock_endpoint = lock_dict.get("endpoint", "")
-        self._lock_paired_status = lock_dict.get("paired_status", "")
+        self._lock_id: str = lock_dict.get("_id", "")
+        self._lock_version: str = lock_dict.get("version", "")
+        self._lock_opr: str = lock_dict.get("opr", "")
+        self._lock_partition_id: str = lock_dict.get("partition_id", "")
+        self._lock_name: str = lock_dict.get("doorlock_name", "")
+        self._lock_status: str = lock_dict.get("status", "")
+        self._lock_node_id: str = lock_dict.get("node_id", "")
+        self._lock_created_by: str = lock_dict.get("created_by", "")
+        self._lock_created_date: str = lock_dict.get("created_date", "")
+        self._lock_updated_by: str = lock_dict.get("updated_by", "")
+        self._lock_last_updated_date: str = lock_dict.get("last_updated_date", "")
+        self._lock_remote_arming: str = lock_dict.get("remote_arming", "")
+        self._lock_keyfob_arming: str = lock_dict.get("keyfob_arming", "")
+        self._lock_panel_arming: str = lock_dict.get("panel_arming", "")
+        self._lock_endpoint: str = lock_dict.get("endpoint", "")
+        self._lock_paired_status: str = lock_dict.get("paired_status", "")
+
+    # -----------------------------
+    # properties + setters
+    # -----------------------------
 
     @property
     def lock_node_id(self) -> str:
@@ -38,14 +40,6 @@ class QolsysLock(QolsysZWaveDevice):
     def lock_status(self) -> str:
         return self._lock_status
 
-    @property
-    def lock_name(self) -> str:
-        return self._lock_name
-
-    @property
-    def paired_status(self) -> str:
-        return self._paired_status
-
     @lock_status.setter
     def lock_status(self, value: str) -> None:
         if self._lock_status != value:
@@ -53,6 +47,10 @@ class QolsysLock(QolsysZWaveDevice):
             self._lock_status = value
             self.notify()
 
+    @property
+    def lock_name(self) -> str:
+        return self._lock_name
+
     @lock_name.setter
     def lock_name(self, value: str) -> None:
         if self._lock_name != value:
@@ -60,6 +58,10 @@ class QolsysLock(QolsysZWaveDevice):
             self._lock_name = value
             self.notify()
 
+    @property
+    def paired_status(self) -> str:
+        return self._paired_status
+
     @paired_status.setter
     def paired_status(self, value: str) -> None:
         if self._paired_status != value:
@@ -67,54 +69,59 @@ class QolsysLock(QolsysZWaveDevice):
             self._lock_paired_status = value
             self.notify()
 
-    def update_lock(self, data: dict) -> None:  # noqa: PLR0912
+    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", "")
         if node_id_update != self.lock_node_id:
             LOGGER.error(
-                "Updating Lock %s (%s) with Lock '%s' (different id)", self.lock_node_id, self.lock_name, node_id_update)
+                "Updating Lock %s (%s) with Lock '%s' (different id)", self.lock_node_id, self.lock_name, node_id_update
+            )
             return
 
         self.start_batch_update()
 
         if "version" in data:
-            self._lock_version = data.get("version")
+            self._lock_version = data.get("version", "")
         if "opr" in data:
-            self._lock_opr = data.get("opr")
+            self._lock_opr = data.get("opr", "")
         if "partition_id" in data:
-            self._lock_partition_id = data.get("partition_id")
+            self._lock_partition_id = data.get("partition_id", "")
         if "lock_name" in data:
-            self.lock_name = data.get("lock_name")
+            self.lock_name = data.get("lock_name", "")
         if "status" in data:
-            self.lock_status = data.get("status")
+            self.lock_status = data.get("status", "")
         if "created_by" in data:
-            self._lock_created_by = data.get("created_by")
+            self._lock_created_by = data.get("created_by", "")
         if "created_date" in data:
-            self._lock_created_date = data.get("created_date")
+            self._lock_created_date = data.get("created_date", "")
         if "updated_by" in data:
-            self._lock_updated_by = data.get("updated_by")
+            self._lock_updated_by = data.get("updated_by", "")
         if "last_updated_date" in data:
-            self._lock_last_updated_date = data.get("last_updated_date")
+            self._lock_last_updated_date = data.get("last_updated_date", "")
         if "remote_arming" in data:
-            self._lock_remote_arming = data.get("remote_arming")
+            self._lock_remote_arming = data.get("remote_arming", "")
         if "keyfob_arming" in data:
-            self._lock_keyfob_arming = data.get("keyfob_arming")
+            self._lock_keyfob_arming = data.get("keyfob_arming", "")
         if "panel_arming" in data:
-            self._lock_panel_arming = data.get("panel_arming")
+            self._lock_panel_arming = data.get("panel_arming", "")
         if "endpoint" in data:
-            self._lock_endpoint = data.get("endpoint")
+            self._lock_endpoint = data.get("endpoint", "")
         if "paired_status" in data:
-            self._lock_paired_status = data.get("paired_status")
+            self._lock_paired_status = data.get("paired_status", "")
 
         self.end_batch_update()
 
-    def to_dict_lock(self) -> dict:
+    def to_dict_lock(self) -> dict[str, str]:
         return {
             "_id": self._lock_id,
             "version": self._lock_version,
             "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

@@ -6,6 +6,8 @@ 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())

qolsys_controller/zwave_service_meter.py

@@ -0,0 +1,192 @@
+__all__ = ["QolsysZwaveMeterSensor"]
+
+import json
+import logging
+from enum import IntEnum
+from typing import TYPE_CHECKING, Any, Type
+
+from qolsys_controller.enum_zwave import (
+    MeterRateType,
+    MeterType,
+    ZWaveElectricMeterScale,
+    ZWaveUnknownMeterScale,
+)
+
+if TYPE_CHECKING:
+    from .zwave_device import QolsysZWaveDevice
+
+LOGGER = logging.getLogger(__name__)
+
+
+def get_enum_by_name(enum: type[IntEnum], name: str) -> IntEnum | None:
+    for val in enum:
+        if val.name.upper() == name.upper():
+            return val
+    return None
+
+
+class QolsysZwaveMeterSensor:
+    def __init__(self, parent_device: "QolsysZWaveDevice", parent_meter: "QolsysZwaveServiceMeter", scale: IntEnum) -> None:
+        self._parent_device: QolsysZWaveDevice = parent_device
+        self._parent_meter: QolsysZwaveServiceMeter = parent_meter
+        self._scale: IntEnum = scale
+        self._value: float | None = None
+        self._delta_time: int | None = None
+        self._previous_value: float | None = None
+
+    @property
+    def value(self) -> float | None:
+        return self._value
+
+    @value.setter
+    def value(self, new_value: float | None) -> None:
+        if self._value != new_value:
+            self._value = new_value
+            LOGGER.debug(
+                "ZWaveMeter%s-%s (%s) - %s - value: %s (%s)",
+                self._parent_device.node_id,
+                self._parent_meter.endpoint,
+                self._parent_device.node_name,
+                self._parent_meter._meter_type.name,
+                new_value,
+                self._scale.name,
+            )
+            self._parent_device.notify()
+
+    @property
+    def scale(self) -> IntEnum:
+        return self._scale
+
+
+class QolsysZwaveServiceMeter:
+    def __init__(self, parent_device: "QolsysZWaveDevice", endpoint: str, meter_dict: dict[str, Any]) -> None:
+        self._parent_device: QolsysZWaveDevice = parent_device
+        self._endpoint: str = endpoint
+        self._meter_type: MeterType = MeterType.UNKNOWN
+        self._rate_type: MeterRateType = MeterRateType.UNSPECIFIED
+        self._scale_type: Type[IntEnum] = ZWaveUnknownMeterScale
+        self._supported_scale: list[IntEnum] = []
+        self._sensors: list[QolsysZwaveMeterSensor] = []
+        self._master_reset_flag: bool = False
+
+        # Set Meter_Type
+        type: str | int = meter_dict.get("meter_type", "")
+        if type == "ENERGY_METER" or type == MeterType.ELECTRIC_METER.value:
+            self._meter_type = MeterType.ELECTRIC_METER
+            self._scale_type = ZWaveElectricMeterScale
+        else:
+            LOGGER.warning("Zave Meter Service - Unknown Meter Type: %s", type)
+            return
+
+        # Set Rate Type
+        rate_type: int = meter_dict.get("meter_ratetype_supported", -1)
+        try:
+            self._rate_type = MeterRateType(rate_type)
+        except ValueError:
+            LOGGER.error("Zave Meter Service - Unknown MeterRateType, Setting to UNSPECIFIED")
+            self._rate_type = MeterRateType.UNSPECIFIED
+
+        # Set Master Reset Flag
+        self._master_reset_flag = bool(meter_dict.get("meter_master_reset_flag", False))
+
+        # Set Supported Scales
+        self.supported_scale = meter_dict.get("meter_scale_supported", "[]")
+
+        # Create Sensors for Supported Scales
+        for scale in self._supported_scale:
+            qolsys_meter_sensor = QolsysZwaveMeterSensor(self._parent_device, self, scale)
+            self.add_sensor(qolsys_meter_sensor)
+
+        # Update sensor values
+        self.update_iq2medi(meter_dict)
+
+    @property
+    def sensors(self) -> list[QolsysZwaveMeterSensor]:
+        return self._sensors
+
+    def add_sensor(self, new_sensor: QolsysZwaveMeterSensor) -> None:
+        for sensor in self._sensors:
+            if sensor._scale == new_sensor._scale:
+                LOGGER.error("Error Adding Sensor, scale allready present")
+                return
+        self._sensors.append(new_sensor)
+        self._parent_device.notify()
+
+    def get_sensor(self, scale: IntEnum) -> QolsysZwaveMeterSensor | None:
+        for sensor in self._sensors:
+            if sensor._scale == scale:
+                return sensor
+        return None
+
+    @property
+    def endpoint(self) -> str:
+        return self._endpoint
+
+    @property
+    def rate_type(self) -> MeterRateType:
+        return self._rate_type
+
+    @rate_type.setter
+    def rate_type(self, value: MeterRateType) -> None:
+        if self._rate_type != value:
+            self._rate_type = value
+            # LOGGER.debug("Zave Meter Service - rate_type: %s", value.name)
+            self._parent_device.notify()
+
+    @property
+    def supported_scale(self) -> list[IntEnum]:
+        return self._supported_scale
+
+    @supported_scale.setter
+    def supported_scale(self, value: str) -> None:
+        try:
+            scales = json.loads(value)
+            cleaned = [s.strip() for s in scales]
+
+        except json.JSONDecodeError:
+            self._supported_scale = []
+            LOGGER.error("Zave Meter Service - Error parsing meter_scale_supported, Setting to empty list")
+
+        for key in cleaned:
+            for scale in self._scale_type:
+                if key.lower() == scale.name.lower():
+                    if scale not in self._supported_scale:
+                        self._supported_scale.append(scale)
+
+    def update_iq2medi(self, data: dict[str, Any]) -> None:
+        # Update Z-Wave Meter Service
+
+        # Cannot change meter type once created
+        type: str | int = data.get("meter_type", "")
+        if type == "ENERGY_METER" or type == MeterType.ELECTRIC_METER:
+            if self._meter_type is not MeterType.ELECTRIC_METER:
+                LOGGER.error("Zave Meter Service - Cannot change Meter Type once created")
+                return
+
+        self._parent_device.start_batch_update()
+
+        # Upate Rate Type
+        if "meter_ratetype_supported" in data:
+            rate_type: int = data.get("meter_ratetype_supported", -1)
+            try:
+                self.rate_type = MeterRateType(rate_type)
+            except ValueError:
+                LOGGER.error("Zave Meter Service - Unknown MeterRateType, Setting to UNSPECIFIED")
+                self.rate_type = MeterRateType.UNSPECIFIED
+
+        # Update Master Reset Flag
+        if "meter_master_reset_flag" in data:
+            self._master_reset_flag = bool(data.get("meter_master_reset_flag", False))
+
+        # Update Meter Values
+        if "meter_scale_reading_values" in data:
+            scale_values: dict[str, Any] = data.get("meter_scale_reading_values", {})
+
+            for key, value in scale_values.items():
+                temp = get_enum_by_name(self._scale_type, key.strip())
+                if temp in self._supported_scale:
+                    sensor = self.get_sensor(temp)
+                    if sensor is not None:
+                        sensor.value = float(value)
+
+        self._parent_device.end_batch_update()

qolsys_controller/zwave_service_multilevelsensor.py

@@ -0,0 +1,119 @@
+__all__ = ["QolsysZwaveMultilevelSensor"]
+
+import logging
+from enum import IntEnum
+from typing import TYPE_CHECKING, Any
+
+from qolsys_controller.enum_zwave import ZWaveMultilevelSensorScale
+
+if TYPE_CHECKING:
+    from .zwave_device import QolsysZWaveDevice
+
+LOGGER = logging.getLogger(__name__)
+
+
+def get_enum_by_name(enum: type[IntEnum], name: str) -> IntEnum | None:
+    for val in enum:
+        if val.name.upper() == name.upper():
+            return val
+    return None
+
+
+class QolsysZwaveMultilevelSensor:
+    def __init__(
+        self,
+        parent_device: "QolsysZWaveDevice",
+        parent_sensor: "QolsysZwaveServiceMultilevelSensor",
+        unit: ZWaveMultilevelSensorScale,
+    ) -> None:
+        self._parent_device: QolsysZWaveDevice = parent_device
+        self._parent_meter: QolsysZwaveServiceMultilevelSensor = parent_sensor
+        self._value: float | None = None
+        self._unit: ZWaveMultilevelSensorScale = unit
+
+    @property
+    def unit(self) -> ZWaveMultilevelSensorScale:
+        return self._unit
+
+    @property
+    def value(self) -> float | None:
+        return self._value
+
+    @value.setter
+    def value(self, new_value: float | None) -> None:
+        if self._value != new_value:
+            self._value = new_value
+            LOGGER.debug(
+                "ZWaveMultilevelSensor%s-%s (%s) - value: %s (%s)",
+                self._parent_device.node_id,
+                self._parent_meter.endpoint,
+                self._parent_device.node_name,
+                new_value,
+                self._unit.name,
+            )
+            self._parent_device.notify()
+
+
+class QolsysZwaveServiceMultilevelSensor:
+    def __init__(self, parent_device: "QolsysZWaveDevice", endpoint: str, sensor_dict: dict[str, Any]) -> None:
+        self._parent_device: QolsysZWaveDevice = parent_device
+        self._endpoint: str = endpoint
+        self._sensors: list[QolsysZwaveMultilevelSensor] = []
+
+        # Update sensor values
+        self.update_iq2medi(sensor_dict)
+
+    @property
+    def sensors(self) -> list[QolsysZwaveMultilevelSensor]:
+        return self._sensors
+
+    def add_sensor(self, new_sensor: QolsysZwaveMultilevelSensor) -> None:
+        for sensor in self._sensors:
+            if sensor._unit == new_sensor._unit:
+                LOGGER.error("Error Adding Sensor, unit allready present")
+                return
+        self._sensors.append(new_sensor)
+        self._parent_device.notify()
+
+    def get_sensor(self, unit: ZWaveMultilevelSensorScale) -> QolsysZwaveMultilevelSensor | None:
+        for sensor in self._sensors:
+            if sensor.unit == unit:
+                return sensor
+        return None
+
+    @property
+    def endpoint(self) -> str:
+        return self._endpoint
+
+    def update_iq2medi(self, data: dict[str, Any]) -> None:
+        # Update Z-Wave Multilevelsensor Service
+
+        self._parent_device.start_batch_update()
+
+        # Update Sensors Values
+        for key, value in data.items():
+            if key == "AIR TEMPERATURE":
+                temperature: float | None = value.get("Fahrenheit (F)", None)
+                sensor = self.get_sensor(ZWaveMultilevelSensorScale.TEMPERATURE_FAHRENHEIT)
+                if sensor:
+                    sensor.value = temperature
+                else:
+                    sensor = QolsysZwaveMultilevelSensor(
+                        self._parent_device, self, ZWaveMultilevelSensorScale.TEMPERATURE_FAHRENHEIT
+                    )
+                    self.add_sensor(sensor)
+                    sensor.value = temperature
+
+            if key == "HUMIDITY":
+                humidity: float | None = value.get("Percentage value (%)", None)
+                sensor = self.get_sensor(ZWaveMultilevelSensorScale.RELATIVE_HUMIDITY)
+                if sensor:
+                    sensor.value = humidity
+                else:
+                    sensor = QolsysZwaveMultilevelSensor(
+                        self._parent_device, self, ZWaveMultilevelSensorScale.RELATIVE_HUMIDITY
+                    )
+                    self.add_sensor(sensor)
+                    sensor.value = humidity
+
+        self._parent_device.end_batch_update()

qolsys_controller/zwave_thermometer.py

@@ -0,0 +1,21 @@
+import logging
+
+from .zwave_device import QolsysZWaveDevice
+
+LOGGER = logging.getLogger(__name__)
+
+
+class QolsysThermometer(QolsysZWaveDevice):
+    def __init__(self, zwave_dict: dict[str, str]) -> None:
+        super().__init__(zwave_dict)
+        self._temprature_value = ""
+        self._humidity_value = ""
+
+    def update_raw(self, payload: bytes) -> None:
+        LOGGER.debug("Raw Update (node%s) - payload: %s", self.node_id, payload.hex())
+
+    def to_dict_thermometer(self) -> dict[str, str]:
+        return {
+            "temperature_value": self._temprature_value,
+            "humidity_value": self._humidity_value,
+        }