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

qolsys_controller/zwave_device.py

@@ -1,147 +1,133 @@
 import logging
 
+from .enum_zwave import ZwaveDeviceClass
 from .observable import QolsysObservable
 
 LOGGER = logging.getLogger(__name__)
 
 
 class QolsysZWaveDevice(QolsysObservable):
-
-    def __init__(self, zwave_dict: dict) -> None:
+    def __init__(self, zwave_dict: dict[str, str]) -> None:
         super().__init__()
 
-        self._id = zwave_dict.get("_id")
-        self._node_id = zwave_dict.get("node_id", "")
-        self._node_name = zwave_dict.get("node_name", "")
-        self._node_type = zwave_dict.get("node_type", "")
-        self._node_status = zwave_dict.get("node_status", "")
-        self._partition_id = zwave_dict.get("partition_id", "")
-        self._node_secure_cmd_cls = zwave_dict.get("node_secure_cmd_cls", "")
-        self._node_battery_level = zwave_dict.get("node_battery_level", "")
-        self._node_battery_level_value = zwave_dict.get("node_battery_level_value", "")
-        self._is_node_listening_node = zwave_dict.get("is_node_listening_node", "")
-        self._basic_report_value = zwave_dict.get("basic_report_value", "")
-        self._switch_multilevel_report_value = zwave_dict.get("switch_multilevel_report_value", "")
-        self._basic_device_type = zwave_dict.get("basic_device_type", "")
-        self._generic_device_type = zwave_dict.get("generic_device_type", "")
-        self._specific_device_type = zwave_dict.get("specific_device_type", "")
-        self._num_secure_command_class = zwave_dict.get("num_secure_command_class", "")
-        self._secure_command_class = zwave_dict.get("secure_command_class", "")
-        self._manufacture_id = zwave_dict.get("manufacture_id", "")
-        self._product_type = zwave_dict.get("product_type", "")
-        self._device_protocol = zwave_dict.get("device_protocol", "")
-        self._paired_status = zwave_dict.get("paired_status", "")
-        self._is_device_sleeping = zwave_dict.get("is_device_sleeping", "")
-        self._is_device_hidden = zwave_dict.get("is_device_hidden", "")
-        self._last_updated_date = zwave_dict.get("last_updated_date", "")
-        self._command_class_list = zwave_dict.get("command_class_list", "")
-
-    @property
-    def node_id(self) -> str:
-        return self._node_id
-
-    @property
-    def paired_status(self) -> str:
-        return self._paired_status
-
-    @property
-    def node_battery_level(self) -> str:
-        return self._node_battery_level
-
-    @property
-    def node_battery_level_value(self) -> str:
-        return self._node_battery_level_value
-
-    @property
-    def node_status(self) -> str:
-        return self._node_status
-
-    @property
-    def node_name(self) -> str:
-        return self._node_name
-
-    @property
-    def node_type(self) -> str:
-        return self._node_type
-
-    @property
-    def partition_id(self) -> str:
-        return self._partition_id
-
-    def update_base(self, data: dict) -> None:  # noqa: C901, PLR0912, PLR0915
-
+        self._id: str = zwave_dict.get("_id", "")
+        self._node_id: str = zwave_dict.get("node_id", "")
+        self._node_name: str = zwave_dict.get("node_name", "")
+        self._node_type: str = zwave_dict.get("node_type", "")
+        self._node_status: str = zwave_dict.get("node_status", "")
+        self._partition_id: str = zwave_dict.get("partition_id", "")
+        self._node_secure_cmd_cls: str = zwave_dict.get("node_secure_cmd_cls", "")
+        self._node_battery_level: str = zwave_dict.get("node_battery_level", "")
+        self._node_battery_level_value: str = zwave_dict.get("node_battery_level_value", "")
+        self._is_node_listening_node: str = zwave_dict.get("is_node_listening_node", "")
+        self._basic_report_value: str = zwave_dict.get("basic_report_value", "")
+        self._switch_multilevel_report_value: str = zwave_dict.get("switch_multilevel_report_value", "")
+        self._basic_device_type: str = zwave_dict.get("basic_device_type", "")
+        self._generic_device_type: str = zwave_dict.get("generic_device_type", "")
+        self._specific_device_type: str = zwave_dict.get("specific_device_type", "")
+        self._num_secure_command_class: str = zwave_dict.get("num_secure_command_class", "")
+        self._secure_command_class: str = zwave_dict.get("secure_command_class", "")
+        self._manufacture_id: str = zwave_dict.get("manufacture_id", "")
+        self._product_type: str = zwave_dict.get("product_type", "")
+        self._device_protocol: str = zwave_dict.get("device_protocol", "")
+        self._paired_status: str = zwave_dict.get("paired_status", "")
+        self._is_device_sleeping: str = zwave_dict.get("is_device_sleeping", "")
+        self._is_device_hidden: str = zwave_dict.get("is_device_hidden", "")
+        self._last_updated_date: str = zwave_dict.get("last_updated_date", "")
+        self._command_class_list: str = zwave_dict.get("command_class_list", "")
+
+    def update_base(self, data: dict[str, str]) -> None:  # noqa: C901, PLR0912, PLR0915
         # Check if we are updating same node_id
         node_id_update = data.get("node_id", "")
         if node_id_update != self._node_id:
             LOGGER.error(
-                "Updating ZWave%s (%s) with ZWave%s (different node_id)", self.node_id, self.node_name, node_id_update,
+                "Updating ZWave%s (%s) with ZWave%s (different node_id)",
+                self.node_id,
+                self.node_name,
+                node_id_update,
             )
             return
 
         self.start_batch_update()
 
         if "paired_status" in data:
-            self.paired_status = data.get("paired_status")
+            self.paired_status = data.get("paired_status", "")
         if "node_battery_level" in data:
-            self.node_battery_level = data.get("node_battery_level")
+            self.node_battery_level = data.get("node_battery_level", "")
         if "node_battery_level_value" in data:
-            self.node_battery_level_value = data.get("node_battery_level_value")
+            self.node_battery_level_value = data.get("node_battery_level_value", "")
         if "node_status" in data:
-            self.node_status = data.get("node_status")
+            self.node_status = data.get("node_status", "")
         if "node_name" in data:
-            self.node_name = data.get("node_name")
+            self.node_name = data.get("node_name", "")
         if "node_type" in data:
-            self.node_type = data.get("node_type")
+            self.node_type = data.get("node_type", "")
         if "partition_id" in data:
-            self.partition_id = data.get("partition_id")
+            self.partition_id = data.get("partition_id", "")
         if "node_secure_cmd_cls" in data:
-            self._node_secure_cmd_cls = data.get("node_secure_cmd_cls")
+            self._node_secure_cmd_cls = data.get("node_secure_cmd_cls", "")
         if "is_node_listening_node" in data:
-            self._is_node_listening_node = data.get("is_node_listening_node")
+            self._is_node_listening_node = data.get("is_node_listening_node", "")
         if "basic_report_value" in data:
-            self._basic_report_value = data.get("basic_report_value")
+            self._basic_report_value = data.get("basic_report_value", "")
         if "switch_multilevel_report_value" in data:
-            self._switch_multilevel_report_value = data.get("switch_multilevel_report_value")
+            self._switch_multilevel_report_value = data.get("switch_multilevel_report_value", "")
         if "basic_device_type" in data:
-            self._basic_device_type = data.get("basic_device_type")
+            self._basic_device_type = data.get("basic_device_type", "")
         if "generic_device_type" in data:
-            self._generic_device_type = data.get("generic_device_type")
+            self._generic_device_type = data.get("generic_device_type", "")
         if "specific_device_type" in data:
-            self._specific_device_type = data.get("specific_device_type")
+            self._specific_device_type = data.get("specific_device_type", "")
         if "num_secure_command_class" in data:
-            self._num_secure_command_class = data.get("num_secure_command_class")
+            self._num_secure_command_class = data.get("num_secure_command_class", "")
         if "secure_command_class" in data:
-            self._secure_command_class = data.get("secure_command_class")
+            self._secure_command_class = data.get("secure_command_class", "")
         if "manufacture_id" in data:
-            self._manufacture_id = data.get("manufacture_id")
+            self._manufacture_id = data.get("manufacture_id", "")
         if "product_type" in data:
-            self._product_type = data.get("product_type")
+            self._product_type = data.get("product_type", "")
         if "device_protocol" in data:
-            self._device_protocol = data.get("device_protocol")
+            self._device_protocol = data.get("device_protocol", "")
         if "paired_status" in data:
-            self.paired_status = data.get("paired_status")
+            self.paired_status = data.get("paired_status", "")
         if "is_device_sleeping" in data:
-            self._is_device_sleeping = data.get("is_device_sleeping")
+            self._is_device_sleeping = data.get("is_device_sleeping", "")
         if "is_device_hidden" in data:
-            self._is_device_hidden = data.get("is_device_hidden")
+            self._is_device_hidden = data.get("is_device_hidden", "")
         if "last_updated_date" in data:
-            self._last_updated_date = data.get("last_updated_date")
+            self._last_updated_date = data.get("last_updated_date", "")
         if "command_class_list" in data:
-            self._last_updated_date = data.get("command_class_list")
+            self._last_updated_date = data.get("command_class_list", "")
 
         self.end_batch_update()
 
+    # -----------------------------
+    # properties + setters
+    # -----------------------------
+
+    @property
+    def node_id(self) -> str:
+        return self._node_id
+
     @node_id.setter
-    def node_id(self, value: str) -> str:
+    def node_id(self, value: str) -> None:
         self._node_id = value
 
+    @property
+    def paired_status(self) -> str:
+        return self._paired_status
+
     @paired_status.setter
-    def paired_status(self, value: str) -> str:
+    def paired_status(self, value: str) -> None:
         if self._paired_status != value:
             LOGGER.debug("ZWave%s (%s) - paired_status: %s", self.node_id, self.node_name, value)
             self._paired_status = value
             self.notify()
 
+    @property
+    def node_battery_level(self) -> str:
+        return self._node_battery_level
+
     @node_battery_level.setter
     def node_battery_level(self, value: str) -> None:
         if self._node_battery_level != value:
@@ -149,42 +135,69 @@ class QolsysZWaveDevice(QolsysObservable):
             self._node_battery_level = value
             self.notify()
 
+    @property
+    def node_battery_level_value(self) -> str:
+        return self._node_battery_level_value
+
     @node_battery_level_value.setter
-    def node_battery_level_value(self, value: str) -> str:
+    def node_battery_level_value(self, value: str) -> None:
         if self._node_battery_level_value != value:
             LOGGER.debug("ZWave%s (%s) - node_battery_level_value: %s", self.node_id, self.node_name, value)
             self._node_battery_level_value = value
             self.notify()
 
+    @property
+    def node_status(self) -> str:
+        return self._node_status
+
     @node_status.setter
-    def node_status(self, value: str) -> str:
+    def node_status(self, value: str) -> None:
         if self._node_status != value:
             LOGGER.debug("ZWave%s (%s) - node_status: %s", self.node_id, self.node_name, value)
             self._node_status = value
             self.notify()
 
+    @property
+    def node_name(self) -> str:
+        return self._node_name
+
     @node_name.setter
-    def node_name(self, value: str) -> str:
+    def node_name(self, value: str) -> None:
         if self._node_name != value:
             LOGGER.debug("ZWave%s (%s) - node_name: %s", self.node_id, self.node_name, value)
             self._node_name = value
             self.notify()
 
+    @property
+    def node_type(self) -> str:
+        return self._node_type
+
     @node_type.setter
-    def node_type(self, value: str) -> str:
+    def node_type(self, value: str) -> None:
         if self._node_type != value:
             LOGGER.debug("ZWave%s (%s) - node_type: %s", self.node_id, self.node_name, value)
             self._node_type = value
             self.notify()
 
+    @property
+    def partition_id(self) -> str:
+        return self._partition_id
+
     @partition_id.setter
-    def partition_id(self, value: str) -> str:
+    def partition_id(self, value: str) -> None:
         if self._partition_id != value:
             LOGGER.debug("ZWave%s (%s) - partition_id: %s", self._node_id, self._node_name, value)
             self._partition_id = value
             self.notify()
 
-    def to_dict_base(self) -> dict:
+    @property
+    def generic_device_type(self) -> ZwaveDeviceClass:
+        try:
+            return ZwaveDeviceClass(int(self._generic_device_type))
+        except ValueError:
+            return ZwaveDeviceClass.Unknown
+
+    def to_dict_base(self) -> dict[str, str]:
         return {
             "_id": self._id,
             "node_id": self.node_id,

qolsys_controller/zwave_dimmer.py

@@ -6,26 +6,31 @@ LOGGER = logging.getLogger(__name__)
 
 
 class QolsysDimmer(QolsysZWaveDevice):
+    def __init__(self, dimmer_dict: dict[str, str], zwave_dict: dict[str, str]) -> None:
+        super().__init__(zwave_dict)
 
-    def __init__(self, dimmer_dict: dict, zwave_dict: dict) -> None:
+        self._dimmer_id: str = dimmer_dict.get("_id", "")
+        self._dimmer_version: str = dimmer_dict.get("version", "")
+        self._dimmer_opr: str = dimmer_dict.get("opr", "")
+        self._dimmer_partition_id: str = dimmer_dict.get("partition_id", "")
+        self._dimmer_name: str = dimmer_dict.get("dimmer_name", "")
+        self._dimmer_status: str = dimmer_dict.get("status", "")
+        self._dimmer_level: str = dimmer_dict.get("level", "")
+        self._dimmer_node_id: str = dimmer_dict.get("node_id", "")
+        self._dimmer_created_by: str = dimmer_dict.get("created_by", "")
+        self._dimmer_created_date: str = dimmer_dict.get("created_date", "")
+        self._dimmer_updated_by: str = dimmer_dict.get("updated_by", "")
+        self._dimmer_last_updated_date: str = dimmer_dict.get("last_updated_date", "")
+        self._dimmer_endpoint: str = dimmer_dict.get("endpoint", "")
+        self._dimmer_power_details: str = dimmer_dict.get("power_details", "")
+        self._dimmer_paired_status: str = dimmer_dict.get("paired_status", "")
 
-        super().__init__(zwave_dict)
+    def is_on(self) -> bool:
+        return self.dimmer_status == "On"
 
-        self._dimmer_id = dimmer_dict.get("_id")
-        self._dimmer_version = dimmer_dict.get("version", "")
-        self._dimmer_opr = dimmer_dict.get("opr", "")
-        self._dimmer_partition_id = dimmer_dict.get("partition_id", "")
-        self._dimmer_name = dimmer_dict.get("dimmer_name", "")
-        self._dimmer_status = dimmer_dict.get("status", "")
-        self._dimmer_level = dimmer_dict.get("level", "")
-        self._dimmer_node_id = dimmer_dict.get("node_id", "")
-        self._dimmer_created_by = dimmer_dict.get("created_by", "")
-        self._dimmer_created_date = dimmer_dict.get("created_date", "")
-        self._dimmer_updated_by = dimmer_dict.get("updated_by", "")
-        self._dimmer_last_updated_date = dimmer_dict.get("last_updated_date", "")
-        self._dimmer_endpoint = dimmer_dict.get("endpoint", "")
-        self._dimmer_power_details = dimmer_dict.get("power_details", "")
-        self._dimmer_paired_status = dimmer_dict.get("paired_status", "")
+    # -----------------------------
+    # properties + setters
+    # -----------------------------
 
     @property
     def dimmer_node_id(self) -> str:
@@ -35,21 +40,6 @@ class QolsysDimmer(QolsysZWaveDevice):
     def dimmer_status(self) -> str:
         return self._dimmer_status
 
-    @property
-    def dimmer_name(self) -> str:
-        return self._dimmer_name
-
-    @property
-    def dimmer_level(self) -> str:
-        return self._dimmer_level
-
-    @dimmer_level.setter
-    def dimmer_level(self, value: str) -> None:
-        if self._dimmer_level != value:
-            LOGGER.debug("Dimmer%s (%s) - level: %s", self.node_id, self.dimmer_name, value)
-            self._dimmer_level = value
-            self.notify()
-
     @dimmer_status.setter
     def dimmer_status(self, value: str) -> None:
         if self._dimmer_status != value:
@@ -57,6 +47,10 @@ class QolsysDimmer(QolsysZWaveDevice):
             self._dimmer_status = value
             self.notify()
 
+    @property
+    def dimmer_name(self) -> str:
+        return self._dimmer_name
+
     @dimmer_name.setter
     def dimmer_name(self, value: str) -> None:
         if self._dimmer_name != value:
@@ -64,49 +58,58 @@ class QolsysDimmer(QolsysZWaveDevice):
             self._dimmer_name = value
             self.notify()
 
-    def is_on(self) -> bool:
-        return self.dimmer_status == "On"
+    @property
+    def dimmer_level(self) -> str:
+        return self._dimmer_level
+
+    @dimmer_level.setter
+    def dimmer_level(self, value: str) -> None:
+        if self._dimmer_level != value:
+            LOGGER.debug("Dimmer%s (%s) - level: %s", self.node_id, self.dimmer_name, value)
+            self._dimmer_level = value
+            self.notify()
 
-    def update_dimmer(self, content_values: dict) -> None:  # noqa: C901
+    def update_dimmer(self, content_values: dict[str, str]) -> None:  # noqa: PLR0912
         # Check if we are updating same none_id
         node_id_update = content_values.get("node_id", "")
         if node_id_update != self._dimmer_node_id:
             LOGGER.error(
-                "Updating Dimmer %s (%s) with dimmer %s (different id)", self._node_id, self.dimmer_name, node_id_update)
+                "Updating Dimmer %s (%s) with dimmer %s (different id)", self._node_id, self.dimmer_name, node_id_update
+            )
             return
 
         self.start_batch_update()
 
         if "status" in content_values:
-            self.dimmer_status = content_values.get("status")
+            self.dimmer_status = content_values.get("status", "")
         if "level" in content_values:
-            self.dimmer_level = content_values.get("level")
+            self.dimmer_level = content_values.get("level", "")
         if "dimmer_name" in content_values:
-            self.dimmer_name = content_values.get("dimmer_name")
+            self.dimmer_name = content_values.get("dimmer_name", "")
         if "created_by" in content_values:
-            self._dimmer_created_by = content_values.get("created_by")
+            self._dimmer_created_by = content_values.get("created_by", "")
         if "created_date" in content_values:
-            self._dimmer_created_date = content_values.get("created_date")
+            self._dimmer_created_date = content_values.get("created_date", "")
         if "version" in content_values:
-            self._dimmer_version = content_values.get("version")
+            self._dimmer_version = content_values.get("version", "")
         if "opr" in content_values:
-            self._dimmer_opr = content_values.get("opr")
+            self._dimmer_opr = content_values.get("opr", "")
         if "partition_id" in content_values:
-            self.partition_id = content_values.get("partition_id")
+            self.partition_id = content_values.get("partition_id", "")
         if "updated_by" in content_values:
-            self._dimmer_updated_by = content_values.get("updated_by")
+            self._dimmer_updated_by = content_values.get("updated_by", "")
         if "last_updated_date" in content_values:
-            self._last_updated_date = content_values.get("last_updated_date")
+            self._last_updated_date = content_values.get("last_updated_date", "")
         if "endpoint" in content_values:
-            self._dimmer_endpoint = content_values.get("endpoint")
+            self._dimmer_endpoint = content_values.get("endpoint", "")
         if "power_details" in content_values:
-            self._dimmer_power_details = content_values.get("power_details")
+            self._dimmer_power_details = content_values.get("power_details", "")
         if "paired_status" in content_values:
-            self._dimmer_paired_status = content_values.get("paired_status")
+            self._dimmer_paired_status = content_values.get("paired_status", "")
 
         self.end_batch_update()
 
-    def to_dict_dimmer(self) -> dict:
+    def to_dict_dimmer(self) -> dict[str, str]:
         return {
             "_id": self._dimmer_id,
             "version": self._dimmer_version,

qolsys_controller/zwave_garagedoor.py

@@ -6,6 +6,5 @@ LOGGER = logging.getLogger(__name__)
 
 
 class QolsysGarageDoor(QolsysZWaveDevice):
-
     def __init__(self) -> None:
         pass

qolsys_controller/zwave_generic.py

@@ -1,11 +1,10 @@
 import logging
 
-from qolsys_controller.zwave_device import QolsysZWaveDevice
+from .zwave_device import QolsysZWaveDevice
 
 LOGGER = logging.getLogger(__name__)
 
 
 class QolsysGeneric(QolsysZWaveDevice):
-
-    def __init__(self, zwave_dict: dict) -> None:
+    def __init__(self, zwave_dict: dict[str, str]) -> None:
         super().__init__(zwave_dict)

qolsys_controller/zwave_lock.py

@@ -6,29 +6,31 @@ LOGGER = logging.getLogger(__name__)
 
 
 class QolsysLock(QolsysZWaveDevice):
-
     LOCK_STATUS_ARRAY = ["Locked"]  # noqa: RUF012
 
-    def __init__(self, lock_dict: dict, zwave_dict: dict) -> None:
-
+    def __init__(self, lock_dict: dict[str, str], zwave_dict: dict[str, str]) -> None:
         super().__init__(zwave_dict)
 
-        self._lock_id = lock_dict.get("_id")
-        self._lock_version = lock_dict.get("version", "")
-        self._lock_opr = lock_dict.get("opr", "")
-        self._lock_partition_id = lock_dict.get("partition_id", "")
-        self._lock_name = lock_dict.get("doorlock_name", "")
-        self._lock_status = lock_dict.get("status", "")
-        self._lock_node_id = lock_dict.get("node_id", "")
-        self._lock_created_by = lock_dict.get("created_by", "")
-        self._lock_created_date = lock_dict.get("created_date", "")
-        self._lock_updated_by = lock_dict.get("updated_by", "")
-        self._lock_last_updated_date = lock_dict.get("last_updated_date", "")
-        self._lock_remote_arming = lock_dict.get("remote_arming", "")
-        self._lock_keyfob_arming = lock_dict.get("keyfob_arming", "")
-        self._lock_panel_arming = lock_dict.get("panel_arming", "")
-        self._lock_endpoint = lock_dict.get("endpoint", "")
-        self._lock_paired_status = lock_dict.get("paired_status", "")
+        self._lock_id: str = lock_dict.get("_id", "")
+        self._lock_version: str = lock_dict.get("version", "")
+        self._lock_opr: str = lock_dict.get("opr", "")
+        self._lock_partition_id: str = lock_dict.get("partition_id", "")
+        self._lock_name: str = lock_dict.get("doorlock_name", "")
+        self._lock_status: str = lock_dict.get("status", "")
+        self._lock_node_id: str = lock_dict.get("node_id", "")
+        self._lock_created_by: str = lock_dict.get("created_by", "")
+        self._lock_created_date: str = lock_dict.get("created_date", "")
+        self._lock_updated_by: str = lock_dict.get("updated_by", "")
+        self._lock_last_updated_date: str = lock_dict.get("last_updated_date", "")
+        self._lock_remote_arming: str = lock_dict.get("remote_arming", "")
+        self._lock_keyfob_arming: str = lock_dict.get("keyfob_arming", "")
+        self._lock_panel_arming: str = lock_dict.get("panel_arming", "")
+        self._lock_endpoint: str = lock_dict.get("endpoint", "")
+        self._lock_paired_status: str = lock_dict.get("paired_status", "")
+
+    # -----------------------------
+    # properties + setters
+    # -----------------------------
 
     @property
     def lock_node_id(self) -> str:
@@ -38,14 +40,6 @@ class QolsysLock(QolsysZWaveDevice):
     def lock_status(self) -> str:
         return self._lock_status
 
-    @property
-    def lock_name(self) -> str:
-        return self._lock_name
-
-    @property
-    def paired_status(self) -> str:
-        return self._paired_status
-
     @lock_status.setter
     def lock_status(self, value: str) -> None:
         if self._lock_status != value:
@@ -53,6 +47,10 @@ class QolsysLock(QolsysZWaveDevice):
             self._lock_status = value
             self.notify()
 
+    @property
+    def lock_name(self) -> str:
+        return self._lock_name
+
     @lock_name.setter
     def lock_name(self, value: str) -> None:
         if self._lock_name != value:
@@ -60,6 +58,10 @@ class QolsysLock(QolsysZWaveDevice):
             self._lock_name = value
             self.notify()
 
+    @property
+    def paired_status(self) -> str:
+        return self._paired_status
+
     @paired_status.setter
     def paired_status(self, value: str) -> None:
         if self._paired_status != value:
@@ -67,48 +69,49 @@ class QolsysLock(QolsysZWaveDevice):
             self._lock_paired_status = value
             self.notify()
 
-    def update_lock(self, data: dict) -> None:  # noqa: PLR0912
+    def update_lock(self, data: dict[str, str]) -> None:  # noqa: PLR0912
         # Check if we are updating same zoneid
         node_id_update = data.get("node_id", "")
         if node_id_update != self.lock_node_id:
             LOGGER.error(
-                "Updating Lock %s (%s) with Lock '%s' (different id)", self.lock_node_id, self.lock_name, node_id_update)
+                "Updating Lock %s (%s) with Lock '%s' (different id)", self.lock_node_id, self.lock_name, node_id_update
+            )
             return
 
         self.start_batch_update()
 
         if "version" in data:
-            self._lock_version = data.get("version")
+            self._lock_version = data.get("version", "")
         if "opr" in data:
-            self._lock_opr = data.get("opr")
+            self._lock_opr = data.get("opr", "")
         if "partition_id" in data:
-            self._lock_partition_id = data.get("partition_id")
+            self._lock_partition_id = data.get("partition_id", "")
         if "lock_name" in data:
-            self.lock_name = data.get("lock_name")
+            self.lock_name = data.get("lock_name", "")
         if "status" in data:
-            self.lock_status = data.get("status")
+            self.lock_status = data.get("status", "")
         if "created_by" in data:
-            self._lock_created_by = data.get("created_by")
+            self._lock_created_by = data.get("created_by", "")
         if "created_date" in data:
-            self._lock_created_date = data.get("created_date")
+            self._lock_created_date = data.get("created_date", "")
         if "updated_by" in data:
-            self._lock_updated_by = data.get("updated_by")
+            self._lock_updated_by = data.get("updated_by", "")
         if "last_updated_date" in data:
-            self._lock_last_updated_date = data.get("last_updated_date")
+            self._lock_last_updated_date = data.get("last_updated_date", "")
         if "remote_arming" in data:
-            self._lock_remote_arming = data.get("remote_arming")
+            self._lock_remote_arming = data.get("remote_arming", "")
         if "keyfob_arming" in data:
-            self._lock_keyfob_arming = data.get("keyfob_arming")
+            self._lock_keyfob_arming = data.get("keyfob_arming", "")
         if "panel_arming" in data:
-            self._lock_panel_arming = data.get("panel_arming")
+            self._lock_panel_arming = data.get("panel_arming", "")
         if "endpoint" in data:
-            self._lock_endpoint = data.get("endpoint")
+            self._lock_endpoint = data.get("endpoint", "")
         if "paired_status" in data:
-            self._lock_paired_status = data.get("paired_status")
+            self._lock_paired_status = data.get("paired_status", "")
 
         self.end_batch_update()
 
-    def to_dict_lock(self) -> dict:
+    def to_dict_lock(self) -> dict[str, str]:
         return {
             "_id": self._lock_id,
             "version": self._lock_version,

qolsys_controller/zwave_outlet.py

@@ -6,6 +6,5 @@ LOGGER = logging.getLogger(__name__)
 
 
 class QolsysOutlet(QolsysZWaveDevice):
-
     def __init__(self) -> None:
         pass