streamlit-webrtc 0.51.2__py3-none-any.whl → 0.52.0__py3-none-any.whl

streamlit_webrtc/__init__.py

@@ -7,7 +7,6 @@ except ModuleNotFoundError:
     import importlib_metadata  # type: ignore
 
 from .component import (
-    ClientSettings,
     WebRtcStreamerContext,
     WebRtcStreamerState,
     webrtc_streamer,
@@ -58,7 +57,6 @@ VideoTransformerFactory = VideoProcessorFactory
 
 __all__ = [
     "webrtc_streamer",
-    "ClientSettings",
     "AudioProcessorBase",
     "AudioProcessorFactory",
     "AudioReceiver",

streamlit_webrtc/component.py

@@ -1,4 +1,3 @@
-import copy
 import json
 import logging
 import os
@@ -11,7 +10,6 @@ from typing import (
     Generic,
     NamedTuple,
     Optional,
-    TypedDict,
     Union,
     cast,
     overload,
@@ -19,6 +17,7 @@ from typing import (
 
 import streamlit as st
 import streamlit.components.v1 as components
+from aiortc import RTCConfiguration
 from aiortc.mediastreams import MediaStreamTrack
 
 from streamlit_webrtc.models import (
@@ -37,11 +36,14 @@ from .config import (
     DEFAULT_VIDEO_HTML_ATTRS,
     AudioHTMLAttributes,
     MediaStreamConstraints,
-    RTCConfiguration,
     Translations,
     VideoHTMLAttributes,
+    compile_ice_servers,
+    compile_rtc_configuration,
+)
+from .credentials import (
+    get_available_ice_servers,
 )
-from .credentials import get_hf_ice_servers, get_twilio_ice_servers
 from .session_info import get_script_run_count, get_this_session_info
 from .webrtc import (
     AudioProcessorFactory,
@@ -72,11 +74,6 @@ else:
     _component_func = components.declare_component("webrtc_streamer", path=build_dir)
 
 
-class ClientSettings(TypedDict, total=False):
-    rtc_configuration: RTCConfiguration
-    media_stream_constraints: MediaStreamConstraints
-
-
 class WebRtcStreamerState(NamedTuple):
     playing: bool
     signalling: bool
@@ -93,7 +90,6 @@ class WebRtcStreamerContext(Generic[VideoProcessorT, AudioProcessorT]):
     _worker_ref: "Optional[weakref.ReferenceType[WebRtcWorker[VideoProcessorT, AudioProcessorT]]]"  # noqa
 
     _component_value_snapshot: Union[ComponentValueSnapshot, None]
-    _rtc_configuration: Optional[Union[Dict[str, Any], RTCConfiguration]]
 
     def __init__(
         self,
@@ -103,7 +99,6 @@ class WebRtcStreamerContext(Generic[VideoProcessorT, AudioProcessorT]):
         self._set_worker(worker)
         self._set_state(state)
         self._component_value_snapshot = None
-        self._rtc_configuration = None
 
     def _set_worker(
         self, worker: Optional[WebRtcWorker[VideoProcessorT, AudioProcessorT]]
@@ -246,7 +241,6 @@ def webrtc_streamer(
     translations: Optional[Translations] = None,
     on_change: Optional[Callable] = None,
     # Deprecated. Just for backward compatibility
-    client_settings: Optional[Union[ClientSettings, Dict]] = None,
     video_transformer_factory: None = None,
     async_transform: Optional[bool] = None,
 ) -> WebRtcStreamerContext:
@@ -287,7 +281,6 @@ def webrtc_streamer(
     translations: Optional[Translations] = None,
     on_change: Optional[Callable] = None,
     # Deprecated. Just for backward compatibility
-    client_settings: Optional[Union[ClientSettings, Dict]] = None,
     video_transformer_factory: None = None,
     async_transform: Optional[bool] = None,
 ) -> WebRtcStreamerContext[VideoProcessorT, Any]:
@@ -324,7 +317,6 @@ def webrtc_streamer(
     translations: Optional[Translations] = None,
     on_change: Optional[Callable] = None,
     # Deprecated. Just for backward compatibility
-    client_settings: Optional[Union[ClientSettings, Dict]] = None,
     video_transformer_factory: None = None,
     async_transform: Optional[bool] = None,
 ) -> WebRtcStreamerContext[Any, AudioProcessorT]:
@@ -361,7 +353,6 @@ def webrtc_streamer(
     translations: Optional[Translations] = None,
     on_change: Optional[Callable] = None,
     # Deprecated. Just for backward compatibility
-    client_settings: Optional[Union[ClientSettings, Dict]] = None,
     video_transformer_factory: None = None,
     async_transform: Optional[bool] = None,
 ) -> WebRtcStreamerContext[VideoProcessorT, AudioProcessorT]:
@@ -397,7 +388,6 @@ def webrtc_streamer(
     translations: Optional[Translations] = None,
     on_change: Optional[Callable] = None,
     # Deprecated. Just for backward compatibility
-    client_settings: Optional[Union[ClientSettings, Dict]] = None,
     video_transformer_factory=None,
     async_transform: Optional[bool] = None,
 ) -> WebRtcStreamerContext[VideoProcessorT, AudioProcessorT]:
@@ -420,19 +410,6 @@ def webrtc_streamer(
             stacklevel=2,
         )
         async_processing = async_transform
-    if client_settings is not None:
-        warnings.warn(
-            "The argument client_settings is deprecated. "
-            "Use rtc_configuration and media_stream_constraints instead.",
-            DeprecationWarning,
-            stacklevel=2,
-        )
-        rtc_configuration = (
-            client_settings.get("rtc_configuration") if client_settings else None
-        )
-        media_stream_constraints = (
-            client_settings.get("media_stream_constraints") if client_settings else None
-        )
 
     if media_stream_constraints is None:
         media_stream_constraints = DEFAULT_MEDIA_STREAM_CONSTRAINTS
@@ -460,49 +437,6 @@ def webrtc_streamer(
         )
         st.session_state[key] = context
 
-    if context._rtc_configuration is None:
-        context._rtc_configuration = copy.deepcopy(rtc_configuration)
-    if context._rtc_configuration is None or (
-        isinstance(context._rtc_configuration, dict)
-        and context._rtc_configuration.get("iceServers") is None
-    ):
-        LOGGER.info(
-            "rtc_configuration.iceServers is not set. Try to set it automatically."
-        )
-        if hf_token := os.getenv("HF_TOKEN"):
-            LOGGER.info("Try to use TURN server from Hugging Face.")
-            try:
-                ice_servers = get_hf_ice_servers(hf_token)
-                if context._rtc_configuration is None:
-                    context._rtc_configuration = {}
-                LOGGER.info("Successfully got TURN credentials from Hugging Face.")
-                context._rtc_configuration["iceServers"] = ice_servers
-            except Exception as e:
-                LOGGER.error("Failed to get TURN credentials from Hugging Face: %s", e)
-        elif os.getenv("TWILIO_ACCOUNT_SID") and os.getenv("TWILIO_AUTH_TOKEN"):
-            LOGGER.info("Try to use TURN server from Twilio.")
-            twilio_sid = os.getenv("TWILIO_ACCOUNT_SID")
-            twilio_token = os.getenv("TWILIO_AUTH_TOKEN")
-            try:
-                ice_servers = get_twilio_ice_servers(twilio_sid, twilio_token)
-                if context._rtc_configuration is None:
-                    context._rtc_configuration = {}
-                LOGGER.info("Successfully got TURN credentials from Twilio.")
-                context._rtc_configuration["iceServers"] = ice_servers
-            except Exception as e:
-                LOGGER.error("Failed to get TURN credentials from Twilio: %s", e)
-        else:
-            LOGGER.info("Use STUN server from Google.")
-            # TODO: Check network reachability and unset ice_servers if failed
-            ice_servers = [{"urls": "stun:stun.l.google.com:19302"}]
-            if ice_servers:
-                if context._rtc_configuration is None:
-                    context._rtc_configuration = {}
-                LOGGER.info("Successfully got STUN server from Google.")
-                context._rtc_configuration["iceServers"] = [
-                    {"urls": "stun:stun.l.google.com:19302"}
-                ]
-
     webrtc_worker = context._get_worker()
 
     sdp_answer_json = None
@@ -539,8 +473,6 @@ def webrtc_streamer(
         key=frontend_key,
         sdp_answer_json=sdp_answer_json,
         mode=mode.name,
-        settings=client_settings,
-        rtc_configuration=context._rtc_configuration,
         media_stream_constraints=media_stream_constraints,
         video_html_attrs=video_html_attrs,
         audio_html_attrs=audio_html_attrs,
@@ -597,8 +529,6 @@ def webrtc_streamer(
         context._set_worker(None)
         webrtc_worker = None
 
-        context._rtc_configuration = None
-
         # Rerun to unset the SDP answer from the frontend args
         rerun()
 
@@ -622,8 +552,23 @@ def webrtc_streamer(
             'Create a new worker (key="%s").',
             key,
         )
+
+        aiortc_rtc_configuration = (
+            compile_rtc_configuration(rtc_configuration)
+            if rtc_configuration and isinstance(rtc_configuration, dict)
+            else RTCConfiguration()
+        )
+
+        if aiortc_rtc_configuration.iceServers is None:
+            LOGGER.info(
+                "rtc_configuration.iceServers is not set. Try to set it automatically."
+            )
+            ice_servers = get_available_ice_servers()
+            aiortc_rtc_configuration.iceServers = compile_ice_servers(ice_servers)
+
         webrtc_worker = WebRtcWorker(
             mode=mode,
+            rtc_configuration=aiortc_rtc_configuration,
             player_factory=player_factory,
             in_recorder_factory=in_recorder_factory,
             out_recorder_factory=out_recorder_factory,

streamlit_webrtc/config.py

@@ -1,4 +1,11 @@
-from typing import Dict, List, Optional, TypedDict, Union
+from typing import Any, Dict, List, Optional, TypedDict, Union
+
+from aiortc import (
+    RTCConfiguration as AiortcRTCConfiguration,
+)
+from aiortc import (
+    RTCIceServer as AiortcRTCIceServer,
+)
 
 RTCIceServer = TypedDict(
     "RTCIceServer",
@@ -15,6 +22,44 @@ class RTCConfiguration(TypedDict, total=False):
     iceServers: Optional[List[RTCIceServer]]
 
 
+def compile_rtc_ice_server(
+    ice_server: Union[RTCIceServer, dict[str, Any]],
+) -> AiortcRTCIceServer:
+    if not isinstance(ice_server, dict):
+        raise ValueError("ice_server must be a dict")
+    if "urls" not in ice_server:
+        raise ValueError("ice_server must have a urls key")
+
+    return AiortcRTCIceServer(
+        urls=ice_server["urls"],  # type: ignore  # aiortc's type def is incorrect
+        username=ice_server.get("username"),
+        credential=ice_server.get("credential"),
+    )
+
+
+def compile_ice_servers(
+    ice_servers: Union[List[RTCIceServer], List[dict[str, Any]]],
+) -> List[AiortcRTCIceServer]:
+    return [
+        compile_rtc_ice_server(server)
+        for server in ice_servers
+        if isinstance(server, dict) and "urls" in server
+    ]
+
+
+def compile_rtc_configuration(
+    rtc_configuration: Union[RTCConfiguration, dict[str, Any]],
+) -> AiortcRTCConfiguration:
+    if not isinstance(rtc_configuration, dict):
+        raise ValueError("rtc_configuration must be a dict")
+    ice_servers = rtc_configuration.get("iceServers", [])
+    if not isinstance(ice_servers, list):
+        raise ValueError("iceServers must be a list")
+    return AiortcRTCConfiguration(
+        iceServers=compile_ice_servers(ice_servers),
+    )
+
+
 Number = Union[int, float]
 
 

streamlit_webrtc/credentials.py

@@ -24,6 +24,7 @@ SOFTWARE.
 # Original: https://github.com/freddyaboulton/fastrtc/blob/66f0a81b76684c5d58761464fb67642891066f93/LICENSE
 
 import json
+import logging
 import os
 import urllib.error
 import urllib.request
@@ -31,6 +32,8 @@ from typing import List, Optional
 
 from .config import RTCIceServer
 
+LOGGER = logging.getLogger(__name__)
+
 
 def get_hf_ice_servers(token: Optional[str] = None) -> List[RTCIceServer]:
     if token is None:
@@ -67,11 +70,35 @@ def get_twilio_ice_servers(
         raise ImportError("Please install twilio with `pip install twilio`")
 
     if not twilio_sid and not twilio_token:
-        twilio_sid = os.environ.get("TWILIO_ACCOUNT_SID")
-        twilio_token = os.environ.get("TWILIO_AUTH_TOKEN")
+        twilio_sid = os.getenv("TWILIO_ACCOUNT_SID")
+        twilio_token = os.getenv("TWILIO_AUTH_TOKEN")
+
+    if twilio_sid is None or twilio_token is None:
+        raise ValueError("TWILIO_ACCOUNT_SID and TWILIO_AUTH_TOKEN must be set")
 
     client = Client(twilio_sid, twilio_token)
 
     token = client.tokens.create()
 
     return token.ice_servers
+
+
+def get_available_ice_servers() -> List[RTCIceServer]:
+    try:
+        LOGGER.info("Try to use TURN server from Hugging Face.")
+        ice_servers = get_hf_ice_servers()
+        LOGGER.info("Successfully got TURN credentials from Hugging Face.")
+        return ice_servers
+    except Exception as e:
+        LOGGER.info("Failed to get TURN credentials from Hugging Face: %s", e)
+
+    try:
+        LOGGER.info("Try to use TURN server from Twilio.")
+        ice_servers = get_twilio_ice_servers()
+        LOGGER.info("Successfully got TURN credentials from Twilio.")
+        return ice_servers
+    except Exception as e:
+        LOGGER.info("Failed to get TURN credentials from Twilio: %s", e)
+
+    LOGGER.info("Use STUN server from Google.")
+    return [RTCIceServer(urls="stun:stun.l.google.com:19302")]