zwave-js-server-python 0.35.0__tar.gz → 0.35.3__tar.gz

{zwave-js-server-python-0.35.0 → zwave-js-server-python-0.35.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: zwave-js-server-python
-Version: 0.35.0
+Version: 0.35.3
 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.0 → zwave-js-server-python-0.35.3}/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.0"
+VERSION = "0.35.3"
 
 
 setup(

{zwave-js-server-python-0.35.0 → zwave-js-server-python-0.35.3}/zwave_js_server/event.py

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

{zwave-js-server-python-0.35.0 → zwave-js-server-python-0.35.3}/zwave_js_server/exceptions.py

@@ -4,7 +4,6 @@ from typing import TYPE_CHECKING, Optional
 from .const import CommandClass
 
 if TYPE_CHECKING:
-    from .event import Event
     from .model.value import Value
 
 
@@ -157,16 +156,3 @@ 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-python-0.35.0 → zwave-js-server-python-0.35.3}/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.0 → zwave-js-server-python-0.35.3}/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
@@ -420,18 +420,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 +444,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."""

{zwave-js-server-python-0.35.0 → zwave-js-server-python-0.35.3}/zwave_js_server/model/device_config.py

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

{zwave-js-server-python-0.35.0 → zwave-js-server-python-0.35.3}/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.0 → zwave-js-server-python-0.35.3}/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.0 → zwave-js-server-python-0.35.3}/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,
 )
@@ -58,6 +58,9 @@ if TYPE_CHECKING:
     from ...client import Client
 
 
+_LOGGER = logging.getLogger(__package__)
+
+
 class Node(EventBase):
     """Represent a Z-Wave JS node."""
 
@@ -152,7 +155,9 @@ class Node(EventBase):
     @property
     def is_secure(self) -> Optional[bool]:
         """Return the is_secure."""
-        return self.data.get("isSecure")
+        if (is_secure := self.data.get("isSecure")) == "unknown":
+            return None
+        return is_secure
 
     @property
     def protocol_version(self) -> Optional[int]:
@@ -787,7 +792,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."""

{zwave-js-server-python-0.35.0 → zwave-js-server-python-0.35.3}/zwave_js_server/model/node/data_model.py

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

{zwave-js-server-python-0.35.0 → zwave-js-server-python-0.35.3}/zwave_js_server_python.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: zwave-js-server-python
-Version: 0.35.0
+Version: 0.35.3
 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.0 → zwave-js-server-python-0.35.3}/zwave_js_server_python.egg-info/SOURCES.txt

@@ -2,9 +2,6 @@ LICENSE
 README.md
 setup.cfg
 setup.py
-scripts/__init__.py
-scripts/generate_multilevel_sensor_constants.py
-scripts/run_mock_server.py
 test/test_client.py
 test/test_dump.py
 test/test_event.py

{zwave-js-server-python-0.35.0 → zwave-js-server-python-0.35.3}/zwave_js_server_python.egg-info/top_level.txt

@@ -1,2 +1 @@
-scripts
 zwave_js_server

zwave-js-server-python-0.35.0/scripts/__init__.py

@@ -1 +0,0 @@
-"""Scripts module."""

zwave-js-server-python-0.35.0/scripts/generate_multilevel_sensor_constants.py

@@ -1,245 +0,0 @@
-"""Script to generate Multilevel Sensor CC constants."""
-from __future__ import annotations
-
-import json
-import pathlib
-import re
-import subprocess
-from collections import defaultdict
-from typing import Callable, List
-
-import requests
-from slugify import slugify
-
-GITHUB_PROJECT = "zwave-js/node-zwave-js"
-BRANCH_NAME = "master"
-SENSOR_TYPES_FILE_PATH = "packages/config/config/sensorTypes.json"
-DEFAULT_SCALES_FILE_PATH = "packages/config/config/scales.json"
-
-CONST_FILE_PATH = pathlib.Path(__file__).parent.joinpath(
-    "../zwave_js_server/const/command_class/multilevel_sensor.py"
-)
-
-
-def remove_comments(text: str) -> str:
-    """Remove comments from a JSON string."""
-    return "\n".join(
-        line for line in text.split("\n") if not line.strip().startswith("//")
-    )
-
-
-def remove_paranthesis(text: str) -> str:
-    """Remove text in paranethesis from a string."""
-    return re.sub(r"\([^)]*\)", "", text)
-
-
-def enum_name_format(name: str, should_remove_paranthesis: bool) -> str:
-    """Convert sensor/scale name to enum format."""
-    if should_remove_paranthesis:
-        name = remove_paranthesis(name)
-    return slugify(name, separator="_").upper()
-
-
-def normalize_name(name: str) -> str:
-    """Convert a sensor/scale name into a normalized name."""
-    return enum_name_format(name, True).replace("_", " ").title()
-
-
-def format_for_class_name(name: str) -> str:
-    """Convert sensor/scale name to class name format."""
-    return f"{normalize_name(name).replace(' ', '')}Scale"
-
-
-def normalize_scale_definition(scale_definitions: dict[str, dict]) -> dict[str, int]:
-    """Convert a scales definition dictionary into a normalized dictionary."""
-    scale_def_ = {}
-    for scale_id, scale_props in scale_definitions.items():
-        scale_id = int(scale_id, 16)
-        scale_name_ = enum_name_format(scale_props["label"], True)
-        scale_def_[scale_name_] = scale_id
-
-    return dict(sorted(scale_def_.items(), key=lambda kv: kv[0]))
-
-
-sensor_types = json.loads(
-    remove_comments(
-        requests.get(
-            (
-                f"https://raw.githubusercontent.com/{GITHUB_PROJECT}/{BRANCH_NAME}/"
-                f"{SENSOR_TYPES_FILE_PATH}"
-            )
-        ).text
-    )
-)
-default_scales = json.loads(
-    remove_comments(
-        requests.get(
-            (
-                f"https://raw.githubusercontent.com/{GITHUB_PROJECT}/{BRANCH_NAME}/"
-                f"{DEFAULT_SCALES_FILE_PATH}"
-            )
-        ).text
-    )
-)
-
-scales = {
-    normalize_name(scale_name): normalize_scale_definition(scale_def)
-    for scale_name, scale_def in default_scales.items()
-}
-
-sensors = {}
-for sensor_id, sensor_props in sensor_types.items():
-    sensor_id = int(sensor_id, 16)
-    scale_def = sensor_props["scales"]
-    remove_paranthesis_ = True
-    if sensor_id in (87, 88):
-        remove_paranthesis_ = False
-    sensor_name = enum_name_format(sensor_props["label"], remove_paranthesis_)
-    sensors[sensor_name] = {"id": sensor_id}
-    if isinstance(scale_def, str):
-        sensors[sensor_name]["scale"] = normalize_name(
-            scale_def.replace("$SCALES:", "")
-        )
-    else:
-        scales[sensor_name] = normalize_scale_definition(scale_def)
-        sensors[sensor_name]["scale"] = normalize_name(sensor_name)
-
-scales = dict(sorted(scales.items(), key=lambda kv: kv[0]))
-sensors = dict(sorted(sensors.items(), key=lambda kv: kv[0]))
-
-
-def generate_int_enum_class_definition(
-    class_name: str,
-    enum_dict: dict[str, str | dict],
-    enum_ref_url: str | None = None,
-    get_id_func: Callable | None = None,
-    docstring_info: str = "",
-) -> List[str]:
-    """Generate an IntEnum class definition as an array of lines of string."""
-    class_def = []
-    class_def.append(f"class {class_name}(IntEnum):")
-    docstring = (
-        f'"""Enum for known {docstring_info} multilevel sensor types."""'.replace(
-            "  ", " "
-        )
-    )
-    class_def.append(f"    {docstring}")
-    if enum_ref_url:
-        class_def.append(f"    # {enum_ref_url}")
-    for enum_name, enum_id in enum_dict.items():
-        if get_id_func:
-            enum_id = get_id_func(enum_id)
-        class_def.append(f"    {enum_name} = {enum_id}")
-    return class_def
-
-
-SENSOR_TYPE_URL = (
-    f"https://github.com/{GITHUB_PROJECT}/blob/{BRANCH_NAME}/{SENSOR_TYPES_FILE_PATH}"
-)
-
-lines = [
-    '"""Constants for the Multilevel Sensor CC."""',
-    "",
-    "# ----------------------------------------------------------------------------------- #",
-    "# **BEGINNING OF AUTOGENERATED CONTENT** (TO ADD ADDITIONAL MANUAL CONTENT, LOOK FOR  #",
-    '# THE "END OF AUTOGENERATED CONTENT" COMMENT BLOCK AND ADD YOUR CODE BELOW IT)        #',
-    "# ----------------------------------------------------------------------------------- #",
-    "",
-    "from enum import IntEnum",
-    "from typing import Dict, Set, Type, Union",
-    'CC_SPECIFIC_SCALE = "scale"',
-    'CC_SPECIFIC_SENSOR_TYPE = "sensorType"',
-]
-
-lines.extend(
-    generate_int_enum_class_definition(
-        "MultilevelSensorType",
-        sensors,
-        SENSOR_TYPE_URL,
-        get_id_func=lambda x: x["id"],
-    )
-)
-
-unit_name_to_enum_map = defaultdict(list)
-for scale_name, scale_dict in scales.items():
-    lines.extend(
-        generate_int_enum_class_definition(
-            format_for_class_name(scale_name),
-            scale_dict,
-            SENSOR_TYPE_URL,
-            docstring_info=f"scales for {scale_name}",
-        )
-    )
-    for unit_name in scale_dict.keys():
-        unit_name_to_enum_map[unit_name].append(
-            f"{format_for_class_name(scale_name)}.{unit_name}"
-        )
-unit_name_to_enum_map = dict(
-    sorted(unit_name_to_enum_map.items(), key=lambda kv: kv[0])
-)
-for unit_name, enum_list in unit_name_to_enum_map.items():
-    unit_name_to_enum_map[unit_name] = sorted(enum_list)
-
-scale_class_names = [format_for_class_name(scale_name) for scale_name in scales]
-lines.extend(
-    [f"MultilevelSensorScaleType = Union[{', '.join(sorted(scale_class_names))}]", ""]
-)
-
-multilevel_sensor_type_to_scale_map_line = (
-    "MULTILEVEL_SENSOR_TYPE_TO_SCALE_MAP: Dict[MultilevelSensorType, "
-    "Type[MultilevelSensorScaleType]] = {"
-)
-for sensor_name, sensor_def in sensors.items():
-    multilevel_sensor_type_to_scale_map_line += (
-        f"    MultilevelSensorType.{sensor_name}: "
-        f"{format_for_class_name(sensor_def['scale'])},"
-    )
-multilevel_sensor_type_to_scale_map_line += "}"
-lines.append(multilevel_sensor_type_to_scale_map_line)
-lines.append("")
-
-for unit_name, unit_enums in unit_name_to_enum_map.items():
-    lines.append(
-        f"UNIT_{unit_name}: Set[MultilevelSensorScaleType] = {{{','.join(sorted(unit_enums))}}}"
-    )
-
-lines.extend(
-    [
-        "",
-        "# ----------------------------------------------------------------------------------- #",
-        "# **END OF AUTOGENERATED CONTENT** (DO NOT EDIT/REMOVE THIS COMMENT BLOCK AND DO NOT  #",
-        "# EDIT ANYTHING ABOVE IT. IF A NEW IMPORT IS NEEDED, UPDATE THE LINES AROUND 135      #",
-        "# IN scripts/generate_multilevel_sensor_constants.py THEN RE-RUN THE SCRIPT. ALL      #",
-        "# LINES WRITTEN BELOW THIS BLOCK WILL BE PRESERVED AS LONG AS THIS BLOCK REMAINS)     #",
-        "# ----------------------------------------------------------------------------------- #",
-        "",
-    ]
-)
-
-existing_const_file = CONST_FILE_PATH.read_text(encoding="utf-8").splitlines()
-
-manually_written_code_start_idx = (
-    next(
-        i
-        for i, line in enumerate(existing_const_file)
-        if "**END OF AUTOGENERATED CONTENT**" in line
-    )
-    + 6
-)
-if len(existing_const_file) > manually_written_code_start_idx:
-    lines.extend(
-        [
-            line.strip("\n")
-            for line in existing_const_file[manually_written_code_start_idx:]
-        ]
-    )
-
-CONST_FILE_PATH.write_text("\n".join(lines), encoding="utf-8")
-
-if subprocess.run(["which", "black"], capture_output=True, check=True).stdout:
-    subprocess.run(
-        ["black", CONST_FILE_PATH],
-        check=True,
-    )
-else:
-    print("Could not run black on new file, please run it to properly format it.")