zwave-js-server-python 0.56.0__py3-none-any.whl → 0.58.0__py3-none-any.whl

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/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/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/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/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/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/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/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/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/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/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/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/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/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/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.dist-info → zwave_js_server_python-0.58.0.dist-info}/METADATA

@@ -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.dist-info → zwave_js_server_python-0.58.0.dist-info}/RECORD

@@ -2,12 +2,12 @@ zwave_js_server/__init__.py,sha256=Ey3O4Tha56uU-M92oLJmQHupCJ7B9oZmxlQTo8pGUM8,4
 zwave_js_server/__main__.py,sha256=X6Zdbtv6QmYjsWeQ5OvtIRhtEyT1o3o0XvAmXtRrgoY,3659
 zwave_js_server/client.py,sha256=i9TaYZ8SArj1P1Z2HeAFnKr43dmXYXPJmPVFNxQ8ZIw,19829
 zwave_js_server/dump.py,sha256=ZBhkC07ndrFd784zpogfjRJtAdEh8-y8ZycvrGf34sE,1523
-zwave_js_server/event.py,sha256=EgNBgCNqPpRIL3zPQnRcPSfotdM-naYTqBH4r1gF4MM,2197
+zwave_js_server/event.py,sha256=xsF_4mCVMWpEiVV-LNCST9kSqNt3hni4EV3ZT7qrQrw,2403
 zwave_js_server/exceptions.py,sha256=8SY6FA8NiTEQgtauLR83F7m69gBGQviJ6O2obirH2po,6148
 zwave_js_server/firmware.py,sha256=KXB_-MgBDlNg289bPibUeWtF4l8WtEq9jmiFFMYg1KM,2381
 zwave_js_server/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 zwave_js_server/version.py,sha256=PUwxOVcUMk5pOguQP9zAjiPjs1Nnmiwj3fcA4HJLiBg,401
-zwave_js_server/const/__init__.py,sha256=I43CH0L33AQUFVVDh48FDO6sIt-aZBtRALQHgauPBRE,13808
+zwave_js_server/const/__init__.py,sha256=EFn6K6Pq2LG-iO0UWb0mm1SaZ5EbEm1j7BQvL3R-jek,14263
 zwave_js_server/const/command_class/__init__.py,sha256=WilOppnr9CXahDjEEkAXyh_j7iCq_qZ1GtBkjWLoQUg,37
 zwave_js_server/const/command_class/barrier_operator.py,sha256=IJ195hGKEi1FLLqKWMtC2ZhY9Jt5PACr7GYTyVPjkKM,820
 zwave_js_server/const/command_class/basic.py,sha256=cs0k7p5qxrwpR8-NvXQLtnfEsC6IlBAYiW79DaM_6Eg,96
@@ -16,8 +16,8 @@ zwave_js_server/const/command_class/color_switch.py,sha256=tuKpgZSERdcVxo48YheeR
 zwave_js_server/const/command_class/energy_production.py,sha256=Ah9Zzb3EHFrN28v-DrblXVS9I40VnhO57fLyq-d-zBk,1501
 zwave_js_server/const/command_class/entry_control.py,sha256=WetdiEx0K4QaasYS1wEYndxz5lFqpvVcLR5Slz03T1s,972
 zwave_js_server/const/command_class/humidity_control.py,sha256=AtrhAaDst7LC7c-PZeLmdgoo5D6996PfwuJrdni-yr8,1894
-zwave_js_server/const/command_class/lock.py,sha256=HTLnjVYrLnGbWhrvETeaCbHXKemklDfzOHsD4D0uHh4,6629
-zwave_js_server/const/command_class/meter.py,sha256=l_ys_r5lOGGxW-XfdgSobS3QxPsaVp3hV8Jm9dl3a_A,3998
+zwave_js_server/const/command_class/lock.py,sha256=0HtTwW6ifAeCk3FhupCXRIKOvvay_w1Lc6w83FACZtY,6706
+zwave_js_server/const/command_class/meter.py,sha256=OY5QeAViJnlwjLeDO-_CgTi9JD5r0hpu8ofMbuc2iyw,4070
 zwave_js_server/const/command_class/multilevel_sensor.py,sha256=Js5ZIORRkGAEfJa491m91Jf8L0Owxg9ibUBQTSaUSP4,37067
 zwave_js_server/const/command_class/multilevel_switch.py,sha256=yBDE9O9Ad1eMK_rgqs7l-DPJxnB-fi9CGclgpFc-QRk,576
 zwave_js_server/const/command_class/notification.py,sha256=psLLSYNsBaKq3lEOTXdChvLrNPwZK2CD3BCGWmD1QGs,37899
@@ -29,11 +29,11 @@ zwave_js_server/const/command_class/thermostat.py,sha256=VqgKCF_Itfdq29cCzA0hN_K
 zwave_js_server/const/command_class/wake_up.py,sha256=Rvnr1-_BPmWe8-dxpBoqEMo9feew5imdtZar5a9C9H8,175
 zwave_js_server/const/command_class/window_covering.py,sha256=o2_CBQ5DSbDNmJQxrcCH8pUXPNGMyGZTtlgUA-7SbYE,2088
 zwave_js_server/model/__init__.py,sha256=XfyKH8lxZ3CB7CbRkOr5sR-eV0GrklZiBtNPmlnCJ_8,123
-zwave_js_server/model/association.py,sha256=nRFEC2ysQlIq3Xezh9Hqx9BTdL0b5PNDN7XguIKhhvU,527
-zwave_js_server/model/command_class.py,sha256=_YimyLtb3aFHdhbYURNZZQlAf-lc3CC8HW8Vbk-Vrqc,1263
-zwave_js_server/model/device_class.py,sha256=owVKlFjQ32O3qrOiL6QruVKLfzMjS9Id_s-oGInf4eY,1964
+zwave_js_server/model/association.py,sha256=4rpf8PbafCYCfNJGISAmnpfcvJZTo_jPDGm2M-BuiPk,878
+zwave_js_server/model/command_class.py,sha256=SDTyGKlz5tDUoBb4RgKwPGwPuJvZ77a_q2EllN4bnzU,1394
+zwave_js_server/model/device_class.py,sha256=WTeYuR9PoIMzfjNhE21XIlHoTA9yDNEuRPkFS1W6nts,1609
 zwave_js_server/model/device_config.py,sha256=PV13U1T0zlBJ4CvoLziFW2SUJHHumYiez-n2qOapaQw,6423
-zwave_js_server/model/driver.py,sha256=w4PXh90OYSI7hEHA7VjIMYrY-NS-wV32H5u2ykrdTLI,6518
+zwave_js_server/model/driver.py,sha256=6g-8VmrCGLJuPa2O1NNdTaHNMxqMwnXbgzUIhQCRcl8,6779
 zwave_js_server/model/duration.py,sha256=OW2OqReexL6GXxxLs__i5Vs3JCVoODgLpwPHU48yynU,1153
 zwave_js_server/model/endpoint.py,sha256=0ZbT3I82xcCH-GRx_6MDgyNJB1bUBpFtSsU0slOpUeM,12609
 zwave_js_server/model/log_config.py,sha256=uF7gJlr2dSBP2mBMYzOyFiV_T45PwGU98AM5c7qs2g0,1574
@@ -41,19 +41,19 @@ zwave_js_server/model/log_message.py,sha256=SNicnss7LUZd6woMecNQ0ZKwghC9OmxNdA1v
 zwave_js_server/model/notification.py,sha256=-M9MZ1RUWmUCHuIU_So6h5sYhMILKxntGx3zBkKaqeo,6165
 zwave_js_server/model/statistics.py,sha256=in7S8oxWlG38tCEz1k3lxLjEsfY5yfsnD0bolcEeuHg,3233
 zwave_js_server/model/utils.py,sha256=VMoJQ99QRkpJleJhXR4eojbgObdZZeEfse5gonmK7Ic,1157
-zwave_js_server/model/value.py,sha256=7vr5CYV2TC5I593ww1CBJvM1GzpTFM31qfkYZto6_K0,13552
+zwave_js_server/model/value.py,sha256=Ku_VnX79WL82SD6Up01qQUNRldnCvi37HeEuTrTdBPU,13266
 zwave_js_server/model/version.py,sha256=EnyL6O8r2gSv7qLIuZ-sWnybG5JnJWw-IEE5UtIUjiM,1272
-zwave_js_server/model/controller/__init__.py,sha256=HkVk2on8qljAvYw7jcSHv2p1lIs0UDD1QDu20J4SRdo,36544
+zwave_js_server/model/controller/__init__.py,sha256=MMABFVu7GG1rYywM01gHWokGBpcwI1i-DmTunT20TBo,36653
 zwave_js_server/model/controller/data_model.py,sha256=5e6M0t7RkSJytovmDz1tULMFFoCQ1TsGHe56scrZRqI,851
-zwave_js_server/model/controller/event_model.py,sha256=-pqe316I7MVdIm8btovsw5ZXZbillDyH7AnGoYtvZWg,6207
+zwave_js_server/model/controller/event_model.py,sha256=FUU9PzVUO9ouOVldzKmBndBI4I3Z9Dv2cPnGFT0Yt-c,10172
 zwave_js_server/model/controller/firmware.py,sha256=GnctTeLitmUVf3wfJgZsDBAlQP4eDU6ytohXqigjGEg,2907
-zwave_js_server/model/controller/inclusion_and_provisioning.py,sha256=Vq8uDujGkt_oaPKV4F8RdcM1eCCJKBSvbYlnI0qHYK8,7491
+zwave_js_server/model/controller/inclusion_and_provisioning.py,sha256=PAO5HQE_yyTMxoVN3Woth1qC_oL6EzJNJ7NEvMtpBEA,7667
 zwave_js_server/model/controller/rebuild_routes.py,sha256=ElAZdSLiDaQLbGgfJQMnuilTpsSbCz3qag3lFBt2JoM,1073
 zwave_js_server/model/controller/statistics.py,sha256=iU2wiRvWvHzYGwydOqs8Y7CBdKA3DgL6tI1NW1zBTfU,4672
-zwave_js_server/model/node/__init__.py,sha256=N3fBQImgnNzCDVsmc3NnTApZV8lirusdn-SNoJcAHNY,40911
+zwave_js_server/model/node/__init__.py,sha256=6YZd1Xo-ZNrd2AB0OgY2X3VWJNQLl4E6NAzNvX0THAo,41118
 zwave_js_server/model/node/data_model.py,sha256=sQp0Mlp0SBkPv170cD0MjIX4BAMmrr4HtTZaKbIA0kQ,1845
-zwave_js_server/model/node/event_model.py,sha256=Xaw_P3IlefSA-sFCJSJE4qmYeptQGSuYHNlnYPJlImg,6281
-zwave_js_server/model/node/firmware.py,sha256=rPWNYSxHpxviZ2272r_FY8WdAv-qMurXNOsFlAyZDuA,10106
+zwave_js_server/model/node/event_model.py,sha256=mSRqCIBt6LXvCmMaOGmWz_cLrfPqot_ScZLmVr_z2w4,10055
+zwave_js_server/model/node/firmware.py,sha256=jF1CrI6hnETj8oZsXuwQVnIkTJ9qQ8uJEdY7JAthpC0,10214
 zwave_js_server/model/node/health_check.py,sha256=GuDFPfk5BL7aK4q5aEtGcpyZz_F-aLEIGeVw_4shq5E,5341
 zwave_js_server/model/node/statistics.py,sha256=f8JElpXEtT7y9cLhH6UhOGVwrGprtfL5GQX1VIKAGcQ,2871
 zwave_js_server/util/__init__.py,sha256=ArF1K885aW0GdVd7Lo8fl8Atf70gvsxO5Ra_WoJTG28,42
@@ -65,9 +65,9 @@ zwave_js_server/util/command_class/__init__.py,sha256=sRxti47ekLTzfk8B609CMQumIb
 zwave_js_server/util/command_class/energy_production.py,sha256=K1VmGDlqXmKDfQRpTu5o99sjnDShBMV_crEb49o-O_4,1489
 zwave_js_server/util/command_class/meter.py,sha256=tJ7rbwWUZbJCS7xEJWS_KnqUUGR8RN0f2S8iLkufae0,1258
 zwave_js_server/util/command_class/multilevel_sensor.py,sha256=wG4GQ0kjrP6d3x5DpEkUHrZd8-0LbvXoYdIxZAf6bso,1427
-zwave_js_server_python-0.56.0.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-zwave_js_server_python-0.56.0.dist-info/METADATA,sha256=HBXTuqRHL0PW8e7p55c4cuZeCdGDZkBgv2U_EWOxdxc,14767
-zwave_js_server_python-0.56.0.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-zwave_js_server_python-0.56.0.dist-info/entry_points.txt,sha256=lvzma7Rd_3FW_k-_xGuTfpvcvA2MR_22DOz5f1t7-xg,73
-zwave_js_server_python-0.56.0.dist-info/top_level.txt,sha256=-hwsl-i4Av5Op_yfOHC_OP56KPmzp_iVEkeohRIN5Ng,16
-zwave_js_server_python-0.56.0.dist-info/RECORD,,
+zwave_js_server_python-0.58.0.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+zwave_js_server_python-0.58.0.dist-info/METADATA,sha256=Al2giY0YNUq8pRiPN2g9o74p7-o1JSV5KfcI30UDaRA,14767
+zwave_js_server_python-0.58.0.dist-info/WHEEL,sha256=cVxcB9AmuTcXqmwrtPhNK88dr7IR_b6qagTj0UvIEbY,91
+zwave_js_server_python-0.58.0.dist-info/entry_points.txt,sha256=lvzma7Rd_3FW_k-_xGuTfpvcvA2MR_22DOz5f1t7-xg,73
+zwave_js_server_python-0.58.0.dist-info/top_level.txt,sha256=-hwsl-i4Av5Op_yfOHC_OP56KPmzp_iVEkeohRIN5Ng,16
+zwave_js_server_python-0.58.0.dist-info/RECORD,,

{zwave_js_server_python-0.56.0.dist-info → zwave_js_server_python-0.58.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.43.0)
+Generator: setuptools (74.1.2)
 Root-Is-Purelib: true
 Tag: py3-none-any