qolsys-controller 0.0.44__py3-none-any.whl → 0.0.87__py3-none-any.whl

qolsys_controller/database/db.py

@@ -1,5 +1,6 @@
 import logging  # noqa: INP001
 import sqlite3
+from typing import Any
 
 from .table import QolsysTable
 from .table_alarmedsensor import QolsysTableAlarmedSensor
@@ -23,6 +24,7 @@ from .table_powerg_device import QolsysTablePowerGDevice
 from .table_qolsyssettings import QolsysTableQolsysSettings
 from .table_scene import QolsysTableScene
 from .table_sensor import QolsysTableSensor
+from .table_sensor_group import QolsysTableSensorGroup
 from .table_shades import QolsysTableShades
 from .table_smartsocket import QolsysTableSmartSocket
 from .table_state import QolsysTableState
@@ -42,9 +44,7 @@ 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()
 
@@ -64,6 +64,7 @@ class QolsysDB:
         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_sensor_group = QolsysTableSensorGroup(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)
@@ -84,8 +85,9 @@ class QolsysDB:
         self.table_shades = QolsysTableShades(self.db, self.cursor)
         self.table_nest_device = QolsysTableNestDevice(self.db, self.cursor)
 
-        self._table_array = []
+        self._table_array: list[QolsysTable] = []
         self._table_array.append(self.table_sensor)
+        self._table_array.append(self.table_sensor_group)
         self._table_array.append(self.table_partition)
         self._table_array.append(self.table_qolsyssettings)
         self._table_array.append(self.table_alarmedsensor)
@@ -153,7 +155,43 @@ class QolsysDB:
     def cursor(self) -> sqlite3.Cursor:
         return self._cursor
 
-    def get_scenes(self) -> list[dict]:
+    def get_users(self) -> list[dict[str, str]]:
+        self.cursor.execute(f"SELECT * FROM {self.table_user.table} ORDER BY _id")
+        self.db.commit()
+
+        users = []
+        columns = [description[0] for description in self.cursor.description]
+        for row in self.cursor.fetchall():
+            row_dict = dict(zip(columns, row, strict=True))
+            users.append(row_dict)
+
+        return users
+
+    def get_master_slave(self) -> list[dict[str, str]]:
+        self.cursor.execute(f"SELECT * FROM {self.table_master_slave.table}")
+        self.db.commit()
+
+        masterslave = []
+        columns = [description[0] for description in self.cursor.description]
+        for row in self.cursor.fetchall():
+            row_dict = dict(zip(columns, row, strict=True))
+            masterslave.append(row_dict)
+
+        return masterslave
+
+    def get_iqremote_settings(self) -> list[dict[str, str]]:
+        self.cursor.execute(f"SELECT * FROM {self.table_iqremotesettings.table}")
+        self.db.commit()
+
+        iqremote_settings = []
+        columns = [description[0] for description in self.cursor.description]
+        for row in self.cursor.fetchall():
+            row_dict = dict(zip(columns, row, strict=True))
+            iqremote_settings.append(row_dict)
+
+        return iqremote_settings
+
+    def get_scenes(self) -> list[dict[str, str]]:
         self.cursor.execute(f"SELECT * FROM {self.table_scene.table} ORDER BY scene_id")
         self.db.commit()
 
@@ -165,7 +203,7 @@ class QolsysDB:
 
         return scenes
 
-    def get_partitions(self) -> list[dict]:
+    def get_partitions(self) -> list[dict[str, str]]:
         self.cursor.execute(f"SELECT * FROM {self.table_partition.table} ORDER BY partition_id")
         self.db.commit()
 
@@ -177,7 +215,19 @@ class QolsysDB:
 
         return partitions
 
-    def get_zwave_devices(self) -> list[dict]:
+    def get_adc_devices(self) -> list[dict[str, str]]:
+        self.cursor.execute(f"SELECT * FROM {self.table_virtual_device.table} ORDER BY device_id")
+        self.db.commit()
+
+        devices = []
+        columns = [description[0] for description in self.cursor.description]
+        for row in self.cursor.fetchall():
+            row_dict = dict(zip(columns, row, strict=True))
+            devices.append(row_dict)
+
+        return devices
+
+    def get_zwave_devices(self) -> list[dict[str, str]]:
         self.cursor.execute(f"SELECT * FROM {self.table_zwave_node.table} ORDER BY node_id")
         self.db.commit()
 
@@ -189,7 +239,19 @@ class QolsysDB:
 
         return devices
 
-    def get_locks(self) -> list[dict]:
+    def get_zwave_other_devices(self) -> list[dict[str, str]]:
+        self.cursor.execute(f"SELECT * FROM {self.table_zwave_other.table} ORDER BY node_id")
+        self.db.commit()
+
+        devices = []
+        columns = [description[0] for description in self.cursor.description]
+        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[str, str]]:
         self.cursor.execute(f"SELECT * FROM {self.table_doorlock.table} ORDER BY node_id")
         self.db.commit()
 
@@ -201,7 +263,7 @@ class QolsysDB:
 
         return locks
 
-    def get_thermostats(self) -> list[dict]:
+    def get_thermostats(self) -> list[dict[str, str]]:
         self.cursor.execute(f"SELECT * FROM {self.table_thermostat.table} ORDER BY node_id")
         self.db.commit()
 
@@ -213,7 +275,7 @@ class QolsysDB:
 
         return thermostats
 
-    def get_dimmers(self) -> list[dict]:
+    def get_dimmers(self) -> list[dict[str, str]]:
         self.cursor.execute(f"SELECT * FROM {self.table_dimmer.table} ORDER BY node_id")
         self.db.commit()
 
@@ -225,7 +287,7 @@ class QolsysDB:
 
         return dimmers
 
-    def get_zones(self) -> list[dict]:
+    def get_zones(self) -> list[dict[str, str]]:
         self.cursor.execute(f"SELECT * FROM {self.table_sensor.table} ORDER BY zoneid")
         self.db.commit()
 
@@ -237,9 +299,21 @@ class QolsysDB:
 
         return zones
 
-    def get_powerg(self, short_id: str) -> dict:
+    def get_weather(self) -> list[dict[str, str]]:
+        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[str, str] | None:
         try:
-            self.cursor.execute(f"SELECT * FROM {self.table_powerg_device.table} WHERE shortID = ?",(short_id,))
+            self.cursor.execute(f"SELECT * FROM {self.table_powerg_device.table} WHERE shortID = ?", (short_id,))
             self.db.commit()
 
             row = self.cursor.fetchone()
@@ -249,45 +323,51 @@ class QolsysDB:
                 return None
 
             columns = [description[0] for description in self.cursor.description]
-            return  dict(zip(columns, row, strict=True))
+            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"))
+        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)
-            return None
+            return ""
 
-        return row[0]
+        return str(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:
+        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)
-            return None
+            return ""
 
-        return row[0]
+        return str(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))
+            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)
             return None
 
-        return row[0]
+        return str(row[0])
 
     def get_alarm_type(self, partition_id: str) -> list[str]:
         alarm_type = []
@@ -310,8 +390,7 @@ class QolsysDB:
 
         return None
 
-    def load_db(self, database: dict) -> None:
-
+    def load_db(self, database: list[dict[str, Any]]) -> None:
         self.clear_db()
 
         if not database:
@@ -319,7 +398,7 @@ class QolsysDB:
             return
 
         for uri in database:
-            table = self.get_table(uri.get("uri"))
+            table = self.get_table(uri.get("uri", ""))
 
             if table is None:
                 LOGGER.error("Please Report")
@@ -327,5 +406,5 @@ class QolsysDB:
                 LOGGER.error(uri)
                 continue
 
-            for u in uri.get("resultSet"):
+            for u in uri.get("resultSet", ""):
                 table.insert(data=u)

qolsys_controller/database/table.py

@@ -7,7 +7,6 @@ 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
@@ -15,7 +14,7 @@ class QolsysTable:
         self._table: str = ""
         self._columns: list[str] = []
         self._abort_on_error: bool = False
-        self._implemented:bool = False
+        self._implemented: bool = False
 
     @property
     def uri(self) -> str:
@@ -37,16 +36,18 @@ class QolsysTable:
         column_defs += [f"{col} TEXT" for col in other_columns]
 
         try:
-            query = f"CREATE TABLE {self._table} ({', '.join(column_defs)})"
+            query: str = f"CREATE TABLE {self._table} ({', '.join(column_defs)})"
             self._cursor.execute(query)
             self._db.commit()
 
         except sqlite3.Error as err:
-            error = QolsysSqlError({
-                "table": self.table,
-                "query": query,
-                "columns": self._columns,
-            })
+            error = QolsysSqlError(
+                {
+                    "table": self.table,
+                    "query": query,
+                    "columns": self._columns,
+                }
+            )
 
             if self._abort_on_error:
                 raise error from err
@@ -58,16 +59,18 @@ class QolsysTable:
             self._db.commit()
 
         except sqlite3.Error as err:
-            error = QolsysSqlError({
-                "table": self.table,
-                "query": query,
-                "columns": self._columns,
-            })
+            error = QolsysSqlError(
+                {
+                    "table": self.table,
+                    "query": query,
+                    "columns": self._columns,
+                }
+            )
 
             if self._abort_on_error:
                 raise error from err
 
-    def insert(self, data: dict) -> None:
+    def insert(self, data: dict[str, str]) -> None:
         try:
             if not self._implemented and data is not None:
                 LOGGER.warning("New Table format: %s", self.uri)
@@ -76,6 +79,7 @@ class QolsysTable:
                 LOGGER.warning("Please Report")
                 return
 
+            # Select only known columns
             full_data = {col: data.get(col, "") for col in self._columns}
 
             new_columns = []
@@ -92,97 +96,123 @@ 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()
 
         except sqlite3.Error as err:
-            error = QolsysSqlError({
-                "table": self.table,
-                "query": query,
-                "columns": self._columns,
-            })
+            error = QolsysSqlError(
+                {
+                    "table": self.table,
+                    "query": query,
+                    "columns": self._columns,
+                }
+            )
 
             if self._abort_on_error:
                 raise error from err
 
-    def update(self, selection: str, selection_argument: str, content_value: str) -> None:
+    def update(
+        self, selection: str | None, selection_argument: list[str] | str | None, content_value: dict[str, str] | None
+    ) -> None:
         # selection: 'zone_id=?, parition_id=?'
-
-        # 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"}"
-
-
-        # Selection Argument
-        # Panel send selection_argument as list in Firmware 4.6.1
-        if(type(selection_argument) is not list):
-            #Firmware 4.4.1, seletion_argument is sent as a string
+        # Firmware 4.4.1: seletion_argument is sent as a string and needs to be converted to an array
+        if isinstance(selection_argument, str):
             selection_argument = selection_argument.strip("[]")
             selection_argument = [item.strip() for item in selection_argument.split(",")]
 
+        if selection_argument is None:
+            selection_argument = []
+
         try:
             full_data = {}
             new_columns = []
 
-            for key, value in content_value.items():
-                if key in self._columns:
-                    full_data[key] = value
-                else:
-                    new_columns.append(key)
-
-            db_value = ",".join([f"{key}='{value}'" for key, value in full_data.items()])
+            # Separate valid and unknown columns
+            if content_value is not None:
+                for key, value in content_value.items():
+                    if key in self._columns:
+                        full_data[key] = value
+                    else:
+                        new_columns.append(key)
 
-            # Warn if new column found in iq2meid database
+            # Warn for unknown columns
             if new_columns:
                 LOGGER.warning("New column found in iq2meid database")
                 LOGGER.warning("Table: %s", self.table)
                 LOGGER.warning("New Columns: %s", new_columns)
                 LOGGER.warning("Please Report")
 
-            query = f"UPDATE {self.table} SET {db_value} WHERE {selection}"
-            self._cursor.execute(query, selection_argument)
+            set_clause = ", ".join([f"{key} = ?" for key in full_data])
+            set_values = list(full_data.values())
+
+            if selection:
+                query = f"UPDATE {self.table} SET {set_clause} WHERE {selection}"
+                params = set_values + selection_argument
+            else:
+                query = f"UPDATE {self.table} SET {set_clause}"
+                params = set_values
+
+            self._cursor.execute(query, params)
             self._db.commit()
 
         except sqlite3.Error as err:
-            error = QolsysSqlError({
-                "table": self.table,
-                "query": query,
-                "columns": self._columns,
-                "content_value": content_value,
-                "selection": selection,
-                "selection_argument": selection_argument,
-            })
+            error = QolsysSqlError(
+                {
+                    "table": self.table,
+                    "query": query,
+                    "columns": self._columns,
+                    "content_value": content_value,
+                    "selection": selection,
+                    "selection_argument": selection_argument,
+                }
+            )
 
             if self._abort_on_error:
                 raise error from err
 
-    def delete(self, selection: str, selection_argument: str) -> None:
+    def delete(self, selection: str | None, selection_argument: list[str] | str | None) -> None:
         # selection: 'zone_id=?, parition_id=?'
         # Firmware 4.4.1: selection_argument: '[3,1]'
         # Firmware 4.6.1: selection_argument: ['3','1']
 
-        # Selection Argument
-        if(type(selection_argument) is not list):
-            #Firmware 4.4.1, seletion_argument is sent as a string
+        # Firmware 4.4.1: seletion_argument is sent as a string and needs to be converted to an array
+        if type(selection_argument) is str:
             selection_argument = selection_argument.strip("[]")
             selection_argument = [item.strip() for item in selection_argument.split(",")]
 
+        if selection_argument is None:
+            selection_argument = []
+
         try:
-            query = f"DELETE FROM {self.table} WHERE {selection}"
-            self._cursor.execute(query, selection_argument)
+            if selection:
+                query = f"DELETE FROM {self.table} WHERE {selection}"
+
+                if "?" in selection:
+                    # Query expects parameters → must pass the list
+                    self._cursor.execute(query, selection_argument)
+                else:
+                    # Query has no ? , do not pass arguments
+                    self._cursor.execute(query)
+            else:
+                self.clear()
+
             self._db.commit()
 
         except sqlite3.Error as err:
-            error = QolsysSqlError({
-                "table": self.table,
-                "query": query,
-                "columns": self._columns,
-                "selection": selection,
-                "selection_argument": selection_argument,
-            })
+            error = QolsysSqlError(
+                {
+                    "table": self.table,
+                    "query": query,
+                    "columns": self._columns,
+                    "selection": selection,
+                    "selection_argument": selection_argument,
+                }
+            )
 
             if self._abort_on_error:
                 raise error from err

qolsys_controller/database/table_alarmedsensor.py

@@ -7,7 +7,6 @@ LOGGER = logging.getLogger(__name__)
 
 
 class QolsysTableAlarmedSensor(QolsysTable):
-
     def __init__(self, db: sqlite3.Connection, cursor: sqlite3.Cursor) -> None:
         super().__init__(db, cursor)
         self._uri = "content://com.qolsys.qolsysprovider.AlarmedSensorProvider/alarmedsensor"
@@ -15,7 +14,6 @@ class QolsysTableAlarmedSensor(QolsysTable):
         self._abort_on_error = True
         self._implemented = True
 
-
         self._columns = [
             "_id",
             "partition_id",
@@ -28,6 +26,8 @@ class QolsysTableAlarmedSensor(QolsysTable):
             "priority",
             "aseb_type",
             "alarm_time",
+            "version",
+            "opr",
         ]
 
         self._create_table()

qolsys_controller/database/table_automation.py

@@ -7,7 +7,6 @@ LOGGER = logging.getLogger(__name__)
 
 
 class QolsysTableAutomation(QolsysTable):
-
     def __init__(self, db: sqlite3.Connection, cursor: sqlite3.Cursor) -> None:
         super().__init__(db, cursor)
         self._uri = "content://com.qolsys.qolsysprovider.AutomationDeviceContentProvider/automation"

qolsys_controller/database/table_country_locale.py

@@ -7,7 +7,6 @@ LOGGER = logging.getLogger(__name__)
 
 
 class QolsysTableCountryLocale(QolsysTable):
-
     def __init__(self, db: sqlite3.Connection, cursor: sqlite3.Cursor) -> None:
         super().__init__(db, cursor)
         self._uri = "content://com.qolsys.qolsysprovider.CountryLocaleContentProvider/country_locale"

qolsys_controller/database/table_dashboard_msgs.py

@@ -7,7 +7,6 @@ LOGGER = logging.getLogger(__name__)
 
 
 class QolsysTableDashboardMsgs(QolsysTable):
-
     def __init__(self, db: sqlite3.Connection, cursor: sqlite3.Cursor) -> None:
         super().__init__(db, cursor)
         self._uri = "content://com.qolsys.qolsysprovider.DashboardMessagesContentProvider/dashboard_msgs"
@@ -15,7 +14,6 @@ class QolsysTableDashboardMsgs(QolsysTable):
         self._abort_on_error = False
         self._implemented = True
 
-
         self._columns = [
             "_id",
             "version",
@@ -29,6 +27,7 @@ class QolsysTableDashboardMsgs(QolsysTable):
             "end_time",
             "read",
             "mime_type",
+            "type",
         ]
 
         self._create_table()

qolsys_controller/database/table_dimmerlight.py

@@ -7,7 +7,6 @@ LOGGER = logging.getLogger(__name__)
 
 
 class QolsysTableDimmerLight(QolsysTable):
-
     def __init__(self, db: sqlite3.Connection, cursor: sqlite3.Cursor) -> None:
         super().__init__(db, cursor)
         self._uri = "content://com.qolsys.qolsysprovider.DimmerLightsContentProvider/dimmerlight"

qolsys_controller/database/table_doorlock.py

@@ -7,7 +7,6 @@ LOGGER = logging.getLogger(__name__)
 
 
 class QolsysTableDoorLock(QolsysTable):
-
     def __init__(self, db: sqlite3.Connection, cursor: sqlite3.Cursor) -> None:
         super().__init__(db, cursor)
         self._uri = "content://com.qolsys.qolsysprovider.DoorLocksContentProvider/doorlock"

qolsys_controller/database/table_eu_event.py

@@ -7,7 +7,6 @@ LOGGER = logging.getLogger(__name__)
 
 
 class QolsysTableEuEvent(QolsysTable):
-
     def __init__(self, db: sqlite3.Connection, cursor: sqlite3.Cursor) -> None:
         super().__init__(db, cursor)
         self._uri = "content://com.qolsys.qolsysprovider.EUEventContentProvider/eu_event"
@@ -15,7 +14,6 @@ class QolsysTableEuEvent(QolsysTable):
         self._abort_on_error = False
         self._implemented = True
 
-
         self._columns = [
             "_id",
             "version",
@@ -28,6 +26,7 @@ class QolsysTableEuEvent(QolsysTable):
             "time",
             "ack",
             "type",
+            "feature2",
         ]
 
         self._create_table()

qolsys_controller/database/table_heat_map.py

@@ -7,7 +7,6 @@ LOGGER = logging.getLogger(__name__)
 
 
 class QolsysTableHeatMap(QolsysTable):
-
     def __init__(self, db: sqlite3.Connection, cursor: sqlite3.Cursor) -> None:
         super().__init__(db, cursor)
         self._uri = "content://com.qolsys.qolsysprovider.HeatMapContentProvider/heat_map"
@@ -28,4 +27,3 @@ class QolsysTableHeatMap(QolsysTable):
         ]
 
         self._create_table()
-

qolsys_controller/database/table_history.py

@@ -7,7 +7,6 @@ LOGGER = logging.getLogger(__name__)
 
 
 class QolsysTableHistory(QolsysTable):
-
     def __init__(self, db: sqlite3.Connection, cursor: sqlite3.Cursor) -> None:
         super().__init__(db, cursor)
         self._uri = "content://com.qolsys.qolsysprovider.HistoryContentProvider/history"
@@ -28,6 +27,10 @@ class QolsysTableHistory(QolsysTable):
             "feature1",
             "feature2",
             "device_id",
+            # "history_bulk_insert",
+            "Partition",
+            # "History_Device_Names_List",
+            # "History Bypass Event",
         ]
 
         self._create_table()

qolsys_controller/database/table_iqremotesettings.py

@@ -7,7 +7,6 @@ LOGGER = logging.getLogger(__name__)
 
 
 class QolsysTableIqRemoteSettings(QolsysTable):
-
     def __init__(self, db: sqlite3.Connection, cursor: sqlite3.Cursor) -> None:
         super().__init__(db, cursor)
         self._uri = "content://com.qolsys.qolsysprovider.IQRemoteSettingsContentProvider/iqremotesettings"
@@ -27,4 +26,3 @@ class QolsysTableIqRemoteSettings(QolsysTable):
         ]
 
         self._create_table()
-