qolsys-controller 0.0.40__tar.gz → 0.0.42__tar.gz

{qolsys_controller-0.0.40 → qolsys_controller-0.0.42}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: qolsys-controller
-Version: 0.0.40
+Version: 0.0.42
 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

{qolsys_controller-0.0.40 → qolsys_controller-0.0.42}/pyproject.toml

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

{qolsys_controller-0.0.40 → qolsys_controller-0.0.42}/qolsys_controller/database/db.py

@@ -237,6 +237,25 @@ class QolsysDB:
 
         return zones
 
+    def get_powerg(self, short_id: str) -> dict:
+        try:
+            self.cursor.execute(f"SELECT * FROM {self.table_powerg_device.table} WHERE shortID = ?",short_id)
+            self.db.commit()
+
+            row = self.cursor.fetchone()
+
+            if row is None:
+                LOGGER.debug("%s value not found", short_id)
+                return None
+
+            columns = [description[0] for description in self.cursor.description]
+            return  dict(zip(columns, row, strict=True))
+
+        except sqlite3.Error:
+            LOGGER.exception("Error getting PowerG device info for shortID %s", short_id)
+            return None
+
+
     def get_setting_panel(self, setting: str) -> str:
         self.cursor.execute(f"""SELECT value FROM {self.table_qolsyssettings.table}
                              WHERE name = ? and partition_id  = ? """, (setting, "0"))

{qolsys_controller-0.0.40 → qolsys_controller-0.0.42}/qolsys_controller/panel.py

@@ -406,7 +406,7 @@ class QolsysPanel(QolsysObservable):
                             case self.db.table_sensor.uri:
                                 self.db.table_sensor.update(selection, selection_argument, content_values)
                                 zoneid = content_values.get("zoneid", "")
-                                zone = self._state.zone(zoneid)
+                                zone = self._state.zone(zone_id=zoneid)
                                 if zone is not None:
                                     zone.update(content_values)
 
@@ -521,7 +521,14 @@ class QolsysPanel(QolsysObservable):
                                 self.db.table_eu_event.update(selection,selection_argument,content_values)
                                 # No action needed
 
-
+                            # Update PowerG Device
+                            case self.db.table_powerg_device:
+                                self.db.table_powerg_device.update(selection,selection_argument,content_values)
+                                short_id = content_values.get("shortID", "")
+                                zone = self._state.zone_from_short_id(short_id)
+                                if zone is not None:
+                                    LOGGER.debug("iq2meid updating powerg device for zoneid(%s):%s", zone.zone_id,content_values)
+                                    zone.update_powerg(content_values)
 
                             case _:
                                 LOGGER.debug("iq2meid updating unknow uri:%s", uri)
@@ -601,6 +608,9 @@ class QolsysPanel(QolsysObservable):
                             case self.db.table_eu_event:
                                 self.db.table_eu_event.delete(selection,selection_argument)
 
+                            case self.db.table_powerg_device:
+                                self.db.table_powerg_device.delete(selection,selection_argument)
+
                             case _:
                                 LOGGER.debug("iq2meid deleting unknown uri:%s", uri)
                                 LOGGER.debug(data)
@@ -729,6 +739,10 @@ class QolsysPanel(QolsysObservable):
                             case self.db.table_eu_event:
                                 self.db.table_eu_event.insert(data=content_values)
 
+                            # PowerG Device
+                            case self.db.table_powerg_device:
+                                self.db.table_powerg_device.insert(data=content_values)
+
                             case _:
                                 LOGGER.debug("iq2meid inserting unknow uri:%s", uri)
                                 LOGGER.debug(data)
@@ -820,7 +834,17 @@ class QolsysPanel(QolsysObservable):
 
         # Create sensors array
         for zone_info in zones_list:
-            zones.append(QolsysZone(zone_info,self._settings))
+
+            new_zone = QolsysZone(zone_info,self._settings)
+
+            if new_zone.current_capability == "POWERG":
+                LOGGER.debug("Loading PowerG device info for zone %s", new_zone.id)
+                powerg_dict = self.db.get_powerg(short_id= new_zone.shortID)
+                LOGGER.debug("PowerG device info: %s", powerg_dict)
+                if powerg_dict is not None:
+                    new_zone.update_powerg(powerg_dict)
+
+            zones.append(new_zone)
 
         return zones
 

{qolsys_controller-0.0.40 → qolsys_controller-0.0.42}/qolsys_controller/state.py

@@ -149,6 +149,12 @@ class QolsysState(QolsysObservable):
                 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:
         for zone in self.zones:
             if new_zone.zone_id == zone.zone_id:
@@ -299,6 +305,7 @@ 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:

{qolsys_controller-0.0.40 → qolsys_controller-0.0.42}/qolsys_controller/zone.py

@@ -11,7 +11,7 @@ LOGGER = logging.getLogger(__name__)
 
 class QolsysZone(QolsysObservable):
 
-    def __init__(self, data: dict, settings: QolsysSettings) -> None:
+    def __init__(self, data: dict, settings: QolsysSettings) -> None:  # noqa: PLR0915
         super().__init__()
 
         self._settings = settings
@@ -27,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", "")
@@ -56,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", "")
@@ -73,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")
 
@@ -205,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
@@ -217,6 +276,43 @@ 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:
@@ -303,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,