qolsys-controller 0.0.2__py3-none-any.whl → 0.0.5__py3-none-any.whl

qolsys_controller/panel.py

@@ -1,7 +1,5 @@
 import json
 import logging
-from datetime import datetime
-from pathlib import Path
 
 from .database.db import QolsysDB
 from .enum import (
@@ -11,6 +9,7 @@ from .enum import (
 )
 from .observable import QolsysObservable
 from .partition import QolsysPartition
+from .settings import QolsysSettings
 from .state import QolsysState
 from .zone import QolsysZone
 from .zwave_device import QolsysZWaveDevice
@@ -21,26 +20,31 @@ from .zwave_thermostat import QolsysThermostat
 
 LOGGER = logging.getLogger(__name__)
 
+
 class QolsysPanel(QolsysObservable):
-    def __init__(self,settings_directory:str,state:QolsysState) -> None:
+    def __init__(self, settings: QolsysSettings, state: QolsysState) -> None:
 
         self._state = state
+        self._settings = settings
         self._db = QolsysDB()
 
         # Partition settings
-        self.settings_partition = ["SYSTEM_STATUS","EXIT_SOUNDS","ENTRY_DELAYS","SYSTEM_STATUS_CHANGED_TIME"]
+        self.settings_partition = ["SYSTEM_STATUS", "EXIT_SOUNDS", "ENTRY_DELAYS", "SYSTEM_STATUS_CHANGED_TIME"]
         self.state_partition = ["ALARM_STATE"]
 
         # Panel settings
         self.settings_panel_observer = QolsysObservable()
-        self.settings_panel = ["PANEL_TAMPER_STATE","AC_STATUS","BATTERY_STATUS","FAIL_TO_COMMUNICATE","SECURE_ARMING",
-                                "AUTO_BYPASS","AUTO_STAY","AUTO_ARM_STAY","AUTO_EXIT_EXTENSION","FINAL_EXIT_DOOR_ARMING"
-                                "NO_ARM_LOW_BATTERY","TEMPFORMAT","LANGUAGE","COUNTRY","SYSTEM_TIME","GSM_CONNECTION_STATUS",
-                                "GSM_SIGNAL_STRENGTH","ANDROID_VERSION","HARDWARE_VERSION","TIMER_NORMAL_ENTRY_DELAY",
-                                "TIMER_NORMAL_EXIT_DELAY","TIMER_LONG_ENTRY_DELAY","TIMER_LONG_EXIT_DELAY","ZWAVE_CONTROLLER",
-                                "ZWAVE_CARD","POLICE_PANIC_ENABLED","FIRE_PANIC_ENABLED","AUXILIARY_PANIC_ENABLED","NIGHTMODE_SETTINGS",
-                                "NIGHT_SETTINGS_STATE","PARTITIONS","SIX_DIGIT_USER_CODE","SHOW_SECURITY_SENSORS","SYSTEM_LOGGED_IN_USER",
-                                "PANEL_SCENES_SETTING","CONTROL_4","ZWAVE_FIRM_WARE_VERSION","FINAL_EXIT_DOOR_ARMING","NO_ARM_LOW_BATTERY","MAC_ADDRESS","LAST_UPDATE_IQ_REMOTE_PATCH_CKECKSUM_N" ]
+        self.settings_panel = [
+            "PANEL_TAMPER_STATE", "AC_STATUS", "BATTERY_STATUS", "FAIL_TO_COMMUNICATE", "SECURE_ARMING", "AUTO_BYPASS",
+            "AUTO_STAY", "AUTO_ARM_STAY", "AUTO_EXIT_EXTENSION", "FINAL_EXIT_DOOR_ARMING", "NO_ARM_LOW_BATTERY",
+            "TEMPFORMAT", "LANGUAGE", "COUNTRY", "SYSTEM_TIME", "GSM_CONNECTION_STATUS", "GSM_SIGNAL_STRENGTH",
+            "ANDROID_VERSION", "HARDWARE_VERSION", "TIMER_NORMAL_ENTRY_DELAY", "TIMER_NORMAL_EXIT_DELAY",
+            "TIMER_LONG_ENTRY_DELAY", "TIMER_LONG_EXIT_DELAY", "ZWAVE_CONTROLLER", "ZWAVE_CARD", "POLICE_PANIC_ENABLED",
+            "FIRE_PANIC_ENABLED", "AUXILIARY_PANIC_ENABLED", "NIGHTMODE_SETTINGS", "NIGHT_SETTINGS_STATE", "PARTITIONS",
+            "SIX_DIGIT_USER_CODE", "SHOW_SECURITY_SENSORS", "SYSTEM_LOGGED_IN_USER", "PANEL_SCENES_SETTING", "CONTROL_4",
+            "ZWAVE_FIRM_WARE_VERSION", "FINAL_EXIT_DOOR_ARMING", "NO_ARM_LOW_BATTERY", "MAC_ADDRESS",
+            "LAST_UPDATE_IQ_REMOTE_PATCH_CKECKSUM_N",
+        ]
 
         self._PANEL_TAMPER_STATE = ""
         self._AC_STATUS = ""
@@ -84,28 +88,28 @@ class QolsysPanel(QolsysObservable):
 
         self._users = []
         self._unique_id = ""
-        self._settings_directory = settings_directory
 
         self._imei = ""
         self._product_type = ""
 
     def read_users_file(self) -> bool:
-        # Loading user_code data from users.conf file
-        try:
-            path = Path(self._settings_directory + "users.conf")
-            with path.open("r", encoding="utf-8") as file:
-                try:
-                    users = json.load(file)
-                    for user in users:
-                        self._users.append(user)
-
-                except json.JSONDecodeError:
-                    LOGGER.exception("users.conf file json error")
-                    return False
-
-        except FileNotFoundError:
-            LOGGER.exception("users.conf file not found")
-            return False
+        # Loading user_code data from users.conf file if exists
+        if self._settings.users_file_path.is_file():
+            try:
+                path = self._settings.users_file_path
+                with path.open("r", encoding="utf-8") as file:
+                    try:
+                        users = json.load(file)
+                        for user in users:
+                            self._users.append(user)
+
+                    except json.JSONDecodeError:
+                        LOGGER.exception("users.conf file json error")
+                        return False
+
+            except FileNotFoundError:
+                LOGGER.exception("users.conf file not found")
+                return False
 
         return True
 
@@ -284,26 +288,26 @@ class QolsysPanel(QolsysObservable):
         return self._TIMER_LONG_ENTRY_DELAY
 
     @property
-    def  MAC_ADDRESS(self) -> str:
+    def MAC_ADDRESS(self) -> str:
         self._MAC_ADDRESS = self.db.get_setting_panel("MAC_ADDRESS")
         return self._MAC_ADDRESS
 
     @MAC_ADDRESS.setter
-    def MAC_ADDRESS(self, value:str) -> None:
+    def MAC_ADDRESS(self, value: str) -> None:
         self._MAC_ADDRESS = value
 
     @property
-    def unique_id(self)  -> str:
+    def unique_id(self) -> str:
         mac_address = self.MAC_ADDRESS
-        return mac_address.replace(":","")
+        return mac_address.replace(":", "")
 
     @property
-    def TIMER_LONG_EXIT_DELAY(self) ->  str:
+    def TIMER_LONG_EXIT_DELAY(self) -> str:
         self._TIMER_LONG_EXIT_DELAY = self.db.get_setting_panel("TIMER_LONG_ENTRY_DELAY")
         return self._TIMER_LONG_EXIT_DELAY
 
     @property
-    def LAST_UPDATE_IQ_REMOTE_PATCH_CKECKSUM_N(self) -> str :
+    def LAST_UPDATE_IQ_REMOTE_PATCH_CKECKSUM_N(self) -> str:
         self._LAST_UPDATE_IQ_REMOTE_PATCH_CKECKSUM_N = self.db.get_setting_panel("LAST_UPDATE_IQ_REMOTE_PATCH_CKECKSUM_N")
         return self._LAST_UPDATE_IQ_REMOTE_PATCH_CKECKSUM_N
 
@@ -312,7 +316,7 @@ class QolsysPanel(QolsysObservable):
         return self._imei
 
     @imei.setter
-    def imei(self,value:str) -> None:
+    def imei(self, value: str) -> None:
         self._imei = value
 
     @property
@@ -320,7 +324,7 @@ class QolsysPanel(QolsysObservable):
         return self._product_type
 
     @product_type.setter
-    def product_type(self,value:str) -> None:
+    def product_type(self, value: str) -> None:
         self._product_type = value
 
     @property
@@ -329,7 +333,7 @@ class QolsysPanel(QolsysObservable):
         return self._SYSTEM_LOGGED_IN_USER
 
     @SYSTEM_LOGGED_IN_USER.setter
-    def SYSTEM_LOGGED_IN_USER(self,value:str) -> None:
+    def SYSTEM_LOGGED_IN_USER(self, value: str) -> None:
         self._SYSTEM_LOGGED_IN_USER = value
 
     @property
@@ -337,14 +341,14 @@ class QolsysPanel(QolsysObservable):
         self._PANEL_SCENES_SETTING = self.db.get_setting_panel("PANEL_SCENES_SETTING")
         return self.PANEL_SCENES_SETTING
 
-    def load_database(self,database:dict) -> None:
+    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())
 
     # Parse panel update to database
-    def parse_iq2meid_message(self,data:dict) -> bool:  # noqa: C901, PLR0912, PLR0915
+    def parse_iq2meid_message(self, data: dict) -> bool:  # noqa: C901, PLR0912, PLR0915
 
         eventName = data.get("eventName")
         dbOperation = data.get("dbOperation")
@@ -368,22 +372,22 @@ class QolsysPanel(QolsysObservable):
 
                             # Update Settings Content Provider
                             case self.db.table_qolsyssettings.uri:
-                                name = content_values.get("name","")
-                                new_value = content_values.get("value","")
+                                name = content_values.get("name", "")
+                                new_value = content_values.get("value", "")
                                 old_value = self.db.get_setting_panel(name)
-                                self.db.table_qolsyssettings.update(selection,selection_argument,content_values)
+                                self.db.table_qolsyssettings.update(selection, selection_argument, content_values)
 
                                 # Update Panel Settings - Send notification if settings ha changed
                                 if name in self.settings_panel and old_value != new_value:
-                                    LOGGER.debug("Panel Setting - %s: %s",name,new_value)
+                                    LOGGER.debug("Panel Setting - %s: %s", name, new_value)
                                     self.settings_panel_observer.notify()
 
                                 # Update Partition setting - Send notification if setting has changed
                                 if name in self.settings_partition:
-                                    partition_id = content_values.get("partition_id","")
+                                    partition_id = content_values.get("partition_id", "")
                                     partition = self._state.partition(partition_id)
                                     if partition is not None:
-                                       match name:
+                                        match name:
                                             case "SYSTEM_STATUS":
                                                 partition.system_status = PartitionSystemStatus(new_value)
                                             case "SYSTEM_STATUS_CHANGED_TIME":
@@ -395,18 +399,18 @@ class QolsysPanel(QolsysObservable):
 
                             # Update Sensor Content Provider
                             case self.db.table_sensor.uri:
-                                self.db.table_sensor.update(selection,selection_argument,content_values)
-                                zoneid =  content_values.get("zoneid","")
+                                self.db.table_sensor.update(selection, selection_argument, content_values)
+                                zoneid = content_values.get("zoneid", "")
                                 zone = self._state.zone(zoneid)
                                 if zone is not None:
                                     zone.update(content_values)
 
                             # Update State
                             case self.db.table_state.uri:
-                                name = content_values.get("name","")
-                                new_value = content_values.get("value","")
-                                partition_id = content_values.get("partition_id","")
-                                self.db.table_state.update(selection,selection_argument,content_values)
+                                name = content_values.get("name", "")
+                                new_value = content_values.get("value", "")
+                                partition_id = content_values.get("partition_id", "")
+                                self.db.table_state.update(selection, selection_argument, content_values)
 
                                 if name in self.state_partition:
                                     partition = self._state.partition(partition_id)
@@ -417,85 +421,85 @@ class QolsysPanel(QolsysObservable):
 
                             # Update heat_map
                             case self.db.table_heat_map.uri:
-                                self.db.table_heat_map.update(selection,selection_argument,content_values)
+                                self.db.table_heat_map.update(selection, selection_argument, content_values)
                                 # No action needed
 
                             # Update master_slave
                             case self.db.table_master_slave.uri:
-                                self.db.table_master_slave.update(selection,selection_argument,content_values)
+                                self.db.table_master_slave.update(selection, selection_argument, content_values)
                                 # No action needed
 
                             # Update dashboard_msgs
                             case self.db.table_dashboard_msgs.uri:
-                                self.db.table_dashboard_msgs.update(selection,selection_argument,content_values)
+                                self.db.table_dashboard_msgs.update(selection, selection_argument, content_values)
                                 # No action needed
 
                             # Update PartitionContentProvider
                             case self.db.table_partition.uri:
-                                self.db.table_partition.update(selection,selection_argument,content_values)
-                                partition_id = content_values.get("partition_id","")
+                                self.db.table_partition.update(selection, selection_argument, content_values)
+                                partition_id = content_values.get("partition_id", "")
                                 partition = self._state.partition(partition_id)
                                 if partition is not None:
                                     partition.update_partition(content_values)
 
                             # Update History Content Provider
                             case self.db.table_history.uri:
-                                self.db.table_history.update(selection,selection_argument,content_values)
+                                self.db.table_history.update(selection, selection_argument, content_values)
                                 # No action needed
 
                             # Update DimmerLightsContentProvider
                             case self.db.table_dimmer.uri:
-                                self.db.table_dimmer.update(selection,selection_argument,content_values)
-                                node_id =  content_values.get("node_id","")
+                                self.db.table_dimmer.update(selection, selection_argument, content_values)
+                                node_id = content_values.get("node_id", "")
                                 node = self._state.zwave_device(node_id)
-                                if node is not None and isinstance(node,QolsysDimmer):
+                                if node is not None and isinstance(node, QolsysDimmer):
                                     node.update_dimmer(content_values)
 
                             # Update Thermostat Content Provider
                             case self.db.table_thermostat.uri:
-                                self.db.table_thermostat.update(selection,selection_argument,content_values)
-                                node_id =  content_values.get("node_id","")
+                                self.db.table_thermostat.update(selection, selection_argument, content_values)
+                                node_id = content_values.get("node_id", "")
                                 node = self._state.zwave_device(node_id)
-                                if node is not None and isinstance(node,QolsysThermostat):
+                                if node is not None and isinstance(node, QolsysThermostat):
                                     node.update_thermostat(content_values)
 
                             # Update DoorLockContentProvider
                             case self.db.table_doorlock.uri:
-                                self.db.table_doorlock.update(selection,selection_argument,content_values)
-                                node_id =  content_values.get("node_id","")
+                                self.db.table_doorlock.update(selection, selection_argument, content_values)
+                                node_id = content_values.get("node_id", "")
                                 node = self._state.zwave_device(node_id)
-                                if node is not None and isinstance(node,QolsysLock):
+                                if node is not None and isinstance(node, QolsysLock):
                                     node.update_lock(content_values)
 
                             # Update ZwaveContentProvider
                             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","")
+                                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)
                                 if node is not None:
                                     node.update_base(content_values)
 
                             # Update Z-Wave History Content Provier
                             case self.db.table_zwave_history.uri:
-                                self.db.table_zwave_history.update(selection,selection_argument,content_values)
+                                self.db.table_zwave_history.update(selection, selection_argument, content_values)
                                 # No action needed
 
                             # Update AutomationDeviceContentProvider
                             case self.db.table_automation.uri:
-                                self.db.table_automation.update(selection,selection_argument,content_values)
+                                self.db.table_automation.update(selection, selection_argument, content_values)
                                 # No action needed
 
                             # Update Alarmed Sensor Content Provider
                             case self.db.table_alarmedsensor.uri:
-                                self.db.table_alarmedsensor.update(selection,selection_argument,content_values)
+                                self.db.table_alarmedsensor.update(selection, selection_argument, content_values)
 
                             # Update IQ Remote Settings Content Provider
                             case self.db.table_iqremotesettings.uri:
-                                self.db.table_iqremotesettings.update(selection,selection_argument,content_values)
+                                self.db.table_iqremotesettings.update(selection, selection_argument, content_values)
                                 # No action needed
 
                             case _:
-                                LOGGER.debug("iq2meid updating unknow uri:%s",uri)
+                                LOGGER.debug("iq2meid updating unknow uri:%s", uri)
                                 LOGGER.debug(data)
 
                     case "delete":
@@ -505,72 +509,72 @@ class QolsysPanel(QolsysObservable):
                         match uri:
 
                             case self.db.table_sensor.uri:
-                                self.db.table_sensor.delete(selection,selection_argument)
+                                self.db.table_sensor.delete(selection, selection_argument)
                                 self._state.sync_zones_data(self.get_zones_from_db())
                                 # Notify delete zone
 
                             case self.db.table_iqremotesettings.uri:
-                                self.db.table_iqremotesettings.delete(selection,selection_argument)
+                                self.db.table_iqremotesettings.delete(selection, selection_argument)
                                 # No action needed
 
                             case self.db.table_state.uri:
-                                self.db.table_state.delete(selection,selection_argument)
+                                self.db.table_state.delete(selection, selection_argument)
                                 # No action needed
 
                             case self.db.table_master_slave.uri:
-                                self.db.table_master_slave.delete(selection,selection_argument)
+                                self.db.table_master_slave.delete(selection, selection_argument)
                                 # No action needed
 
                             case self.db.table_qolsyssettings.uri:
-                                self.db.table_qolsyssettings.delete(selection,selection_argument)
+                                self.db.table_qolsyssettings.delete(selection, selection_argument)
                                 # No action needed
 
                             case self.db.table_alarmedsensor.uri:
-                                self.db.table_alarmedsensor.delete(selection,selection_argument)
+                                self.db.table_alarmedsensor.delete(selection, selection_argument)
                                 self._state.sync_partitions_data(self.get_partitions_from_db())
 
                             case self.db.table_history.uri:
-                                self.db.table_history.delete(selection,selection_argument)
+                                self.db.table_history.delete(selection, selection_argument)
                                 # No action needed
 
                             case self.db.table_zwave_history.uri:
-                                self.db.table_zwave_history.delete(selection,selection_argument)
+                                self.db.table_zwave_history.delete(selection, selection_argument)
                                 # No action needed
 
                             case self.db.table_doorlock.uri:
-                                self.db.table_doorlock.delete(selection,selection_argument)
+                                self.db.table_doorlock.delete(selection, selection_argument)
                                 self._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.db.table_dimmer.delete(selection, selection_argument)
                                 self._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.db.table_thermostat.delete(selection, selection_argument)
                                 self._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.db.table_zwave_node.delete(selection, selection_argument)
                                 self._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)
+                                self.db.table_automation.delete(selection, selection_argument)
                                 # No action needed
 
                             case self.db.table_partition.uri:
-                                self.db.table_partition.delete(selection,selection_argument)
+                                self.db.table_partition.delete(selection, selection_argument)
                                 self._state.sync_partitions_data(self.get_partitions_from_db())
 
                             case self.db.table_user.uri:
-                                self.db.table_user.delete(selection,selection_argument)
+                                self.db.table_user.delete(selection, selection_argument)
                                 # No action needed
 
                             case self.db.table_dashboard_msgs.uri:
-                                self.db.table_dashboard_msgs.delete(selection,selection_argument)
+                                self.db.table_dashboard_msgs.delete(selection, selection_argument)
                                 # No action needed
 
                             case _:
-                                LOGGER.debug("iq2meid deleting unknown uri:%s",uri)
+                                LOGGER.debug("iq2meid deleting unknown uri:%s", uri)
                                 LOGGER.debug(data)
 
                     case "insert":
@@ -582,10 +586,10 @@ class QolsysPanel(QolsysObservable):
                             case self.db.table_state.uri:
                                 self.db.table_state.insert(data=content_values)
 
-                                name = content_values.get("name","")
-                                new_value = content_values.get("value","")
+                                name = content_values.get("name", "")
+                                new_value = content_values.get("value", "")
                                 if name in self.state_partition:
-                                    partition_id = content_values.get("partition_id","")
+                                    partition_id = content_values.get("partition_id", "")
                                     partition = self._state.partition(partition_id)
                                     if partition is not None:
                                         match name:
@@ -602,13 +606,13 @@ class QolsysPanel(QolsysObservable):
                                 self.db.table_qolsyssettings.insert(data=content_values)
 
                                 # Update Partition setting - Send notification if setting has changed
-                                name = content_values.get("name","")
-                                new_value = content_values.get("value","")
+                                name = content_values.get("name", "")
+                                new_value = content_values.get("value", "")
                                 if name in self.settings_partition:
-                                    partition_id = content_values.get("partition_id","")
+                                    partition_id = content_values.get("partition_id", "")
                                     partition = self._state.partition(partition_id)
                                     if partition is not None:
-                                       match name:
+                                        match name:
                                             case "SYSTEM_STATUS":
                                                 partition.system_status = PartitionSystemStatus(new_value)
                                             case "SYSTEM_STATUS_CHANGED_TIME":
@@ -653,7 +657,7 @@ class QolsysPanel(QolsysObservable):
                                 self.db.table_thermostat.insert(data=content_values)
                                 self._state.sync_zwave_devices_data(self.get_zwave_devices_from_db())
 
-                            #ZWave Node Content Provider
+                            # 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())
@@ -666,12 +670,12 @@ class QolsysPanel(QolsysObservable):
                             # AlarmedSensorProvider
                             case self.db.table_alarmedsensor.uri:
 
-                                partition_id = content_values.get("partition_id","")
+                                partition_id = content_values.get("partition_id", "")
                                 self.db.table_alarmedsensor.insert(data=content_values)
 
                                 partition = self._state.partition(partition_id)
                                 if partition is not None:
-                                    partition.append_alarm_type([PartitionAlarmType(content_values.get("sgroup",""))])
+                                    partition.append_alarm_type([PartitionAlarmType(content_values.get("sgroup", ""))])
 
                             # IQRemoteSettingsProvider
                             case self.db.table_iqremotesettings.uri:
@@ -693,19 +697,18 @@ class QolsysPanel(QolsysObservable):
                                 self.db.table_dashboard_msgs.insert(data=content_values)
                                 # No action needed
 
-
                             case _:
-                                LOGGER.debug("iq2meid inserting unknow uri:%s",uri)
+                                LOGGER.debug("iq2meid inserting unknow uri:%s", uri)
                                 LOGGER.debug(data)
 
                     case _:
-                        LOGGER.debug("iq2meid - Unknow dboperation: %s",dbOperation)
+                        LOGGER.debug("iq2meid - Unknow dboperation: %s", dbOperation)
                         LOGGER.debug(data)
             case _:
-                LOGGER.debug("iq2meid - Unknow event: %s",eventName)
+                LOGGER.debug("iq2meid - Unknow event: %s", eventName)
                 LOGGER.debug(data)
 
-    def check_user(self,user_code:str) -> int:
+    def check_user(self, user_code: str) -> int:
         for user in self._users:
             if user["user_code"] == user_code:
                 return user["id"]
@@ -724,36 +727,36 @@ class QolsysPanel(QolsysObservable):
 
             device_added = False
 
-            zwave_node_id = device.get("node_id","")
+            zwave_node_id = device.get("node_id", "")
             # Check if z-wave device is a Dimmer
             for d in dimmers_list:
-                dimmer_node_id = d.get("node_id","")
+                dimmer_node_id = d.get("node_id", "")
 
                 # Found a Dimmer
                 if zwave_node_id == dimmer_node_id:
-                    qolsys_dimmer = QolsysDimmer(d,device)
+                    qolsys_dimmer = QolsysDimmer(d, device)
                     devices.append(qolsys_dimmer)
                     device_added = True
                     break
 
             # Check is z-wave devie is a Thermostat
             for thermostat in thermostats_list:
-                thermostat_node_id = thermostat.get("node_id","")
+                thermostat_node_id = thermostat.get("node_id", "")
 
                 # Found a Thermostat
                 if zwave_node_id == thermostat_node_id:
-                    qolsys_thermostat = QolsysThermostat(thermostat,device)
+                    qolsys_thermostat = QolsysThermostat(thermostat, device)
                     devices.append(qolsys_thermostat)
                     device_added = True
                     break
 
             # Check is z-wave device is a Lock
             for lock in locks_list:
-                lock_node_id = lock.get("node_id","")
+                lock_node_id = lock.get("node_id", "")
 
                 # Found a Lock
                 if zwave_node_id == lock_node_id:
-                    qolsys_lock = QolsysLock(lock,device)
+                    qolsys_lock = QolsysLock(lock, device)
                     devices.append(qolsys_lock)
                     device_added = True
                     break
@@ -771,9 +774,9 @@ class QolsysPanel(QolsysObservable):
 
     def get_zones_from_db(self) -> list[QolsysZone]:
         zones = []
-        zones_list:list[dict] = self.db.get_zones()
+        zones_list: list[dict] = self.db.get_zones()
 
-         # Create sensors array
+        # Create sensors array
         for zone_info in zones_list:
             zones.append(QolsysZone(zone_info))
 
@@ -782,7 +785,7 @@ class QolsysPanel(QolsysObservable):
     def get_partitions_from_db(self) -> list[QolsysPartition]:
 
         partitions = []
-        partition_list:list[dict] = self.db.get_partitions()
+        partition_list: list[dict] = self.db.get_partitions()
 
         # Create partitions array
         for partition_dict in partition_list:
@@ -790,10 +793,10 @@ class QolsysPanel(QolsysObservable):
             partition_id = partition_dict["partition_id"]
 
             settings_dict = {
-                "SYSTEM_STATUS": self.db.get_setting_partition("SYSTEM_STATUS",partition_id) or "UNKNOWN",
-                "SYSTEM_STATUS_CHANGED_TIME": self.db.get_setting_partition("SYSTEM_STATUS_CHANGED_TIME",partition_id) or "",
-                "EXIT_SOUNDS": self.db.get_setting_partition("EXIT_SOUNDS",partition_id) or "",
-                "ENTRY_DELAYS":  self.db.get_setting_partition("ENTRY_DELAYS",partition_id) or "",
+                "SYSTEM_STATUS": self.db.get_setting_partition("SYSTEM_STATUS", partition_id) or "UNKNOWN",
+                "SYSTEM_STATUS_CHANGED_TIME": self.db.get_setting_partition("SYSTEM_STATUS_CHANGED_TIME", partition_id) or "",
+                "EXIT_SOUNDS": self.db.get_setting_partition("EXIT_SOUNDS", partition_id) or "",
+                "ENTRY_DELAYS": self.db.get_setting_partition("ENTRY_DELAYS", partition_id) or "",
             }
 
             alarm_type = []
@@ -803,54 +806,53 @@ class QolsysPanel(QolsysObservable):
                 else:
                     alarm_type.append(PartitionAlarmType(alarm))
 
-            alarm_state = PartitionAlarmState(self.db.get_state_partition("ALARM_STATE",partition_id) or "UNKNOWN")
+            alarm_state = PartitionAlarmState(self.db.get_state_partition("ALARM_STATE", partition_id) or "UNKNOWN")
 
-            partition = QolsysPartition(partition_dict,settings_dict,alarm_state,alarm_type)
+            partition = QolsysPartition(partition_dict, settings_dict, alarm_state, alarm_type)
             partitions.append(partition)
 
         return partitions
 
     def dump(self) -> None:
         LOGGER.debug("*** Qolsys Panel Information ***")
-        LOGGER.debug("Android Version: %s",self.ANDROID_VERSION)
-        LOGGER.debug("Hardware Version: %s",self.HARDWARE_VERSION)
-        LOGGER.debug("MAC Address: %s",self.MAC_ADDRESS)
-        LOGGER.debug("Unique ID: %s",self.unique_id)
-        LOGGER.debug("Panel Tamper State: %s",self.PANEL_TAMPER_STATE)
-        LOGGER.debug("AC Status: %s",self.AC_STATUS)
-        LOGGER.debug("Battery Status: %s",self.BATTERY_STATUS)
-        LOGGER.debug("GSM Connection Status: %s",self.GSM_CONNECTION_STATUS)
-        LOGGER.debug("GSM Signal Strength: %s",self.GSM_SIGNAL_STRENGTH)
-        LOGGER.debug("Fail To Communicate: %s",self.FAIL_TO_COMMUNICATE)
-        LOGGER.debug("System Time: %s",datetime.fromtimestamp(int(self.SYSTEM_TIME)/1000))
-        LOGGER.debug("Country: %s",self.COUNTRY)
-        LOGGER.debug("Language: %s",self.LANGUAGE)
-        LOGGER.debug("Temp Format: %s",self.TEMPFORMAT)
-        LOGGER.debug("Z-Wave Firmware Version: %s",self.ZWAVE_FIRM_WARE_VERSION)
-        LOGGER.debug("Z-Wave Card Present: %s",self.ZWAVE_CARD)
-        LOGGER.debug("Z-Wave Controller Enabled: %s",self.ZWAVE_CONTROLLER)
-        LOGGER.debug("Partitons Enabled: %s",self.PARTITIONS)
-        LOGGER.debug("Control4 Enabled: %s",self.CONTROL_4)
-        LOGGER.debug("Six Digit User Code Enabled: %s",self.SIX_DIGIT_USER_CODE)
-        LOGGER.debug("Secure Arming: %s",self.SECURE_ARMING)
-        LOGGER.debug("Auto-Stay: %s",self.AUTO_STAY)
-        LOGGER.debug("Auto-Bypass: %s",self.AUTO_BYPASS)
-        LOGGER.debug("Auto-Arm-Stay: %s",self.AUTO_ARM_STAY)
-        LOGGER.debug("Auto-Exit-Extension: %s",self.AUTO_EXIT_EXTENSION)
-        LOGGER.debug("Final-Exit-Door-Arming: %s",self.FINAL_EXIT_DOOR_ARMING)
-        LOGGER.debug("No-Arm-Low-Battery: %s",self.NO_ARM_LOW_BATTERY)
-        LOGGER.debug("Normal Entry Delay: %s",self.TIMER_NORMAL_ENTRY_DELAY)
-        LOGGER.debug("Normal Exit Delay: %s",self.TIMER_NORMAL_EXIT_DELAY)
-        LOGGER.debug("Long Entry Delay: %s",self.TIMER_LONG_ENTRY_DELAY)
-        LOGGER.debug("Long Exit Delay: %s",self.TIMER_LONG_EXIT_DELAY)
-        LOGGER.debug("Auxiliary Panic Enabled: %s",self.AUXILIARY_PANIC_ENABLED)
-        LOGGER.debug("Fire Panic Enabled: %s",self.FIRE_PANIC_ENABLED)
-        LOGGER.debug("Police Panic Enabled: %s",self.POLICE_PANIC_ENABLED)
-        LOGGER.debug("Night Mode Settings: %s",self.NIGHTMODE_SETTINGS)
-        LOGGER.debug("Night Mode Settings Stage: %s",self.NIGHT_SETTINGS_STATE)
-        LOGGER.debug("Show Security Sensors: %s",self.SHOW_SECURITY_SENSORS)
+        LOGGER.debug("Android Version: %s", self.ANDROID_VERSION)
+        LOGGER.debug("Hardware Version: %s", self.HARDWARE_VERSION)
+        LOGGER.debug("MAC Address: %s", self.MAC_ADDRESS)
+        LOGGER.debug("Unique ID: %s", self.unique_id)
+        LOGGER.debug("Panel Tamper State: %s", self.PANEL_TAMPER_STATE)
+        LOGGER.debug("AC Status: %s", self.AC_STATUS)
+        LOGGER.debug("Battery Status: %s", self.BATTERY_STATUS)
+        LOGGER.debug("GSM Connection Status: %s", self.GSM_CONNECTION_STATUS)
+        LOGGER.debug("GSM Signal Strength: %s", self.GSM_SIGNAL_STRENGTH)
+        LOGGER.debug("Fail To Communicate: %s", self.FAIL_TO_COMMUNICATE)
+        # LOGGER.debug("System Time: %s",datetime.fromtimestamp(int(self.SYSTEM_TIME)/1000))
+        LOGGER.debug("Country: %s", self.COUNTRY)
+        LOGGER.debug("Language: %s", self.LANGUAGE)
+        LOGGER.debug("Temp Format: %s", self.TEMPFORMAT)
+        LOGGER.debug("Z-Wave Firmware Version: %s", self.ZWAVE_FIRM_WARE_VERSION)
+        LOGGER.debug("Z-Wave Card Present: %s", self.ZWAVE_CARD)
+        LOGGER.debug("Z-Wave Controller Enabled: %s", self.ZWAVE_CONTROLLER)
+        LOGGER.debug("Partitons Enabled: %s", self.PARTITIONS)
+        LOGGER.debug("Control4 Enabled: %s", self.CONTROL_4)
+        LOGGER.debug("Six Digit User Code Enabled: %s", self.SIX_DIGIT_USER_CODE)
+        LOGGER.debug("Secure Arming: %s", self.SECURE_ARMING)
+        LOGGER.debug("Auto-Stay: %s", self.AUTO_STAY)
+        LOGGER.debug("Auto-Bypass: %s", self.AUTO_BYPASS)
+        LOGGER.debug("Auto-Arm-Stay: %s", self.AUTO_ARM_STAY)
+        LOGGER.debug("Auto-Exit-Extension: %s", self.AUTO_EXIT_EXTENSION)
+        LOGGER.debug("Final-Exit-Door-Arming: %s", self.FINAL_EXIT_DOOR_ARMING)
+        LOGGER.debug("No-Arm-Low-Battery: %s", self.NO_ARM_LOW_BATTERY)
+        LOGGER.debug("Normal Entry Delay: %s", self.TIMER_NORMAL_ENTRY_DELAY)
+        LOGGER.debug("Normal Exit Delay: %s", self.TIMER_NORMAL_EXIT_DELAY)
+        LOGGER.debug("Long Entry Delay: %s", self.TIMER_LONG_ENTRY_DELAY)
+        LOGGER.debug("Long Exit Delay: %s", self.TIMER_LONG_EXIT_DELAY)
+        LOGGER.debug("Auxiliary Panic Enabled: %s", self.AUXILIARY_PANIC_ENABLED)
+        LOGGER.debug("Fire Panic Enabled: %s", self.FIRE_PANIC_ENABLED)
+        LOGGER.debug("Police Panic Enabled: %s", self.POLICE_PANIC_ENABLED)
+        LOGGER.debug("Night Mode Settings: %s", self.NIGHTMODE_SETTINGS)
+        LOGGER.debug("Night Mode Settings Stage: %s", self.NIGHT_SETTINGS_STATE)
+        LOGGER.debug("Show Security Sensors: %s", self.SHOW_SECURITY_SENSORS)
 
         LOGGER.debug("Users list:")
         for user in self._users:
-            LOGGER.debug("User: %s",user["id"])
-
+            LOGGER.debug("User: %s", user["id"])