Add support for schema 47 state properties and events (1/4) (#1404)

* Add support for schema 47 state properties and events (1/4)

Mirrors upstream PR #1509. This is the first of four PRs that together
add full schema 47 support; the subsequent three add the new commands
(driver, controller/node/endpoint, zniffer/utility/broadcast).

Bumps both MIN_SERVER_SCHEMA_VERSION and MAX_SERVER_SCHEMA_VERSION to
47, since HA will rely on the new state properties as load-bearing.

State properties added:
- Driver.ready / all_nodes_ready / config_version (new Driver.data dict
  populated from state["driver"], plus Driver.update() symmetric with
  Controller.update())
- Controller.is_sis / max_payload_size / max_payload_size_lr /
  zwave_api_version / zwave_chip_type
- Node.can_sleep / supports_wake_up_on_demand / hardware_version /
  has_suc_return_route / manufacturer / dsk

Events added:
- Driver: bootloader ready, error (with error payload)
- Controller: network found (with homeId/ownNodeId), network joined,
  network left, joining network failed, leaving network failed

State mutations on event handlers:
- handle_driver_ready -> data["ready"] = True
- handle_all_nodes_ready -> data["allNodesReady"] = True
- handle_network_found is currently a no-op; whether it should mutate
  data["homeId"]/["ownNodeId"] from the event payload (vs. waiting for
  network joined or a fresh state dump) is an open question for upstream
  review.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

* Address Copilot review on #1404

- Rename unused `event` param to `_event` on `handle_error` and
  `handle_bootloader_ready` for consistency with `handle_driver_ready` /
  `handle_all_nodes_ready` (which were already renamed in this branch).
- Move the `handle_network_found` open design question out of the
  user-facing docstring and into a TODO code comment. The docstring now
  documents current behavior succinctly.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

* Address review: unify ZWaveChipType and add test annotations

Addresses MartinHjelmare's review comments on #1404:

1. Replace `str | UnknownZWaveChipTypeDataType | None` return type on
   `Controller.zwave_chip_type` with a unified `ZWaveChipType` frozen
   dataclass. Known chips set `name`; unknown chips set `type`/`version`.
   Includes `from_dict` classmethod following the codebase convention.

2. Add complete type annotations (parameter types + `-> None`) to all
   new test functions in test_driver.py, test_controller.py, and
   test_node.py.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: raman325

test/conftest.py

@@ -262,7 +262,7 @@ def version_data_fixture() -> dict[str, Any]:
         "serverVersion": "test_server_version",
         "homeId": "test_home_id",
         "minSchemaVersion": 0,
-        "maxSchemaVersion": 46,
+        "maxSchemaVersion": 47,
     }
 
 

test/model/test_controller.py

@@ -3,10 +3,12 @@
 from copy import deepcopy
 import json
 import logging
+from typing import Any
 from unittest.mock import patch
 
 import pytest
 
+from zwave_js_server.client import Client
 from zwave_js_server.const import (
     AssociationCheckResult,
     ControllerStatus,
@@ -29,6 +31,7 @@
     controller as controller_pkg,
 )
 from zwave_js_server.model.controller import Controller
+from zwave_js_server.model.controller.data_model import ZWaveChipType
 from zwave_js_server.model.controller.rebuild_routes import (
     RebuildRoutesOptions,
     RebuildRoutesStatus,
@@ -2359,3 +2362,82 @@ async def test_inclusion_state_changed(controller):
     )
     controller.receive_event(event)
     assert controller.inclusion_state == InclusionState.INCLUDING
+
+
+async def test_schema_47_controller_state_properties(
+    client: Client, controller_state: dict[str, Any]
+) -> None:
+    """Schema 47+ controller state properties read from the controller state dict."""
+    state = {
+        "controller": {
+            **controller_state["controller"],
+            "isSIS": True,
+            "maxPayloadSize": 46,
+            "maxPayloadSizeLR": 1280,
+            "zwaveApiVersion": {"kind": "official", "version": 11},
+            "zwaveChipType": "ZW0700",
+        },
+        "nodes": [],
+    }
+    ctl = Controller(client, state)
+    assert ctl.is_sis is True
+    assert ctl.max_payload_size == 46
+    assert ctl.max_payload_size_lr == 1280
+    assert ctl.zwave_api_version == {"kind": "official", "version": 11}
+    assert ctl.zwave_chip_type == ZWaveChipType(name="ZW0700")
+
+    # Unknown chip type exposes type/version instead of name.
+    state["controller"]["zwaveChipType"] = {"type": 7, "version": 0}
+    ctl = Controller(client, state)
+    assert ctl.zwave_chip_type == ZWaveChipType(type=7, version=0)
+    assert ctl.zwave_chip_type.name is None
+
+    # All schema-47 properties default to None when absent.
+    bare = Controller(
+        client, {"controller": controller_state["controller"], "nodes": []}
+    )
+    assert bare.is_sis is None
+    assert bare.max_payload_size is None
+    assert bare.max_payload_size_lr is None
+    assert bare.zwave_api_version is None
+    assert bare.zwave_chip_type is None
+
+
+async def test_schema_47_network_lifecycle_events(controller: Controller) -> None:
+    """The new schema-47 network events are dispatched and observable."""
+    received: list[str] = []
+    for evt in (
+        "network found",
+        "network joined",
+        "network left",
+        "joining network failed",
+        "leaving network failed",
+    ):
+        controller.on(evt, lambda data, name=evt: received.append(name))
+
+    controller.receive_event(
+        Event(
+            "network found",
+            {
+                "source": "controller",
+                "event": "network found",
+                "homeId": 12345,
+                "ownNodeId": 1,
+            },
+        )
+    )
+    for evt in (
+        "network joined",
+        "network left",
+        "joining network failed",
+        "leaving network failed",
+    ):
+        controller.receive_event(Event(evt, {"source": "controller", "event": evt}))
+
+    assert received == [
+        "network found",
+        "network joined",
+        "network left",
+        "joining network failed",
+        "leaving network failed",
+    ]

test/model/test_driver.py

@@ -6,6 +6,7 @@
 
 import pytest
 
+from zwave_js_server.client import Client
 from zwave_js_server.const import LogLevel
 from zwave_js_server.event import Event
 from zwave_js_server.model import (
@@ -394,14 +395,16 @@ async def test_unknown_event(driver, caplog):
     assert caplog.records[0].levelno == logging.INFO
 
 
-async def test_all_nodes_ready_event(driver):
-    """Test that the all nodes ready event is succesfully validated by pydantic."""
+async def test_all_nodes_ready_event(driver: Driver) -> None:
+    """`all nodes ready` event marks the driver as having all nodes ready."""
+    assert driver.all_nodes_ready is None  # not set yet
     event = Event("all nodes ready", {"source": "driver", "event": "all nodes ready"})
     driver.receive_event(event)
+    assert driver.all_nodes_ready is True
 
 
-async def test_driver_ready_event(driver):
-    """Test that the driver ready event is succesfully validated by pydantic."""
+async def test_driver_ready_event(driver: Driver) -> None:
+    """`driver ready` event marks the driver as ready and fires listeners."""
     event_type = "driver ready"
     event_data = {"source": "driver", "event": event_type}
     event = Event(event_type, event_data)
@@ -410,7 +413,70 @@ def callback(data: dict) -> None:
         assert data == event_data
 
     driver.on(event_type, callback)
+    assert driver.ready is None  # not set yet
     driver.receive_event(event)
+    assert driver.ready is True
+
+
+async def test_schema_47_driver_state_properties(
+    client: Client, controller_state: dict[str, Any], log_config: dict[str, Any]
+) -> None:
+    """Schema 47+ driver state properties read from state["driver"]."""
+
+    state = {
+        **controller_state,
+        "driver": {
+            "ready": True,
+            "allNodesReady": False,
+            "configVersion": "2026.3.0",
+        },
+    }
+    driver = Driver(client, state, log_config)
+    assert driver.ready is True
+    assert driver.all_nodes_ready is False
+    assert driver.config_version == "2026.3.0"
+
+    # Properties default to None when state["driver"] is absent.
+    bare = Driver(client, controller_state, log_config)
+    assert bare.ready is None
+    assert bare.all_nodes_ready is None
+    assert bare.config_version is None
+
+
+async def test_driver_update_replaces_data(driver: Driver) -> None:
+    """`Driver.update()` replaces the data dict, mirroring Controller.update()."""
+    driver.update({"ready": True, "allNodesReady": True, "configVersion": "2026.4.0"})
+    assert driver.ready is True
+    assert driver.all_nodes_ready is True
+    assert driver.config_version == "2026.4.0"
+
+
+async def test_error_event(driver: Driver) -> None:
+    """`error` event fires listeners and exposes the error string."""
+    received: list[str] = []
+    driver.on("error", lambda data: received.append(data["error"]))
+    driver.receive_event(
+        Event(
+            "error",
+            {"source": "driver", "event": "error", "error": "boom"},
+        )
+    )
+    assert received == ["boom"]
+
+
+async def test_bootloader_ready_event(driver: Driver) -> None:
+    """`bootloader ready` event fires listeners (observable only, no state)."""
+    fired = False
+
+    def cb(_data: dict) -> None:
+        nonlocal fired
+        fired = True
+
+    driver.on("bootloader ready", cb)
+    driver.receive_event(
+        Event("bootloader ready", {"source": "driver", "event": "bootloader ready"})
+    )
+    assert fired
 
 
 def test_config_manager(driver):

test/model/test_node.py

@@ -10,6 +10,7 @@
 
 import pytest
 
+from zwave_js_server.client import Client
 from zwave_js_server.const import (
     INTERVIEW_FAILED,
     CommandClass,
@@ -2836,3 +2837,34 @@ def callback(data: dict) -> None:
 
     node.on(event_type, callback)
     node.receive_event(event)
+
+
+async def test_schema_47_node_state_properties(
+    client: Client, multisensor_6_state: dict[str, Any]
+) -> None:
+    """Schema 47+ node state properties read from the node data dict."""
+    enriched_state = {
+        **multisensor_6_state,
+        "canSleep": True,
+        "supportsWakeUpOnDemand": False,
+        "hardwareVersion": 3,
+        "hasSUCReturnRoute": True,
+        "manufacturer": "Aeotec",
+        "dsk": "12345-67890-12345-67890-12345-67890-12345-67890",
+    }
+    node = node_pkg.Node(client, enriched_state)
+    assert node.can_sleep is True
+    assert node.supports_wake_up_on_demand is False
+    assert node.hardware_version == 3
+    assert node.has_suc_return_route is True
+    assert node.manufacturer == "Aeotec"
+    assert node.dsk == "12345-67890-12345-67890-12345-67890-12345-67890"
+
+    # Properties default to None when absent.
+    bare = node_pkg.Node(client, multisensor_6_state)
+    assert bare.can_sleep is None
+    assert bare.supports_wake_up_on_demand is None
+    assert bare.hardware_version is None
+    assert bare.has_suc_return_route is None
+    assert bare.manufacturer is None
+    assert bare.dsk is None

test/test_client.py

@@ -463,7 +463,7 @@ async def test_additional_user_agent_components(client_session, url):
             {
                 "command": "initialize",
                 "messageId": "initialize",
-                "schemaVersion": 46,
+                "schemaVersion": 47,
                 "additionalUserAgentComponents": {
                     "zwave-js-server-python": __version__,
                     "foo": "bar",

test/test_dump.py

@@ -106,7 +106,7 @@ async def test_dump_additional_user_agent_components(
         {
             "command": "initialize",
             "messageId": "initialize",
-            "schemaVersion": 46,
+            "schemaVersion": 47,
             "additionalUserAgentComponents": {
                 "zwave-js-server-python": __version__,
                 "foo": "bar",

test/test_main.py

@@ -58,7 +58,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': 46}\n"
+        "'minSchemaVersion': 0, 'maxSchemaVersion': 47}\n"
         "{'type': 'result', 'success': True, 'result': {}, 'messageId': 'initialize'}\n"
         "test_result\n"
     )

zwave_js_server/const/__init__.py

@@ -11,9 +11,9 @@
 __version__ = "0.69.0"
 
 # minimal server schema version we can handle
-MIN_SERVER_SCHEMA_VERSION = 44
+MIN_SERVER_SCHEMA_VERSION = 47
 # max server schema version we can handle (and our code is compatible with)
-MAX_SERVER_SCHEMA_VERSION = 46
+MAX_SERVER_SCHEMA_VERSION = 47
 
 VALUE_UNKNOWN = "unknown"
 

zwave_js_server/model/controller/__init__.py

@@ -26,7 +26,7 @@
 from ..association import AssociationAddress, AssociationGroup
 from ..node import Node
 from ..node.firmware import NodeFirmwareUpdateResult
-from .data_model import ControllerDataType
+from .data_model import ControllerDataType, ZWaveApiVersionDataType, ZWaveChipType
 from .event_model import CONTROLLER_EVENT_MODEL_MAP
 from .inclusion_and_provisioning import (
     InclusionGrant,
@@ -247,6 +247,33 @@ def supports_long_range(self) -> bool | None:
         """Return whether controller supports long range or not."""
         return self.data.get("supportsLongRange")
 
+    @property
+    def is_sis(self) -> bool | None:
+        """Return whether the controller is the SIS (Static Information Source)."""
+        return self.data.get("isSIS")
+
+    @property
+    def max_payload_size(self) -> int | None:
+        """Return the maximum Z-Wave payload size in bytes."""
+        return self.data.get("maxPayloadSize")
+
+    @property
+    def max_payload_size_lr(self) -> int | None:
+        """Return the maximum Long Range payload size in bytes."""
+        return self.data.get("maxPayloadSizeLR")
+
+    @property
+    def zwave_api_version(self) -> ZWaveApiVersionDataType | None:
+        """Return the Z-Wave API version (kind + version) supported by the controller."""
+        return self.data.get("zwaveApiVersion")
+
+    @property
+    def zwave_chip_type(self) -> ZWaveChipType | None:
+        """Return the Z-Wave chip type."""
+        if (raw := self.data.get("zwaveChipType")) is None:
+            return None
+        return ZWaveChipType.from_dict(raw)
+
     def update(self, data: ControllerDataType) -> None:
         """Update controller data."""
         self.data = data
@@ -1014,3 +1041,20 @@ def handle_status_changed(self, event: Event) -> None:
         """Process a status changed event."""
         self.data["status"] = event.data["status"]
         event.data["status"] = ControllerStatus(event.data["status"])
+
+    def handle_network_found(self, _event: Event) -> None:
+        """Process a `network found` event without mutating controller identity."""
+        # TODO: Revisit whether `homeId` / `ownNodeId` from this event should
+        # update `self.data` once upstream semantics are confirmed.
+
+    def handle_network_joined(self, event: Event) -> None:
+        """Process a `network joined` event (schema 47+)."""
+
+    def handle_network_left(self, event: Event) -> None:
+        """Process a `network left` event (schema 47+)."""
+
+    def handle_joining_network_failed(self, event: Event) -> None:
+        """Process a `joining network failed` event (schema 47+)."""
+
+    def handle_leaving_network_failed(self, event: Event) -> None:
+        """Process a `leaving network failed` event (schema 47+)."""