zwave-js-server-python 0.65.0__tar.gz → 0.67.0__tar.gz

{zwave_js_server_python-0.65.0/zwave_js_server_python.egg-info → zwave_js_server_python-0.67.0}/PKG-INFO

@@ -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 → zwave_js_server_python-0.67.0}/pyproject.toml

@@ -19,7 +19,10 @@ classifiers = [
     "Programming Language :: Python :: 3.13",
     "Topic :: Home Automation",
 ]
-dependencies = ["aiohttp>3", "pydantic>=1.10.0"]
+dependencies = [
+    "aiohttp>3",
+    "pydantic>=2.0.0",
+]
 dynamic = ["version"]
 
 [project.urls]
@@ -40,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.65.0 → zwave_js_server_python-0.67.0}/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_python-0.65.0 → zwave_js_server_python-0.67.0}/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_python-0.65.0 → zwave_js_server_python-0.67.0}/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.65.0 → zwave_js_server_python-0.67.0}/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_python-0.65.0 → zwave_js_server_python-0.67.0}/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_python-0.65.0 → zwave_js_server_python-0.67.0}/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_python-0.67.0/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.0/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.65.0 → zwave_js_server_python-0.67.0}/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_python-0.65.0 → zwave_js_server_python-0.67.0}/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: