zwave-js-server-python 0.69.0__tar.gz → 0.70.0__tar.gz

{zwave_js_server_python-0.69.0/zwave_js_server_python.egg-info → zwave_js_server_python-0.70.0}/PKG-INFO

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

{zwave_js_server_python-0.69.0 → zwave_js_server_python-0.70.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.69.0"
+__version__ = "0.70.0"
 
 # minimal server schema version we can handle
-MIN_SERVER_SCHEMA_VERSION = 44
+MIN_SERVER_SCHEMA_VERSION = 47
 # max server schema version we can handle (and our code is compatible with)
-MAX_SERVER_SCHEMA_VERSION = 45
+MAX_SERVER_SCHEMA_VERSION = 47
 
 VALUE_UNKNOWN = "unknown"
 
@@ -457,7 +457,7 @@ class DateAndTimeDataType(TypedDict, total=False):
     standardOffset: int
 
 
-@dataclass
+@dataclass(frozen=True)
 class DateAndTime:
     """Represent a date and time."""
 
@@ -474,16 +474,16 @@ class DateAndTime:
 
     def __post_init__(self) -> None:
         """Post initialization."""
-        self.hour = self.data.get("hour")
-        self.minute = self.data.get("minute")
+        object.__setattr__(self, "hour", self.data.get("hour"))
+        object.__setattr__(self, "minute", self.data.get("minute"))
         if weekday := self.data.get("weekday"):
-            self.weekday = Weekday(weekday)
-        self.second = self.data.get("second")
-        self.year = self.data.get("year")
-        self.month = self.data.get("month")
-        self.day = self.data.get("day")
-        self.dst_offset = self.data.get("dstOffset")
-        self.standard_offset = self.data.get("standardOffset")
+            object.__setattr__(self, "weekday", Weekday(weekday))
+        object.__setattr__(self, "second", self.data.get("second"))
+        object.__setattr__(self, "year", self.data.get("year"))
+        object.__setattr__(self, "month", self.data.get("month"))
+        object.__setattr__(self, "day", self.data.get("day"))
+        object.__setattr__(self, "dst_offset", self.data.get("dstOffset"))
+        object.__setattr__(self, "standard_offset", self.data.get("standardOffset"))
 
 
 class ControllerStatus(IntEnum):

{zwave_js_server_python-0.69.0 → zwave_js_server_python-0.70.0}/zwave_js_server/const/command_class/lock.py

@@ -151,7 +151,7 @@ class DoorLockCCConfigurationSetOptionsDataType(TypedDict, total=False):
 DEFAULT_HANDLE_CONFIGURATION = [True, True, True, True]
 
 
-@dataclass
+@dataclass(frozen=True)
 class DoorLockCCConfigurationSetOptions:
     """Door Lock CC Configuration Set command options."""
 
@@ -173,7 +173,7 @@ class DoorLockCCConfigurationSetOptions:
             "outside_handles_can_open_door_configuration",
         ):
             if not getattr(self, attr_name):
-                setattr(self, attr_name, DEFAULT_HANDLE_CONFIGURATION)
+                object.__setattr__(self, attr_name, list(DEFAULT_HANDLE_CONFIGURATION))
 
     def to_dict(self) -> DoorLockCCConfigurationSetOptionsDataType:
         """Convert command options to dict."""

{zwave_js_server_python-0.69.0 → zwave_js_server_python-0.70.0}/zwave_js_server/model/association.py

@@ -10,7 +10,7 @@ if TYPE_CHECKING:
     from .node import Node
 
 
-@dataclass
+@dataclass(frozen=True)
 class AssociationGroup:
     """Represent a association group dict type."""
 
@@ -22,7 +22,7 @@ class AssociationGroup:
     issued_commands: dict[int, list[int]] = field(default_factory=dict)
 
 
-@dataclass
+@dataclass(frozen=True)
 class AssociationAddress:
     """Represent a association dict type."""
 

{zwave_js_server_python-0.69.0 → zwave_js_server_python-0.70.0}/zwave_js_server/model/controller/__init__.py

@@ -2,7 +2,7 @@
 
 from __future__ import annotations
 
-from dataclasses import dataclass
+from functools import cached_property
 import logging
 from typing import TYPE_CHECKING, Any, Literal, cast
 
@@ -26,7 +26,13 @@ from ...util.helpers import convert_base64_to_bytes, convert_bytes_to_base64
 from ..association import AssociationAddress, AssociationGroup
 from ..node import Node
 from ..node.firmware import NodeFirmwareUpdateResult
-from .data_model import ControllerDataType
+from .data_model import (
+    BackgroundRSSI,
+    ControllerDataType,
+    NVMProgress,
+    ZWaveApiVersionDataType,
+    ZWaveChipType,
+)
 from .event_model import CONTROLLER_EVENT_MODEL_MAP
 from .inclusion_and_provisioning import (
     InclusionGrant,
@@ -64,14 +70,6 @@ DEFAULT_CONTROLLER_STATISTICS = (  # pylint: disable=invalid-name
 )
 
 
-@dataclass
-class NVMProgress:
-    """Class to represent an NVM backup/restore progress event."""
-
-    bytes_read_or_written: int
-    total_bytes: int
-
-
 class Controller(EventBase):
     """Represent a Z-Wave JS controller."""
 
@@ -247,9 +245,37 @@ class Controller(EventBase):
         """Return whether controller supports long range or not."""
         return self.data.get("supportsLongRange")
 
+    @property
+    def is_sis(self) -> bool | None:
+        """Return whether the controller is the SIS (Static Information Source)."""
+        return self.data.get("isSIS")
+
+    @property
+    def max_payload_size(self) -> int | None:
+        """Return the maximum Z-Wave payload size in bytes."""
+        return self.data.get("maxPayloadSize")
+
+    @property
+    def max_payload_size_lr(self) -> int | None:
+        """Return the maximum Long Range payload size in bytes."""
+        return self.data.get("maxPayloadSizeLR")
+
+    @property
+    def zwave_api_version(self) -> ZWaveApiVersionDataType | None:
+        """Return the Z-Wave API version (kind + version) supported by the controller."""
+        return self.data.get("zwaveApiVersion")
+
+    @cached_property
+    def zwave_chip_type(self) -> ZWaveChipType | None:
+        """Return the Z-Wave chip type."""
+        if (raw := self.data.get("zwaveChipType")) is None:
+            return None
+        return ZWaveChipType.from_dict(raw)
+
     def update(self, data: ControllerDataType) -> None:
         """Update controller data."""
         self.data = data
+        self.__dict__.pop("zwave_chip_type", None)
         self._statistics = ControllerStatistics(
             self.data.get("statistics", DEFAULT_CONTROLLER_STATISTICS)
         )
@@ -887,6 +913,107 @@ class Controller(EventBase):
         )
         return cast(bool, data["progress"])
 
+    async def async_get_background_rssi(self) -> BackgroundRSSI:
+        """Send getBackgroundRSSI command to Controller."""
+        data = await self.client.async_send_command(
+            {"command": "controller.get_background_rssi"},
+            require_schema=47,
+        )
+        return BackgroundRSSI(
+            channel_0=data["rssiChannel0"],
+            channel_1=data["rssiChannel1"],
+            channel_2=data.get("rssiChannel2"),
+            channel_3=data.get("rssiChannel3"),
+        )
+
+    async def async_get_long_range_nodes(self) -> list[Node]:
+        """Send getLongRangeNodes command to Controller."""
+        data = await self.client.async_send_command(
+            {"command": "controller.get_long_range_nodes"},
+            require_schema=47,
+        )
+        return [self.nodes[nid] for nid in data["nodeIds"]]
+
+    async def async_get_all_association_groups(
+        self, node: Node
+    ) -> dict[int, dict[int, AssociationGroup]]:
+        """Send getAllAssociationGroups command to Controller."""
+        data = await self.client.async_send_command(
+            {
+                "command": "controller.get_all_association_groups",
+                "nodeId": node.node_id,
+            },
+            require_schema=47,
+        )
+        return {
+            int(endpoint_id): {
+                int(group_id): AssociationGroup(
+                    max_nodes=group["maxNodes"],
+                    is_lifeline=group["isLifeline"],
+                    multi_channel=group["multiChannel"],
+                    label=group["label"],
+                    profile=group.get("profile"),
+                    issued_commands={
+                        int(cc): cmds
+                        for cc, cmds in group.get("issuedCommands", {}).items()
+                    },
+                )
+                for group_id, group in groups.items()
+            }
+            for endpoint_id, groups in data["groups"].items()
+        }
+
+    async def async_get_all_associations(
+        self, node: Node
+    ) -> dict[int, dict[int, dict[int, list[AssociationAddress]]]]:
+        """Send getAllAssociations command to Controller."""
+        data = await self.client.async_send_command(
+            {
+                "command": "controller.get_all_associations",
+                "nodeId": node.node_id,
+            },
+            require_schema=47,
+        )
+        return {
+            int(node_id_str): {
+                int(endpoint_id): {
+                    int(group_id): [
+                        AssociationAddress(
+                            self,
+                            node_id=addr["nodeId"],
+                            endpoint=addr.get("endpoint"),
+                        )
+                        for addr in addresses
+                    ]
+                    for group_id, addresses in groups.items()
+                }
+                for endpoint_id, groups in endpoints.items()
+            }
+            for node_id_str, endpoints in data["associations"].items()
+        }
+
+    async def async_get_all_available_firmware_updates(
+        self,
+        api_key: str,
+        include_prereleases: bool = True,
+        rf_region: RFRegion | None = None,
+    ) -> dict[int, list[NodeFirmwareUpdateInfo]]:
+        """Send getAllAvailableFirmwareUpdates command to Controller."""
+        cmd: dict[str, Any] = {
+            "command": "controller.get_all_available_firmware_updates",
+            "apiKey": api_key,
+            "includePrereleases": include_prereleases,
+        }
+        if rf_region is not None:
+            cmd["rfRegion"] = rf_region.value
+        data = await self.client.async_send_command(cmd, require_schema=47)
+        return {
+            int(node_id): [
+                NodeFirmwareUpdateInfo.from_dict(update) for update in updates
+            ]
+            for node_id, updates in data["updates"].items()
+        }
+
     def receive_event(self, event: Event) -> None:
         """Receive an event."""
         if event.data["source"] == "node":
@@ -1014,3 +1141,26 @@ class Controller(EventBase):
         """Process a status changed event."""
         self.data["status"] = event.data["status"]
         event.data["status"] = ControllerStatus(event.data["status"])
+
+    def handle_network_found(self, _event: Event) -> None:
+        """Process a `network found` event without mutating controller identity."""
+        # TODO: Revisit whether `homeId` / `ownNodeId` from this event should
+        # update `self.data` once upstream semantics are confirmed.
+
+    def handle_network_joined(self, event: Event) -> None:
+        """Process a `network joined` event (schema 47+)."""
+
+    def handle_network_left(self, event: Event) -> None:
+        """Process a `network left` event (schema 47+)."""
+
+    def handle_joining_network_failed(self, event: Event) -> None:
+        """Process a `joining network failed` event (schema 47+)."""
+
+    def handle_joining_network_show_dsk(self, event: Event) -> None:
+        """Process a `joining network show dsk` event (schema 47+)."""
+
+    def handle_joining_network_done(self, event: Event) -> None:
+        """Process a `joining network done` event (schema 47+)."""
+
+    def handle_leaving_network_failed(self, event: Event) -> None:
+        """Process a `leaving network failed` event (schema 47+)."""

zwave_js_server_python-0.70.0/zwave_js_server/model/controller/data_model.py

@@ -0,0 +1,98 @@
+"""Data model for a Z-Wave JS controller."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Literal, TypedDict
+
+from .statistics import ControllerStatisticsDataType
+
+
+class ZWaveApiVersionDataType(TypedDict):
+    """Represent a Z-Wave API version (schema 47+)."""
+
+    kind: Literal["official", "legacy"]
+    version: int
+
+
+class UnknownZWaveChipTypeDataType(TypedDict):
+    """Represent an unknown Z-Wave chip type descriptor (schema 47+)."""
+
+    type: int
+    version: int
+
+
+@dataclass(frozen=True)
+class ZWaveChipType:
+    """Z-Wave chip type descriptor (schema 47+).
+
+    For known chips, `name` is set (e.g. ``"ZW0700"``).
+    For unknown chips, `type` and `version` are set instead.
+    """
+
+    name: str | None = None
+    type: int | None = None
+    version: int | None = None
+
+    @classmethod
+    def from_dict(cls, data: str | UnknownZWaveChipTypeDataType) -> ZWaveChipType:
+        """Initialize from dict."""
+        if isinstance(data, str):
+            return cls(name=data)
+        return cls(type=data["type"], version=data["version"])
+
+
+@dataclass(frozen=True)
+class NVMProgress:
+    """Class to represent an NVM operation progress event.
+
+    Used for backup, restore, and convert progress updates.
+    """
+
+    bytes_read_or_written: int
+    total_bytes: int
+
+
+@dataclass(frozen=True)
+class BackgroundRSSI:
+    """Background RSSI noise levels for all channels."""
+
+    channel_0: int
+    channel_1: int
+    channel_2: int | None = None
+    channel_3: int | None = None
+
+
+class ControllerDataType(TypedDict, total=False):
+    """Represent a controller data dict type."""
+
+    sdkVersion: str
+    type: int
+    homeId: int
+    ownNodeId: int
+    isPrimary: bool
+    isSUC: bool
+    nodeType: int
+    isUsingHomeIdFromOtherNetwork: bool
+    isSISPresent: bool
+    wasRealPrimary: bool
+    firmwareVersion: str
+    manufacturerId: int
+    productType: int
+    productId: int
+    supportedFunctionTypes: list[int]
+    sucNodeId: int
+    supportsTimers: bool
+    isRebuildingRoutes: bool
+    statistics: ControllerStatisticsDataType
+    inclusionState: int
+    rfRegion: int
+    status: int
+    rebuildRoutesProgress: dict[str, str]
+    supportsLongRange: bool
+    # Schema 47+ properties
+    isSIS: bool
+    maxPayloadSize: int
+    maxPayloadSizeLR: int
+    zwaveApiVersion: ZWaveApiVersionDataType
+    zwaveChipType: str | UnknownZWaveChipTypeDataType

{zwave_js_server_python-0.69.0 → zwave_js_server_python-0.70.0}/zwave_js_server/model/controller/event_model.py

@@ -303,11 +303,82 @@ class StatusChangedEventModel(BaseControllerEventModel):
         )
 
 
+class NetworkFoundEventModel(BaseControllerEventModel):
+    """Model for `network found` event data (schema 47+)."""
+
+    event: Literal["network found"]
+    homeId: int
+    ownNodeId: int
+
+    @classmethod
+    def from_dict(cls, data: dict) -> NetworkFoundEventModel:
+        """Initialize from dict."""
+        return cls(
+            source=data["source"],
+            event=data["event"],
+            homeId=data["homeId"],
+            ownNodeId=data["ownNodeId"],
+        )
+
+
+class NetworkJoinedEventModel(BaseControllerEventModel):
+    """Model for `network joined` event data (schema 47+)."""
+
+    event: Literal["network joined"]
+
+
+class NetworkLeftEventModel(BaseControllerEventModel):
+    """Model for `network left` event data (schema 47+)."""
+
+    event: Literal["network left"]
+
+
+class JoiningNetworkFailedEventModel(BaseControllerEventModel):
+    """Model for `joining network failed` event data (schema 47+)."""
+
+    event: Literal["joining network failed"]
+
+
+class LeavingNetworkFailedEventModel(BaseControllerEventModel):
+    """Model for `leaving network failed` event data (schema 47+)."""
+
+    event: Literal["leaving network failed"]
+
+
+class JoiningNetworkShowDSKEventModel(BaseControllerEventModel):
+    """Model for `joining network show dsk` event data (schema 47+)."""
+
+    event: Literal["joining network show dsk"]
+    dsk: str
+
+    @classmethod
+    def from_dict(cls, data: dict) -> JoiningNetworkShowDSKEventModel:
+        """Initialize from dict."""
+        return cls(
+            source=data["source"],
+            event=data["event"],
+            dsk=data["dsk"],
+        )
+
+
+class JoiningNetworkDoneEventModel(BaseControllerEventModel):
+    """Model for `joining network done` event data (schema 47+)."""
+
+    event: Literal["joining network done"]
+
+
 CONTROLLER_EVENT_MODEL_MAP: dict[str, type[BaseControllerEventModel]] = {
     "exclusion failed": ExclusionFailedEventModel,
     "exclusion started": ExclusionStartedEventModel,
     "exclusion stopped": ExclusionStoppedEventModel,
     "grant security classes": GrantSecurityClassesEventModel,
+    "joining network done": JoiningNetworkDoneEventModel,
+    "joining network failed": JoiningNetworkFailedEventModel,
+    "joining network show dsk": JoiningNetworkShowDSKEventModel,
+    "leaving network failed": LeavingNetworkFailedEventModel,
+    "network found": NetworkFoundEventModel,
+    "network joined": NetworkJoinedEventModel,
+    "network left": NetworkLeftEventModel,
     "rebuild routes done": RebuildRoutesDoneEventModel,
     "rebuild routes progress": RebuildRoutesProgressEventModel,
     "identify": IdentifyEventModel,

{zwave_js_server_python-0.69.0 → zwave_js_server_python-0.70.0}/zwave_js_server/model/controller/inclusion_and_provisioning.py

@@ -16,7 +16,7 @@ class InclusionGrantDataType(TypedDict):
     clientSideAuth: bool
 
 
-@dataclass
+@dataclass(frozen=True)
 class InclusionGrant:
     """Representation of an inclusion grant."""
 
@@ -41,7 +41,7 @@ class InclusionGrant:
         )
 
 
-@dataclass
+@dataclass(frozen=True)
 class ProvisioningEntry:
     """Class to represent the base fields of a provisioning entry."""
 
@@ -82,19 +82,28 @@ class ProvisioningEntry:
             for k, v in data.items()
             if k not in ("dsk", "securityClasses", "requestedSecurityClasses", "status")
         }:
-            cls_instance.additional_properties = additional_properties
+            object.__setattr__(
+                cls_instance, "additional_properties", additional_properties
+            )
         if "requestedSecurityClasses" in data:
-            cls_instance.requested_security_classes = [
-                SecurityClass(sec_cls) for sec_cls in data["requestedSecurityClasses"]
-            ]
+            object.__setattr__(
+                cls_instance,
+                "requested_security_classes",
+                [
+                    SecurityClass(sec_cls)
+                    for sec_cls in data["requestedSecurityClasses"]
+                ],
+            )
         if "status" in data:
-            cls_instance.status = ProvisioningEntryStatus(data["status"])
+            object.__setattr__(
+                cls_instance, "status", ProvisioningEntryStatus(data["status"])
+            )
         if "protocol" in data:
-            cls_instance.protocol = Protocols(data["protocol"])
+            object.__setattr__(cls_instance, "protocol", Protocols(data["protocol"]))
         return cls_instance
 
 
-@dataclass
+@dataclass(frozen=True)
 class QRProvisioningInformationMixin:
     """Mixin class to represent the base fields of a QR provisioning information."""
 
@@ -111,7 +120,7 @@ class QRProvisioningInformationMixin:
     supported_protocols: list[Protocols] | None
 
 
-@dataclass
+@dataclass(frozen=True)
 class QRProvisioningInformation(ProvisioningEntry, QRProvisioningInformationMixin):
     """Representation of provisioning information retrieved from a QR code."""
 
@@ -193,11 +202,20 @@ class QRProvisioningInformation(ProvisioningEntry, QRProvisioningInformationMixi
                 "status",
             )
         }:
-            cls_instance.additional_properties = additional_properties
+            object.__setattr__(
+                cls_instance, "additional_properties", additional_properties
+            )
         if "requestedSecurityClasses" in data:
-            cls_instance.requested_security_classes = [
-                SecurityClass(sec_cls) for sec_cls in data["requestedSecurityClasses"]
-            ]
+            object.__setattr__(
+                cls_instance,
+                "requested_security_classes",
+                [
+                    SecurityClass(sec_cls)
+                    for sec_cls in data["requestedSecurityClasses"]
+                ],
+            )
         if "status" in data:
-            cls_instance.status = ProvisioningEntryStatus(data["status"])
+            object.__setattr__(
+                cls_instance, "status", ProvisioningEntryStatus(data["status"])
+            )
         return cls_instance

{zwave_js_server_python-0.69.0 → zwave_js_server_python-0.70.0}/zwave_js_server/model/controller/rebuild_routes.py

@@ -13,7 +13,7 @@ class RebuildRoutesOptionsDataType(TypedDict, total=False):
     includeSleeping: bool
 
 
-@dataclass
+@dataclass(frozen=True)
 class RebuildRoutesOptions:
     """Represent options for rebuilding routes."""