zwave-js-server-python 0.56.0__tar.gz → 0.58.0__tar.gz

{zwave_js_server_python-0.56.0 → zwave_js_server_python-0.58.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: zwave-js-server-python
-Version: 0.56.0
+Version: 0.58.0
 Summary: Python wrapper for zwave-js-server
 Author-email: Home Assistant Team <hello@home-assistant.io>
 License:                                  Apache License
@@ -212,9 +212,9 @@ Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: Natural Language :: English
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
 Classifier: Topic :: Home Automation
-Requires-Python: >=3.11
+Requires-Python: >=3.12
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: aiohttp>3

{zwave_js_server_python-0.56.0 → zwave_js_server_python-0.58.0}/pyproject.toml

@@ -7,7 +7,7 @@ name = "zwave-js-server-python"
 authors = [{ name = "Home Assistant Team", email = "hello@home-assistant.io" }]
 description = "Python wrapper for zwave-js-server"
 readme = "README.md"
-requires-python = ">=3.11"
+requires-python = ">=3.12"
 license = { file = "LICENSE" }
 keywords = ["home", "automation", "zwave", "zwave-js"]
 classifiers = [
@@ -15,7 +15,7 @@ classifiers = [
     "Intended Audience :: Developers",
     "Natural Language :: English",
     "Programming Language :: Python :: 3",
-    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
     "Topic :: Home Automation",
 ]
 dependencies = ["aiohttp>3", "pydantic>=1.10.0"]
@@ -88,6 +88,20 @@ expected-line-ending-format = "LF"
 asyncio_mode = "auto"
 
 [tool.ruff]
+exclude = [
+    ".venv",
+    ".git",
+    ".tox",
+    "docs",
+    "venv",
+    "bin",
+    "lib",
+    "deps",
+    "build",
+]
+line-length = 88
+
+[tool.ruff.lint]
 select = ["D", "E", "F", "G", "I", "PLC", "PLE", "PLR", "PLW", "UP", "W"]
 ignore = [
     "D202",
@@ -104,22 +118,10 @@ ignore = [
     "UP006",   # keep type annotation style as is
     "UP007",   # keep type annotation style as is
 ]
-exclude = [
-    ".venv",
-    ".git",
-    ".tox",
-    "docs",
-    "venv",
-    "bin",
-    "lib",
-    "deps",
-    "build",
-]
-line-length = 88
 
-[tool.ruff.isort]
+[tool.ruff.lint.isort]
 force-sort-within-sections = true
-known-first-party = ["zwave_js_server"]
+known-first-party = ["zwave_js_server", "test"]
 combine-as-imports = true
 split-on-trailing-comma = false
 case-sensitive = true

{zwave_js_server_python-0.56.0 → zwave_js_server_python-0.58.0}/zwave_js_server/const/__init__.py

@@ -8,12 +8,12 @@ import logging
 from typing import TypedDict
 
 PACKAGE_NAME = "zwave-js-server-python"
-__version__ = "0.56.0"
+__version__ = "0.58.0"
 
 # minimal server schema version we can handle
-MIN_SERVER_SCHEMA_VERSION = 35
+MIN_SERVER_SCHEMA_VERSION = 37
 # max server schema version we can handle (and our code is compatible with)
-MAX_SERVER_SCHEMA_VERSION = 35
+MAX_SERVER_SCHEMA_VERSION = 37
 
 VALUE_UNKNOWN = "unknown"
 
@@ -505,3 +505,16 @@ class SupervisionStatus(IntEnum):
     WORKING = 1
     FAIL = 2
     SUCCESS = 255
+
+
+class AssociationCheckResult(IntEnum):
+    """Enum for all known association check results."""
+
+    # https://github.com/zwave-js/node-zwave-js/blob/master/packages/cc/src/lib/_Types.ts#L47
+    OK = 1
+    FORBIDDEN_DESTINATION_IS_LONG_RANGE = 2
+    FORBIDDEN_SOURCE_IS_LONG_RANGE = 3
+    FORBIDDEN_SELF_ASSOCIATION = 4
+    FORBIDDEN_SECURITY_CLASS_MISMATCH = 5
+    FORBIDDEN_DESTINATION_SECURITY_CLASS_NOT_GRANTED = 6
+    FORBIDDEN_NO_SUPPORTED_CCS = 7

{zwave_js_server_python-0.56.0 → zwave_js_server_python-0.58.0}/zwave_js_server/const/command_class/lock.py

@@ -186,6 +186,7 @@ class DoorLockCCConfigurationSetOptions:
             ),
         )
         for prop_name, val in (
+            (TARGET_LOCK_TIMEOUT_PROPERTY, self.lock_timeout_configuration),
             (TARGET_AUTO_RELOCK_TIME_PROPERTY, self.auto_relock_time),
             (TARGET_HOLD_AND_RELEASE_TIME_PROPERTY, self.hold_and_release_time),
             (TARGET_TWIST_ASSIST_PROPERTY, self.twist_assist),

{zwave_js_server_python-0.56.0 → zwave_js_server_python-0.58.0}/zwave_js_server/const/command_class/meter.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 from enum import IntEnum
 
 VALUE_PROPERTY = "value"
+RESET_PROPERTY = "reset"
 
 CC_SPECIFIC_SCALE = "scale"
 CC_SPECIFIC_METER_TYPE = "meterType"
@@ -13,9 +14,11 @@ CC_SPECIFIC_RATE_TYPE = "rateType"
 RESET_METER_CC_API = "reset"
 
 # optional attributes when calling the Meter CC reset API.
-# https://github.com/zwave-js/node-zwave-js/blob/master/packages/zwave-js/src/lib/commandclass/MeterCC.ts#L873-L881
+# https://github.com/zwave-js/node-zwave-js/blob/master/packages/cc/src/cc/MeterCC.ts
 RESET_METER_OPTION_TARGET_VALUE = "targetValue"
 RESET_METER_OPTION_TYPE = "type"
+RESET_METER_OPTION_SCALE = "scale"
+RESET_METER_OPTION_RATE_TYPE = "rateType"
 
 
 # https://github.com/zwave-js/node-zwave-js/blob/master/packages/config/config/meters.json

{zwave_js_server_python-0.56.0 → zwave_js_server_python-0.58.0}/zwave_js_server/event.py

@@ -21,6 +21,14 @@ class BaseEventModel(BaseModel):
     source: Literal["controller", "driver", "node"]
     event: str
 
+    @classmethod
+    def from_dict(cls, data: dict) -> BaseEventModel:
+        """Initialize from dict."""
+        return cls(
+            source=data["source"],
+            event=data["event"],
+        )
+
 
 @dataclass
 class Event:

{zwave_js_server_python-0.56.0 → zwave_js_server_python-0.58.0}/zwave_js_server/model/association.py

@@ -3,6 +3,11 @@
 from __future__ import annotations
 
 from dataclasses import dataclass, field
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from .controller import Controller
+    from .node import Node
 
 
 @dataclass
@@ -21,5 +26,13 @@ class AssociationGroup:
 class AssociationAddress:
     """Represent a association dict type."""
 
+    controller: Controller
     node_id: int
     endpoint: int | None = None
+
+    @property
+    def node(self) -> Node | None:
+        """Return the node."""
+        if self.node_id in self.controller.nodes:
+            return self.controller.nodes[self.node_id]
+        return None

{zwave_js_server_python-0.56.0 → zwave_js_server_python-0.58.0}/zwave_js_server/model/command_class.py

@@ -51,3 +51,7 @@ class CommandClassInfo:
     def is_secure(self) -> bool:
         """Return if the CommandClass is used securely on this node/endpoint."""
         return self.data["isSecure"]
+
+    def to_dict(self) -> CommandClassInfoDataType:
+        """Create a dictionary from itself."""
+        return self.data.copy()

{zwave_js_server_python-0.56.0 → zwave_js_server_python-0.58.0}/zwave_js_server/model/controller/__init__.py

@@ -9,6 +9,7 @@ from zwave_js_server.model.node.firmware import NodeFirmwareUpdateInfo
 
 from ...const import (
     MINIMUM_QR_STRING_LENGTH,
+    AssociationCheckResult,
     ControllerStatus,
     ExclusionStrategy,
     InclusionState,
@@ -574,6 +575,7 @@ class Controller(EventBase):
         for key, association_addresses in data["associations"].items():
             associations[int(key)] = [
                 AssociationAddress(
+                    self,
                     node_id=association_address["nodeId"],
                     endpoint=association_address.get("endpoint"),
                 )
@@ -581,10 +583,10 @@ class Controller(EventBase):
             ]
         return associations
 
-    async def async_is_association_allowed(
+    async def async_check_association(
         self, source: AssociationAddress, group: int, association: AssociationAddress
-    ) -> bool:
-        """Send isAssociationAllowed command to Controller."""
+    ) -> AssociationCheckResult:
+        """Send checkAssociation command to Controller."""
         source_data = {"nodeId": source.node_id}
         if source.endpoint is not None:
             source_data["endpoint"] = source.endpoint
@@ -594,13 +596,14 @@ class Controller(EventBase):
             association_data["endpoint"] = association.endpoint
         data = await self.client.async_send_command(
             {
-                "command": "controller.is_association_allowed",
+                "command": "controller.check_association",
                 **source_data,
                 "group": group,
                 "association": association_data,
-            }
+            },
+            require_schema=37,
         )
-        return cast(bool, data["allowed"])
+        return AssociationCheckResult(data["result"])
 
     async def async_add_associations(
         self,
@@ -869,7 +872,7 @@ class Controller(EventBase):
                 f"{event.data}"
             )
 
-        CONTROLLER_EVENT_MODEL_MAP[event.type](**event.data)
+        CONTROLLER_EVENT_MODEL_MAP[event.type].from_dict(event.data)
 
         self._handle_event_protocol(event)
 

{zwave_js_server_python-0.56.0 → zwave_js_server_python-0.58.0}/zwave_js_server/model/controller/event_model.py

@@ -52,6 +52,15 @@ class FirmwareUpdateFinishedEventModel(BaseControllerEventModel):
     event: Literal["firmware update finished"]
     result: ControllerFirmwareUpdateResultDataType
 
+    @classmethod
+    def from_dict(cls, data: dict) -> FirmwareUpdateFinishedEventModel:
+        """Initialize from dict."""
+        return cls(
+            source=data["source"],
+            event=data["event"],
+            result=data["result"],
+        )
+
 
 class FirmwareUpdateProgressEventModel(BaseControllerEventModel):
     """Model for `firmware update progress` event data."""
@@ -59,6 +68,15 @@ class FirmwareUpdateProgressEventModel(BaseControllerEventModel):
     event: Literal["firmware update progress"]
     progress: ControllerFirmwareUpdateProgressDataType
 
+    @classmethod
+    def from_dict(cls, data: dict) -> FirmwareUpdateProgressEventModel:
+        """Initialize from dict."""
+        return cls(
+            source=data["source"],
+            event=data["event"],
+            progress=data["progress"],
+        )
+
 
 class GrantSecurityClassesEventModel(BaseControllerEventModel):
     """Model for `grant security classes` event data."""
@@ -66,6 +84,15 @@ class GrantSecurityClassesEventModel(BaseControllerEventModel):
     event: Literal["grant security classes"]
     requested: InclusionGrantDataType
 
+    @classmethod
+    def from_dict(cls, data: dict) -> GrantSecurityClassesEventModel:
+        """Initialize from dict."""
+        return cls(
+            source=data["source"],
+            event=data["event"],
+            requested=data["requested"],
+        )
+
 
 class RebuildRoutesDoneEventModel(BaseControllerEventModel):
     """Model for `rebuild routes done` event data."""
@@ -73,6 +100,15 @@ class RebuildRoutesDoneEventModel(BaseControllerEventModel):
     event: Literal["rebuild routes done"]
     result: dict[str, str]
 
+    @classmethod
+    def from_dict(cls, data: dict) -> RebuildRoutesDoneEventModel:
+        """Initialize from dict."""
+        return cls(
+            source=data["source"],
+            event=data["event"],
+            result=data["result"],
+        )
+
 
 class RebuildRoutesProgressEventModel(BaseControllerEventModel):
     """Model for `rebuild routes progress` event data."""
@@ -80,6 +116,15 @@ class RebuildRoutesProgressEventModel(BaseControllerEventModel):
     event: Literal["rebuild routes progress"]
     progress: dict[str, str]
 
+    @classmethod
+    def from_dict(cls, data: dict) -> RebuildRoutesProgressEventModel:
+        """Initialize from dict."""
+        return cls(
+            source=data["source"],
+            event=data["event"],
+            progress=data["progress"],
+        )
+
 
 class InclusionAbortedEventModel(BaseControllerEventModel):
     """Model for `inclusion aborted` event data."""
@@ -99,6 +144,15 @@ class InclusionStartedEventModel(BaseControllerEventModel):
     event: Literal["inclusion started"]
     secure: bool
 
+    @classmethod
+    def from_dict(cls, data: dict) -> InclusionStartedEventModel:
+        """Initialize from dict."""
+        return cls(
+            source=data["source"],
+            event=data["event"],
+            secure=data["secure"],
+        )
+
 
 class InclusionStoppedEventModel(BaseControllerEventModel):
     """Model for `inclusion stopped` event data."""
@@ -113,6 +167,16 @@ class NodeAddedEventModel(BaseControllerEventModel):
     node: NodeDataType
     result: InclusionResultDataType
 
+    @classmethod
+    def from_dict(cls, data: dict) -> NodeAddedEventModel:
+        """Initialize from dict."""
+        return cls(
+            source=data["source"],
+            event=data["event"],
+            node=data["node"],
+            result=data["result"],
+        )
+
 
 class NodeFoundEventModel(BaseControllerEventModel):
     """Model for `node found` event data."""
@@ -120,6 +184,15 @@ class NodeFoundEventModel(BaseControllerEventModel):
     event: Literal["node found"]
     node: FoundNodeDataType
 
+    @classmethod
+    def from_dict(cls, data: dict) -> NodeFoundEventModel:
+        """Initialize from dict."""
+        return cls(
+            source=data["source"],
+            event=data["event"],
+            node=data["node"],
+        )
+
 
 class NodeRemovedEventModel(BaseControllerEventModel):
     """Model for `node removed` event data."""
@@ -128,6 +201,16 @@ class NodeRemovedEventModel(BaseControllerEventModel):
     node: NodeDataType
     reason: RemoveNodeReason
 
+    @classmethod
+    def from_dict(cls, data: dict) -> NodeRemovedEventModel:
+        """Initialize from dict."""
+        return cls(
+            source=data["source"],
+            event=data["event"],
+            node=data["node"],
+            reason=data["reason"],
+        )
+
 
 class NVMBackupAndConvertProgressEventModel(BaseControllerEventModel):
     """Base model for `nvm backup progress` and `nvm convert progress` event data."""
@@ -135,6 +218,16 @@ class NVMBackupAndConvertProgressEventModel(BaseControllerEventModel):
     bytesRead: int
     total: int
 
+    @classmethod
+    def from_dict(cls, data: dict) -> NVMBackupAndConvertProgressEventModel:
+        """Initialize from dict."""
+        return cls(
+            source=data["source"],
+            event=data["event"],
+            bytesRead=data["bytesRead"],
+            total=data["total"],
+        )
+
 
 class NVMBackupProgressEventModel(NVMBackupAndConvertProgressEventModel):
     """Model for `nvm backup progress` event data."""
@@ -155,6 +248,16 @@ class NVMRestoreProgressEventModel(BaseControllerEventModel):
     bytesWritten: int
     total: int
 
+    @classmethod
+    def from_dict(cls, data: dict) -> NVMRestoreProgressEventModel:
+        """Initialize from dict."""
+        return cls(
+            source=data["source"],
+            event=data["event"],
+            bytesWritten=data["bytesWritten"],
+            total=data["total"],
+        )
+
 
 class StatisticsUpdatedEventModel(BaseControllerEventModel):
     """Model for `statistics updated` event data."""
@@ -162,6 +265,15 @@ class StatisticsUpdatedEventModel(BaseControllerEventModel):
     event: Literal["statistics updated"]
     statistics: ControllerStatisticsDataType
 
+    @classmethod
+    def from_dict(cls, data: dict) -> StatisticsUpdatedEventModel:
+        """Initialize from dict."""
+        return cls(
+            source=data["source"],
+            event=data["event"],
+            statistics=data["statistics"],
+        )
+
 
 class ValidateDSKAndEnterPINEventModel(BaseControllerEventModel):
     """Model for `validate dsk and enter pin` event data."""
@@ -169,6 +281,15 @@ class ValidateDSKAndEnterPINEventModel(BaseControllerEventModel):
     event: Literal["validate dsk and enter pin"]
     dsk: str
 
+    @classmethod
+    def from_dict(cls, data: dict) -> ValidateDSKAndEnterPINEventModel:
+        """Initialize from dict."""
+        return cls(
+            source=data["source"],
+            event=data["event"],
+            dsk=data["dsk"],
+        )
+
 
 class IdentifyEventModel(BaseControllerEventModel):
     """Model for `identify` event data."""
@@ -176,6 +297,15 @@ class IdentifyEventModel(BaseControllerEventModel):
     event: Literal["identify"]
     nodeId: int
 
+    @classmethod
+    def from_dict(cls, data: dict) -> IdentifyEventModel:
+        """Initialize from dict."""
+        return cls(
+            source=data["source"],
+            event=data["event"],
+            nodeId=data["nodeId"],
+        )
+
 
 class StatusChangedEventModel(BaseControllerEventModel):
     """Model for `status changed` event data."""
@@ -183,6 +313,15 @@ class StatusChangedEventModel(BaseControllerEventModel):
     event: Literal["status changed"]
     status: int
 
+    @classmethod
+    def from_dict(cls, data: dict) -> StatusChangedEventModel:
+        """Initialize from dict."""
+        return cls(
+            source=data["source"],
+            event=data["event"],
+            status=data["status"],
+        )
+
 
 CONTROLLER_EVENT_MODEL_MAP: dict[str, type[BaseControllerEventModel]] = {
     "exclusion failed": ExclusionFailedEventModel,

{zwave_js_server_python-0.56.0 → zwave_js_server_python-0.58.0}/zwave_js_server/model/controller/inclusion_and_provisioning.py

@@ -76,13 +76,13 @@ class ProvisioningEntry:
             security_classes=[
                 SecurityClass(sec_cls) for sec_cls in data["securityClasses"]
             ],
-            additional_properties={
-                k: v
-                for k, v in data.items()
-                if k
-                not in {"dsk", "securityClasses", "requestedSecurityClasses", "status"}
-            },
         )
+        if additional_properties := {
+            k: v
+            for k, v in data.items()
+            if k not in ("dsk", "securityClasses", "requestedSecurityClasses", "status")
+        }:
+            cls_instance.additional_properties = additional_properties
         if "requestedSecurityClasses" in data:
             cls_instance.requested_security_classes = [
                 SecurityClass(sec_cls) for sec_cls in data["requestedSecurityClasses"]
@@ -148,6 +148,12 @@ class QRProvisioningInformation(ProvisioningEntry, QRProvisioningInformationMixi
     @classmethod
     def from_dict(cls, data: dict[str, Any]) -> QRProvisioningInformation:
         """Return QRProvisioningInformation from data dict."""
+        supported_protocols: list[Protocols] | None = None
+        if "supportedProtocols" in data:
+            supported_protocols = [
+                Protocols(supported_protocol)
+                for supported_protocol in data["supportedProtocols"]
+            ]
         cls_instance = cls(
             version=QRCodeVersion(data["version"]),
             security_classes=[
@@ -163,33 +169,31 @@ class QRProvisioningInformation(ProvisioningEntry, QRProvisioningInformationMixi
             application_version=data["applicationVersion"],
             max_inclusion_request_interval=data.get("maxInclusionRequestInterval"),
             uuid=data.get("uuid"),
-            supported_protocols=[
-                Protocols(supported_protocol)
-                for supported_protocol in data.get("supportedProtocols", [])
-            ],
-            additional_properties={
-                k: v
-                for k, v in data.items()
-                if k
-                not in {
-                    "version",
-                    "securityClasses",
-                    "requestedSecurityClasses",
-                    "dsk",
-                    "genericDeviceClass",
-                    "specificDeviceClass",
-                    "installerIconType",
-                    "manufacturerId",
-                    "productType",
-                    "productId",
-                    "applicationVersion",
-                    "maxInclusionRequestInterval",
-                    "uuid",
-                    "supportedProtocols",
-                    "status",
-                }
-            },
+            supported_protocols=supported_protocols,
         )
+        if additional_properties := {
+            k: v
+            for k, v in data.items()
+            if k
+            not in (
+                "version",
+                "securityClasses",
+                "requestedSecurityClasses",
+                "dsk",
+                "genericDeviceClass",
+                "specificDeviceClass",
+                "installerIconType",
+                "manufacturerId",
+                "productType",
+                "productId",
+                "applicationVersion",
+                "maxInclusionRequestInterval",
+                "uuid",
+                "supportedProtocols",
+                "status",
+            )
+        }:
+            cls_instance.additional_properties = additional_properties
         if "requestedSecurityClasses" in data:
             cls_instance.requested_security_classes = [
                 SecurityClass(sec_cls) for sec_cls in data["requestedSecurityClasses"]

{zwave_js_server_python-0.56.0 → zwave_js_server_python-0.58.0}/zwave_js_server/model/device_class.py

@@ -23,8 +23,6 @@ class DeviceClassDataType(TypedDict):
     basic: DeviceClassItemDataType
     generic: DeviceClassItemDataType
     specific: DeviceClassItemDataType
-    mandatorySupportedCCs: list[int]
-    mandatoryControlledCCs: list[int]
 
 
 @dataclass
@@ -40,11 +38,18 @@ class DeviceClass:
 
     def __init__(self, data: DeviceClassDataType) -> None:
         """Initialize."""
-        self._basic = DeviceClassItem(**data["basic"])
-        self._generic = DeviceClassItem(**data["generic"])
-        self._specific = DeviceClassItem(**data["specific"])
-        self._mandatory_supported_ccs: list[int] = data["mandatorySupportedCCs"]
-        self._mandatory_controlled_ccs: list[int] = data["mandatoryControlledCCs"]
+        self._basic = DeviceClassItem(
+            key=data["basic"]["key"],
+            label=data["basic"]["label"],
+        )
+        self._generic = DeviceClassItem(
+            key=data["generic"]["key"],
+            label=data["generic"]["label"],
+        )
+        self._specific = DeviceClassItem(
+            key=data["specific"]["key"],
+            label=data["specific"]["label"],
+        )
 
     @property
     def basic(self) -> DeviceClassItem:
@@ -60,13 +65,3 @@ class DeviceClass:
     def specific(self) -> DeviceClassItem:
         """Return specific DeviceClass."""
         return self._specific
-
-    @property
-    def mandatory_supported_ccs(self) -> list[int]:
-        """Return list of mandatory Supported CC id's."""
-        return self._mandatory_supported_ccs
-
-    @property
-    def mandatory_controlled_ccs(self) -> list[int]:
-        """Return list of mandatory Controlled CC id's."""
-        return self._mandatory_controlled_ccs

{zwave_js_server_python-0.56.0 → zwave_js_server_python-0.58.0}/zwave_js_server/model/driver.py

@@ -30,6 +30,15 @@ class LogConfigUpdatedEventModel(BaseDriverEventModel):
     event: Literal["log config updated"]
     config: LogConfigDataType
 
+    @classmethod
+    def from_dict(cls, data: dict) -> LogConfigUpdatedEventModel:
+        """Initialize from dict."""
+        return cls(
+            source=data["source"],
+            event=data["event"],
+            config=data["config"],
+        )
+
 
 class AllNodesReadyEventModel(BaseDriverEventModel):
     """Model for `all nodes ready` event data."""
@@ -87,7 +96,7 @@ class Driver(EventBase):
             self.controller.receive_event(event)
             return
 
-        DRIVER_EVENT_MODEL_MAP[event.type](**event.data)
+        DRIVER_EVENT_MODEL_MAP[event.type].from_dict(event.data)
 
         self._handle_event_protocol(event)
 

{zwave_js_server_python-0.56.0 → zwave_js_server_python-0.58.0}/zwave_js_server/model/node/__init__.py

@@ -19,12 +19,7 @@ from ...const import (
     SecurityClass,
 )
 from ...event import Event, EventBase
-from ...exceptions import (
-    FailedCommand,
-    NotFoundError,
-    UnparseableValue,
-    UnwriteableValue,
-)
+from ...exceptions import NotFoundError, UnparseableValue, UnwriteableValue
 from ..command_class import CommandClassInfo
 from ..device_class import DeviceClass
 from ..device_config import DeviceConfig
@@ -50,7 +45,6 @@ from ..value import (
     ValueMetadata,
     ValueNotification,
     _get_value_id_str_from_dict,
-    _init_value,
 )
 from .data_model import NodeDataType
 from .event_model import NODE_EVENT_MODEL_MAP
@@ -139,6 +133,12 @@ class Node(EventBase):
             self.client.driver == other.client.driver and self.node_id == other.node_id
         )
 
+    def _init_value(self, val: ValueDataType) -> Value | ConfigurationValue:
+        """Initialize a Value object from ValueDataType."""
+        if val["commandClass"] == CommandClass.CONFIGURATION:
+            return ConfigurationValue(self, val)
+        return Value(self, val)
+
     @property
     def node_id(self) -> int:
         """Return node ID property."""
@@ -429,7 +429,7 @@ class Node(EventBase):
                 if value_id in self.values:
                     self.values[value_id].update(val)
                 else:
-                    self.values[value_id] = _init_value(self, val)
+                    self.values[value_id] = self._init_value(val)
             except UnparseableValue:
                 # If we can't parse the value, don't store it
                 pass
@@ -448,8 +448,9 @@ class Node(EventBase):
         )
         if last_seen := data.get("lastSeen"):
             self._last_seen = datetime.fromisoformat(last_seen)
-        if not self._statistics.last_seen:
+        if not self._statistics.last_seen and self.last_seen:
             self._statistics.last_seen = self.last_seen
+            self._statistics.data["lastSeen"] = self.last_seen.isoformat()
 
         self._update_values(self.data.pop("values"))
         self._update_endpoints(self.data.pop("endpoints"))
@@ -474,7 +475,7 @@ class Node(EventBase):
 
     def receive_event(self, event: Event) -> None:
         """Receive an event."""
-        NODE_EVENT_MODEL_MAP[event.type](**event.data)
+        NODE_EVENT_MODEL_MAP[event.type].from_dict(event.data)
 
         self._handle_event_protocol(event)
         event.data["node"] = self
@@ -593,12 +594,9 @@ class Node(EventBase):
         data = await self.async_send_command(
             "get_defined_value_ids", wait_for_result=True
         )
-
-        if data is None:
-            # We should never reach this code
-            raise FailedCommand("Command failed", "failed_command")
+        assert data
         return [
-            _init_value(self, cast(ValueDataType, value_id))
+            self._init_value(cast(ValueDataType, value_id))
             for value_id in data["valueIds"]
         ]
 
@@ -1061,7 +1059,7 @@ class Node(EventBase):
         value_id = _get_value_id_str_from_dict(self, evt_val_data)
         value = self.values.get(value_id)
         if value is None:
-            value = _init_value(self, evt_val_data)
+            value = self._init_value(evt_val_data)
             self.values[value.value_id] = event.data["value"] = value
         else:
             value.receive_event(event)

{zwave_js_server_python-0.56.0 → zwave_js_server_python-0.58.0}/zwave_js_server/model/node/event_model.py

@@ -32,6 +32,15 @@ class BaseNodeEventModel(BaseEventModel):
     source: Literal["node"]
     nodeId: int
 
+    @classmethod
+    def from_dict(cls, data: dict) -> BaseNodeEventModel:
+        """Initialize from dict."""
+        return cls(
+            source=data["source"],
+            event=data["event"],
+            nodeId=data["nodeId"],
+        )
+
 
 class AliveEventModel(BaseNodeEventModel):
     """Model for `alive` event data."""
@@ -50,6 +59,18 @@ class CheckHealthProgressEventModel(BaseNodeEventModel):
     totalRounds: int
     lastRating: int
 
+    @classmethod
+    def from_dict(cls, data: dict) -> CheckHealthProgressEventModel:
+        """Initialize from dict."""
+        return cls(
+            source=data["source"],
+            event=data["event"],
+            nodeId=data["nodeId"],
+            rounds=data["rounds"],
+            totalRounds=data["totalRounds"],
+            lastRating=data["lastRating"],
+        )
+
 
 class CheckLifelineHealthProgressEventModel(CheckHealthProgressEventModel):
     """Model for `check lifeline health progress` event data."""
@@ -83,6 +104,19 @@ class InterviewFailedEventArgsModel(BaseModel):
     attempt: int | None
     maxAttempts: int | None
 
+    @classmethod
+    def from_dict(cls, data: dict) -> InterviewFailedEventArgsModel:
+        """Initialize from dict."""
+        return cls(
+            source=data["source"],
+            event=data["event"],
+            nodeId=data["nodeId"],
+            errorMessage=data["errorMessage"],
+            isFinal=data["isFinal"],
+            attempt=data["attempt"],
+            maxAttempts=data["maxAttempts"],
+        )
+
 
 class InterviewFailedEventModel(BaseNodeEventModel):
     """Model for `interview failed` event data."""
@@ -90,6 +124,16 @@ class InterviewFailedEventModel(BaseNodeEventModel):
     event: Literal["interview failed"]
     args: InterviewFailedEventArgsModel
 
+    @classmethod
+    def from_dict(cls, data: dict) -> InterviewFailedEventModel:
+        """Initialize from dict."""
+        return cls(
+            source=data["source"],
+            event=data["event"],
+            nodeId=data["nodeId"],
+            args=data["args"],
+        )
+
 
 class InterviewStageCompletedEventModel(BaseNodeEventModel):
     """Model for `interview stage completed` event data."""
@@ -97,6 +141,16 @@ class InterviewStageCompletedEventModel(BaseNodeEventModel):
     event: Literal["interview stage completed"]
     stageName: str
 
+    @classmethod
+    def from_dict(cls, data: dict) -> InterviewStageCompletedEventModel:
+        """Initialize from dict."""
+        return cls(
+            source=data["source"],
+            event=data["event"],
+            nodeId=data["nodeId"],
+            stageName=data["stageName"],
+        )
+
 
 class InterviewStartedEventModel(BaseNodeEventModel):
     """Model for `interview started` event data."""
@@ -118,6 +172,18 @@ class NotificationEventModel(BaseNodeEventModel):
         | MultilevelSwitchNotificationArgsDataType
     )
 
+    @classmethod
+    def from_dict(cls, data: dict) -> NotificationEventModel:
+        """Initialize from dict."""
+        return cls(
+            source=data["source"],
+            event=data["event"],
+            nodeId=data["nodeId"],
+            endpointIndex=data["endpointIndex"],
+            ccId=data["ccId"],
+            args=data["args"],
+        )
+
 
 class ReadyEventModel(BaseNodeEventModel):
     """Model for `ready` event data."""
@@ -125,6 +191,16 @@ class ReadyEventModel(BaseNodeEventModel):
     event: Literal["ready"]
     nodeState: NodeDataType
 
+    @classmethod
+    def from_dict(cls, data: dict) -> ReadyEventModel:
+        """Initialize from dict."""
+        return cls(
+            source=data["source"],
+            event=data["event"],
+            nodeId=data["nodeId"],
+            nodeState=data["nodeState"],
+        )
+
 
 class SleepEventModel(BaseNodeEventModel):
     """Model for `sleep` event data."""
@@ -138,6 +214,16 @@ class StatisticsUpdatedEventModel(BaseNodeEventModel):
     event: Literal["statistics updated"]
     statistics: NodeStatisticsDataType
 
+    @classmethod
+    def from_dict(cls, data: dict) -> StatisticsUpdatedEventModel:
+        """Initialize from dict."""
+        return cls(
+            source=data["source"],
+            event=data["event"],
+            nodeId=data["nodeId"],
+            statistics=data["statistics"],
+        )
+
 
 class TestPowerLevelProgressEventModel(BaseNodeEventModel):
     """Model for `test powerlevel progress` event data."""
@@ -146,6 +232,17 @@ class TestPowerLevelProgressEventModel(BaseNodeEventModel):
     acknowledged: int
     total: int
 
+    @classmethod
+    def from_dict(cls, data: dict) -> TestPowerLevelProgressEventModel:
+        """Initialize from dict."""
+        return cls(
+            source=data["source"],
+            event=data["event"],
+            nodeId=data["nodeId"],
+            acknowledged=data["acknowledged"],
+            total=data["total"],
+        )
+
 
 class ValueEventModel(BaseNodeEventModel):
     """
@@ -157,6 +254,16 @@ class ValueEventModel(BaseNodeEventModel):
 
     args: ValueDataType
 
+    @classmethod
+    def from_dict(cls, data: dict) -> ValueEventModel:
+        """Initialize from dict."""
+        return cls(
+            source=data["source"],
+            event=data["event"],
+            nodeId=data["nodeId"],
+            args=data["args"],
+        )
+
 
 class MetadataUpdatedEventModel(ValueEventModel):
     """Model for `metadata updated` event data."""
@@ -200,6 +307,16 @@ class FirmwareUpdateFinishedEventModel(BaseNodeEventModel):
     event: Literal["firmware update finished"]
     result: NodeFirmwareUpdateResultDataType
 
+    @classmethod
+    def from_dict(cls, data: dict) -> FirmwareUpdateFinishedEventModel:
+        """Initialize from dict."""
+        return cls(
+            source=data["source"],
+            event=data["event"],
+            nodeId=data["nodeId"],
+            result=data["result"],
+        )
+
 
 class FirmwareUpdateProgressEventModel(BaseNodeEventModel):
     """Model for `firmware update progress` event data."""
@@ -207,6 +324,16 @@ class FirmwareUpdateProgressEventModel(BaseNodeEventModel):
     event: Literal["firmware update progress"]
     progress: NodeFirmwareUpdateProgressDataType
 
+    @classmethod
+    def from_dict(cls, data: dict) -> FirmwareUpdateProgressEventModel:
+        """Initialize from dict."""
+        return cls(
+            source=data["source"],
+            event=data["event"],
+            nodeId=data["nodeId"],
+            progress=data["progress"],
+        )
+
 
 NODE_EVENT_MODEL_MAP: dict[str, type[BaseNodeEventModel]] = {
     "alive": AliveEventModel,

{zwave_js_server_python-0.56.0 → zwave_js_server_python-0.58.0}/zwave_js_server/model/node/firmware.py

@@ -213,7 +213,11 @@ class NodeFirmwareUpdateFileInfo:
         cls, data: NodeFirmwareUpdateFileInfoDataType
     ) -> NodeFirmwareUpdateFileInfo:
         """Initialize from dict."""
-        return cls(**data)
+        return cls(
+            target=data["target"],
+            url=data["url"],
+            integrity=data["integrity"],
+        )
 
     def to_dict(self) -> NodeFirmwareUpdateFileInfoDataType:
         """Return dict representation of the object."""

{zwave_js_server_python-0.56.0 → zwave_js_server_python-0.58.0}/zwave_js_server/model/value.py

@@ -8,7 +8,6 @@ from typing import TYPE_CHECKING, Any, TypedDict
 
 from ..const import (
     VALUE_UNKNOWN,
-    CommandClass,
     CommandStatus,
     ConfigurationValueType,
     SetValueStatus,
@@ -75,13 +74,6 @@ class ValueDataType(TypedDict, total=False):
     ccVersion: int  # required
 
 
-def _init_value(node: Node, val: ValueDataType) -> Value | ConfigurationValue:
-    """Initialize a Value object from ValueDataType."""
-    if val["commandClass"] == CommandClass.CONFIGURATION:
-        return ConfigurationValue(node, val)
-    return Value(node, val)
-
-
 def _get_value_id_str_from_dict(node: Node, val: ValueDataType) -> str:
     """Return string ID of value from ValueDataType dict."""
     return get_value_id_str(

{zwave_js_server_python-0.56.0 → zwave_js_server_python-0.58.0}/zwave_js_server_python.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: zwave-js-server-python
-Version: 0.56.0
+Version: 0.58.0
 Summary: Python wrapper for zwave-js-server
 Author-email: Home Assistant Team <hello@home-assistant.io>
 License:                                  Apache License
@@ -212,9 +212,9 @@ Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: Natural Language :: English
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
 Classifier: Topic :: Home Automation
-Requires-Python: >=3.11
+Requires-Python: >=3.12
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: aiohttp>3