qolsys-controller 0.0.34__tar.gz → 0.0.35__tar.gz

{qolsys_controller-0.0.34 → qolsys_controller-0.0.35}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: qolsys-controller
-Version: 0.0.34
+Version: 0.0.35
 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
@@ -33,10 +33,11 @@ A Python module that emulates a virtual IQ Remote device, enabling full **local
 | **Panel**            | Diagnostics sensors              | ✅  |
 |---|---|---|
 | **Partitions**       | Arming status                    | ✅ |
-|                      | Set Exit sounds                  | ✅            |
-|                      | Home Instant arming              | ✅            |
-|                      | Home Silent Disarm               | ✅            |
 |                      | Alarm state and type             | ✅            |
+|                      | Set Exit sound                   | ✅            |
+|                      | Set Entry Delay                  | ✅            |
+|                      | Arm-Stay Instant arming          | ✅            |
+|                      | Arm-Stay Silent Disarm           | ✅            |
 |                      | Disarm pictures             | 🛠️ WIP            |
 |---|---|---|
 | **Zones**            | Sensor Status                    | ✅            |

{qolsys_controller-0.0.34 → qolsys_controller-0.0.35}/README.md

@@ -17,10 +17,11 @@ A Python module that emulates a virtual IQ Remote device, enabling full **local
 | **Panel**            | Diagnostics sensors              | ✅  |
 |---|---|---|
 | **Partitions**       | Arming status                    | ✅ |
-|                      | Set Exit sounds                  | ✅            |
-|                      | Home Instant arming              | ✅            |
-|                      | Home Silent Disarm               | ✅            |
 |                      | Alarm state and type             | ✅            |
+|                      | Set Exit sound                   | ✅            |
+|                      | Set Entry Delay                  | ✅            |
+|                      | Arm-Stay Instant arming          | ✅            |
+|                      | Arm-Stay Silent Disarm           | ✅            |
 |                      | Disarm pictures             | 🛠️ WIP            |
 |---|---|---|
 | **Zones**            | Sensor Status                    | ✅            |

{qolsys_controller-0.0.34 → qolsys_controller-0.0.35}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "qolsys-controller"
-version = "0.0.34"
+version = "0.0.35"
 authors = [
   { name="Eric Hylands", email="" },
 ]

{qolsys_controller-0.0.34 → qolsys_controller-0.0.35}/qolsys_controller/enum.py

@@ -26,6 +26,7 @@ class PartitionAlarmType(StrEnum):
     SILENT_AUXILIARY_EMERGENCY = "Silent Auxiliary Emergency"
     SILENT_POLICE_EMERGENCY = "Silent Police Emergency"
     GLASS_BREAK_AWAY_ONLY = "glassbreakawayonly"
+    GLASS_BREAK = "glassbreak"
 
 class ZoneStatus(StrEnum):
     ALARMED = "Alarmed"

{qolsys_controller-0.0.34 → qolsys_controller-0.0.35}/qolsys_controller/panel.py

@@ -353,7 +353,7 @@ class QolsysPanel(QolsysObservable):
     def parse_iq2meid_message(self, data: dict) -> bool:  # noqa: C901, PLR0912, PLR0915
 
         eventName = data.get("eventName")
-        dbOperation = data.get("dbOperation")
+        dbOperation = data.get("dbOperation","")
         uri = data.get("uri")
 
         match eventName:
@@ -361,6 +361,9 @@ class QolsysPanel(QolsysObservable):
             case "stopScreenCapture":
                 pass
 
+            case "primaryDisconnect":
+                LOGGER.info("Main Panel Disconnect")
+
             case "dbChanged":
 
                 match dbOperation:
@@ -508,6 +511,11 @@ class QolsysPanel(QolsysObservable):
                                 if scene is not None and isinstance(node, QolsysScene):
                                     scene.update(content_values)
 
+                            # Update Trouble Conditions
+                            case self.db.table_trouble_conditions:
+                                self.db.table_trouble_conditions.update(selection,selection_argument,content_values)
+                                # No action needed
+
 
                             case _:
                                 LOGGER.debug("iq2meid updating unknow uri:%s", uri)
@@ -799,7 +807,7 @@ class QolsysPanel(QolsysObservable):
 
         # Create sensors array
         for zone_info in zones_list:
-            zones.append(QolsysZone(zone_info))
+            zones.append(QolsysZone(zone_info,self._settings))
 
         return zones
 

{qolsys_controller-0.0.34 → qolsys_controller-0.0.35}/qolsys_controller/plugin_remote.py

@@ -1,11 +1,13 @@
 import asyncio
 import base64
+import contextlib
 import datetime
 import json
 import logging
 import random
 import ssl
 import uuid
+from pathlib import Path
 
 import aiomqtt
 
@@ -146,7 +148,7 @@ class QolsysPluginRemote(QolsysPlugin):
         return True
 
     async def start_operation(self) -> None:
-        await self._task_manager.run(self.mqtt_connect_task(reconnect=True), self._mqtt_task_connect_label)
+        await self._task_manager.run(self.mqtt_connect_task(reconnect=True, run_forever=True), self._mqtt_task_connect_label)
 
     async def stop_operation(self) -> None:
         LOGGER.debug("Stopping Plugin Operation")
@@ -166,7 +168,7 @@ class QolsysPluginRemote(QolsysPlugin):
         self.connected = False
         self.connected_observer.notify()
 
-    async def mqtt_connect_task(self, reconnect: bool) -> None:
+    async def mqtt_connect_task(self, reconnect: bool, run_forever: bool) -> None:
         # Configure TLS parameters for MQTT connection
         tls_params = aiomqtt.TLSParameters(
             ca_certs=self._pki.qolsys_cer_file_path,
@@ -179,6 +181,9 @@ class QolsysPluginRemote(QolsysPlugin):
 
         LOGGER.debug("MQTT: Connecting ...")
 
+        self._task_manager.cancel(self._mqtt_task_listen_label)
+        self._task_manager.cancel(self._mqtt_task_ping_label)
+
         while True:
             try:
                 self.aiomqtt = aiomqtt.Client(
@@ -188,7 +193,7 @@ class QolsysPluginRemote(QolsysPlugin):
                     tls_insecure=True,
                     clean_session=True,
                     timeout=self.settings.mqtt_timeout,
-                    identifier="QolsysController",
+                    identifier= self.settings.mqtt_remote_client_id,
                 )
 
                 await self.aiomqtt.__aenter__()
@@ -207,14 +212,11 @@ class QolsysPluginRemote(QolsysPlugin):
                 # Only log all traffic for debug purposes
                 if self.log_mqtt_mesages:
                     # Subscribe to MQTT commands send to panel by other devices
-                    #await self.aiomqtt.subscribe("mastermeid", qos=self.settings.mqtt_qos)
+                    await self.aiomqtt.subscribe("mastermeid", qos=self.settings.mqtt_qos)
 
                     # Subscribe to all topics
-                    await self.aiomqtt.subscribe("#", qos=self.settings.mqtt_qos)
+                    # await self.aiomqtt.subscribe("#", qos=self.settings.mqtt_qos)
 
-                # Start mqtt_listent_task and mqtt_ping_task
-                self._task_manager.cancel(self._mqtt_task_listen_label)
-                self._task_manager.cancel(self._mqtt_task_ping_label)
                 self._task_manager.run(self.mqtt_listen_task(), self._mqtt_task_listen_label)
                 self._task_manager.run(self.mqtt_ping_task(), self._mqtt_task_ping_label)
 
@@ -223,7 +225,6 @@ class QolsysPluginRemote(QolsysPlugin):
                 self.panel.product_type = response_connect.get("primary_product_type", "")
 
                 await self.command_pingevent()
-                await self.command_timesync()
                 await self.command_pair_status_request()
 
                 response_database = await self.command_sync_database()
@@ -234,17 +235,24 @@ class QolsysPluginRemote(QolsysPlugin):
 
                 self.connected = True
                 self.connected_observer.notify()
+
+                if not run_forever:
+                    self.connected = False
+                    self.connected_observer.notify()
+                    self._task_manager.cancel(self._mqtt_task_listen_label)
+                    self._task_manager.cancel(self._mqtt_task_ping_label)
+                    await self.aiomqtt.__aexit__(None,None,None)
+
                 break
 
             except aiomqtt.MqttError as err:
                 # Receive pannel network error
                 self.connected = False
                 self.connected_observer.notify()
-                await self.aiomqtt.__aexit__(None, None, None)
                 self.aiomqtt = None
 
                 if reconnect:
-                    LOGGER.debug("MQTT Error - %s: Reconnecting in %s seconds ...", err, self.settings.mqtt_timeout)
+                    LOGGER.debug("MQTT Error - %s: Connect - Reconnecting in %s seconds ...", err, self.settings.mqtt_timeout)
                     await asyncio.sleep(self.settings.mqtt_timeout)
                 else:
                     raise QolsysMqttError from err
@@ -255,14 +263,14 @@ class QolsysPluginRemote(QolsysPlugin):
                 # Pannels need to be re-paired
                 self.connected = False
                 self.connected_observer.notify()
-                await self.aiomqtt.__aexit__(None, None, None)
                 self.aiomqtt = None
                 raise QolsysSslError from err
 
     async def mqtt_ping_task(self) -> None:
         while True:
             if self.aiomqtt is not None and self.connected:
-                await self.command_pingevent()
+                with contextlib.suppress(aiomqtt.MqttError):
+                    await self.command_pingevent()
 
             await asyncio.sleep(self.settings.mqtt_ping)
 
@@ -293,25 +301,13 @@ class QolsysPluginRemote(QolsysPlugin):
                     decoded_payload = base64.b64decode(zwave.get("ZWAVE_PAYLOAD","")).hex()
                     LOGGER.debug("Z-Wave Response: Node(%s) - Status(%s) - Payload(%s)",zwave.get("NODE_ID",""),zwave.get("ZWAVE_COMMAND_STATUS",""),decoded_payload)
 
-
         except aiomqtt.MqttError as err:
             self.connected = False
             self.connected_observer.notify()
 
-            LOGGER.debug("%s: Reconnecting in %s seconds ...", err, self.settings.mqtt_timeout)
-            self._task_manager.cancel(self.mqtt_ping_task)
+            LOGGER.debug("%s: Listen - Reconnecting in %s seconds ...", err, self.settings.mqtt_timeout)
             await asyncio.sleep(self.settings.mqtt_timeout)
-            self._task_manager.run(self.mqtt_connect_task(reconnect=True), self._mqtt_task_connect_label)
-
-        except ssl.SSLError as err:
-            # SSL error is and authentication error with invalid certificates en pki
-            # We cannot recover from this error automaticly
-            # Pannels need to be re-paired
-            self.connected = False
-            self.connected_observer.notify()
-            await self.aiomqtt.__aexit__(None, None, None)
-            self.aiomqtt = None
-            raise QolsysSslError from err
+            self._task_manager.run(self.mqtt_connect_task(reconnect=True, run_forever=True), self._mqtt_task_connect_label)
 
     async def start_initial_pairing(self) -> bool:
         # check if random_mac exist
@@ -354,7 +350,6 @@ class QolsysPluginRemote(QolsysPlugin):
             context.load_cert_chain(certfile=self._pki.cer_file_path, keyfile=self._pki.key_file_path)
             self.certificate_exchange_server = await asyncio.start_server(self.handle_key_exchange_client,
                                                                           self.settings.plugin_ip, pairing_port, ssl=context)
-
             LOGGER.debug("Certificate Exchange Server Waiting for Panel")
             LOGGER.debug("Press Pair Button in IQ Remote Config Page ...")
 
@@ -371,7 +366,7 @@ class QolsysPluginRemote(QolsysPlugin):
 
         # We have client sgined certificate at this point
         # Connect to Panel MQTT to send pairing command
-        await self._task_manager.run(self.mqtt_connect_task(reconnect=False), self._mqtt_task_connect_label)
+        await self._task_manager.run(self.mqtt_connect_task(reconnect=False, run_forever=False), self._mqtt_task_connect_label)
         LOGGER.debug("Plugin Pairing Completed ")
         return True
 
@@ -381,9 +376,6 @@ class QolsysPluginRemote(QolsysPlugin):
         received_signed_client_certificate = False
         received_qolsys_cer = False
 
-        signed_certificate_data = ""
-        qolsys_certificate_data = ""
-
         try:
             continue_pairing = True
             while continue_pairing:
@@ -410,7 +402,7 @@ class QolsysPluginRemote(QolsysPlugin):
                     await writer.drain()
 
                     # Sending CSR File to panel
-                    with open(self._pki.csr_file_path, "rb") as file:
+                    with Path.open(self._pki.csr_file_path, "rb") as file:
                         content = file.read()
                         LOGGER.debug("Sending to Panel: [CSR File Content]")
                         writer.write(content)
@@ -421,36 +413,26 @@ class QolsysPluginRemote(QolsysPlugin):
 
                 # Read signed certificate data
                 if (received_panel_mac and not received_signed_client_certificate and not received_qolsys_cer):
+                    request = await reader.readuntil(b"sent")
+                    if request.endswith(b"sent"):
+                        request = request[:-5]
 
-                    request = (await reader.readline())
-                    signed_certificate_data += request.decode()
-
-                    if "sent" in request.decode():
-                        certificates = [item for item in signed_certificate_data.split("sent") if item]
-                        LOGGER.debug("Saving [Signed Client Certificate]")
-                        with open(self._pki.secure_file_path, "wb") as f:
-                            f.write(certificates[0].encode())
-                            received_signed_client_certificate = True
-
-                        if len(certificates) > 1:
-                            qolsys_certificate_data += certificates[1]
+                    LOGGER.debug("Saving [Signed Client Certificate]")
+                    with Path.open(self._pki.secure_file_path, "wb") as f:
+                        f.write(request)
+                        received_signed_client_certificate = True
 
                 # Read qolsys certificate data
                 if (received_panel_mac and received_signed_client_certificate and not received_qolsys_cer):
-
-                    request = (await reader.readline())
-                    qolsys_certificate_data += request.decode()
-
-                    if "sent" in request.decode():
+                    request = await reader.readuntil(b"sent")
+                    if request.endswith(b"sent"):
+                        request = request[:-5]
+
+                    LOGGER.debug("Saving [Qolsys Certificate]")
+                    with Path.open(self._pki.qolsys_cer_file_path, "wb") as f:
+                        f.write(request)
+                        received_qolsys_cer = True
                         continue_pairing = False
-                        certificates = [item for item in qolsys_certificate_data.split("sent") if item]
-
-                        LOGGER.debug("Saving [Qolsys Certificate]")
-                        with open(self._pki.qolsys_cer_file_path, "w") as f:
-                            f.write(certificates[0])
-                            received_qolsys_cer = True
-                            continue_pairing = False
-                            writer.close()
 
                     continue
 
@@ -462,6 +444,7 @@ class QolsysPluginRemote(QolsysPlugin):
 
         finally:
             writer.close()
+            await writer.wait_closed()
             self.certificate_exchange_server.close()
 
     async def send_command(self, topic: str, json_payload: str, request_id: str) -> dict:
@@ -1185,11 +1168,11 @@ class QolsysPluginRemote(QolsysPlugin):
         LOGGER.debug("MQTT:Receiving zwave_switch_binary command")
 
 
-    async def command_arm(self, partition_id: str, arming_type: str, user_code: str = "", exit_sounds: bool = False,
+    async def command_arm(self, partition_id: str, arming_type: str, user_code: str = "", exit_sounds: bool = False,  # noqa: PLR0913
                           instant_arm: bool = False, entry_delay: bool = True) -> bool:
 
-        LOGGER.debug("MQTT: Sending arm command: partition%s, arming_type:%s, secure_arm:%s, exit_sounds:%s, instant_arm: %s, entry_delay:%s",
-                     partition_id, arming_type, self.panel.SECURE_ARMING,exit_sounds,instant_arm,entry_delay)
+        LOGGER.debug("MQTT: Sending arm command: partition%s, arming_type:%s, exit_sounds:%s, instant_arm: %s, entry_delay:%s",
+                     partition_id, arming_type,exit_sounds,instant_arm,entry_delay)
 
         user_id = 0
 

{qolsys_controller-0.0.34 → qolsys_controller-0.0.35}/qolsys_controller/settings.py

@@ -14,6 +14,7 @@ class QolsysSettings:
         self._panel_mac = ""
         self._panel_ip = ""
 
+        # Path
         self._config_directory: Path = Path()
         self._pki_directory: Path = Path()
         self._media_directory: Path = Path()
@@ -28,6 +29,10 @@ class QolsysSettings:
         self._mqtt_qos:int = 0
         self._mqtt_remote_client_id = ""
 
+        # Operation
+        self._motion_sensor_delay:bool = True
+        self._motion_sensor_delay_sec:int = 310
+
     @property
     def random_mac(self) -> str:
         return self._random_mac
@@ -60,6 +65,18 @@ class QolsysSettings:
     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
+
     @panel_ip.setter
     def panel_ip(self, panel_ip: str) -> None:
         self._panel_ip = panel_ip
@@ -131,7 +148,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-0.0.34 → qolsys_controller-0.0.35}/qolsys_controller/state.py

@@ -102,6 +102,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 +129,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 +147,6 @@ class QolsysState(QolsysObservable):
         for zone in self.zones:
             if zone.zone_id == zone_id:
                 return zone
-
         return None
 
     def zone_add(self, new_zone: QolsysZone) -> None:
@@ -154,6 +156,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 +184,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:
@@ -247,7 +251,7 @@ 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_scenes_data(self, db_scenes: list[QolsysScene]) -> None:
         db_scene_list = []
@@ -271,7 +275,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:
@@ -300,7 +304,7 @@ class QolsysState(QolsysObservable):
         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:

{qolsys_controller-0.0.34 → qolsys_controller-0.0.35}/qolsys_controller/task_manager.py

@@ -2,8 +2,6 @@ import asyncio
 import logging
 from collections.abc import Coroutine
 
-import aiomqtt
-
 LOGGER = logging.getLogger(__name__)
 
 
@@ -31,14 +29,21 @@ class QolsysTaskManager:
         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-0.0.34 → qolsys_controller-0.0.35}/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:
         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", ""))
@@ -214,21 +221,42 @@ class QolsysZone(QolsysObservable):
     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: