zwave-js-server-python 0.65.0__py3-none-any.whl → 0.67.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.65.0"
+__version__ = "0.67.0"
 
 # minimal server schema version we can handle
-MIN_SERVER_SCHEMA_VERSION = 41
+MIN_SERVER_SCHEMA_VERSION = 44
 # max server schema version we can handle (and our code is compatible with)
-MAX_SERVER_SCHEMA_VERSION = 43
+MAX_SERVER_SCHEMA_VERSION = 44
 
 VALUE_UNKNOWN = "unknown"
 

zwave_js_server/event.py

@@ -7,10 +7,7 @@ from dataclasses import dataclass, field
 import logging
 from typing import Literal
 
-try:
-    from pydantic.v1 import BaseModel
-except ImportError:
-    from pydantic import BaseModel
+from pydantic import BaseModel
 
 LOGGER = logging.getLogger(__package__)
 

zwave_js_server/model/config_manager/__init__.py

@@ -6,7 +6,7 @@ https://zwave-js.github.io/node-zwave-js/#/api/config-manager
 
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Any, Optional
+from typing import TYPE_CHECKING, Any
 
 from ..device_config import DeviceConfig
 
@@ -26,7 +26,7 @@ class ConfigManager:
         manufacturer_id: int,
         product_type: int,
         product_id: int,
-        firmware_version: Optional[str] = None,
+        firmware_version: str | None = None,
     ) -> DeviceConfig | None:
         """Look up the definition of a given device in the configuration DB."""
         cmd: dict[str, Any] = {

zwave_js_server/model/controller/statistics.py

@@ -53,6 +53,7 @@ class BackgroundRSSIDataType(TypedDict, total=False):
     channel0: ChannelRSSIDataType  # required
     channel1: ChannelRSSIDataType  # required
     channel2: ChannelRSSIDataType
+    channel3: ChannelRSSIDataType
 
 
 class ControllerStatisticsDataType(TypedDict, total=False):
@@ -94,16 +95,20 @@ class BackgroundRSSI:
     channel_0: ChannelRSSI = field(init=False)
     channel_1: ChannelRSSI = field(init=False)
     channel_2: ChannelRSSI | None = field(init=False)
+    channel_3: ChannelRSSI | None = field(init=False)
 
     def __post_init__(self) -> None:
         """Post initialize."""
         self.timestamp = self.data["timestamp"]
         self.channel_0 = ChannelRSSI(self.data["channel0"])
         self.channel_1 = ChannelRSSI(self.data["channel1"])
-        if not (channel_2 := self.data.get("channel2")):
-            self.channel_2 = None
-            return
-        self.channel_2 = ChannelRSSI(channel_2)
+        # Channels 2 and 3 may not be present, but 3 requires 2 to be present
+        self.channel_2 = None
+        self.channel_3 = None
+        if channel_2 := self.data.get("channel2"):
+            self.channel_2 = ChannelRSSI(channel_2)
+            if channel_3 := self.data.get("channel3"):
+                self.channel_3 = ChannelRSSI(channel_3)
 
 
 @dataclass

zwave_js_server/model/device_config.py

@@ -12,8 +12,8 @@ from typing import Any, Literal, TypedDict
 class DeviceDeviceDataType(TypedDict, total=False):
     """Represent a device device data dict type."""
 
-    productType: str
-    productId: str
+    productType: str | int
+    productId: str | int
 
 
 class DeviceDevice:
@@ -24,12 +24,12 @@ class DeviceDevice:
         self.data = data
 
     @property
-    def product_type(self) -> str | None:
+    def product_type(self) -> str | int | None:
         """Return product type."""
         return self.data.get("productType")
 
     @property
-    def product_id(self) -> str | None:
+    def product_id(self) -> str | int | None:
         """Return product id."""
         return self.data.get("productId")
 
@@ -125,7 +125,7 @@ class DeviceConfigDataType(TypedDict, total=False):
 
     filename: str
     manufacturer: str
-    manufacturerId: str
+    manufacturerId: int
     label: str
     description: str
     devices: list[DeviceDeviceDataType]
@@ -164,8 +164,8 @@ class DeviceConfig:
         return self.data.get("manufacturer")
 
     @property
-    def manufacturer_id(self) -> str | None:  # TODO: In the dump this is an int.
-        """Return manufacturer id (as defined in specs) as a 4-digit hex string."""
+    def manufacturer_id(self) -> int | None:
+        """Return manufacturer id (as defined in specs)."""
         return self.data.get("manufacturerId")
 
     @property

zwave_js_server/model/driver/__init__.py

@@ -4,11 +4,18 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING, Any, Literal, cast
 
+from zwave_js_server.model.firmware import (
+    FirmwareUpdateData,
+    FirmwareUpdateDataDataType,
+    FirmwareUpdateInfo,
+    FirmwareUpdateInfoDataType,
+)
+
 from ...event import BaseEventModel, Event, EventBase
 from ..config_manager import ConfigManager
 from ..controller import Controller
 from ..log_config import LogConfig, LogConfigDataType
-from ..log_message import LogMessage, LogMessageDataType
+from ..log_message import LogMessage, LogMessageContextDataType, LogMessageDataType
 from .firmware import (
     DriverFirmwareUpdateProgress,
     DriverFirmwareUpdateProgressDataType,
@@ -16,11 +23,6 @@ from .firmware import (
     DriverFirmwareUpdateResultDataType,
 )
 
-try:
-    from pydantic.v1 import create_model_from_typeddict
-except ImportError:
-    from pydantic import create_model_from_typeddict
-
 if TYPE_CHECKING:
     from ...client import Client
 
@@ -53,9 +55,40 @@ class AllNodesReadyEventModel(BaseDriverEventModel):
     event: Literal["all nodes ready"]
 
 
-LoggingEventModel = create_model_from_typeddict(
-    LogMessageDataType, __base__=BaseDriverEventModel
-)
+class LoggingEventModel(BaseDriverEventModel):
+    """Model for `logging` event data."""
+
+    event: Literal["logging"]
+    message: str | list[str]  # required
+    formattedMessage: str | list[str]  # required
+    direction: str  # required
+    level: str  # required
+    context: LogMessageContextDataType  # required
+    primaryTags: str | None = None
+    secondaryTags: str | None = None
+    secondaryTagPadding: int | None = None
+    multiline: bool | None = None
+    timestamp: str | None = None
+    label: str | None = None
+
+    @classmethod
+    def from_dict(cls, data: dict) -> LoggingEventModel:
+        """Initialize from dict."""
+        return cls(
+            source=data["source"],
+            event=data["event"],
+            message=data["message"],
+            formattedMessage=data["formattedMessage"],
+            direction=data["direction"],
+            level=data["level"],
+            context=data["context"],
+            primaryTags=data.get("primaryTags"),
+            secondaryTags=data.get("secondaryTags"),
+            secondaryTagPadding=data.get("secondaryTagPadding"),
+            multiline=data.get("multiline"),
+            timestamp=data.get("timestamp"),
+            label=data.get("label"),
+        )
 
 
 class DriverReadyEventModel(BaseDriverEventModel):
@@ -216,6 +249,38 @@ class Driver(EventBase):
         )
         return cast(bool, result["success"])
 
+    async def async_firmware_update_otw(
+        self,
+        *,
+        update_data: FirmwareUpdateData | None = None,
+        update_info: FirmwareUpdateInfo | None = None,
+    ) -> DriverFirmwareUpdateResult:
+        """Send firmwareUpdateOTW command to Driver."""
+        if update_data is None and update_info is None:
+            raise ValueError(
+                "Either update_data or update_info must be provided for firmware update."
+            )
+        if update_data is not None and update_info is not None:
+            raise ValueError(
+                "Only one of update_data or update_info can be provided for firmware update."
+            )
+        params: FirmwareUpdateDataDataType | dict[str, FirmwareUpdateInfoDataType]
+        if update_data is not None:
+            params = update_data.to_dict()
+        elif update_info is not None:
+            params = {"updateInfo": update_info.to_dict()}
+        data = await self._async_send_command(
+            "firmware_update_otw", require_schema=44, **params
+        )
+        return DriverFirmwareUpdateResult(data["result"])
+
+    async def async_is_otw_firmware_update_in_progress(self) -> bool:
+        """Send isOTWFirmwareUpdateInProgress command to Driver."""
+        result = await self._async_send_command(
+            "is_otw_firmware_update_in_progress", require_schema=41
+        )
+        return cast(bool, result["progress"])
+
     async def async_set_preferred_scales(
         self, scales: dict[str | int, str | int]
     ) -> None:

zwave_js_server/model/driver/firmware.py

@@ -4,37 +4,25 @@ from __future__ import annotations
 
 from dataclasses import dataclass, field
 from enum import IntEnum
-from typing import TypedDict
 
-from ...util.helpers import convert_bytes_to_base64
+from zwave_js_server.model.firmware import (
+    FirmwareUpdateData,
+    FirmwareUpdateDataDataType,
+    FirmwareUpdateProgress,
+    FirmwareUpdateProgressDataType,
+    FirmwareUpdateResult,
+    FirmwareUpdateResultDataType,
+)
 
 
-class DriverFirmwareUpdateDataDataType(TypedDict, total=False):
+class DriverFirmwareUpdateDataDataType(FirmwareUpdateDataDataType):
     """Represent a driver firmware update data dict type."""
 
-    filename: str  # required
-    file: str  # required
-    fileFormat: str
-
 
 @dataclass
-class DriverFirmwareUpdateData:
+class DriverFirmwareUpdateData(FirmwareUpdateData):
     """Driver firmware update data."""
 
-    filename: str
-    file: bytes
-    file_format: str | None = None
-
-    def to_dict(self) -> DriverFirmwareUpdateDataDataType:
-        """Convert firmware update data to dict."""
-        data: DriverFirmwareUpdateDataDataType = {
-            "filename": self.filename,
-            "file": convert_bytes_to_base64(self.file),
-        }
-        if self.file_format is not None:
-            data["fileFormat"] = self.file_format
-        return data
-
 
 class DriverFirmwareUpdateStatus(IntEnum):
     """Enum with all driver firmware update status values.
@@ -52,46 +40,26 @@ class DriverFirmwareUpdateStatus(IntEnum):
     OK = 255
 
 
-class DriverFirmwareUpdateProgressDataType(TypedDict):
+class DriverFirmwareUpdateProgressDataType(FirmwareUpdateProgressDataType):
     """Represent a driver firmware update progress dict type."""
 
-    sentFragments: int
-    totalFragments: int
-    progress: float
-
 
 @dataclass
-class DriverFirmwareUpdateProgress:
+class DriverFirmwareUpdateProgress(FirmwareUpdateProgress):
     """Model for a driver firmware update progress data."""
 
     data: DriverFirmwareUpdateProgressDataType = field(repr=False)
-    sent_fragments: int = field(init=False)
-    total_fragments: int = field(init=False)
-    progress: float = field(init=False)
 
-    def __post_init__(self) -> None:
-        """Post initialize."""
-        self.sent_fragments = self.data["sentFragments"]
-        self.total_fragments = self.data["totalFragments"]
-        self.progress = float(self.data["progress"])
 
-
-class DriverFirmwareUpdateResultDataType(TypedDict):
+class DriverFirmwareUpdateResultDataType(FirmwareUpdateResultDataType):
     """Represent a driver firmware update result dict type."""
 
-    status: int
-    success: bool
-
 
 @dataclass
-class DriverFirmwareUpdateResult:
+class DriverFirmwareUpdateResult(FirmwareUpdateResult):
     """Model for driver firmware update result data."""
 
     data: DriverFirmwareUpdateResultDataType = field(repr=False)
     status: DriverFirmwareUpdateStatus = field(init=False)
     success: bool = field(init=False)
-
-    def __post_init__(self) -> None:
-        """Post initialize."""
-        self.status = DriverFirmwareUpdateStatus(self.data["status"])
-        self.success = self.data["success"]
+    _status_class = DriverFirmwareUpdateStatus

zwave_js_server/model/firmware.py

@@ -0,0 +1,210 @@
+"""Provide models for Z-Wave JS firmware."""
+
+from __future__ import annotations
+
+from dataclasses import asdict, dataclass, field
+from enum import IntEnum
+from typing import Literal, Required, TypedDict, cast
+
+from zwave_js_server.const import RFRegion
+from zwave_js_server.util.helpers import convert_bytes_to_base64
+
+
+@dataclass
+class FirmwareUpdateData:
+    """Firmware update data."""
+
+    filename: str
+    file: bytes
+    file_format: str | None = None
+
+    def to_dict(self) -> FirmwareUpdateDataDataType:
+        """Convert firmware update data to dict."""
+        data: FirmwareUpdateDataDataType = {
+            "filename": self.filename,
+            "file": convert_bytes_to_base64(self.file),
+        }
+        if self.file_format is not None:
+            data["fileFormat"] = self.file_format
+        return data
+
+
+class FirmwareUpdateDataDataType(TypedDict, total=False):
+    """Represent a firmware update data dict type."""
+
+    filename: Required[str]
+    file: Required[str]
+    fileFormat: str
+
+
+@dataclass
+class FirmwareUpdateInfo:
+    """Represent a firmware update info."""
+
+    version: str
+    changelog: str
+    channel: Literal["stable", "beta"]
+    files: list[FirmwareUpdateFileInfo]
+    downgrade: bool
+    normalized_version: str
+    device: FirmwareUpdateDeviceID
+
+    @classmethod
+    def from_dict(cls, data: FirmwareUpdateInfoDataType) -> FirmwareUpdateInfo:
+        """Initialize from dict."""
+        return cls(
+            version=data["version"],
+            changelog=data["changelog"],
+            channel=data["channel"],
+            files=[FirmwareUpdateFileInfo.from_dict(file) for file in data["files"]],
+            downgrade=data["downgrade"],
+            normalized_version=data["normalizedVersion"],
+            device=FirmwareUpdateDeviceID.from_dict(data["device"]),
+        )
+
+    def to_dict(self) -> FirmwareUpdateInfoDataType:
+        """Return dict representation of the object."""
+        return cast(
+            FirmwareUpdateInfoDataType,
+            {
+                "version": self.version,
+                "changelog": self.changelog,
+                "channel": self.channel,
+                "files": [file.to_dict() for file in self.files],
+                "downgrade": self.downgrade,
+                "normalizedVersion": self.normalized_version,
+                "device": self.device.to_dict(),
+            },
+        )
+
+
+class FirmwareUpdateInfoDataType(TypedDict, total=False):
+    """Represent a firmware update info data dict type."""
+
+    version: str
+    changelog: str
+    channel: Literal["stable", "beta"]
+    files: list[FirmwareUpdateFileInfoDataType]
+    downgrade: bool
+    normalizedVersion: str
+    device: FirmwareUpdateDeviceIDDataType
+
+
+@dataclass
+class FirmwareUpdateDeviceID:
+    """Represent a firmware update device ID."""
+
+    manufacturer_id: int
+    product_type: int
+    product_id: int
+    firmware_version: str
+    rf_region: RFRegion | None
+
+    @classmethod
+    def from_dict(cls, data: FirmwareUpdateDeviceIDDataType) -> FirmwareUpdateDeviceID:
+        """Initialize from dict."""
+        return cls(
+            manufacturer_id=data["manufacturerId"],
+            product_type=data["productType"],
+            product_id=data["productId"],
+            firmware_version=data["firmwareVersion"],
+            rf_region=RFRegion(data["rfRegion"]) if "rfRegion" in data else None,
+        )
+
+    def to_dict(self) -> FirmwareUpdateDeviceIDDataType:
+        """Return dict representation of the object."""
+        data = {
+            "manufacturerId": self.manufacturer_id,
+            "productType": self.product_type,
+            "productId": self.product_id,
+            "firmwareVersion": self.firmware_version,
+        }
+        if self.rf_region is not None:
+            data["rfRegion"] = self.rf_region
+        return cast(FirmwareUpdateDeviceIDDataType, data)
+
+
+class FirmwareUpdateDeviceIDDataType(TypedDict, total=False):
+    """Represent a firmware update device ID dict type."""
+
+    manufacturerId: Required[int]
+    productType: Required[int]
+    productId: Required[int]
+    firmwareVersion: Required[str]
+    rfRegion: int
+
+
+@dataclass
+class FirmwareUpdateFileInfo:
+    """Represent a firmware update file info."""
+
+    target: int
+    url: str
+    integrity: str
+
+    @classmethod
+    def from_dict(cls, data: FirmwareUpdateFileInfoDataType) -> FirmwareUpdateFileInfo:
+        """Initialize from dict."""
+        return cls(
+            target=data["target"],
+            url=data["url"],
+            integrity=data["integrity"],
+        )
+
+    def to_dict(self) -> FirmwareUpdateFileInfoDataType:
+        """Return dict representation of the object."""
+        return cast(FirmwareUpdateFileInfoDataType, asdict(self))
+
+
+class FirmwareUpdateFileInfoDataType(TypedDict):
+    """Represent a firmware update file info data dict type."""
+
+    target: int
+    url: str
+    integrity: str  # sha256
+
+
+@dataclass
+class FirmwareUpdateProgress:
+    """Model for a firmware update progress."""
+
+    data: FirmwareUpdateProgressDataType = field(repr=False)
+    sent_fragments: int = field(init=False)
+    total_fragments: int = field(init=False)
+    progress: float = field(init=False)
+
+    def __post_init__(self) -> None:
+        """Post initialize."""
+        self.sent_fragments = self.data["sentFragments"]
+        self.total_fragments = self.data["totalFragments"]
+        self.progress = float(self.data["progress"])
+
+
+class FirmwareUpdateProgressDataType(TypedDict):
+    """Represent a firmware update progress dict type."""
+
+    sentFragments: int
+    totalFragments: int
+    progress: float
+
+
+@dataclass
+class FirmwareUpdateResult:
+    """Model for firmware update result data."""
+
+    data: FirmwareUpdateResultDataType = field(repr=False)
+    status: IntEnum = field(init=False)
+    success: bool = field(init=False)
+    _status_class: type[IntEnum] = field(init=False, repr=False)
+
+    def __post_init__(self) -> None:
+        """Post initialize."""
+        self.status = self._status_class(self.data["status"])
+        self.success = self.data["success"]
+
+
+class FirmwareUpdateResultDataType(TypedDict):
+    """Represent a driver firmware update result dict type."""
+
+    status: int
+    success: bool

zwave_js_server/model/node/__init__.py

@@ -503,10 +503,7 @@ class Node(EventBase):
         if wait_for_result:
             result = await self.client.async_send_command(message, **kwargs)
             return result
-        if wait_for_result is None and self.status not in (
-            NodeStatus.ASLEEP,
-            NodeStatus.DEAD,
-        ):
+        if wait_for_result is None and self.status not in (NodeStatus.ASLEEP,):
             result_task = asyncio.create_task(
                 self.client.async_send_command(message, **kwargs)
             )

zwave_js_server/model/node/event_model.py

@@ -4,6 +4,8 @@ from __future__ import annotations
 
 from typing import Literal
 
+from pydantic import BaseModel
+
 from ...const import CommandClass
 from ...event import BaseEventModel
 from ..notification import (
@@ -20,11 +22,6 @@ from .firmware import (
 )
 from .statistics import NodeStatisticsDataType
 
-try:
-    from pydantic.v1 import BaseModel
-except ImportError:
-    from pydantic import BaseModel
-
 
 class BaseNodeEventModel(BaseEventModel):
     """Base model for a node event."""
@@ -101,8 +98,8 @@ class InterviewFailedEventArgsModel(BaseModel):
 
     errorMessage: str
     isFinal: bool
-    attempt: int | None
-    maxAttempts: int | None
+    attempt: int | None = None
+    maxAttempts: int | None = None
 
     @classmethod
     def from_dict(cls, data: dict) -> InterviewFailedEventArgsModel:

zwave_js_server/model/node/firmware.py

@@ -2,52 +2,56 @@
 
 from __future__ import annotations
 
-from dataclasses import asdict, dataclass, field
+from dataclasses import dataclass, field
 from enum import IntEnum
-from typing import TYPE_CHECKING, Literal, TypedDict, cast
-
-from ...const import VALUE_UNKNOWN, RFRegion
-from ...util.helpers import convert_bytes_to_base64
+from typing import TYPE_CHECKING, Required, TypedDict, cast
+
+from zwave_js_server.model.firmware import (
+    FirmwareUpdateData,
+    FirmwareUpdateDataDataType,
+    FirmwareUpdateDeviceID,
+    FirmwareUpdateDeviceIDDataType,
+    FirmwareUpdateFileInfo,
+    FirmwareUpdateFileInfoDataType,
+    FirmwareUpdateInfo,
+    FirmwareUpdateInfoDataType,
+    FirmwareUpdateProgress,
+    FirmwareUpdateProgressDataType,
+    FirmwareUpdateResult,
+    FirmwareUpdateResultDataType,
+)
+
+from ...const import VALUE_UNKNOWN
 
 if TYPE_CHECKING:
     from . import Node
 
 
-class NodeFirmwareUpdateDataDataType(TypedDict, total=False):
+class NodeFirmwareUpdateDataDataType(FirmwareUpdateDataDataType):
     """Represent a firmware update data dict type."""
 
-    filename: str  # required
-    file: str  # required
-    fileFormat: str
     firmwareTarget: int
 
 
 @dataclass
-class NodeFirmwareUpdateData:
+class NodeFirmwareUpdateData(FirmwareUpdateData):
     """Firmware update data."""
 
-    filename: str
-    file: bytes
-    file_format: str | None = None
     firmware_target: int | None = None
 
     def to_dict(self) -> NodeFirmwareUpdateDataDataType:
         """Convert firmware update data to dict."""
-        data: NodeFirmwareUpdateDataDataType = {
-            "filename": self.filename,
-            "file": convert_bytes_to_base64(self.file),
-        }
-        if self.file_format is not None:
-            data["fileFormat"] = self.file_format
+        data = super().to_dict()
+        node_data = cast(NodeFirmwareUpdateDataDataType, data)
         if self.firmware_target is not None:
-            data["firmwareTarget"] = self.firmware_target
-        return data
+            node_data["firmwareTarget"] = self.firmware_target
+        return node_data
 
 
 class NodeFirmwareUpdateCapabilitiesDataType(TypedDict, total=False):
     """Represent a firmware update capabilities dict type."""
 
-    firmwareUpgradable: bool  # required
+    firmwareUpgradable: Required[bool]
     firmwareTargets: list[int]
     continuesToFunction: bool | str
     supportsActivation: bool | str
@@ -56,7 +60,7 @@ class NodeFirmwareUpdateCapabilitiesDataType(TypedDict, total=False):
 class NodeFirmwareUpdateCapabilitiesDict(TypedDict, total=False):
     """Represent a dict from FirmwareUpdateCapabilities."""
 
-    firmware_upgradable: bool  # required
+    firmware_upgradable: Required[bool]
     firmware_targets: list[int]
     continues_to_function: bool | None
     supports_activation: bool | None
@@ -133,193 +137,125 @@ class NodeFirmwareUpdateStatus(IntEnum):
     OK_RESTART_PENDING = 255
 
 
-class NodeFirmwareUpdateProgressDataType(TypedDict):
+class NodeFirmwareUpdateProgressDataType(FirmwareUpdateProgressDataType):
     """Represent a node firmware update progress dict type."""
 
     currentFile: int
     totalFiles: int
-    sentFragments: int
-    totalFragments: int
-    progress: float
 
 
 @dataclass
-class NodeFirmwareUpdateProgress:
+class NodeFirmwareUpdateProgress(FirmwareUpdateProgress):
     """Model for a node firmware update progress data."""
 
     node: Node
     data: NodeFirmwareUpdateProgressDataType = field(repr=False)
     current_file: int = field(init=False)
     total_files: int = field(init=False)
-    sent_fragments: int = field(init=False)
-    total_fragments: int = field(init=False)
-    progress: float = field(init=False)
+
+    def __init__(self, node: Node, data: NodeFirmwareUpdateProgressDataType) -> None:
+        """Initialize the node firmware update progress.
+
+        Explicit init method to retain backwards compatibility
+        that requires the node as first parameter.
+        """
+        super().__init__(data)
+        self.node = node
 
     def __post_init__(self) -> None:
         """Post initialize."""
+        super().__post_init__()
         self.current_file = self.data["currentFile"]
         self.total_files = self.data["totalFiles"]
-        self.sent_fragments = self.data["sentFragments"]
-        self.total_fragments = self.data["totalFragments"]
-        self.progress = float(self.data["progress"])
 
 
-class NodeFirmwareUpdateResultDataType(TypedDict, total=False):
+class NodeFirmwareUpdateResultDataType(FirmwareUpdateResultDataType, total=False):
     """Represent a node firmware update result dict type."""
 
-    status: int  # required
-    success: bool  # required
     waitTime: int
-    reInterview: bool  # required
+    reInterview: Required[bool]
 
 
 @dataclass
-class NodeFirmwareUpdateResult:
+class NodeFirmwareUpdateResult(FirmwareUpdateResult):
     """Model for node firmware update result data."""
 
     node: Node
     data: NodeFirmwareUpdateResultDataType = field(repr=False)
     status: NodeFirmwareUpdateStatus = field(init=False)
-    success: bool = field(init=False)
     wait_time: int | None = field(init=False)
     reinterview: bool = field(init=False)
+    _status_class = NodeFirmwareUpdateStatus
+
+    def __init__(self, node: Node, data: NodeFirmwareUpdateResultDataType) -> None:
+        """Initialize the node firmware update result.
+
+        Explicit init method to retain backwards compatibility
+        that requires the node as first parameter.
+        """
+        super().__init__(data)
+        self.node = node
 
     def __post_init__(self) -> None:
         """Post initialize."""
-        self.status = NodeFirmwareUpdateStatus(self.data["status"])
-        self.success = self.data["success"]
+        super().__post_init__()
         self.wait_time = self.data.get("waitTime")
         self.reinterview = self.data["reInterview"]
 
 
-class NodeFirmwareUpdateFileInfoDataType(TypedDict):
-    """Represent a firmware update file info data dict type."""
-
-    target: int
-    url: str
-    integrity: str  # sha256
+class NodeFirmwareUpdateFileInfoDataType(FirmwareUpdateFileInfoDataType):
+    """Represent a node firmware update file info data dict type."""
 
 
 @dataclass
-class NodeFirmwareUpdateFileInfo:
+class NodeFirmwareUpdateFileInfo(FirmwareUpdateFileInfo):
     """Represent a firmware update file info."""
 
-    target: int
-    url: str
-    integrity: str
-
     @classmethod
     def from_dict(
         cls, data: NodeFirmwareUpdateFileInfoDataType
     ) -> NodeFirmwareUpdateFileInfo:
         """Initialize from dict."""
-        return cls(
-            target=data["target"],
-            url=data["url"],
-            integrity=data["integrity"],
-        )
+        return cast(NodeFirmwareUpdateFileInfo, super().from_dict(data))
 
     def to_dict(self) -> NodeFirmwareUpdateFileInfoDataType:
         """Return dict representation of the object."""
-        return cast(NodeFirmwareUpdateFileInfoDataType, asdict(self))
-
+        return super().to_dict()
 
-class NodeFirmwareUpdateDeviceIDDataType(TypedDict, total=False):
-    """Represent a firmware update device ID dict type."""
 
-    manufacturerId: int  # required
-    productType: int  # required
-    productId: int  # required
-    firmwareVersion: str  # required
-    rfRegion: int
+class NodeFirmwareUpdateDeviceIDDataType(FirmwareUpdateDeviceIDDataType):
+    """Represent a node firmware update device ID data dict type."""
 
 
 @dataclass
-class NodeFirmwareUpdateDeviceID:
+class NodeFirmwareUpdateDeviceID(FirmwareUpdateDeviceID):
     """Represent a firmware update device ID."""
 
-    manufacturer_id: int
-    product_type: int
-    product_id: int
-    firmware_version: str
-    rf_region: RFRegion | None
-
     @classmethod
     def from_dict(
         cls, data: NodeFirmwareUpdateDeviceIDDataType
     ) -> NodeFirmwareUpdateDeviceID:
         """Initialize from dict."""
-        return cls(
-            manufacturer_id=data["manufacturerId"],
-            product_type=data["productType"],
-            product_id=data["productId"],
-            firmware_version=data["firmwareVersion"],
-            rf_region=RFRegion(data["rfRegion"]) if "rfRegion" in data else None,
-        )
+        return cast(NodeFirmwareUpdateDeviceID, super().from_dict(data))
 
     def to_dict(self) -> NodeFirmwareUpdateDeviceIDDataType:
         """Return dict representation of the object."""
-        data = {
-            "manufacturerId": self.manufacturer_id,
-            "productType": self.product_type,
-            "productId": self.product_id,
-            "firmwareVersion": self.firmware_version,
-        }
-        if self.rf_region is not None:
-            data["rfRegion"] = self.rf_region
-        return cast(NodeFirmwareUpdateDeviceIDDataType, data)
-
+        return super().to_dict()
 
-class NodeFirmwareUpdateInfoDataType(TypedDict, total=False):
-    """Represent a firmware update info data dict type."""
 
-    version: str
-    changelog: str
-    channel: Literal["stable", "beta"]
-    files: list[NodeFirmwareUpdateFileInfoDataType]
-    downgrade: bool
-    normalizedVersion: str
-    device: NodeFirmwareUpdateDeviceIDDataType
+class NodeFirmwareUpdateInfoDataType(FirmwareUpdateInfoDataType):
+    """Represent a node firmware update info data dict type."""
 
 
 @dataclass
-class NodeFirmwareUpdateInfo:
+class NodeFirmwareUpdateInfo(FirmwareUpdateInfo):
     """Represent a firmware update info."""
 
-    version: str
-    changelog: str
-    channel: Literal["stable", "beta"]
-    files: list[NodeFirmwareUpdateFileInfo]
-    downgrade: bool
-    normalized_version: str
-    device: NodeFirmwareUpdateDeviceID
-
     @classmethod
     def from_dict(cls, data: NodeFirmwareUpdateInfoDataType) -> NodeFirmwareUpdateInfo:
         """Initialize from dict."""
-        return cls(
-            version=data["version"],
-            changelog=data["changelog"],
-            channel=data["channel"],
-            files=[
-                NodeFirmwareUpdateFileInfo.from_dict(file) for file in data["files"]
-            ],
-            downgrade=data["downgrade"],
-            normalized_version=data["normalizedVersion"],
-            device=NodeFirmwareUpdateDeviceID.from_dict(data["device"]),
-        )
+        return cast(NodeFirmwareUpdateInfo, super().from_dict(data))
 
     def to_dict(self) -> NodeFirmwareUpdateInfoDataType:
         """Return dict representation of the object."""
-        return cast(
-            NodeFirmwareUpdateInfoDataType,
-            {
-                "version": self.version,
-                "changelog": self.changelog,
-                "channel": self.channel,
-                "files": [file.to_dict() for file in self.files],
-                "downgrade": self.downgrade,
-                "normalizedVersion": self.normalized_version,
-                "device": self.device.to_dict(),
-            },
-        )
+        return super().to_dict()

zwave_js_server/model/node/statistics.py

@@ -25,7 +25,7 @@ class NodeStatisticsDataType(TypedDict, total=False):
     commandsDroppedTX: int  # required
     commandsDroppedRX: int  # required
     timeoutResponse: int  # required
-    rtt: int
+    rtt: float
     rssi: int
     lwr: RouteStatisticsDataType
     nlwr: RouteStatisticsDataType
@@ -43,7 +43,7 @@ class NodeStatistics:
     commands_dropped_rx: int = field(init=False)
     commands_dropped_tx: int = field(init=False)
     timeout_response: int = field(init=False)
-    rtt: int | None = field(init=False)
+    rtt: float | None = field(init=False)
     lwr: RouteStatistics | None = field(init=False, default=None)
     nlwr: RouteStatistics | None = field(init=False, default=None)
     last_seen: datetime | None = field(init=False, default=None)

zwave_js_server/model/value.py

@@ -40,7 +40,7 @@ class MetaDataType(TypedDict, total=False):
     label: str
     min: int | None
     max: int | None
-    unit: str
+    unit: str | None
     states: dict[str, str]
     ccSpecific: dict[str, Any]
     valueChangeOptions: list[str]

{zwave_js_server_python-0.65.0.dist-info → zwave_js_server_python-0.67.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: zwave-js-server-python
-Version: 0.65.0
+Version: 0.67.0
 Summary: Python wrapper for zwave-js-server
 Author-email: Home Assistant Team <hello@home-assistant.io>
 License-Expression: Apache-2.0
@@ -18,7 +18,7 @@ Requires-Python: >=3.12
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: aiohttp>3
-Requires-Dist: pydantic>=1.10.0
+Requires-Dist: pydantic>=2.0.0
 Dynamic: license-file
 
 # zwave-js-server-python

{zwave_js_server_python-0.65.0.dist-info → zwave_js_server_python-0.67.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=1kwujigWJU84-vT61vvYED2EeB-4JS_7gMqu4ipjlEI,19589
 zwave_js_server/dump.py,sha256=ZBhkC07ndrFd784zpogfjRJtAdEh8-y8ZycvrGf34sE,1523
-zwave_js_server/event.py,sha256=zz6hzhommpsqWOZul9JtI_RlX5hyn2KVNuAqH_0Cgsg,2435
+zwave_js_server/event.py,sha256=FBZ86ns4bEi95UAMrcinNs2WKHUbR7plAErIc1Ed0lg,2368
 zwave_js_server/exceptions.py,sha256=8SY6FA8NiTEQgtauLR83F7m69gBGQviJ6O2obirH2po,6148
 zwave_js_server/firmware.py,sha256=57L7olhmtJ0FosEi3GtinNjfayudbQxYRYhpgrzsj90,2328
 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=eD2a2MTdU9x5VH2GLsJQbZLASqphFn-pmAJE6x6lPs4,14264
+zwave_js_server/const/__init__.py,sha256=oxX2Jq12Q2TKPUaNgYvTGxW_AwIfULadxw0SyhFtGVU,14264
 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
@@ -32,31 +32,32 @@ zwave_js_server/model/__init__.py,sha256=XfyKH8lxZ3CB7CbRkOr5sR-eV0GrklZiBtNPmln
 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=HpM-DchbhcyjhkDrp-6b8YaX2Qqo7KZbWk60xcMIhFY,6562
+zwave_js_server/model/device_config.py,sha256=ANKQLGpXYAk6ibZTr6zRQEj6i70sby7ctsRN1XwYjc4,6525
 zwave_js_server/model/duration.py,sha256=OW2OqReexL6GXxxLs__i5Vs3JCVoODgLpwPHU48yynU,1153
 zwave_js_server/model/endpoint.py,sha256=V_OWg4PLwExOSdY4cAiY5IkiJ2FH5MHF3tKG8O0X1Lo,11911
+zwave_js_server/model/firmware.py,sha256=kSGtfvwurDi3fekcipl3658FZ5hIHgDBq46LSUDFn3c,6219
 zwave_js_server/model/log_config.py,sha256=uF7gJlr2dSBP2mBMYzOyFiV_T45PwGU98AM5c7qs2g0,1574
 zwave_js_server/model/log_message.py,sha256=SNicnss7LUZd6woMecNQ0ZKwghC9OmxNdA1vYnR-YAE,4450
 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=Ku_VnX79WL82SD6Up01qQUNRldnCvi37HeEuTrTdBPU,13266
+zwave_js_server/model/value.py,sha256=aHiWfmFym8t5aok2uxQoVHw375wbv-frNjAMAs6MSMg,13273
 zwave_js_server/model/version.py,sha256=EnyL6O8r2gSv7qLIuZ-sWnybG5JnJWw-IEE5UtIUjiM,1272
-zwave_js_server/model/config_manager/__init__.py,sha256=g1qEnadcfG7P8AJrUjxTeke9OBaKFiLVelgTQQJRMx4,1246
+zwave_js_server/model/config_manager/__init__.py,sha256=zLcC-G4-skg7CDK_458T5ny-MGcUCzBxHDrb-e_ig1s,1233
 zwave_js_server/model/controller/__init__.py,sha256=d2htuMJhnwF9CdcaIK7sRExDJ1ljH6ypsKOk5mu6k4M,37378
 zwave_js_server/model/controller/data_model.py,sha256=5e6M0t7RkSJytovmDz1tULMFFoCQ1TsGHe56scrZRqI,851
 zwave_js_server/model/controller/event_model.py,sha256=BtacPbezXVByd9kuMSHysywLP3eCz5VgTdWs2NmA65M,9518
 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/driver/__init__.py,sha256=VMqZAdbIq4h-udwTvLfQR1zyxA3QEoAojfkgMNwz6Lg,9275
-zwave_js_server/model/driver/firmware.py,sha256=pWSI6QYt4mJ-ff3Wd4Hyc3r-MeiJPkaAz24lFcz40Vs,2815
-zwave_js_server/model/node/__init__.py,sha256=OeHGrrjzsviGXWRv6HrLTlw70pmAagP6NwiRQACNxrE,41489
+zwave_js_server/model/controller/statistics.py,sha256=s1wg-npEtXp-2yprych8BuQfG1NHq0fAZypqFz2T8hI,4954
+zwave_js_server/model/driver/__init__.py,sha256=wXzUX0W8B3o4_RgOMFtAZ2s_xavSf8PwCk9_fTcOiAo,11870
+zwave_js_server/model/driver/firmware.py,sha256=y5qcCpD2O6vCPl-eEGZiH4SHnaqegBlF2o6q0i1ygkY,1939
+zwave_js_server/model/node/__init__.py,sha256=Qqav-yXwaRkeTnug2rn2ZPPSw7X6jCAEIudVnH27BbY,41438
 zwave_js_server/model/node/data_model.py,sha256=lhCUcOkJ-PYAJ6ItnDwX4WkrBCMHZTDtSerf3YAdbEE,1872
-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/event_model.py,sha256=Xx_4U6HVsw1j4Hpt63CrxX4JtiVSVf9e-opaP0grZDk,10002
+zwave_js_server/model/node/firmware.py,sha256=hloB17eUCL1Rge9hh359bve3O5_Lp80MNap5X6zVj5E,8411
 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/model/node/statistics.py,sha256=PkD_vsOcT_6Iwwlqy5ISBZRXFQ-alTOZwIpatRg0PFQ,2875
 zwave_js_server/util/__init__.py,sha256=ArF1K885aW0GdVd7Lo8fl8Atf70gvsxO5Ra_WoJTG28,42
 zwave_js_server/util/helpers.py,sha256=BNEaa5xSGlFwJrIIWt-Ne8BdHFOdcUnZOhZ-nsfDk2c,1638
 zwave_js_server/util/lock.py,sha256=QKl6BuzDhIP25HBB0Ba9Fl6drARXnyqV3u5ywQl0Te8,7422
@@ -66,9 +67,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.65.0.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-zwave_js_server_python-0.65.0.dist-info/METADATA,sha256=BhcNcKhkENka1CwbOlJxBJWHvVz4iBpH0W-tnB6tG0c,1927
-zwave_js_server_python-0.65.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-zwave_js_server_python-0.65.0.dist-info/entry_points.txt,sha256=lvzma7Rd_3FW_k-_xGuTfpvcvA2MR_22DOz5f1t7-xg,73
-zwave_js_server_python-0.65.0.dist-info/top_level.txt,sha256=-hwsl-i4Av5Op_yfOHC_OP56KPmzp_iVEkeohRIN5Ng,16
-zwave_js_server_python-0.65.0.dist-info/RECORD,,
+zwave_js_server_python-0.67.0.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+zwave_js_server_python-0.67.0.dist-info/METADATA,sha256=H6r6_Efz63gNZIppDeHql5lSF5RNNwMMXUXyqLwmbcg,1926
+zwave_js_server_python-0.67.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+zwave_js_server_python-0.67.0.dist-info/entry_points.txt,sha256=lvzma7Rd_3FW_k-_xGuTfpvcvA2MR_22DOz5f1t7-xg,73
+zwave_js_server_python-0.67.0.dist-info/top_level.txt,sha256=-hwsl-i4Av5Op_yfOHC_OP56KPmzp_iVEkeohRIN5Ng,16
+zwave_js_server_python-0.67.0.dist-info/RECORD,,