qolsys-controller 0.0.2__tar.gz → 0.0.4__tar.gz

qolsys_controller-0.0.4/.github/workflows/publish.yml

@@ -0,0 +1,27 @@
+    name: Publish Python package to PyPI
+
+    on:
+      release:
+        types: [published]
+
+    jobs:
+      pypi-publish:
+        name: Upload release to PyPI
+        runs-on: ubuntu-latest
+        environment:
+          name: pypi
+          url: https://pypi.org/project/qolsys-controller/ 
+        permissions:
+          id-token: write # Required for PyPI Trusted Publishers
+        steps:
+          - uses: actions/checkout@v4
+          - name: Set up Python
+            uses: actions/setup-python@v5
+            with:
+              python-version: "3.12"
+          - name: Install build dependencies
+            run: python -m pip install build
+          - name: Build package
+            run: python -m build
+          - name: Publish package to PyPI
+            uses: pypa/gh-action-pypi-publish@release/v1

qolsys_controller-0.0.4/.github/workflows/python-app.yml

@@ -0,0 +1,36 @@
+# This workflow will install Python dependencies, run tests and lint with a single version of Python
+# For more information see: https://docs.github.com/en/actions/automating-builds-and-tests/building-and-testing-python
+
+name: Python application
+
+on:
+  push:
+    branches: [ "main" ]
+  pull_request:
+    branches: [ "main" ]
+
+permissions:
+  contents: read
+
+jobs:
+  build:
+
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v4
+    - name: Set up Python 3.12
+      uses: actions/setup-python@v3
+      with:
+        python-version: "3.12"
+    - name: Install dependencies
+      run: |
+        python -m pip install --upgrade pip
+        pip install flake8 pytest
+        if [ -f requirements.txt ]; then pip install -r requirements.txt; fi
+    - name: Lint with flake8
+      run: |
+        # stop the build if there are Python syntax errors or undefined names
+        flake8 . --count --select=E9,F63,F7,F82 --show-source --statistics
+        # exit-zero treats all errors as warnings. The GitHub editor is 127 chars wide
+        flake8 . --count --exit-zero --max-complexity=10 --max-line-length=127 --statistics

{qolsys_controller-0.0.2 → qolsys_controller-0.0.4}/.gitignore

@@ -3,6 +3,8 @@
 /__pycache__
 .pyc
 build
+dist
+config
 __pycache__
 *.key
 *.secure

{qolsys_controller-0.0.2 → qolsys_controller-0.0.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: qolsys-controller
-Version: 0.0.2
+Version: 0.0.4
 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.4/bin/qolsys.py

@@ -0,0 +1,75 @@
+#!/usr/bin/env python3
+
+import argparse
+import asyncio
+import logging
+import os
+import sys
+
+from qolsys_controller import qolsys_controller
+from qolsys_controller.errors import QolsysMqttError, QolsysSqlError, QolsysSslError
+
+
+async def main() -> None:  # noqa: D103
+
+    cli_parser = argparse.ArgumentParser()
+    cli_parser.add_argument("--panel-ip", help="Qolsys Panel IP", default="")
+    cli_parser.add_argument("--plugin-ip", help="Plugin IP", default="")
+    cli_parser.add_argument("--config-dir", help="Configuration Directory", default="./config/")
+    cli_parser.add_argument("--pki-autodiscovery", help="Enable PKI Autodiscovery", action="store_true")
+    cli_parser.add_argument("--debug", help="Verbose MQTT Traffic", action="store_true")
+
+    args = cli_parser.parse_args()
+
+    logging.basicConfig(level=logging.DEBUG, format="%(levelname)s - %(module)s: %(message)s")
+    LOGGER = logging.getLogger(__name__)
+
+    loop = asyncio.new_event_loop()
+    asyncio.set_event_loop(loop)
+
+    Panel = qolsys_controller()
+
+    # Select plugin
+    Panel.select_plugin("remote")
+    Panel.settings.config_directory = args.config_dir
+    Panel.plugin.settings.panel_ip = args.panel_ip
+    Panel.plugin.settings.plugin_ip = args.plugin_ip
+    Panel.plugin.settings.random_mac = ""
+
+    # Additionnal remote plugin config
+    Panel.plugin.check_user_code_on_disarm = False
+    Panel.plugin.log_mqtt_mesages = args.debug
+    Panel.plugin.auto_discover_pki = args.pki_autodiscovery
+
+    # Configure remote plugin
+    if not await Panel.plugin.config(start_pairing=True):
+        LOGGER.debug("Error Configuring remote plugin")
+        return
+
+    try:
+        await Panel.plugin.start_operation()
+
+    except QolsysMqttError:
+        LOGGER.debug("QolsysMqttError")
+
+    except QolsysSslError:
+        LOGGER.debug("QolsysSslError")
+
+    except QolsysSqlError:
+        LOGGER.debug("QolsysSqlError")
+
+    if not Panel.plugin.connected:
+        LOGGER.error("Panel not ready for operation")
+        return
+
+    LOGGER.debug("Qolsys Panel Ready for operation")
+
+    stop_event = asyncio.Event()
+    await stop_event.wait()
+
+# Change to the "Selector" event loop if platform is Windows
+if sys.platform.lower() == "win32" or os.name.lower() == "nt":
+    from asyncio import WindowsSelectorEventLoopPolicy, set_event_loop_policy
+    set_event_loop_policy(WindowsSelectorEventLoopPolicy())
+
+asyncio.run(main())

{qolsys_controller-0.0.2 → qolsys_controller-0.0.4}/example.py

@@ -8,23 +8,25 @@ import sys
 from qolsys_controller.controller import QolsysController
 from qolsys_controller.errors import QolsysMqttError, QolsysSqlError, QolsysSslError
 
-logging.basicConfig(level=logging.DEBUG,format="%(levelname)s - %(module)s: %(message)s")
+logging.basicConfig(level=logging.DEBUG, format="%(levelname)s - %(module)s: %(message)s")
 LOGGER = logging.getLogger(__name__)
 
+
 async def main() -> None:  # noqa: D103
 
-    remote = QolsysController(config_directory="./config/")
+    remote = QolsysController()
 
     # Select plugin
     remote.select_plugin("remote")
 
-    remote.plugin.settings.panel_ip =  "192.168.10.220"
+    remote.plugin.settings.config_directory = "./config/"
+    remote.plugin.settings.panel_ip = "192.168.10.220"
     remote.plugin.settings.plugin_ip = "192.168.10.73"
-    remote.plugin.settings.random_mac = "" # Example: F2:16:3E:33:ED:20
+    remote.plugin.settings.random_mac = ""  # Example: F2:16:3E:33:ED:20
 
     # Additionnal remote plugin config
-    remote.plugin.check_user_code_on_disarm = False # Check user code in user.conf file
-    remote.plugin.log_mqtt_mesages = False # Enable for MQTT debug purposes
+    remote.plugin.check_user_code_on_disarm = False  # Check user code in user.conf file
+    remote.plugin.log_mqtt_mesages = False  # Enable for MQTT debug purposes
     remote.plugin.auto_discover_pki = True
 
     # Configure remote plugin
@@ -36,13 +38,13 @@ async def main() -> None:  # noqa: D103
         await remote.plugin.start_operation()
 
     except QolsysMqttError:
-            LOGGER.debug("QolsysMqttError")
+        LOGGER.debug("QolsysMqttError")
 
     except QolsysSslError:
-            LOGGER.debug("QolsysSslError")
+        LOGGER.debug("QolsysSslError")
 
     except QolsysSqlError:
-            LOGGER.debug("QolsysSqlError")
+        LOGGER.debug("QolsysSqlError")
 
     if not remote.plugin.connected:
         LOGGER.error("Panel not ready for operation")
@@ -56,9 +58,9 @@ async def main() -> None:  # noqa: D103
     # await asyncio.sleep(3)
     # await remote.plugin.command_zwave_switch_multi_level(node_id=6,level=99)
 
-     # DISARM
-    #await asyncio.sleep(3)
-    #await remote.plugin.command_disarm(partition_id="0",
+    # DISARM
+    # await asyncio.sleep(3)
+    # await remote.plugin.command_disarm(partition_id="0",
     #                                   user_code="1111")
 
     # ARM_STAY
@@ -68,24 +70,23 @@ async def main() -> None:  # noqa: D103
                                     user_code="1111",
                                     exit_sounds=False,
                                     instant_arm=False)
-    
 
     # DISARM
     await asyncio.sleep(3)
     await remote.plugin.command_disarm(partition_id="0",
                                        user_code="1111")
 
-
     # ARM_AWAY
-    #await asyncio.sleep(3)
-    #await remote.plugin.command_arm(partition_id=0,
+    # await asyncio.sleep(3)
+    # await remote.plugin.command_arm(partition_id=0,
     #                               arming_type='ARM-AWAY',
     #                               user_code='1111',
     #                                exit_sounds=True,
     #                               instant_arm=False)
 
-    while True:
-        await asyncio.sleep(1)
+    # Use an asyncio.Event to keep the program running efficiently
+    stop_event = asyncio.Event()
+    await stop_event.wait()
 
 # Change to the "Selector" event loop if platform is Windows
 if sys.platform.lower() == "win32" or os.name.lower() == "nt":
@@ -93,5 +94,3 @@ if sys.platform.lower() == "win32" or os.name.lower() == "nt":
     set_event_loop_policy(WindowsSelectorEventLoopPolicy())
 
 asyncio.run(main())
-
-

{qolsys_controller-0.0.2 → qolsys_controller-0.0.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "qolsys-controller"
-version = "0.0.2"
+version = "0.0.4"
 authors = [
   { name="Eric Hylands", email="" },
 ]
@@ -31,5 +31,5 @@ line-length = 88
 
 [tool.ruff.lint]
 select = ['ALL']
-ignore = ["E501","S608","S311","S104","D100","D101", "D102","D107", "FBT001", "N802","N806","PERF401"]
+ignore = ["E501","S608","S311","S104","D100","D101", "D102","D107","ERA001", "FBT001","FBT002", "N802","N806","PERF401"]
 

{qolsys_controller-0.0.2 → qolsys_controller-0.0.4}/qolsys_controller/controller.py

@@ -9,16 +9,16 @@ from .state import QolsysState
 
 LOGGER = logging.getLogger(__name__)
 
+
 class QolsysController:
 
-    def __init__(self,config_directory:str) -> None:
+    def __init__(self) -> None:
 
         # QolsysController Information
         self.plugin = None
-        self._config_directory = config_directory
         self._state = QolsysState()
-        self._panel = QolsysPanel(settings_directory=config_directory,state=self.state)
         self._settings = QolsysSettings()
+        self._panel = QolsysPanel(settings=self.settings, state=self.state)
 
     @property
     def state(self) -> QolsysState:
@@ -32,21 +32,19 @@ class QolsysController:
     def settings(self) -> QolsysSettings:
         return self._settings
 
-    def select_plugin(self,plugin: str) -> None:
+    def select_plugin(self, plugin: str) -> None:
 
         match plugin:
 
             case "c4":
                 LOGGER.debug("C4 Plugin Selected")
-                self.plugin = QolsysPluginC4(self.state,self.panel,self.settings)
+                self.plugin = QolsysPluginC4(self.state, self.panel, self.settings)
                 return
 
             case "remote":
                 LOGGER.debug("Remote Plugin Selected")
-                self.plugin = QolsysPluginRemote(self.state,self.panel,self.settings,self._config_directory)
+                self.plugin = QolsysPluginRemote(self.state, self.panel, self.settings)
                 return
 
             case _:
                 LOGGER.debug("Unknow Plugin Selected")
-
-

{qolsys_controller-0.0.2 → qolsys_controller-0.0.4}/qolsys_controller/database/db.py

@@ -36,44 +36,45 @@ from .table_zwave_other import QolsysTableZwaveOther
 
 LOGGER = logging.getLogger(__name__)
 
+
 class QolsysDB:
 
     def __init__(self) -> None:  # noqa: PLR0915
 
-        self._db:sqlite3.Connection = sqlite3.connect(":memory:")
-        self._cursor:sqlite3.Cursor = self._db.cursor()
-
-        self.table_alarmedsensor = QolsysTableAlarmedSensor(self.db,self.cursor)
-        self.table_automation = QolsysTableAutomation(self.db,self.cursor)
-        self.table_country_locale = QolsysTableCountryLocale(self.db,self.cursor)
-        self.table_dashboard_msgs = QolsysTableDashboardMsgs(self.db,self.cursor)
-        self.table_dimmer = QolsysTableDimmerLight(self.db,self.cursor)
-        self.table_doorlock = QolsysTableDoorLock(self.db,self.cursor)
-        self.table_eu_event = QolsysTableEuEvent(self.db,self.cursor)
-        self.table_heat_map = QolsysTableHeatMap(self.db,self.cursor)
-        self.table_history = QolsysTableHistory(self.db,self.cursor)
-        self.table_iqremotesettings = QolsysTableIqRemoteSettings(self.db,self.cursor)
-        self.table_iqrouter_network_config = QolsysTableIqRouterNetworkConfig(self.db,self.cursor)
-        self.table_iqrouter_user_device = QolsysTableIqRouterUserDevice(self.db,self.cursor)
-        self.table_master_slave = QolsysTableMasterSlave(self.db,self.cursor)
-        self.table_partition = QolsysTablePartition(self.db,self.cursor)
-        self.table_powerg_device = QolsysTablePowerGDevice(self.db,self.cursor)
-        self.table_sensor = QolsysTableSensor(self.db,self.cursor)
-        self.table_smartsocket = QolsysTableSmartSocket(self.db,self.cursor)
-        self.table_qolsyssettings = QolsysTableQolsysSettings(self.db,self.cursor)
-        self.table_scene = QolsysTableScene(self.db,self.cursor)
-        self.table_state = QolsysTableState(self.db,self.cursor)
-        self.table_tcc = QolsysTableTcc(self.db,self.cursor)
-        self.table_thermostat = QolsysTableThermostat(self.db,self.cursor)
-        self.table_trouble_conditions = QolsysTableTroubleConditions(self.db,self.cursor)
-        self.table_user = QolsysTableUser(self.db,self.cursor)
-        self.table_virtual_device = QolsysTableVirtualDevice(self.db,self.cursor)
-        self.table_weather = QolsysTableWeather(self.db,self.cursor)
-        self.table_zigbee_device = QolsysTableZigbeeDevice(self.db,self.cursor)
-        self.table_zwave_association_goup = QolsysTableZwaveAssociationGroup(self.db,self.cursor)
-        self.table_zwave_history = QolsysTableZwaveHistory(self.db,self.cursor)
-        self.table_zwave_node = QolsysTableZwaveNode(self.db,self.cursor)
-        self.table_zwave_other = QolsysTableZwaveOther(self.db,self.cursor)
+        self._db: sqlite3.Connection = sqlite3.connect(":memory:")
+        self._cursor: sqlite3.Cursor = self._db.cursor()
+
+        self.table_alarmedsensor = QolsysTableAlarmedSensor(self.db, self.cursor)
+        self.table_automation = QolsysTableAutomation(self.db, self.cursor)
+        self.table_country_locale = QolsysTableCountryLocale(self.db, self.cursor)
+        self.table_dashboard_msgs = QolsysTableDashboardMsgs(self.db, self.cursor)
+        self.table_dimmer = QolsysTableDimmerLight(self.db, self.cursor)
+        self.table_doorlock = QolsysTableDoorLock(self.db, self.cursor)
+        self.table_eu_event = QolsysTableEuEvent(self.db, self.cursor)
+        self.table_heat_map = QolsysTableHeatMap(self.db, self.cursor)
+        self.table_history = QolsysTableHistory(self.db, self.cursor)
+        self.table_iqremotesettings = QolsysTableIqRemoteSettings(self.db, self.cursor)
+        self.table_iqrouter_network_config = QolsysTableIqRouterNetworkConfig(self.db, self.cursor)
+        self.table_iqrouter_user_device = QolsysTableIqRouterUserDevice(self.db, self.cursor)
+        self.table_master_slave = QolsysTableMasterSlave(self.db, self.cursor)
+        self.table_partition = QolsysTablePartition(self.db, self.cursor)
+        self.table_powerg_device = QolsysTablePowerGDevice(self.db, self.cursor)
+        self.table_sensor = QolsysTableSensor(self.db, self.cursor)
+        self.table_smartsocket = QolsysTableSmartSocket(self.db, self.cursor)
+        self.table_qolsyssettings = QolsysTableQolsysSettings(self.db, self.cursor)
+        self.table_scene = QolsysTableScene(self.db, self.cursor)
+        self.table_state = QolsysTableState(self.db, self.cursor)
+        self.table_tcc = QolsysTableTcc(self.db, self.cursor)
+        self.table_thermostat = QolsysTableThermostat(self.db, self.cursor)
+        self.table_trouble_conditions = QolsysTableTroubleConditions(self.db, self.cursor)
+        self.table_user = QolsysTableUser(self.db, self.cursor)
+        self.table_virtual_device = QolsysTableVirtualDevice(self.db, self.cursor)
+        self.table_weather = QolsysTableWeather(self.db, self.cursor)
+        self.table_zigbee_device = QolsysTableZigbeeDevice(self.db, self.cursor)
+        self.table_zwave_association_goup = QolsysTableZwaveAssociationGroup(self.db, self.cursor)
+        self.table_zwave_history = QolsysTableZwaveHistory(self.db, self.cursor)
+        self.table_zwave_node = QolsysTableZwaveNode(self.db, self.cursor)
+        self.table_zwave_other = QolsysTableZwaveOther(self.db, self.cursor)
 
         self._table_array = []
         self._table_array.append(self.table_sensor)
@@ -143,108 +144,111 @@ class QolsysDB:
         return self._cursor
 
     def get_partitions(self) -> list[dict]:
-        self.cursor.execute(f"SELECT * FROM {self.table_partition.table} ORDER BY partition_id" )
+        self.cursor.execute(f"SELECT * FROM {self.table_partition.table} ORDER BY partition_id")
         self.db.commit()
 
         partitions = []
         columns = [description[0] for description in self.cursor.description]
-        for row in  self.cursor.fetchall():
+        for row in self.cursor.fetchall():
             row_dict = dict(zip(columns, row, strict=True))
             partitions.append(row_dict)
 
         return partitions
 
     def get_zwave_devices(self) -> list[dict]:
-        self.cursor.execute(f"SELECT * FROM {self.table_zwave_node.table} ORDER BY node_id" )
+        self.cursor.execute(f"SELECT * FROM {self.table_zwave_node.table} ORDER BY node_id")
         self.db.commit()
 
         devices = []
         columns = [description[0] for description in self.cursor.description]
-        for row in  self.cursor.fetchall():
+        for row in self.cursor.fetchall():
             row_dict = dict(zip(columns, row, strict=True))
             devices.append(row_dict)
 
         return devices
 
     def get_locks(self) -> list[dict]:
-        self.cursor.execute(f"SELECT * FROM {self.table_doorlock.table} ORDER BY node_id" )
+        self.cursor.execute(f"SELECT * FROM {self.table_doorlock.table} ORDER BY node_id")
         self.db.commit()
 
         locks = []
         columns = [description[0] for description in self.cursor.description]
-        for row in  self.cursor.fetchall():
+        for row in self.cursor.fetchall():
             row_dict = dict(zip(columns, row, strict=True))
             locks.append(row_dict)
 
         return locks
 
     def get_thermostats(self) -> list[dict]:
-        self.cursor.execute(f"SELECT * FROM {self.table_thermostat.table} ORDER BY node_id" )
+        self.cursor.execute(f"SELECT * FROM {self.table_thermostat.table} ORDER BY node_id")
         self.db.commit()
 
         thermostats = []
         columns = [description[0] for description in self.cursor.description]
-        for row in  self.cursor.fetchall():
+        for row in self.cursor.fetchall():
             row_dict = dict(zip(columns, row, strict=True))
             thermostats.append(row_dict)
 
         return thermostats
 
     def get_dimmers(self) -> list[dict]:
-        self.cursor.execute(f"SELECT * FROM {self.table_dimmer.table} ORDER BY node_id" )
+        self.cursor.execute(f"SELECT * FROM {self.table_dimmer.table} ORDER BY node_id")
         self.db.commit()
 
         dimmers = []
         columns = [description[0] for description in self.cursor.description]
-        for row in  self.cursor.fetchall():
+        for row in self.cursor.fetchall():
             row_dict = dict(zip(columns, row, strict=True))
             dimmers.append(row_dict)
 
         return dimmers
 
     def get_zones(self) -> list[dict]:
-        self.cursor.execute(f"SELECT * FROM {self.table_sensor.table} ORDER BY zoneid" )
+        self.cursor.execute(f"SELECT * FROM {self.table_sensor.table} ORDER BY zoneid")
         self.db.commit()
 
         zones = []
         columns = [description[0] for description in self.cursor.description]
-        for row in  self.cursor.fetchall():
+        for row in self.cursor.fetchall():
             row_dict = dict(zip(columns, row, strict=True))
             zones.append(row_dict)
 
         return zones
 
-    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"))
+    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"))
         row = self.cursor.fetchone()
 
         if row is None:
-            LOGGER.debug("%s value not found",setting)
+            LOGGER.debug("%s value not found", setting)
             return None
 
         return row[0]
 
-    def get_setting_partition(self,setting:str,partition_id:str) -> str | None:
-        self.cursor.execute(f"SELECT value FROM {self.table_qolsyssettings.table} WHERE name = ? and partition_id  = ? ", (setting,partition_id))
+    def get_setting_partition(self, setting: str, partition_id: str) -> str | None:
+        self.cursor.execute(f"""SELECT value FROM {self.table_qolsyssettings.table}
+                             WHERE name = ? and partition_id  = ? """, (setting, partition_id))
         row = self.cursor.fetchone()
 
         if row is None:
-            LOGGER.debug("%s value not found",setting)
+            LOGGER.debug("%s value not found", setting)
             return None
 
         return row[0]
 
-    def get_state_partition(self,state:str,partition_id:str) -> str | None:
-        self.cursor.execute(f"SELECT value FROM {self.table_state.table} WHERE name = ? and partition_id  = ? ", (state,partition_id))
+    def get_state_partition(self, state: str, partition_id: str) -> str | None:
+        self.cursor.execute(
+            f"""SELECT value FROM {self.table_state.table} WHERE name = ? and partition_id  = ? """, (state, partition_id))
         row = self.cursor.fetchone()
 
         if row is None:
-            LOGGER.debug("%s value not found",state)
+            LOGGER.debug("%s value not found", state)
             return None
 
         return row[0]
 
-    def get_alarm_type(self,partition_id:str) -> list[str]:
+    def get_alarm_type(self, partition_id: str) -> list[str]:
         alarm_type = []
         self.cursor.execute(f"SELECT sgroup FROM {self.table_alarmedsensor.table} WHERE partition_id  = ? ", (partition_id))
         rows = self.cursor.fetchall()
@@ -258,14 +262,14 @@ class QolsysDB:
         for table in self._table_array:
             table.clear()
 
-    def get_table(self,uri:str) -> QolsysTable | None:
+    def get_table(self, uri: str) -> QolsysTable | None:
         for table in self._table_array:
             if uri == table.uri:
                 return table
 
         return None
 
-    def load_db(self,database:dict) -> None:
+    def load_db(self, database: dict) -> None:
 
         self.clear_db()
 

{qolsys_controller-0.0.2 → qolsys_controller-0.0.4}/qolsys_controller/database/table.py

@@ -5,19 +5,21 @@ from qolsys_controller.errors import QolsysSqlError
 
 LOGGER = logging.getLogger(__name__)
 
+
 class QolsysTable:
 
-    def __init__(self,db:sqlite3.Connection,cursor:sqlite3.Cursor) -> None:
-        self._db:sqlite3.Connection = db
-        self._cursor:sqlite3.Cursor = cursor
-        self._uri:str = ""
-        self._table:str = ""
-        self._columns:list[str] = []
-        self._abort_on_error:bool = False
+    def __init__(self, db: sqlite3.Connection, cursor: sqlite3.Cursor) -> None:
+        self._db: sqlite3.Connection = db
+        self._cursor: sqlite3.Cursor = cursor
+        self._uri: str = ""
+        self._table: str = ""
+        self._columns: list[str] = []
+        self._abort_on_error: bool = False
 
     @property
     def uri(self) -> str:
         return self._uri
+
     @property
     def table(self) -> str:
         return self._table
@@ -62,21 +64,20 @@ class QolsysTable:
             })
 
             if self._abort_on_error:
-               raise error from err
+                raise error from err
 
-    def update(self,selection:str,selection_argument:str,content_value:str) -> None:
-        # selection: 'zone_id=?, parition_id=?'  # noqa: ERA001
-        # selection_argument: '[3,1]'  # noqa: ERA001
+    def update(self, selection: str, selection_argument: str, content_value: str) -> None:
+        # selection: 'zone_id=?, parition_id=?'
+        # selection_argument: '[3,1]'
         #  "contentValues":{"partition_id":"0","sensorgroup":"safetymotion","sensorstatus":"Idle"}"
 
         # Panel is sending query parameter for db update in text string
         # Have not found a way to make it work with parametrized query yet
         # Using f string concat for moment ...
 
-
         # New Values to update in table
-        # To change for parametrized 
-        db_value = ",".join([f"{key}='{value}'" for key,value in content_value.items()])
+        # To change for parametrized
+        db_value = ",".join([f"{key}='{value}'" for key, value in content_value.items()])
 
         # Selection Argument
         selection_argument = selection_argument.strip("[]")
@@ -84,7 +85,7 @@ class QolsysTable:
 
         try:
             query = f"UPDATE {self.table} SET {db_value} WHERE {selection}"
-            self._cursor.execute(query,selection_argument)
+            self._cursor.execute(query, selection_argument)
             self._db.commit()
 
         except sqlite3.Error as err:
@@ -98,25 +99,25 @@ class QolsysTable:
             })
 
             if self._abort_on_error:
-               raise error from err
+                raise error from err
 
     def insert(self) -> None:
         pass
 
-    def delete(self,selection:str,selection_argument:str) -> None:
-        # selection: 'zone_id=?, parition_id=?'  # noqa: ERA001
-        # selection_argument: '[3,1]'  # noqa: ERA001
+    def delete(self, selection: str, selection_argument: str) -> None:
+        # selection: 'zone_id=?, parition_id=?'
+        # selection_argument: '[3,1]'
 
         selection_argument = selection_argument.strip("[]")
         selection_argument = [item.strip() for item in selection_argument.split(",")]
 
         # Replace '?' in selection string with selection_argument
-        #for i in selection_argument:
-        #    selection = selection.replace("?",f"'{i}'",1)  # noqa: ERA001
+        # for i in selection_argument:
+        #    selection = selection.replace("?",f"'{i}'",1)
 
         try:
             query = f"DELETE FROM {self.table} WHERE {selection}"
-            self._cursor.execute(query,selection_argument)
+            self._cursor.execute(query, selection_argument)
             self._db.commit()
 
         except sqlite3.Error as err:
@@ -129,6 +130,4 @@ class QolsysTable:
             })
 
             if self._abort_on_error:
-               raise error from err
-
-
+                raise error from err