qolsys-controller 0.0.38__py3-none-any.whl → 0.0.62__py3-none-any.whl

qolsys_controller/scene.py

@@ -6,36 +6,46 @@ LOGGER = logging.getLogger(__name__)
 
 
 class QolsysScene(QolsysObservable):
-
-    def __init__(self, data: dict) -> None:
+    def __init__(self, data: dict[str, str]) -> None:
         super().__init__()
 
-        self._scene_id = data.get("scene_id", "")
-        self._name = data.get("name", "")
-        self._icon = data.get("icon", "")
-        self._color = data.get("color", "")
-
-    def update(self, data: dict) -> None:
+        self._scene_id: str = data.get("scene_id", "")
+        self._name: str = data.get("name", "")
+        self._icon: str = data.get("icon", "")
+        self._color: str = data.get("color", "")
 
+    def update(self, data: dict[str, str]) -> None:
         scene_id_update = data.get("scene_id", "")
         if scene_id_update != self._scene_id:
-            LOGGER.error("Updating Scene%s (%s) with Scene%s (different id)", self._scene_id, self.sensorname, scene_id_update)
+            LOGGER.error("Updating Scene%s (%s) with Scene%s (different id)", self._scene_id, self.name, scene_id_update)
             return
 
         self.start_batch_update()
 
         # Update name
         if "name" in data:
-            self.sensorname = data.get("name")
+            self.sensorname = data.get("name", "")
 
         if "color" in data:
-            self.color = data.get("color")
+            self.color = data.get("color", "")
 
         if "icon" in data:
-            self.icon = data.get("icon")
+            self.icon = data.get("icon", "")
 
         self.end_batch_update()
 
+    def to_dict(self) -> dict[str, str]:
+        return {
+            "scene_id": self.scene_id,
+            "name": self.name,
+            "color": self.color,
+            "icon": self.icon,
+        }
+
+    # -----------------------------
+    # properties + setters
+    # -----------------------------
+
     @property
     def scene_id(self) -> str:
         return self._scene_id
@@ -44,36 +54,28 @@ class QolsysScene(QolsysObservable):
     def name(self) -> str:
         return self._name
 
-    @property
-    def icon(self) -> str:
-        return self._icon
-
-    @property
-    def color(self) -> str:
-        return self._color
-
     @name.setter
     def name(self, value: str) -> None:
         if self._name != value:
             self._name = value
             self.notify()
 
+    @property
+    def icon(self) -> str:
+        return self._icon
+
     @icon.setter
     def icon(self, value: str) -> None:
         if self._icon != value:
             self._icon = value
             self.notify()
 
+    @property
+    def color(self) -> str:
+        return self._color
+
     @color.setter
     def color(self, value: str) -> None:
         if self._color != value:
             self._color = value
             self.notify()
-
-    def to_dict(self) -> dict:
-        return {
-            "scene_id": self.scene_id,
-            "name": self.name,
-            "color": self.color,
-            "icon": self.icon,
-        }

qolsys_controller/settings.py

@@ -1,18 +1,24 @@
+from __future__ import annotations
+
 import logging
 from pathlib import Path
+from typing import TYPE_CHECKING
 
 LOGGER = logging.getLogger(__name__)
 
+if TYPE_CHECKING:
+    from .controller import QolsysController
 
-class QolsysSettings:
 
-    def __init__(self) -> None:
+class QolsysSettings:
+    def __init__(self, controller: QolsysController) -> None:
+        self._controller = controller
 
         # Plugin
-        self._plugin_ip = ""
-        self._random_mac = ""
-        self._panel_mac = ""
-        self._panel_ip = ""
+        self._plugin_ip: str = ""
+        self._random_mac: str = ""
+        self._panel_mac: str = ""
+        self._panel_ip: str = ""
 
         # Path
         self._config_directory: Path = Path()
@@ -22,16 +28,40 @@ class QolsysSettings:
 
         # Pki
         self._key_size: int = 2048
+        self._auto_discover_pki: bool = True
 
         # MQTT
         self._mqtt_timeout: int = 30
         self._mqtt_ping: int = 600
-        self._mqtt_qos:int = 0
-        self._mqtt_remote_client_id = ""
+        self._mqtt_qos: int = 0
+        self._mqtt_remote_client_id: str = ""
+        self._log_mqtt_message: bool = False
 
         # Operation
-        self._motion_sensor_delay:bool = True
-        self._motion_sensor_delay_sec:int = 310
+        self._motion_sensor_delay: bool = True
+        self._motion_sensor_delay_sec: int = 310
+        self._check_user_code_on_arm: bool = False
+        self._check_user_code_on_disarm: bool = True
+
+    def check_panel_ip(self) -> bool:
+        if self._panel_ip == "":
+            LOGGER.debug("Invalid Panel IP:  %s", self._panel_ip)
+            return False
+
+        LOGGER.debug("Found Panel IP: %s", self._panel_ip)
+        return True
+
+    def check_plugin_ip(self) -> bool:
+        if self._plugin_ip == "":
+            LOGGER.debug("Invalid Plugin IP:  %s", self._plugin_ip)
+            return False
+
+        LOGGER.debug("Found Plugin IP: %s", self._plugin_ip)
+        return True
+
+    # -----------------------------
+    # properties + setters
+    # -----------------------------
 
     @property
     def random_mac(self) -> str:
@@ -45,6 +75,10 @@ class QolsysSettings:
     def plugin_ip(self) -> str:
         return self._plugin_ip
 
+    @plugin_ip.setter
+    def plugin_ip(self, plugin_ip: str) -> None:
+        self._plugin_ip = plugin_ip
+
     @property
     def panel_mac(self) -> str:
         return self._panel_mac
@@ -57,36 +91,76 @@ class QolsysSettings:
     def panel_ip(self) -> str:
         return self._panel_ip
 
+    @panel_ip.setter
+    def panel_ip(self, panel_ip: str) -> None:
+        self._panel_ip = panel_ip
+
+    @property
+    def log_mqtt_mesages(self) -> bool:
+        return self._log_mqtt_messages
+
+    @log_mqtt_mesages.setter
+    def log_mqtt_mesages(self, log_mqtt_mesages: bool) -> None:
+        self._log_mqtt_messages = log_mqtt_mesages
+
+    @property
+    def check_user_code_on_disarm(self) -> bool:
+        return self._check_user_code_on_disarm
+
+    @check_user_code_on_disarm.setter
+    def check_user_code_on_disarm(self, check_user_code_on_disarm: bool) -> None:
+        self._check_user_code_on_disarm = check_user_code_on_disarm
+
+    @property
+    def check_user_code_on_arm(self) -> bool:
+        return self._check_user_code_on_arm
+
+    @check_user_code_on_arm.setter
+    def check_user_code_on_arm(self, check_user_code_on_arm: bool) -> None:
+        self._check_user_code_on_arm = check_user_code_on_arm
+
+    @property
+    def auto_discover_pki(self) -> bool:
+        return self._auto_discover_pki
+
+    @auto_discover_pki.setter
+    def auto_discover_pki(self, value: bool) -> None:
+        self._auto_discover_pki = value
+
     @property
     def mqtt_timeout(self) -> int:
         return self._mqtt_timeout
 
+    @mqtt_timeout.setter
+    def mqtt_timeout(self, value: int) -> None:
+        self._mqtt_timeout = value
+
     @property
     def mqtt_ping(self) -> int:
         return self._mqtt_ping
 
+    @mqtt_ping.setter
+    def mqtt_ping(self, value: int) -> None:
+        self._mqtt_ping = value
+
     @property
     def motion_sensor_delay(self) -> bool:
         return self._motion_sensor_delay
 
-    @property
-    def motion_sensor_delay_sec(self) -> int:
-        return self._motion_sensor_delay_sec
-
     @motion_sensor_delay.setter
     def motion_sensor_delay(self, value: bool) -> None:
         self._motion_sensor_delay = value
 
-    @panel_ip.setter
-    def panel_ip(self, panel_ip: str) -> None:
-        self._panel_ip = panel_ip
+    @property
+    def motion_sensor_delay_sec(self) -> int:
+        return self._motion_sensor_delay_sec
 
-    @plugin_ip.setter
-    def plugin_ip(self, plugin_ip: str) -> None:
-        self._plugin_ip = plugin_ip
+    @motion_sensor_delay_sec.setter
+    def motion_sensor_delay_sec(self, value: int) -> None:
+        self._motion_sensor_delay_sec = value
 
     @property
-    def config_directory(self) -> str:
+    def config_directory(self) -> Path:
         return self._config_directory
 
     @config_directory.setter
@@ -108,18 +182,6 @@ class QolsysSettings:
     def key_size(self) -> int:
         return self._key_size
 
-    @mqtt_timeout.setter
-    def mqtt_timeout(self, value: int) -> None:
-        self._mqtt_timeout = value
-
-    @mqtt_ping.setter
-    def mqtt_ping(self, value: int) -> None:
-        self._mqtt_ping = value
-
-    @mqtt_ping.setter
-    def mqtt_ping(self, ping:int) -> None:
-        self._mqtt_ping = ping
-
     @property
     def mqtt_qos(self) -> int:
         return self._mqtt_qos
@@ -129,25 +191,9 @@ class QolsysSettings:
         return self._mqtt_remote_client_id
 
     @mqtt_remote_client_id.setter
-    def mqtt_remote_client_id(self,client_id:str) -> None:
+    def mqtt_remote_client_id(self, client_id: str) -> None:
         self._mqtt_remote_client_id = client_id
 
-    def check_panel_ip(self) -> bool:
-        if self._panel_ip == "":
-            LOGGER.debug("Invalid Panel IP:  %s", self._panel_ip)
-            return False
-
-        LOGGER.debug("Found Panel IP: %s", self._panel_ip)
-        return True
-
-    def check_plugin_ip(self) -> bool:
-        if self._plugin_ip == "":
-            LOGGER.debug("Invalid Plugin IP:  %s", self._plugin_ip)
-            return False
-
-        LOGGER.debug("Found Plugin IP: %s", self._plugin_ip)
-        return True
-
     def check_config_directory(self, create: bool = True) -> bool:  # noqa: PLR0911
         if not self.config_directory.is_dir():
             if not create:

qolsys_controller/state.py

@@ -1,9 +1,10 @@
+from __future__ import annotations
+
 import logging
+from typing import TYPE_CHECKING
 
 from .observable import QolsysObservable
-from .partition import QolsysPartition
-from .scene import QolsysScene
-from .zone import QolsysZone
+from .weather import QolsysWeather
 from .zwave_device import QolsysZWaveDevice
 from .zwave_dimmer import QolsysDimmer
 from .zwave_generic import QolsysGeneric
@@ -12,17 +13,23 @@ from .zwave_thermostat import QolsysThermostat
 
 LOGGER = logging.getLogger(__name__)
 
+if TYPE_CHECKING:
+    from .controller import QolsysController
+    from .partition import QolsysPartition
+    from .scene import QolsysScene
+    from .zone import QolsysZone
+    from .zwave_device import QolsysZWaveDevice
 
-class QolsysState(QolsysObservable):
 
-    def __init__(self) -> None:
+class QolsysState(QolsysObservable):
+    def __init__(self, controller: QolsysController) -> None:
         super().__init__()
-
-        self._partitions = []
-        self._zones = []
-        self._zwave_devices = []
-        self._scenes = []
-
+        self._controller: QolsysController = controller
+        self._weather: QolsysWeather = QolsysWeather()
+        self._partitions: list[QolsysPartition] = []
+        self._zones: list[QolsysZone] = []
+        self._zwave_devices: list[QolsysZWaveDevice] = []
+        self._scenes: list[QolsysScene] = []
         self._state_partition_observer = QolsysObservable()
         self._state_zone_observer = QolsysObservable()
         self._state_zwave_observer = QolsysObservable()
@@ -44,6 +51,10 @@ class QolsysState(QolsysObservable):
     def scenes(self) -> list[QolsysScene]:
         return self._scenes
 
+    @property
+    def weather(self) -> QolsysWeather:
+        return self._weather
+
     @property
     def zwave_dimmers(self) -> list[QolsysDimmer]:
         dimmers = []
@@ -87,7 +98,7 @@ class QolsysState(QolsysObservable):
     def state_scene_observer(self) -> QolsysObservable:
         return self._state_scene_observer
 
-    def partition(self, partition_id: str) -> QolsysPartition:
+    def partition(self, partition_id: str) -> QolsysPartition | None:
         for partition in self.partitions:
             if partition.id == partition_id:
                 return partition
@@ -97,8 +108,11 @@ class QolsysState(QolsysObservable):
     def partition_add(self, new_partition: QolsysPartition) -> None:
         for partition in self.partitions:
             if new_partition.id == partition.id:
-                LOGGER.debug("Adding Partition to State, Partition%s (%s) - Allready in Partitions List",
-                             new_partition.id, partition.name)
+                LOGGER.debug(
+                    "Adding Partition to State, Partition%s (%s) - Allready in Partitions List",
+                    new_partition.id,
+                    partition.name,
+                )
                 return
 
         self.partitions.append(new_partition)
@@ -115,7 +129,7 @@ class QolsysState(QolsysObservable):
         self.partitions.remove(partition)
         self.state_partition_observer.notify()
 
-    def scene(self, scene_id: str) -> QolsysScene:
+    def scene(self, scene_id: str) -> QolsysScene | None:
         for scene in self.scenes:
             if scene.scene_id == scene_id:
                 return scene
@@ -125,7 +139,7 @@ class QolsysState(QolsysObservable):
     def scene_add(self, new_scene: QolsysScene) -> None:
         for scene in self.scenes:
             if new_scene.scene_id == scene.scene_id:
-                LOGGER.debug("Adding Scene to State, Scene%s (%s) - Allready in Scene List", new_scene.scene_id, scene.name )
+                LOGGER.debug("Adding Scene to State, Scene%s (%s) - Allready in Scene List", new_scene.scene_id, scene.name)
                 return
 
         self.scenes.append(new_scene)
@@ -143,16 +157,24 @@ class QolsysState(QolsysObservable):
         self.scenes.remove(scene)
         self.state_scene_observer.notify()
 
-    def zone(self, zone_id: str) -> QolsysZone:
+    def zone(self, zone_id: str) -> QolsysZone | None:
         for zone in self.zones:
             if zone.zone_id == zone_id:
                 return zone
         return None
 
+    def zone_from_short_id(self, short_id: int) -> QolsysZone | None:
+        for zone in self.zones:
+            if zone.shortID == str(short_id):
+                return zone
+        return None
+
     def zone_add(self, new_zone: QolsysZone) -> None:
         for zone in self.zones:
             if new_zone.zone_id == zone.zone_id:
-                LOGGER.debug("Adding Zone to State, zone%s (%s) - Allready in Zone List", new_zone.zone_id, self.sensorname)
+                LOGGER.debug(
+                    "Adding Zone to State, zone%s (%s) - Allready in Zone List", new_zone.zone_id, new_zone.sensorname
+                )
                 return
 
         self.zones.append(new_zone)
@@ -169,7 +191,7 @@ class QolsysState(QolsysObservable):
         self.zones.remove(zone)
         self.state_zone_observer.notify()
 
-    def zwave_device(self, node_id: str) -> QolsysZWaveDevice:
+    def zwave_device(self, node_id: str) -> QolsysZWaveDevice | None:
         for zwave_device in self.zwave_devices:
             if zwave_device.node_id == node_id:
                 return zwave_device
@@ -179,8 +201,9 @@ class QolsysState(QolsysObservable):
     def zwave_add(self, new_zwave: QolsysZWaveDevice) -> None:
         for zwave_device in self.zwave_devices:
             if new_zwave.node_id == zwave_device.node_id:
-                LOGGER.debug("Adding ZWave to State, ZWave%s (%s) - Allready in ZWave List",
-                             new_zwave.node_id, zwave_device.node_name)
+                LOGGER.debug(
+                    "Adding ZWave to State, ZWave%s (%s) - Allready in ZWave List", new_zwave.node_id, zwave_device.node_name
+                )
                 return
 
         self.zwave_devices.append(new_zwave)
@@ -198,7 +221,6 @@ class QolsysState(QolsysObservable):
         self.state_zwave_observer.notify()
 
     def sync_zwave_devices_data(self, db_zwaves: list[QolsysZWaveDevice]) -> None:  # noqa: PLR0912
-
         db_zwave_list = []
         for db_zwave in db_zwaves:
             db_zwave_list.append(db_zwave.node_id)
@@ -223,13 +245,13 @@ class QolsysState(QolsysObservable):
                         # Update Thermostat
                         if isinstance(state_zwave, QolsysThermostat) and isinstance(db_zwave, QolsysThermostat):
                             state_zwave.update_base(db_zwave.to_dict_base())
-                            state_zwave.update_thermostat(db_zwave.to_dict_thermostat)
+                            state_zwave.update_thermostat(db_zwave.to_dict_thermostat())
                             break
 
                         # Update Lock
                         if isinstance(state_zwave, QolsysLock) and isinstance(db_zwave, QolsysLock):
                             state_zwave.update_base(db_zwave.to_dict_base())
-                            state_zwave.update_lock(db_zwave.to_dict_lock)
+                            state_zwave.update_lock(db_zwave.to_dict_lock())
                             break
 
                         # Generic Z-Wave Device
@@ -237,10 +259,6 @@ class QolsysState(QolsysObservable):
                             state_zwave.update_base(db_zwave.to_dict_base())
                             break
 
-                        # zwave node_id has changed of node_type, delete and add again
-                        # self.zwave_delete(int(state_zwave.node_id))
-                        # self.zwave_add(db_zwave)
-
         # Add new zwave device
         for db_zwave in db_zwaves:
             if db_zwave.node_id not in state_zwave_list:
@@ -250,9 +268,13 @@ class QolsysState(QolsysObservable):
         # Delete zwave device
         for state_zwave in self.zwave_devices:
             if state_zwave.node_id not in db_zwave_list:
-                LOGGER.debug("sync_data - delete ZWave%s", state_zwave.none_id)
+                LOGGER.debug("sync_data - delete ZWave%s", state_zwave.node_id)
                 self.zwave_delete(state_zwave.node_id)
 
+    def sync_weather_data(self, db_weather: QolsysWeather) -> None:
+        LOGGER.debug("sync_data - update Weather")
+        self._weather.update(db_weather.forecasts)
+
     def sync_scenes_data(self, db_scenes: list[QolsysScene]) -> None:
         db_scene_list = []
         for db_scene in db_scenes:
@@ -299,6 +321,7 @@ class QolsysState(QolsysObservable):
                     if state_zone.zone_id == db_zone.zone_id:
                         LOGGER.debug("sync_data - update Zone%s", state_zone.zone_id)
                         state_zone.update(db_zone.to_dict())
+                        state_zone.update_powerg(db_zone.to_powerg_dict())
 
         # Delete zones
         for state_zone in self.zones:
@@ -344,8 +367,8 @@ class QolsysState(QolsysObservable):
                 LOGGER.debug("sync_data - Add Partition%s", db_partition.id)
                 self.partition_add(db_partition)
 
-    def dump(self) -> None:  # noqa: PLR0915
-        LOGGER.debug("*** Information ***")
+    def dump(self) -> None:  # noqa: PLR0912, PLR0915
+        LOGGER.debug("*** Device Information ***")
 
         for partition in self.partitions:
             pid = partition.id
@@ -371,6 +394,12 @@ class QolsysState(QolsysObservable):
             LOGGER.debug("Zone%s (%s) - latestdBm: %s", zid, name, zone.latestdBm)
             LOGGER.debug("Zone%s (%s) - averagedBm: %s", zid, name, zone.averagedBm)
 
+            if zone.is_powerg_temperature_enabled():
+                LOGGER.debug("Zone%s (%s) - powerg_temperature: %s", zid, name, zone.powerg_temperature)
+
+            if zone.is_powerg_light_enabled():
+                LOGGER.debug("Zone%s (%s) - powerg_light: %s", zid, name, zone.powerg_light)
+
         for zwave in self.zwave_devices:
             if isinstance(zwave, QolsysDimmer):
                 nid = zwave.node_id
@@ -398,7 +427,7 @@ class QolsysState(QolsysObservable):
             if isinstance(zwave, QolsysLock):
                 zid = zwave.lock_node_id
                 name = zwave.lock_name
-                LOGGER.debug("Lock%s (%s) - current_temp: %s", zid, name, zwave.lock_status)
+                LOGGER.debug("Lock%s (%s) - lock_status: %s", zid, name, zwave.lock_status)
                 continue
 
             if isinstance(zwave, QolsysGeneric):
@@ -413,4 +442,13 @@ class QolsysState(QolsysObservable):
         for scene in self.scenes:
             sid = scene.scene_id
             name = scene.name
-            LOGGER.debug("Scene%s (%s)",sid, name)
+            LOGGER.debug("Scene%s (%s)", sid, name)
+
+        for forecast in self.weather.forecasts:
+            LOGGER.debug(
+                "Weather - %s - High: %s, Low:%s, Condition: %s",
+                forecast.day_of_week[0:3],
+                forecast.high_temp,
+                forecast.low_temp,
+                forecast.condition,
+            )

qolsys_controller/task_manager.py

@@ -7,32 +7,31 @@ LOGGER = logging.getLogger(__name__)
 
 class QolsysTaskManager:
     def __init__(self) -> None:
-        self._tasks = set()
+        self._tasks: set[asyncio.Task] = set()  # type: ignore[type-arg]
 
-    def run(self, coro: Coroutine, label: str) -> asyncio.Task:
+    def run(self, coro: Coroutine, label: str) -> asyncio.Task:  # type: ignore[type-arg]
         task = asyncio.create_task(coro, name=label)
         self._tasks.add(task)
 
-        def _done_callback(task: asyncio.Task) -> None:
-
+        def _done_callback(task: asyncio.Task) -> None:  # type: ignore[type-arg]
             try:
                 task.result()
 
             except asyncio.CancelledError:
-                LOGGER.debug("Task Cancelled: %s",task.get_name())
+                LOGGER.debug("Task Cancelled: %s", task.get_name())
 
             except Exception as e:  # noqa: BLE001
-                LOGGER.debug("[Callback] Task failed with: %s",e)
+                LOGGER.debug("[Callback] Task failed with: %s", e)
 
             self._tasks.discard(task)
 
         task.add_done_callback(_done_callback)
         return task
 
-    def get_task(self, label:str) -> asyncio.Task | None:
+    def get_task(self, label: str) -> asyncio.Task | None:  # type: ignore[type-arg]
         for task in self._tasks:
-             if task.get_name() == label:
-                 return task
+            if task.get_name() == label:
+                return task
         return None
 
     def cancel(self, label: str) -> None:
@@ -49,9 +48,6 @@ class QolsysTaskManager:
         if self._tasks:
             await asyncio.gather(*self._tasks, return_exceptions=True)
 
-    def pending(self) -> None:
-        return {t for t in self._tasks if not t.done()}
-
     def dump(self) -> None:
         for task in self._tasks:
             LOGGER.debug("Task: %s, Done: %s, Cancelled: %s", task.get_name(), task.done(), task.cancelled())

qolsys_controller/users.py

@@ -0,0 +1,25 @@
+import logging
+
+LOGGER = logging.getLogger(__name__)
+
+
+class QolsysUser:
+    def __init__(self) -> None:
+        self._id: int = 0
+        self._user_code = ""
+
+    @property
+    def id(self) -> int:
+        return self._id
+
+    @id.setter
+    def id(self, value: int) -> None:
+        self._id = value
+
+    @property
+    def user_code(self) -> str:
+        return self._user_code
+
+    @user_code.setter
+    def user_code(self, value: str) -> None:
+        self._user_code = value

qolsys_controller/utils_mqtt.py

@@ -1,24 +1,16 @@
 import logging
 import random
-import re
 
 LOGGER = logging.getLogger(__name__)
 
 
-def fix_json_string(json_string):
-    def replace_escape(match):
-        hex_value = match.group(1)
-        decimal_value = int(hex_value, 16)
-        return f"\\u{decimal_value:04x}"
-
-    return re.sub(r"\\x([0-9a-fA-F]{2})", replace_escape, json_string)
-
-
-def generate_random_mac() -> str:
+def generate_random_mac() -> str:  # noqa: D103
     mac = [
-        0xf2, 0x16, 0x3e,
-        random.randint(0x00, 0x7f),
-        random.randint(0x00, 0xff),
-        random.randint(0x00, 0xff),
+        0xF2,
+        0x16,
+        0x3E,
+        random.randint(0x00, 0x7F),
+        random.randint(0x00, 0xFF),
+        random.randint(0x00, 0xFF),
     ]
-    return ":".join(map(lambda x: "%02x" % x, mac))
+    return ":".join(map(lambda x: "%02x" % x, mac))  # noqa: C417, UP031