zwave-js-server-python 0.35.0__py3-none-any.whl → 0.36.0__py3-none-any.whl

zwave_js_server/const/__init__.py

@@ -3,9 +3,9 @@ import sys
 from enum import Enum, IntEnum
 
 # minimal server schema version we can handle
-MIN_SERVER_SCHEMA_VERSION = 15
+MIN_SERVER_SCHEMA_VERSION = 16
 # max server schema version we can handle (and our code is compatible with)
-MAX_SERVER_SCHEMA_VERSION = 15
+MAX_SERVER_SCHEMA_VERSION = 16
 
 TYPING_EXTENSION_FOR_TYPEDDICT_REQUIRED = sys.version_info < (3, 9, 2)
 
@@ -297,3 +297,23 @@ class RFRegion(IntEnum):
     KOREA = 33
     UNKNOWN = 254
     DEFAULT_EU = 255
+
+
+class ProtocolDataRate(IntEnum):
+    """Enum for all known protocol data rates."""
+
+    # https://github.com/zwave-js/node-zwave-js/blob/master/packages/core/src/capabilities/Protocols.ts#L6
+
+    ZWAVE_9K6 = 1
+    ZWAVE_40K = 2
+    ZWAVE_100K = 3
+    LONG_RANGE_100K = 4
+
+
+class RssiError(IntEnum):
+    """Enum for all known RSSI errors."""
+
+    # https://github.com/zwave-js/node-zwave-js/blob/master/packages/zwave-js/src/lib/controller/SendDataShared.ts#L79
+    NOT_AVAILABLE = 127
+    RECEIVER_SATURATED = 126
+    NO_SIGNAL_DETECTED = 125

zwave_js_server/const/command_class/multilevel_switch.py

@@ -1,4 +1,5 @@
 """Constants for the Multilevel Switch CC."""
+from enum import IntEnum
 
 COVER_OPEN_PROPERTY = "Open"
 COVER_UP_PROPERTY = "Up"
@@ -6,3 +7,10 @@ COVER_ON_PROPERTY = "On"
 COVER_CLOSE_PROPERTY = "Close"
 COVER_DOWN_PROPERTY = "Down"
 COVER_OFF_PROPERTY = "Off"
+
+
+class MultilevelSwitchCommand(IntEnum):
+    """Enum for known multilevel switch notifications."""
+
+    START_LEVEL_CHANGE = 4
+    STOP_LEVEL_CHANGE = 5

zwave_js_server/event.py

@@ -57,7 +57,7 @@ class EventBase:
 
     def emit(self, event_name: str, data: dict) -> None:
         """Run all callbacks for an event."""
-        for listener in self._listeners.get(event_name, []):
+        for listener in self._listeners.get(event_name, []).copy():
             listener(data)
 
     def _handle_event_protocol(self, event: Event) -> None:

zwave_js_server/exceptions.py

@@ -1,10 +1,10 @@
 """Exceptions for zwave-js-server."""
-from typing import TYPE_CHECKING, Optional
+from typing import TYPE_CHECKING, List, Optional
 
-from .const import CommandClass
+from .const import RssiError
 
 if TYPE_CHECKING:
-    from .event import Event
+    from .const import CommandClass
     from .model.value import Value
 
 
@@ -129,7 +129,7 @@ class BulkSetConfigParameterFailed(BaseZwaveJSServerError):
 class InvalidCommandClass(BaseZwaveJSServerError):
     """Exception raised when Zwave Value has an invalid command class."""
 
-    def __init__(self, value: "Value", command_class: CommandClass) -> None:
+    def __init__(self, value: "Value", command_class: "CommandClass") -> None:
         """Initialize an invalid Command Class error."""
         self.value = value
         self.command_class = command_class
@@ -159,14 +159,23 @@ class UnknownValueData(BaseZwaveJSServerError):
         )
 
 
-class NotificationHasUnsupportedCommandClass(BaseZwaveJSServerError):
-    """Exception raised when notification is received for an unsupported CC."""
+class RssiErrorReceived(BaseZwaveJSServerError):
+    """Exception raised when an RSSI error is received."""
 
-    def __init__(self, event: "Event", command_class: CommandClass) -> None:
-        """Initialize an invalid Command Class error."""
-        self.event_data = event.data
-        self.command_class = command_class
-        super().__init__(
-            "Notification received with unsupported command class "
-            f"{command_class.name}: {event.data}"
-        )
+    def __init__(self, error: "RssiError") -> None:
+        """Initialize an RSSI error."""
+        self.error = error
+        super().__init__()
+
+
+class RepeaterRssiErrorReceived(BaseZwaveJSServerError):
+    """Exception raised when an RSSI error is received in list of RSSIs."""
+
+    def __init__(self, rssi_list: List[int]) -> None:
+        """Initialize an RSSI error."""
+        self.rssi_list = rssi_list
+        rssi_errors = [item.value for item in RssiError]
+        self.error_list = [
+            RssiError(rssi_) if rssi_ in rssi_errors else None for rssi_ in rssi_list
+        ]
+        super().__init__()

zwave_js_server/model/association.py

@@ -16,7 +16,7 @@ class AssociationGroup:
 
 
 @dataclass
-class Association:
+class AssociationAddress:
     """Represent a association dict type."""
 
     node_id: int

zwave_js_server/model/controller/__init__.py

@@ -12,7 +12,7 @@ from ...const import (
 )
 from ...event import Event, EventBase
 from ...util.helpers import convert_base64_to_bytes, convert_bytes_to_base64
-from ..association import Association, AssociationGroup
+from ..association import AssociationAddress, AssociationGroup
 from ..node import Node
 from .data_model import ControllerDataType
 from .event_model import CONTROLLER_EVENT_MODEL_MAP
@@ -21,7 +21,7 @@ from .inclusion_and_provisioning import (
     ProvisioningEntry,
     QRProvisioningInformation,
 )
-from .statistics import ControllerStatistics
+from .statistics import ControllerLifelineRoutes, ControllerStatistics
 
 if TYPE_CHECKING:
     from ...client import Client
@@ -44,6 +44,7 @@ class Controller(EventBase):
         self.client = client
         self.nodes: Dict[int, Node] = {}
         self._heal_network_progress: Optional[Dict[int, str]] = None
+        self._statistics = ControllerStatistics()
         for node_state in state["nodes"]:
             node = Node(client, node_state)
             self.nodes[node.node_id] = node
@@ -64,9 +65,9 @@ class Controller(EventBase):
         return self.home_id == other.home_id
 
     @property
-    def library_version(self) -> Optional[str]:
-        """Return library_version."""
-        return self.data.get("libraryVersion")
+    def sdk_version(self) -> Optional[str]:
+        """Return sdk_version."""
+        return self.data.get("sdkVersion")
 
     @property
     def controller_type(self) -> Optional[int]:
@@ -114,9 +115,9 @@ class Controller(EventBase):
         return self.data.get("isSlave")
 
     @property
-    def serial_api_version(self) -> Optional[str]:
-        """Return serial_api_version."""
-        return self.data.get("serialApiVersion")
+    def firmware_version(self) -> Optional[str]:
+        """Return firmware_version."""
+        return self.data.get("firmwareVersion")
 
     @property
     def manufacturer_id(self) -> Optional[int]:
@@ -420,18 +421,21 @@ class Controller(EventBase):
         return cast(bool, data["failed"])
 
     async def async_get_association_groups(
-        self, node_id: int
+        self, source: AssociationAddress
     ) -> Dict[int, AssociationGroup]:
         """Send getAssociationGroups command to Controller."""
+        source_data = {"nodeId": source.node_id}
+        if source.endpoint is not None:
+            source_data["endpoint"] = source.endpoint
         data = await self.client.async_send_command(
             {
                 "command": "controller.get_association_groups",
-                "nodeId": node_id,
+                **source_data,
             }
         )
         groups = {}
         for key, group in data["groups"].items():
-            groups[key] = AssociationGroup(
+            groups[int(key)] = AssociationGroup(
                 max_nodes=group["maxNodes"],
                 is_lifeline=group["isLifeline"],
                 multi_channel=group["multiChannel"],
@@ -441,84 +445,125 @@ class Controller(EventBase):
             )
         return groups
 
-    async def async_get_associations(self, node_id: int) -> Dict[int, Association]:
+    async def async_get_associations(
+        self, source: AssociationAddress
+    ) -> Dict[int, List[AssociationAddress]]:
         """Send getAssociations command to Controller."""
+        source_data = {"nodeId": source.node_id}
+        if source.endpoint is not None:
+            source_data["endpoint"] = source.endpoint
         data = await self.client.async_send_command(
             {
                 "command": "controller.get_associations",
-                "nodeId": node_id,
+                **source_data,
             }
         )
         associations = {}
-        for key, association in data["associations"].items():
-            associations[key] = Association(
-                node_id=association["nodeId"], endpoint=association.get("endpoint")
-            )
+        for key, association_addresses in data["associations"].items():
+            associations[int(key)] = [
+                AssociationAddress(
+                    node_id=association_address["nodeId"],
+                    endpoint=association_address.get("endpoint"),
+                )
+                for association_address in association_addresses
+            ]
         return associations
 
     async def async_is_association_allowed(
-        self, node_id: int, group: int, association: Association
+        self, source: AssociationAddress, group: int, association: AssociationAddress
     ) -> bool:
         """Send isAssociationAllowed command to Controller."""
+        source_data = {"nodeId": source.node_id}
+        if source.endpoint is not None:
+            source_data["endpoint"] = source.endpoint
+
+        association_data = {"nodeId": association.node_id}
+        if association.endpoint is not None:
+            association_data["endpoint"] = association.endpoint
         data = await self.client.async_send_command(
             {
                 "command": "controller.is_association_allowed",
-                "nodeId": node_id,
+                **source_data,
                 "group": group,
-                "association": {
-                    "nodeId": association.node_id,
-                    "endpoint": association.endpoint,
-                },
+                "association": association_data,
             }
         )
         return cast(bool, data["allowed"])
 
     async def async_add_associations(
-        self, node_id: int, group: int, associations: List[Association]
+        self,
+        source: AssociationAddress,
+        group: int,
+        associations: List[AssociationAddress],
+        wait_for_result: bool = False,
     ) -> None:
         """Send addAssociations command to Controller."""
-        await self.client.async_send_command(
-            {
-                "command": "controller.add_associations",
-                "nodeId": node_id,
-                "group": group,
-                "associations": [
-                    {
-                        "nodeId": association.node_id,
-                        "endpoint": association.endpoint,
-                    }
-                    for association in associations
-                ],
-            }
-        )
+        source_data = {"nodeId": source.node_id}
+        if source.endpoint is not None:
+            source_data["endpoint"] = source.endpoint
+
+        associations_data = []
+        for association in associations:
+            association_data = {"nodeId": association.node_id}
+            if association.endpoint is not None:
+                association_data["endpoint"] = association.endpoint
+            associations_data.append(association_data)
+
+        cmd = {
+            "command": "controller.add_associations",
+            **source_data,
+            "group": group,
+            "associations": associations_data,
+        }
+        if wait_for_result:
+            await self.client.async_send_command(cmd)
+        else:
+            await self.client.async_send_command_no_wait(cmd)
 
     async def async_remove_associations(
-        self, node_id: int, group: int, associations: List[Association]
+        self,
+        source: AssociationAddress,
+        group: int,
+        associations: List[AssociationAddress],
+        wait_for_result: bool = False,
     ) -> None:
         """Send removeAssociations command to Controller."""
-        await self.client.async_send_command(
-            {
-                "command": "controller.remove_associations",
-                "nodeId": node_id,
-                "group": group,
-                "associations": [
-                    {
-                        "nodeId": association.node_id,
-                        "endpoint": association.endpoint,
-                    }
-                    for association in associations
-                ],
-            }
-        )
+        source_data = {"nodeId": source.node_id}
+        if source.endpoint is not None:
+            source_data["endpoint"] = source.endpoint
+
+        associations_data = []
+        for association in associations:
+            association_data = {"nodeId": association.node_id}
+            if association.endpoint is not None:
+                association_data["endpoint"] = association.endpoint
+            associations_data.append(association_data)
+
+        cmd = {
+            "command": "controller.remove_associations",
+            **source_data,
+            "group": group,
+            "associations": associations_data,
+        }
+        if wait_for_result:
+            await self.client.async_send_command(cmd)
+        else:
+            await self.client.async_send_command_no_wait(cmd)
 
-    async def async_remove_node_from_all_associations(self, node_id: int) -> None:
+    async def async_remove_node_from_all_associations(
+        self,
+        node_id: int,
+        wait_for_result: bool = False,
+    ) -> None:
         """Send removeNodeFromAllAssociations command to Controller."""
-        await self.client.async_send_command(
-            {
-                "command": "controller.remove_node_from_all_associations",
-                "nodeId": node_id,
-            }
-        )
+        cmd = {
+            "command": "controller.remove_node_from_all_associations",
+            "nodeId": node_id,
+        }
+        if wait_for_result:
+            await self.client.async_send_command(cmd)
+        else:
+            await self.client.async_send_command_no_wait(cmd)
 
     async def async_get_node_neighbors(self, node_id: int) -> List[int]:
         """Send getNodeNeighbors command to Controller to get node's neighbors."""
@@ -629,6 +674,19 @@ class Controller(EventBase):
         )
         return cast(bool, data["success"])
 
+    async def async_get_known_lifeline_routes(
+        self,
+    ) -> Dict[Node, ControllerLifelineRoutes]:
+        """Send getKnownLifelineRoutes command to Controller."""
+        data = await self.client.async_send_command(
+            {"command": "controller.get_known_lifeline_routes"}, require_schema=16
+        )
+
+        return {
+            self.nodes[node_id]: ControllerLifelineRoutes(self.client, lifeline_routes)
+            for node_id, lifeline_routes in data["routes"].items()
+        }
+
     def receive_event(self, event: Event) -> None:
         """Receive an event."""
         if event.data["source"] == "node":
@@ -695,8 +753,9 @@ class Controller(EventBase):
 
     def handle_statistics_updated(self, event: Event) -> None:
         """Process a statistics updated event."""
-        self._statistics.data.update(event.data["statistics"])
-        event.data["statistics_updated"] = self.statistics
+        self._statistics = event.data["statistics_updated"] = ControllerStatistics(
+            event.data["statistics"]
+        )
 
     def handle_grant_security_classes(self, event: Event) -> None:
         """Process a grant security classes event."""

zwave_js_server/model/controller/data_model.py

@@ -13,7 +13,7 @@ else:
 class ControllerDataType(TypedDict, total=False):
     """Represent a controller data dict type."""
 
-    libraryVersion: str
+    sdkVersion: str
     type: int
     homeId: int
     ownNodeId: int
@@ -23,7 +23,7 @@ class ControllerDataType(TypedDict, total=False):
     wasRealPrimary: bool
     isStaticUpdateController: bool
     isSlave: bool
-    serialApiVersion: str
+    firmwareVersion: str
     manufacturerId: int
     productType: int
     productId: int

zwave_js_server/model/controller/statistics.py

@@ -1,13 +1,52 @@
 """Provide a model for the Z-Wave JS controller's statistics."""
-from typing import Optional
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Optional
 
 from ...const import TYPING_EXTENSION_FOR_TYPEDDICT_REQUIRED
+from ..statistics import RouteStatistics, RouteStatisticsDataType
 
 if TYPING_EXTENSION_FOR_TYPEDDICT_REQUIRED:
     from typing_extensions import TypedDict
 else:
     from typing import TypedDict
 
+if TYPE_CHECKING:
+    from ...client import Client
+
+
+class ControllerLifelineRoutesDataType(TypedDict):
+    """Represent a controller lifeline routes data dict type."""
+
+    lwr: RouteStatisticsDataType
+    nlwr: RouteStatisticsDataType
+
+
+@dataclass
+class ControllerLifelineRoutes:
+    """Represent controller lifeline routes."""
+
+    def __init__(
+        self, client: "Client", data: ControllerLifelineRoutesDataType
+    ) -> None:
+        """Initialize controller lifeline routes."""
+        self.data = data
+        self._lwr = None
+        if lwr := self.data.get("lwr"):
+            self._lwr = RouteStatistics(client, lwr)
+        self._nlwr = None
+        if nlwr := self.data.get("nlwr"):
+            self._nlwr = RouteStatistics(client, nlwr)
+
+    @property
+    def lwr(self) -> Optional[RouteStatistics]:
+        """Return the last working route from the controller to this node."""
+        return self._lwr
+
+    @property
+    def nlwr(self) -> Optional[RouteStatistics]:
+        """Return the next to last working route from the controller to this node."""
+        return self._nlwr
+
 
 class ControllerStatisticsDataType(TypedDict):
     """Represent a controller statistics data dict type."""

zwave_js_server/model/device_config.py

@@ -3,7 +3,7 @@ Model for a Zwave Node's device config.
 
 https://zwave-js.github.io/node-zwave-js/#/api/node?id=deviceconfig
 """
-from typing import Dict, List, Literal, Optional, Union
+from typing import Any, Dict, List, Literal, Optional, Union
 
 from ..const import TYPING_EXTENSION_FOR_TYPEDDICT_REQUIRED
 
@@ -138,7 +138,7 @@ class DeviceConfigDataType(TypedDict, total=False):
     paramInformation: Dict[str, dict]
     supportsZWavePlus: bool
     proprietary: dict
-    compat: Dict[str, dict]
+    compat: Dict[str, Any]
     metadata: DeviceMetadataDataType
     isEmbedded: bool
 

zwave_js_server/model/driver.py

@@ -161,6 +161,10 @@ class Driver(EventBase):
             "set_preferred_scales", scales=scales, require_schema=6
         )
 
+    async def async_enable_error_reporting(self) -> None:
+        """Send command to enable Sentry error reporting."""
+        await self._async_send_command("enable_error_reporting", require_schema=16)
+
     def handle_logging(self, event: Event) -> None:
         """Process a driver logging event."""
         event.data["log_message"] = LogMessage(cast(LogMessageDataType, event.data))

zwave_js_server/model/endpoint.py

@@ -49,6 +49,24 @@ class Endpoint(EventBase):
         self.values: Dict[str, Union[ConfigurationValue, Value]] = {}
         self.update(data, values)
 
+    def __repr__(self) -> str:
+        """Return the representation."""
+        return f"{type(self).__name__}(node_id={self.node_id}, index={self.index})"
+
+    def __hash__(self) -> int:
+        """Return the hash."""
+        return hash((self.client.driver, self.node_id, self.index))
+
+    def __eq__(self, other: object) -> bool:
+        """Return whether this instance equals another."""
+        if not isinstance(other, Endpoint):
+            return False
+        return (
+            self.client.driver == other.client.driver
+            and self.node_id == other.node_id
+            and self.index == other.index
+        )
+
     @property
     def node_id(self) -> int:
         """Return node ID property."""

zwave_js_server/model/log_message.py

@@ -13,7 +13,7 @@ class LogMessageContextDataType(TypedDict, total=False):
     """Represent a log message context data dict type."""
 
     source: Literal["config", "serial", "controller", "driver"]  # required
-    type: Literal["value", "node"]
+    type: Literal["controller", "value", "node"]
     nodeId: int
     header: str
     direction: Literal["inbound", "outbound", "none"]
@@ -38,7 +38,7 @@ class LogMessageContext:
         return self.data["source"]
 
     @property
-    def type(self) -> Optional[Literal["value", "node"]]:
+    def type(self) -> Optional[Literal["controller", "value", "node"]]:
         """Return the object type for the log message if applicable."""
         return self.data.get("type")
 

zwave_js_server/model/node/__init__.py

@@ -1,4 +1,5 @@
 """Provide a model for the Z-Wave JS node."""
+import logging
 from typing import TYPE_CHECKING, Any, Dict, List, Optional, Union, cast
 
 from ...const import (
@@ -12,7 +13,6 @@ from ...event import Event, EventBase
 from ...exceptions import (
     FailedCommand,
     NotFoundError,
-    NotificationHasUnsupportedCommandClass,
     UnparseableValue,
     UnwriteableValue,
 )
@@ -33,6 +33,8 @@ from ..notification import (
     NotificationNotificationDataType,
     PowerLevelNotification,
     PowerLevelNotificationDataType,
+    MultilevelSwitchNotification,
+    MultilevelSwitchNotificationDataType,
 )
 from ..value import (
     ConfigurationValue,
@@ -58,6 +60,9 @@ if TYPE_CHECKING:
     from ...client import Client
 
 
+_LOGGER = logging.getLogger(__package__)
+
+
 class Node(EventBase):
     """Represent a Z-Wave JS node."""
 
@@ -67,7 +72,7 @@ class Node(EventBase):
         self.client = client
         self.data: NodeDataType = {}
         self._device_config: DeviceConfig = DeviceConfig({})
-        self._statistics: NodeStatistics = NodeStatistics()
+        self._statistics: NodeStatistics = NodeStatistics(client)
         self._firmware_update_progress: Optional[FirmwareUpdateProgress] = None
         self.values: Dict[str, Union[ConfigurationValue, Value]] = {}
         self.endpoints: Dict[int, Endpoint] = {}
@@ -152,7 +157,9 @@ class Node(EventBase):
     @property
     def is_secure(self) -> Optional[bool]:
         """Return the is_secure."""
-        return self.data.get("isSecure")
+        if (is_secure := self.data.get("isSecure")) == "unknown":
+            return None
+        return is_secure
 
     @property
     def protocol_version(self) -> Optional[int]:
@@ -300,7 +307,7 @@ class Node(EventBase):
         """Update the internal state data."""
         self.data = data
         self._device_config = DeviceConfig(self.data.get("deviceConfig", {}))
-        self._statistics = NodeStatistics(self.data.get("statistics"))
+        self._statistics = NodeStatistics(self.client, self.data.get("statistics"))
 
         # Remove stale values
         value_ids = (_get_value_id_from_dict(self, val) for val in data["values"])
@@ -778,6 +785,10 @@ class Node(EventBase):
             event.data["notification"] = NotificationNotification(
                 self, cast(NotificationNotificationDataType, event.data)
             )
+        elif command_class == CommandClass.SWITCH_MULTILEVEL:
+            event.data["notification"] = MultilevelSwitchNotification(
+                self, cast(MultilevelSwitchNotificationDataType, event.data)
+            )
         elif command_class == CommandClass.ENTRY_CONTROL:
             event.data["notification"] = EntryControlNotification(
                 self, cast(EntryControlNotificationDataType, event.data)
@@ -787,7 +798,7 @@ class Node(EventBase):
                 self, cast(PowerLevelNotificationDataType, event.data)
             )
         else:
-            raise NotificationHasUnsupportedCommandClass(event, command_class)
+            _LOGGER.info("Unhandled notification command class: %s", command_class.name)
 
     def handle_firmware_update_progress(self, event: Event) -> None:
         """Process a node firmware update progress event."""
@@ -806,5 +817,6 @@ class Node(EventBase):
 
     def handle_statistics_updated(self, event: Event) -> None:
         """Process a statistics updated event."""
-        self._statistics.data.update(event.data["statistics"])
-        event.data["statistics_updated"] = self.statistics
+        event.data["statistics_updated"] = self._statistics = NodeStatistics(
+            self.client, event.data["statistics"]
+        )

zwave_js_server/model/node/data_model.py

@@ -1,5 +1,5 @@
 """Data model for a Z-Wave JS node."""
-from typing import List, Optional, Union
+from typing import List, Literal, Optional, Union
 
 from ...const import TYPING_EXTENSION_FOR_TYPEDDICT_REQUIRED
 from ..device_class import DeviceClassDataType
@@ -33,7 +33,7 @@ class NodeDataType(TypedDict, total=False):
     isRouting: bool
     maxDataRate: int
     supportedDataRates: List[int]
-    isSecure: bool
+    isSecure: Union[bool, Literal["unknown"]]
     supportsBeaming: bool
     supportsSecurity: bool
     protocolVersion: int