zwave-js-server-python 0.44.0__py3-none-any.whl → 0.45.0__py3-none-any.whl

zwave_js_server/client.py

@@ -404,7 +404,7 @@ class Client:
                     "record_type": "event",
                     "ts": datetime.utcnow().isoformat(),
                     "type": msg["event"]["event"],
-                    "event": deepcopy(msg),
+                    "event_msg": deepcopy(msg),
                 }
             )
 

zwave_js_server/const/__init__.py

@@ -7,9 +7,9 @@ PACKAGE_NAME = "zwave-js-server-python"
 __version__ = metadata.version(PACKAGE_NAME)
 
 # minimal server schema version we can handle
-MIN_SERVER_SCHEMA_VERSION = 24
+MIN_SERVER_SCHEMA_VERSION = 25
 # max server schema version we can handle (and our code is compatible with)
-MAX_SERVER_SCHEMA_VERSION = 24
+MAX_SERVER_SCHEMA_VERSION = 25
 
 TYPING_EXTENSION_FOR_TYPEDDICT_REQUIRED = sys.version_info < (3, 9, 2)
 

zwave_js_server/firmware.py

@@ -16,7 +16,7 @@ async def update_firmware(
     session: aiohttp.ClientSession,
     additional_user_agent_components: Optional[Dict[str, str]] = None,
 ) -> bool:
-    """Send beginFirmwareUpdate command to Node."""
+    """Send updateFirmware command to Node."""
     client = Client(
         url, session, additional_user_agent_components=additional_user_agent_components
     )
@@ -37,3 +37,38 @@ async def update_firmware(
         receive_task.cancel()
 
     return cast(bool, data["success"])
+
+
+async def controller_firmware_update_otw(
+    url: str,
+    firmware_file: FirmwareUpdateData,
+    session: aiohttp.ClientSession,
+    additional_user_agent_components: Optional[Dict[str, str]] = None,
+) -> bool:
+    """
+    Send firmwareUpdateOTW command to Controller.
+
+    Sending the wrong firmware to a controller can brick it and make it unrecoverable.
+    Consumers of this library should build mechanisms to ensure that users understand
+    the risks.
+    """
+    client = Client(
+        url, session, additional_user_agent_components=additional_user_agent_components
+    )
+    await client.connect()
+    await client.initialize()
+
+    receive_task = asyncio.get_running_loop().create_task(client.receive_until_closed())
+
+    data = await client.async_send_command(
+        {
+            "command": "controller.firmware_update_otw",
+            **firmware_file.to_dict(),
+        },
+        require_schema=25,
+    )
+    await client.disconnect()
+    if not receive_task.done():
+        receive_task.cancel()
+
+    return cast(bool, data["success"])

zwave_js_server/model/controller/__init__.py

@@ -2,7 +2,10 @@
 from dataclasses import dataclass
 from typing import TYPE_CHECKING, Any, Dict, List, Literal, Optional, Union, cast
 
-from zwave_js_server.model.firmware import FirmwareUpdateFileInfo, FirmwareUpdateInfo
+from zwave_js_server.model.node.firmware import (
+    NodeFirmwareUpdateFileInfo,
+    NodeFirmwareUpdateInfo,
+)
 
 from ...const import (
     MINIMUM_QR_STRING_LENGTH,
@@ -20,6 +23,7 @@ from ..association import AssociationAddress, AssociationGroup
 from ..node import Node
 from .data_model import ControllerDataType
 from .event_model import CONTROLLER_EVENT_MODEL_MAP
+from .firmware import ControllerFirmwareUpdateProgress, ControllerFirmwareUpdateResult
 from .inclusion_and_provisioning import (
     InclusionGrant,
     ProvisioningEntry,
@@ -88,6 +92,13 @@ class Controller(EventBase):
         """Return own_node_id."""
         return self.data.get("ownNodeId")
 
+    @property
+    def own_node(self) -> Optional[Node]:
+        """Return own_node."""
+        if self.own_node_id is None:
+            return None
+        return self.nodes.get(self.own_node_id)
+
     @property
     def is_primary(self) -> Optional[bool]:
         """Return is_primary."""
@@ -175,6 +186,13 @@ class Controller(EventBase):
         """Return inclusion state."""
         return InclusionState(self.data["inclusionState"])
 
+    @property
+    def rf_region(self) -> Optional[RFRegion]:
+        """Return RF region of controller."""
+        if (rf_region := self.data.get("rfRegion")) is None:
+            return None
+        return RFRegion(rf_region)
+
     def update(self, data: ControllerDataType) -> None:
         """Update controller data."""
         self.data = data
@@ -714,7 +732,7 @@ class Controller(EventBase):
 
     async def async_get_available_firmware_updates(
         self, node: Node, api_key: str, include_prereleases: bool = False
-    ) -> List[FirmwareUpdateInfo]:
+    ) -> List[NodeFirmwareUpdateInfo]:
         """Send getAvailableFirmwareUpdates command to Controller."""
         data = await self.client.async_send_command(
             {
@@ -726,10 +744,10 @@ class Controller(EventBase):
             require_schema=24,
         )
         assert data
-        return [FirmwareUpdateInfo.from_dict(update) for update in data["updates"]]
+        return [NodeFirmwareUpdateInfo.from_dict(update) for update in data["updates"]]
 
     async def async_firmware_update_ota(
-        self, node: Node, updates: List[FirmwareUpdateFileInfo]
+        self, node: Node, updates: List[NodeFirmwareUpdateFileInfo]
     ) -> bool:
         """Send firmwareUpdateOTA command to Controller."""
         data = await self.client.async_send_command(
@@ -766,6 +784,18 @@ class Controller(EventBase):
         event.data["controller"] = self
         self.emit(event.type, event.data)
 
+    def handle_firmware_update_progress(self, event: Event) -> None:
+        """Process a firmware update progress event."""
+        event.data["firmware_update_progress"] = ControllerFirmwareUpdateProgress(
+            event.data["progress"]
+        )
+
+    def handle_firmware_update_finished(self, event: Event) -> None:
+        """Process a firmware update finished event."""
+        event.data["firmware_update_finished"] = ControllerFirmwareUpdateResult(
+            event.data["result"]
+        )
+
     def handle_inclusion_failed(self, event: Event) -> None:
         """Process an inclusion failed event."""
 

zwave_js_server/model/controller/data_model.py

@@ -33,3 +33,4 @@ class ControllerDataType(TypedDict, total=False):
     isHealNetworkActive: bool
     statistics: ControllerStatisticsDataType
     inclusionState: int
+    rfRegion: int

zwave_js_server/model/controller/event_model.py

@@ -4,6 +4,7 @@ from typing import Dict, Literal, Type
 from ...const import TYPING_EXTENSION_FOR_TYPEDDICT_REQUIRED
 from ...event import BaseEventModel
 from ..node.data_model import FoundNodeDataType, NodeDataType
+from .firmware import ControllerFirmwareUpdateProgressDataType
 from .inclusion_and_provisioning import InclusionGrantDataType
 from .statistics import ControllerStatisticsDataType
 
@@ -43,6 +44,20 @@ class ExclusionStoppedEventModel(BaseControllerEventModel):
     event: Literal["exclusion stopped"]
 
 
+class FirmwareUpdateFinishedEventModel(BaseControllerEventModel):
+    """Model for `firmware update finished` event data."""
+
+    event: Literal["firmware update finished"]
+    result: int
+
+
+class FirmwareUpdateProgressEventModel(BaseControllerEventModel):
+    """Model for `firmware update progress` event data."""
+
+    event: Literal["firmware update progress"]
+    progress: ControllerFirmwareUpdateProgressDataType
+
+
 class GrantSecurityClassesEventModel(BaseControllerEventModel):
     """Model for `grant security classes` event data."""
 
@@ -157,6 +172,8 @@ CONTROLLER_EVENT_MODEL_MAP: Dict[str, Type["BaseControllerEventModel"]] = {
     "exclusion failed": ExclusionFailedEventModel,
     "exclusion started": ExclusionStartedEventModel,
     "exclusion stopped": ExclusionStoppedEventModel,
+    "firmware update finished": FirmwareUpdateFinishedEventModel,
+    "firmware update progress": FirmwareUpdateProgressEventModel,
     "grant security classes": GrantSecurityClassesEventModel,
     "heal network done": HealNetworkDoneEventModel,
     "heal network progress": HealNetworkProgressEventModel,

zwave_js_server/model/controller/firmware.py

@@ -0,0 +1,73 @@
+"""Provide a model for Z-Wave controller firmware."""
+from enum import IntEnum
+from typing import TypedDict
+
+
+class ControllerFirmwareUpdateStatus(IntEnum):
+    """Enum with all controller firmware update status values.
+
+    https://zwave-js.github.io/node-zwave-js/#/api/node?id=status
+    """
+
+    ERROR_TIMEOUT = 0
+    # The maximum number of retry attempts for a firmware fragments were reached
+    ERROR_RETRY_LIMIT_REACHED = 1
+    # The update was aborted by the bootloader
+    ERROR_ABORTED = 2
+    OK = 255
+
+
+class ControllerFirmwareUpdateProgressDataType(TypedDict):
+    """Represent a controller firmware update progress dict type."""
+
+    sentFragments: int
+    totalFragments: int
+    progress: float
+
+
+class ControllerFirmwareUpdateProgress:
+    """Model for a controller firmware update progress data."""
+
+    def __init__(self, data: ControllerFirmwareUpdateProgressDataType) -> None:
+        """Initialize."""
+        self.data = data
+
+    @property
+    def sent_fragments(self) -> int:
+        """Return the number of fragments sent to the device so far."""
+        return self.data["sentFragments"]
+
+    @property
+    def total_fragments(self) -> int:
+        """Return the total number of fragments that need to be sent to the device."""
+        return self.data["totalFragments"]
+
+    @property
+    def progress(self) -> float:
+        """Return progress."""
+        return float(self.data["progress"])
+
+
+class ControllerFirmwareUpdateResultDataType(TypedDict):
+    """Represent a controller firmware update result dict type."""
+
+    status: int
+    success: bool
+
+
+class ControllerFirmwareUpdateResult:
+    """Model for controller firmware update result data."""
+
+    def __init__(self, data: ControllerFirmwareUpdateResultDataType) -> None:
+        """Initialize."""
+        self.data = data
+
+    @property
+    def status(self) -> ControllerFirmwareUpdateStatus:
+        """Return the firmware update status."""
+        return ControllerFirmwareUpdateStatus(self.data["status"])
+
+    @property
+    def success(self) -> bool:
+        """Return whether the firmware update was successful."""
+        return self.data["success"]

zwave_js_server/model/driver.py

@@ -166,6 +166,18 @@ class Driver(EventBase):
         """Send command to enable Sentry error reporting."""
         await self._async_send_command("enable_error_reporting", require_schema=16)
 
+    async def async_hard_reset(self) -> None:
+        """Send command to hard reset controller."""
+        await self._async_send_command("hard_reset", require_schema=25)
+
+    async def async_try_soft_reset(self) -> None:
+        """Send command to try to soft reset controller."""
+        await self._async_send_command("try_soft_reset", require_schema=25)
+
+    async def async_soft_reset(self) -> None:
+        """Send command to soft reset controller."""
+        await self._async_send_command("soft_reset", require_schema=25)
+
     def handle_logging(self, event: Event) -> None:
         """Process a driver logging event."""
         event.data["log_message"] = LogMessage(cast(LogMessageDataType, event.data))

zwave_js_server/model/firmware.py

@@ -1,9 +1,8 @@
 """Provide a model for Z-Wave firmware."""
-from dataclasses import asdict, dataclass
-from enum import IntEnum
-from typing import TYPE_CHECKING, List, Optional, Union, cast
+from dataclasses import dataclass
+from typing import Optional
 
-from ..const import TYPING_EXTENSION_FOR_TYPEDDICT_REQUIRED, VALUE_UNKNOWN
+from ..const import TYPING_EXTENSION_FOR_TYPEDDICT_REQUIRED
 from ..util.helpers import convert_bytes_to_base64
 
 if TYPING_EXTENSION_FOR_TYPEDDICT_REQUIRED:
@@ -11,9 +10,6 @@ if TYPING_EXTENSION_FOR_TYPEDDICT_REQUIRED:
 else:
     from typing import TypedDict
 
-if TYPE_CHECKING:
-    from .node import Node
-
 
 class FirmwareUpdateDataDataType(TypedDict, total=False):
     """Represent a firmware update data dict type."""
@@ -40,222 +36,3 @@ class FirmwareUpdateData:
         if self.file_format is not None:
             data["fileFormat"] = self.file_format
         return data
-
-
-class FirmwareUpdateCapabilitiesDataType(TypedDict, total=False):
-    """Represent a firmware update capabilities dict type."""
-
-    firmwareUpgradable: bool  # required
-    firmwareTargets: List[int]
-    continuesToFunction: Union[bool, str]
-    supportsActivation: Union[bool, str]
-
-
-class FirmwareUpdateCapabilitiesDict(TypedDict, total=False):
-    """Represent a dict from FirmwareUpdateCapabilities."""
-
-    firmware_upgradable: bool  # required
-    firmware_targets: List[int]
-    continues_to_function: Optional[bool]
-    supports_activation: Optional[bool]
-
-
-class FirmwareUpdateCapabilities:
-    """Model for firmware update capabilities."""
-
-    def __init__(self, data: FirmwareUpdateCapabilitiesDataType) -> None:
-        """Initialize class."""
-        self.data = data
-
-    @property
-    def firmware_upgradable(self) -> bool:
-        """Return whether firmware is upgradable."""
-        return self.data["firmwareUpgradable"]
-
-    @property
-    def firmware_targets(self) -> List[int]:
-        """Return firmware targets."""
-        if not self.firmware_upgradable:
-            raise TypeError("Firmware is not upgradeable.")
-        return self.data["firmwareTargets"]
-
-    @property
-    def continues_to_function(self) -> Optional[bool]:
-        """Return whether node continues to function during update."""
-        if not self.firmware_upgradable:
-            raise TypeError("Firmware is not upgradeable.")
-        if (val := self.data["continuesToFunction"]) == VALUE_UNKNOWN:
-            return None
-        assert isinstance(val, bool)
-        return val
-
-    @property
-    def supports_activation(self) -> Optional[bool]:
-        """Return whether node supports delayed activation of the new firmware."""
-        if not self.firmware_upgradable:
-            raise TypeError("Firmware is not upgradeable.")
-        if (val := self.data["supportsActivation"]) == VALUE_UNKNOWN:
-            return None
-        assert isinstance(val, bool)
-        return val
-
-    def to_dict(self) -> FirmwareUpdateCapabilitiesDict:
-        """Return dict representation of the object."""
-        if not self.firmware_upgradable:
-            return {"firmware_upgradable": self.firmware_upgradable}
-        return {
-            "firmware_upgradable": self.firmware_upgradable,
-            "firmware_targets": self.firmware_targets,
-            "continues_to_function": self.continues_to_function,
-            "supports_activation": self.supports_activation,
-        }
-
-
-class FirmwareUpdateStatus(IntEnum):
-    """Enum with all Firmware update status values.
-
-    https://zwave-js.github.io/node-zwave-js/#/api/node?id=status
-    """
-
-    ERROR_TIMEOUT = -1
-    ERROR_CHECKSUM = 0
-    ERROR_TRANSMISSION_FAILED = 1
-    ERROR_INVALID_MANUFACTURER_ID = 2
-    ERROR_INVALID_FIRMWARE_ID = 3
-    ERROR_INVALID_FIRMWARE_TARGET = 4
-    ERROR_INVALID_HEADER_INFORMATION = 5
-    ERROR_INVALID_HEADER_FORMAT = 6
-    ERROR_INSUFFICIENT_MEMORY = 7
-    ERROR_INVALID_HARDWARE_VERSION = 8
-    OK_WAITING_FOR_ACTIVATION = 253
-    OK_NO_RESTART = 254
-    OK_RESTART_PENDING = 255
-
-
-class FirmwareUpdateProgressDataType(TypedDict):
-    """Represent a firmware update progress dict type."""
-
-    currentFile: int
-    totalFiles: int
-    sentFragments: int
-    totalFragments: int
-    progress: float
-
-
-class FirmwareUpdateProgress:
-    """Model for firmware update progress data."""
-
-    def __init__(self, node: "Node", data: FirmwareUpdateProgressDataType) -> None:
-        """Initialize."""
-        self.data = data
-        self.node = node
-
-    @property
-    def current_file(self) -> int:
-        """Return current file."""
-        return self.data["currentFile"]
-
-    @property
-    def total_files(self) -> int:
-        """Return total files."""
-        return self.data["totalFiles"]
-
-    @property
-    def sent_fragments(self) -> int:
-        """Return the number of fragments sent to the device so far."""
-        return self.data["sentFragments"]
-
-    @property
-    def total_fragments(self) -> int:
-        """Return the total number of fragments that need to be sent to the device."""
-        return self.data["totalFragments"]
-
-    @property
-    def progress(self) -> float:
-        """Return progress."""
-        return float(self.data["progress"])
-
-
-class FirmwareUpdateResultDataType(TypedDict, total=False):
-    """Represent a firmware update result dict type."""
-
-    status: int  # required
-    success: bool  # required
-    waitTime: int
-    reInterview: bool  # required
-
-
-class FirmwareUpdateResult:
-    """Model for firmware update result data."""
-
-    def __init__(self, node: "Node", data: FirmwareUpdateResultDataType) -> None:
-        """Initialize."""
-        self.data = data
-        self.node = node
-
-    @property
-    def status(self) -> FirmwareUpdateStatus:
-        """Return the firmware update status."""
-        return FirmwareUpdateStatus(self.data["status"])
-
-    @property
-    def success(self) -> bool:
-        """Return whether the firmware update was successful."""
-        return self.data["success"]
-
-    @property
-    def wait_time(self) -> Optional[int]:
-        """Return the wait time in seconds before the device is functional again."""
-        return self.data.get("waitTime")
-
-    @property
-    def reinterview(self) -> bool:
-        """Return whether the node will be re-interviewed."""
-        return self.data["reInterview"]
-
-
-class FirmwareUpdateFileInfoDataType(TypedDict):
-    """Represent a firmware update file info data dict type."""
-
-    target: int
-    url: str
-    integrity: str  # sha256
-
-
-@dataclass
-class FirmwareUpdateFileInfo:
-    """Represent a firmware update file info."""
-
-    target: int
-    url: str
-    integrity: str
-
-    def to_dict(self) -> FirmwareUpdateFileInfoDataType:
-        """Return dict representation of the object."""
-        return cast(FirmwareUpdateFileInfoDataType, asdict(self))
-
-
-class FirmwareUpdateInfoDataType(TypedDict):
-    """Represent a firmware update info data dict type."""
-
-    version: str
-    changelog: str
-    files: List[FirmwareUpdateFileInfoDataType]
-
-
-@dataclass
-class FirmwareUpdateInfo:
-    """Represent a firmware update info."""
-
-    version: str
-    changelog: str
-    files: List[FirmwareUpdateFileInfo]
-
-    @classmethod
-    def from_dict(cls, data: FirmwareUpdateInfoDataType) -> "FirmwareUpdateInfo":
-        """Initialize from dict."""
-        return cls(
-            version=data["version"],
-            changelog=data["changelog"],
-            files=[FirmwareUpdateFileInfo(**file) for file in data["files"]],
-        )

zwave_js_server/model/node/__init__.py

@@ -21,14 +21,6 @@ from ..command_class import CommandClassInfo
 from ..device_class import DeviceClass
 from ..device_config import DeviceConfig
 from ..endpoint import Endpoint
-from ..firmware import (
-    FirmwareUpdateCapabilities,
-    FirmwareUpdateCapabilitiesDataType,
-    FirmwareUpdateProgress,
-    FirmwareUpdateProgressDataType,
-    FirmwareUpdateResult,
-    FirmwareUpdateResultDataType,
-)
 from ..notification import (
     EntryControlNotification,
     EntryControlNotificationDataType,
@@ -51,6 +43,14 @@ from ..value import (
 )
 from .data_model import NodeDataType
 from .event_model import NODE_EVENT_MODEL_MAP
+from .firmware import (
+    NodeFirmwareUpdateCapabilities,
+    NodeFirmwareUpdateCapabilitiesDataType,
+    NodeFirmwareUpdateProgress,
+    NodeFirmwareUpdateProgressDataType,
+    NodeFirmwareUpdateResult,
+    NodeFirmwareUpdateResultDataType,
+)
 from .health_check import (
     CheckHealthProgress,
     LifelineHealthCheckSummary,
@@ -91,7 +91,7 @@ class Node(EventBase):
         self.data: NodeDataType = {}
         self._device_config = DeviceConfig({})
         self._statistics = NodeStatistics(client, data.get("statistics"))
-        self._firmware_update_progress: Optional[FirmwareUpdateProgress] = None
+        self._firmware_update_progress: Optional[NodeFirmwareUpdateProgress] = None
         self.values: Dict[str, Union[ConfigurationValue, Value]] = {}
         self.endpoints: Dict[int, Endpoint] = {}
         self.update(data)
@@ -309,7 +309,7 @@ class Node(EventBase):
         return self._statistics
 
     @property
-    def firmware_update_progress(self) -> Optional[FirmwareUpdateProgress]:
+    def firmware_update_progress(self) -> Optional[NodeFirmwareUpdateProgress]:
         """Return firmware update progress."""
         return self._firmware_update_progress
 
@@ -527,7 +527,7 @@ class Node(EventBase):
 
     async def async_get_firmware_update_capabilities(
         self,
-    ) -> FirmwareUpdateCapabilities:
+    ) -> NodeFirmwareUpdateCapabilities:
         """Send getFirmwareUpdateCapabilities command to Node."""
         data = await self.async_send_command(
             "get_firmware_update_capabilities",
@@ -535,13 +535,13 @@ class Node(EventBase):
             wait_for_result=True,
         )
         assert data
-        return FirmwareUpdateCapabilities(
-            cast(FirmwareUpdateCapabilitiesDataType, data["capabilities"])
+        return NodeFirmwareUpdateCapabilities(
+            cast(NodeFirmwareUpdateCapabilitiesDataType, data["capabilities"])
         )
 
     async def async_get_firmware_update_capabilities_cached(
         self,
-    ) -> FirmwareUpdateCapabilities:
+    ) -> NodeFirmwareUpdateCapabilities:
         """Send getFirmwareUpdateCapabilitiesCached command to Node."""
         data = await self.async_send_command(
             "get_firmware_update_capabilities_cached",
@@ -549,8 +549,8 @@ class Node(EventBase):
             wait_for_result=True,
         )
         assert data
-        return FirmwareUpdateCapabilities(
-            cast(FirmwareUpdateCapabilitiesDataType, data["capabilities"])
+        return NodeFirmwareUpdateCapabilities(
+            cast(NodeFirmwareUpdateCapabilitiesDataType, data["capabilities"])
         )
 
     async def async_abort_firmware_update(self) -> None:
@@ -905,15 +905,15 @@ class Node(EventBase):
         """Process a node firmware update progress event."""
         self._firmware_update_progress = event.data[
             "firmware_update_progress"
-        ] = FirmwareUpdateProgress(
-            self, cast(FirmwareUpdateProgressDataType, event.data["progress"])
+        ] = NodeFirmwareUpdateProgress(
+            self, cast(NodeFirmwareUpdateProgressDataType, event.data["progress"])
         )
 
     def handle_firmware_update_finished(self, event: Event) -> None:
         """Process a node firmware update finished event."""
         self._firmware_update_progress = None
-        event.data["firmware_update_finished"] = FirmwareUpdateResult(
-            self, cast(FirmwareUpdateResultDataType, event.data["result"])
+        event.data["firmware_update_finished"] = NodeFirmwareUpdateResult(
+            self, cast(NodeFirmwareUpdateResultDataType, event.data["result"])
         )
 
     def handle_statistics_updated(self, event: Event) -> None:

zwave_js_server/model/node/event_model.py

@@ -6,7 +6,6 @@ from pydantic import BaseModel
 from zwave_js_server.const import CommandClass
 
 from ...event import BaseEventModel
-from ..firmware import FirmwareUpdateProgressDataType, FirmwareUpdateResultDataType
 from ..notification import (
     EntryControlNotificationArgsDataType,
     NotificationNotificationArgsDataType,
@@ -14,6 +13,10 @@ from ..notification import (
 )
 from ..value import ValueDataType
 from .data_model import NodeDataType
+from .firmware import (
+    NodeFirmwareUpdateProgressDataType,
+    NodeFirmwareUpdateResultDataType,
+)
 from .statistics import NodeStatisticsDataType
 
 
@@ -186,14 +189,14 @@ class FirmwareUpdateFinishedEventModel(BaseNodeEventModel):
     """Model for `firmware update finished` event data."""
 
     event: Literal["firmware update finished"]
-    result: FirmwareUpdateResultDataType
+    result: NodeFirmwareUpdateResultDataType
 
 
 class FirmwareUpdateProgressEventModel(BaseNodeEventModel):
     """Model for `firmware update progress` event data."""
 
     event: Literal["firmware update progress"]
-    progress: FirmwareUpdateProgressDataType
+    progress: NodeFirmwareUpdateProgressDataType
 
 
 NODE_EVENT_MODEL_MAP: Dict[str, Type["BaseNodeEventModel"]] = {

zwave_js_server/model/node/firmware.py

@@ -0,0 +1,235 @@
+"""Provide a model for Z-Wave firmware."""
+from dataclasses import asdict, dataclass
+from enum import IntEnum
+from typing import TYPE_CHECKING, List, Optional, Union, cast
+
+from ...const import TYPING_EXTENSION_FOR_TYPEDDICT_REQUIRED, VALUE_UNKNOWN
+
+if TYPING_EXTENSION_FOR_TYPEDDICT_REQUIRED:
+    from typing_extensions import TypedDict
+else:
+    from typing import TypedDict
+
+if TYPE_CHECKING:
+    from . import Node
+
+
+class NodeFirmwareUpdateCapabilitiesDataType(TypedDict, total=False):
+    """Represent a firmware update capabilities dict type."""
+
+    firmwareUpgradable: bool  # required
+    firmwareTargets: List[int]
+    continuesToFunction: Union[bool, str]
+    supportsActivation: Union[bool, str]
+
+
+class NodeFirmwareUpdateCapabilitiesDict(TypedDict, total=False):
+    """Represent a dict from FirmwareUpdateCapabilities."""
+
+    firmware_upgradable: bool  # required
+    firmware_targets: List[int]
+    continues_to_function: Optional[bool]
+    supports_activation: Optional[bool]
+
+
+class NodeFirmwareUpdateCapabilities:
+    """Model for firmware update capabilities."""
+
+    def __init__(self, data: NodeFirmwareUpdateCapabilitiesDataType) -> None:
+        """Initialize class."""
+        self.data = data
+
+    @property
+    def firmware_upgradable(self) -> bool:
+        """Return whether firmware is upgradable."""
+        return self.data["firmwareUpgradable"]
+
+    @property
+    def firmware_targets(self) -> List[int]:
+        """Return firmware targets."""
+        if not self.firmware_upgradable:
+            raise TypeError("Firmware is not upgradeable.")
+        return self.data["firmwareTargets"]
+
+    @property
+    def continues_to_function(self) -> Optional[bool]:
+        """Return whether node continues to function during update."""
+        if not self.firmware_upgradable:
+            raise TypeError("Firmware is not upgradeable.")
+        if (val := self.data["continuesToFunction"]) == VALUE_UNKNOWN:
+            return None
+        assert isinstance(val, bool)
+        return val
+
+    @property
+    def supports_activation(self) -> Optional[bool]:
+        """Return whether node supports delayed activation of the new firmware."""
+        if not self.firmware_upgradable:
+            raise TypeError("Firmware is not upgradeable.")
+        if (val := self.data["supportsActivation"]) == VALUE_UNKNOWN:
+            return None
+        assert isinstance(val, bool)
+        return val
+
+    def to_dict(self) -> NodeFirmwareUpdateCapabilitiesDict:
+        """Return dict representation of the object."""
+        if not self.firmware_upgradable:
+            return {"firmware_upgradable": self.firmware_upgradable}
+        return {
+            "firmware_upgradable": self.firmware_upgradable,
+            "firmware_targets": self.firmware_targets,
+            "continues_to_function": self.continues_to_function,
+            "supports_activation": self.supports_activation,
+        }
+
+
+class NodeFirmwareUpdateStatus(IntEnum):
+    """Enum with all node firmware update status values.
+
+    https://zwave-js.github.io/node-zwave-js/#/api/node?id=status
+    """
+
+    ERROR_TIMEOUT = -1
+    ERROR_CHECKSUM = 0
+    ERROR_TRANSMISSION_FAILED = 1
+    ERROR_INVALID_MANUFACTURER_ID = 2
+    ERROR_INVALID_FIRMWARE_ID = 3
+    ERROR_INVALID_FIRMWARE_TARGET = 4
+    ERROR_INVALID_HEADER_INFORMATION = 5
+    ERROR_INVALID_HEADER_FORMAT = 6
+    ERROR_INSUFFICIENT_MEMORY = 7
+    ERROR_INVALID_HARDWARE_VERSION = 8
+    OK_WAITING_FOR_ACTIVATION = 253
+    OK_NO_RESTART = 254
+    OK_RESTART_PENDING = 255
+
+
+class NodeFirmwareUpdateProgressDataType(TypedDict):
+    """Represent a node firmware update progress dict type."""
+
+    currentFile: int
+    totalFiles: int
+    sentFragments: int
+    totalFragments: int
+    progress: float
+
+
+class NodeFirmwareUpdateProgress:
+    """Model for a node firmware update progress data."""
+
+    def __init__(self, node: "Node", data: NodeFirmwareUpdateProgressDataType) -> None:
+        """Initialize."""
+        self.data = data
+        self.node = node
+
+    @property
+    def current_file(self) -> int:
+        """Return current file."""
+        return self.data["currentFile"]
+
+    @property
+    def total_files(self) -> int:
+        """Return total files."""
+        return self.data["totalFiles"]
+
+    @property
+    def sent_fragments(self) -> int:
+        """Return the number of fragments sent to the device so far."""
+        return self.data["sentFragments"]
+
+    @property
+    def total_fragments(self) -> int:
+        """Return the total number of fragments that need to be sent to the device."""
+        return self.data["totalFragments"]
+
+    @property
+    def progress(self) -> float:
+        """Return progress."""
+        return float(self.data["progress"])
+
+
+class NodeFirmwareUpdateResultDataType(TypedDict, total=False):
+    """Represent a node firmware update result dict type."""
+
+    status: int  # required
+    success: bool  # required
+    waitTime: int
+    reInterview: bool  # required
+
+
+class NodeFirmwareUpdateResult:
+    """Model for node firmware update result data."""
+
+    def __init__(self, node: "Node", data: NodeFirmwareUpdateResultDataType) -> None:
+        """Initialize."""
+        self.data = data
+        self.node = node
+
+    @property
+    def status(self) -> NodeFirmwareUpdateStatus:
+        """Return the firmware update status."""
+        return NodeFirmwareUpdateStatus(self.data["status"])
+
+    @property
+    def success(self) -> bool:
+        """Return whether the firmware update was successful."""
+        return self.data["success"]
+
+    @property
+    def wait_time(self) -> Optional[int]:
+        """Return the wait time in seconds before the device is functional again."""
+        return self.data.get("waitTime")
+
+    @property
+    def reinterview(self) -> bool:
+        """Return whether the node will be re-interviewed."""
+        return self.data["reInterview"]
+
+
+class NodeFirmwareUpdateFileInfoDataType(TypedDict):
+    """Represent a firmware update file info data dict type."""
+
+    target: int
+    url: str
+    integrity: str  # sha256
+
+
+@dataclass
+class NodeFirmwareUpdateFileInfo:
+    """Represent a firmware update file info."""
+
+    target: int
+    url: str
+    integrity: str
+
+    def to_dict(self) -> NodeFirmwareUpdateFileInfoDataType:
+        """Return dict representation of the object."""
+        return cast(NodeFirmwareUpdateFileInfoDataType, asdict(self))
+
+
+class NodeFirmwareUpdateInfoDataType(TypedDict):
+    """Represent a firmware update info data dict type."""
+
+    version: str
+    changelog: str
+    files: List[NodeFirmwareUpdateFileInfoDataType]
+
+
+@dataclass
+class NodeFirmwareUpdateInfo:
+    """Represent a firmware update info."""
+
+    version: str
+    changelog: str
+    files: List[NodeFirmwareUpdateFileInfo]
+
+    @classmethod
+    def from_dict(
+        cls, data: NodeFirmwareUpdateInfoDataType
+    ) -> "NodeFirmwareUpdateInfo":
+        """Initialize from dict."""
+        return cls(
+            version=data["version"],
+            changelog=data["changelog"],
+            files=[NodeFirmwareUpdateFileInfo(**file) for file in data["files"]],
+        )

zwave_js_server/model/utils.py

@@ -1,4 +1,6 @@
 """Model for utils commands."""
+from typing import Optional
+
 from ..client import Client
 from ..const import MINIMUM_QR_STRING_LENGTH
 from .controller import QRProvisioningInformation
@@ -19,3 +21,13 @@ async def async_parse_qr_code_string(
         {"command": "utils.parse_qr_code_string", "qr": qr_code_string}
     )
     return QRProvisioningInformation.from_dict(data["qrProvisioningInformation"])
+
+
+async def async_try_parse_dsk_from_qr_code_string(
+    client: Client, qr_code_string: str
+) -> Optional[str]:
+    """Try to get DSK QR code."""
+    data = await client.async_send_command(
+        {"command": "utils.try_parse_dsk_from_qr_code_string", "qr": qr_code_string}
+    )
+    return data.get("dsk")

{zwave_js_server_python-0.44.0.dist-info → zwave_js_server_python-0.45.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: zwave-js-server-python
-Version: 0.44.0
+Version: 0.45.0
 Summary: Python wrapper for zwave-js-server
 Home-page: https://github.com/home-assistant-libs/zwave-js-server-python
 Author: Home Assistant Team

{zwave_js_server_python-0.44.0.dist-info → zwave_js_server_python-0.45.0.dist-info}/RECORD

@@ -1,13 +1,13 @@
 zwave_js_server/__init__.py,sha256=Ey3O4Tha56uU-M92oLJmQHupCJ7B9oZmxlQTo8pGUM8,45
 zwave_js_server/__main__.py,sha256=1gWC927sa3FwcA47ndmrRWW0HlfYVdiUarjEsccRF2k,3624
-zwave_js_server/client.py,sha256=TULMYH5ONGC5jkHJWtpSjv6rSM6b_LkJ95KOVOKHw-0,15698
+zwave_js_server/client.py,sha256=J1JFbCOnDurnH-g1NeCuMSdaUPYFrz818NEtKGUvmUk,15702
 zwave_js_server/dump.py,sha256=ntHBOFS4tca2CHiS8kmd4Eo58-DEOV617-QNXvhPWpw,1532
 zwave_js_server/event.py,sha256=E2bIEb635al9MsCB5rkk3ZklU4-YkmqmXtifzlbxXaQ,1958
 zwave_js_server/exceptions.py,sha256=s-a--Stnp8wOIsIb8GfagrrRFyD8cus0iBHe2-rekEw,6097
-zwave_js_server/firmware.py,sha256=edHCqhB1w3vFOkRQUZmsvjN5L8kHJzN2orQf-XDu8aQ,1096
+zwave_js_server/firmware.py,sha256=pLp2YkZN_yI2Lb187e7Y5h6tsiQcCR--8Kk1E8gUg0Q,2150
 zwave_js_server/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 zwave_js_server/version.py,sha256=RDFP2kSU3cCVIQbgMWggdeDnvhtVsZzzZg9pOjH7CC8,364
-zwave_js_server/const/__init__.py,sha256=W3r131B2skBAmjQ0uS1jsfMX7Iiyp4OfxpQuTMQCuKw,9131
+zwave_js_server/const/__init__.py,sha256=Du-7Q-8_enu4roX5xaUKhMW0fOnhLrxMOCogiFZtE2M,9131
 zwave_js_server/const/command_class/__init__.py,sha256=WilOppnr9CXahDjEEkAXyh_j7iCq_qZ1GtBkjWLoQUg,37
 zwave_js_server/const/command_class/barrier_operator.py,sha256=NBhTp5T-6T31glpIKrEOLgbKTndkB5gqdQmCJlXFFUA,783
 zwave_js_server/const/command_class/color_switch.py,sha256=9jIDdmz8gJ5d1RdINHiK7Yh0NXg1I0U1xVzkrQJICk8,918
@@ -28,24 +28,26 @@ zwave_js_server/model/association.py,sha256=GIrgo-3uxQxFnCH8PJ6TtGRoBW9Ak3iKWTJb
 zwave_js_server/model/command_class.py,sha256=pb_aXIl1_r9iHzdEyRr300y5xu62uE6GzmF6540CQd4,1256
 zwave_js_server/model/device_class.py,sha256=KpSM101bGa_3Mig4C-_rkE4CzqImK2JPIUtlG-TFcvU,1886
 zwave_js_server/model/device_config.py,sha256=7NaMa4BZ5tGe2p0YtOQFIUjBwRVF7GYWVExLwAgIUtE,6659
-zwave_js_server/model/driver.py,sha256=Dy-RPYsfoU_etOLsN2H9qOlrrJvRsKI7ifIfLC7eEt8,6299
+zwave_js_server/model/driver.py,sha256=fxQQMNGB1SyS-Y6GFQOs-pKsmn_msK63nPB8WXExGIU,6830
 zwave_js_server/model/endpoint.py,sha256=KRh4aeXKC4PNpTZbT3NuF5x_fDlbeOvoOSJ4u16lrLc,7972
-zwave_js_server/model/firmware.py,sha256=3KDV0t5035PBGCn-m_XRkJ7YJt0nL-qchSVf_JSJSes,7711
+zwave_js_server/model/firmware.py,sha256=llAEyTMocofgaGL1TVgt9CktE3BKQJXe934hZ0prFnA,1047
 zwave_js_server/model/log_config.py,sha256=F-QM7oHUXAfAxbdkrvmi6k6woM4VOwxB3qRrGmTQiQA,1722
 zwave_js_server/model/log_message.py,sha256=IxZ4USpXTeHsuRNS61NDPYMSIflv1KDO_EjUy4_vavE,5859
 zwave_js_server/model/notification.py,sha256=vrkKOdNV2bj1G4gP-1n1o43HaFkGoMw060VVLBlM6wU,7269
 zwave_js_server/model/statistics.py,sha256=uG87o-iNGKHxJc4Kfr2ZJ0VY7NjCbdxwgWOqu-D-JNE,3321
-zwave_js_server/model/utils.py,sha256=fLs1pOKG53yWQggBWUKvPgzlT0JkK3biLzRkhPBNArI,814
+zwave_js_server/model/utils.py,sha256=YTlfb3ceRnH-d7lO3jWSPrlixxqzonwa0M7Nbw7MhZY,1152
 zwave_js_server/model/value.py,sha256=4xl7E6eCOgcpGFQc6GKkYvvmnX-BhzUIFSoLVB9hPh0,8786
 zwave_js_server/model/version.py,sha256=W1H-UbhKdgMW5KdnY9MUfRFibfMZSOD3nljXOv1ZVVM,1398
-zwave_js_server/model/controller/__init__.py,sha256=ybQ7KUy0lWzNykm86NAXAY8_LNgwK3mvqZg56dyNQpQ,31606
-zwave_js_server/model/controller/data_model.py,sha256=XepG9ICR3ooRwQuMOZPL5QG9mHCcMfH5-sa_GWISAdg,949
-zwave_js_server/model/controller/event_model.py,sha256=pDk0t_czfnpL107Z9OiiOyO3ZpQ70KgPXR9_5YX2V3c,5161
+zwave_js_server/model/controller/__init__.py,sha256=BVmHUD6YWgWrHt8dV4MVc91hoZsbw1kJixPp0YCCaPE,32660
+zwave_js_server/model/controller/data_model.py,sha256=OotRUphLDQxZJ_Ik2Piwbrhz82_JgE_uw0VaxRE3TdM,967
+zwave_js_server/model/controller/event_model.py,sha256=2F6iLMudRfYgDcc1wym363wVAu2y9Zt1xGhElgrD9AY,5777
+zwave_js_server/model/controller/firmware.py,sha256=6emM0SHi_8CWDmEJsiCMvxSdnZ50qb10EjBm6QuDQqk,2148
 zwave_js_server/model/controller/inclusion_and_provisioning.py,sha256=01YUq4YBhQe3gmJAIsN6ctMM3pcLEaGMSyIySBI9v2c,7497
 zwave_js_server/model/controller/statistics.py,sha256=7aeFjKq_-TvcHBWc-a4xQP6wvO3GoGjr9P-m8uyOco8,4031
-zwave_js_server/model/node/__init__.py,sha256=mpr0O4B8RUAZ59P57gaxfLELPL02jKy-RwKvdUxFhw0,33009
+zwave_js_server/model/node/__init__.py,sha256=t_huosfTraNJChqKpFC327gQKYfIqy1ltQrtO8az_qI,33080
 zwave_js_server/model/node/data_model.py,sha256=qaeK77paI3mXFDusi8BWMRAl42tXiNgQTUz0jHLEsC8,1941
-zwave_js_server/model/node/event_model.py,sha256=AjlCDK21zVmKwll9OiRELnlvUARTshzHMyRhS1TWZS4,6068
+zwave_js_server/model/node/event_model.py,sha256=OQzbbs1LW2I9-VjwIXgVFtZ1w7dI3dmiEjVuJV7nuJ8,6096
+zwave_js_server/model/node/firmware.py,sha256=CgcZSJLkFO8T7fG2LQlThMqdDow-UxloKVvrLzq_MKo,7096
 zwave_js_server/model/node/health_check.py,sha256=EAOMBkMKd5q--fhax2GvJhWdhuuv5dX_-2Hf_mczODs,6054
 zwave_js_server/model/node/statistics.py,sha256=SgAdnXnvC-Hs2GdBvENz1mkbtnXOUf5E0s2OU0iUARE,3634
 zwave_js_server/util/__init__.py,sha256=ArF1K885aW0GdVd7Lo8fl8Atf70gvsxO5Ra_WoJTG28,42
@@ -56,9 +58,9 @@ zwave_js_server/util/node.py,sha256=9cUky9gssP6psiascmOtdRCqU2MOkZ6tym6VBKsgyqs,
 zwave_js_server/util/command_class/__init__.py,sha256=sRxti47ekLTzfk8B609CMQumIbcD6mon2ZS0zwh9omY,59
 zwave_js_server/util/command_class/meter.py,sha256=Qkif1ul4KpV_k6Dc7yNXlSjlJLLTH8mCitgQk9J9W0A,1277
 zwave_js_server/util/command_class/multilevel_sensor.py,sha256=p92YLNRze5z3UWhfIDJO95F-j5tqx1PKUG9oamo9Dng,1446
-zwave_js_server_python-0.44.0.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-zwave_js_server_python-0.44.0.dist-info/METADATA,sha256=Pm77zeK-CNhq2zex6ri_OgrsGpr7b52ElULMNHA3TDY,1684
-zwave_js_server_python-0.44.0.dist-info/WHEEL,sha256=2wepM1nk4DS4eFpYrW1TTqPcoGNfHhhO_i5m4cOimbo,92
-zwave_js_server_python-0.44.0.dist-info/entry_points.txt,sha256=_8Swg1yhKiBElo6k1fxIEd6E8uPz8PDxQpwQoZ29FZE,74
-zwave_js_server_python-0.44.0.dist-info/top_level.txt,sha256=-hwsl-i4Av5Op_yfOHC_OP56KPmzp_iVEkeohRIN5Ng,16
-zwave_js_server_python-0.44.0.dist-info/RECORD,,
+zwave_js_server_python-0.45.0.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+zwave_js_server_python-0.45.0.dist-info/METADATA,sha256=NQdmntgI38wyEk25PeAl8Sgd_MVQUjSYR7mzjXg7-cU,1684
+zwave_js_server_python-0.45.0.dist-info/WHEEL,sha256=2wepM1nk4DS4eFpYrW1TTqPcoGNfHhhO_i5m4cOimbo,92
+zwave_js_server_python-0.45.0.dist-info/entry_points.txt,sha256=_8Swg1yhKiBElo6k1fxIEd6E8uPz8PDxQpwQoZ29FZE,74
+zwave_js_server_python-0.45.0.dist-info/top_level.txt,sha256=-hwsl-i4Av5Op_yfOHC_OP56KPmzp_iVEkeohRIN5Ng,16
+zwave_js_server_python-0.45.0.dist-info/RECORD,,