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

qolsys_controller/controller.py

@@ -1,5 +1,10 @@
 #!/usr/bin/env python3
+from __future__ import annotations
+
 import logging
+from typing import TYPE_CHECKING
+
+from qolsys_controller.plugin import QolsysPlugin
 
 from .panel import QolsysPanel
 from .plugin_c4 import QolsysPluginC4
@@ -9,20 +14,27 @@ from .state import QolsysState
 
 LOGGER = logging.getLogger(__name__)
 
+if TYPE_CHECKING:
+    from .plugin import QolsysPlugin
+
 class QolsysController:
 
     def __init__(self) -> None:
 
         # QolsysController Information
-        self.plugin = None
-        self._state = QolsysState()
-        self._settings = QolsysSettings()
-        self._panel = QolsysPanel(settings=self.settings, state=self.state)
+        self._plugin: QolsysPlugin | None = None
+        self._state = QolsysState(self)
+        self._settings = QolsysSettings(self)
+        self._panel = QolsysPanel(self)
 
     @property
     def state(self) -> QolsysState:
         return self._state
 
+    @property
+    def plugin(self) -> QolsysPlugin:
+        return self._plugin
+
     @property
     def panel(self) -> QolsysPanel:
         return self._panel
@@ -37,13 +49,13 @@ class QolsysController:
 
             case "c4":
                 LOGGER.debug("C4 Plugin Selected")
-                self.plugin = QolsysPluginC4(self.state, self.panel, self.settings)
+                self._plugin = QolsysPluginC4(self)
                 return
 
             case "remote":
                 LOGGER.debug("Remote Plugin Selected")
-                self.plugin = QolsysPluginRemote(self.state, self.panel, self.settings)
+                self._plugin = QolsysPluginRemote(self)
                 return
 
             case _:
-                LOGGER.debug("Unknow Plugin Selected")
+                LOGGER.error("Unknow Plugin Selected")

qolsys_controller/database/db.py

@@ -237,6 +237,37 @@ class QolsysDB:
 
         return zones
 
+    def get_weather(self) -> list[dict]:
+        self.cursor.execute(f"SELECT * FROM {self.table_weather.table} ORDER BY _id")
+        self.db.commit()
+
+        weather_list = []
+        columns = [description[0] for description in self.cursor.description]
+        for row in self.cursor.fetchall():
+            row_dict = dict(zip(columns, row, strict=True))
+            weather_list.append(row_dict)
+
+        return weather_list
+
+    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/database/table.py

@@ -68,6 +68,7 @@ class QolsysTable:
                 raise error from err
 
     def insert(self, data: dict) -> None:
+
         try:
             if not self._implemented and data is not None:
                 LOGGER.warning("New Table format: %s", self.uri)
@@ -92,6 +93,7 @@ class QolsysTable:
 
             col_str = ", ".join(full_data.keys())
             placeholder_str = ", ".join([f":{key}" for key in full_data])
+
             query = f"INSERT OR IGNORE INTO {self.table} ({col_str}) VALUES ({placeholder_str})"
             self._cursor.execute(query, full_data)
             self._db.commit()
@@ -112,9 +114,14 @@ class QolsysTable:
         # selection_argument:
         # Firmware 4.4.1: selection_argument: '[3,1]'
         # Firmware 4.6.1: selection_argument: ['3','1']
-
         # contentValues:{"partition_id":"0","sensorgroup":"safetymotion","sensorstatus":"Idle"}"
 
+        if selection_argument == "":
+            LOGGER.debug("Update called with empty selection_argument")
+            LOGGER.debug("Table: %s", self.table)
+            LOGGER.debug("Selection: %s", selection)
+            LOGGER.debug("selection_argument: %s", selection_argument)
+            return
 
         # Selection Argument
         # Panel send selection_argument as list in Firmware 4.6.1
@@ -164,6 +171,14 @@ class QolsysTable:
         # Firmware 4.4.1: selection_argument: '[3,1]'
         # Firmware 4.6.1: selection_argument: ['3','1']
 
+
+        if selection_argument == "":
+            LOGGER.debug("Delete called with empty selection_argument")
+            LOGGER.debug("Table: %s", self.table)
+            LOGGER.debug("Selection: %s", selection)
+            LOGGER.debug("selection_argument: %s", selection_argument)
+            return
+
         # Selection Argument
         if(type(selection_argument) is not list):
             #Firmware 4.4.1, seletion_argument is sent as a string

qolsys_controller/database/table_powerg_device.py

@@ -13,7 +13,7 @@ class QolsysTablePowerGDevice(QolsysTable):
         self._uri = "content://com.qolsys.qolsysprovider.PowerGDeviceContentProvider/powerg_device"
         self._table = "powerg_device"
         self._abort_on_error = False
-        self._implemented = False
+        self._implemented = True
 
 
         self._columns = [

qolsys_controller/enum.py

@@ -94,7 +94,6 @@ class ZoneSensorGroup(StrEnum):
     TAMPER_ZONE = "tamperzone"
     SHOCK = "shock"
 
-
     # ENTRY_EXIT_NORMAL_DELAY = "" #TBD
     # ENTRY_EXIT_LONG_DELAY = "" #TBD
     # INSTANT_PERIMETER_DW = "" #TBD

qolsys_controller/enum_zwave.py

@@ -34,4 +34,3 @@ class ThermostatFanMode(Enum):
     QUIET: 0x0400
     EXTERNAL_CIRCULATION: 0x0800
     MANUFACTURER_SPECEFIC: 0x1000
-

qolsys_controller/mdns.py

@@ -6,9 +6,14 @@ from zeroconf.asyncio import AsyncZeroconf
 
 class QolsysMDNS:
 
-    def __init__(self, ip: str, port: int) -> None:
-
-        self.azc = AsyncZeroconf()
+    def __init__(self, ip: str, port: int, external_zero_conf: AsyncZeroconf | None = None) -> None:
+
+        # Add possible external zeroconf instance provided by Home Assistant by example
+        # If no external instance is provided, create our own
+        if external_zero_conf:
+            self.azc = external_zero_conf
+        else:
+            self.azc = AsyncZeroconf()
 
         self.mdns_info = ServiceInfo(
             "_http._tcp.local.",

qolsys_controller/panel.py

@@ -1,5 +1,8 @@
+from __future__ import annotations
+
 import json
 import logging
+from typing import TYPE_CHECKING
 
 from .database.db import QolsysDB
 from .enum import (
@@ -10,10 +13,8 @@ from .enum import (
 from .observable import QolsysObservable
 from .partition import QolsysPartition
 from .scene import QolsysScene
-from .settings import QolsysSettings
-from .state import QolsysState
+from .weather import QolsysForecast, QolsysWeather
 from .zone import QolsysZone
-from .zwave_device import QolsysZWaveDevice
 from .zwave_dimmer import QolsysDimmer
 from .zwave_generic import QolsysGeneric
 from .zwave_lock import QolsysLock
@@ -21,12 +22,15 @@ from .zwave_thermostat import QolsysThermostat
 
 LOGGER = logging.getLogger(__name__)
 
+if TYPE_CHECKING:
+    from .controller import QolsysController
+    from .zwave_device import QolsysZWaveDevice
+
 
 class QolsysPanel(QolsysObservable):
-    def __init__(self, settings: QolsysSettings, state: QolsysState) -> None:
+    def __init__(self, controller: QolsysController) -> None:
 
-        self._state = state
-        self._settings = settings
+        self._controller = controller
         self._db = QolsysDB()
 
         # Partition settings
@@ -95,9 +99,9 @@ class QolsysPanel(QolsysObservable):
 
     def read_users_file(self) -> bool:
         # Loading user_code data from users.conf file if exists
-        if self._settings.users_file_path.is_file():
+        if self._controller.settings.users_file_path.is_file():
             try:
-                path = self._settings.users_file_path
+                path = self._controller.settings.users_file_path
                 with path.open("r", encoding="utf-8") as file:
                     try:
                         users = json.load(file)
@@ -344,10 +348,12 @@ class QolsysPanel(QolsysObservable):
 
     def load_database(self, database: dict) -> None:
         self.db.load_db(database)
-        self._state.sync_partitions_data(self.get_partitions_from_db())
-        self._state.sync_zones_data(self.get_zones_from_db())
-        self._state.sync_zwave_devices_data(self.get_zwave_devices_from_db())
-        self._state.sync_scenes_data(self.get_scenes_from_db())
+        self._controller.state.sync_partitions_data(self.get_partitions_from_db())
+        self._controller.state.sync_zones_data(self.get_zones_from_db())
+        self._controller.state.sync_zwave_devices_data(self.get_zwave_devices_from_db())
+        self._controller.state.sync_scenes_data(self.get_scenes_from_db())
+        self._controller.state.sync_weather_data(self.get_weather_from_db())
+
 
     # Parse panel update to database
     def parse_iq2meid_message(self, data: dict) -> bool:  # noqa: C901, PLR0912, PLR0915
@@ -369,9 +375,13 @@ class QolsysPanel(QolsysObservable):
                 match dbOperation:
 
                     case "update":
-                        content_values = data.get("contentValues")
-                        selection = data.get("selection")
-                        selection_argument = data.get("selectionArgs")
+                        content_values = data.get("contentValues","")
+                        selection = data.get("selection","")
+                        selection_argument = data.get("selectionArgs","")
+
+                        if selection_argument == "" or selection == "":
+                            LOGGER.debug("iq2meid invalid update selection or selectionArgs")
+                            LOGGER.debug("data:%s", data)
 
                         match uri:
 
@@ -390,7 +400,7 @@ class QolsysPanel(QolsysObservable):
                                 # Update Partition setting - Send notification if setting has changed
                                 if name in self.settings_partition:
                                     partition_id = content_values.get("partition_id", "")
-                                    partition = self._state.partition(partition_id)
+                                    partition = self._controller.state.partition(partition_id)
                                     if partition is not None:
                                         match name:
                                             case "SYSTEM_STATUS":
@@ -406,7 +416,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._controller.state.zone(zone_id=zoneid)
                                 if zone is not None:
                                     zone.update(content_values)
 
@@ -418,7 +428,7 @@ class QolsysPanel(QolsysObservable):
                                 self.db.table_state.update(selection, selection_argument, content_values)
 
                                 if name in self.state_partition:
-                                    partition = self._state.partition(partition_id)
+                                    partition = self._controller.state.partition(partition_id)
                                     if partition is not None:
                                         match name:
                                             case "ALARM_STATE":
@@ -443,7 +453,7 @@ class QolsysPanel(QolsysObservable):
                             case self.db.table_partition.uri:
                                 self.db.table_partition.update(selection, selection_argument, content_values)
                                 partition_id = content_values.get("partition_id", "")
-                                partition = self._state.partition(partition_id)
+                                partition = self._controller.state.partition(partition_id)
                                 if partition is not None:
                                     partition.update_partition(content_values)
 
@@ -456,7 +466,7 @@ class QolsysPanel(QolsysObservable):
                             case self.db.table_dimmer.uri:
                                 self.db.table_dimmer.update(selection, selection_argument, content_values)
                                 node_id = content_values.get("node_id", "")
-                                node = self._state.zwave_device(node_id)
+                                node = self._controller.state.zwave_device(node_id)
                                 if node is not None and isinstance(node, QolsysDimmer):
                                     node.update_dimmer(content_values)
 
@@ -464,7 +474,7 @@ class QolsysPanel(QolsysObservable):
                             case self.db.table_thermostat.uri:
                                 self.db.table_thermostat.update(selection, selection_argument, content_values)
                                 node_id = content_values.get("node_id", "")
-                                node = self._state.zwave_device(node_id)
+                                node = self._controller.state.zwave_device(node_id)
                                 if node is not None and isinstance(node, QolsysThermostat):
                                     node.update_thermostat(content_values)
 
@@ -472,7 +482,7 @@ class QolsysPanel(QolsysObservable):
                             case self.db.table_doorlock.uri:
                                 self.db.table_doorlock.update(selection, selection_argument, content_values)
                                 node_id = content_values.get("node_id", "")
-                                node = self._state.zwave_device(node_id)
+                                node = self._controller.state.zwave_device(node_id)
                                 if node is not None and isinstance(node, QolsysLock):
                                     node.update_lock(content_values)
 
@@ -480,7 +490,7 @@ class QolsysPanel(QolsysObservable):
                             case self.db.table_zwave_node.uri:
                                 self.db.table_zwave_node.update(selection, selection_argument, content_values)
                                 node_id = content_values.get("node_id", "")
-                                node = self._state.zwave_device(node_id)
+                                node = self._controller.state.zwave_device(node_id)
                                 if node is not None:
                                     node.update_base(content_values)
 
@@ -507,35 +517,51 @@ class QolsysPanel(QolsysObservable):
                             case self.db.table_scene.uri:
                                 self.db.table_scene.update(selection, selection_argument, content_values)
                                 scene_id = content_values.get("scene_id", "")
-                                scene = self._state.scene(scene_id)
+                                scene = self._controller.state.scene(scene_id)
                                 if scene is not None and isinstance(node, QolsysScene):
                                     scene.update(content_values)
 
                             # Update Trouble Conditions
-                            case self.db.table_trouble_conditions:
+                            case self.db.table_trouble_conditions.uri:
                                 self.db.table_trouble_conditions.update(selection,selection_argument,content_values)
                                 # No action needed
 
                             # Update EU_EVENT:
-                            case self.db.table_eu_event:
+                            case self.db.table_eu_event.uri:
                                 self.db.table_eu_event.update(selection,selection_argument,content_values)
                                 # No action needed
 
+                            # Update PowerG Device
+                            case self.db.table_powerg_device.uri:
+                                self.db.table_powerg_device.update(selection,selection_argument,content_values)
+                                short_id = content_values.get("shortID", "")
+                                zone = self._controller.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)
 
+                            # Update Weather
+                            case self.db.table_weather.uri:
+                                self.db.table_weather.update(selection,selection_argument,content_values)
+                                self._controller.state.sync_weather_data(self.get_weather_from_db())
 
                             case _:
                                 LOGGER.debug("iq2meid updating unknow uri:%s", uri)
                                 LOGGER.debug(data)
 
                     case "delete":
-                        selection = data.get("selection")
-                        selection_argument = data.get("selectionArgs")
+                        selection = data.get("selection","")
+                        selection_argument = data.get("selectionArgs","")
+
+                        if selection_argument == "" or selection == "":
+                            LOGGER.debug("iq2meid invalid delete selection or selectionArgs")
+                            LOGGER.debug("data:%s", data)
 
                         match uri:
 
                             case self.db.table_sensor.uri:
                                 self.db.table_sensor.delete(selection, selection_argument)
-                                self._state.sync_zones_data(self.get_zones_from_db())
+                                self._controller.state.sync_zones_data(self.get_zones_from_db())
                                 # Notify delete zone
 
                             case self.db.table_iqremotesettings.uri:
@@ -556,7 +582,7 @@ class QolsysPanel(QolsysObservable):
 
                             case self.db.table_alarmedsensor.uri:
                                 self.db.table_alarmedsensor.delete(selection, selection_argument)
-                                self._state.sync_partitions_data(self.get_partitions_from_db())
+                                self._controller.state.sync_partitions_data(self.get_partitions_from_db())
 
                             case self.db.table_history.uri:
                                 self.db.table_history.delete(selection, selection_argument)
@@ -568,19 +594,19 @@ class QolsysPanel(QolsysObservable):
 
                             case self.db.table_doorlock.uri:
                                 self.db.table_doorlock.delete(selection, selection_argument)
-                                self._state.sync_zwave_devices_data(self.get_zwave_devices_from_db())
+                                self._controller.state.sync_zwave_devices_data(self.get_zwave_devices_from_db())
 
                             case self.db.table_dimmer.uri:
                                 self.db.table_dimmer.delete(selection, selection_argument)
-                                self._state.sync_zwave_devices_data(self.get_zwave_devices_from_db())
+                                self._controller.state.sync_zwave_devices_data(self.get_zwave_devices_from_db())
 
                             case self.db.table_thermostat.uri:
                                 self.db.table_thermostat.delete(selection, selection_argument)
-                                self._state.sync_zwave_devices_data(self.get_zwave_devices_from_db())
+                                self._controller.state.sync_zwave_devices_data(self.get_zwave_devices_from_db())
 
                             case self.db.table_zwave_node.uri:
                                 self.db.table_zwave_node.delete(selection, selection_argument)
-                                self._state.sync_zwave_devices_data(self.get_zwave_devices_from_db())
+                                self._controller.state.sync_zwave_devices_data(self.get_zwave_devices_from_db())
 
                             case self.db.table_automation.uri:
                                 self.db.table_automation.delete(selection, selection_argument)
@@ -588,7 +614,7 @@ class QolsysPanel(QolsysObservable):
 
                             case self.db.table_partition.uri:
                                 self.db.table_partition.delete(selection, selection_argument)
-                                self._state.sync_partitions_data(self.get_partitions_from_db())
+                                self._controller.state.sync_partitions_data(self.get_partitions_from_db())
 
                             case self.db.table_user.uri:
                                 self.db.table_user.delete(selection, selection_argument)
@@ -598,9 +624,16 @@ class QolsysPanel(QolsysObservable):
                                 self.db.table_dashboard_msgs.delete(selection, selection_argument)
                                 # No action needed
 
-                            case self.db.table_eu_event:
+                            case self.db.table_eu_event.uri:
                                 self.db.table_eu_event.delete(selection,selection_argument)
 
+                            case self.db.table_powerg_device.uri:
+                                self.db.table_powerg_device.delete(selection,selection_argument)
+
+                            case self.db.table_weather.uri:
+                                self.db.table_weather.delete(selection,selection_argument)
+                                self._controller.state.sync_weather_data(self.get_weather_from_db())
+
                             case _:
                                 LOGGER.debug("iq2meid deleting unknown uri:%s", uri)
                                 LOGGER.debug(data)
@@ -618,16 +651,16 @@ class QolsysPanel(QolsysObservable):
                                 new_value = content_values.get("value", "")
                                 if name in self.state_partition:
                                     partition_id = content_values.get("partition_id", "")
-                                    partition = self._state.partition(partition_id)
+                                    partition = self._controller.state.partition(partition_id)
                                     if partition is not None:
                                         match name:
                                             case "ALARM_STATE":
                                                 partition.alarm_state = PartitionAlarmState(new_value)
 
                             # Inser Partition Content Provider
-                            case self.db.table_partition:
+                            case self.db.table_partition.uri:
                                 self.db.table_partition.insert(data=content_values)
-                                self._state.sync_partitions_data(self.get_partitions_from_db())
+                                self._controller.state.sync_partitions_data(self.get_partitions_from_db())
 
                             # Insert Settings Content Provider
                             case self.db.table_qolsyssettings.uri:
@@ -638,7 +671,7 @@ class QolsysPanel(QolsysObservable):
                                 new_value = content_values.get("value", "")
                                 if name in self.settings_partition:
                                     partition_id = content_values.get("partition_id", "")
-                                    partition = self._state.partition(partition_id)
+                                    partition = self._controller.state.partition(partition_id)
                                     if partition is not None:
                                         match name:
                                             case "SYSTEM_STATUS":
@@ -668,27 +701,27 @@ class QolsysPanel(QolsysObservable):
                             # Sensor Content Provider
                             case self.db.table_sensor.uri:
                                 self.db.table_sensor.insert(data=content_values)
-                                self._state.sync_zones_data(self.get_zones_from_db())
+                                self._controller.state.sync_zones_data(self.get_zones_from_db())
 
                             # Door Lock Content Provider
                             case self.db.table_doorlock.uri:
                                 self.db.table_doorlock.insert(data=content_values)
-                                self._state.sync_zwave_devices_data(self.get_zwave_devices_from_db())
+                                self._controller.state.sync_zwave_devices_data(self.get_zwave_devices_from_db())
 
                             # Dimmer Content Provider
                             case self.db.table_dimmer.uri:
                                 self.db.table_dimmer.insert(data=content_values)
-                                self._state.sync_zwave_devices_data(self.get_zwave_devices_from_db())
+                                self._controller.state.sync_zwave_devices_data(self.get_zwave_devices_from_db())
 
                             # Thermostat Content Provider
                             case self.db.table_thermostat.uri:
                                 self.db.table_thermostat.insert(data=content_values)
-                                self._state.sync_zwave_devices_data(self.get_zwave_devices_from_db())
+                                self._controller.state.sync_zwave_devices_data(self.get_zwave_devices_from_db())
 
                             # ZWave Node Content Provider
                             case self.db.table_zwave_node.uri:
                                 self.db.table_zwave_node.insert(data=content_values)
-                                self._state.sync_zwave_devices_data(self.get_zwave_devices_from_db())
+                                self._controller.state.sync_zwave_devices_data(self.get_zwave_devices_from_db())
 
                             # HistoryContentProvider
                             case self.db.table_history.uri:
@@ -701,7 +734,7 @@ class QolsysPanel(QolsysObservable):
                                 partition_id = content_values.get("partition_id", "")
                                 self.db.table_alarmedsensor.insert(data=content_values)
 
-                                partition = self._state.partition(partition_id)
+                                partition = self._controller.state.partition(partition_id)
                                 if partition is not None:
                                     partition.append_alarm_type([PartitionAlarmType(content_values.get("sgroup", ""))])
 
@@ -726,9 +759,18 @@ class QolsysPanel(QolsysObservable):
                                 # No action needed
 
                             # EU_EVENT
-                            case self.db.table_eu_event:
+                            case self.db.table_eu_event.uri:
                                 self.db.table_eu_event.insert(data=content_values)
 
+                            # PowerG Device
+                            case self.db.table_powerg_device.uri:
+                                self.db.table_powerg_device.insert(data=content_values)
+
+                            # Weather
+                            case self.db.table_weather.uri:
+                                self.db.table_weather.insert(data=content_values)
+                                self._controller.state.sync_weather_data(self.get_weather_from_db())
+
                             case _:
                                 LOGGER.debug("iq2meid inserting unknow uri:%s", uri)
                                 LOGGER.debug(data)
@@ -814,13 +856,35 @@ class QolsysPanel(QolsysObservable):
 
         return scenes
 
+    def get_weather_from_db(self) -> QolsysWeather:
+        weather = QolsysWeather()
+        forecast_dic_list: list[dict] = self.db.get_weather()
+
+        forecast_obj_list = []
+        for forecast in forecast_dic_list:
+            forecast_obj_list.append(QolsysForecast(forecast))
+
+        # Create weather array
+        weather.update(forecast_obj_list)
+
+        return weather
+
     def get_zones_from_db(self) -> list[QolsysZone]:
         zones = []
         zones_list: list[dict] = self.db.get_zones()
 
         # Create sensors array
         for zone_info in zones_list:
-            zones.append(QolsysZone(zone_info,self._settings))
+            new_zone = QolsysZone(zone_info,self._controller.settings)
+
+            if new_zone.current_capability == "POWERG":
+                LOGGER.debug("Loading PowerG device info for zone %s", new_zone.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
 
@@ -898,3 +962,7 @@ class QolsysPanel(QolsysObservable):
         LOGGER.debug("Users list:")
         for user in self._users:
             LOGGER.debug("User: %s", user["id"])
+
+        LOGGER.debug("*** Plugin Information ***")
+        LOGGER.debug("Motion Delay Enabled: %s", self._controller.settings.motion_sensor_delay)
+        LOGGER.debug("Motion Delay Value: %s", self._controller.settings.motion_sensor_delay_sec)

qolsys_controller/partition.py

@@ -44,7 +44,7 @@ class QolsysPartition(QolsysObservable):
         self._command_arm_entry_delay = True
 
     @property
-    def id(self) -> int:
+    def id(self) -> str:
         return self._id
 
     @property

qolsys_controller/plugin.py

@@ -1,34 +1,24 @@
+from __future__ import annotations
+
 import logging
+from abc import abstractmethod
+from typing import TYPE_CHECKING
 
 from .observable import QolsysObservable
-from .panel import QolsysPanel
-from .settings import QolsysSettings
-from .state import QolsysState
 
 LOGGER = logging.getLogger(__name__)
 
+if TYPE_CHECKING:
+    from .controller import QolsysController
 
-class QolsysPlugin:
-    def __init__(self, state: QolsysState, panel: QolsysPanel, settings: QolsysSettings) -> None:
-
-        self._state: QolsysState = state
-        self._panel: QolsysPanel = panel
-        self._settings: QolsysSettings = settings
 
+class QolsysPlugin:
+    def __init__(self, controller: QolsysController) -> None:
+        self._controller = controller
         self.connected = False
         self.connected_observer = QolsysObservable()
 
+    @abstractmethod
     def config(self) -> None:
         pass
 
-    @property
-    def state(self) -> QolsysState:
-        return self._state
-
-    @property
-    def panel(self) -> QolsysPanel:
-        return self._panel
-
-    @property
-    def settings(self) -> QolsysSettings:
-        return self._settings

qolsys_controller/plugin_c4.py

@@ -9,7 +9,7 @@ class QolsysPluginC4(QolsysPlugin):
     def __init__(self) -> None:
 
         # C4 Integration
-        self._token = ""
+        raise NotImplementedError("C4 Plugin Not Yet Implemented") # noqa: EM101
 
     def config(self, panel_ip: str, token: str) -> bool:  # noqa: ARG002
         LOGGER.warning("C4Plugin: Configuring Plugin")