chore: regenerate openapi and proto spec

Author: vivekd22

generate_webrtc.sh

@@ -41,7 +41,7 @@ fi
 
 # Install Python dependencies
 echo "Installing Python dependencies..."
-uv add "twirp>=0.0.7" "protobuf>=4.25.1" "python-dateutil>=2.8.2" "aiortc>=1.10.1" --optional webrtc
+uv add "twirp>=0.0.7" "protobuf>=6.31.1" "python-dateutil>=2.8.2" "aiortc>=1.10.1" --optional webrtc
 
 # Ensure Go tools are available for Twirp
 if ! command -v go &> /dev/null; then

getstream/models/__init__.py

@@ -475,7 +475,7 @@ class AsyncExportErrorEvent(DataClassJsonMixin):
     task_id: str = dc_field(metadata=dc_config(field_name="task_id"))
     custom: Dict[str, object] = dc_field(metadata=dc_config(field_name="custom"))
     type: str = dc_field(
-        default="export.moderation_logs.error", metadata=dc_config(field_name="type")
+        default="export.channels.error", metadata=dc_config(field_name="type")
     )
     received_at: Optional[datetime] = dc_field(
         default=None,
@@ -1789,8 +1789,8 @@ class CallParticipant(DataClassJsonMixin):
         )
     )
     online: bool = dc_field(metadata=dc_config(field_name="online"))
-    role: str = dc_field(metadata=dc_config(field_name="Role"))
     role: str = dc_field(metadata=dc_config(field_name="role"))
+    role: str = dc_field(metadata=dc_config(field_name="Role"))
     user_session_id: str = dc_field(metadata=dc_config(field_name="UserSessionID"))
     custom: Dict[str, object] = dc_field(metadata=dc_config(field_name="custom"))
     teams_role: "Dict[str, str]" = dc_field(metadata=dc_config(field_name="teams_role"))
@@ -8575,7 +8575,7 @@ class ModerationFlagResponse(DataClassJsonMixin):
     moderation_payload: "Optional[ModerationPayload]" = dc_field(
         default=None, metadata=dc_config(field_name="moderation_payload")
     )
-    review_queue_item: "Optional[ReviewQueueItem]" = dc_field(
+    review_queue_item: "Optional[ReviewQueueItemResponse]" = dc_field(
         default=None, metadata=dc_config(field_name="review_queue_item")
     )
     user: "Optional[UserResponse]" = dc_field(

getstream/plugins/deepgram/tests/test_realtime.py

@@ -188,18 +188,18 @@ def on_partial_transcript(text, user, metadata):
 
     # Check that we received the partial transcript events
     assert len(partial_transcript_events) == 2, "Expected 2 partial transcript events"
-    assert (
-        partial_transcript_events[0][0] == "typing in prog"
-    ), "Incorrect partial transcript text"
-    assert (
-        partial_transcript_events[1][0] == "typing in progress"
-    ), "Incorrect partial transcript text"
+    assert partial_transcript_events[0][0] == "typing in prog", (
+        "Incorrect partial transcript text"
+    )
+    assert partial_transcript_events[1][0] == "typing in progress", (
+        "Incorrect partial transcript text"
+    )
 
     # Check that we received the final transcript event
     assert len(transcript_events) == 1, "Expected 1 final transcript event"
-    assert (
-        transcript_events[0][0] == "typing in progress complete"
-    ), "Incorrect final transcript text"
+    assert transcript_events[0][0] == "typing in progress complete", (
+        "Incorrect final transcript text"
+    )
 
     # Cleanup
     await stt.close()

getstream/plugins/deepgram/tests/test_stt.py

@@ -412,7 +412,7 @@ def on_error(error):
     max_retries = 3
     for attempt in range(max_retries):
         try:
-            print(f"Attempt {attempt+1}/{max_retries}: Sending audio to Deepgram")
+            print(f"Attempt {attempt + 1}/{max_retries}: Sending audio to Deepgram")
 
             # Instead of sending all at once, let's chunk the audio
             # This simulates real-time audio streaming better
@@ -465,7 +465,7 @@ def on_error(error):
         except Exception as e:
             if attempt < max_retries - 1:
                 # Log the error and retry
-                print(f"Retry {attempt+1}/{max_retries} failed: {e}")
+                print(f"Retry {attempt + 1}/{max_retries} failed: {e}")
                 await asyncio.sleep(1.0)  # Wait before retrying
                 # Try to create a fresh STT instance
                 await stt.close()
@@ -498,9 +498,9 @@ def on_error(error):
             else:
                 # Final attempt failed
                 print(f"All retry attempts failed: {e}")
-                assert (
-                    False
-                ), f"Failed to process audio after {max_retries} attempts: {e}"
+                assert False, (
+                    f"Failed to process audio after {max_retries} attempts: {e}"
+                )
 
     # Cleanup and close the connection
     try:
@@ -510,9 +510,9 @@ def on_error(error):
         print(f"Error closing STT: {e}")
 
     # We should have received transcripts
-    assert (
-        len(transcripts) > 0 or len(partial_transcripts) > 0
-    ), "No transcripts received after sending audio"
+    assert len(transcripts) > 0 or len(partial_transcripts) > 0, (
+        "No transcripts received after sending audio"
+    )
     print(
         f"Received {len(transcripts)} transcripts and {len(partial_transcripts)} partial transcripts"
     )
@@ -541,9 +541,9 @@ async def test_deepgram_keep_alive_mechanism():
     await asyncio.sleep(0.2)
 
     # We should see that keep-alive messages have been sent
-    assert (
-        len(connection.sent_text_messages) > 0
-    ), "No keep-alive messages sent after wait"
+    assert len(connection.sent_text_messages) > 0, (
+        "No keep-alive messages sent after wait"
+    )
 
     # Cleanup
     await stt.close()
@@ -569,9 +569,9 @@ async def test_deepgram_keep_alive_after_audio():
     await asyncio.sleep(0.2)
 
     # We should see that keep-alive messages have been sent
-    assert (
-        len(connection.sent_text_messages) > 0
-    ), "No keep-alive messages sent after audio processing"
+    assert len(connection.sent_text_messages) > 0, (
+        "No keep-alive messages sent after audio processing"
+    )
 
     # Cleanup
     await stt.close()
@@ -594,9 +594,9 @@ async def test_deepgram_keep_alive_direct():
     assert success, "Failed to send keep-alive message"
 
     # The connection should have received the message
-    assert (
-        len(connection.sent_text_messages) > 0
-    ), "No keep-alive messages were recorded"
+    assert len(connection.sent_text_messages) > 0, (
+        "No keep-alive messages were recorded"
+    )
 
     # If the connection has a keep_alive method, then the send_text method should not be used
     if hasattr(connection, "keep_alive"):
@@ -853,15 +853,15 @@ def on_error(error):
 
         if transcripts:
             for i, (text, user, metadata) in enumerate(transcripts):
-                print(f"Final transcript {i+1}: {text}")
+                print(f"Final transcript {i + 1}: {text}")
                 print(f"Metadata: {metadata}")
 
         if partial_transcripts:
             print(f"Total partial transcripts: {len(partial_transcripts)}")
 
         if errors:
             for i, error in enumerate(errors):
-                print(f"Error {i+1}: {error}")
+                print(f"Error {i + 1}: {error}")
 
         # Validation
         assert len(errors) == 0, f"Received errors: {errors}"
@@ -904,14 +904,14 @@ def on_error(error):
             print(f"Key words found: {found_key_words}")
 
             # We should find at least some key words from the story
-            assert (
-                len(found_key_words) >= 2
-            ), f"Expected to find at least 2 key words from {key_words}, but only found {found_key_words}"
+            assert len(found_key_words) >= 2, (
+                f"Expected to find at least 2 key words from {key_words}, but only found {found_key_words}"
+            )
 
             # Check that we got a reasonable amount of text
-            assert (
-                len(actual_words) >= 10
-            ), f"Expected at least 10 words, but got {len(actual_words)}: {combined_text}"
+            assert len(actual_words) >= 10, (
+                f"Expected at least 10 words, but got {len(actual_words)}: {combined_text}"
+            )
 
             # Verify metadata structure
             assert "confidence" in metadata

getstream/plugins/moonshine/tests/test_stt.py

@@ -696,17 +696,17 @@ def on_error(error):
 
         if transcripts:
             for i, (text, user, metadata) in enumerate(transcripts):
-                print(f"Transcript {i+1}: {text}")
+                print(f"Transcript {i + 1}: {text}")
                 print(f"Metadata: {metadata}")
 
         if errors:
             for i, error in enumerate(errors):
-                print(f"Error {i+1}: {error}")
+                print(f"Error {i + 1}: {error}")
 
         # We should either get transcripts or errors, but not silence
-        assert (
-            len(transcripts) > 0 or len(errors) > 0
-        ), "No transcripts or errors received"
+        assert len(transcripts) > 0 or len(errors) > 0, (
+            "No transcripts or errors received"
+        )
 
         # If we got transcripts, verify they contain reasonable content
         if transcripts:
@@ -745,14 +745,14 @@ def on_error(error):
             print(f"Key words found: {found_key_words}")
 
             # We should find at least some key words from the story
-            assert (
-                len(found_key_words) >= 2
-            ), f"Expected to find at least 2 key words from {key_words}, but only found {found_key_words}"
+            assert len(found_key_words) >= 2, (
+                f"Expected to find at least 2 key words from {key_words}, but only found {found_key_words}"
+            )
 
             # Check that we got a reasonable amount of text
-            assert (
-                len(actual_words) >= 10
-            ), f"Expected at least 10 words, but got {len(actual_words)}: {combined_text}"
+            assert len(actual_words) >= 10, (
+                f"Expected at least 10 words, but got {len(actual_words)}: {combined_text}"
+            )
 
             # Verify metadata structure
             assert "processing_time_ms" in metadata

getstream/plugins/silero/tests/test_bench.py

@@ -161,6 +161,6 @@ async def test_vad_benchmark_onnx():
     print(f"  Speech segments detected: {results['speech_segments']}")
 
     # Verify that the ONNX implementation is reasonably efficient
-    assert (
-        results["rtf"] < 2.0
-    ), f"ONNX VAD performance too slow: RTF = {results['rtf']:.3f}"
+    assert results["rtf"] < 2.0, (
+        f"ONNX VAD performance too slow: RTF = {results['rtf']:.3f}"
+    )

getstream/plugins/silero/tests/test_vad.py

@@ -225,9 +225,9 @@ def verify_detected_speech(
 
     # Verify number of turns if specified
     if expected_turns is not None:
-        assert (
-            len(detected_segments) == expected_turns
-        ), f"Expected {expected_turns} speech turns, got {len(detected_segments)}"
+        assert len(detected_segments) == expected_turns, (
+            f"Expected {expected_turns} speech turns, got {len(detected_segments)}"
+        )
 
     # Calculate total detected duration
     total_detected_duration = sum(segment["duration"] for segment in detected_segments)
@@ -241,19 +241,19 @@ def verify_detected_speech(
         logger.info(f"Expected speech duration: {expected_duration:.2f} seconds")
         logger.info(f"Detected speech duration: {total_detected_duration:.2f} seconds")
         logger.info(
-            f"Tolerance: ±{tolerance*100:.0f}% ({min_expected:.2f} - {max_expected:.2f}s)"
+            f"Tolerance: ±{tolerance * 100:.0f}% ({min_expected:.2f} - {max_expected:.2f}s)"
         )
 
         if len(detected_segments) > 0:
             logger.info(f"Number of detected segments: {len(detected_segments)}")
             # Log the speech segments for inspection
             for i, segment in enumerate(detected_segments):
-                logger.info(f"Speech segment {i+1}: {segment['duration']:.2f}s")
+                logger.info(f"Speech segment {i + 1}: {segment['duration']:.2f}s")
 
         # Verify that the duration is within expected range
-        assert (
-            min_expected <= total_detected_duration <= max_expected
-        ), f"Expected speech duration {expected_duration}s (±{tolerance*100:.0f}%), got {total_detected_duration}s"
+        assert min_expected <= total_detected_duration <= max_expected, (
+            f"Expected speech duration {expected_duration}s (±{tolerance * 100:.0f}%), got {total_detected_duration}s"
+        )
 
 
 def verify_partial_events(partial_segments, detected_segments):
@@ -269,9 +269,9 @@ def verify_partial_events(partial_segments, detected_segments):
 
     # Each detected segment should have at least one corresponding partial event
     # For simplicity, we just check that we have at least one partial event per detected segment
-    assert (
-        len(partial_segments) >= len(detected_segments)
-    ), f"Expected at least {len(detected_segments)} partial events, got {len(partial_segments)}"
+    assert len(partial_segments) >= len(detected_segments), (
+        f"Expected at least {len(detected_segments)} partial events, got {len(partial_segments)}"
+    )
 
 
 @pytest.mark.asyncio
@@ -512,9 +512,9 @@ def on_partial(event, user=None):
 
         # Verify that partial events were received before the final audio event
         assert len(partial_events) > 0, "No partial events detected"
-        assert (
-            len(partial_events) >= len(detected_speech)
-        ), f"Expected at least {len(detected_speech)} partial events, got {len(partial_events)}"
+        assert len(partial_events) >= len(detected_speech), (
+            f"Expected at least {len(detected_speech)} partial events, got {len(partial_events)}"
+        )
         logger.info(f"Detected {len(partial_events)} partial events")
 
         # Clean up
@@ -600,9 +600,9 @@ def on_partial_16k(event, user=None):
         # Load 16 kHz audio file
         audio_path_16k = get_audio_asset("formant_speech_16k.wav")
         audio_data_16k, sample_rate_16k = sf.read(audio_path_16k, dtype="int16")
-        assert (
-            sample_rate_16k == 16000
-        ), f"Expected sample rate 16000, got {sample_rate_16k}"
+        assert sample_rate_16k == 16000, (
+            f"Expected sample rate 16000, got {sample_rate_16k}"
+        )
 
         # Process the 16 kHz audio
         await vad_16k.process_audio(
@@ -634,9 +634,9 @@ def on_partial_48k(event, user=None):
         # Load 48 kHz audio file
         audio_path_48k = get_audio_asset("formant_speech_48k.wav")
         audio_data_48k, sample_rate_48k = sf.read(audio_path_48k, dtype="int16")
-        assert (
-            sample_rate_48k == 48000
-        ), f"Expected sample rate 48000, got {sample_rate_48k}"
+        assert sample_rate_48k == 48000, (
+            f"Expected sample rate 48000, got {sample_rate_48k}"
+        )
 
         # Process the 48 kHz audio
         await vad_48k.process_audio(
@@ -646,12 +646,12 @@ def on_partial_48k(event, user=None):
         await asyncio.sleep(0.1)
 
         # Verify both detected speech segments and partial events
-        assert (
-            len(detected_speech_16k) > 0
-        ), "No speech segments detected in 16 kHz audio"
-        assert (
-            len(detected_speech_48k) > 0
-        ), "No speech segments detected in 48 kHz audio"
+        assert len(detected_speech_16k) > 0, (
+            "No speech segments detected in 16 kHz audio"
+        )
+        assert len(detected_speech_48k) > 0, (
+            "No speech segments detected in 48 kHz audio"
+        )
         logger.info(
             f"Detected {len(detected_speech_16k)} speech segments in 16 kHz audio"
         )
@@ -779,9 +779,9 @@ async def test_cuda_fallback(self):
         )
 
         # Check that the device fell back to CPU
-        assert (
-            vad.device_name == "cpu"
-        ), "Failed to fall back to CPU when CUDA unavailable"
+        assert vad.device_name == "cpu", (
+            "Failed to fall back to CPU when CUDA unavailable"
+        )
         assert vad.device.type == "cpu", "Device is not CPU after fallback"
 
         # Create a short silence for inference
@@ -837,9 +837,9 @@ def on_audio(event, user=None):
 
         # Verify that at least one speech segment was emitted due to the flush
         assert len(detected_speech) > 0, "No speech segments detected after flush"
-        assert detected_speech[-1][
-            "from_flush"
-        ], "Last speech segment was not triggered by flush"
+        assert detected_speech[-1]["from_flush"], (
+            "Last speech segment was not triggered by flush"
+        )
 
         # Clean up
         await vad.close()

getstream/stream.py

@@ -14,7 +14,6 @@
 from getstream.video.client import VideoClient
 
 
-
 BASE_URL = "https://chat.stream-io-api.com/"