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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: qolsys-controller
-Version: 0.0.82
+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

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

@@ -1,6 +1,6 @@
 [project]
 name = "qolsys-controller"
-version = "0.0.82"
+version = "0.2.9"
 authors = [
   { name="Eric Hylands", email="" },
 ]

{qolsys_controller-0.0.82 → qolsys_controller-0.2.9}/qolsys_controller/controller.py

@@ -157,15 +157,24 @@ class QolsysController:
         self.connected_observer.notify()
 
     async def mqtt_connect_task(self, reconnect: bool, run_forever: bool) -> None:
-        # Configure TLS parameters for MQTT connection
-        tls_params = aiomqtt.TLSParameters(
-            ca_certs=str(self._pki.qolsys_cer_file_path),
-            certfile=str(self._pki.secure_file_path),
-            keyfile=str(self._pki.key_file_path),
-            cert_reqs=ssl.CERT_REQUIRED,
-            tls_version=ssl.PROTOCOL_TLSv1_2,
-            ciphers="ALL:@SECLEVEL=0",
-        )
+        # Configure TLS context for MQTT connection
+        def create_tls_context(self: QolsysController) -> ssl.SSLContext:
+            ctx = ssl.create_default_context(
+                purpose=ssl.Purpose.SERVER_AUTH,
+                cafile=str(self._pki.qolsys_cer_file_path),
+            )
+            ctx.set_ciphers("DEFAULT:@SECLEVEL=0")
+            ctx.minimum_version = ssl.TLSVersion.TLSv1_2
+            ctx.check_hostname = False
+            ctx.verify_mode = ssl.CERT_NONE
+            ctx.load_cert_chain(
+                certfile=str(self._pki.secure_file_path),
+                keyfile=str(self._pki.key_file_path),
+            )
+            return ctx
+
+        loop = asyncio.get_running_loop()
+        ctx = await loop.run_in_executor(None, create_tls_context, self)
 
         LOGGER.debug("MQTT: Connecting ...")
 
@@ -177,7 +186,7 @@ class QolsysController:
                 self.aiomqtt = aiomqtt.Client(
                     hostname=self.settings.panel_ip,
                     port=8883,
-                    tls_params=tls_params,
+                    tls_context=ctx,
                     tls_insecure=True,
                     clean_session=True,
                     timeout=self.settings.mqtt_timeout,
@@ -748,6 +757,51 @@ class QolsysController:
         LOGGER.debug("MQTT: Receiving execute_scene command")
         return response
 
+    async def command_panel_virtual_device_action(self, device_id: str, state: int) -> dict[str, Any] | None:
+        LOGGER.debug("MQTT: Sending virtual_device command")
+
+        garage_door = self.state.adc_device(device_id)
+        if not garage_door:
+            LOGGER.error("Invalid Virtual Garage Door Id: %s", device_id)
+
+        device_list = {
+            "virtualDeviceList": [
+                {
+                    "virtualDeviceId": device_id,
+                    "virtualDeviceFunctionList": [
+                        {
+                            "vdFuncId": 1,
+                            "vdFuncState": state,
+                            "vdFuncBackendTimestamp": int(time.time() * 1000),
+                            "vdFuncType": 1,
+                        }
+                    ],
+                }
+            ]
+        }
+
+        virtual_command = {
+            "operation_name": "send_virtual_device_description",
+            "virtual_device_operation": 4,
+            "virtual_device_description": json.dumps(device_list),
+            "operation_source": 0,
+        }
+
+        ipc_request = [
+            {
+                "dataType": "string",
+                "dataValue": json.dumps(virtual_command),
+            }
+        ]
+
+        LOGGER.debug("virtual command: %s", virtual_command)
+
+        command = MQTTCommand_Panel(self)
+        command.append_ipc_request(ipc_request)
+        response = await command.send_command()
+        LOGGER.debug("MQTT: Receiving virtual_device command: %s", response)
+        return response
+
     async def command_panel_trigger_police(self, partition_id: str, silent: bool) -> dict[str, Any] | None:
         LOGGER.debug("MQTT: Sending panel_trigger_police command")
 
@@ -839,7 +893,7 @@ class QolsysController:
         return response
 
     async def command_zwave_switch_binary_set(self, node_id: str, status: bool) -> dict[str, Any] | None:
-        LOGGER.debug("MQTT: Sending set_zwave_switch_binary command  - Node(%s) - Status(%s)", node_id, status)
+        LOGGER.debug("MQTT: Sending set_zwave_switch_binar#y command  - Node(%s) - Status(%s)", node_id, status)
         zwave_node = self.state.zwave_device(node_id)
 
         if not zwave_node:
@@ -916,17 +970,21 @@ class QolsysController:
         temp_int = int(round(setpoint * (10**precision)))
         temp_bytes = temp_int.to_bytes(size, byteorder="big", signed=True)
 
+        setpointmode = ThermostatSetpointMode.HEATING
+        if mode == ThermostatSetpointMode.COOLING:
+            setpointmode = mode
+
         zwave_bytes: list[int] = [
-            ZwaveCommandClass.ThermostatSetPoint.value,
-            0x03,  # SET
-            mode.value,
+            0x43,  # Thermostat Setpoint
+            0x01,  # SET
+            setpointmode.value,
             pss,
         ] + list(temp_bytes)
 
         LOGGER.debug(
             "MQTT: Sending zwave_thermostat_setpoint_set - Node(%s) - Mode(%s) - Setpoint(%s): %s",
             node_id,
-            mode,
+            mode.value,
             setpoint,
             zwave_bytes,
         )
@@ -943,7 +1001,6 @@ class QolsysController:
             LOGGER.error("zwave_thermostat_mode_set - Invalid node_id %s", node_id)
             return None
 
-        LOGGER.debug("thermostat_mode: %s", int(mode))
         if mode not in thermostat.available_thermostat_mode():
             LOGGER.error("thermostat_mode_set - Invalid mode %s", mode)
 

{qolsys_controller-0.0.82 → qolsys_controller-0.2.9}/qolsys_controller/database/db.py

@@ -216,7 +216,7 @@ class QolsysDB:
         return partitions
 
     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.cursor.execute(f"SELECT * FROM {self.table_virtual_device.table} ORDER BY CAST(device_id AS INTEGER)")
         self.db.commit()
 
         devices = []
@@ -228,7 +228,7 @@ class QolsysDB:
         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.cursor.execute(f"SELECT * FROM {self.table_zwave_node.table} ORDER BY CAST(node_id AS INTEGER)")
         self.db.commit()
 
         devices = []
@@ -240,7 +240,7 @@ class QolsysDB:
         return devices
 
     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.cursor.execute(f"SELECT * FROM {self.table_zwave_other.table} ORDER BY CAST(node_id AS INTEGER)")
         self.db.commit()
 
         devices = []
@@ -252,7 +252,7 @@ class QolsysDB:
         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.cursor.execute(f"SELECT * FROM {self.table_doorlock.table} ORDER BY CAST(node_id AS INTEGER)")
         self.db.commit()
 
         locks = []
@@ -264,7 +264,7 @@ class QolsysDB:
         return locks
 
     def get_thermostats(self) -> list[dict[str, str]]:
-        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 CAST(node_id AS INTEGER)")
         self.db.commit()
 
         thermostats = []
@@ -276,7 +276,7 @@ class QolsysDB:
         return thermostats
 
     def get_dimmers(self) -> list[dict[str, str]]:
-        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 CAST(node_id AS INTEGER)")
         self.db.commit()
 
         dimmers = []
@@ -288,7 +288,7 @@ class QolsysDB:
         return dimmers
 
     def get_zones(self) -> list[dict[str, str]]:
-        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 CAST(zoneid AS INTEGER)")
         self.db.commit()
 
         zones = []

{qolsys_controller-0.0.82 → qolsys_controller-0.2.9}/qolsys_controller/database/table_sensor.py

@@ -65,6 +65,8 @@ class QolsysTableSensor(QolsysTable):
             "extras",
             "allowspeaker",
             "firmware_version",
+            "radio_version",
+            "radio_id",
         ]
 
         self._create_table()

{qolsys_controller-0.0.82 → qolsys_controller-0.2.9}/qolsys_controller/database/table_smartsocket.py

@@ -12,10 +12,21 @@ class QolsysTableSmartSocket(QolsysTable):
         self._uri = "content://com.qolsys.qolsysprovider.SmartSocketsContentProvider/smartsocket"
         self._table = "smartsocket"
         self._abort_on_error = False
-        self._implemented = False
+        self._implemented = True
 
         self._columns = [
             "_id",
+            "created_by",
+            "created_date",
+            "last_updated_date",
+            "node_id",
+            "paired_status",
+            "power_usage",
+            "status",
+            "updated_by",
+            "socket_id",
+            "socket_name",
+            "current_usagevoltage_usage",
         ]
 
         self._create_table()

{qolsys_controller-0.0.82 → qolsys_controller-0.2.9}/qolsys_controller/database/table_user.py

@@ -39,6 +39,7 @@ class QolsysTableUser(QolsysTable):
             "tag_flag",
             "check_in_time",
             "user_feature1",
+            "user_feature2",
         ]
 
         self._create_table()

{qolsys_controller-0.0.82 → qolsys_controller-0.2.9}/qolsys_controller/enum.py

@@ -1,6 +1,16 @@
 from enum import StrEnum
 
 
+class QolsysEvent(StrEnum):
+    EVENT_PANEL_PARTITION_ADD = "EVENT_PANEL_PARTITION_ADD"
+    EVENT_PANEL_ZONE_ADD = "EVENT_PANEL_ZONE_ADD"
+    EVENT_PANEL_DOORBELL = "EVENT_PANEL_DOORBELL"
+    EVENT_PANEL_CHIME = "EVENT_PANEL_CHIME"
+    EVENT_ZWAVE_DEVICE_ADD = "EVENT_ZWAVE_MULTILEVELSENSOR_ADD"
+    EVENT_ZWAVE_MULTILEVELSENSOR_ADD = "EVENT_ZWAVE_MULTILEVELSENSOR_ADD"
+    EVENT_ZWAVE_METER_ADD = "EVENT_ZWAVE_METER_ADD"
+
+
 class PartitionSystemStatus(StrEnum):
     ARM_STAY = "ARM-STAY"
     ARM_AWAY = "ARM-AWAY"
@@ -48,23 +58,24 @@ class PartitionAlarmType(StrEnum):
 
 
 class ZoneStatus(StrEnum):
+    ACTIVE = "Active"
+    ACTIVATED = "Activated"
     ALARMED = "Alarmed"
-    OPEN = "Open"
+    ARM_AWAY = "Arm-Away"
+    ARM_STAY = "Arm-Stay"
     CLOSED = "Closed"
-    ACTIVE = "Active"
+    CONNECTED = "connected"
+    DISARM = "Disarm"
+    OPEN = "Open"
     INACTIVE = "Inactive"
-    ACTIVATED = "Activated"
     IDLE = "Idle"
     NORMAL = "Normal"
     UNREACHABLE = "Unreachable"
     TAMPERED = "Tampered"
     SYNCHRONIZING = "Synchronizing"
-    CONNECTED = "connected"
     DISCONNECTED = "disconnected"
     FAILURE = "Failure"
     NOT_NETWORKED = "Not Networked"
-    DISARM = "Disarm"
-    ARM_AWAY = "Arm-Away"
 
 
 class DeviceCapability(StrEnum):
@@ -72,20 +83,20 @@ class DeviceCapability(StrEnum):
     WIFI = "WiFi"
     POWERG = "POWERG"
     ZWAVE = "Z-Wave"
+    S_LINE = "S-Line"
 
 
 class ZoneSensorType(StrEnum):
-    DOOR_WINDOW = "Door_Window"
+    AUXILIARY_PENDANT = "Auxiliary Pendant"
+    BLUETOOTH = "Bluetooth"
+    CO_DETECTOR = "CODetector"
     DOORBELL = "Doorbell"
-    MOTION = "Motion"
+    DOOR_WINDOW = "Door_Window"
     GLASS_BREAK = "GlassBreak"
+    MOTION = "Motion"
     KEY_FOB = "KeyFob"
     KEYPAD = "Keypad"
-    AUXILIARY_PENDANT = "Auxiliary Pendant"
     SMOKE_DETECTOR = "SmokeDetector"
-    CO_DETECTOR = "CODetector"
-    # HARDWIRE_TRANSLATOR = "" # TBD
-    # WIRELESS_TRANSLATOR = "" #TBD
     TEMPERATURE = "Temperature"
     HEAT = "Heat"
     WATER = "Water"
@@ -93,16 +104,18 @@ class ZoneSensorType(StrEnum):
     FREEZE = "Freeze"
     TILT = "Tilt"
     SMOKE_M = "Smoke_M"
-    # DOOR_WINDOW_M = "" #TBD
-    # OCCUPANCY = ""  #TBD
     SIREN = "Siren"
-    # HIGH_TEMPERATURE = "" # TBD
     PANEL_MOTION = "Panel Motion"
     PANEL_GLASS_BREAK = "Panel Glass Break"
-    BLUETOOTH = "Bluetooth"
     TAKEOVER_MODULE = "TakeoverModule"
     TRANSLATOR = "Translator"
     TAMPER = "Tamper Sensor"
+    ZWAVE_SIREN = "Z-Wave Siren"
+    # HARDWIRE_TRANSLATOR = "" # TBD
+    # HIGH_TEMPERATURE = "" # TBD
+    # DOOR_WINDOW_M = "" #TBD
+    # WIRELESS_TRANSLATOR = "" #TBD
+    # OCCUPANCY = ""  #TBD
 
 
 class ZoneSensorGroup(StrEnum):

{qolsys_controller-0.0.82 → qolsys_controller-0.2.9}/qolsys_controller/enum_zwave.py

@@ -160,14 +160,30 @@ BITMASK_SUPPORTED_THERMOSTAT_FAN_MODE = {
 class ZwaveCommandClass(IntEnum):
     SwitchBinary = 0x25
     SwitchMultilevel = 0x26
+    SceneActivation = 0x2B
+    SceneActuatorConf = 0x2C
     SensorMultiLevel = 0x31
     Meter = 0x32
     ThermostatMode = 0x40
     ThermostatSetPoint = 0x43
     ThermostatFanMode = 0x44
     ThermostatFanState = 0x45
+    DeviceResetLocally = 0x5A
+    AssociationGroupInformation = 0x59
+    ZWavePlusInfo = 0x5E
+    MultiChannel = 0x60
     DoorLock = 0x62
+    Supervision = 0x6C
+    Configuration = 0x70
     Alarm = 0x71
+    ManufacturerSpecific = 0x72
+    PowerLevel = 0x73
+    FirmwareUpdate = 0x7A
+    Association = 0x85
+    Version = 0x86
+    Indicator = 0x87
+    MultiChannelAssociation = 0x8E
+    SecurityS2 = 0x9F
 
 
 class ZwaveCommand(IntEnum):

qolsys_controller-0.2.9/qolsys_controller/observable_v2.py

@@ -0,0 +1,14 @@
+from collections.abc import Callable
+from typing import Any
+
+
+class QolsysObservable_v2:
+    def __init__(self) -> None:
+        self._observers: dict[str, Any] = {}
+
+    def subscribe(self, event_name: str, callback: Callable[[], None]) -> None:
+        self._observers.setdefault(event_name, []).append(callback)
+
+    def publish(self, event_name: str, *args: Any, **kwargs: Any) -> None:
+        for callback in self._observers.get(event_name, []):
+            callback(*args, **kwargs)

{qolsys_controller-0.0.82 → qolsys_controller-0.2.9}/qolsys_controller/panel.py

@@ -7,13 +7,18 @@ from typing import TYPE_CHECKING, Any
 
 from qolsys_controller.adc_device import QolsysAdcDevice
 from qolsys_controller.zwave_energy_clamp import QolsysEnergyClamp
+from qolsys_controller.zwave_extenal_siren import QolsysExternalSiren
+from qolsys_controller.zwave_garagedoor import QolsysGarageDoor
+from qolsys_controller.zwave_smart_socket import QolsysSmartSocket
 from qolsys_controller.zwave_thermometer import QolsysThermometer
+from qolsys_controller.zwave_water_valve import QolsysWaterValve
 
 from .database.db import QolsysDB
 from .enum import (
     PartitionAlarmState,
     PartitionAlarmType,
     PartitionSystemStatus,
+    QolsysEvent,
 )
 from .observable import QolsysObservable
 from .partition import QolsysPartition
@@ -452,6 +457,14 @@ class QolsysPanel(QolsysObservable):
             case "primaryDisconnect":
                 LOGGER.info("Main Panel Disconnect")
 
+            case "eventNameDoorBell":
+                LOGGER.debug("Doorbell Event: %s", json.dumps(data))
+                self._controller.state.state_observer.publish(QolsysEvent.EVENT_PANEL_DOORBELL, data)
+
+            case "chime":
+                LOGGER.debug("Chime Event: %s", json.dumps(data))
+                self._controller.state.state_observer.publish(QolsysEvent.EVENT_PANEL_CHIME, data)
+
             case "dbChanged":
                 match dbOperation:
                     case "update":
@@ -901,23 +914,29 @@ class QolsysPanel(QolsysObservable):
             # Check if z-wave device is an Energy Clamp
             if device.get("node_type", "") == "Energy Clamp":
                 LOGGER.debug(device)
-                qolsys_meter_device = QolsysEnergyClamp(device)
+                qolsys_meter_device = QolsysEnergyClamp(self._controller, device)
                 devices.append(qolsys_meter_device)
                 device_added = True
 
             # Check if z-wave device is a thermometer
             if device.get("node_type", "") == "Thermometer":
-                qolsys_thermometer = QolsysThermometer(device)
+                qolsys_thermometer = QolsysThermometer(self._controller, device)
                 devices.append(qolsys_thermometer)
                 device_added = True
 
+            # Check if z-wave device is an external siren
+            if device.get("node_type", "") == "External Siren":
+                qolsys_siren = QolsysExternalSiren(self._controller, device)
+                devices.append(qolsys_siren)
+                device_added = True
+
             # Check if z-wave device is a Dimmer
             for d in dimmers_list:
                 dimmer_node_id = d.get("node_id", "")
 
                 # Found a Dimmer
                 if zwave_node_id == dimmer_node_id:
-                    qolsys_dimmer = QolsysDimmer(d, device)
+                    qolsys_dimmer = QolsysDimmer(self._controller, d, device)
                     devices.append(qolsys_dimmer)
                     device_added = True
                     break
@@ -928,7 +947,7 @@ class QolsysPanel(QolsysObservable):
 
                 # Found a Thermostat
                 if zwave_node_id == thermostat_node_id:
-                    qolsys_thermostat = QolsysThermostat(thermostat, device)
+                    qolsys_thermostat = QolsysThermostat(self._controller, thermostat, device)
                     devices.append(qolsys_thermostat)
                     device_added = True
                     break
@@ -939,18 +958,32 @@ class QolsysPanel(QolsysObservable):
 
                 # Found a Lock
                 if zwave_node_id == lock_node_id:
-                    qolsys_lock = QolsysLock(lock, device)
+                    qolsys_lock = QolsysLock(self._controller, lock, device)
                     devices.append(qolsys_lock)
                     device_added = True
                     break
 
             # Found a Smart Outlet
+            if device.get("node_type", "") == "Smart Socket":
+                qolsys_socket = QolsysSmartSocket(self._controller, device)
+                devices.append(qolsys_socket)
+                device_added = True
 
             # Found Garage Door Openner
+            if device.get("node_type", "") == "Garage Door":
+                qolsys_garagedoor = QolsysGarageDoor(self._controller, device)
+                devices.append(qolsys_garagedoor)
+                device_added = True
+
+            # Found a Water Valve
+            if device.get("node_type", "") == "Water Valve":
+                qolsys_watervalve = QolsysWaterValve(self._controller, device)
+                devices.append(qolsys_watervalve)
+                device_added = True
 
             # No Specific z-wave device found, add a generic z-wave device
             if not device_added:
-                qolsys_generic = QolsysGeneric(device)
+                qolsys_generic = QolsysGeneric(self._controller, device)
                 devices.append(qolsys_generic)
 
         return devices
@@ -987,9 +1020,7 @@ class QolsysPanel(QolsysObservable):
             new_zone = QolsysZone(zone_info, self._controller.settings)
 
             if new_zone.current_capability == "POWERG":
-                LOGGER.debug("Loading PowerG device info for zone %s", new_zone.zone_id)
                 powerg_dict = self.db.get_powerg(short_id=new_zone.shortID)
-                LOGGER.debug("PowerG device info: %s", powerg_dict)
                 if powerg_dict is not None:
                     new_zone.update_powerg(powerg_dict)
 
@@ -1042,7 +1073,7 @@ class QolsysPanel(QolsysObservable):
         LOGGER.debug("Z-Wave Firmware Version: %s", self.ZWAVE_FIRM_WARE_VERSION)
         LOGGER.debug("Z-Wave Card Present: %s", self.ZWAVE_CARD)
         LOGGER.debug("Z-Wave Controller Enabled: %s", self.ZWAVE_CONTROLLER)
-        LOGGER.debug("Partitons Enabled: %s", self.PARTITIONS)
+        LOGGER.debug("Partitions Enabled: %s", self.PARTITIONS)
         LOGGER.debug("Control4 Enabled: %s", self.CONTROL_4)
         LOGGER.debug("Six Digit User Code Enabled: %s", self.SIX_DIGIT_USER_CODE)
         LOGGER.debug("Secure Arming: %s", self.SECURE_ARMING)