getstream 3.3.2__tar.gz → 3.3.4__tar.gz

{getstream-3.3.2 → getstream-3.3.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: getstream
-Version: 3.3.2
+Version: 3.3.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.3.2 → getstream-3.3.4}/getstream/video/rtc/encoders_patches.py

@@ -1,8 +1,11 @@
+import fractions
 import logging
 import os
 from typing import Optional
 
+import av
 from aiortc import RTCRtpCodecParameters
+from aiortc.codecs.h264 import MAX_FRAME_RATE as H264_MAX_FRAME_RATE
 from aiortc.codecs.h264 import H264Encoder
 from aiortc.codecs.vpx import Vp8Encoder
 from aiortc.rtcrtpsender import RTCEncodedFrame, RTCRtpSender
@@ -26,6 +29,11 @@ BITRATE_PATCH_DISABLED = os.getenv(
     "off",
 )
 
+# libx264 preset for the StreamH264Encoder. Defaults to "ultrafast" for
+# real-time CPU; can be raised (e.g. "veryfast", "medium") for better
+# quality-per-bit at the cost of more CPU per frame.
+STREAM_H264_PRESET = os.getenv("STREAM_PATCH_AIORTC_H264_PRESET", "ultrafast").strip()
+
 
 try:
     # Verify the name-mangled attributes we depend on still exist.
@@ -51,11 +59,13 @@ try:
             self._Vp8Encoder__target_bitrate = bitrate
 
     class StreamH264Encoder(H264Encoder):
-        """H264Encoder subclass with higher bitrate bounds for Stream calls."""
+        """H264Encoder subclass with higher bitrate bounds and a real-time
+        libx264 preset for Stream calls."""
 
         def __init__(self) -> None:
             super().__init__()
             self._H264Encoder__target_bitrate = STREAM_VIDEO_DEFAULT_BITRATE
+            self.preset = STREAM_H264_PRESET
 
         @property
         def target_bitrate(self) -> int:
@@ -68,10 +78,45 @@ try:
             )
             self._H264Encoder__target_bitrate = bitrate
 
+        def _encode_frame(self, frame, force_keyframe):
+            # Mirror parent's invalidation policy so we own codec creation in
+            # both first-init AND recreation (resolution/bitrate change) paths;
+            # otherwise parent's `if self.codec is None` branch silently
+            # reverts our preset to libx264's default `medium`.
+            codec = self.codec
+            if (
+                codec is not None
+                and codec.bit_rate
+                and (
+                    frame.width != codec.width
+                    or frame.height != codec.height
+                    or abs(self.target_bitrate - codec.bit_rate) / codec.bit_rate > 0.1
+                )
+            ):
+                self.buffer_data = b""
+                self.buffer_pts = None
+                self.codec = None
+
+            if self.codec is None:
+                self.codec = av.CodecContext.create("libx264", "w")
+                self.codec.width = frame.width
+                self.codec.height = frame.height
+                self.codec.bit_rate = self.target_bitrate
+                self.codec.pix_fmt = "yuv420p"
+                self.codec.framerate = fractions.Fraction(H264_MAX_FRAME_RATE, 1)
+                self.codec.time_base = fractions.Fraction(1, H264_MAX_FRAME_RATE)
+                self.codec.options = {
+                    "level": "31",
+                    "tune": "zerolatency",
+                    "preset": self.preset,
+                }
+                self.codec.profile = "Baseline"
+            yield from super()._encode_frame(frame, force_keyframe)
+
 except Exception:
     logger.warning(
-        "Failed to patch aiortc video encoder subclasses with Stream bitrate values (aiortc internals may have changed), "
-        "falling back to default aiortc bitrates. \n"
+        "Failed to patch aiortc encoder subclasses with Stream values (aiortc internals may have changed), "
+        "falling back to default aiortc encoders. \n"
         "Set STREAM_PATCH_AIORTC_BITRATES=0 to disable patching.",
         exc_info=True,
     )
@@ -80,10 +125,11 @@ except Exception:
 
 
 def patch_sender_encoder(sender: RTCRtpSender) -> None:
-    """Patch a video sender to use Stream's higher-bitrate encoders.
+    """Patch a sender to use Stream's tuned encoders for the negotiated codec.
 
-    If anything goes wrong (e.g. aiortc internals changed), the sender
-    is left untouched and will use the stock encoder via get_encoder().
+    Works for video (VP8/H264) senders. If anything
+    goes wrong (e.g. aiortc internals changed), the sender is left untouched
+    and will use the stock encoder via get_encoder().
     """
     if StreamVp8Encoder is None or StreamH264Encoder is None:
         return
@@ -105,8 +151,8 @@ def patch_sender_encoder(sender: RTCRtpSender) -> None:
         sender._next_encoded_frame = _next_with_stream_encoder  # type: ignore[method-assign]
     except Exception:
         logger.warning(
-            "Failed to patch aiortc video encoder subclasses with Stream bitrate values (aiortc internals may have changed), "
-            "falling back to default aiortc bitrates. \n"
+            "Failed to patch aiortc encoder subclasses with Stream values (aiortc internals may have changed), "
+            "falling back to default aiortc encoders. \n"
             "Set STREAM_PATCH_AIORTC_BITRATES=0 to disable patching.",
             exc_info=True,
         )

{getstream-3.3.2 → getstream-3.3.4}/getstream/video/rtc/pc.py

@@ -53,10 +53,6 @@ class PublisherPeerConnection(aiortc.RTCPeerConnection):
         self._closed = False
         self._connected_event = asyncio.Event()
 
-        for transceiver in self.getTransceivers():
-            if transceiver.kind == "video":
-                transceiver.setCodecPreferences(publish_codec_preferences())
-
         @self.on("icegatheringstatechange")
         def on_icegatheringstatechange():
             logger.info(
@@ -79,8 +75,13 @@ class PublisherPeerConnection(aiortc.RTCPeerConnection):
 
     def addTrack(self, track: MediaStreamTrack) -> RTCRtpSender:
         sender = super().addTrack(track)
-        if track.kind == "video" and not BITRATE_PATCH_DISABLED:
-            patch_sender_encoder(sender)
+        if track.kind == "video":
+            for transceiver in self.getTransceivers():
+                if transceiver.sender is sender:
+                    transceiver.setCodecPreferences(publish_codec_preferences())
+                    break
+            if not BITRATE_PATCH_DISABLED:
+                patch_sender_encoder(sender)
         return sender
 
     async def handle_answer(self, response):

{getstream-3.3.2 → getstream-3.3.4}/getstream/video/rtc/reconnection.py

@@ -218,6 +218,9 @@ class ReconnectionManager:
                     token=self.connection_manager.join_response.credentials.token
                     if self.connection_manager.join_response
                     else None,
+                    ws_url=self.connection_manager.join_response.credentials.server.ws_endpoint
+                    if self.connection_manager.join_response
+                    else None,
                     session_id=self.connection_manager.session_id,
                 )
 

{getstream-3.3.2 → getstream-3.3.4}/getstream/video/rtc/signaling.py

@@ -68,6 +68,10 @@ class WebSocketClient(StreamAsyncIOEventEmitter):
         self.running = False
         self.closed = False
         self._connection_lost_sent = False
+        # Set when a `call_ended` SFU event arrives. Read by `_on_close` to
+        # suppress `connection_lost`, since the close frame that follows carries
+        # no distinguishing status code or reason.
+        self._call_ended = False
 
         # For ping/health check mechanism
         self.ping_thread = None
@@ -168,6 +172,9 @@ class WebSocketClient(StreamAsyncIOEventEmitter):
         event_type = event.WhichOneof("event_payload")
         logger.debug(f"WebSocket message received {event_type}")
 
+        if event_type and event_type == "call_ended":
+            self._call_ended = True
+
         if event.HasField("health_check_response"):
             logger.debug("received health check response")
             self.last_health_check_time = time.time()
@@ -199,29 +206,30 @@ class WebSocketClient(StreamAsyncIOEventEmitter):
 
     def _on_error(self, ws, error):
         """Handle WebSocket error."""
-        if (
+        is_close_frame = (
             isinstance(error, websocket.ABNF)
             and error.opcode == websocket.ABNF.OPCODE_CLOSE
-        ):
-            # For some reason, websockets lib propagates closing frame as an error.
-            # Simply log a debug here if that happens.
-            logger.debug(f"WebSocket closed by server: {error}")
+        )
+        if is_close_frame or not self.running:
+            # Close-frame-as-error or post-disconnect teardown noise.
+            logger.debug(f"WebSocket error after disconnect: {error}")
         else:
             logger.error(f"WebSocket error: {error}")
 
         if not self.first_message_event.is_set():
-            # Create an error event
+            # Mid-handshake failure: unblock `connect()` with a synthetic
+            # error event instead of leaving it parked on `first_message_event`.
             error_event = events_pb2.SfuEvent()
             error_event.error.error.message = str(error)
             self.first_message = error_event
             self.first_message_event.set()
-        elif not self.closed:
+        elif not self.closed and not is_close_frame:
             self._notify_connection_lost(f"error: {error}")
 
     def _on_close(self, ws, close_status_code, close_msg):
         """Handle WebSocket close event."""
         logger.debug(f"WebSocket connection closed: {close_status_code} {close_msg}")
-        was_unexpected = not self.closed
+        was_unexpected = not self.closed and not self._call_ended
         self.running = False
         if was_unexpected:
             self._notify_connection_lost(
@@ -248,7 +256,7 @@ class WebSocketClient(StreamAsyncIOEventEmitter):
             logger.exception("Failed to schedule connection_lost emit")
 
     def _claim_connection_lost(self) -> bool:
-        """Return True iff this is the first connection-lost notification."""
+        """Return True if this is the first connection-lost notification."""
         if self._connection_lost_sent:
             return False
         self._connection_lost_sent = True