zwave-js-server-python 0.34.0__py3-none-any.whl → 0.35.2__py3-none-any.whl

zwave_js_server/client.py

@@ -1,12 +1,12 @@
 """Client."""
 import asyncio
+import logging
+import pprint
+import uuid
 from collections import defaultdict
 from copy import deepcopy
 from datetime import datetime
-import logging
 from operator import itemgetter
-import pprint
-import uuid
 from types import TracebackType
 from typing import Any, DefaultDict, Dict, List, Optional, cast
 

zwave_js_server/const/__init__.py

@@ -1,10 +1,13 @@
 """Constants for the Z-Wave JS python library."""
+import sys
 from enum import Enum, IntEnum
 
 # minimal server schema version we can handle
-MIN_SERVER_SCHEMA_VERSION = 14
+MIN_SERVER_SCHEMA_VERSION = 15
 # max server schema version we can handle (and our code is compatible with)
-MAX_SERVER_SCHEMA_VERSION = 14
+MAX_SERVER_SCHEMA_VERSION = 15
+
+TYPING_EXTENSION_FOR_TYPEDDICT_REQUIRED = sys.version_info < (3, 9, 2)
 
 VALUE_UNKNOWN = "unknown"
 

zwave_js_server/const/command_class/power_level.py

@@ -0,0 +1,11 @@
+"""Constants for the Power Level Command Class."""
+from enum import IntEnum
+
+
+class PowerLevelTestStatus(IntEnum):
+    """Enum with all known power level test statuses."""
+
+    # https://github.com/zwave-js/node-zwave-js/blob/master/packages/zwave-js/src/lib/commandclass/PowerlevelCC.ts#L52
+    FAILED = 0
+    SUCCESS = 1
+    IN_PROGRESS = 2

zwave_js_server/event.py

@@ -1,11 +1,20 @@
 """Provide Event base classes for Z-Wave JS."""
 import logging
 from dataclasses import dataclass, field
-from typing import Callable, Dict, List
+from typing import Callable, Dict, List, Literal
+
+from pydantic import BaseModel
 
 LOGGER = logging.getLogger(__package__)
 
 
+class BaseEventModel(BaseModel):
+    """Base model for an event."""
+
+    source: Literal["controller", "driver", "node"]
+    event: str
+
+
 @dataclass
 class Event:
     """Represent an event."""
@@ -48,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

@@ -4,6 +4,7 @@ from typing import TYPE_CHECKING, Optional
 from .const import CommandClass
 
 if TYPE_CHECKING:
+    from .event import Event
     from .model.value import Value
 
 
@@ -156,3 +157,16 @@ class UnknownValueData(BaseZwaveJSServerError):
             "upstream issue with the driver or missing support for this data in the "
             "library"
         )
+
+
+class NotificationHasUnsupportedCommandClass(BaseZwaveJSServerError):
+    """Exception raised when notification is received for an unsupported CC."""
+
+    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}"
+        )

zwave_js_server/model/command_class.py

@@ -3,10 +3,12 @@ Model for Zwave Command Class Info.
 
 https://zwave-js.github.io/node-zwave-js/#/api/endpoint?id=commandclasses
 """
+from ..const import TYPING_EXTENSION_FOR_TYPEDDICT_REQUIRED, CommandClass
 
-from typing import TypedDict
-
-from ..const import CommandClass
+if TYPING_EXTENSION_FOR_TYPEDDICT_REQUIRED:
+    from typing_extensions import TypedDict
+else:
+    from typing import TypedDict
 
 
 class CommandClassInfoDataType(TypedDict):

zwave_js_server/model/{controller.py → controller/__init__.py}

@@ -1,101 +1,30 @@
 """Provide a model for the Z-Wave JS controller."""
 from dataclasses import dataclass
-from typing import (
-    TYPE_CHECKING,
-    Any,
-    Dict,
-    List,
-    Literal,
-    Optional,
-    TypedDict,
-    Union,
-    cast,
-)
+from typing import TYPE_CHECKING, Any, Dict, List, Literal, Optional, Union, cast
 
-from ..const import (
+from ...const import (
     MINIMUM_QR_STRING_LENGTH,
     InclusionState,
     InclusionStrategy,
-    Protocols,
     QRCodeVersion,
     RFRegion,
-    SecurityClass,
     ZwaveFeature,
 )
-from .controller_statistics import ControllerStatistics, ControllerStatisticsDataType
-from ..event import Event, EventBase
-from .association import Association, AssociationGroup
-from .node import Node
-from ..util.helpers import (
-    convert_base64_to_bytes,
-    convert_bytes_to_base64,
+from ...event import Event, EventBase
+from ...util.helpers import convert_base64_to_bytes, convert_bytes_to_base64
+from ..association import Association, AssociationGroup
+from ..node import Node
+from .data_model import ControllerDataType
+from .event_model import CONTROLLER_EVENT_MODEL_MAP
+from .inclusion_and_provisioning import (
+    InclusionGrant,
+    ProvisioningEntry,
+    QRProvisioningInformation,
 )
+from .statistics import ControllerStatistics
 
 if TYPE_CHECKING:
-    from ..client import Client
-
-
-class InclusionGrantDataType(TypedDict):
-    """Representation of an inclusion grant data dict type."""
-
-    # https://github.com/zwave-js/node-zwave-js/blob/master/packages/zwave-js/src/lib/controller/Inclusion.ts#L48-L56
-    securityClasses: List[int]
-    clientSideAuth: bool
-
-
-@dataclass
-class InclusionGrant:
-    """Representation of an inclusion grant."""
-
-    security_classes: List[SecurityClass]
-    client_side_auth: bool
-
-    def to_dict(self) -> InclusionGrantDataType:
-        """Return InclusionGrantDataType dict from self."""
-        return {
-            "securityClasses": [sec_cls.value for sec_cls in self.security_classes],
-            "clientSideAuth": self.client_side_auth,
-        }
-
-    @classmethod
-    def from_dict(cls, data: InclusionGrantDataType) -> "InclusionGrant":
-        """Return InclusionGrant from InclusionGrantDataType dict."""
-        return cls(
-            security_classes=[
-                SecurityClass(sec_cls) for sec_cls in data["securityClasses"]
-            ],
-            client_side_auth=data["clientSideAuth"],
-        )
-
-
-@dataclass
-class ProvisioningEntry:
-    """Class to represent the base fields of a provisioning entry."""
-
-    dsk: str
-    security_classes: List[SecurityClass]
-    additional_properties: Optional[Dict[str, Any]] = None
-
-    def to_dict(self) -> Dict[str, Any]:
-        """Return PlannedProvisioning data dict from self."""
-        return {
-            "dsk": self.dsk,
-            "securityClasses": [sec_cls.value for sec_cls in self.security_classes],
-            **(self.additional_properties or {}),
-        }
-
-    @classmethod
-    def from_dict(cls, data: Dict[str, Any]) -> "ProvisioningEntry":
-        """Return ProvisioningEntry from data dict."""
-        return cls(
-            dsk=data["dsk"],
-            security_classes=[
-                SecurityClass(sec_cls) for sec_cls in data["securityClasses"]
-            ],
-            additional_properties={
-                k: v for k, v in data.items() if k not in {"dsk", "securityClasses"}
-            },
-        )
+    from ...client import Client
 
 
 @dataclass
@@ -106,122 +35,6 @@ class NVMProgress:
     total_bytes: int
 
 
-@dataclass
-class QRProvisioningInformationMixin:
-    """Mixin class to represent the base fields of a QR provisioning information."""
-
-    version: QRCodeVersion
-    generic_device_class: int
-    specific_device_class: int
-    installer_icon_type: int
-    manufacturer_id: int
-    product_type: int
-    product_id: int
-    application_version: str
-    max_inclusion_request_interval: Optional[int]
-    uuid: Optional[str]
-    supported_protocols: Optional[List[Protocols]]
-
-
-@dataclass
-class QRProvisioningInformation(ProvisioningEntry, QRProvisioningInformationMixin):
-    """Representation of provisioning information retrieved from a QR code."""
-
-    def to_dict(self) -> Dict[str, Any]:
-        """Return QRProvisioningInformation data dict from self."""
-        data = {
-            "version": self.version.value,
-            "securityClasses": [sec_cls.value for sec_cls in self.security_classes],
-            "dsk": self.dsk,
-            "genericDeviceClass": self.generic_device_class,
-            "specificDeviceClass": self.specific_device_class,
-            "installerIconType": self.installer_icon_type,
-            "manufacturerId": self.manufacturer_id,
-            "productType": self.product_type,
-            "productId": self.product_id,
-            "applicationVersion": self.application_version,
-            **(self.additional_properties or {}),
-        }
-        if self.max_inclusion_request_interval is not None:
-            data["maxInclusionRequestInterval"] = self.max_inclusion_request_interval
-        if self.uuid is not None:
-            data["uuid"] = self.uuid
-        if self.supported_protocols is not None:
-            data["supportedProtocols"] = [
-                protocol.value for protocol in self.supported_protocols
-            ]
-        return data
-
-    @classmethod
-    def from_dict(cls, data: Dict[str, Any]) -> "QRProvisioningInformation":
-        """Return QRProvisioningInformation from data dict."""
-        return cls(
-            version=QRCodeVersion(data["version"]),
-            security_classes=[
-                SecurityClass(sec_cls) for sec_cls in data["securityClasses"]
-            ],
-            dsk=data["dsk"],
-            generic_device_class=data["genericDeviceClass"],
-            specific_device_class=data["specificDeviceClass"],
-            installer_icon_type=data["installerIconType"],
-            manufacturer_id=data["manufacturerId"],
-            product_type=data["productType"],
-            product_id=data["productId"],
-            application_version=data["applicationVersion"],
-            max_inclusion_request_interval=data.get("maxInclusionRequestInterval"),
-            uuid=data.get("uuid"),
-            supported_protocols=[
-                Protocols(supported_protocol)
-                for supported_protocol in data.get("supportedProtocols", [])
-            ],
-            additional_properties={
-                k: v
-                for k, v in data.items()
-                if k
-                not in {
-                    "version",
-                    "securityClasses",
-                    "dsk",
-                    "genericDeviceClass",
-                    "specificDeviceClass",
-                    "installerIconType",
-                    "manufacturerId",
-                    "productType",
-                    "productId",
-                    "applicationVersion",
-                    "maxInclusionRequestInterval",
-                    "uuid",
-                    "supportedProtocols",
-                }
-            },
-        )
-
-
-class ControllerDataType(TypedDict, total=False):
-    """Represent a controller data dict type."""
-
-    libraryVersion: str
-    type: int
-    homeId: int
-    ownNodeId: int
-    isSecondary: bool  # TODO: The following items are missing in the docs.
-    isUsingHomeIdFromOtherNetwork: bool
-    isSISPresent: bool
-    wasRealPrimary: bool
-    isStaticUpdateController: bool
-    isSlave: bool
-    serialApiVersion: str
-    manufacturerId: int
-    productType: int
-    productId: int
-    supportedFunctionTypes: List[int]
-    sucNodeId: int
-    supportsTimers: bool
-    isHealNetworkActive: bool
-    statistics: ControllerStatisticsDataType
-    inclusionState: int
-
-
 class Controller(EventBase):
     """Represent a Z-Wave JS controller."""
 
@@ -833,6 +646,8 @@ class Controller(EventBase):
                 f"Controller doesn't know how to handle/forward this event: {event.data}"
             )
 
+        CONTROLLER_EVENT_MODEL_MAP[event.type](**event.data)
+
         self._handle_event_protocol(event)
 
         event.data["controller"] = self
@@ -864,6 +679,8 @@ class Controller(EventBase):
     def handle_node_removed(self, event: Event) -> None:
         """Process a node removed event."""
         event.data["node"] = self.nodes.pop(event.data["node"]["nodeId"])
+        # Remove client from node since it's no longer connected to the controller
+        event.data["node"].client = None
 
     def handle_heal_network_progress(self, event: Event) -> None:
         """Process a heal network progress event."""

zwave_js_server/model/controller/data_model.py

@@ -0,0 +1,35 @@
+"""Data model for a Z-Wave JS controller."""
+from typing import List
+
+from ...const import TYPING_EXTENSION_FOR_TYPEDDICT_REQUIRED
+from .statistics import ControllerStatisticsDataType
+
+if TYPING_EXTENSION_FOR_TYPEDDICT_REQUIRED:
+    from typing_extensions import TypedDict
+else:
+    from typing import TypedDict
+
+
+class ControllerDataType(TypedDict, total=False):
+    """Represent a controller data dict type."""
+
+    libraryVersion: str
+    type: int
+    homeId: int
+    ownNodeId: int
+    isSecondary: bool  # TODO: The following items are missing in the docs.
+    isUsingHomeIdFromOtherNetwork: bool
+    isSISPresent: bool
+    wasRealPrimary: bool
+    isStaticUpdateController: bool
+    isSlave: bool
+    serialApiVersion: str
+    manufacturerId: int
+    productType: int
+    productId: int
+    supportedFunctionTypes: List[int]
+    sucNodeId: int
+    supportsTimers: bool
+    isHealNetworkActive: bool
+    statistics: ControllerStatisticsDataType
+    inclusionState: int

zwave_js_server/model/controller/event_model.py

@@ -0,0 +1,160 @@
+"""Provide a model for the Z-Wave JS controller's events."""
+from typing import Dict, Literal, Type
+
+from ...const import TYPING_EXTENSION_FOR_TYPEDDICT_REQUIRED
+from ...event import BaseEventModel
+from ..node.data_model import NodeDataType
+from .inclusion_and_provisioning import InclusionGrantDataType
+from .statistics import ControllerStatisticsDataType
+
+if TYPING_EXTENSION_FOR_TYPEDDICT_REQUIRED:
+    from typing_extensions import TypedDict
+else:
+    from typing import TypedDict
+
+
+class InclusionResultDataType(TypedDict, total=False):
+    """Represent an inclusion result data dict type."""
+
+    lowSecurity: bool
+
+
+class BaseControllerEventModel(BaseEventModel):
+    """Base model for a controller event."""
+
+    source: Literal["controller"]
+
+
+class ExclusionFailedEventModel(BaseControllerEventModel):
+    """Model for `exclusion failed` event data."""
+
+    event: Literal["exclusion failed"]
+
+
+class ExclusionStartedEventModel(BaseControllerEventModel):
+    """Model for `exclusion started` event data."""
+
+    event: Literal["exclusion started"]
+
+
+class ExclusionStoppedEventModel(BaseControllerEventModel):
+    """Model for `exclusion stopped` event data."""
+
+    event: Literal["exclusion stopped"]
+
+
+class GrantSecurityClassesEventModel(BaseControllerEventModel):
+    """Model for `grant security classes` event data."""
+
+    event: Literal["grant security classes"]
+    requested: InclusionGrantDataType
+
+
+class HealNetworkDoneEventModel(BaseControllerEventModel):
+    """Model for `heal network done` event data."""
+
+    event: Literal["heal network done"]
+    result: Dict[int, str]
+
+
+class HealNetworkProgressEventModel(BaseControllerEventModel):
+    """Model for `heal network progress` event data."""
+
+    event: Literal["heal network progress"]
+    progress: Dict[int, str]
+
+
+class InclusionFailedEventModel(BaseControllerEventModel):
+    """Model for `inclusion failed` event data."""
+
+    event: Literal["inclusion failed"]
+
+
+class InclusionStartedEventModel(BaseControllerEventModel):
+    """Model for `inclusion started` event data."""
+
+    event: Literal["inclusion started"]
+    secure: bool
+
+
+class InclusionStoppedEventModel(BaseControllerEventModel):
+    """Model for `inclusion stopped` event data."""
+
+    event: Literal["inclusion stopped"]
+
+
+class NodeAddedEventModel(BaseControllerEventModel):
+    """Model for `node added` event data."""
+
+    event: Literal["node added"]
+    node: NodeDataType
+    result: InclusionResultDataType
+
+
+class NodeRemovedEventModel(BaseControllerEventModel):
+    """Model for `node removed` event data."""
+
+    event: Literal["node removed"]
+    node: NodeDataType
+    replaced: bool
+
+
+class NVMBackupAndConvertProgressEventModel(BaseControllerEventModel):
+    """Base model for `nvm backup progress` and `nvm convert progress` event data."""
+
+    bytesRead: int
+    total: int
+
+
+class NVMBackupProgressEventModel(NVMBackupAndConvertProgressEventModel):
+    """Model for `nvm backup progress` event data."""
+
+    event: Literal["nvm backup progress"]
+
+
+class NVMConvertProgressEventModel(NVMBackupAndConvertProgressEventModel):
+    """Model for `nvm convert progress` event data."""
+
+    event: Literal["nvm convert progress"]
+
+
+class NVMRestoreProgressEventModel(BaseControllerEventModel):
+    """Model for `nvm restore progress` event data."""
+
+    event: Literal["nvm restore progress"]
+    bytesWritten: int
+    total: int
+
+
+class StatisticsUpdatedEventModel(BaseControllerEventModel):
+    """Model for `statistics updated` event data."""
+
+    event: Literal["statistics updated"]
+    statistics: ControllerStatisticsDataType
+
+
+class ValidateDSKAndEnterPINEventModel(BaseControllerEventModel):
+    """Model for `validate dsk and enter pin` event data."""
+
+    event: Literal["validate dsk and enter pin"]
+    dsk: str
+
+
+CONTROLLER_EVENT_MODEL_MAP: Dict[str, Type["BaseControllerEventModel"]] = {
+    "exclusion failed": ExclusionFailedEventModel,
+    "exclusion started": ExclusionStartedEventModel,
+    "exclusion stopped": ExclusionStoppedEventModel,
+    "grant security classes": GrantSecurityClassesEventModel,
+    "heal network done": HealNetworkDoneEventModel,
+    "heal network progress": HealNetworkProgressEventModel,
+    "inclusion failed": InclusionFailedEventModel,
+    "inclusion started": InclusionStartedEventModel,
+    "inclusion stopped": InclusionStoppedEventModel,
+    "node added": NodeAddedEventModel,
+    "node removed": NodeRemovedEventModel,
+    "nvm backup progress": NVMBackupProgressEventModel,
+    "nvm convert progress": NVMConvertProgressEventModel,
+    "nvm restore progress": NVMRestoreProgressEventModel,
+    "statistics updated": StatisticsUpdatedEventModel,
+    "validate dsk and enter pin": ValidateDSKAndEnterPINEventModel,
+}