zwave-js-server-python 0.22.0__py3-none-any.whl → 0.23.0__py3-none-any.whl

zwave_js_server/const.py

@@ -1,36 +1,88 @@
 """Constants for the Z-Wave JS python library."""
-from dataclasses import dataclass
 from enum import Enum, IntEnum
 from typing import Dict, List
 
 # minimal server schema version we can handle
-MIN_SERVER_SCHEMA_VERSION = 1
+MIN_SERVER_SCHEMA_VERSION = 3
 # max server schema version we can handle (and our code is compatible with)
-MAX_SERVER_SCHEMA_VERSION = 2
+MAX_SERVER_SCHEMA_VERSION = 3
 
 VALUE_UNKNOWN = "unknown"
 
 
-class LogLevel(IntEnum):
+class CommandStatus(str, Enum):
+    """Status of a command sent to zwave-js-server."""
+
+    ACCEPTED = "accepted"
+    QUEUED = "queued"
+
+
+class EntryControlEventType(IntEnum):
+    """Entry control event types."""
+
+    # https://github.com/zwave-js/node-zwave-js/blob/master/packages/zwave-js/src/lib/commandclass/EntryControlCC.ts#L54
+    CACHING = 0
+    CACHED_KEYS = 1
+    ENTER = 2
+    DISARM_ALL = 3
+    ARM_ALL = 4
+    ARM_AWAY = 5
+    ARM_HOME = 6
+    EXIT_DELAY = 7
+    ARM1 = 8
+    ARM2 = 9
+    ARM3 = 10
+    ARM4 = 11
+    ARM5 = 12
+    ARM6 = 13
+    RFID = 14
+    BELL = 15
+    FIRE = 16
+    POLICE = 17
+    ALERT_PANIC = 18
+    ALERT_MEDICAL = 19
+    GATE_OPEN = 20
+    GATE_CLOSE = 21
+    LOCK = 22
+    UNLOCK = 23
+    TEST = 24
+    CANCEL = 25
+
+
+class EntryControlDataType(IntEnum):
+    """Entry control data types."""
+
+    # https://github.com/zwave-js/node-zwave-js/blob/master/packages/zwave-js/src/lib/commandclass/EntryControlCC.ts#L83
+    NONE = 0
+    RAW = 1
+    ASCII = 2
+    MD5 = 3
+
+
+class ProtocolVersion(IntEnum):
+    """Protocol version."""
+
+    # https://github.com/zwave-js/node-zwave-js/blob/master/packages/zwave-js/src/lib/node/Types.ts#L149
+    UNKNOWN = 0
+    VERSION_2_0 = 1
+    VERSION_4_2X_OR_5_0X = 2
+    VERSION_4_5X_OR_6_0X = 3
+
+
+# Multiple inheritance so that LogLevel will JSON serialize properly
+# Reference: https://stackoverflow.com/a/51976841
+class LogLevel(str, Enum):
     """Enum for log levels used by node-zwave-js."""
 
     # https://github.com/zwave-js/node-zwave-js/blob/master/packages/core/src/log/shared.ts#L12
     # https://github.com/winstonjs/triple-beam/blame/master/config/npm.js#L14
-    ERROR = 0
-    WARN = 1
-    INFO = 2
-    HTTP = 3
-    VERBOSE = 4
-    DEBUG = 5
-    SILLY = 6
-
-
-@dataclass
-class PropertyKey:
-    """Class to represent a property key and its name."""
-
-    key: int
-    name: str
+    ERROR = "error"
+    WARN = "warn"
+    INFO = "info"
+    HTTP = "http"
+    VERBOSE = "verbose"
+    DEBUG = "debug"
+    SILLY = "silly"
 
 
 class CommandClass(IntEnum):
@@ -253,7 +305,7 @@ class ThermostatOperatingState(IntEnum):
     THIRD_STAGE_AUX_HEAT = 11
 
 
-class ThermostatSetpointType(Enum):
+class ThermostatSetpointType(IntEnum):
     """
     Enum with all (known/used) Z-Wave Thermostat Setpoint Types.
 
@@ -261,18 +313,18 @@ class ThermostatSetpointType(Enum):
     """
 
     # https://github.com/zwave-js/node-zwave-js/blob/master/packages/zwave-js/src/lib/commandclass/ThermostatSetpointCC.ts#L53-L66
-    NA = PropertyKey(0, "N/A")
-    HEATING = PropertyKey(1, "Heating")
-    COOLING = PropertyKey(2, "Cooling")
-    FURNACE = PropertyKey(7, "Furnace")
-    DRY_AIR = PropertyKey(8, "Dry Air")
-    MOIST_AIR = PropertyKey(9, "Moist Air")
-    AUTO_CHANGEOVER = PropertyKey(10, "Auto Changeover")
-    ENERGY_SAVE_HEATING = PropertyKey(11, "Energy Save Heating")
-    ENERGY_SAVE_COOLING = PropertyKey(12, "Energy Save Cooling")
-    AWAY_HEATING = PropertyKey(13, "Away Heating")
-    AWAY_COOLING = PropertyKey(14, "Away Cooling")
-    FULL_POWER = PropertyKey(15, "Full Power")
+    NA = 0
+    HEATING = 1
+    COOLING = 2
+    FURNACE = 7
+    DRY_AIR = 8
+    MOIST_AIR = 9
+    AUTO_CHANGEOVER = 10
+    ENERGY_SAVE_HEATING = 11
+    ENERGY_SAVE_COOLING = 12
+    AWAY_HEATING = 13
+    AWAY_COOLING = 14
+    FULL_POWER = 15
 
 
 # In Z-Wave the modes and presets are both in ThermostatMode.
@@ -336,16 +388,16 @@ class BarrierState(IntEnum):
     OPEN = 255
 
 
-class ColorComponent(Enum):
+class ColorComponent(IntEnum):
     """Enum with all (known/used) Color Switch CC colors."""
 
     # https://github.com/zwave-js/node-zwave-js/blob/master/packages/zwave-js/src/lib/commandclass/ColorSwitchCC.ts#L62
-    WARM_WHITE = PropertyKey(0, "Warm White")
-    COLD_WHITE = PropertyKey(1, "Cold White")
-    RED = PropertyKey(2, "Red")
-    GREEN = PropertyKey(3, "Green")
-    BLUE = PropertyKey(4, "Blue")
-    AMBER = PropertyKey(5, "Amber")
-    CYAN = PropertyKey(6, "Cyan")
-    PURPLE = PropertyKey(7, "Purple")
-    INDEX = PropertyKey(8, "Index")
+    WARM_WHITE = 0
+    COLD_WHITE = 1
+    RED = 2
+    GREEN = 3
+    BLUE = 4
+    AMBER = 5
+    CYAN = 6
+    PURPLE = 7
+    INDEX = 8

zwave_js_server/exceptions.py

@@ -82,6 +82,10 @@ class InvalidNewValue(BaseZwaveJSServerError):
     """Exception raised when target new value is invalid based on Value metadata."""
 
 
+class ValueTypeError(BaseZwaveJSServerError):
+    """Exception raised when target Zwave value is the wrong type."""
+
+
 class SetValueFailed(BaseZwaveJSServerError):
     """
     Exception raise when setting a value fails.

zwave_js_server/model/association.py

@@ -1,6 +1,6 @@
 """Provide a model for the association."""
-from typing import Dict, List, Optional
 from dataclasses import dataclass, field
+from typing import Dict, List, Optional
 
 
 @dataclass

zwave_js_server/model/command_class.py

@@ -5,6 +5,7 @@ https://zwave-js.github.io/node-zwave-js/#/api/endpoint?id=commandclasses
 """
 
 from typing import TypedDict
+
 from ..const import CommandClass
 
 

zwave_js_server/model/controller.py

@@ -2,10 +2,7 @@
 from typing import TYPE_CHECKING, Dict, List, Optional, TypedDict, cast
 
 from ..event import Event, EventBase
-from .association import (
-    AssociationGroup,
-    Association,
-)
+from .association import Association, AssociationGroup
 from .node import Node
 
 if TYPE_CHECKING:
@@ -318,11 +315,11 @@ class Controller(EventBase):
             }
         )
 
-    async def async_remove_node_from_all_assocations(self, node_id: int) -> None:
-        """Send removeNodeFromAllAssocations command to Controller."""
+    async def async_remove_node_from_all_associations(self, node_id: int) -> None:
+        """Send removeNodeFromAllAssociations command to Controller."""
         await self.client.async_send_command(
             {
-                "command": "controller.remove_node_from_all_assocations",
+                "command": "controller.remove_node_from_all_associations",
                 "nodeId": node_id,
             }
         )

zwave_js_server/model/driver.py

@@ -1,5 +1,6 @@
 """Provide a model for the Z-Wave JS Driver."""
 from typing import TYPE_CHECKING
+
 from zwave_js_server.model.log_config import LogConfig
 
 from ..event import Event, EventBase

zwave_js_server/model/endpoint.py

@@ -6,12 +6,15 @@ https://zwave-js.github.io/node-zwave-js/#/api/endpoint?id=endpoint-properties
 
 from typing import Optional, TypedDict
 
+from .device_class import DeviceClass, DeviceClassDataType
+
 
 class EndpointDataType(TypedDict, total=False):
     """Represent an endpoint data dict type."""
 
     nodeId: int  # required
     index: int  # required
+    deviceClass: DeviceClassDataType  # required
     installerIcon: int
     userIcon: int
 
@@ -33,6 +36,11 @@ class Endpoint:
         """Return index property."""
         return self.data["index"]
 
+    @property
+    def device_class(self) -> DeviceClass:
+        """Return the device_class."""
+        return DeviceClass(self.data["deviceClass"])
+
     @property
     def installer_icon(self) -> Optional[int]:
         """Return installer icon property."""

zwave_js_server/model/log_config.py

@@ -31,7 +31,7 @@ class LogConfig:
         """Return LogConfigDataType dict from self."""
         data = {
             "enabled": self.enabled,
-            "level": self.level,
+            "level": self.level.value if self.level else None,
             "logToFile": self.log_to_file,
             "filename": self.filename,
             "forceConsole": self.force_console,
@@ -43,7 +43,7 @@ class LogConfig:
         """Return LogConfig from LogConfigDataType dict."""
         return LogConfig(
             data.get("enabled"),
-            data.get("level"),
+            LogLevel(data["level"]) if "level" in data else None,
             data.get("logToFile"),
             data.get("filename"),
             data.get("forceConsole"),

zwave_js_server/model/node.py

@@ -10,7 +10,12 @@ from .command_class import CommandClassInfo, CommandClassInfoDataType
 from .device_class import DeviceClass, DeviceClassDataType
 from .device_config import DeviceConfig, DeviceConfigDataType
 from .endpoint import Endpoint, EndpointDataType
-from .notification import Notification, NotificationDataType
+from .notification import (
+    EntryControlNotification,
+    EntryControlNotificationDataType,
+    NotificationNotification,
+    NotificationNotificationDataType,
+)
 from .value import (
     ConfigurationValue,
     MetaDataType,
@@ -19,6 +24,7 @@ from .value import (
     ValueMetadata,
     ValueNotification,
     _get_value_id_from_dict,
+    _init_value,
 )
 
 if TYPE_CHECKING:
@@ -47,15 +53,17 @@ class NodeDataType(TypedDict, total=False):
     status: int  # 0-4  # required
     deviceClass: DeviceClassDataType
     zwavePlusVersion: int
-    nodeType: int
-    roleType: int
+    zwavePlusNodeType: int
+    zwavePlusRoleType: int
     isListening: bool
-    isFrequentListening: bool
+    isFrequentListening: Union[bool, str]
     isRouting: bool
-    maxBaudRate: int
+    maxDataRate: int
+    supportedDataRates: List[int]
     isSecure: bool
-    isBeaming: bool
-    version: int
+    supportsBeaming: bool
+    supportsSecurity: bool
+    protocolVersion: int
     firmwareVersion: str
     manufacturerId: int
     productId: int
@@ -91,10 +99,7 @@ class Node(EventBase):
         for val in data["values"]:
             value_id = _get_value_id_from_dict(self, val)
             try:
-                if val["commandClass"] == CommandClass.CONFIGURATION:
-                    self.values[value_id] = ConfigurationValue(self, val)
-                else:
-                    self.values[value_id] = Value(self, val)
+                self.values[value_id] = _init_value(self, val)
             except UnparseableValue:
                 # If we can't parse the value, don't store it
                 pass
@@ -156,9 +161,9 @@ class Node(EventBase):
         return self.data.get("isListening")
 
     @property
-    def is_frequent_listening(self) -> Optional[bool]:
+    def is_frequent_listening(self) -> Optional[Union[bool, str]]:
         """Return the is_frequent_listening."""
-        return self.data["isFrequentListening"]
+        return self.data.get("isFrequentListening")
 
     @property
     def is_routing(self) -> Optional[bool]:
@@ -166,9 +171,14 @@ class Node(EventBase):
         return self.data.get("isRouting")
 
     @property
-    def max_baud_rate(self) -> Optional[int]:
-        """Return the max_baud_rate."""
-        return self.data.get("maxBaudRate")
+    def max_data_rate(self) -> Optional[int]:
+        """Return the max_data_rate."""
+        return self.data.get("maxDataRate")
+
+    @property
+    def supported_data_rates(self) -> List[int]:
+        """Return the supported_data_rates."""
+        return self.data.get("supportedDataRates", [])
 
     @property
     def is_secure(self) -> Optional[bool]:
@@ -176,14 +186,19 @@ class Node(EventBase):
         return self.data.get("isSecure")
 
     @property
-    def version(self) -> Optional[int]:
-        """Return the version."""
-        return self.data.get("version")
+    def protocol_version(self) -> Optional[int]:
+        """Return the protocol_version."""
+        return self.data.get("protocolVersion")
 
     @property
-    def is_beaming(self) -> Optional[bool]:
-        """Return the is_beaming."""
-        return self.data.get("isBeaming")
+    def supports_beaming(self) -> Optional[bool]:
+        """Return the supports_beaming."""
+        return self.data.get("supportsBeaming")
+
+    @property
+    def supports_security(self) -> Optional[bool]:
+        """Return the supports_security."""
+        return self.data.get("supportsSecurity")
 
     @property
     def manufacturer_id(self) -> Optional[int]:
@@ -211,14 +226,14 @@ class Node(EventBase):
         return self.data.get("zwavePlusVersion")
 
     @property
-    def node_type(self) -> Optional[int]:
-        """Return the node_type."""
-        return self.data.get("nodeType")
+    def zwave_plus_node_type(self) -> Optional[int]:
+        """Return the zwave_plus_node_type."""
+        return self.data.get("zwavePlusNodeType")
 
     @property
-    def role_type(self) -> Optional[int]:
-        """Return the role_type."""
-        return self.data.get("roleType")
+    def zwave_plus_role_type(self) -> Optional[int]:
+        """Return the zwave_plus_role_type."""
+        return self.data.get("zwavePlusRoleType")
 
     @property
     def name(self) -> Optional[str]:
@@ -310,7 +325,7 @@ class Node(EventBase):
 
         self.emit(event.type, event.data)
 
-    async def _async_send_command(
+    async def async_send_command(
         self,
         cmd: str,
         require_schema: Optional[int] = None,
@@ -352,7 +367,7 @@ class Node(EventBase):
             raise UnwriteableValue
 
         # the value object needs to be send to the server
-        result = await self._async_send_command(
+        result = await self.async_send_command(
             "set_value",
             valueId=val.data,
             value=new_value,
@@ -366,11 +381,11 @@ class Node(EventBase):
 
     async def async_refresh_info(self) -> None:
         """Send refreshInfo command to Node."""
-        await self._async_send_command("refresh_info", wait_for_result=False)
+        await self.async_send_command("refresh_info", wait_for_result=False)
 
     async def async_get_defined_value_ids(self) -> List[Value]:
         """Send getDefinedValueIDs command to Node."""
-        data = await self._async_send_command(
+        data = await self.async_send_command(
             "get_defined_value_ids", wait_for_result=True
         )
 
@@ -378,7 +393,8 @@ class Node(EventBase):
             # We should never reach this code
             raise FailedCommand("Command failed", "failed_command")
         return [
-            Value(self, cast(ValueDataType, valueId)) for valueId in data["valueIds"]
+            _init_value(self, cast(ValueDataType, value_id))
+            for value_id in data["valueIds"]
         ]
 
     async def async_get_value_metadata(self, val: Union[Value, str]) -> ValueMetadata:
@@ -387,21 +403,21 @@ class Node(EventBase):
         if not isinstance(val, Value):
             val = self.values[val]
         # the value object needs to be send to the server
-        data = await self._async_send_command(
+        data = await self.async_send_command(
             "get_value_metadata", valueId=val.data, wait_for_result=True
         )
         return ValueMetadata(cast(MetaDataType, data))
 
     async def async_abort_firmware_update(self) -> None:
         """Send abortFirmwareUpdate command to Node."""
-        await self._async_send_command("abort_firmware_update", wait_for_result=False)
+        await self.async_send_command("abort_firmware_update", wait_for_result=False)
 
     async def async_poll_value(self, val: Union[Value, str]) -> None:
         """Send pollValue command to Node for given value (or value_id)."""
         # a value may be specified as value_id or the value itself
         if not isinstance(val, Value):
             val = self.values[val]
-        await self._async_send_command("poll_value", valueId=val.data, require_schema=1)
+        await self.async_send_command("poll_value", valueId=val.data, require_schema=1)
 
     def handle_wake_up(self, event: Event) -> None:
         """Process a node wake up event."""
@@ -438,13 +454,13 @@ class Node(EventBase):
             value_id = _get_value_id_from_dict(self, value_state)
             value = self.values.get(value_id)
             if value is None:
-                self.values[value_id] = Value(self, value_state)
+                self.values[value_id] = _init_value(self, value_state)
             else:
                 value.update(value_state)
 
     def handle_value_added(self, event: Event) -> None:
         """Process a node value added event."""
-        value = Value(self, event.data["args"])
+        value = _init_value(self, event.data["args"])
         self.values[value.value_id] = event.data["value"] = value
 
     def handle_value_updated(self, event: Event) -> None:
@@ -485,9 +501,14 @@ class Node(EventBase):
 
     def handle_notification(self, event: Event) -> None:
         """Process a node notification event."""
-        event.data["notification"] = Notification(
-            self, cast(NotificationDataType, event.data)
-        )
+        if event.data["ccId"] == CommandClass.NOTIFICATION.value:
+            event.data["notification"] = NotificationNotification(
+                self, cast(NotificationNotificationDataType, event.data)
+            )
+        else:
+            event.data["notification"] = EntryControlNotification(
+                self, cast(EntryControlNotificationDataType, event.data)
+            )
 
     def handle_firmware_update_progress(self, event: Event) -> None:
         """Process a node firmware update progress event."""

zwave_js_server/model/notification.py

@@ -4,26 +4,57 @@ Model for a Zwave Node's Notification Event.
 https://zwave-js.github.io/node-zwave-js/#/api/node?id=quotnotificationquot
 """
 
-from typing import Literal, TYPE_CHECKING, Any, Dict, TypedDict
+from typing import TYPE_CHECKING, Any, Dict, Literal, Optional, TypedDict, Union
+
+from zwave_js_server.util.helpers import parse_buffer
 
 if TYPE_CHECKING:
     from .node import Node
 
 
-class NotificationDataType(TypedDict, total=False):
-    """Represent a notification event data dict type."""
+class NotificationDataType(TypedDict):
+    """Represent a generic notification event data dict type."""
 
     source: Literal["node"]  # required
     event: Literal["notification"]  # required
     nodeId: int  # required
-    notificationLabel: str  # required
+    ccId: int  # required
+
+
+class EntryControlNotificationArgsDataType(TypedDict, total=False):
+    """Represent args for a Entry Control CC notification event data dict type."""
+
+    eventType: int  # required
+    dataType: int  # required
+    eventData: Union[str, Dict[str, Any]]
+
+
+class EntryControlNotificationDataType(NotificationDataType):
+    """Represent an Entry Control CC notification event data dict type."""
+
+    args: EntryControlNotificationArgsDataType  # required
+
+
+class NotificationNotificationArgsDataType(TypedDict, total=False):
+    """Represent args for a Notification CC notification event data dict type."""
+
+    type: int  # required
+    label: str  # required
+    event: int  # required
+    eventLabel: str  # required
     parameters: Dict[str, Any]
 
 
-class Notification:
-    """Model for a Zwave Node's notification event."""
+class NotificationNotificationDataType(NotificationDataType):
+    """Represent a Notification CC notification event data dict type."""
 
-    def __init__(self, node: "Node", data: NotificationDataType) -> None:
+    args: NotificationNotificationArgsDataType  # required
+
+
+class NotificationNotification:
+    """Model for a Zwave Node's Notification CC notification event."""
+
+    def __init__(self, node: "Node", data: NotificationNotificationDataType) -> None:
         """Initialize."""
         self.node = node
         self.data = data
@@ -34,11 +65,67 @@ class Notification:
         return self.data["nodeId"]
 
     @property
-    def notification_label(self) -> str:
+    def command_class(self) -> int:
+        """Return command class."""
+        return self.data["ccId"]
+
+    @property
+    def type_(self) -> int:
+        """Return type property."""
+        return self.data["args"]["type"]
+
+    @property
+    def label(self) -> str:
+        """Return label property."""
+        return self.data["args"]["label"]
+
+    @property
+    def event(self) -> int:
+        """Return event property."""
+        return self.data["args"]["event"]
+
+    @property
+    def event_label(self) -> str:
         """Return notification label property."""
-        return self.data["notificationLabel"]
+        return self.data["args"]["eventLabel"]
 
     @property
     def parameters(self) -> Dict[str, Any]:
         """Return installer icon property."""
-        return self.data.get("parameters", {})
+        return self.data["args"].get("parameters", {})
+
+
+class EntryControlNotification:
+    """Model for a Zwave Node's Entry Control CC notification event."""
+
+    def __init__(self, node: "Node", data: EntryControlNotificationDataType) -> 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) -> int:
+        """Return event type property."""
+        return self.data["args"]["eventType"]
+
+    @property
+    def data_type(self) -> int:
+        """Return data type property."""
+        return self.data["args"]["dataType"]
+
+    @property
+    def event_data(self) -> Optional[str]:
+        """Return event data property."""
+        if event_data := self.data["args"].get("eventData"):
+            return parse_buffer(event_data)
+        return None

zwave_js_server/model/value.py

@@ -1,9 +1,9 @@
 """Provide a model for the Z-Wave JS value."""
 from typing import TYPE_CHECKING, Any, Dict, Optional, TypedDict, Union
 
-from ..const import VALUE_UNKNOWN, ConfigurationValueType
+from ..const import VALUE_UNKNOWN, CommandClass, ConfigurationValueType
 from ..event import Event
-from ..util.helpers import is_json_string, parse_buffer, parse_buffer_from_json
+from ..util.helpers import parse_buffer
 
 if TYPE_CHECKING:
     from .node import Node
@@ -23,6 +23,7 @@ class MetaDataType(TypedDict, total=False):
     states: Dict[int, str]
     ccSpecific: Dict[str, Any]
     allowManualEntry: bool
+    valueSize: int
 
 
 class ValueDataType(TypedDict, total=False):
@@ -42,6 +43,15 @@ class ValueDataType(TypedDict, total=False):
     ccVersion: int
 
 
+def _init_value(
+    node: "Node", val: ValueDataType
+) -> Union["Value", "ConfigurationValue"]:
+    """Intialize a Value object from ValueDataType."""
+    if val["commandClass"] == CommandClass.CONFIGURATION:
+        return ConfigurationValue(node, val)
+    return Value(node, val)
+
+
 def _get_value_id_from_dict(node: "Node", val: ValueDataType) -> str:
     """Return ID of value from ValueDataType dict."""
     return get_value_id(
@@ -132,6 +142,11 @@ class ValueMetadata:
         """Return allowManualEntry."""
         return self.data.get("allowManualEntry")
 
+    @property
+    def value_size(self) -> Optional[int]:
+        """Return valueSize."""
+        return self.data.get("valueSize")
+
     def update(self, data: MetaDataType) -> None:
         """Update data."""
         self.data.update(data)
@@ -240,13 +255,8 @@ class Value:
             self._metadata.update(data["metadata"])
 
         # Handle buffer dict and json string in value.
-        # In schema version 1 this is type string,
-        # while in schema version 2 this is type buffer.
-        if self.metadata.type in ("string", "buffer"):
-            if isinstance(self._value, dict):
-                self._value = parse_buffer(self._value)
-            elif is_json_string(self._value):
-                self._value = parse_buffer_from_json(self._value)
+        if self.metadata.type == "buffer":
+            self._value = parse_buffer(self._value)
 
 
 class ValueNotification(Value):

zwave_js_server/util/helpers.py

@@ -1,7 +1,7 @@
 """Generic Utility helper functions."""
 
 import json
-from typing import Any, Dict
+from typing import Any, Dict, Union
 
 from ..exceptions import UnparseableValue
 
@@ -12,7 +12,18 @@ def is_json_string(value: Any) -> bool:
     return isinstance(value, str) and value.startswith("{") and value.endswith("}")
 
 
-def parse_buffer(value: Dict[str, Any]) -> str:
+def parse_buffer(value: Union[Dict[str, Any], str]) -> str:
+    """Parse value from a buffer data type."""
+    if isinstance(value, dict):
+        return parse_buffer_from_dict(value)
+
+    if is_json_string(value):
+        return parse_buffer_from_json(value)
+
+    return value
+
+
+def parse_buffer_from_dict(value: Dict[str, Any]) -> str:
     """Parse value dictionary from a buffer data type."""
     if value.get("type") != "Buffer" or "data" not in value:
         raise UnparseableValue(f"Unparseable value: {value}") from ValueError(
@@ -24,6 +35,6 @@ def parse_buffer(value: Dict[str, Any]) -> str:
 def parse_buffer_from_json(value: str) -> str:
     """Parse value string from a buffer data type."""
     try:
-        return parse_buffer(json.loads(value))
+        return parse_buffer_from_dict(json.loads(value))
     except ValueError as err:
         raise UnparseableValue(f"Unparseable value: {value}") from err

zwave_js_server/util/lock.py

@@ -13,7 +13,7 @@ from ..const import (
 )
 from ..exceptions import NotFoundError
 from ..model.node import Node
-from ..model.value import get_value_id, Value
+from ..model.value import Value, get_value_id
 
 
 def get_code_slot_value(node: Node, code_slot: int, property_name: str) -> Value:

zwave_js_server/util/node.py

@@ -1,58 +1,17 @@
 """Utility functions for Z-Wave JS nodes."""
 import json
-from typing import Optional, Union
+from typing import Dict, Optional, Tuple, Union, cast
 
-from ..const import CommandClass, ConfigurationValueType
-from ..exceptions import InvalidNewValue, NotFoundError, SetValueFailed
+from ..const import CommandClass, CommandStatus, ConfigurationValueType
+from ..exceptions import InvalidNewValue, NotFoundError, SetValueFailed, ValueTypeError
 from ..model.node import Node
 from ..model.value import ConfigurationValue, get_value_id
 
 
-async def async_set_config_parameter(
-    node: Node,
-    new_value: Union[int, str],
-    property_or_property_name: Union[int, str],
-    property_key: Optional[Union[int, str]] = None,
-) -> ConfigurationValue:
-    """
-    Set a value for a config parameter on this node.
-
-    new_value and property_ can be provided as labels, so we need to resolve them to
-    the appropriate key
-    """
-    config_values = node.get_configuration_values()
-
-    # If a property name is provided, we have to search for the correct value since
-    # we can't use value ID
-    if isinstance(property_or_property_name, str):
-        try:
-            zwave_value = next(
-                config_value
-                for config_value in config_values.values()
-                if config_value.property_name == property_or_property_name
-            )
-        except StopIteration:
-            raise NotFoundError(
-                "Configuration parameter with parameter name "
-                f"{property_or_property_name} could not be found"
-            ) from None
-    else:
-        value_id = get_value_id(
-            node,
-            CommandClass.CONFIGURATION,
-            property_or_property_name,
-            endpoint=0,
-            property_key=property_key,
-        )
-
-        try:
-            zwave_value = config_values[value_id]
-        except KeyError:
-            raise NotFoundError(
-                f"Configuration parameter with value ID {value_id} could not be "
-                "found"
-            ) from None
-
+def _validate_and_transform_new_value(
+    zwave_value: ConfigurationValue, new_value: Union[int, str]
+) -> int:
+    """Validate a new value and return the integer value to set."""
     # Validate that new value for enumerated configuration parameter is a valid state
     # key or label
     if (
@@ -64,8 +23,8 @@ async def async_set_config_parameter(
         ]
     ):
         raise InvalidNewValue(
-            "Must provide a value that represents a valid state key or label from "
-            f"{json.dumps(zwave_value.metadata.states)}"
+            f"Must provide a value for {zwave_value.value_id} that represents a valid "
+            f"state key or label from {json.dumps(zwave_value.metadata.states)}"
         )
 
     # Validate that new value for manual entry configuration parameter is a valid state
@@ -76,8 +35,8 @@ async def async_set_config_parameter(
         and str(new_value) not in zwave_value.metadata.states.values()
     ):
         raise InvalidNewValue(
-            "Must provide a value that represents a valid state from "
-            f"{list(zwave_value.metadata.states.values())}"
+            f"Must provide a value for {zwave_value.value_id} that represents a valid "
+            f"state from {list(zwave_value.metadata.states.values())}"
         )
 
     # If needed, convert a state label to its key. We know the state exists because
@@ -115,12 +74,164 @@ async def async_set_config_parameter(
             f"Must provide a value within the target range ({', '.join(bounds)})"
         )
 
+    return new_value
+
+
+def partial_param_bit_shift(property_key: int) -> int:
+    """Get the number of bits to shift the value for a given property key."""
+    # We can get the binary representation of the property key, reverse it,
+    # and find the first 1
+    return bin(property_key)[::-1].index("1")
+
+
+async def async_bulk_set_partial_config_parameters(
+    node: Node,
+    property_: int,
+    new_value: Union[int, Dict[int, Union[int, str]]],
+) -> CommandStatus:
+    """Bulk set partial configuration values on this node."""
+    config_values = node.get_configuration_values()
+    property_values = [
+        value for value in config_values.values() if value.property_ == property_
+    ]
+
+    # If we can't find any values with this property, the property is wrong
+    if not property_values:
+        raise NotFoundError(
+            f"Configuration parameter {property_} for node {node.node_id} not found"
+        )
+
+    # If we only find one value with this property_, we know this value isn't split
+    # into partial params
+    if len(property_values) == 1:
+        raise ValueTypeError(
+            f"Configuration parameter {property_} for node {node.node_id} does not "
+            "have partials"
+        )
+
+    # If new_value is a dictionary, we need to calculate the full value to send
+    if isinstance(new_value, dict):
+        temp_value = 0
+        # For each property key provided, we bit shift the partial value using the
+        # property_key
+        for property_key, partial_value in new_value.items():
+            value_id = get_value_id(
+                node, CommandClass.CONFIGURATION, property_, property_key=property_key
+            )
+            if value_id not in node.values:
+                raise NotFoundError(
+                    f"Bitmask {property_key} ({hex(property_key)}) not found for "
+                    f"parameter {property_}"
+                )
+            zwave_value = cast(ConfigurationValue, node.values[value_id])
+            partial_value = _validate_and_transform_new_value(
+                zwave_value, partial_value
+            )
+            temp_value += partial_value << partial_param_bit_shift(property_key)
+
+        # To set partial parameters in bulk, we also have to include cached values for
+        # property keys that haven't been specified
+        for property_value in property_values:
+            if property_value.property_key not in new_value:
+                temp_value += cast(
+                    int, property_value.value
+                ) << partial_param_bit_shift(cast(int, property_value.property_key))
+
+        new_value = temp_value
+    else:
+        remaining_value = new_value
+
+        # Break down the bulk value into partial values and validate them against
+        # each partial parameter's metadata by looping through the property values
+        # starting with the highest property key
+        for zwave_value in sorted(
+            property_values, key=lambda val: cast(int, val.property_key), reverse=True
+        ):
+            property_key = cast(int, zwave_value.property_key)
+            multiplication_factor = 2 ** partial_param_bit_shift(property_key)
+            partial_value = int(remaining_value / multiplication_factor)
+            remaining_value = remaining_value % multiplication_factor
+            _validate_and_transform_new_value(zwave_value, partial_value)
+
+    cmd_response = await node.async_send_command(
+        "set_value",
+        valueId={
+            "commandClass": CommandClass.CONFIGURATION.value,
+            "property": property_,
+        },
+        value=new_value,
+    )
+
+    # If we didn't wait for a response, we assume the command has been queued
+    if cmd_response is None:
+        return CommandStatus.QUEUED
+
+    if not cast(bool, cmd_response["success"]):
+        raise SetValueFailed(
+            "Unable to set value, refer to "
+            "https://zwave-js.github.io/node-zwave-js/#/api/node?id=setvalue for "
+            "possible reasons"
+        )
+
+    # If we received a response that is not false, the command was successful
+    return CommandStatus.ACCEPTED
+
+
+async def async_set_config_parameter(
+    node: Node,
+    new_value: Union[int, str],
+    property_or_property_name: Union[int, str],
+    property_key: Optional[Union[int, str]] = None,
+) -> Tuple[ConfigurationValue, CommandStatus]:
+    """
+    Set a value for a config parameter on this node.
+
+    new_value and property_ can be provided as labels, so we need to resolve them to
+    the appropriate key
+    """
+    config_values = node.get_configuration_values()
+
+    # If a property name is provided, we have to search for the correct value since
+    # we can't use value ID
+    if isinstance(property_or_property_name, str):
+        try:
+            zwave_value = next(
+                config_value
+                for config_value in config_values.values()
+                if config_value.property_name == property_or_property_name
+            )
+        except StopIteration:
+            raise NotFoundError(
+                "Configuration parameter with parameter name "
+                f"{property_or_property_name} could not be found"
+            ) from None
+    else:
+        value_id = get_value_id(
+            node,
+            CommandClass.CONFIGURATION,
+            property_or_property_name,
+            endpoint=0,
+            property_key=property_key,
+        )
+
+        if value_id not in config_values:
+            raise NotFoundError(
+                f"Configuration parameter with value ID {value_id} could not be "
+                "found"
+            ) from None
+        zwave_value = config_values[value_id]
+
+    new_value = _validate_and_transform_new_value(zwave_value, new_value)
+
     # Finally attempt to set the value and return the Value object if successful
-    if await node.async_set_value(zwave_value, new_value) is False:
+    success = await node.async_set_value(zwave_value, new_value)
+    if success is False:
         raise SetValueFailed(
             "Unable to set value, refer to "
             "https://zwave-js.github.io/node-zwave-js/#/api/node?id=setvalue for "
             "possible reasons"
         )
 
-    return zwave_value
+    status = CommandStatus.ACCEPTED if success else CommandStatus.QUEUED
+
+    return zwave_value, status

{zwave_js_server_python-0.22.0.dist-info → zwave_js_server_python-0.23.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: zwave-js-server-python
-Version: 0.22.0
+Version: 0.23.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.23.0.dist-info/RECORD

@@ -0,0 +1,31 @@
+zwave_js_server/__init__.py,sha256=Ey3O4Tha56uU-M92oLJmQHupCJ7B9oZmxlQTo8pGUM8,45
+zwave_js_server/__main__.py,sha256=1gWC927sa3FwcA47ndmrRWW0HlfYVdiUarjEsccRF2k,3624
+zwave_js_server/client.py,sha256=Tz6nKa9uZFhBgh1HTXwW6jUMauUq-oSgCBPxIW7UJcQ,10788
+zwave_js_server/const.py,sha256=5hc0tIRBwvfDaI-QyQ9FAPTA5fSX7qAC5Lw9h21EOMQ,10887
+zwave_js_server/dump.py,sha256=inv0Q-i0DbzEcbwXeLDiu29U2I248pPMyNUTQDp5wYY,1184
+zwave_js_server/event.py,sha256=0Aw3NzkzKMnhS7AxBh6BwAVYXRu4zDKeUDib9mHjj8w,1772
+zwave_js_server/exceptions.py,sha256=V3FqKQdi1ggT-NnZBuJLviH99yRmPr7dg26OGnMS9Gw,2742
+zwave_js_server/version.py,sha256=RDFP2kSU3cCVIQbgMWggdeDnvhtVsZzzZg9pOjH7CC8,364
+zwave_js_server/model/__init__.py,sha256=XfyKH8lxZ3CB7CbRkOr5sR-eV0GrklZiBtNPmlnCJ_8,123
+zwave_js_server/model/association.py,sha256=FsgKAha7mw6dpk7u7zdQoNEajTyiL0S5eOYcY4M2Rx4,529
+zwave_js_server/model/command_class.py,sha256=CPKZOJNr6T3Y-ShfFB0CDZOLmITtXm5p1cOHbnRHMaI,1118
+zwave_js_server/model/controller.py,sha256=KcjWELFj-jUdHbnV-EafHN52Q8sYxztiwOB1XkP0faY,13140
+zwave_js_server/model/device_class.py,sha256=XxiTRVxY-Dc5cVHfJQFc2IkUHEXRiLpL5-V49PkwMxg,1708
+zwave_js_server/model/device_config.py,sha256=JcOC-QUiBWjWd3NM11EwJoirVTU2uMsVoUxu2ExAnCs,2715
+zwave_js_server/model/driver.py,sha256=FLuJF2x63HjSkX6iNR4GkCKHdlg5AXTfoeezC67KVNI,1802
+zwave_js_server/model/endpoint.py,sha256=wOa9dXZBkkG8e_cqHYwaMUzuofWPgkxr8cRcW8R41EM,1315
+zwave_js_server/model/log_config.py,sha256=21_roDDPzxKuYl1TNiIJ0vhtPI2Zx6tzzAVwql-cbLM,1571
+zwave_js_server/model/node.py,sha256=hPBvzDlxG1ytdXE6NNqpM1_-zR5gsGPlmBQvuzqTmKc,17526
+zwave_js_server/model/notification.py,sha256=hflkoNjr6ZrS7D1rpdTmeVfi6h9L87EqGCVupgmBAZY,3689
+zwave_js_server/model/value.py,sha256=2rNZ7aDsC62iSzRiqdwXnhmbXRrc08P0wPLglltg5sY,8250
+zwave_js_server/model/version.py,sha256=FTdCCyHW69NW4CXeeuNMx339SF0tV2ZipPt24eVcl2o,1000
+zwave_js_server/util/__init__.py,sha256=ArF1K885aW0GdVd7Lo8fl8Atf70gvsxO5Ra_WoJTG28,42
+zwave_js_server/util/helpers.py,sha256=nWTa9KIJJ4Kg9-ZDMKUpQgzdrwe911MJYdbQWE8WYN8,1303
+zwave_js_server/util/lock.py,sha256=KG4fGOlVY8FbFn6b2hxULRGnso3ljs2X38sRksrKxdQ,3197
+zwave_js_server/util/node.py,sha256=rMAe1O5uGHFuSadv2fkKloE11EIh9bSKfkTNWAHirVg,9161
+zwave_js_server_python-0.23.0.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+zwave_js_server_python-0.23.0.dist-info/METADATA,sha256=aCYXs_WzJlB4QW3xzXUTy2qFWuawFphcCYU24GKnSQU,1579
+zwave_js_server_python-0.23.0.dist-info/WHEEL,sha256=OqRkF0eY5GHssMorFjlbTIq072vpHpF60fIQA6lS9xA,92
+zwave_js_server_python-0.23.0.dist-info/entry_points.txt,sha256=_8Swg1yhKiBElo6k1fxIEd6E8uPz8PDxQpwQoZ29FZE,74
+zwave_js_server_python-0.23.0.dist-info/top_level.txt,sha256=-hwsl-i4Av5Op_yfOHC_OP56KPmzp_iVEkeohRIN5Ng,16
+zwave_js_server_python-0.23.0.dist-info/RECORD,,

zwave_js_server_python-0.22.0.dist-info/RECORD

@@ -1,31 +0,0 @@
-zwave_js_server/__init__.py,sha256=Ey3O4Tha56uU-M92oLJmQHupCJ7B9oZmxlQTo8pGUM8,45
-zwave_js_server/__main__.py,sha256=1gWC927sa3FwcA47ndmrRWW0HlfYVdiUarjEsccRF2k,3624
-zwave_js_server/client.py,sha256=Tz6nKa9uZFhBgh1HTXwW6jUMauUq-oSgCBPxIW7UJcQ,10788
-zwave_js_server/const.py,sha256=l0wTowqvJfI4eXAlVvdBWrFuZbsYTH12t7jRgLwJYJs,10139
-zwave_js_server/dump.py,sha256=inv0Q-i0DbzEcbwXeLDiu29U2I248pPMyNUTQDp5wYY,1184
-zwave_js_server/event.py,sha256=0Aw3NzkzKMnhS7AxBh6BwAVYXRu4zDKeUDib9mHjj8w,1772
-zwave_js_server/exceptions.py,sha256=OYKHE_1UatceS-U0cZs36uzdXhUYyAJJ6aHltPcde9E,2624
-zwave_js_server/version.py,sha256=RDFP2kSU3cCVIQbgMWggdeDnvhtVsZzzZg9pOjH7CC8,364
-zwave_js_server/model/__init__.py,sha256=XfyKH8lxZ3CB7CbRkOr5sR-eV0GrklZiBtNPmlnCJ_8,123
-zwave_js_server/model/association.py,sha256=eUCb3uOow4KiMJ95YkWP2jufQNt9HBb5ahQB8pFlFhA,529
-zwave_js_server/model/command_class.py,sha256=ASBS2Gx6z8ghKsnHKV3a7k6zSfAoTx2-xG_B-NjHeb8,1117
-zwave_js_server/model/controller.py,sha256=pepUanQTBGBqU8I6lxTlNnhNawgXOmuGboYPMYeScxY,13150
-zwave_js_server/model/device_class.py,sha256=XxiTRVxY-Dc5cVHfJQFc2IkUHEXRiLpL5-V49PkwMxg,1708
-zwave_js_server/model/device_config.py,sha256=JcOC-QUiBWjWd3NM11EwJoirVTU2uMsVoUxu2ExAnCs,2715
-zwave_js_server/model/driver.py,sha256=D4pqsOHgWjjBAKTIiWpqZuSyBMwtTAaxCvx5UUGRvR0,1801
-zwave_js_server/model/endpoint.py,sha256=un0SSPaKpa-n2cslj8rfwavI5PzvXX4J0X-uMc3et3Y,1056
-zwave_js_server/model/log_config.py,sha256=LyjCBYJ8q2STQFlycfCLpIqfeMT5Up0DwhsY8xBZznk,1506
-zwave_js_server/model/node.py,sha256=3VpdCylyysjTxL8WWgAr3-OTbhuWrya687TT6Eg6RsU,16721
-zwave_js_server/model/notification.py,sha256=9nuQS6lpAr7zqk8odZQbgmUTW3xsoC2P6TfyydcN1iw,1189
-zwave_js_server/model/value.py,sha256=zX3KbpPv-5rqU2jIuezf5PQVhnaOJSvLEGspXnhg5Ao,8122
-zwave_js_server/model/version.py,sha256=FTdCCyHW69NW4CXeeuNMx339SF0tV2ZipPt24eVcl2o,1000
-zwave_js_server/util/__init__.py,sha256=ArF1K885aW0GdVd7Lo8fl8Atf70gvsxO5Ra_WoJTG28,42
-zwave_js_server/util/helpers.py,sha256=WMXhcODwE1UU6E9LZca_tdKQxifZVTH4IO3UcszdgbA,996
-zwave_js_server/util/lock.py,sha256=jdEU0eyS_9TnZYz-BMU4amUsNFplSsoRpSBFHUWlHKc,3197
-zwave_js_server/util/node.py,sha256=N5JCXxhQe1sjbOK9K9S7gD6mk8kx8bv6uMeKRpnBHjY,4566
-zwave_js_server_python-0.22.0.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-zwave_js_server_python-0.22.0.dist-info/METADATA,sha256=rUqNTy1yXTTAAzB-h8WuGIPq-qw-vicMIqJ6Zj3ApfE,1579
-zwave_js_server_python-0.22.0.dist-info/WHEEL,sha256=OqRkF0eY5GHssMorFjlbTIq072vpHpF60fIQA6lS9xA,92
-zwave_js_server_python-0.22.0.dist-info/entry_points.txt,sha256=_8Swg1yhKiBElo6k1fxIEd6E8uPz8PDxQpwQoZ29FZE,74
-zwave_js_server_python-0.22.0.dist-info/top_level.txt,sha256=-hwsl-i4Av5Op_yfOHC_OP56KPmzp_iVEkeohRIN5Ng,16
-zwave_js_server_python-0.22.0.dist-info/RECORD,,