qolsys-controller 0.0.56__tar.gz → 0.2.9__tar.gz

qolsys_controller-0.2.9/.github/workflows/build.yml

@@ -0,0 +1,30 @@
+name: Build
+
+on:
+  push:
+  pull_request:
+
+jobs:
+  lint_and_typecheck:
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+
+      - name: Install dependencies
+        run: |
+          pip install -r requirements.txt
+          pip install ruff mypy
+
+      - name: Ruff lint
+        run: ruff check .
+
+      - name: Ruff format check
+        run: ruff format --check .
+
+      - name: Mypy type checking
+        run: mypy .

{qolsys_controller-0.0.56 → qolsys_controller-0.2.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: qolsys-controller
-Version: 0.0.56
+Version: 0.2.9
 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
@@ -40,7 +40,6 @@ A Python module that emulates a virtual IQ Remote device, enabling full **local
 |                        | Home Silent Disarming (Firmware 4.6.1)| ✅     |
 |                        | Set Exit Sounds                      | ✅     |
 |                        | Set Entry Delay                      | ✅            |
-|                        | Disarm Photos                        | 🛠️     |
 |                        | TTS                                  | 🛠️     |
 | **Zones**              | Sensor Status                        | ✅     |
 |                        | Tamper State                         | ✅     |
@@ -52,7 +51,8 @@ A Python module that emulates a virtual IQ Remote device, enabling full **local
 | **Z-Wave Devices**     | Battery Level                        | ✅     |
 |                        | Node Status                          | ✅     |
 |                        | Control Generic Devices              | TBD    |
-| **Z-Wave Dimmers**     | Light Status and Level Control       | ✅     |
+| **Z-Wave Dimmers**     | Binary Switch                        | ✅     |
+|                        | Multi Level Dimmer                   | ✅     |
 | **Z-Wave Door Locks**  | Lock, Unlock                         | ✅     |
 | **Z-Wave Thermostats** | Read device status                   | ✅     |
 |                        | Write device status                  | ✅     |

{qolsys_controller-0.0.56 → qolsys_controller-0.2.9}/README.md

@@ -24,7 +24,6 @@ A Python module that emulates a virtual IQ Remote device, enabling full **local
 |                        | Home Silent Disarming (Firmware 4.6.1)| ✅     |
 |                        | Set Exit Sounds                      | ✅     |
 |                        | Set Entry Delay                      | ✅            |
-|                        | Disarm Photos                        | 🛠️     |
 |                        | TTS                                  | 🛠️     |
 | **Zones**              | Sensor Status                        | ✅     |
 |                        | Tamper State                         | ✅     |
@@ -36,7 +35,8 @@ A Python module that emulates a virtual IQ Remote device, enabling full **local
 | **Z-Wave Devices**     | Battery Level                        | ✅     |
 |                        | Node Status                          | ✅     |
 |                        | Control Generic Devices              | TBD    |
-| **Z-Wave Dimmers**     | Light Status and Level Control       | ✅     |
+| **Z-Wave Dimmers**     | Binary Switch                        | ✅     |
+|                        | Multi Level Dimmer                   | ✅     |
 | **Z-Wave Door Locks**  | Lock, Unlock                         | ✅     |
 | **Z-Wave Thermostats** | Read device status                   | ✅     |
 |                        | Write device status                  | ✅     |

{qolsys_controller-0.0.56 → qolsys_controller-0.2.9}/bin/qolsys.py

@@ -6,12 +6,11 @@ import logging
 import os
 import sys
 
-from qolsys_controller import qolsys_controller
+from qolsys_controller import qolsys_controller  # type: ignore[attr-defined]
 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="")
@@ -28,26 +27,23 @@ async def main() -> None:  # noqa: D103
     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 = ""
+    Panel.settings.panel_ip = args.panel_ip
+    Panel.settings.plugin_ip = args.plugin_ip
+    Panel.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
+    Panel.settings.check_user_code_on_disarm = False
+    Panel.settings.log_mqtt_mesages = args.debug
+    Panel.settings.auto_discover_pki = args.pki_autodiscovery
 
     # Configure remote plugin
-    if not await Panel.plugin.config(start_pairing=True):
+    if not await Panel.config(start_pairing=True):
         LOGGER.debug("Error Configuring remote plugin")
         return
 
     try:
-        await Panel.plugin.start_operation()
+        await Panel.start_operation()
 
     except QolsysMqttError:
         LOGGER.debug("QolsysMqttError")
@@ -58,7 +54,7 @@ async def main() -> None:  # noqa: D103
     except QolsysSqlError:
         LOGGER.debug("QolsysSqlError")
 
-    if not Panel.plugin.connected:
+    if not Panel.connected:
         LOGGER.error("Panel not ready for operation")
         return
 
@@ -67,9 +63,14 @@ async def main() -> None:  # noqa: D103
     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
+    from asyncio import (  # type: ignore[attr-defined]
+        WindowsSelectorEventLoopPolicy,
+        set_event_loop_policy,
+    )
+
     set_event_loop_policy(WindowsSelectorEventLoopPolicy())
 
 asyncio.run(main())

qolsys_controller-0.2.9/example.py

@@ -0,0 +1,78 @@
+#!/usr/bin/env python3
+
+import asyncio
+import logging
+import os
+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")
+LOGGER = logging.getLogger(__name__)
+
+
+async def main() -> None:  # noqa: D103
+    remote = QolsysController()
+    remote.settings.config_directory = "./config/"
+    remote.settings.panel_ip = "****"
+    remote.settings.plugin_ip = "****"
+    remote.settings.random_mac = ""  # Example: F2:16:3E:33:ED:20
+
+    # Additionnal remote plugin config
+    remote.settings.check_user_code_on_disarm = False  # Check user code in user.conf file
+    remote.settings.log_mqtt_mesages = False  # Enable for MQTT debug purposes
+    remote.settings.auto_discover_pki = True
+
+    # Configure remote plugin
+    if not await remote.config(start_pairing=True):
+        LOGGER.debug("Error Configuring remote plugin")
+        return
+
+    try:
+        await remote.start_operation()
+
+    except QolsysMqttError:
+        LOGGER.debug("QolsysMqttError")
+
+    except QolsysSslError:
+        LOGGER.debug("QolsysSslError")
+
+    except QolsysSqlError:
+        LOGGER.debug("QolsysSqlError")
+
+    if not remote.connected:
+        LOGGER.error("Panel not ready for operation")
+        return
+
+    LOGGER.debug("Qolsys Panel Ready for operation")
+
+    await asyncio.sleep(5)
+    # await remote.command_zwave_switch_multi_level(node_id="6",level=99)
+    # await remote.command_zwave_switch_binary_set(node_id="8", status=True)
+    # await remote.plugin.command_arm(
+    #   partition_id='0',
+    #   arming_type=PartitionArmingType:ARM_NIGHT,
+    #   user_code="1111",
+    #   exit_sounds=False,
+    #   instant_arm=True)
+    # await remote.command_disarm(partition_id="0", user_code="1111")
+    # await remote.command_panel_execute_scene(scene_id="3")
+    # await remote.command_zwave_doorlock_set(node_id="7",locked=True)
+    # await remote.stop_operation()
+
+    # 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":
+    from asyncio import (  # type: ignore[attr-defined]
+        WindowsSelectorEventLoopPolicy,
+        set_event_loop_policy,
+    )
+
+    set_event_loop_policy(WindowsSelectorEventLoopPolicy())
+
+asyncio.run(main())

qolsys_controller-0.2.9/mypy.ini

@@ -0,0 +1,6 @@
+[mypy]
+python_version = 3.12
+warn_unused_configs = True
+disallow_untyped_defs = True
+ignore_missing_imports = True
+strict = True

{qolsys_controller-0.0.56 → qolsys_controller-0.2.9}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "qolsys-controller"
-version = "0.0.56"
+version = "0.2.9"
 authors = [
   { name="Eric Hylands", email="" },
 ]
@@ -27,11 +27,13 @@ build-backend = "hatchling.build"
 packages = ["qolsys_controller/"]
 
 [tool.ruff]
-line-length = 100
+line-length = 127
+target-version = "py312"
+
 
 [tool.ruff.lint]
-select = ['ALL']
-ignore = ["E501","S608","S311","S104","D100","D101", "D102","D107","ERA001", "FBT001","FBT002", "N802","N806","PERF401"]
+select = ["E", "F", "W", "I"]
+ignore = ["E501"]
 
 [tool.ruff.lint.mccabe]
 max-complexity = 25

qolsys_controller-0.2.9/qolsys_controller/adc_device.py

@@ -0,0 +1,202 @@
+import json
+import logging
+from typing import TYPE_CHECKING
+
+from .adc_service import QolsysAdcService
+from .adc_service_garagedoor import QolsysAdcGarageDoorService
+from .enum_adc import vdFuncLocalControl, vdFuncName, vdFuncState, vdFuncType
+from .observable import QolsysObservable
+
+if TYPE_CHECKING:
+    from .adc_service import QolsysAdcService
+
+LOGGER = logging.getLogger(__name__)
+
+
+class QolsysAdcDevice(QolsysObservable):
+    def __init__(self, adc_dict: dict[str, str]) -> None:
+        super().__init__()
+
+        self._services: list[QolsysAdcService] = []
+
+        self._id: str = adc_dict.get("_id", "")
+        self._partition_id: str = adc_dict.get("partition_id", "")
+        self._device_id: str = adc_dict.get("device_id", "")
+        self._name: str = adc_dict.get("name", "")
+        self._type: str = adc_dict.get("type", "")
+        self._create_time: str = adc_dict.get("create_time", "")
+        self._created_by: str = adc_dict.get("created_by", "")
+        self._update_time: str = adc_dict.get("update_time", "")
+        self._updated_by: str = adc_dict.get("updated_by", "")
+        self._device_zone_list: str = adc_dict.get("device_zone_list", "")
+        self._func_list = ""
+        self.func_list = adc_dict.get("func_list", "")
+
+    def update_adc_device(self, data: dict[str, str]) -> None:
+        # Check if we are updating same device_id
+        device_id_update = data.get("device_id", "")
+        if device_id_update != self._device_id:
+            LOGGER.error(
+                "Updating ADC%s (%s) with ADC%s (different device_id)",
+                self._device_id,
+                self._name,
+                device_id_update,
+            )
+            return
+
+        self.start_batch_update()
+
+        if "partition_id" in data:
+            self.partition_id = data.get("partition_id", "")
+
+        if "name" in data:
+            self.name = data.get("name", "")
+
+        if "type" in data:
+            self.type = data.get("type", "")
+
+        self.end_batch_update()
+
+        if "func_list" in data:
+            self.func_list = data.get("func_list", "")
+
+    def get_adc_service(self, id: int) -> QolsysAdcService | None:
+        for service in self._services:
+            if service.id == id:
+                return service
+        return None
+
+    def add_adc_service(
+        self,
+        id: int,
+        local_control: vdFuncLocalControl,
+        func_name: vdFuncName,
+        func_type: vdFuncType,
+        func_state: vdFuncState,
+        timestamp: str,
+    ) -> None:
+        # Garage Door
+        if func_name == vdFuncName.OPEN_CLOSE and func_type == vdFuncType.BINARY_ACTUATOR:
+            LOGGER.debug("ADC%s (%s) - Adding garage door service", self.device_id, self.name)
+            self._services.append(
+                QolsysAdcGarageDoorService(self, id, func_name, local_control, func_type, func_state, timestamp)
+            )
+            self.notify()
+            return
+
+        # Add generic service if other services have beed identified
+        LOGGER.debug("ADC%s (%s) - Adding generic service", self.device_id, self.name)
+        self._services.append(QolsysAdcService(self, id, func_name, local_control, func_type, func_state, timestamp))
+        self.notify()
+        return
+
+    # -----------------------------
+    # properties + setters
+    # -----------------------------
+
+    @property
+    def device_id(self) -> str:
+        return self._device_id
+
+    @device_id.setter
+    def device_id(self, value: str) -> None:
+        self._device_id = value
+
+    @property
+    def services(self) -> list[QolsysAdcService]:
+        return self._services
+
+    @property
+    def partition_id(self) -> str:
+        return self._partition_id
+
+    @partition_id.setter
+    def partition_id(self, value: str) -> None:
+        if self._partition_id != value:
+            LOGGER.debug("ADC%s (%s) - partition_id: %s", self.device_id, self.name, value)
+            self._partition_id = value
+            self.notify()
+
+    @property
+    def name(self) -> str:
+        return self._name
+
+    @name.setter
+    def name(self, value: str) -> None:
+        if self._name != value:
+            LOGGER.debug("ADC%s (%s) - name: %s", self.device_id, self.name, value)
+            self._name = value
+            self.notify()
+
+    @property
+    def type(self) -> str:
+        return self._type
+
+    @type.setter
+    def type(self, value: str) -> None:
+        if self._type != value:
+            LOGGER.debug("ADC%s (%s) - type: %s", self.device_id, self.name, value)
+            self._type = value
+            self.notify()
+
+    @property
+    def func_list(self) -> str:
+        return self._func_list
+
+    @func_list.setter
+    def func_list(self, value: str) -> None:
+        if self._func_list != value:
+            LOGGER.debug("ADC%s (%s) - func_list: %s", self.device_id, self.name, value)
+            self._func_list = value
+
+            try:
+                json_func_list = json.loads(self._func_list)
+                new_service_id: list[int] = []
+                self.start_batch_update()
+
+                for function in json_func_list:
+                    try:
+                        id = function.get("vdFuncId")
+                        local_control = vdFuncLocalControl(function.get("vdFuncLocalControl"))
+                        func_name = vdFuncName(function.get("vdFuncName"))
+                        func_type = vdFuncType(function.get("vdFuncType"))
+                        func_state = vdFuncState(function.get("vdFuncState"))
+                        timestamp = function.get("vdFuncBackendTimestamp")
+                        new_service_id.append(id)
+
+                        service = self.get_adc_service(id)
+                        if service is not None:
+                            service.update_adc_service(func_name, local_control, func_type, func_state, timestamp)
+
+                        if service is None:
+                            self.add_adc_service(id, local_control, func_name, func_type, func_state, timestamp)
+
+                    except ValueError as e:
+                        LOGGER.error("Error converting value:", e)
+                        continue
+
+                # Check if service have been removed
+                for service in self._services:
+                    if service.id not in new_service_id:
+                        self._services.remove(service)
+                        self.notify()
+
+                self.end_batch_update()
+
+            except json.JSONDecodeError as e:
+                LOGGER.error("ADC%s - Error parsing JSON:", self.device_id, e)
+
+    def to_dict_adc(self) -> dict[str, str]:
+        return {
+            "_id": self._id,
+            "partition_id": self.partition_id,
+            "device_id": self.device_id,
+            "name": self.name,
+            "type": self.type,
+            "func_list": self.func_list,
+            "create_time": self._create_time,
+            "created_by": self._created_by,
+            "update_time": self._update_time,
+            "updated_by": self._updated_by,
+            "device_zone_list": self._device_zone_list,
+        }

qolsys_controller-0.2.9/qolsys_controller/adc_service.py

@@ -0,0 +1,139 @@
+import logging
+from typing import TYPE_CHECKING
+
+from .enum_adc import vdFuncLocalControl, vdFuncName, vdFuncState, vdFuncType
+
+if TYPE_CHECKING:
+    from .adc_device import QolsysAdcDevice
+
+LOGGER = logging.getLogger(__name__)
+
+
+class QolsysAdcService:
+    def __init__(
+        self,
+        parent_device: "QolsysAdcDevice",
+        id: int,
+        func_name: vdFuncName,
+        local_control: vdFuncLocalControl,
+        func_type: vdFuncType,
+        func_state: vdFuncState,
+        timestamp: str,
+    ) -> None:
+        super().__init__()
+        self._parent_device: QolsysAdcDevice = parent_device
+        self._id: int = id
+        self._func_name: vdFuncName = func_name
+        self._local_control: vdFuncLocalControl = local_control
+        self._func_type: vdFuncType = func_type
+        self._func_state: vdFuncState = func_state
+        self._timestamp: str = timestamp
+
+    def update_adc_service(
+        self,
+        func_name: vdFuncName,
+        local_control: vdFuncLocalControl,
+        func_type: vdFuncType,
+        func_state: vdFuncState,
+        timestamp: str,
+    ) -> None:
+        self.name = func_name
+        self.local_control = local_control
+        self.func_type = func_type
+        self.func_state = func_state
+        self.timestamp = timestamp
+
+    # -----------------------------
+    # properties + setters
+    # -----------------------------
+
+    @property
+    def id(self) -> int:
+        return self._id
+
+    @property
+    def func_name(self) -> vdFuncName:
+        return self._func_name
+
+    @func_name.setter
+    def func_name(self, value: vdFuncName) -> None:
+        if value != self._func_name:
+            self._func_name = value
+            LOGGER.debug(
+                "ADC%s (%s) - Func%s - func_name:%s",
+                self._parent_device.device_id,
+                self._parent_device.name,
+                self.id,
+                self.func_name,
+            )
+            LOGGER.debug("Warning - Changing func_name will change device type - Not supported")
+            self._parent_device.notify()
+
+    @property
+    def local_control(self) -> vdFuncLocalControl:
+        return self._local_control
+
+    @local_control.setter
+    def local_control(self, value: vdFuncLocalControl) -> None:
+        if value != self.local_control:
+            self._local_control = value
+            LOGGER.debug(
+                "ADC%s (%s) - Func%s - local_control:%s",
+                self._parent_device.device_id,
+                self._parent_device.name,
+                self.id,
+                self.local_control,
+            )
+            self._parent_device.notify()
+
+    @property
+    def func_type(self) -> vdFuncType:
+        return self._func_type
+
+    @func_type.setter
+    def func_type(self, value: vdFuncType) -> None:
+        if value != self._func_type:
+            self._func_type = value
+            LOGGER.debug(
+                "ADC%s (%s) - Func%s - func_type:%s",
+                self._parent_device.device_id,
+                self._parent_device.name,
+                self.id,
+                self.func_type,
+            )
+            LOGGER.debug("Warning - Changing func_type will change device type - Not supported")
+            self._parent_device.notify()
+
+    @property
+    def func_state(self) -> vdFuncState:
+        return self._func_state
+
+    @func_state.setter
+    def func_state(self, value: vdFuncState) -> None:
+        if value != self._func_state:
+            self._func_state = value
+            LOGGER.debug(
+                "ADC%s (%s) - Func%s - func_state:%s",
+                self._parent_device.device_id,
+                self._parent_device.name,
+                self.id,
+                self.func_state,
+            )
+            self._parent_device.notify()
+
+    @property
+    def timestamp(self) -> str:
+        return self._timestamp
+
+    @timestamp.setter
+    def timestamp(self, value: str) -> None:
+        if value != self._timestamp:
+            self._timestamp = value
+            LOGGER.debug(
+                "ADC%s (%s) - Func%s - timestamp:%s",
+                self._parent_device.device_id,
+                self._parent_device.name,
+                self.id,
+                self.timestamp,
+            )
+            self._parent_device.notify()

qolsys_controller-0.2.9/qolsys_controller/adc_service_garagedoor.py

@@ -0,0 +1,35 @@
+import logging
+from typing import TYPE_CHECKING
+
+from .adc_service import QolsysAdcService
+from .enum_adc import vdFuncLocalControl, vdFuncName, vdFuncState, vdFuncType
+
+if TYPE_CHECKING:
+    from .adc_device import QolsysAdcDevice
+
+LOGGER = logging.getLogger(__name__)
+
+
+class QolsysAdcGarageDoorService(QolsysAdcService):
+    def __init__(
+        self,
+        parent_device: "QolsysAdcDevice",
+        id: int,
+        func_name: vdFuncName,
+        local_control: vdFuncLocalControl,
+        func_type: vdFuncType,
+        func_state: vdFuncState,
+        timestamp: str,
+    ) -> None:
+        super().__init__(
+            parent_device,
+            id,
+            func_name,
+            local_control,
+            func_type,
+            func_state,
+            timestamp,
+        )
+
+    def is_open(self) -> bool:
+        return self.func_state == vdFuncState.ON