qolsys-controller 0.0.28__py3-none-any.whl → 0.0.51__py3-none-any.whl

qolsys_controller/settings.py

@@ -1,19 +1,29 @@
+from __future__ import annotations
+
 import logging
 from pathlib import Path
+from typing import TYPE_CHECKING
 
 LOGGER = logging.getLogger(__name__)
 
+if TYPE_CHECKING:
+    from .controller import QolsysController
+
 
 class QolsysSettings:
 
-    def __init__(self) -> None:
+    def __init__(self, controller: QolsysController) -> None:
+
+        # Main controller
+        self._controller = controller
 
         # Plugin
-        self._plugin_ip = ""
-        self._random_mac = ""
-        self._panel_mac = ""
-        self._panel_ip = ""
+        self._plugin_ip: str = ""
+        self._random_mac: str = ""
+        self._panel_mac: str  = ""
+        self._panel_ip: str = ""
 
+        # Path
         self._config_directory: Path = Path()
         self._pki_directory: Path = Path()
         self._media_directory: Path = Path()
@@ -25,8 +35,12 @@ class QolsysSettings:
         # MQTT
         self._mqtt_timeout: int = 30
         self._mqtt_ping: int = 600
-        self._mqtt_qos:int = 0
-        self._mqtt_remote_client_id = ""
+        self._mqtt_qos: int = 0
+        self._mqtt_remote_client_id: str = ""
+
+        # Operation
+        self._motion_sensor_delay: bool = True
+        self._motion_sensor_delay_sec: int = 310
 
     @property
     def random_mac(self) -> str:
@@ -52,6 +66,30 @@ class QolsysSettings:
     def panel_ip(self) -> str:
         return self._panel_ip
 
+    @property
+    def mqtt_timeout(self) -> int:
+        return self._mqtt_timeout
+
+    @property
+    def mqtt_ping(self) -> int:
+        return self._mqtt_ping
+
+    @property
+    def motion_sensor_delay(self) -> bool:
+        return self._motion_sensor_delay
+
+    @property
+    def motion_sensor_delay_sec(self) -> int:
+        return self._motion_sensor_delay_sec
+
+    @motion_sensor_delay.setter
+    def motion_sensor_delay(self, value: bool) -> None:
+        self._motion_sensor_delay = value
+
+    @motion_sensor_delay_sec.setter
+    def motion_sensor_delay_sec(self, value: int) -> None:
+        self._motion_sensor_delay_sec = value
+
     @panel_ip.setter
     def panel_ip(self, panel_ip: str) -> None:
         self._panel_ip = panel_ip
@@ -61,7 +99,7 @@ class QolsysSettings:
         self._plugin_ip = plugin_ip
 
     @property
-    def config_directory(self) -> str:
+    def config_directory(self) -> Path:
         return self._config_directory
 
     @config_directory.setter
@@ -83,17 +121,13 @@ class QolsysSettings:
     def key_size(self) -> int:
         return self._key_size
 
-    @property
-    def mqtt_timeout(self) -> int:
-        return self._mqtt_timeout
-
-    @property
-    def mqtt_ping(self) -> int:
-        return self._mqtt_ping
+    @mqtt_timeout.setter
+    def mqtt_timeout(self, value: int) -> None:
+        self._mqtt_timeout = value
 
     @mqtt_ping.setter
-    def mqtt_ping(self, ping:int) -> None:
-        self._mqtt_ping = ping
+    def mqtt_ping(self, value: int) -> None:
+        self._mqtt_ping = value
 
     @property
     def mqtt_qos(self) -> int:
@@ -104,7 +138,7 @@ class QolsysSettings:
         return self._mqtt_remote_client_id
 
     @mqtt_remote_client_id.setter
-    def mqtt_remote_client_id(self,client_id:str) -> None:
+    def mqtt_remote_client_id(self,client_id: str) -> None:
         self._mqtt_remote_client_id = client_id
 
     def check_panel_ip(self) -> bool:
@@ -123,7 +157,7 @@ class QolsysSettings:
         LOGGER.debug("Found Plugin IP: %s", self._plugin_ip)
         return True
 
-    def check_config_directory(self, create: bool = True) -> bool:
+    def check_config_directory(self, create: bool = True) -> bool:  # noqa: PLR0911
         if not self.config_directory.is_dir():
             if not create:
                 LOGGER.debug("config_directory not found:  %s", self.config_directory)

qolsys_controller/state.py

@@ -1,9 +1,10 @@
+from __future__ import annotations
+
 import logging
+from typing import TYPE_CHECKING
 
 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,12 +13,23 @@ 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:
+    def __init__(self, controller: QolsysController) -> None:
         super().__init__()
 
+        self._controller = controller
+
+        self._weather = QolsysWeather()
+
         self._partitions = []
         self._zones = []
         self._zwave_devices = []
@@ -32,6 +44,10 @@ class QolsysState(QolsysObservable):
     def partitions(self) -> list[QolsysPartition]:
         return self._partitions
 
+    @property
+    def weather(self) -> QolsysWeather:
+        return self._weather
+
     @property
     def zwave_devices(self) -> list[QolsysZWaveDevice]:
         return self._zwave_devices
@@ -102,6 +118,7 @@ class QolsysState(QolsysObservable):
                 return
 
         self.partitions.append(new_partition)
+        self.partitions.sort(key=lambda x: x.id, reverse=False)
         self.state_partition_observer.notify()
 
     def partition_delete(self, partition_id: str) -> None:
@@ -128,6 +145,8 @@ class QolsysState(QolsysObservable):
                 return
 
         self.scenes.append(new_scene)
+        self.scenes.sort(key=lambda x: x.scene_id, reverse=False)
+
         self.state_scene_observer.notify()
 
     def scene_delete(self, scene_id: str) -> None:
@@ -144,7 +163,12 @@ class QolsysState(QolsysObservable):
         for zone in self.zones:
             if zone.zone_id == zone_id:
                 return zone
+        return None
 
+    def zone_from_short_id(self, short_id: int) -> QolsysZone | None:
+        for zone in self.zones:
+            if zone.shortID == short_id:
+                return zone
         return None
 
     def zone_add(self, new_zone: QolsysZone) -> None:
@@ -154,6 +178,7 @@ class QolsysState(QolsysObservable):
                 return
 
         self.zones.append(new_zone)
+        self.zones.sort(key=lambda x: x.zone_id, reverse=False)
         self.state_zone_observer.notify()
 
     def zone_delete(self, zone_id: str) -> None:
@@ -181,6 +206,7 @@ class QolsysState(QolsysObservable):
                 return
 
         self.zwave_devices.append(new_zwave)
+        self.zwave_devices.sort(key=lambda x: x.node_id, reverse=False)
         self.state_zwave_observer.notify()
 
     def zwave_delete(self, node_id: str) -> None:
@@ -193,7 +219,7 @@ 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: C901, PLR0912
+    def sync_zwave_devices_data(self, db_zwaves: list[QolsysZWaveDevice]) -> None:  # noqa: PLR0912
 
         db_zwave_list = []
         for db_zwave in db_zwaves:
@@ -247,7 +273,11 @@ class QolsysState(QolsysObservable):
         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)
-                self.zwave_delete(int(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 = []
@@ -271,7 +301,7 @@ class QolsysState(QolsysObservable):
         for state_scene in self.scenes:
             if state_scene.scene_id not in db_scene_list:
                 LOGGER.debug("sync_data - delete Scene%s", state_scene.scene_id)
-                self.scene_delete(int(state_scene.scene_id))
+                self.scene_delete(state_scene.scene_id)
 
         # Add new scene
         for db_scene in db_scenes:
@@ -279,7 +309,7 @@ class QolsysState(QolsysObservable):
                 LOGGER.debug("sync_data - add Scene%s", db_scene.scene_id)
                 self.scene_add(db_scene)
 
-    def sync_zones_data(self, db_zones: list[QolsysZone]) -> None:  # noqa: C901
+    def sync_zones_data(self, db_zones: list[QolsysZone]) -> None:
         db_zone_list = []
         for db_zone in db_zones:
             db_zone_list.append(db_zone.zone_id)
@@ -295,12 +325,13 @@ class QolsysState(QolsysObservable):
                     if state_zone.zone_id == db_zone.zone_id:
                         LOGGER.debug("sync_data - update Zone%s", state_zone.zone_id)
                         state_zone.update(db_zone.to_dict())
+                        state_zone.update_powerg(db_zone.to_powerg_dict())
 
         # Delete zones
         for state_zone in self.zones:
             if state_zone.zone_id not in db_zone_list:
                 LOGGER.debug("sync_data - delete Zone%s", state_zone.zone_id)
-                self.zone_delete(int(state_zone.zone_id))
+                self.zone_delete(state_zone.zone_id)
 
         # Add new zone
         for db_zone in db_zones:
@@ -308,7 +339,7 @@ class QolsysState(QolsysObservable):
                 LOGGER.debug("sync_data - add Zone%s", db_zone.zone_id)
                 self.zone_add(db_zone)
 
-    def sync_partitions_data(self, db_partitions: list[QolsysPartition]) -> None:  # noqa: C901
+    def sync_partitions_data(self, db_partitions: list[QolsysPartition]) -> None:
         db_partition_list = []
         for db_partition in db_partitions:
             db_partition_list.append(db_partition.id)
@@ -340,8 +371,8 @@ 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 ***")
 
         for partition in self.partitions:
             pid = partition.id
@@ -367,6 +398,12 @@ class QolsysState(QolsysObservable):
             LOGGER.debug("Zone%s (%s) - latestdBm: %s", zid, name, zone.latestdBm)
             LOGGER.debug("Zone%s (%s) - averagedBm: %s", zid, name, zone.averagedBm)
 
+            if zone.is_powerg_temperature_enabled():
+                LOGGER.debug("Zone%s (%s) - powerg_temperature: %s", zid, name, zone.powerg_temperature)
+
+            if zone.is_powerg_light_enabled():
+                LOGGER.debug("Zone%s (%s) - powerg_light: %s", zid, name, zone.powerg_light)
+
         for zwave in self.zwave_devices:
             if isinstance(zwave, QolsysDimmer):
                 nid = zwave.node_id
@@ -394,7 +431,7 @@ class QolsysState(QolsysObservable):
             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)
                 continue
 
             if isinstance(zwave, QolsysGeneric):
@@ -410,3 +447,6 @@ class QolsysState(QolsysObservable):
             sid = scene.scene_id
             name = scene.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

@@ -14,19 +14,36 @@ class QolsysTaskManager:
         self._tasks.add(task)
 
         def _done_callback(task: asyncio.Task) -> None:
+
+            try:
+                task.result()
+
+            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)
+
             self._tasks.discard(task)
 
         task.add_done_callback(_done_callback)
         return task
 
+    def get_task(self, label:str) -> asyncio.Task | None:
+        for task in self._tasks:
+             if task.get_name() == label:
+                 return task
+        return None
+
     def cancel(self, label: str) -> None:
         for task in self._tasks:
             if task.get_name() == label:
                 task.cancel()
 
-    def cancel_all(self) -> None:
+    async def cancel_all(self) -> None:
         for task in self._tasks:
             task.cancel()
+            await task
 
     async def wait_all(self) -> None:
         if self._tasks:

qolsys_controller/weather.py

@@ -0,0 +1,74 @@
+import logging
+
+from .observable import QolsysObservable
+
+LOGGER = logging.getLogger(__name__)
+
+
+class QolsysForecast:
+    def __init__(self, data: dict) -> None:
+        self._high_temp = data.get("high_temp", "")
+        self._low_temp = data.get("low_temp", "")
+        self._day_of_week = data.get("day_of_week", "")
+        self._condition = data.get("condition", "")
+        self._icon = data.get("icon", "")
+        self._precipitation = data.get("precipitation", "")
+        self._current_weather_date = 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
+
+    def to_dict(self) -> dict:
+        pass

qolsys_controller/zone.py

@@ -1,5 +1,8 @@
+import asyncio
 import logging
 
+from qolsys_controller.settings import QolsysSettings
+
 from .enum import ZoneSensorGroup, ZoneSensorType, ZoneStatus
 from .observable import QolsysObservable
 
@@ -8,9 +11,13 @@ LOGGER = logging.getLogger(__name__)
 
 class QolsysZone(QolsysObservable):
 
-    def __init__(self, data: dict) -> None:
+    def __init__(self, data: dict, settings: QolsysSettings) -> None:  # noqa: PLR0915
         super().__init__()
 
+        self._settings = settings
+
+        self._delay_task:asyncio.Task = None
+
         self._zone_id = data.get("zoneid", "")
         self._sensorname = data.get("sensorname", "")
         self._sensorstatus: ZoneStatus = ZoneStatus(data.get("sensorstatus", ""))
@@ -20,6 +27,9 @@ class QolsysZone(QolsysObservable):
         self._averagedBm = data.get("averagedBm", "")
         self._latestdBm = data.get("latestdBm", "")
         self._ac_status = data.get("ac_status", "")
+        self._shortID = data.get("shortID", "")
+        self._device_capability = data.get("device_capability", "")
+        self._current_capability = data.get("current_capability", "")
 
         self._id = data.get("_id", "")
         self._zone_type = data.get("zone_type", "")
@@ -49,14 +59,69 @@ class QolsysZone(QolsysObservable):
         self._created_by = data.get("created_by", "")
         self._updated_by = data.get("updated_by", "")
         self._updated_date = data.get("updated_date", "")
-        self._shortID = data.get("shortID", "")
         self._diag_24hr = data.get("diag_24hr", "")
-        self._device_capability = data.get("device_capability", "")
         self._sub_type = data.get("sub_type", "")
         self._powerg_manufacture_id = data.get("powerg_manufacture_id", "")
         self._parent_node = data.get("parent_node", "")
         self._extras = data.get("extras", "")
 
+        # EXTRA POWERG ATTRIBUTES
+        self._powerg_long_id = ""
+        self._powerg_status_data:str = ""
+        self._powerg_temperature:str = ""
+        self._powerg_light:str = ""
+        self._powerg_notification_period = ""
+        self._powerg_average_link_quality = ""
+        self._powerg_link_quality = ""
+        self._powerg_link_status = ""
+        self._powerg_battery_voltage = ""
+
+    def is_powerg_enabled(self) -> bool:
+        return self._current_capability == "PowerG"
+
+    def is_powerg_temperature_enabled(self) -> bool:
+        return self._powerg_temperature != ""
+
+    def is_powerg_light_enabled(self) -> bool:
+        return self._powerg_light != ""
+
+    def update_powerg(self, data: dict) -> None:
+        short_id_update = data.get("shortID", "")
+        if short_id_update != self.shortID:
+            LOGGER.error("Updating Zone%s PowerG Attribute (%s) with Zone%s (different shortID)", self._zone_id, self.sensorname, short_id_update)
+            return
+
+        self.start_batch_update()
+
+        if "longID" in data:
+            self._powerg_long_id = data.get("longID")
+
+        if "status_data" in data:
+            self.powerg_status_data = data.get("status_data")
+
+        if "temperature" in data:
+            self.powerg_temperature = data.get("temperature")
+
+        if "light" in data:
+            self.powerg_light = data.get("light")
+
+        if "notification_period" in data:
+            self._powerg_notification_period = data.get("notification_period")
+
+        if "average_link_quality" in data:
+            self._powerg_average_link_quality = data.get("average_link_quality")
+
+        if "link_quality" in data:
+            self._powerg_link_quality = data.get("link_quality")
+
+        if "link_status" in data:
+            self._powerg_link_status = data.get("link_status")
+
+        if "battery_voltage" in data:
+            self._powerg_battery_voltage = data.get("battery_voltage")
+
+        self.end_batch_update()
+
     def update(self, data: dict) -> None:  # noqa: C901, PLR0912, PLR0915
 
         zone_id_update = data.get("zoneid", "")
@@ -66,31 +131,24 @@ class QolsysZone(QolsysObservable):
 
         self.start_batch_update()
 
-        # Update sensor_name
         if "sensorname" in data:
             self.sensorname = data.get("sensorname")
 
-        # Update sensorsatus
         if "sensorstatus" in data:
             self.sensorstatus = ZoneStatus(data.get("sensorstatus"))
 
-        # Update battery_status
         if "battery_status" in data:
             self.battery_status = data.get("battery_status")
 
-        # Update time
         if "time" in data:
             self.time = data.get("time")
 
-        # Update partition_id
         if "partition_id" in data:
             self._partition_id = data.get("partition_id")
 
-        # Update lastestdBm
         if "lastestdBm" in data:
             self.latestdBm = data.get("latestdBm")
 
-        # Update averagedBm
         if "averagedBm" in data:
             self.averagedBm = data.get("averagedBm")
 
@@ -198,10 +256,18 @@ class QolsysZone(QolsysObservable):
     def partition_id(self) -> str:
         return self._partition_id
 
+    @property
+    def shortID(self) -> str:
+        return self._shortID
+
     @property
     def time(self) -> str:
         return self._time
 
+    @property
+    def current_capability(self) -> str:
+        return self._current_capability
+
     @property
     def latestdBm(self) -> str:
         return self._latestdBm
@@ -210,25 +276,83 @@ class QolsysZone(QolsysObservable):
     def averagedBm(self) -> str:
         return self._averagedBm
 
+    @property
+    def device_capability(self) -> str:
+        return self._device_capability
+
+    @property
+    def powerg_temperature(self) -> float | None:
+        return self._powerg_temperature
+
+    @property
+    def powerg_light(self) -> float | None:
+        return self._powerg_light
+
+    @property
+    def powerg_status_data(self) -> str:
+        return self._powerg_status_data
+
+    @powerg_temperature.setter
+    def powerg_temperature(self, value: str) -> None:
+        if self._powerg_temperature != value:
+                LOGGER.debug("Zone%s (%s) - powerg_temperature: %s", self._zone_id, self.sensorname, value)
+                self._powerg_temperature = value
+                self.notify()
+
+    @powerg_light.setter
+    def powerg_light(self, value: str) -> None:
+        if self._powerg_light != value:
+            LOGGER.debug("Zone%s (%s) - powerg_light: %s", self._zone_id, self.sensorname, value)
+            self._powerg_light = value
+            self.notify()
+
+    @powerg_status_data.setter
+    def powerg_status_data(self, value: str) -> None:
+        if self._powerg_status_data != value:
+            LOGGER.debug("Zone%s (%s) - powerg_status_data: %s", self._zone_id, self.sensorname, value)
+            self._powerg_status_data = value
+            self.notify()
+
     @averagedBm.setter
     def averagedBm(self, value: str) -> None:
         if self._averagedBm != value:
             self._averagedBm = value
+
+            if value == "":
+                self._averagedBm = 0
+
             self.notify()
 
     @latestdBm.setter
     def latestdBm(self, value: str) -> None:
         if self._latestdBm != value:
             self.latestdBm = value
+
+            if value == "":
+                self._latestdBm = 0
+
             self.notify()
 
     @sensorstatus.setter
     def sensorstatus(self, new_value: ZoneStatus) -> None:
+        if self._settings.motion_sensor_delay and self._sensortype in {ZoneSensorType.MOTION, ZoneSensorType.PANEL_MOTION}:
+            if new_value == ZoneStatus.IDLE:
+                return
+            if self._delay_task is not None:
+                self._delay_task.cancel()
+            self._delay_task = asyncio.create_task(self.delay_zone(ZoneStatus.IDLE))
+
         if self._sensorstatus != new_value:
             LOGGER.debug("Zone%s (%s) - sensorstatus: %s", self._zone_id, self.sensorname, new_value)
             self._sensorstatus = new_value
             self.notify()
 
+    async def delay_zone(self,next_status: ZoneStatus) -> None:
+        await asyncio.sleep(self._settings.motion_sensor_delay_sec)
+        self._sensorstatus = next_status
+        LOGGER.debug("Zone%s (%s) - sensorstatus: %s", self._zone_id, self.sensorname, next_status)
+        self.notify()
+
     @battery_status.setter
     def battery_status(self, value: str) -> None:
         if self._battery_status != value:
@@ -275,6 +399,20 @@ class QolsysZone(QolsysObservable):
             self.partition_id = value
             self.notify()
 
+    def to_powerg_dict(self) -> dict:
+        return {
+            "shortID": self.shortID,
+            "longID": self._powerg_long_id,
+            "status_data": self._powerg_status_data,
+            "temperature": self._powerg_temperature,
+            "light": self._powerg_light,
+            "notification_period": self._powerg_notification_period,
+            "average_link_quality": self._powerg_average_link_quality,
+            "link_quality": self._powerg_link_quality,
+            "link_status": self._powerg_link_status,
+            "battery_voltage": self._powerg_battery_voltage,
+        }
+
     def to_dict(self) -> dict:
         return {
             "_id": self.id,