matter-python-client 1.5.0a0.dev202610200302__tar.gz → 1.5.1__tar.gz

{matter_python_client-1.5.0a0.dev202610200302 → matter_python_client-1.5.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: matter-python-client
-Version: 1.5.0a0.dev202610200302
+Version: 1.5.1
 Summary: Python Client for the OHF Matter Server
 Author-email: Open Home Foundation <hello@openhomefoundation.io>
 License-Expression: Apache-2.0
@@ -141,9 +141,19 @@ Beyond the `python-matter-server` API, the client exposes commands the Matter.js
   play your audio; without it the server makes the offer's audio sections not send, so a browser-style
   `sendrecv` audio offer goes to the camera as `recvonly`. `camera_session_ended` and
   `camera_stream_evicted` events arrive as `CameraSessionEndedData` / `CameraStreamEvictedData`;
-  `webrtc_callback` stays a dict. Errors 102 to 106 (`CameraStreamIncompatible`, ...) expose their
+  `webrtc_callback` stays a dict. `camera_session_ended` covers every end of a session opened with
+  `camera_start_stream` that the client did not ask for, the camera's own `End` included; its `cause` says why. Errors 102 to 106 (`CameraStreamIncompatible`, ...) expose their
   details as attributes, e.g. `err.reason` and `err.bound` on `CameraStreamIncompatible`
 
+  `camera_start_stream(..., client_session_key="...")` names the session with your own key (1 to 128
+  characters, unique among the connection's starting and open sessions). Every `webrtc_callback` and
+  `camera_session_ended` event of the session carries it as `client_session_key`, so a handler can
+  match events even when it runs before the awaited call returns. `camera_provide_ice_candidates(node_id,
+  endpoint_id, None, candidates, client_session_key=...)` and `camera_stop_stream(node_id, endpoint_id,
+  client_session_key=...)` take it in place of the session id, also while `camera_start_stream` is still
+  running: candidates are queued on the server and sent after the start's response, and the stop cancels
+  the start.
+
   The minimal `camera_start_stream` call is `node_id`, `endpoint_id`, `stream_usage` and your SDP
   offer: the server reuses or allocates the best stream the camera can serve that still fits what
   the offer can decode, and adds audio when it can. Pass `video` / `audio` hints only to set hard bounds. A

{matter_python_client-1.5.0a0.dev202610200302 → matter_python_client-1.5.1}/README.md

@@ -109,9 +109,19 @@ Beyond the `python-matter-server` API, the client exposes commands the Matter.js
   play your audio; without it the server makes the offer's audio sections not send, so a browser-style
   `sendrecv` audio offer goes to the camera as `recvonly`. `camera_session_ended` and
   `camera_stream_evicted` events arrive as `CameraSessionEndedData` / `CameraStreamEvictedData`;
-  `webrtc_callback` stays a dict. Errors 102 to 106 (`CameraStreamIncompatible`, ...) expose their
+  `webrtc_callback` stays a dict. `camera_session_ended` covers every end of a session opened with
+  `camera_start_stream` that the client did not ask for, the camera's own `End` included; its `cause` says why. Errors 102 to 106 (`CameraStreamIncompatible`, ...) expose their
   details as attributes, e.g. `err.reason` and `err.bound` on `CameraStreamIncompatible`
 
+  `camera_start_stream(..., client_session_key="...")` names the session with your own key (1 to 128
+  characters, unique among the connection's starting and open sessions). Every `webrtc_callback` and
+  `camera_session_ended` event of the session carries it as `client_session_key`, so a handler can
+  match events even when it runs before the awaited call returns. `camera_provide_ice_candidates(node_id,
+  endpoint_id, None, candidates, client_session_key=...)` and `camera_stop_stream(node_id, endpoint_id,
+  client_session_key=...)` take it in place of the session id, also while `camera_start_stream` is still
+  running: candidates are queued on the server and sent after the start's response, and the stop cancels
+  the start.
+
   The minimal `camera_start_stream` call is `node_id`, `endpoint_id`, `stream_usage` and your SDP
   offer: the server reuses or allocates the best stream the camera can serve that still fits what
   the offer can decode, and adds audio when it can. Pass `video` / `audio` hints only to set hard bounds. A

{matter_python_client-1.5.0a0.dev202610200302 → matter_python_client-1.5.1}/chip/clusters/Objects.py

@@ -43,6 +43,7 @@ __all__ = [
     "ApplicationBasic",
     "ApplicationLauncher",
     "AqaraAmbientSensingConfigurationCluster",
+    "AqaraLedStripT2Cluster",
     "AqaraOccupantLocationCluster",
     "AqaraRadarSensingUnionCluster",
     "AudioOutput",

matter_python_client-1.5.1/chip/clusters/cluster_defs/AqaraLedStripT2Cluster.py

@@ -0,0 +1,171 @@
+"""AqaraLedStripT2Cluster cluster definition (auto-generated, DO NOT edit)."""
+
+from __future__ import annotations
+
+import typing
+from dataclasses import dataclass, field
+from enum import IntFlag
+
+from ... import ChipUtility
+from ...clusters.enum import MatterIntEnum
+from ...tlv import float32, uint
+from ..ClusterObjects import (Cluster, ClusterAttributeDescriptor, ClusterCommand, ClusterEvent, ClusterObject,
+                              ClusterObjectDescriptor, ClusterObjectFieldDescriptor)
+from ..Types import Nullable, NullValue
+
+
+@dataclass
+class AqaraLedStripT2Cluster(Cluster):
+    id: typing.ClassVar[int] = 0x115FFC0F
+
+    @ChipUtility.classproperty
+    def descriptor(cls) -> ClusterObjectDescriptor:
+        return ClusterObjectDescriptor(
+            Fields=[
+                ClusterObjectFieldDescriptor(Label="musicSyncEnabled", Tag=0x00000013, Type=typing.Optional[bool]),
+                ClusterObjectFieldDescriptor(Label="musicSyncEffect", Tag=0x00000015, Type=typing.Optional[uint]),
+                ClusterObjectFieldDescriptor(Label="musicSyncSensitivity", Tag=0x00000016, Type=typing.Optional[uint]),
+                ClusterObjectFieldDescriptor(Label="generatedCommandList", Tag=0x0000FFF8, Type=typing.List[uint]),
+                ClusterObjectFieldDescriptor(Label="acceptedCommandList", Tag=0x0000FFF9, Type=typing.List[uint]),
+                ClusterObjectFieldDescriptor(Label="attributeList", Tag=0x0000FFFB, Type=typing.List[uint]),
+                ClusterObjectFieldDescriptor(Label="featureMap", Tag=0x0000FFFC, Type=uint),
+                ClusterObjectFieldDescriptor(Label="clusterRevision", Tag=0x0000FFFD, Type=uint),
+            ])
+
+    musicSyncEnabled: typing.Optional[bool] = None
+    musicSyncEffect: typing.Optional[uint] = None
+    musicSyncSensitivity: typing.Optional[uint] = None
+    generatedCommandList: typing.List[uint] = field(default_factory=lambda: [])
+    acceptedCommandList: typing.List[uint] = field(default_factory=lambda: [])
+    attributeList: typing.List[uint] = field(default_factory=lambda: [])
+    featureMap: uint = 0
+    clusterRevision: uint = 0
+
+    class Attributes:
+        @dataclass
+        class MusicSyncEnabled(ClusterAttributeDescriptor):
+            @ChipUtility.classproperty
+            def cluster_id(cls) -> int:
+                return 0x115FFC0F
+
+            @ChipUtility.classproperty
+            def attribute_id(cls) -> int:
+                return 0x00000013
+
+            @ChipUtility.classproperty
+            def attribute_type(cls) -> ClusterObjectFieldDescriptor:
+                return ClusterObjectFieldDescriptor(Type=typing.Optional[bool])
+
+            value: typing.Optional[bool] = None
+
+        @dataclass
+        class MusicSyncEffect(ClusterAttributeDescriptor):
+            @ChipUtility.classproperty
+            def cluster_id(cls) -> int:
+                return 0x115FFC0F
+
+            @ChipUtility.classproperty
+            def attribute_id(cls) -> int:
+                return 0x00000015
+
+            @ChipUtility.classproperty
+            def attribute_type(cls) -> ClusterObjectFieldDescriptor:
+                return ClusterObjectFieldDescriptor(Type=typing.Optional[uint])
+
+            value: typing.Optional[uint] = None
+
+        @dataclass
+        class MusicSyncSensitivity(ClusterAttributeDescriptor):
+            @ChipUtility.classproperty
+            def cluster_id(cls) -> int:
+                return 0x115FFC0F
+
+            @ChipUtility.classproperty
+            def attribute_id(cls) -> int:
+                return 0x00000016
+
+            @ChipUtility.classproperty
+            def attribute_type(cls) -> ClusterObjectFieldDescriptor:
+                return ClusterObjectFieldDescriptor(Type=typing.Optional[uint])
+
+            value: typing.Optional[uint] = None
+
+        @dataclass
+        class GeneratedCommandList(ClusterAttributeDescriptor):
+            @ChipUtility.classproperty
+            def cluster_id(cls) -> int:
+                return 0x115FFC0F
+
+            @ChipUtility.classproperty
+            def attribute_id(cls) -> int:
+                return 0x0000FFF8
+
+            @ChipUtility.classproperty
+            def attribute_type(cls) -> ClusterObjectFieldDescriptor:
+                return ClusterObjectFieldDescriptor(Type=typing.List[uint])
+
+            value: typing.List[uint] = field(default_factory=lambda: [])
+
+        @dataclass
+        class AcceptedCommandList(ClusterAttributeDescriptor):
+            @ChipUtility.classproperty
+            def cluster_id(cls) -> int:
+                return 0x115FFC0F
+
+            @ChipUtility.classproperty
+            def attribute_id(cls) -> int:
+                return 0x0000FFF9
+
+            @ChipUtility.classproperty
+            def attribute_type(cls) -> ClusterObjectFieldDescriptor:
+                return ClusterObjectFieldDescriptor(Type=typing.List[uint])
+
+            value: typing.List[uint] = field(default_factory=lambda: [])
+
+        @dataclass
+        class AttributeList(ClusterAttributeDescriptor):
+            @ChipUtility.classproperty
+            def cluster_id(cls) -> int:
+                return 0x115FFC0F
+
+            @ChipUtility.classproperty
+            def attribute_id(cls) -> int:
+                return 0x0000FFFB
+
+            @ChipUtility.classproperty
+            def attribute_type(cls) -> ClusterObjectFieldDescriptor:
+                return ClusterObjectFieldDescriptor(Type=typing.List[uint])
+
+            value: typing.List[uint] = field(default_factory=lambda: [])
+
+        @dataclass
+        class FeatureMap(ClusterAttributeDescriptor):
+            @ChipUtility.classproperty
+            def cluster_id(cls) -> int:
+                return 0x115FFC0F
+
+            @ChipUtility.classproperty
+            def attribute_id(cls) -> int:
+                return 0x0000FFFC
+
+            @ChipUtility.classproperty
+            def attribute_type(cls) -> ClusterObjectFieldDescriptor:
+                return ClusterObjectFieldDescriptor(Type=uint)
+
+            value: uint = 0
+
+        @dataclass
+        class ClusterRevision(ClusterAttributeDescriptor):
+            @ChipUtility.classproperty
+            def cluster_id(cls) -> int:
+                return 0x115FFC0F
+
+            @ChipUtility.classproperty
+            def attribute_id(cls) -> int:
+                return 0x0000FFFD
+
+            @ChipUtility.classproperty
+            def attribute_type(cls) -> ClusterObjectFieldDescriptor:
+                return ClusterObjectFieldDescriptor(Type=uint)
+
+            value: uint = 0

{matter_python_client-1.5.0a0.dev202610200302 → matter_python_client-1.5.1}/chip/clusters/cluster_defs/__init__.py

@@ -11,6 +11,7 @@ from .AmbientContextSensing import AmbientContextSensing
 from .ApplicationBasic import ApplicationBasic
 from .ApplicationLauncher import ApplicationLauncher
 from .AqaraAmbientSensingConfigurationCluster import AqaraAmbientSensingConfigurationCluster
+from .AqaraLedStripT2Cluster import AqaraLedStripT2Cluster
 from .AqaraOccupantLocationCluster import AqaraOccupantLocationCluster
 from .AqaraRadarSensingUnionCluster import AqaraRadarSensingUnionCluster
 from .AudioOutput import AudioOutput
@@ -163,6 +164,7 @@ __all__ = [
     "ApplicationBasic",
     "ApplicationLauncher",
     "AqaraAmbientSensingConfigurationCluster",
+    "AqaraLedStripT2Cluster",
     "AqaraOccupantLocationCluster",
     "AqaraRadarSensingUnionCluster",
     "AudioOutput",

{matter_python_client-1.5.0a0.dev202610200302 → matter_python_client-1.5.1}/matter_python_client.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: matter-python-client
-Version: 1.5.0a0.dev202610200302
+Version: 1.5.1
 Summary: Python Client for the OHF Matter Server
 Author-email: Open Home Foundation <hello@openhomefoundation.io>
 License-Expression: Apache-2.0
@@ -141,9 +141,19 @@ Beyond the `python-matter-server` API, the client exposes commands the Matter.js
   play your audio; without it the server makes the offer's audio sections not send, so a browser-style
   `sendrecv` audio offer goes to the camera as `recvonly`. `camera_session_ended` and
   `camera_stream_evicted` events arrive as `CameraSessionEndedData` / `CameraStreamEvictedData`;
-  `webrtc_callback` stays a dict. Errors 102 to 106 (`CameraStreamIncompatible`, ...) expose their
+  `webrtc_callback` stays a dict. `camera_session_ended` covers every end of a session opened with
+  `camera_start_stream` that the client did not ask for, the camera's own `End` included; its `cause` says why. Errors 102 to 106 (`CameraStreamIncompatible`, ...) expose their
   details as attributes, e.g. `err.reason` and `err.bound` on `CameraStreamIncompatible`
 
+  `camera_start_stream(..., client_session_key="...")` names the session with your own key (1 to 128
+  characters, unique among the connection's starting and open sessions). Every `webrtc_callback` and
+  `camera_session_ended` event of the session carries it as `client_session_key`, so a handler can
+  match events even when it runs before the awaited call returns. `camera_provide_ice_candidates(node_id,
+  endpoint_id, None, candidates, client_session_key=...)` and `camera_stop_stream(node_id, endpoint_id,
+  client_session_key=...)` take it in place of the session id, also while `camera_start_stream` is still
+  running: candidates are queued on the server and sent after the start's response, and the stop cancels
+  the start.
+
   The minimal `camera_start_stream` call is `node_id`, `endpoint_id`, `stream_usage` and your SDP
   offer: the server reuses or allocates the best stream the camera can serve that still fits what
   the offer can decode, and adds audio when it can. Pass `video` / `audio` hints only to set hard bounds. A

{matter_python_client-1.5.0a0.dev202610200302 → matter_python_client-1.5.1}/matter_python_client.egg-info/SOURCES.txt

@@ -17,6 +17,7 @@ chip/clusters/cluster_defs/AmbientContextSensing.py
 chip/clusters/cluster_defs/ApplicationBasic.py
 chip/clusters/cluster_defs/ApplicationLauncher.py
 chip/clusters/cluster_defs/AqaraAmbientSensingConfigurationCluster.py
+chip/clusters/cluster_defs/AqaraLedStripT2Cluster.py
 chip/clusters/cluster_defs/AqaraOccupantLocationCluster.py
 chip/clusters/cluster_defs/AqaraRadarSensingUnionCluster.py
 chip/clusters/cluster_defs/AudioOutput.py

{matter_python_client-1.5.0a0.dev202610200302 → matter_python_client-1.5.1}/matter_server/client/client.py

@@ -31,6 +31,7 @@ from matter_server.common.models import (
     CameraCapabilities,
     CameraIceServer,
     CameraResolutionHint,
+    CameraResolutionTarget,
     CameraSessionEndedData,
     CameraSnapshotResult,
     CameraStartStreamResult,
@@ -116,6 +117,16 @@ NODE_SCOPED_CAMERA_EVENTS: Final = frozenset(
 # pylint: disable=too-many-public-methods,too-many-locals,too-many-branches
 
 
+def _session_reference(webrtc_session_id: int | None, client_session_key: str | None) -> dict[str, Any]:
+    """Return the arguments naming a session; the server refuses both or neither with error 8."""
+    reference: dict[str, Any] = {}
+    if webrtc_session_id is not None:
+        reference["webrtc_session_id"] = webrtc_session_id
+    if client_session_key is not None:
+        reference["client_session_key"] = client_session_key
+    return reference
+
+
 def _command_name(command: ClusterCommand) -> str:
     """Return the wire name of a command: the name of its class."""
     return type(command).__name__
@@ -599,10 +610,20 @@ class MatterClient:
                     node_type = NodeType.END_DEVICE
         elif network_type == NetworkType.WIFI:
             node_type = NodeType.END_DEVICE
+        # NetworkID is an SSID only on a Wi-Fi instance; Thread uses the binary Extended PAN ID
+        network_commissioning_features = node.get_attribute_value(
+            0,
+            cluster=None,
+            attribute=Clusters.NetworkCommissioning.Attributes.FeatureMap,
+        )
+        network_id_is_ssid = network_type in (NetworkType.WIFI, NetworkType.UNKNOWN) and bool(
+            (network_commissioning_features or 0)
+            & Clusters.NetworkCommissioning.Bitmaps.Feature.kWiFiNetworkInterface
+        )
         # use lastNetworkID from NetworkCommissioning cluster as fallback to get the network name
         # this allows getting the SSID as the wifi diagnostics cluster only has the BSSID
         last_network_id: bytes | str | None
-        if not network_name and (
+        if network_id_is_ssid and not network_name and (
             last_network_id := node.get_attribute_value(
                 0,
                 cluster=None,
@@ -616,7 +637,7 @@ class MatterClient:
         # last resort to get the (wifi) networkname;
         # enumerate networks on the NetworkCommissioning cluster
         networks: list[Clusters.NetworkCommissioning.Structs.NetworkInfoStruct]
-        if not network_name and (
+        if network_id_is_ssid and not network_name and (
             networks := node.get_attribute_value(
                 0,
                 cluster=None,
@@ -1058,6 +1079,7 @@ class MatterClient:
         metadata_enabled: bool | None = None,
         allow_eviction: bool | None = None,
         talkback: bool | None = None,
+        client_session_key: str | None = None,
     ) -> CameraStartStreamResult:
         """Open a WebRTC session, allocating or reusing the streams it needs.
 
@@ -1065,9 +1087,15 @@ class MatterClient:
         offer arrives as a ``webrtc_callback`` ``offer`` event. For ``video`` and ``audio``, ``None``
         lets the server decide, a hints dict sets hard requirements, and ``False`` leaves the track
         out. ``talkback=True`` (requires ``sdp``) forwards the offer unchanged so the camera can play
-        the caller's audio; otherwise the server makes the offer's audio sections not send. That only
-        asks the camera: it may still answer ``sendrecv``, so a caller that must not send audio keeps
-        the track off its audio sender. Arguments left ``None`` are not sent.
+        the caller's audio; otherwise the server makes the offer's audio sections not send. A camera
+        that answers ``sendrecv`` anyway gets its answer narrowed by the server to the directions the
+        offer allows. Arguments left ``None`` are not sent.
+
+        ``client_session_key`` (1 to 128 characters, unique among this connection's starting and open
+        sessions) is the caller's own name for the session. Every ``webrtc_callback`` and
+        ``camera_session_ended`` event of the session carries it, so a handler can match events
+        before this call returns. ``camera_provide_ice_candidates`` and ``camera_stop_stream`` accept
+        it in place of the session id, also while this call is still running.
 
         Requires schema 14.
         """
@@ -1080,6 +1108,7 @@ class MatterClient:
             "metadata_enabled": metadata_enabled,
             "allow_eviction": allow_eviction,
             "talkback": talkback,
+            "client_session_key": client_session_key,
         }
         data = await self.send_command(
             APICommand.CAMERA_START_STREAM,
@@ -1109,12 +1138,18 @@ class MatterClient:
         self,
         node_id: int,
         endpoint_id: int,
-        webrtc_session_id: int,
+        webrtc_session_id: int | None,
         ice_candidates: Sequence[WebRTCIceCandidate | dict[str, Any]],
+        *,
+        client_session_key: str | None = None,
     ) -> None:
-        """Send one or more ICE candidates to an existing session.
+        """Send one or more ICE candidates to a session.
 
-        A candidate from a ``webrtc_callback`` ``ice_candidates`` event can be passed unchanged.
+        Name the session by ``webrtc_session_id`` or by ``client_session_key`` (pass ``None`` for the
+        id then), not both. With the key of a session whose ``camera_start_stream`` is still running,
+        the server queues the candidates and this call returns once they were sent, after that
+        response. A candidate from a ``webrtc_callback`` ``ice_candidates`` event can be passed
+        unchanged.
 
         Requires schema 14.
         """
@@ -1123,7 +1158,7 @@ class MatterClient:
             require_schema=14,
             node_id=node_id,
             endpoint_id=endpoint_id,
-            webrtc_session_id=webrtc_session_id,
+            **_session_reference(webrtc_session_id, client_session_key),
             ice_candidates=[
                 asdict(candidate) if isinstance(candidate, WebRTCIceCandidate) else candidate
                 for candidate in ice_candidates
@@ -1131,10 +1166,19 @@ class MatterClient:
         )
 
     async def camera_stop_stream(
-        self, node_id: int, endpoint_id: int, webrtc_session_id: int
+        self,
+        node_id: int,
+        endpoint_id: int,
+        webrtc_session_id: int | None = None,
+        *,
+        client_session_key: str | None = None,
     ) -> CameraStopStreamResult:
         """End a WebRTC session; the stream allocation is kept.
 
+        Name the session by ``webrtc_session_id`` or by ``client_session_key``, not both. The key of a
+        session whose ``camera_start_stream`` is still running cancels that start; ``ended`` then says
+        whether the camera had opened a session that the server ended.
+
         Requires schema 14.
         """
         data = await self.send_command(
@@ -1142,7 +1186,7 @@ class MatterClient:
             require_schema=14,
             node_id=node_id,
             endpoint_id=endpoint_id,
-            webrtc_session_id=webrtc_session_id,
+            **_session_reference(webrtc_session_id, client_session_key),
         )
         return dataclass_from_dict(CameraStopStreamResult, data)
 
@@ -1154,15 +1198,22 @@ class MatterClient:
         codec: str | None = None,
         watermark_enabled: bool | None = None,
         osd_enabled: bool | None = None,
+        resolution: CameraResolutionTarget | None = None,
     ) -> CameraSnapshotResult:
         """Capture one image. An argument left ``None`` is not sent.
 
+        ``resolution`` is the size you want, such as a thumbnail's: ``{"width": 320}``,
+        ``{"height": 240}`` or both. The server uses the smallest capability that reaches it
+        (within ``max_resolution``) and asks the camera to scale to it. The camera may return
+        a larger frame, so check the result's ``resolution``.
+
         The snapshot stream stays allocated; free it with ``camera_release_stream``.
 
         Requires schema 14.
         """
         optional = {
             "max_resolution": max_resolution,
+            "resolution": resolution,
             "codec": codec,
             "watermark_enabled": watermark_enabled,
             "osd_enabled": osd_enabled,

{matter_python_client-1.5.0a0.dev202610200302 → matter_python_client-1.5.1}/matter_server/common/custom_clusters.py

@@ -1,6 +1,7 @@
 """Custom (vendor-specific) cluster re-exports (auto-generated, DO NOT edit)."""
 
 from chip.clusters.cluster_defs.AqaraAmbientSensingConfigurationCluster import AqaraAmbientSensingConfigurationCluster
+from chip.clusters.cluster_defs.AqaraLedStripT2Cluster import AqaraLedStripT2Cluster
 from chip.clusters.cluster_defs.AqaraOccupantLocationCluster import AqaraOccupantLocationCluster
 from chip.clusters.cluster_defs.AqaraRadarSensingUnionCluster import AqaraRadarSensingUnionCluster
 from chip.clusters.cluster_defs.DraftElectricalMeasurementCluster import DraftElectricalMeasurementCluster
@@ -16,6 +17,7 @@ from chip.clusters.cluster_defs.WagoCluster import WagoCluster
 
 ALL_CUSTOM_CLUSTERS: dict = {
     AqaraAmbientSensingConfigurationCluster.id: AqaraAmbientSensingConfigurationCluster,
+    AqaraLedStripT2Cluster.id: AqaraLedStripT2Cluster,
     AqaraOccupantLocationCluster.id: AqaraOccupantLocationCluster,
     AqaraRadarSensingUnionCluster.id: AqaraRadarSensingUnionCluster,
     DraftElectricalMeasurementCluster.id: DraftElectricalMeasurementCluster,
@@ -33,6 +35,7 @@ ALL_CUSTOM_CLUSTERS: dict = {
 __all__ = [
     "ALL_CUSTOM_CLUSTERS",
     "AqaraAmbientSensingConfigurationCluster",
+    "AqaraLedStripT2Cluster",
     "AqaraOccupantLocationCluster",
     "AqaraRadarSensingUnionCluster",
     "DraftElectricalMeasurementCluster",

{matter_python_client-1.5.0a0.dev202610200302 → matter_python_client-1.5.1}/matter_server/common/models.py

@@ -163,6 +163,7 @@ class WebRTCCallbackData:
       - "answer": {"sdp": str}
       - "ice_candidates": {"ice_candidates": list[WebRTCIceCandidate]}
       - "end": {"reason": int}
+    `client_session_key` is the key the session was started with, absent when it had none.
     """
 
     event_type: str
@@ -171,6 +172,7 @@ class WebRTCCallbackData:
     endpoint_id: int
     fabric_index: int
     data: dict | None
+    client_session_key: str | None = None
 
 
 @dataclass
@@ -458,6 +460,13 @@ class CameraResolutionHint(TypedDict):
     height: int
 
 
+class CameraResolutionTarget(TypedDict, total=False):
+    """The size `camera_snapshot` should aim for. State `width`, `height` or both; at least one."""
+
+    width: int
+    height: int
+
+
 class CameraVideoHints(TypedDict, total=False):
     """Video hints for `camera_start_stream`; every key set is a hard requirement."""
 
@@ -775,11 +784,19 @@ class CameraSnapshotResult:
 
 @dataclass
 class CameraSessionEndedData:
-    """Payload of the `camera_session_ended` event."""
+    """Payload of the `camera_session_ended` event.
+
+    `cause` is `peer`, `other_connection`, `camera_restarted`, `camera_dropped` or `node_removed`.
+    `reason` is the camera's WebRTCEndReasonEnum value, sent with `cause` `peer` when the camera stated one.
+    `client_session_key` is the key the session was started with, absent when it had none.
+    """
 
     node_id: int
     endpoint_id: int
     webrtc_session_id: int
+    cause: str
+    reason: int | None = None
+    client_session_key: str | None = None
 
 
 @dataclass

{matter_python_client-1.5.0a0.dev202610200302 → matter_python_client-1.5.1}/pyproject.toml

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

{matter_python_client-1.5.0a0.dev202610200302 → matter_python_client-1.5.1}/tests/test_camera.py

@@ -393,6 +393,23 @@ async def test_snapshot_sends_stated_arguments_and_parses_the_result() -> None:
     )
 
 
+async def test_snapshot_sends_a_width_only_resolution_target() -> None:
+    client = _bare_client(
+        {
+            "data": "",
+            "codec": "JPEG",
+            "resolution": _RESOLUTION,
+            "degraded": False,
+            "stream_id": 4,
+            "provenance": "allocated",
+        }
+    )
+    await client.camera_snapshot(5, 1, resolution={"width": 320})
+    _, kwargs = _sent(client)
+    assert kwargs["resolution"] == {"width": 320}
+    assert "max_resolution" not in kwargs
+
+
 async def test_snapshot_sends_overlay_flags_including_false() -> None:
     client = _bare_client(
         {
@@ -419,6 +436,35 @@ async def test_stop_stream_parses_ended() -> None:
     assert kwargs["webrtc_session_id"] == 9
 
 
+async def test_stop_stream_by_key_sends_the_key_and_no_id() -> None:
+    client = _bare_client({"ended": True})
+    assert await client.camera_stop_stream(5, 1, client_session_key="k1") == CameraStopStreamResult(ended=True)
+    _, kwargs = _sent(client)
+    assert kwargs["client_session_key"] == "k1"
+    assert "webrtc_session_id" not in kwargs
+
+
+async def test_provide_ice_candidates_by_key_sends_the_key_and_no_id() -> None:
+    client = _bare_client()
+    await client.camera_provide_ice_candidates(5, 1, None, [{"candidate": "c"}], client_session_key="k1")
+    _, kwargs = _sent(client)
+    assert kwargs["client_session_key"] == "k1"
+    assert "webrtc_session_id" not in kwargs
+    assert kwargs["ice_candidates"] == [{"candidate": "c"}]
+
+
+async def test_start_stream_sends_the_key_only_when_given() -> None:
+    client = _bare_client(
+        {"webrtc_session_id": 9, "mode": "provide_offer", "video": None, "audio": None, "talkback": False}
+    )
+    await client.camera_start_stream(5, 1, "LiveView", client_session_key="k1")
+    _, kwargs = _sent(client)
+    assert kwargs["client_session_key"] == "k1"
+    await client.camera_start_stream(5, 1, "LiveView")
+    _, kwargs = _sent(client)
+    assert "client_session_key" not in kwargs
+
+
 async def test_provide_answer_sends_session_and_sdp() -> None:
     client = _bare_client()
     await client.camera_provide_answer(5, 1, 9, "v=0")