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

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,
+        }

qolsys_controller/zwave_thermostat.py

@@ -1,6 +1,14 @@
 import logging
 
-from .enum_zwave import ThermostatFanMode, ThermostatMode
+from .enum_zwave import (
+    BITMASK_SUPPORTED_THERMOSTAT_FAN_MODE,
+    BITMASK_SUPPORTED_THERMOSTAT_MODE,
+    BITMASK_SUPPORTED_THERMOSTAT_SETPOINT_MODE,
+    ThermostatFanMode,
+    ThermostatMode,
+    ThermostatSetpointMode,
+    ZWaveMultilevelSensorScale,
+)
 from .zwave_device import QolsysZWaveDevice
 
 LOGGER = logging.getLogger(__name__)
@@ -41,6 +49,10 @@ class QolsysThermostat(QolsysZWaveDevice):
         self._thermostat_endpoint: str = thermostat_dict.get("endpoint", "")
         self._thermostat_paired_status: str = thermostat_dict.get("paired_status", "")
         self._thermostat_configuration_parameter: str = thermostat_dict.get("configuration_parameter", "")
+        self._thermostat_operating_state: str = thermostat_dict.get("operating_state", "")
+        self._thermostat_setpoint_capabilites = thermostat_dict.get("setpoint_capabilites", "")
+
+        self._thermostat_current_humidity: float | None = None
 
     # -----------------------------
     # properties + setters
@@ -61,6 +73,41 @@ class QolsysThermostat(QolsysZWaveDevice):
             self._thermostat_name = value
             self.notify()
 
+    @property
+    def thermostat_operating_state(self) -> str:
+        return self._thermostat_operating_state
+
+    @thermostat_operating_state.setter
+    def thermostat_operating_state(self, value: str) -> None:
+        if self._thermostat_operating_state != value:
+            LOGGER.debug("Thermostat%s (%s) - operating_state: %s", self.thermostat_node_id, self.thermostat_name, value)
+            self._thermostat_operating_state = value
+            self.notify()
+
+    @property
+    def thermostat_configuration_parameter(self) -> str:
+        return self._thermostat_configuration_parameter
+
+    @thermostat_configuration_parameter.setter
+    def thermostat_configuration_parameter(self, value: str) -> None:
+        if self._thermostat_configuration_parameter != value:
+            LOGGER.debug(
+                "Thermostat%s (%s) - configuration_parameter: %s", self.thermostat_node_id, self.thermostat_name, value
+            )
+            self._thermostat_configuration_parameter = value
+            self.notify()
+
+    @property
+    def thermostat_setpoint_capabilites(self) -> str:
+        return self._thermostat_setpoint_capabilites
+
+    @thermostat_setpoint_capabilites.setter
+    def thermostat_setpoint_capabilites(self, value: str) -> None:
+        if self._thermostat_setpoint_capabilites != value:
+            LOGGER.debug("Thermostat%s (%s) - setpoint_capabilites: %s", self.thermostat_node_id, self.thermostat_name, value)
+            self._thermostat_setpoint_capabilites = value
+            self.notify()
+
     @property
     def thermostat_device_temp_unit(self) -> str:
         return self._thermostat_device_temp_unit
@@ -118,37 +165,79 @@ class QolsysThermostat(QolsysZWaveDevice):
 
     @property
     def thermostat_mode(self) -> ThermostatMode | None:
-        thermostat_mode = int(self._thermostat_mode)
-        for mode in ThermostatMode:
-            if thermostat_mode == mode:
-                return mode
-        return None
+        value = self._thermostat_mode.strip("[]").split(",")
+
+        if len(value) > 1:
+            LOGGER.error(
+                "Thermostat%s (%s) - thermostat_mode has multiple values: %s",
+                self.thermostat_node_id,
+                self.thermostat_name,
+                value,
+            )
+            return None
+
+        try:
+            int_value = int(value[0])
+            for mode in ThermostatMode:
+                if int_value == mode.value:
+                    return mode
+            return None
+        except ValueError:
+            LOGGER.error(
+                "Thermostat%s (%s) - thermostat_mode value is not an integer: %s",
+                self.thermostat_node_id,
+                self.thermostat_name,
+                value,
+            )
+            return None
 
     @thermostat_mode.setter
     def thermostat_mode(self, value: str) -> None:
-        if self._thermostat_mode != value:
-            LOGGER.debug("Thermostat%s (%s) - mode: %s", self.thermostat_node_id, self.thermostat_name, value)
-            self._thermostat_mode = value
+        new_value = value.strip("[]")
+        if self._thermostat_mode != new_value:
+            LOGGER.debug("Thermostat%s (%s) - mode: %s", self.thermostat_node_id, self.thermostat_name, new_value)
+            self._thermostat_mode = new_value
             self.notify()
 
     @property
     def thermostat_fan_mode(self) -> ThermostatFanMode | None:
-        thermostat_fan_mode = int(self._thermostat_fan_mode)
-        for mode in ThermostatFanMode:
-            if thermostat_fan_mode == mode:
-                return mode
-        return None
+        value = self._thermostat_fan_mode.strip("[]").split(",")
+
+        if len(value) > 1:
+            LOGGER.error(
+                "Thermostat%s (%s) - thermostat_fan_mode has multiple values: %s",
+                self.thermostat_node_id,
+                self.thermostat_name,
+                value,
+            )
+            return None
+
+        try:
+            int_value = int(value[0])
+            for mode in ThermostatFanMode:
+                if int_value == mode.value:
+                    return mode
+            return None
+        except ValueError:
+            LOGGER.error(
+                "Thermostat%s (%s) - thermostat_fan_mode value is not an integer: %s",
+                self.thermostat_node_id,
+                self.thermostat_name,
+                value,
+            )
+            return None
 
     @thermostat_fan_mode.setter
     def thermostat_fan_mode(self, value: str) -> None:
-        if self._thermostat_fan_mode != value:
-            LOGGER.debug("Thermostat%s (%s) - fan_mode: %s", self.thermostat_node_id, self.thermostat_name, value)
-            self._thermostat_fan_mode = value
+        new_value = value.strip("[]")
+        if self._thermostat_fan_mode != new_value:
+            LOGGER.debug("Thermostat%s (%s) - fan_mode: %s", self.thermostat_node_id, self.thermostat_name, new_value)
+            self._thermostat_fan_mode = new_value
             self.notify()
 
     @property
     def thermostat_set_point_mode(self) -> str:
-        return self._thermostat_set_point_mode
+        return self._thermostat_set_point_mode.strip("[]")
 
     @thermostat_set_point_mode.setter
     def thermostat_set_point_mode(self, value: str) -> None:
@@ -157,6 +246,22 @@ class QolsysThermostat(QolsysZWaveDevice):
             self._thermostat_set_point_mode = value
             self.notify()
 
+    @property
+    def thermostat_current_humidity(self) -> float | None:
+        sensor = self.multilevelsensor_value(ZWaveMultilevelSensorScale.RELATIVE_HUMIDITY)
+
+        if not sensor:
+            return None
+
+        if len(sensor) == 1:
+            return sensor[0].value
+
+        LOGGER.error("Multiple humidity sensor present")
+        return sensor[0].value
+
+    def update_raw(self, payload: bytes) -> None:
+        pass
+
     def update_thermostat(self, data: dict[str, str]) -> None:  # noqa: C901, PLR0912, PLR0915
         # Check if we are updating same none_id
         node_id_update = data.get("node_id", "")
@@ -227,6 +332,10 @@ class QolsysThermostat(QolsysZWaveDevice):
             self._thermostat_endpoint = data.get("endpoint", "")
         if "configuration_parameter" in data:
             self._thermostat_configuration_parameter = data.get("configuration_parameter", "")
+        if "operating_state" in data:
+            self.thermostat_operating_state = data.get("operating_state", "")
+        if "setpoint_capabilites" in data:
+            self.thermostat_setpoint_capabilites = data.get("setpoint_capabilites", "")
 
         self.end_batch_update()
 
@@ -237,6 +346,7 @@ class QolsysThermostat(QolsysZWaveDevice):
             "opr": self._thermostat_opr,
             "partition_id": self._thermostat_partition_id,
             "thermostat_name": self.thermostat_name,
+            "node_id": self.thermostat_node_id,
             "device_temp_unit": self.thermostat_device_temp_unit,
             "current_temp": self.thermostat_current_temp,
             "target_cool_temp": self.thermostat_target_cool_temp,
@@ -260,41 +370,43 @@ class QolsysThermostat(QolsysZWaveDevice):
             "current_temp_updated_time": self._thermostat_current_temp_updated_time,
             "paired_status": self._thermostat_paired_status,
             "endpoint": self._thermostat_endpoint,
-            "configuration_parameter": self._thermostat_configuration_parameter,
+            "configuration_parameter": self.thermostat_configuration_parameter,
+            "operating_state": self.thermostat_operating_state,
+            "setpoint_capabilites": self._thermostat_setpoint_capabilites,
         }
 
     def available_thermostat_mode(self) -> list[ThermostatMode]:
-        int_list = [int(x) for x in self._thermostat_mode_bitmask.split(",")]
+        int_list = [int(x) for x in self._thermostat_mode_bitmask.strip("[]").split(",")]
         byte_array = bytes(int_list)
         bitmask = int.from_bytes(byte_array, byteorder="little")
 
-        mode_array = []
-        for mode in ThermostatMode:
-            if mode.value & bitmask:
-                mode_array.append(mode)
+        supported = []
+        for bit, mode in BITMASK_SUPPORTED_THERMOSTAT_MODE.items():
+            if bitmask & (1 << bit):
+                supported.append(mode)
 
-        return mode_array
+        return supported
 
     def available_thermostat_fan_mode(self) -> list[ThermostatFanMode]:
-        int_list = [int(x) for x in self._thermostat_fan_mode_bitmask.split(",")]
+        int_list = [int(x) for x in self._thermostat_fan_mode_bitmask.strip("[]").split(",")]
         byte_array = bytes(int_list)
         bitmask = int.from_bytes(byte_array, byteorder="little")
 
-        fan_mode_array = []
-        for mode in ThermostatFanMode:
-            if mode.value & bitmask:
-                fan_mode_array.append(mode)
+        supported = []
+        for bit, mode in BITMASK_SUPPORTED_THERMOSTAT_FAN_MODE.items():
+            if bitmask & (1 << bit):
+                supported.append(mode)
 
-        return fan_mode_array
+        return supported
 
-    def available_thermostat_set_point_mode(self) -> list[ThermostatMode]:
-        int_list = [int(x) for x in self._thermostat_set_point_mode_bitmask.split(",")]
+    def available_thermostat_set_point_mode(self) -> list[ThermostatSetpointMode]:
+        int_list = [int(x) for x in self._thermostat_set_point_mode_bitmask.strip("[]").split(",")]
         byte_array = bytes(int_list)
         bitmask = int.from_bytes(byte_array, byteorder="little")
 
-        set_point_mode_array = []
-        for mode in ThermostatMode:
-            if mode.value & bitmask:
-                set_point_mode_array.append(mode)
+        supported = []
+        for bit, mode in BITMASK_SUPPORTED_THERMOSTAT_SETPOINT_MODE.items():
+            if bitmask & (1 << bit):
+                supported.append(mode)
 
-        return set_point_mode_array
+        return supported

{qolsys_controller-0.0.62.dist-info → qolsys_controller-0.0.87.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: qolsys-controller
-Version: 0.0.62
+Version: 0.0.87
 Summary: A Python module that emulates a virtual IQ Remote device, enabling full local control of a Qolsys IQ Panel
 Project-URL: Homepage, https://github.com/EHylands/QolsysController
 Project-URL: Issues, https://github.com/EHylands/QolsysController/issues