livekit 1.2.0__tar.gz → 1.2.1__tar.gz

{livekit-1.2.0 → livekit-1.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: livekit
-Version: 1.2.0
+Version: 1.2.1
 Summary: Python Real-time SDK for LiveKit
 Author-email: LiveKit <support@livekit.io>
 License-Expression: Apache-2.0

{livekit-1.2.0 → livekit-1.2.1}/livekit/rtc/_ffi_client.py

@@ -231,12 +231,17 @@ def to_python_level(level: proto_ffi.LogLevel.ValueType) -> Optional[int]:
 class FfiClient:
     _instance: Optional["FfiClient"] = None
     _ffi_disposed: bool = False
+    _instance_lock = threading.Lock()
 
     @classproperty
     def instance(cls) -> "FfiClient":
-        if cls._instance is None:
-            cls._instance = FfiClient()
-        return cls._instance
+        if cls._instance is not None:
+            return cls._instance
+        # threads that race here would each get their own client and lose events sent to the other
+        with cls._instance_lock:
+            if cls._instance is None:
+                cls._instance = FfiClient()
+            return cls._instance
 
     def __init__(self) -> None:
         FfiClient._ffi_disposed = False

{livekit-1.2.0 → livekit-1.2.1}/livekit/rtc/audio_source.py

@@ -136,9 +136,19 @@ class AudioSource:
         req.capture_audio_frame.source_handle = self._ffi_handle.handle
         req.capture_audio_frame.buffer.CopyFrom(frame._proto_info())
 
-        queue = FfiClient.instance.queue.subscribe(loop=self._loop)
+        # The async_id is only known once the request returns; until then every capture
+        # callback is let through, and wait_for drops the ones of other captures.
+        async_id: int | None = None
+        queue = FfiClient.instance.queue.subscribe(
+            loop=self._loop,
+            filter_fn=lambda e: (
+                e.WhichOneof("message") == "capture_audio_frame"
+                and (async_id is None or e.capture_audio_frame.async_id == async_id)
+            ),
+        )
         try:
             resp = FfiClient.instance.request(req)
+            async_id = resp.capture_audio_frame.async_id
             cb: proto_ffi.FfiEvent = await queue.wait_for(
                 lambda e: e.capture_audio_frame.async_id == resp.capture_audio_frame.async_id
             )

{livekit-1.2.0 → livekit-1.2.1}/livekit/rtc/audio_stream.py

@@ -106,11 +106,16 @@ class AudioStream:
         self._num_channels = num_channels
         self._frame_size_ms = frame_size_ms
         self._loop = loop or asyncio.get_event_loop()
-        # Only subscribe to audio_stream_event to avoid unnecessary memory allocations
-        # from other event types (room_event, track_event, etc.)
+        # Subscribe before creating the stream so none of its events are missed. Its
+        # handle is only known once the request returns; until then every audio stream
+        # event is let through, and _run drops the ones of other streams.
+        handle_id: int | None = None
         self._ffi_queue = FfiClient.instance.queue.subscribe(
             self._loop,
-            filter_fn=lambda e: e.WhichOneof("message") == "audio_stream_event",
+            filter_fn=lambda e: (
+                e.WhichOneof("message") == "audio_stream_event"
+                and (handle_id is None or e.audio_stream_event.stream_handle == handle_id)
+            ),
         )
         self._queue: RingQueue[AudioFrameEvent | None] = RingQueue(capacity)
 
@@ -133,6 +138,7 @@ class AudioStream:
         else:
             stream = self._create_owned_stream()
         self._ffi_handle = FfiHandle(stream.handle.id)
+        handle_id = stream.handle.id
         self._info = stream.info
 
         # Start _run only after _ffi_handle is set, so a failure above doesn't orphan
@@ -248,7 +254,10 @@ class AudioStream:
         )
 
     def __del__(self) -> None:
-        FfiClient.instance.queue.unsubscribe(self._ffi_queue)
+        # _ffi_queue is unset if __init__ raised early or the instance was built via __new__
+        ffi_queue = getattr(self, "_ffi_queue", None)
+        if ffi_queue is not None:
+            FfiClient.instance.queue.unsubscribe(ffi_queue)
 
     def _create_owned_stream(self) -> Any:
         assert self._track is not None

{livekit-1.2.0 → livekit-1.2.1}/livekit/rtc/participant.py

@@ -14,7 +14,6 @@
 
 from __future__ import annotations
 
-import ctypes
 import asyncio
 import functools
 import inspect
@@ -42,7 +41,7 @@ from ._proto.room_pb2 import (
 from ._proto.track_pb2 import (
     ParticipantTrackPermission,
 )
-from ._utils import BroadcastQueue
+from ._utils import BroadcastQueue, get_address
 from .track import LocalTrack
 from .track_publication import (
     LocalTrackPublication,
@@ -336,11 +335,10 @@ class LocalParticipant(Participant):
             payload = payload.encode("utf-8")
 
         data_len = len(payload)
-        cdata = (ctypes.c_byte * data_len)(*payload)
 
         req = proto_ffi.FfiRequest()
         req.publish_data.local_participant_handle = self._ffi_handle.handle
-        req.publish_data.data_ptr = ctypes.addressof(cdata)
+        req.publish_data.data_ptr = get_address(payload)
         req.publish_data.data_len = data_len
         req.publish_data.reliable = reliable
         req.publish_data.topic = topic

{livekit-1.2.0 → livekit-1.2.1}/livekit/rtc/room.py

@@ -129,7 +129,7 @@ class RoomOptions:
     connect_timeout: float | None = None
     """Timeout in seconds for each signal connection attempt. When None, uses the default (5s)."""
     single_peer_connection: bool | None = None
-    """Use a single peer connection for both publish and subscribe. When None, uses the default (false)."""
+    """Use a single peer connection for both publish and subscribe. When None, uses the default (true)."""
     data_stream: DataStreamOptions | None = None
     """Options for incoming data streams. When None, uses the FFI defaults."""
 
@@ -189,6 +189,7 @@ class Room(EventEmitter[EventTypes]):
         self._connection_state = ConnectionState.CONN_DISCONNECTED
         self._first_sid_future = asyncio.Future[str]()
         self._local_participant: LocalParticipant | None = None
+        self._is_connecting: bool = False
 
         # active incoming stream readers, keyed by FFI reader handle id
         self._text_stream_readers: Dict[int, TextStreamReader] = {}
@@ -209,10 +210,16 @@ class Room(EventEmitter[EventTypes]):
 
         Returns:
             str: The session ID of the room.
+
+        Raises:
+            RuntimeError: If the room is disconnected and no SID was received.
         """
         if self._info.sid:
             return self._info.sid
 
+        if self._connection_state == ConnectionState.CONN_DISCONNECTED and not self._is_connecting:
+            raise RuntimeError("cannot get sid of a disconnected room")
+
         # This future is shared state for the Room. Caller-side timeouts, e.g.
         # asyncio.wait_for(room.sid, ...), should not cancel it for future waiters.
         return await asyncio.shield(self._first_sid_future)
@@ -221,8 +228,16 @@ class Room(EventEmitter[EventTypes]):
         # The room SID can arrive through the initial connect result or later
         # room update events. Resolve the first-SID waiter from any source that
         # carries it so waiters do not depend on event ordering.
-        if sid and not self._first_sid_future.done():
-            self._first_sid_future.set_result(sid)
+        if sid:
+            self._info.sid = sid
+            if not self._first_sid_future.done():
+                self._first_sid_future.set_result(sid)
+
+    def _fail_first_sid(self, exc: BaseException) -> None:
+        if not self._first_sid_future.done():
+            self._first_sid_future.set_exception(exc)
+            # Retrieve the exception to suppress unretrieved future warnings if unawaited
+            self._first_sid_future.exception()
 
     @property
     def local_participant(self) -> LocalParticipant:
@@ -469,6 +484,9 @@ class Room(EventEmitter[EventTypes]):
         """
         self._server_url = url
         self._token = token
+        self._is_connecting = True
+        if self._first_sid_future.done() and not self._info.sid:
+            self._first_sid_future = asyncio.Future[str]()
         req = proto_ffi.FfiRequest()
         req.connect.url = url
         req.connect.token = token
@@ -560,43 +578,55 @@ class Room(EventEmitter[EventTypes]):
             ),
         )
 
-        queue = FfiClient.instance.queue.subscribe()
         try:
-            resp = FfiClient.instance.request(req)
-            cb: proto_ffi.FfiEvent = await queue.wait_for(
-                lambda e: e.connect.async_id == resp.connect.async_id
-            )
-        finally:
-            FfiClient.instance.queue.unsubscribe(queue)
-
-        if cb.connect.error:
-            FfiClient.instance.queue.unsubscribe(self._ffi_queue)
-            raise ConnectError(cb.connect.error)
-
-        self._ffi_handle = FfiHandle(cb.connect.result.room.handle.id)
+            queue = FfiClient.instance.queue.subscribe()
+            try:
+                resp = FfiClient.instance.request(req)
+                cb: proto_ffi.FfiEvent = await queue.wait_for(
+                    lambda e: e.connect.async_id == resp.connect.async_id
+                )
+            finally:
+                FfiClient.instance.queue.unsubscribe(queue)
 
-        self._e2ee_manager = E2EEManager(
-            self._ffi_handle.handle, options.encryption or options.e2ee
-        )
+            if cb.connect.error:
+                FfiClient.instance.queue.unsubscribe(self._ffi_queue)
+                raise ConnectError(cb.connect.error)
 
-        self._info = cb.connect.result.room.info
-        self._resolve_first_sid(self._info.sid)
-        self._connection_state = ConnectionState.CONN_CONNECTED
+            self._ffi_handle = FfiHandle(cb.connect.result.room.handle.id)
 
-        self._local_participant = LocalParticipant(
-            self._room_queue, cb.connect.result.local_participant
-        )
+            self._e2ee_manager = E2EEManager(
+                self._ffi_handle.handle, options.encryption or options.e2ee
+            )
 
-        for pt in cb.connect.result.participants:
-            rp = self._create_remote_participant(pt.participant)
+            self._info = cb.connect.result.room.info
+            self._resolve_first_sid(self._info.sid)
+            self._connection_state = ConnectionState.CONN_CONNECTED
 
-            # add the initial remote participant tracks
-            for owned_publication_info in pt.publications:
-                publication = RemoteTrackPublication(owned_publication_info)
-                rp._track_publications[publication.sid] = publication
+            self._local_participant = LocalParticipant(
+                self._room_queue, cb.connect.result.local_participant
+            )
 
-        # start listening to room events
-        self._task = self._loop.create_task(self._listen_task())
+            for pt in cb.connect.result.participants:
+                rp = self._create_remote_participant(pt.participant)
+
+                # add the initial remote participant tracks
+                for owned_publication_info in pt.publications:
+                    publication = RemoteTrackPublication(owned_publication_info)
+                    rp._track_publications[publication.sid] = publication
+
+            # start listening to room events
+            self._task = self._loop.create_task(self._listen_task())
+        except BaseException as e:
+            if self._ffi_handle is None and hasattr(self, "_ffi_queue"):
+                FfiClient.instance.queue.unsubscribe(self._ffi_queue)
+            self._fail_first_sid(
+                RuntimeError("room connection was cancelled")
+                if isinstance(e, asyncio.CancelledError)
+                else e
+            )
+            raise
+        finally:
+            self._is_connecting = False
 
         # unsubscribe from the FFI queue once the listen task ends.
         # disconnect() unsubscribes too, but it early-returns when the
@@ -713,6 +743,7 @@ class Room(EventEmitter[EventTypes]):
         if self._connection_state != ConnectionState.CONN_DISCONNECTED:
             self.local_participant._info.disconnect_reason = reason
             self._connection_state = ConnectionState.CONN_DISCONNECTED
+            self._fail_first_sid(RuntimeError("room disconnected before receiving sid"))
             self.emit("connection_state_changed", self._connection_state)
             self.emit("disconnected", reason)
 
@@ -744,6 +775,7 @@ class Room(EventEmitter[EventTypes]):
         await self._drain_rpc_invocation_tasks()
         self._error_stream_readers()
         self._dispose_open_stream_writers()
+        self._fail_first_sid(RuntimeError("room disconnected before receiving sid"))
 
     def _on_rpc_method_invocation(self, rpc_invocation: RpcMethodInvocationEvent) -> None:
         if self._local_participant is None:
@@ -1083,12 +1115,7 @@ class Room(EventEmitter[EventTypes]):
             if which_val == "user":
                 owned_buffer_info = packet.user.data
                 buffer_info = owned_buffer_info.data
-                native_data = ctypes.cast(
-                    buffer_info.data_ptr,
-                    ctypes.POINTER(ctypes.c_byte * buffer_info.data_len),
-                ).contents
-
-                data = bytes(native_data)
+                data = ctypes.string_at(buffer_info.data_ptr, buffer_info.data_len)
                 FfiHandle(owned_buffer_info.handle.id).dispose()
                 rparticipant = cast(
                     RemoteParticipant,
@@ -1126,6 +1153,7 @@ class Room(EventEmitter[EventTypes]):
             self._connection_state = connection_state
             self.emit("connection_state_changed", connection_state)
         elif which == "disconnected":
+            self._fail_first_sid(RuntimeError("room disconnected before receiving sid"))
             self.emit("disconnected", event.disconnected.reason)
         elif which == "reconnecting":
             self.emit("reconnecting")
@@ -1243,8 +1271,12 @@ class Room(EventEmitter[EventTypes]):
 
     def _retrieve_participant(self, identity: str) -> Optional[Participant]:
         """Retrieve a local or remote participant by identity"""
-        if identity and identity == self.local_participant.identity:
-            return self.local_participant
+        if (
+            identity
+            and self._local_participant is not None
+            and identity == self._local_participant.identity
+        ):
+            return self._local_participant
 
         return self._retrieve_remote_participant(identity)
 
@@ -1260,7 +1292,13 @@ class Room(EventEmitter[EventTypes]):
 
     def __repr__(self) -> str:
         sid = "unknown"
-        if self._first_sid_future.done():
+        if self._info.sid:
+            sid = self._info.sid
+        elif (
+            self._first_sid_future.done()
+            and not self._first_sid_future.cancelled()
+            and self._first_sid_future.exception() is None
+        ):
             sid = self._first_sid_future.result()
 
         return f"rtc.Room(sid={sid}, name={self.name}, metadata={self.metadata}, connection_state={ConnectionState.Name(self._connection_state)})"

livekit-1.2.1/livekit/rtc/version.py

@@ -0,0 +1 @@
+__version__ = "1.2.1"

{livekit-1.2.0 → livekit-1.2.1}/livekit/rtc/video_stream.py

@@ -48,11 +48,16 @@ class VideoStream:
         **kwargs: Any,
     ) -> None:
         self._loop = loop or asyncio.get_event_loop()
-        # Only subscribe to video_stream_event to avoid unnecessary memory allocations
-        # from other event types (room_event, track_event, etc.)
+        # Subscribe before creating the stream so none of its events are missed. Its
+        # handle is only known once the request returns; until then every video stream
+        # event is let through, and _run drops the ones of other streams.
+        handle_id: int | None = None
         self._ffi_queue = FfiClient.instance.queue.subscribe(
             self._loop,
-            filter_fn=lambda e: e.WhichOneof("message") == "video_stream_event",
+            filter_fn=lambda e: (
+                e.WhichOneof("message") == "video_stream_event"
+                and (handle_id is None or e.video_stream_event.stream_handle == handle_id)
+            ),
         )
         self._queue: RingQueue[VideoFrameEvent | None] = RingQueue(capacity)
         self._track: Track | None = track
@@ -68,6 +73,7 @@ class VideoStream:
             stream = self._create_owned_stream()
 
         self._ffi_handle = FfiHandle(stream.handle.id)
+        handle_id = stream.handle.id
         self._info = stream.info
 
         self._task = self._loop.create_task(self._run())

{livekit-1.2.0 → livekit-1.2.1}/livekit.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: livekit
-Version: 1.2.0
+Version: 1.2.1
 Summary: Python Real-time SDK for LiveKit
 Author-email: LiveKit <support@livekit.io>
 License-Expression: Apache-2.0

{livekit-1.2.0 → livekit-1.2.1}/livekit.egg-info/SOURCES.txt

@@ -73,6 +73,7 @@ livekit/rtc/resources/jupyter-html/index.html
 tests/test_audio.py
 tests/test_audio_stream_init.py
 tests/test_audio_stream_room_lifecycle.py
+tests/test_basic.py
 tests/test_broadcast_queue.py
 tests/test_change_video_quality.py
 tests/test_data_stream_writer.py

{livekit-1.2.0 → livekit-1.2.1}/setup.py

@@ -56,10 +56,7 @@ def get_platform_tag():
     elif sys.platform == "linux":
         return f"linux_{platform.machine()}"
     elif sys.platform == "win32":
-        arch = platform.machine()
-        if arch == "AMD64":
-            arch = "amd64"
-        return f"win_{arch}"
+        return f"win_{platform.machine().lower()}"
     else:
         return f"{platform.system().lower()}_{platform.machine()}"
 

livekit-1.2.1/tests/test_basic.py

@@ -0,0 +1,124 @@
+"""End-to-end Test for basic scenarios.
+
+The test exercises connect/disconnect lifecycle, participant
+visibility, reconnection, and track publish/subscribe between four rooms.
+
+Requires the following environment variables to run:
+    LIVEKIT_URL
+    LIVEKIT_API_KEY
+    LIVEKIT_API_SECRET
+"""
+
+from __future__ import annotations
+
+import os
+
+import pytest
+
+from livekit import rtc
+
+from utils import (  # type: ignore[import-not-found]
+    await_event,
+    connect_room,
+    create_token,
+    ensure_rooms_all_connected,
+    ensure_track_subscribed,
+    expect_room_event,
+    skip_if_no_credentials,
+    unique_room_name,
+    wait_until,
+)
+
+
+async def _publish_video(room: rtc.Room, track_name: str) -> rtc.LocalTrackPublication:
+    source = rtc.VideoSource(320, 240)
+    track = rtc.LocalVideoTrack.create_video_track(track_name, source)
+    options = rtc.TrackPublishOptions(source=rtc.TrackSource.SOURCE_CAMERA)
+    return await room.local_participant.publish_track(track, options)
+
+
+async def _publish_audio(room: rtc.Room, track_name: str) -> rtc.LocalTrackPublication:
+    source = rtc.AudioSource(48000, 1)
+    track = rtc.LocalAudioTrack.create_audio_track(track_name, source)
+    options = rtc.TrackPublishOptions(source=rtc.TrackSource.SOURCE_MICROPHONE)
+    return await room.local_participant.publish_track(track, options)
+
+
+@skip_if_no_credentials()  # type: ignore[untyped-decorator]
+@pytest.mark.asyncio
+async def test_connection_basics() -> None:
+    room_name = unique_room_name("py-basics")
+
+    p1 = await connect_room("p1", room_name)
+    p2 = await connect_room("p2", room_name)
+    await ensure_rooms_all_connected([p1, p2])
+
+    # p2 should observe p1 leaving
+    p2_saw_p1_left = expect_room_event(
+        p2,
+        "participant_disconnected",
+        predicate=lambda p: p.identity == "p1",
+    )
+    await p1.disconnect()
+    await await_event(p2_saw_p1_left)
+
+    await wait_until(
+        lambda: p1.connection_state == rtc.ConnectionState.CONN_DISCONNECTED,
+        message="p1 did not reach CONN_DISCONNECTED",
+    )
+
+    await p2.disconnect()
+    await wait_until(
+        lambda: p2.connection_state == rtc.ConnectionState.CONN_DISCONNECTED,
+        message="p2 did not reach CONN_DISCONNECTED",
+    )
+
+    # p3: connect, disconnect, reconnect, disconnect cycle
+    p3 = await connect_room("p3", room_name)
+    p3_url = os.environ["LIVEKIT_URL"]
+    p3_token = create_token("p3", room_name)
+
+    await p3.disconnect()
+    assert p3.connection_state == rtc.ConnectionState.CONN_DISCONNECTED, (
+        f"expected p3 disconnected, got {p3.connection_state}"
+    )
+
+    await p3.connect(p3_url, p3_token)
+    assert p3.connection_state == rtc.ConnectionState.CONN_CONNECTED, (
+        f"expected p3 connected, got {p3.connection_state}"
+    )
+
+    await p3.disconnect()
+    assert p3.connection_state == rtc.ConnectionState.CONN_DISCONNECTED, (
+        f"expected p3 disconnected, got {p3.connection_state}"
+    )
+
+    # p4 joins, then p3 reconnects to publish to p4
+    p4 = await connect_room("p4", room_name)
+
+    await p3.connect(p3_url, p3_token)
+    assert p3.connection_state == rtc.ConnectionState.CONN_CONNECTED, (
+        f"expected p3 reconnected, got {p3.connection_state}"
+    )
+
+    # publish camera from p3, expect p4 to see track_published
+    video_published = expect_room_event(p4, "track_published")
+    video_pub = await _publish_video(p3, "p3-camera")
+    await await_event(video_published)
+    await ensure_track_subscribed(p4, video_pub.sid)
+
+    # publish microphone from p3, expect p4 to see another track_published
+    audio_published = expect_room_event(
+        p4,
+        "track_published",
+        predicate=lambda pub, _p: pub.sid != video_pub.sid,
+    )
+    audio_pub = await _publish_audio(p3, "p3-mic")
+    await await_event(audio_published)
+    await ensure_track_subscribed(p4, audio_pub.sid)
+
+    await p3.disconnect()
+    await p4.disconnect()
+
+    assert p3.connection_state == rtc.ConnectionState.CONN_DISCONNECTED
+    assert p4.connection_state == rtc.ConnectionState.CONN_DISCONNECTED

{livekit-1.2.0 → livekit-1.2.1}/tests/test_dc.py

@@ -12,6 +12,8 @@ Requires the following environment variables to run:
 from __future__ import annotations
 
 import asyncio
+import ctypes
+import gc
 from typing import Optional
 
 import pytest
@@ -277,3 +279,45 @@ async def test_data_targeted_with_topic() -> None:
     await _assert_no_data(other, other_collector)
 
     await asyncio.gather(sender.disconnect(), target.disconnect(), other.disconnect())
+
+
+@skip_if_no_credentials()  # type: ignore[untyped-decorator]
+@pytest.mark.asyncio
+async def test_publish_data_makes_no_ctypes_array_type() -> None:
+    """Sending and receiving payloads of new lengths makes no ctypes array type."""
+    room_name = unique_room_name("py-dc-array-type")
+
+    sender = rtc.Room()
+    receiver = rtc.Room()
+
+    await connect_room("sender", room_name, room=sender)
+    await connect_room("receiver", room_name, room=receiver)
+    await ensure_rooms_all_connected([sender, receiver])
+    await ensure_participants_visible(sender, ["receiver"])
+
+    collector = _DataCollector(receiver, sender_identity="sender")
+    lengths = range(1001, 1011)
+    payloads = [bytes([i]) * n for i, n in enumerate(lengths)]
+
+    gc.collect()
+    gc.disable()
+    try:
+        for payload in payloads:
+            await sender.local_participant.publish_data(payload)
+        await wait_until(
+            lambda: len(collector.packets) >= len(payloads),
+            message="receiver did not get all payloads",
+        )
+        array_types = [
+            o
+            for o in gc.get_objects()
+            if isinstance(o, type)
+            and issubclass(o, ctypes.Array)
+            and getattr(o, "_length_", None) in lengths
+        ]
+    finally:
+        gc.enable()
+    assert array_types == []
+    assert collector.payloads() == payloads
+
+    await asyncio.gather(sender.disconnect(), receiver.disconnect())

livekit-1.2.0/livekit/rtc/version.py

@@ -1 +0,0 @@
-__version__ = "1.2.0"