zwave-js-server-python 0.35.2__tar.gz → 0.36.0__tar.gz

{zwave-js-server-python-0.35.2 → zwave-js-server-python-0.36.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: zwave-js-server-python
-Version: 0.35.2
+Version: 0.36.0
 Summary: Python wrapper for zwave-js-server
 Home-page: https://github.com/home-assistant-libs/zwave-js-server-python
 Author: Home Assistant Team

{zwave-js-server-python-0.35.2 → zwave-js-server-python-0.36.0}/setup.py

@@ -5,7 +5,7 @@ from setuptools import find_packages, setup
 
 PROJECT_DIR = Path(__file__).parent.resolve()
 README_FILE = PROJECT_DIR / "README.md"
-VERSION = "0.35.2"
+VERSION = "0.36.0"
 
 
 setup(

{zwave-js-server-python-0.35.2 → zwave-js-server-python-0.36.0}/test/test_main.py

@@ -64,7 +64,7 @@ def test_dump_state(
     assert captured.out == (
         "{'type': 'version', 'driverVersion': 'test_driver_version', "
         "'serverVersion': 'test_server_version', 'homeId': 'test_home_id', "
-        "'minSchemaVersion': 0, 'maxSchemaVersion': 15}\n"
+        "'minSchemaVersion': 0, 'maxSchemaVersion': 16}\n"
         "{'type': 'result', 'success': True, 'result': {}, 'messageId': 'api-schema-id'}\n"
         "test_result\n"
     )

{zwave-js-server-python-0.35.2 → zwave-js-server-python-0.36.0}/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-python-0.35.2 → zwave-js-server-python-0.36.0}/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-python-0.35.2 → zwave-js-server-python-0.36.0}/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-python-0.35.2 → zwave-js-server-python-0.36.0}/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-python-0.35.2 → zwave-js-server-python-0.36.0}/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-python-0.35.2 → zwave-js-server-python-0.36.0}/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-python-0.35.2 → zwave-js-server-python-0.36.0}/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-python-0.35.2 → zwave-js-server-python-0.36.0}/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-python-0.35.2 → zwave-js-server-python-0.36.0}/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-python-0.35.2 → zwave-js-server-python-0.36.0}/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-python-0.35.2 → zwave-js-server-python-0.36.0}/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] = {}
@@ -302,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"])
@@ -780,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)
@@ -789,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."""
@@ -808,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-python-0.36.0/zwave_js_server/model/node/statistics.py

@@ -0,0 +1,119 @@
+"""Provide a model for the Z-Wave JS node's statistics."""
+from typing import TYPE_CHECKING, Optional
+
+from zwave_js_server.exceptions import RssiErrorReceived
+
+from ...const import TYPING_EXTENSION_FOR_TYPEDDICT_REQUIRED, RssiError
+from ..statistics import RouteStatistics, RouteStatisticsDataType
+
+if TYPE_CHECKING:
+    from ...client import Client
+
+if TYPING_EXTENSION_FOR_TYPEDDICT_REQUIRED:
+    from typing_extensions import TypedDict
+else:
+    from typing import TypedDict
+
+
+class NodeStatisticsDataType(TypedDict, total=False):
+    """Represent a node statistics data dict type."""
+
+    # https://github.com/zwave-js/node-zwave-js/blob/master/packages/zwave-js/src/lib/node/NodeStatistics.ts#L21-L33
+    commandsTX: int
+    commandsRX: int
+    commandsDroppedTX: int
+    commandsDroppedRX: int
+    timeoutResponse: int
+    rtt: int
+    rssi: int
+    lwr: RouteStatisticsDataType
+    nlwr: RouteStatisticsDataType
+
+
+class NodeStatistics:
+    """Represent a node statistics update."""
+
+    def __init__(
+        self, client: "Client", data: Optional[NodeStatisticsDataType] = None
+    ) -> None:
+        """Initialize node statistics."""
+        self.data = data or NodeStatisticsDataType(
+            commandsDroppedRX=0,
+            commandsDroppedTX=0,
+            commandsRX=0,
+            commandsTX=0,
+            timeoutResponse=0,
+        )
+        self.client = client
+        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 commands_tx(self) -> int:
+        """Return number of commands successfully sent to node."""
+        return self.data["commandsTX"]
+
+    @property
+    def commands_rx(self) -> int:
+        """
+        Return number of commands received from node.
+
+        Includes responses to sent commands.
+        """
+        return self.data["commandsRX"]
+
+    @property
+    def commands_dropped_rx(self) -> int:
+        """Return number of commands from node that were dropped by host."""
+        return self.data["commandsDroppedRX"]
+
+    @property
+    def commands_dropped_tx(self) -> int:
+        """
+        Return number of outgoing commands that were dropped.
+
+        These commands could not be sent.
+        """
+        return self.data["commandsDroppedTX"]
+
+    @property
+    def timeout_response(self) -> int:
+        """Return number of Get-type cmds where node's response didn't come in time."""
+        return self.data["timeoutResponse"]
+
+    @property
+    def rtt(self) -> Optional[int]:
+        """
+        Return average round trip time (RTT) to this node in milliseconds.
+
+        Consecutive measurements are combined using an exponential moving average.
+        """
+        return self.data.get("rtt")
+
+    @property
+    def rssi(self) -> Optional[int]:
+        """
+        Return average RSSI of frames received by this node.
+
+        Consecutive non-error measurements are combined using an exponential moving
+        average.
+        """
+        if (rssi_ := self.data.get("rssi")) is None:
+            return None
+        if rssi_ in [item.value for item in RssiError]:
+            raise RssiErrorReceived(RssiError(rssi_))
+        return rssi_
+
+    @property
+    def lwr(self) -> Optional[RouteStatistics]:
+        """Return last working route from the controller to this node."""
+        return self._lwr
+
+    @property
+    def nlwr(self) -> Optional[RouteStatistics]:
+        """Return next to last working route from the controller to this node."""
+        return self._nlwr

{zwave-js-server-python-0.35.2 → zwave-js-server-python-0.36.0}/zwave_js_server/model/notification.py

@@ -8,6 +8,7 @@ from typing import TYPE_CHECKING, Any, Dict, Literal, Optional, Union
 
 from ..const import TYPING_EXTENSION_FOR_TYPEDDICT_REQUIRED
 from ..const.command_class.power_level import PowerLevelTestStatus
+from ..const.command_class.multilevel_switch import MultilevelSwitchCommand
 from ..util.helpers import parse_buffer
 
 if TYPING_EXTENSION_FOR_TYPEDDICT_REQUIRED:
@@ -184,3 +185,49 @@ class PowerLevelNotification:
     def acknowledged_frames(self) -> int:
         """Return acknowledged frames property."""
         return self.data["args"]["acknowledgedFrames"]
+
+
+class MultilevelSwitchNotificationArgsDataType(TypedDict, total=False):
+    """Represent args for a Multi Level Switch CC notification event data dict type."""
+
+    eventType: int  # required
+    direction: str
+
+
+class MultilevelSwitchNotificationDataType(BaseNotificationDataType):
+    """Represent a Multi Level Switch CC notification event data dict type."""
+
+    args: MultilevelSwitchNotificationArgsDataType  # required
+
+
+class MultilevelSwitchNotification:
+    """Model for a Zwave Node's Multi Level CC notification event."""
+
+    def __init__(
+        self, node: "Node", data: MultilevelSwitchNotificationDataType
+    ) -> None:
+        """Initialize."""
+        self.node = node
+        self.data = data
+
+    @property
+    def node_id(self) -> int:
+        """Return node ID property."""
+        return self.data["nodeId"]
+
+    @property
+    def command_class(self) -> int:
+        """Return command class."""
+        return self.data["ccId"]
+
+    @property
+    def event_type(self) -> MultilevelSwitchCommand:
+        """Return event type property."""
+        return MultilevelSwitchCommand(self.data["args"]["eventType"])
+
+    @property
+    def direction(self) -> Optional[str]:
+        """Return direction property."""
+        if direction := self.data["args"].get("direction"):
+            return direction
+        return None

zwave-js-server-python-0.36.0/zwave_js_server/model/statistics.py

@@ -0,0 +1,77 @@
+"""Common models for statistics."""
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, List, Optional
+
+from zwave_js_server.exceptions import RepeaterRssiErrorReceived, RssiErrorReceived
+
+from ..const import TYPING_EXTENSION_FOR_TYPEDDICT_REQUIRED, ProtocolDataRate, RssiError
+
+if TYPE_CHECKING:
+    from ..client import Client
+    from .node import Node
+
+if TYPING_EXTENSION_FOR_TYPEDDICT_REQUIRED:
+    from typing_extensions import TypedDict
+else:
+    from typing import TypedDict
+
+
+class RouteStatisticsDataType(TypedDict, total=False):
+    """Represent a route statistics data dict type."""
+
+    protocolDataRate: int
+    repeaters: List[int]
+    rssi: int
+    repeaterRSSI: List[int]
+    routeFailedBetween: List[int]
+
+
+@dataclass
+class RouteStatistics:
+    """Represent route statistics."""
+
+    def __init__(self, client: "Client", data: RouteStatisticsDataType) -> None:
+        """Initialize route statistics."""
+        self.data = data
+        self.client = client
+
+    @property
+    def protocol_data_rate(self) -> ProtocolDataRate:
+        """Return protocol data rate."""
+        return ProtocolDataRate(self.data["protocolDataRate"])
+
+    @property
+    def repeaters(self) -> List["Node"]:
+        """Return repeaters."""
+        assert self.client.driver
+        return [
+            self.client.driver.controller.nodes[node_id]
+            for node_id in self.data["repeaters"]
+        ]
+
+    @property
+    def rssi(self) -> Optional[int]:
+        """Return RSSI."""
+        if (rssi := self.data.get("rssi")) is None:
+            return None
+        if rssi in [item.value for item in RssiError]:
+            raise RssiErrorReceived(RssiError(rssi))
+        return rssi
+
+    @property
+    def repeater_rssi(self) -> List[int]:
+        """Return repeater RSSI."""
+        repeater_rssi = self.data.get("repeaterRSSI", [])
+        rssi_errors = [item.value for item in RssiError]
+        if any(rssi_ in rssi_errors for rssi_ in repeater_rssi):
+            raise RepeaterRssiErrorReceived(repeater_rssi)
+
+        return repeater_rssi
+
+    @property
+    def route_failed_between(self) -> Optional[List["Node"]]:
+        """Return route failed between."""
+        if (node_ids := self.data.get("routeFailedBetween")) is None:
+            return None
+        assert self.client.driver
+        return [self.client.driver.controller.nodes[node_id] for node_id in node_ids]

{zwave-js-server-python-0.35.2 → zwave-js-server-python-0.36.0}/zwave_js_server_python.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: zwave-js-server-python
-Version: 0.35.2
+Version: 0.36.0
 Summary: Python wrapper for zwave-js-server
 Home-page: https://github.com/home-assistant-libs/zwave-js-server-python
 Author: Home Assistant Team

{zwave-js-server-python-0.35.2 → zwave-js-server-python-0.36.0}/zwave_js_server_python.egg-info/SOURCES.txt

@@ -43,6 +43,7 @@ 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/model/statistics.py
 zwave_js_server/model/utils.py
 zwave_js_server/model/value.py
 zwave_js_server/model/version.py

zwave-js-server-python-0.35.2/zwave_js_server/model/node/statistics.py

@@ -1,67 +0,0 @@
-"""Provide a model for the Z-Wave JS node's statistics."""
-from typing import Optional
-
-from ...const import TYPING_EXTENSION_FOR_TYPEDDICT_REQUIRED
-
-if TYPING_EXTENSION_FOR_TYPEDDICT_REQUIRED:
-    from typing_extensions import TypedDict
-else:
-    from typing import TypedDict
-
-
-class NodeStatisticsDataType(TypedDict):
-    """Represent a node statistics data dict type."""
-
-    # https://github.com/zwave-js/node-zwave-js/blob/master/packages/zwave-js/src/lib/node/NodeStatistics.ts#L21-L33
-    commandsTX: int
-    commandsRX: int
-    commandsDroppedTX: int
-    commandsDroppedRX: int
-    timeoutResponse: int
-
-
-class NodeStatistics:
-    """Represent a node statistics update."""
-
-    def __init__(self, data: Optional[NodeStatisticsDataType] = None) -> None:
-        """Initialize node statistics."""
-        self.data = data or NodeStatisticsDataType(
-            commandsDroppedRX=0,
-            commandsDroppedTX=0,
-            commandsRX=0,
-            commandsTX=0,
-            timeoutResponse=0,
-        )
-
-    @property
-    def commands_tx(self) -> int:
-        """Return number of commands successfully sent to node."""
-        return self.data["commandsTX"]
-
-    @property
-    def commands_rx(self) -> int:
-        """
-        Return number of commands received from node.
-
-        Includes responses to sent commands.
-        """
-        return self.data["commandsRX"]
-
-    @property
-    def commands_dropped_rx(self) -> int:
-        """Return number of commands from node that were dropped by host."""
-        return self.data["commandsDroppedRX"]
-
-    @property
-    def commands_dropped_tx(self) -> int:
-        """
-        Return number of outgoing commands that were dropped.
-
-        These commands could not be sent.
-        """
-        return self.data["commandsDroppedTX"]
-
-    @property
-    def timeout_response(self) -> int:
-        """Return number of Get-type cmds where node's response didn't come in time."""
-        return self.data["timeoutResponse"]