zwave-js-server-python 0.66.0__tar.gz → 0.67.1__tar.gz

{zwave_js_server_python-0.66.0/zwave_js_server_python.egg-info → zwave_js_server_python-0.67.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: zwave-js-server-python
-Version: 0.66.0
+Version: 0.67.1
 Summary: Python wrapper for zwave-js-server
 Author-email: Home Assistant Team <hello@home-assistant.io>
 License-Expression: Apache-2.0
@@ -19,7 +19,6 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: aiohttp>3
 Requires-Dist: pydantic>=2.0.0
-Requires-Dist: typing_extensions>=4.13.0; python_version < "3.14"
 Dynamic: license-file
 
 # zwave-js-server-python

{zwave_js_server_python-0.66.0 → zwave_js_server_python-0.67.1}/pyproject.toml

@@ -22,7 +22,6 @@ classifiers = [
 dependencies = [
     "aiohttp>3",
     "pydantic>=2.0.0",
-    "typing_extensions>=4.13.0;python_version<'3.14'",
 ]
 dynamic = ["version"]
 
@@ -44,8 +43,6 @@ zwave_js_server = ["py.typed"]
 
 [tool.mypy]
 plugins = ["pydantic.mypy"]
-follow_imports = "skip"
-ignore_missing_imports = true
 check_untyped_defs = true
 disallow_incomplete_defs = true
 disallow_untyped_calls = true

{zwave_js_server_python-0.66.0 → zwave_js_server_python-0.67.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.66.0"
+__version__ = "0.67.1"
 
 # 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_python-0.66.0 → zwave_js_server_python-0.67.1}/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_python-0.66.0 → zwave_js_server_python-0.67.1}/zwave_js_server/model/driver/__init__.py

@@ -2,16 +2,20 @@
 
 from __future__ import annotations
 
-import sys
 from typing import TYPE_CHECKING, Any, Literal, cast
 
-from pydantic import create_model
+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,
@@ -19,11 +23,6 @@ from .firmware import (
     DriverFirmwareUpdateResultDataType,
 )
 
-if sys.version_info >= (3, 14):
-    from annotationlib import get_annotations
-else:
-    from typing_extensions import get_annotations
-
 if TYPE_CHECKING:
     from ...client import Client
 
@@ -56,11 +55,40 @@ class AllNodesReadyEventModel(BaseDriverEventModel):
     event: Literal["all nodes ready"]
 
 
-LoggingEventModel = create_model(
-    "LoggingEventModel",
-    **{k: (v, None) for k, v in get_annotations(LogMessageDataType).items()},
-    __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):
@@ -221,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_python-0.67.1/zwave_js_server/model/driver/firmware.py

@@ -0,0 +1,65 @@
+"""Provide a model for Z-Wave driver firmware."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from enum import IntEnum
+
+from zwave_js_server.model.firmware import (
+    FirmwareUpdateData,
+    FirmwareUpdateDataDataType,
+    FirmwareUpdateProgress,
+    FirmwareUpdateProgressDataType,
+    FirmwareUpdateResult,
+    FirmwareUpdateResultDataType,
+)
+
+
+class DriverFirmwareUpdateDataDataType(FirmwareUpdateDataDataType):
+    """Represent a driver firmware update data dict type."""
+
+
+@dataclass
+class DriverFirmwareUpdateData(FirmwareUpdateData):
+    """Driver firmware update data."""
+
+
+class DriverFirmwareUpdateStatus(IntEnum):
+    """Enum with all driver firmware update status values.
+
+    https://zwave-js.github.io/node-zwave-js/#/api/driver?id=quotfirmware-update-finishedquot
+    """
+
+    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
+    # This driver does not support firmware updates
+    ERROR_NOT_SUPPORTED = 3
+    OK = 255
+
+
+class DriverFirmwareUpdateProgressDataType(FirmwareUpdateProgressDataType):
+    """Represent a driver firmware update progress dict type."""
+
+
+@dataclass
+class DriverFirmwareUpdateProgress(FirmwareUpdateProgress):
+    """Model for a driver firmware update progress data."""
+
+    data: DriverFirmwareUpdateProgressDataType = field(repr=False)
+
+
+class DriverFirmwareUpdateResultDataType(FirmwareUpdateResultDataType):
+    """Represent a driver firmware update result dict type."""
+
+
+@dataclass
+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)
+    _status_class = DriverFirmwareUpdateStatus

zwave_js_server_python-0.67.1/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_python-0.66.0 → zwave_js_server_python-0.67.1}/zwave_js_server/model/node/__init__.py

@@ -395,7 +395,7 @@ class Node(EventBase):
             values = {
                 value_id: value
                 for value_id, value in self.values.items()
-                if self.index == value.endpoint
+                if endpoint_idx == value.endpoint
             }
             if endpoint_idx in self.endpoints:
                 self.endpoints[endpoint_idx].update(endpoint, values)
@@ -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_python-0.66.0 → zwave_js_server_python-0.67.1}/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_python-0.66.0 → zwave_js_server_python-0.67.1/zwave_js_server_python.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: zwave-js-server-python
-Version: 0.66.0
+Version: 0.67.1
 Summary: Python wrapper for zwave-js-server
 Author-email: Home Assistant Team <hello@home-assistant.io>
 License-Expression: Apache-2.0
@@ -19,7 +19,6 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: aiohttp>3
 Requires-Dist: pydantic>=2.0.0
-Requires-Dist: typing_extensions>=4.13.0; python_version < "3.14"
 Dynamic: license-file
 
 # zwave-js-server-python

{zwave_js_server_python-0.66.0 → zwave_js_server_python-0.67.1}/zwave_js_server_python.egg-info/SOURCES.txt

@@ -39,6 +39,7 @@ zwave_js_server/model/device_class.py
 zwave_js_server/model/device_config.py
 zwave_js_server/model/duration.py
 zwave_js_server/model/endpoint.py
+zwave_js_server/model/firmware.py
 zwave_js_server/model/log_config.py
 zwave_js_server/model/log_message.py
 zwave_js_server/model/notification.py

zwave_js_server_python-0.67.1/zwave_js_server_python.egg-info/requires.txt

@@ -0,0 +1,2 @@
+aiohttp>3
+pydantic>=2.0.0

zwave_js_server_python-0.66.0/zwave_js_server/model/driver/firmware.py

@@ -1,97 +0,0 @@
-"""Provide a model for Z-Wave driver firmware."""
-
-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
-
-
-class DriverFirmwareUpdateDataDataType(TypedDict, total=False):
-    """Represent a driver firmware update data dict type."""
-
-    filename: str  # required
-    file: str  # required
-    fileFormat: str
-
-
-@dataclass
-class DriverFirmwareUpdateData:
-    """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.
-
-    https://zwave-js.github.io/node-zwave-js/#/api/driver?id=quotfirmware-update-finishedquot
-    """
-
-    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
-    # This driver does not support firmware updates
-    ERROR_NOT_SUPPORTED = 3
-    OK = 255
-
-
-class DriverFirmwareUpdateProgressDataType(TypedDict):
-    """Represent a driver firmware update progress dict type."""
-
-    sentFragments: int
-    totalFragments: int
-    progress: float
-
-
-@dataclass
-class DriverFirmwareUpdateProgress:
-    """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):
-    """Represent a driver firmware update result dict type."""
-
-    status: int
-    success: bool
-
-
-@dataclass
-class DriverFirmwareUpdateResult:
-    """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"]

zwave_js_server_python-0.66.0/zwave_js_server_python.egg-info/requires.txt

@@ -1,5 +0,0 @@
-aiohttp>3
-pydantic>=2.0.0
-
-[:python_version < "3.14"]
-typing_extensions>=4.13.0