matter-python-client 1.5.0a0.dev20261009__tar.gz → 1.5.0a0.dev20261014__tar.gz

{matter_python_client-1.5.0a0.dev20261009 → matter_python_client-1.5.0a0.dev20261014}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: matter-python-client
-Version: 1.5.0a0.dev20261009
+Version: 1.5.0a0.dev20261014
 Summary: Python Client for the OHF Matter Server
 Author-email: Open Home Foundation <hello@openhomefoundation.io>
 License-Expression: Apache-2.0
@@ -110,6 +110,37 @@ Beyond the `python-matter-server` API, the client exposes commands the Matter.js
   then streams the bytes to `POST /ota-upload/<upload_id>`. Raises `OtaUploadError` (code 101) for a
   corrupt image, an expired/spent id, or disabled OTA support.
 - `get_icd_state`, `register_icd`, `unregister_icd`, `resync_icd` — ICD Check-In registration
+- `camera_get_capabilities`, `camera_start_stream`, `camera_provide_answer`,
+  `camera_provide_ice_candidates`, `camera_stop_stream`, `camera_snapshot`, `camera_release_stream`
+  — the camera API (schema 14+). `camera_get_capabilities`, `camera_start_stream`, `camera_stop_stream`
+  and `camera_snapshot` return dataclasses from `matter_server.common.models`; the other three return
+  `None`.
+  `camera_start_stream`'s `video` / `audio` take `None` (the server decides), a `CameraVideoHints` /
+  `CameraAudioHints` dict, or `False` (no such track). `talkback=True` lets the offer ask the camera to
+  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
+  details as attributes, e.g. `err.reason` and `err.bound` on `CameraStreamIncompatible`
+
+  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
+  session opened this way is driven with `camera_provide_answer`, `camera_provide_ice_candidates`
+  and `camera_stop_stream` only, not with `send_webrtc_provider_command` or a `send_device_command`
+  `EndSession`: the server tracks the session and its streams, and only the `camera_*` methods keep
+  that record correct. The exception is a re-offer (ICE restart), which goes through
+  `send_webrtc_provider_command`. See `docs/websockets_api.md` for the flow and every option.
+
+```python
+    try:
+        result = await client.camera_start_stream(node_id, 1, "LiveView", sdp=offer)
+    except CameraStreamIncompatible as err:
+        print(err.reason, err.bound)
+    else:
+        # The camera's answer arrives as a webrtc_callback "answer" event for this session.
+        print(result.webrtc_session_id, result.video.codec if result.video else None)
+```
 
 ```python
     version = await client.upload_ota_file("/path/to/firmware.ota")

{matter_python_client-1.5.0a0.dev20261009 → matter_python_client-1.5.0a0.dev20261014}/README.md

@@ -78,6 +78,37 @@ Beyond the `python-matter-server` API, the client exposes commands the Matter.js
   then streams the bytes to `POST /ota-upload/<upload_id>`. Raises `OtaUploadError` (code 101) for a
   corrupt image, an expired/spent id, or disabled OTA support.
 - `get_icd_state`, `register_icd`, `unregister_icd`, `resync_icd` — ICD Check-In registration
+- `camera_get_capabilities`, `camera_start_stream`, `camera_provide_answer`,
+  `camera_provide_ice_candidates`, `camera_stop_stream`, `camera_snapshot`, `camera_release_stream`
+  — the camera API (schema 14+). `camera_get_capabilities`, `camera_start_stream`, `camera_stop_stream`
+  and `camera_snapshot` return dataclasses from `matter_server.common.models`; the other three return
+  `None`.
+  `camera_start_stream`'s `video` / `audio` take `None` (the server decides), a `CameraVideoHints` /
+  `CameraAudioHints` dict, or `False` (no such track). `talkback=True` lets the offer ask the camera to
+  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
+  details as attributes, e.g. `err.reason` and `err.bound` on `CameraStreamIncompatible`
+
+  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
+  session opened this way is driven with `camera_provide_answer`, `camera_provide_ice_candidates`
+  and `camera_stop_stream` only, not with `send_webrtc_provider_command` or a `send_device_command`
+  `EndSession`: the server tracks the session and its streams, and only the `camera_*` methods keep
+  that record correct. The exception is a re-offer (ICE restart), which goes through
+  `send_webrtc_provider_command`. See `docs/websockets_api.md` for the flow and every option.
+
+```python
+    try:
+        result = await client.camera_start_stream(node_id, 1, "LiveView", sdp=offer)
+    except CameraStreamIncompatible as err:
+        print(err.reason, err.bound)
+    else:
+        # The camera's answer arrives as a webrtc_callback "answer" event for this session.
+        print(result.webrtc_session_id, result.video.codec if result.video else None)
+```
 
 ```python
     version = await client.upload_ota_file("/path/to/firmware.ota")

{matter_python_client-1.5.0a0.dev20261009 → matter_python_client-1.5.0a0.dev20261014}/matter_python_client.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: matter-python-client
-Version: 1.5.0a0.dev20261009
+Version: 1.5.0a0.dev20261014
 Summary: Python Client for the OHF Matter Server
 Author-email: Open Home Foundation <hello@openhomefoundation.io>
 License-Expression: Apache-2.0
@@ -110,6 +110,37 @@ Beyond the `python-matter-server` API, the client exposes commands the Matter.js
   then streams the bytes to `POST /ota-upload/<upload_id>`. Raises `OtaUploadError` (code 101) for a
   corrupt image, an expired/spent id, or disabled OTA support.
 - `get_icd_state`, `register_icd`, `unregister_icd`, `resync_icd` — ICD Check-In registration
+- `camera_get_capabilities`, `camera_start_stream`, `camera_provide_answer`,
+  `camera_provide_ice_candidates`, `camera_stop_stream`, `camera_snapshot`, `camera_release_stream`
+  — the camera API (schema 14+). `camera_get_capabilities`, `camera_start_stream`, `camera_stop_stream`
+  and `camera_snapshot` return dataclasses from `matter_server.common.models`; the other three return
+  `None`.
+  `camera_start_stream`'s `video` / `audio` take `None` (the server decides), a `CameraVideoHints` /
+  `CameraAudioHints` dict, or `False` (no such track). `talkback=True` lets the offer ask the camera to
+  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
+  details as attributes, e.g. `err.reason` and `err.bound` on `CameraStreamIncompatible`
+
+  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
+  session opened this way is driven with `camera_provide_answer`, `camera_provide_ice_candidates`
+  and `camera_stop_stream` only, not with `send_webrtc_provider_command` or a `send_device_command`
+  `EndSession`: the server tracks the session and its streams, and only the `camera_*` methods keep
+  that record correct. The exception is a re-offer (ICE restart), which goes through
+  `send_webrtc_provider_command`. See `docs/websockets_api.md` for the flow and every option.
+
+```python
+    try:
+        result = await client.camera_start_stream(node_id, 1, "LiveView", sdp=offer)
+    except CameraStreamIncompatible as err:
+        print(err.reason, err.bound)
+    else:
+        # The camera's answer arrives as a webrtc_callback "answer" event for this session.
+        print(result.webrtc_session_id, result.video.codec if result.video else None)
+```
 
 ```python
     version = await client.upload_ota_file("/path/to/firmware.ota")

{matter_python_client-1.5.0a0.dev20261009 → matter_python_client-1.5.0a0.dev20261014}/matter_python_client.egg-info/SOURCES.txt

@@ -186,6 +186,7 @@ matter_server/common/helpers/util.py
 tests/test_bigint_wire.py
 tests/test_bridge_node_fixture.py
 tests/test_bridge_topology.py
+tests/test_camera.py
 tests/test_client.py
 tests/test_client_integration.py
 tests/test_credentials.py

{matter_python_client-1.5.0a0.dev20261009 → matter_python_client-1.5.0a0.dev20261014}/matter_server/client/client.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 import asyncio
+from dataclasses import asdict
 import logging
 from pathlib import Path
 from typing import TYPE_CHECKING, Any, Final, Literal, Self, cast
@@ -25,6 +26,16 @@ from matter_server.common.helpers.util import (
 )
 from matter_server.common.models import (
     APICommand,
+    CameraAudioHints,
+    CameraCapabilities,
+    CameraIceServer,
+    CameraResolutionHint,
+    CameraSessionEndedData,
+    CameraSnapshotResult,
+    CameraStartStreamResult,
+    CameraStopStreamResult,
+    CameraStreamEvictedData,
+    CameraVideoHints,
     CommandMessage,
     CommissionableNodeData,
     CommissioningParameters,
@@ -43,6 +54,7 @@ from matter_server.common.models import (
     ServerDiagnostics,
     ServerInfoMessage,
     SuccessResultMessage,
+    WebRTCIceCandidate,
 )
 
 from .connection import MatterClientConnection
@@ -61,7 +73,7 @@ from .models.node import (
 )
 
 if TYPE_CHECKING:
-    from collections.abc import Callable
+    from collections.abc import Callable, Sequence
     from os import PathLike
     from types import TracebackType
 
@@ -71,6 +83,25 @@ if TYPE_CHECKING:
 
 SUB_WILDCARD: Final = "*"
 
+WebRtcProviderCommandName = Literal[
+    "ProvideOffer",
+    "SolicitOffer",
+    "ProvideAnswer",
+    "ProvideIceCandidates",
+]
+
+# Relayed from schema 14; the offer commands need only schema 12.
+SIGNALLING_PROVIDER_COMMANDS: Final = frozenset({"ProvideAnswer", "ProvideIceCandidates"})
+
+# Payload carries node_id, so node_filter subscribers receive these events.
+NODE_SCOPED_CAMERA_EVENTS: Final = frozenset(
+    {
+        EventType.WEBRTC_CALLBACK,
+        EventType.CAMERA_SESSION_ENDED,
+        EventType.CAMERA_STREAM_EVICTED,
+    }
+)
+
 # pylint: disable=too-many-public-methods,too-many-locals,too-many-branches
 
 
@@ -718,23 +749,190 @@ class MatterClient:
         self,
         node_id: int,
         endpoint_id: int,
-        command_name: Literal["ProvideOffer", "SolicitOffer"],
+        command_name: WebRtcProviderCommandName,
         payload: dict,
-    ) -> dict[str, Any]:
+    ) -> dict[str, Any] | None:
         """Invoke a WebRTCTransportProvider command on a commissioned camera.
 
         The server hard-codes the cluster id (0x0553) and injects
         originatingEndpointId — payload should omit both.
+
+        ``ProvideOffer`` and ``SolicitOffer`` start a session and return the camera's response.
+        ``ProvideAnswer`` and ``ProvideIceCandidates`` act on an existing session, return ``None``
+        and need schema 14. For ``EndSession``, use ``camera_stop_stream``.
         """
         response = await self.send_command(
             APICommand.SEND_WEBRTC_PROVIDER_COMMAND,
-            require_schema=12,
+            require_schema=14 if command_name in SIGNALLING_PROVIDER_COMMANDS else 12,
             node_id=node_id,
             endpoint_id=endpoint_id,
             command_name=command_name,
             payload=payload,
         )
-        return cast(dict[str, Any], response)
+        return cast("dict[str, Any] | None", response)
+
+    async def camera_get_capabilities(self, node_id: int, endpoint_id: int) -> CameraCapabilities:
+        """Return what the camera states and what is allocated on it. Allocates nothing.
+
+        Requires schema 14.
+        """
+        data = await self.send_command(
+            APICommand.CAMERA_GET_CAPABILITIES, require_schema=14, node_id=node_id, endpoint_id=endpoint_id
+        )
+        return dataclass_from_dict(CameraCapabilities, data)
+
+    async def camera_start_stream(  # noqa: PLR0913
+        self,
+        node_id: int,
+        endpoint_id: int,
+        stream_usage: str,
+        sdp: str | None = None,
+        video: CameraVideoHints | Literal[False] | None = None,
+        audio: CameraAudioHints | Literal[False] | None = None,
+        ice_servers: list[CameraIceServer] | None = None,
+        ice_transport_policy: str | None = None,
+        metadata_enabled: bool | None = None,
+        allow_eviction: bool | None = None,
+        talkback: bool | None = None,
+    ) -> CameraStartStreamResult:
+        """Open a WebRTC session, allocating or reusing the streams it needs.
+
+        Sends ``ProvideOffer`` when ``sdp`` is given, ``SolicitOffer`` otherwise; then the camera's
+        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.
+
+        Requires schema 14.
+        """
+        optional = {
+            "sdp": sdp,
+            "video": video,
+            "audio": audio,
+            "ice_servers": ice_servers,
+            "ice_transport_policy": ice_transport_policy,
+            "metadata_enabled": metadata_enabled,
+            "allow_eviction": allow_eviction,
+            "talkback": talkback,
+        }
+        data = await self.send_command(
+            APICommand.CAMERA_START_STREAM,
+            require_schema=14,
+            node_id=node_id,
+            endpoint_id=endpoint_id,
+            stream_usage=stream_usage,
+            **{key: value for key, value in optional.items() if value is not None},
+        )
+        return dataclass_from_dict(CameraStartStreamResult, data)
+
+    async def camera_provide_answer(self, node_id: int, endpoint_id: int, webrtc_session_id: int, sdp: str) -> None:
+        """Send the SDP answer for a session started without ``sdp``.
+
+        Requires schema 14.
+        """
+        await self.send_command(
+            APICommand.CAMERA_PROVIDE_ANSWER,
+            require_schema=14,
+            node_id=node_id,
+            endpoint_id=endpoint_id,
+            webrtc_session_id=webrtc_session_id,
+            sdp=sdp,
+        )
+
+    async def camera_provide_ice_candidates(
+        self,
+        node_id: int,
+        endpoint_id: int,
+        webrtc_session_id: int,
+        ice_candidates: Sequence[WebRTCIceCandidate | dict[str, Any]],
+    ) -> None:
+        """Send one or more ICE candidates to an existing session.
+
+        A candidate from a ``webrtc_callback`` ``ice_candidates`` event can be passed unchanged.
+
+        Requires schema 14.
+        """
+        await self.send_command(
+            APICommand.CAMERA_PROVIDE_ICE_CANDIDATES,
+            require_schema=14,
+            node_id=node_id,
+            endpoint_id=endpoint_id,
+            webrtc_session_id=webrtc_session_id,
+            ice_candidates=[
+                asdict(candidate) if isinstance(candidate, WebRTCIceCandidate) else candidate
+                for candidate in ice_candidates
+            ],
+        )
+
+    async def camera_stop_stream(
+        self, node_id: int, endpoint_id: int, webrtc_session_id: int
+    ) -> CameraStopStreamResult:
+        """End a WebRTC session; the stream allocation is kept.
+
+        Requires schema 14.
+        """
+        data = await self.send_command(
+            APICommand.CAMERA_STOP_STREAM,
+            require_schema=14,
+            node_id=node_id,
+            endpoint_id=endpoint_id,
+            webrtc_session_id=webrtc_session_id,
+        )
+        return dataclass_from_dict(CameraStopStreamResult, data)
+
+    async def camera_snapshot(
+        self,
+        node_id: int,
+        endpoint_id: int,
+        max_resolution: CameraResolutionHint | None = None,
+        codec: str | None = None,
+        watermark_enabled: bool | None = None,
+        osd_enabled: bool | None = None,
+    ) -> CameraSnapshotResult:
+        """Capture one image. An argument left ``None`` is not sent.
+
+        The snapshot stream stays allocated; free it with ``camera_release_stream``.
+
+        Requires schema 14.
+        """
+        optional = {
+            "max_resolution": max_resolution,
+            "codec": codec,
+            "watermark_enabled": watermark_enabled,
+            "osd_enabled": osd_enabled,
+        }
+        data = await self.send_command(
+            APICommand.CAMERA_SNAPSHOT,
+            require_schema=14,
+            node_id=node_id,
+            endpoint_id=endpoint_id,
+            **{key: value for key, value in optional.items() if value is not None},
+        )
+        return dataclass_from_dict(CameraSnapshotResult, data)
+
+    async def camera_release_stream(
+        self,
+        node_id: int,
+        endpoint_id: int,
+        kind: Literal["video", "audio", "snapshot"],
+        stream_id: int,
+    ) -> None:
+        """Deallocate a stream, whoever allocated it.
+
+        Raises ``CameraStreamInUse`` while the camera still references the stream.
+
+        Requires schema 14.
+        """
+        await self.send_command(
+            APICommand.CAMERA_RELEASE_STREAM,
+            require_schema=14,
+            node_id=node_id,
+            endpoint_id=endpoint_id,
+            kind=kind,
+            stream_id=stream_id,
+        )
 
     def _prepare_message(
         self,
@@ -957,6 +1155,14 @@ class MatterClient:
             topology = dataclass_from_dict(NetworkTopology, msg.data)
             self._signal_event(EventType.NETWORK_TOPOLOGY_UPDATED, data=topology)
             return
+        if msg.event in NODE_SCOPED_CAMERA_EVENTS:
+            payload: Any = msg.data
+            if msg.event == EventType.CAMERA_SESSION_ENDED:
+                payload = dataclass_from_dict(CameraSessionEndedData, msg.data)
+            elif msg.event == EventType.CAMERA_STREAM_EVICTED:
+                payload = dataclass_from_dict(CameraStreamEvictedData, msg.data)
+            self._signal_event(msg.event, data=payload, node_id=msg.data["node_id"])
+            return
         # An event type unknown to this (older) client is passed through by parse_value as a raw
         # string; forwarding it would crash on `event.value` in _signal_event. Drop it instead so a
         # newer server emitting a new event type can never disconnect the client.

{matter_python_client-1.5.0a0.dev20261009 → matter_python_client-1.5.0a0.dev20261014}/matter_server/client/models/node.py

@@ -434,22 +434,70 @@ class MatterNode:
     def _map_endpoint_parents(self) -> None:
         """Resolve each endpoint to its closest parent endpoint, split by parent kind.
 
+        The parents come from the server's `endpoint_parents` when it sends them, else they are
+        derived from the partsLists (see `_derive_endpoint_parents`). Only the endpoints of the
+        last snapshot take part.
+
+        A snapshot replaces the relation of an endpoint where it names a parent for it that decides
+        the relation: one that bridges or composes it, or with server parents any parent that
+        reports device types. Derived parents are a guess, so one that makes the endpoint neither
+        bridged nor a part only replaces the relation when it is the parent the endpoint already
+        had. Where a snapshot decides nothing - the endpoint unlisted or unreported, or its parent
+        without a Descriptor or device types - the endpoint keeps its relation until its own
+        removal or that of the parent is announced, so a consumer handling the announcement still
+        finds the device the endpoint is a part of. A kept relation that would close a cycle with a
+        named one is dropped.
+        """
+        snapshot_ids = self._snapshot_endpoint_ids & self.endpoints.keys()
+        server_parents = self.node_data.endpoint_parents
+        if server_parents is None:
+            parents = self._derive_endpoint_parents(snapshot_ids)
+        else:
+            parents = {
+                child_id: parent_id
+                for child_id, parent_id in server_parents.items()
+                if child_id in snapshot_ids and (parent_id == ROOT_ENDPOINT_ID or parent_id in snapshot_ids)
+            }
+
+        previous_composed = self._composed_endpoints
+        previous_bridge = self._bridge_parents
+        self._composed_endpoints = {}
+        self._bridge_parents = {}
+        decided = {
+            child_id for child_id, parent_id in parents.items() if self._map_endpoint_parent(child_id, parent_id)
+        }
+        related = self._composed_endpoints | self._bridge_parents
+        for relations, previous in (
+            (self._composed_endpoints, previous_composed),
+            (self._bridge_parents, previous_bridge),
+        ):
+            for child_id, parent_id in sorted(previous.items()):
+                if child_id in related or (
+                    child_id in decided and (server_parents is not None or parents[child_id] == parent_id)
+                ):
+                    continue
+                if _reaches(parent_id, child_id, related):
+                    LOGGER.warning(
+                        "Dropping parent relation that a snapshot made cyclic: Node %s, endpoint %s below %s",
+                        self.node_id,
+                        child_id,
+                        parent_id,
+                    )
+                    continue
+                relations[child_id] = parent_id
+                related[child_id] = parent_id
+
+        self._report_bridged_devices_without_info()
+
+    def _derive_endpoint_parents(self, snapshot_ids: set[int]) -> dict[int, int]:
+        """Derive the closest parent of each endpoint from the partsLists of the snapshot.
+
         An endpoint's partsList may enumerate its whole family - every descendant, not just
         the direct children - which is the pattern a bridge uses. Of the endpoints listing a
         given endpoint, the closest one is therefore the endpoint that lists none of the
         others - on contradictory lists the smaller family wins, then the lower endpoint
         number - and a parent is only accepted while the relations stay a tree.
-
-        Only the endpoints of the last snapshot take part. A snapshot replaces the relation of an
-        endpoint only where it names a parent for it: one that bridges or composes it, or the
-        parent it already had, whose classification then wins. Where it names none - the endpoint
-        unlisted or unreported, its parent without a Descriptor or device types, or listed only by
-        endpoints that make it neither bridged nor a part - the endpoint keeps its relation until
-        its own removal or that of the parent is announced, so a consumer handling the
-        announcement still finds the device the endpoint is a part of. A kept relation that would
-        close a cycle with a named one is dropped.
         """
-        snapshot_ids = self._snapshot_endpoint_ids & self.endpoints.keys()
         families: dict[int, set[int]] = {}
         for endpoint in self.endpoints.values():
             if endpoint.endpoint_id not in snapshot_ids:
@@ -494,34 +542,7 @@ class MatterNode:
                     continue
                 parents[child_id] = parent_id
                 break
-
-        previous_composed = self._composed_endpoints
-        previous_bridge = self._bridge_parents
-        self._composed_endpoints = {}
-        self._bridge_parents = {}
-        decided = {
-            child_id for child_id, parent_id in parents.items() if self._map_endpoint_parent(child_id, parent_id)
-        }
-        related = self._composed_endpoints | self._bridge_parents
-        for relations, previous in (
-            (self._composed_endpoints, previous_composed),
-            (self._bridge_parents, previous_bridge),
-        ):
-            for child_id, parent_id in sorted(previous.items()):
-                if child_id in related or (child_id in decided and parents[child_id] == parent_id):
-                    continue
-                if _reaches(parent_id, child_id, related):
-                    LOGGER.warning(
-                        "Dropping parent relation that a snapshot made cyclic: Node %s, endpoint %s below %s",
-                        self.node_id,
-                        child_id,
-                        parent_id,
-                    )
-                    continue
-                relations[child_id] = parent_id
-                related[child_id] = parent_id
-
-        self._report_bridged_devices_without_info()
+        return parents
 
     def _report_bridged_devices_without_info(self) -> None:
         """Warn about bridged devices the bridge does not describe, once per endpoint.
@@ -550,14 +571,13 @@ class MatterNode:
         bridged device; any other child stands alone, whether or not the Aggregator is itself a
         Bridged Node (so ids derived from the compose parent match older clients). Below any other endpoint, a child
         is a part of it - also when the device types of that endpoint are unknown to this client,
-        so only a parent that reports no device type at all decides nothing.
+        so only a parent without a Descriptor or device types decides nothing.
         """
         if parent_id == ROOT_ENDPOINT_ID:
             return True
         parent = self.endpoints[parent_id]
         descriptor = parent.get_cluster(Clusters.Descriptor)
-        assert descriptor is not None  # only endpoints with a Descriptor are parents
-        if not descriptor.deviceTypeList:
+        if descriptor is None or not descriptor.deviceTypeList:
             return False
         if RootNode in parent.device_types:
             return True