zwave-js-server-python 0.57.0__tar.gz → 0.58.1__tar.gz

{zwave_js_server_python-0.57.0 → zwave_js_server_python-0.58.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: zwave-js-server-python
-Version: 0.57.0
+Version: 0.58.1
 Summary: Python wrapper for zwave-js-server
 Author-email: Home Assistant Team <hello@home-assistant.io>
 License:                                  Apache License

{zwave_js_server_python-0.57.0 → zwave_js_server_python-0.58.1}/pyproject.toml

@@ -84,10 +84,27 @@ max-attributes = 15
 [tool.pylint.FORMAT]
 expected-line-ending-format = "LF"
 
+[tool.pylint.MESSAGE_CONTROL]
+disable="too-many-positional-arguments"
+
 [tool.pytest.ini_options]
 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 +121,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.57.0 → zwave_js_server_python-0.58.1}/zwave_js_server/const/__init__.py

@@ -8,12 +8,12 @@ import logging
 from typing import TypedDict
 
 PACKAGE_NAME = "zwave-js-server-python"
-__version__ = "0.57.0"
+__version__ = "0.58.1"
 
 # minimal server schema version we can handle
-MIN_SERVER_SCHEMA_VERSION = 36
+MIN_SERVER_SCHEMA_VERSION = 37
 # max server schema version we can handle (and our code is compatible with)
-MAX_SERVER_SCHEMA_VERSION = 36
+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.57.0 → zwave_js_server_python-0.58.1}/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.57.0 → zwave_js_server_python-0.58.1}/zwave_js_server/const/command_class/meter.py

@@ -14,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.57.0 → zwave_js_server_python-0.58.1}/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:
@@ -74,4 +82,4 @@ class EventBase:
         if handler is None:
             LOGGER.debug("Received unknown event: %s", event)
             return
-        handler(event)
+        handler(event)  # pylint: disable=not-callable

{zwave_js_server_python-0.57.0 → zwave_js_server_python-0.58.1}/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.57.0 → zwave_js_server_python-0.58.1}/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.57.0 → zwave_js_server_python-0.58.1}/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.57.0 → zwave_js_server_python-0.58.1}/zwave_js_server/model/controller/event_model.py

@@ -4,7 +4,7 @@ from __future__ import annotations
 
 from typing import Literal, TypedDict
 
-from ...const import RemoveNodeReason
+from ...const import InclusionStrategy, RemoveNodeReason
 from ...event import BaseEventModel
 from ..node.data_model import FoundNodeDataType, NodeDataType
 from .firmware import (
@@ -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."""
@@ -97,7 +142,16 @@ class InclusionStartedEventModel(BaseControllerEventModel):
     """Model for `inclusion started` event data."""
 
     event: Literal["inclusion started"]
-    secure: bool
+    strategy: InclusionStrategy
+
+    @classmethod
+    def from_dict(cls, data: dict) -> InclusionStartedEventModel:
+        """Initialize from dict."""
+        return cls(
+            source=data["source"],
+            event=data["event"],
+            strategy=data["strategy"],
+        )
 
 
 class InclusionStoppedEventModel(BaseControllerEventModel):
@@ -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.57.0 → zwave_js_server_python-0.58.1}/zwave_js_server/model/device_class.py

@@ -38,9 +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._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:

{zwave_js_server_python-0.57.0 → zwave_js_server_python-0.58.1}/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.57.0 → zwave_js_server_python-0.58.1}/zwave_js_server/model/node/__init__.py

@@ -475,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

{zwave_js_server_python-0.57.0 → zwave_js_server_python-0.58.1}/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.57.0 → zwave_js_server_python-0.58.1}/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.57.0 → zwave_js_server_python-0.58.1}/zwave_js_server_python.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: zwave-js-server-python
-Version: 0.57.0
+Version: 0.58.1
 Summary: Python wrapper for zwave-js-server
 Author-email: Home Assistant Team <hello@home-assistant.io>
 License:                                  Apache License