getstream 3.0.2__tar.gz → 3.0.4__tar.gz

{getstream-3.0.2 → getstream-3.0.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: getstream
-Version: 3.0.2
+Version: 3.0.4
 Summary: GetStream Python SDK - Build scalable activity feeds, chat, and video calling applications
 Author-email: sachaarbonel <sacha.arbonel@hotmail.fr>, tbarbugli <tbarbugli@gmail.com>
 License-File: LICENSE.md

{getstream-3.0.2 → getstream-3.0.4}/getstream/stream.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+from contextlib import AsyncExitStack
 from functools import cached_property
 import time
 from typing import List, Optional
@@ -207,6 +208,20 @@ class AsyncStream(BaseStream, AsyncCommonClient):
             user_agent=self.user_agent,
         )
 
+    async def aclose(self):
+        """Close all child clients and the main HTTPX client."""
+        # AsyncExitStack ensures all clients are closed even if one fails.
+        # video/chat/moderation are @cached_property - only close if accessed.
+        async with AsyncExitStack() as stack:
+            cached = self.__dict__
+            if "video" in cached:
+                stack.push_async_callback(self.video.aclose)
+            if "chat" in cached:
+                stack.push_async_callback(self.chat.aclose)
+            if "moderation" in cached:
+                stack.push_async_callback(self.moderation.aclose)
+            stack.push_async_callback(super().aclose)
+
     @cached_property
     def feeds(self):
         raise NotImplementedError("Feeds not supported for async client")

{getstream-3.0.2 → getstream-3.0.4}/getstream/video/rtc/connection_manager.py

@@ -58,6 +58,7 @@ class ConnectionManager(StreamAsyncIOEventEmitter):
         create: bool = True,
         subscription_config: Optional[SubscriptionConfig] = None,
         max_join_retries: int = 3,
+        drain_video_frames: bool = False,
         **kwargs: Any,
     ):
         super().__init__()
@@ -90,7 +91,9 @@ class ConnectionManager(StreamAsyncIOEventEmitter):
         self._subscription_manager: SubscriptionManager = SubscriptionManager(
             self, subscription_config
         )
-        self._peer_manager: PeerConnectionManager = PeerConnectionManager(self)
+        self._peer_manager: PeerConnectionManager = PeerConnectionManager(
+            self, drain_video_frames=drain_video_frames
+        )
 
         self.recording_manager = self._recording_manager
         self.participants_state = self._participants_state

{getstream-3.0.2 → getstream-3.0.4}/getstream/video/rtc/pc.py

@@ -3,7 +3,7 @@ import logging
 from typing import Any, Optional
 
 import aiortc
-from aiortc.contrib.media import MediaRelay
+from aiortc.contrib.media import MediaBlackhole, MediaRelay
 from aiortc.mediastreams import MediaStreamTrack
 from aiortc.rtcrtpparameters import RTCRtpCodecCapability
 from aiortc.rtcrtpsender import RTCRtpSender
@@ -131,15 +131,19 @@ class SubscriberPeerConnection(aiortc.RTCPeerConnection, AsyncIOEventEmitter):
         self,
         connection,
         configuration: aiortc.RTCConfiguration,
+        drain_video_frames: bool = False,
     ) -> None:
         logger.info(
             f"creating subscriber peer connection with configuration: {configuration}"
         )
         super().__init__(configuration)
         self.connection = connection
+        self._drain_video_frames = drain_video_frames
 
         self.track_map = {}  # track_id -> (MediaRelay, original_track)
         self.video_frame_trackers = {}  # track_id -> VideoFrameTracker
+        self._video_blackholes: dict[str, MediaBlackhole] = {}
+        self._video_drain_tasks: dict[str, asyncio.Task] = {}
 
         @self.on("track")
         async def on_track(track: aiortc.mediastreams.MediaStreamTrack):
@@ -177,7 +181,20 @@ class SubscriberPeerConnection(aiortc.RTCPeerConnection, AsyncIOEventEmitter):
                 handler = AudioTrackHandler(relay.subscribe(tracked_track), _emit_pcm)
                 asyncio.create_task(handler.start())
 
-            self.emit("track_added", relay.subscribe(tracked_track), user)
+            proxy = relay.subscribe(tracked_track)
+
+            # Drain unconsumed video frames to prevent unbounded queue growth
+            # in RTCRtpReceiver (aiortc issue #554)
+            if track.kind == "video" and self._drain_video_frames:
+                drain_proxy = relay.subscribe(tracked_track)
+                blackhole = MediaBlackhole()
+                blackhole.addTrack(drain_proxy)
+                self._video_blackholes[track.id] = blackhole
+                self._video_drain_tasks[track.id] = asyncio.create_task(
+                    blackhole.start()
+                )
+
+            self.emit("track_added", proxy, user)
 
         @self.on("icegatheringstatechange")
         def on_icegatheringstatechange():

{getstream-3.0.2 → getstream-3.0.4}/getstream/video/rtc/peer_connection.py

@@ -28,8 +28,9 @@ logger = logging.getLogger(__name__)
 class PeerConnectionManager:
     """Manages WebRTC peer connections for publishing and subscribing."""
 
-    def __init__(self, connection_manager):
+    def __init__(self, connection_manager, drain_video_frames: bool = False):
         self.connection_manager = connection_manager
+        self._drain_video_frames = drain_video_frames
         self.publisher_pc: Optional[PublisherPeerConnection] = None
         self.subscriber_pc: Optional[SubscriberPeerConnection] = None
         self.publisher_negotiation_lock = asyncio.Lock()
@@ -47,6 +48,7 @@ class PeerConnectionManager:
             self.subscriber_pc = SubscriberPeerConnection(
                 connection=self.connection_manager,
                 configuration=self._build_rtc_configuration(),
+                drain_video_frames=self._drain_video_frames,
             )
 
             # Trace create event