matter-python-client 1.4.0a0.dev20260802__tar.gz → 1.4.0a0.dev20260806__tar.gz

{matter_python_client-1.4.0a0.dev20260802 → matter_python_client-1.4.0a0.dev20260806}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: matter-python-client
-Version: 1.4.0a0.dev20260802
+Version: 1.4.0a0.dev20260806
 Summary: Python Client for the OHF Matter Server
 Author-email: Open Home Foundation <hello@openhomefoundation.io>
 License-Expression: Apache-2.0

{matter_python_client-1.4.0a0.dev20260802 → matter_python_client-1.4.0a0.dev20260806}/matter_python_client.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: matter-python-client
-Version: 1.4.0a0.dev20260802
+Version: 1.4.0a0.dev20260806
 Summary: Python Client for the OHF Matter Server
 Author-email: Open Home Foundation <hello@openhomefoundation.io>
 License-Expression: Apache-2.0

{matter_python_client-1.4.0a0.dev20260802 → matter_python_client-1.4.0a0.dev20260806}/matter_python_client.egg-info/SOURCES.txt

@@ -178,6 +178,7 @@ matter_server/common/helpers/__init__.py
 matter_server/common/helpers/api.py
 matter_server/common/helpers/json.py
 matter_server/common/helpers/util.py
+tests/test_client.py
 tests/test_client_integration.py
 tests/test_credentials.py
 tests/test_event_dispatch.py
@@ -185,4 +186,5 @@ tests/test_icd.py
 tests/test_imports.py
 tests/test_integration.py
 tests/test_network_topology.py
+tests/test_util.py
 tests/test_webrtc_protocol.py

{matter_python_client-1.4.0a0.dev20260802 → matter_python_client-1.4.0a0.dev20260806}/matter_server/client/client.py

@@ -16,6 +16,7 @@ from matter_server.common.helpers.util import (
     create_attribute_path_from_attribute,
     dataclass_from_dict,
     dataclass_to_dict,
+    dataclass_to_tag_dict,
 )
 from matter_server.common.models import (
     APICommand,
@@ -623,7 +624,7 @@ class MatterClient:
             require_schema=4,
             node_id=node_id,
             attribute_path=attribute_path,
-            value=value,
+            value=dataclass_to_tag_dict(value),
         )
 
     async def remove_node(self, node_id: int) -> None:

{matter_python_client-1.4.0a0.dev20260802 → matter_python_client-1.4.0a0.dev20260806}/matter_server/common/helpers/util.py

@@ -89,6 +89,43 @@ def dataclass_to_dict(obj_in: DataclassInstance) -> dict:
     )
 
 
+def dataclass_to_tag_dict(obj_in: Any) -> Any:
+    """Recursively convert dataclass instance(s) to TLV tag-keyed dict(s).
+
+    Unlike dataclass_to_dict (keyed by field name, used for DEVICE_COMMAND
+    payloads), WRITE_ATTRIBUTE expects struct values keyed by their numeric
+    TLV tag, matching the format already used for attribute reports.
+
+    Every generated CHIP cluster dataclass (the only kind ever passed to
+    write_attribute()) exposes a `descriptor` with a Tag per field, so the
+    tag lookup always succeeds in practice. A dataclass field is only ever
+    kept name-keyed if `descriptor`/`GetFieldByLabel` is missing/unset for
+    that field, which should not happen for real cluster structs; this is a
+    defensive fallback, not an expected code path.
+
+    A field whose value is None is omitted, matching CHIP's own TLV encoder
+    (ClusterObjects.PutFieldToTLV), which treats None as absent rather than
+    writing an explicit null; NullValue fields are still emitted.
+    """
+    if is_dataclass(obj_in) and not isinstance(obj_in, type):
+        descriptor = getattr(type(obj_in), "descriptor", None)
+        result: dict[str, Any] = {}
+        for field in cached_fields(type(obj_in)):
+            value = getattr(obj_in, field.name)
+            if value is None:
+                continue
+            field_descriptor = descriptor.GetFieldByLabel(field.name) if descriptor is not None else None
+            tag = field_descriptor.Tag if field_descriptor is not None else None
+            key = str(tag) if tag is not None else field.name
+            result[key] = dataclass_to_tag_dict(value)
+        return result
+    if isinstance(obj_in, (list, tuple)):
+        return [dataclass_to_tag_dict(item) for item in obj_in]
+    if isinstance(obj_in, dict):
+        return {key: dataclass_to_tag_dict(value) for key, value in obj_in.items()}
+    return obj_in
+
+
 def parse_utc_timestamp(datetime_string: str) -> datetime:
     """Parse datetime from string."""
     return datetime.fromisoformat(datetime_string)

{matter_python_client-1.4.0a0.dev20260802 → matter_python_client-1.4.0a0.dev20260806}/pyproject.toml

@@ -25,7 +25,7 @@ license = "Apache-2.0"
 name = "matter-python-client"
 readme = "README.md"
 requires-python = ">=3.12"
-version = "1.4.0a0.dev20260802"
+version = "1.4.0a0.dev20260806"
 
 [project.urls]
 Homepage = "https://github.com/matter-js/matterjs-server"

matter_python_client-1.4.0a0.dev20260806/tests/test_client.py

@@ -0,0 +1,44 @@
+"""Tests for matter_server.client.client.MatterClient."""
+
+from __future__ import annotations
+
+from unittest.mock import AsyncMock, MagicMock
+
+from chip.clusters import Objects as clusters
+from matter_server.client.client import MatterClient
+from matter_server.common.models import APICommand
+
+
+async def test_write_attribute_sends_tag_keyed_value() -> None:
+    """write_attribute must route struct values through dataclass_to_tag_dict.
+
+    send_command must receive TLV-tag keys ("0".."5"), not field names, or the
+    server rejects the write with INVALID_DATA_TYPE.
+    """
+    client = MatterClient(ws_server_url="ws://example.invalid/ws", aiohttp_session=MagicMock())
+    client.send_command = AsyncMock(return_value=None)
+
+    preset = clusters.Thermostat.Structs.PresetStruct(
+        presetHandle=b"\x01",
+        presetScenario=clusters.Thermostat.Enums.PresetScenarioEnum.kOccupied,
+        name=None,
+        coolingSetpoint=2500,
+        heatingSetpoint=2100,
+        builtIn=True,
+    )
+
+    await client.write_attribute(node_id=1, attribute_path="1/513/80", value=preset)
+
+    client.send_command.assert_awaited_once_with(
+        APICommand.WRITE_ATTRIBUTE,
+        require_schema=4,
+        node_id=1,
+        attribute_path="1/513/80",
+        value={
+            "0": b"\x01",
+            "1": clusters.Thermostat.Enums.PresetScenarioEnum.kOccupied,
+            "3": 2500,
+            "4": 2100,
+            "5": True,
+        },
+    )

{matter_python_client-1.4.0a0.dev20260802 → matter_python_client-1.4.0a0.dev20260806}/tests/test_integration.py

@@ -548,6 +548,24 @@ class TestAttributeOperations:
         attrs = await client.read_attribute(env["node_id"], "0/40/5")
         assert attrs["0/40/5"] == "Integration Test Node"
 
+    async def test_32a_write_struct_list_attribute(self, env):
+        """Write UserLabel.LabelList with a real CHIP struct and verify."""
+        from chip.clusters import Objects as Clusters
+
+        _require_state(env, "node_id")
+        client: MatterTestClient = env["client"]
+        result = await client.write_attribute(
+            env["node_id"],
+            "1/65/0",
+            [Clusters.UserLabel.Structs.LabelStruct(label="room", value="den")],
+        )
+        assert isinstance(result, list)
+        assert result[0]["Status"] == 0
+
+        # Read back
+        attrs = await client.read_attribute(env["node_id"], "1/65/0")
+        assert attrs["1/65/0"] == [{"0": "room", "1": "den"}]
+
 
 # ============================================================================
 # Section 6 -- Device Commands

matter_python_client-1.4.0a0.dev20260806/tests/test_util.py

@@ -0,0 +1,132 @@
+"""Tests for matter_server.common.helpers.util."""
+
+from __future__ import annotations
+
+from chip.clusters import Objects as clusters
+from chip.clusters.Types import NullValue
+from chip.tlv import uint
+from matter_server.common.helpers.util import dataclass_to_dict, dataclass_to_tag_dict
+
+
+def test_dataclass_to_tag_dict_uses_tlv_tags() -> None:
+    """dataclass_to_tag_dict must key struct fields by their TLV tag, not field name.
+
+    WRITE_ATTRIBUTE expects the same tag-keyed struct format already used for
+    attribute reports. Sending field-name keys instead (as plain
+    dataclasses.asdict()/dataclass_to_dict() would) causes the receiving
+    matter-server to fail mapping fields like `presetHandle`, leaving binary
+    handle fields as un-decoded base64 strings and the write rejected with
+    INVALID_DATA_TYPE.
+    """
+    preset = clusters.Thermostat.Structs.PresetStruct(
+        presetHandle=b"\x01",
+        presetScenario=clusters.Thermostat.Enums.PresetScenarioEnum.kOccupied,
+        name=None,
+        coolingSetpoint=2500,
+        heatingSetpoint=2100,
+        builtIn=True,
+    )
+
+    result = dataclass_to_tag_dict(preset)
+
+    assert result == {
+        "0": b"\x01",
+        "1": clusters.Thermostat.Enums.PresetScenarioEnum.kOccupied,
+        "3": 2500,
+        "4": 2100,
+        "5": True,
+    }
+    assert "2" not in result  # name=None (absent optional field)
+
+
+def test_dataclass_to_tag_dict_is_recursive_through_lists() -> None:
+    """Nested dataclasses inside lists (e.g. Schedule.transitions) must also convert."""
+    schedule = clusters.Thermostat.Structs.ScheduleStruct(
+        scheduleHandle=NullValue,
+        systemMode=clusters.Thermostat.Enums.SystemModeEnum.kHeat,
+        name="Weekdays",
+        presetHandle=None,
+        transitions=[
+            clusters.Thermostat.Structs.ScheduleTransitionStruct(
+                dayOfWeek=clusters.Thermostat.Bitmaps.ScheduleDayOfWeekBitmap.kMonday,
+                transitionTime=uint(420),
+                heatingSetpoint=2100,
+            )
+        ],
+        builtIn=False,
+    )
+
+    result = dataclass_to_tag_dict(schedule)
+
+    assert result["0"] is NullValue  # scheduleHandle, passed through unchanged
+    assert result["1"] == clusters.Thermostat.Enums.SystemModeEnum.kHeat
+    assert result["2"] == "Weekdays"
+    assert isinstance(result["4"], list)
+    transition = result["4"][0]
+    assert transition == {
+        "0": clusters.Thermostat.Bitmaps.ScheduleDayOfWeekBitmap.kMonday,
+        "1": 420,
+        "5": 2100,
+    }
+    for absent_tag in ("2", "3", "4"):  # presetHandle, systemMode, coolingSetpoint
+        assert absent_tag not in transition
+
+
+def test_dataclass_to_tag_dict_omits_none_but_keeps_nullvalue() -> None:
+    """Absent optional fields (None) are omitted; explicit NullValue fields are kept.
+
+    Partial-struct writes (e.g. a heat-only ScheduleTransitionStruct) must not
+    emit unset fields as JSON null, since matter.js rejects null on optional
+    non-nullable members.
+    """
+    transition = clusters.Thermostat.Structs.ScheduleTransitionStruct(
+        dayOfWeek=clusters.Thermostat.Bitmaps.ScheduleDayOfWeekBitmap.kMonday,
+        transitionTime=uint(420),
+        heatingSetpoint=2100,
+    )
+
+    result = dataclass_to_tag_dict(transition)
+
+    assert result == {
+        "0": clusters.Thermostat.Bitmaps.ScheduleDayOfWeekBitmap.kMonday,
+        "1": 420,
+        "5": 2100,
+    }
+
+    preset = clusters.Thermostat.Structs.PresetStruct(
+        presetHandle=b"\x01",
+        presetScenario=clusters.Thermostat.Enums.PresetScenarioEnum.kOccupied,
+        name=NullValue,
+        coolingSetpoint=None,
+        heatingSetpoint=2100,
+        builtIn=True,
+    )
+
+    preset_result = dataclass_to_tag_dict(preset)
+
+    assert preset_result["2"] is NullValue  # name explicitly nulled
+    assert "3" not in preset_result  # coolingSetpoint absent
+
+
+def test_dataclass_to_tag_dict_passes_through_scalars() -> None:
+    """Non-dataclass values (the common case for simple attributes) are untouched."""
+    assert dataclass_to_tag_dict(2000) == 2000
+    assert dataclass_to_tag_dict("Integration Test Node") == "Integration Test Node"
+    assert dataclass_to_tag_dict(None) is None
+
+
+def test_dataclass_to_dict_still_uses_field_names() -> None:
+    """dataclass_to_dict (used for DEVICE_COMMAND payloads) is unaffected by this change."""
+    preset = clusters.Thermostat.Structs.PresetStruct(
+        presetHandle=b"\x01",
+        presetScenario=clusters.Thermostat.Enums.PresetScenarioEnum.kOccupied,
+        name=None,
+        coolingSetpoint=2500,
+        heatingSetpoint=2100,
+        builtIn=True,
+    )
+
+    result = dataclass_to_dict(preset)
+
+    assert result["presetHandle"] == b"\x01"
+    assert result["presetScenario"] == clusters.Thermostat.Enums.PresetScenarioEnum.kOccupied