livekit 0.0.1__py3-none-any.whl

livekit/__init__.py

@@ -0,0 +1,19 @@
+"""LiveKit Client SDK
+"""
+
+__version__ = "0.0.1"
+
+from ._proto.video_frame_pb2 import (
+    VideoRotation, VideoFormatType, VideoFrameBufferType)
+from ._proto.track_pb2 import (TrackKind, TrackSource, StreamState)
+
+from .room import Room
+from .participant import (Participant, LocalParticipant, RemoteParticipant)
+from .track import (Track, LocalAudioTrack, LocalVideoTrack,
+                    RemoteAudioTrack, RemoteVideoTrack)
+from .track_publication import (
+    TrackPublication, LocalTrackPublication, RemoteTrackPublication)
+
+from .video_frame import (ArgbFrame, VideoFrame, VideoFrameBuffer, NativeVideoFrameBuffer, PlanarYuvBuffer,
+                          PlanarYuv8Buffer, PlanarYuv16Buffer, I420Buffer, I420ABuffer, I422Buffer, I010Buffer, NV12Buffer)
+from .video_stream import VideoStream

livekit/_ffi_client.py

@@ -0,0 +1,111 @@
+from ctypes import *
+import platform
+from ._proto import ffi_pb2 as proto_ffi
+from ._proto import room_pb2 as proto_room
+from pyee.asyncio import EventEmitter
+import pkg_resources
+import asyncio
+import threading
+import logging
+
+os = platform.system().lower()
+arch = platform.machine().lower()
+lib_path = 'lib/{}/{}'.format(os, arch)
+
+if os == "windows":
+    lib_file = 'livekit_ffi.dll'
+elif os == "darwin":
+    lib_file = 'liblivekit_ffi.dylib'
+else:
+    lib_file = 'liblivekit_ffi.so'
+
+libpath = pkg_resources.resource_filename('livekit', lib_path + '/' + lib_file)
+
+ffi_lib = CDLL(libpath)
+
+# C function types
+ffi_lib.livekit_ffi_request.argtypes = [
+    POINTER(c_ubyte), c_size_t, POINTER(POINTER(c_ubyte)), POINTER(c_size_t)]
+ffi_lib.livekit_ffi_request.restype = c_size_t
+
+ffi_lib.livekit_ffi_drop_handle.argtypes = [c_size_t]
+ffi_lib.livekit_ffi_drop_handle.restype = c_bool
+
+INVALID_HANDLE = 0
+
+
+@CFUNCTYPE(c_void_p, POINTER(c_uint8), c_size_t)
+def ffi_event_callback(data_ptr: POINTER(c_uint8), data_len: c_size_t):
+    event_data = bytes(data_ptr[:data_len])
+    event = proto_ffi.FfiEvent()
+    event.ParseFromString(event_data)
+
+    ffi_client = FfiClient()
+    with ffi_client._lock:
+        loop = ffi_client._event_loop
+
+    loop.call_soon_threadsafe(dispatch_event, event)
+
+
+def dispatch_event(event: proto_ffi.FfiEvent):
+    ffi_client = FfiClient()
+    which = event.WhichOneof('message')
+    ffi_client.emit(which, getattr(event, which))
+
+
+class Singleton(type):
+    _instances = {}
+
+    def __call__(cls, *args, **kwargs):
+        if cls not in cls._instances:
+            cls._instances[cls] = super(
+                Singleton, cls).__call__(*args, **kwargs)
+        return cls._instances[cls]
+
+
+class FfiClient(EventEmitter, metaclass=Singleton):
+    def __init__(self):
+        super().__init__()
+        self._lock = threading.Lock()
+        self._event_loop = None
+
+        req = proto_ffi.FfiRequest()
+        req.initialize.event_callback_ptr = cast(
+            ffi_event_callback, c_void_p).value
+        self.request(req)
+
+    def set_event_loop(self, loop: asyncio.AbstractEventLoop):
+        with self._lock:
+            if self._event_loop is not None and self._event_loop != loop:
+                logging.warning(
+                    "FfiClient is now using a different asyncio event_loop")
+
+            self._event_loop = loop
+
+    def request(self, req: proto_ffi.FfiRequest) -> proto_ffi.FfiResponse:
+        data = req.SerializeToString()
+        data_len = len(data)
+        data = (c_ubyte * data_len)(*data)
+
+        resp_ptr = POINTER(c_ubyte)()
+        resp_len = c_size_t()
+        handle = ffi_lib.livekit_ffi_request(
+            data, data_len, byref(resp_ptr), byref(resp_len))
+
+        resp_data = bytes(resp_ptr[:resp_len.value])
+        resp = proto_ffi.FfiResponse()
+        resp.ParseFromString(resp_data)
+
+        FfiHandle(handle)
+        return resp
+
+
+class FfiHandle:
+    handle = INVALID_HANDLE
+
+    def __init__(self, handle: int):
+        self.handle = handle
+
+    def __del__(self):
+        if self.handle != INVALID_HANDLE:
+            assert (ffi_lib.livekit_ffi_drop_handle(c_size_t(self.handle)))

livekit/participant.py

@@ -0,0 +1,34 @@
+from ._proto import participant_pb2 as proto_participant
+from .track_publication import TrackPublication
+
+
+class Participant():
+    def __init__(self, info: proto_participant.ParticipantInfo):
+        self._info = info
+        self._tracks: dict[str, TrackPublication] = {}
+
+    @property
+    def sid(self) -> str:
+        return self._info.sid
+
+    @property
+    def name(self) -> str:
+        return self._info.name
+
+    @property
+    def identity(self) -> str:
+        return self._info.identity
+
+    @property
+    def metadata(self) -> str:
+        return self._info.metadata
+
+
+class LocalParticipant(Participant):
+    def __init__(self, info: proto_participant.ParticipantInfo):
+        super().__init__(info)
+
+
+class RemoteParticipant(Participant):
+    def __init__(self, info: proto_participant.ParticipantInfo):
+        super().__init__(info)

livekit/room.py

@@ -0,0 +1,141 @@
+import asyncio
+from pyee.asyncio import AsyncIOEventEmitter
+from ._ffi_client import (FfiClient, FfiHandle)
+from ._proto import ffi_pb2 as proto_ffi
+from ._proto import room_pb2 as proto_room
+from ._proto import participant_pb2 as proto_participant
+from .participant import (Participant, LocalParticipant, RemoteParticipant)
+from .track_publication import (RemoteTrackPublication, LocalTrackPublication)
+from .track import (RemoteAudioTrack, RemoteVideoTrack)
+from livekit import TrackKind
+import weakref
+
+
+class ConnectError(Exception):
+    def __init__(self, message: str):
+        self.message = message
+
+
+class Room(AsyncIOEventEmitter):
+    def __init__(self):
+        super().__init__()
+        self._ffi_handle: FfiHandle = None
+        self._room_info: proto_room.RoomInfo = None
+        self._participants: dict[str, RemoteParticipant] = {}
+
+    def __del__(self):
+        ffi_client = FfiClient()
+        ffi_client.remove_listener('room_event', self._on_room_event)
+
+    async def connect(self, url: str, token: str):
+        # TODO(theomonnom): We should be more flexible about the event loop
+        ffi_client = FfiClient()
+        ffi_client.set_event_loop(asyncio.get_running_loop())
+
+        req = proto_ffi.FfiRequest()
+        req.connect.url = url
+        req.connect.token = token
+
+        resp = ffi_client.request(req)
+        async_id = resp.connect.async_id
+
+        future = asyncio.Future()
+
+        def on_connect_callback(cb: proto_room.ConnectCallback):
+            if cb.async_id == async_id:
+                # add existing participants
+                for participant_info in cb.room.participants:
+                    self._create_remote_participant(participant_info)
+
+                future.set_result(cb)
+                ffi_client.remove_listener('connect', on_connect_callback)
+
+        ffi_client.add_listener('connect', on_connect_callback)
+        resp = await future
+
+        if resp.error:
+            raise ConnectError(resp.error)
+        else:
+            self._ffi_handle = FfiHandle(resp.room.handle.id)
+            self._room_info = resp.room
+            self._close_future = asyncio.Future()
+            ffi_client.add_listener('room_event', self._on_room_event)
+
+    async def close(self):
+        self._ffi_handle = None
+        # TODO(theomonnom): wait for ffi resp
+        self._close_future.set_result(None)
+
+    async def run(self):
+        await self._close_future
+
+    def _on_room_event(self, event: proto_room.RoomEvent):
+        which = event.WhichOneof('message')
+        if which == 'participant_connected':
+            remote_participant = self._create_remote_participant(
+                event.participant_connected.info)
+            self.emit('participant_connected', remote_participant)
+        elif which == 'participant_disconnected':
+            sid = event.participant_disconnected.info.sid
+            participant = self._participants.pop(sid)
+            self.emit('participant_disconnected', participant)
+        elif which == 'track_published':
+            participant = self._participants[event.track_published.participant_sid]
+            publication = RemoteTrackPublication(
+                event.track_published.publication)
+            participant._tracks[publication.sid] = publication
+            self.emit('track_published', publication, participant)
+        elif which == 'track_unpublished':
+            participant = self._participants[event.track_unpublished.participant_sid]
+            publication = participant._tracks.pop(
+                event.track_unpublished.publication_sid)
+            self.emit('track_unpublished', publication, participant)
+        elif which == 'track_subscribed':
+            track_info = event.track_subscribed.track
+            participant = self._participants[event.track_subscribed.participant_sid]
+            publication = participant._tracks[track_info.sid]
+
+            if track_info.kind == TrackKind.KIND_VIDEO:
+                video_track = RemoteVideoTrack(
+                    track_info, weakref.ref(self), weakref.ref(participant))
+                publication._track = video_track
+                self.emit('track_subscribed', video_track,
+                          publication, participant)
+            elif track_info.kind == TrackKind.KIND_AUDIO:
+                audio_track = RemoteAudioTrack(
+                    track_info, weakref.ref(self), weakref.ref(participant))
+                publication._track = audio_track
+                self.emit('track_subscribed', audio_track,
+                          publication, participant)
+        elif which == 'track_unsubscribed':
+            participant = self._participants[event.track_unsubscribed.participant_sid]
+            publication = participant._tracks[event.track_unsubscribed.track_sid]
+            track = publication._track
+            publication._track = None
+            self.emit('track_unsubscribed', track, publication, participant)
+
+    def _create_remote_participant(self, info: proto_participant.ParticipantInfo) -> RemoteParticipant:
+        if info.sid in self._participants:
+            raise Exception('participant already exists')
+
+        participant = RemoteParticipant(info)
+        self._participants[participant.sid] = participant
+
+        #  add existing track publications
+        for publication_info in info.publications:
+            publication = RemoteTrackPublication(publication_info)
+            participant._tracks[publication.sid] = publication
+
+        return participant
+
+    @property
+    def sid(self) -> str:
+        return self._room_info.sid
+
+    @property
+    def name(self) -> str:
+        return self._room_info.name
+
+    @property
+    def metadata(self) -> str:
+        return self._room_info.metadata

livekit/track.py

@@ -0,0 +1,63 @@
+from ._proto import track_pb2 as proto_track
+from ._ffi_client import FfiHandle
+from typing import (Optional, TYPE_CHECKING)
+from weakref import ref
+
+if TYPE_CHECKING:
+    from livekit import (Room, Participant)
+
+
+class Track():
+    def __init__(self, handle: Optional[FfiHandle], info: proto_track.TrackInfo, room: ref['Room'], participant: ref['Participant']):
+        self._info = info
+        self._ffi_handle = handle
+
+        # TODO(theomonnom): Simplify that and use a FfiHandleId?
+        # the weak references are needed because when we need to communicate with the
+        # ffi_server which track we are referring to, we also need to provide the room
+        # and the participant.
+        self._room = room
+        self._participant = participant
+
+    @property
+    def sid(self) -> str:
+        return self._info.sid
+
+    @property
+    def name(self) -> str:
+        return self._info.name
+
+    @property
+    def kind(self) -> proto_track.TrackKind:
+        return self._info.kind
+
+    @property
+    def stream_state(self) -> proto_track.StreamState:
+        return self._info.stream_state
+
+    @property
+    def muted(self) -> bool:
+        return self._info.muted
+
+    def update_info(self, info: proto_track.TrackInfo):
+        self._info = info
+
+
+class LocalAudioTrack(Track):
+    def __init__(self, ffi_handle: FfiHandle, info: proto_track.TrackInfo, room: ref['Room'], participant: ref['Participant']):
+        super().__init__(ffi_handle, info, room, participant)
+
+
+class LocalVideoTrack(Track):
+    def __init__(self, ffi_handle: FfiHandle, info: proto_track.TrackInfo, room: ref['Room'], participant: ref['Participant']):
+        super().__init__(ffi_handle, info, room, participant)
+
+
+class RemoteAudioTrack(Track):
+    def __init__(self, info: proto_track.TrackInfo, room: ref['Room'], participant: ref['Participant']):
+        super().__init__(None, info, room, participant)
+
+
+class RemoteVideoTrack(Track):
+    def __init__(self, info: proto_track.TrackInfo, room: ref['Room'], participant: ref['Participant']):
+        super().__init__(None, info, room, participant)

livekit/track_publication.py

@@ -0,0 +1,55 @@
+from livekit._proto import track_pb2 as proto_track
+from ._proto import track_pb2 as proto_track
+from .track import Track
+
+
+class TrackPublication():
+    def __init__(self, info: proto_track.TrackPublicationInfo):
+        self._info = info
+        self._track: Track = None
+
+    @property
+    def sid(self) -> str:
+        return self._info.sid
+
+    @property
+    def name(self) -> str:
+        return self._info.name
+
+    @property
+    def kind(self) -> proto_track.TrackKind:
+        return self._info.kind
+
+    @property
+    def source(self) -> proto_track.TrackSource:
+        return self._info.source
+
+    @property
+    def simulcasted(self) -> bool:
+        return self._info.simulcasted
+
+    @property
+    def width(self) -> int:
+        return self._info.width
+
+    @property
+    def height(self) -> int:
+        return self._info.height
+
+    @property
+    def mime_type(self) -> str:
+        return self._info.mime_type
+
+    @property
+    def muted(self) -> bool:
+        return self._info.muted
+
+
+class LocalTrackPublication(TrackPublication):
+    def __init__(self, info: proto_track.TrackPublicationInfo):
+        super().__init__(info)
+
+
+class RemoteTrackPublication(TrackPublication):
+    def __init__(self, info: proto_track.TrackPublicationInfo):
+        super().__init__(info)

livekit/video_frame.py

@@ -0,0 +1,229 @@
+import ctypes
+from ._ffi_client import FfiHandle
+from ._proto import video_frame_pb2 as proto_video_frame
+from ._proto import ffi_pb2 as proto_ffi
+from ._ffi_client import FfiClient
+from livekit import (VideoRotation, VideoFormatType, VideoFrameBufferType)
+
+
+class VideoFrame():
+    def __init__(self, info: proto_video_frame.VideoFrameInfo) -> None:
+        self._info = info
+        pass
+
+    @property
+    def timestamp(self) -> int:
+        return self._info.timestamp
+
+    @property
+    def rotation(self) -> VideoRotation:
+        return self._info.rotation
+
+
+class VideoFrameBuffer():
+    def __init__(self, ffi_handle: FfiHandle, info: proto_video_frame.VideoFrameBufferInfo):
+        self._info = info
+        self._ffi_handle = ffi_handle
+
+    @property
+    def width(self) -> int:
+        return self._info.width
+
+    @property
+    def height(self) -> int:
+        return self._info.height
+
+    @property
+    def type(self) -> VideoFrameBufferType:
+        return self._info.buffer_type
+
+    def to_i420(self) -> 'I420Buffer':
+        req = proto_ffi.FfiRequest()
+        req.to_i420.buffer.id = self._ffi_handle.handle
+
+        ffi_client = FfiClient()
+        resp = ffi_client.request(req)
+
+        new_info = resp.to_i420.buffer
+        ffi_handle = FfiHandle(new_info.handle.id)
+        return I420Buffer(ffi_handle, new_info)
+
+    def to_argb(self, dst: 'ArgbFrame'):
+        req = proto_ffi.FfiRequest()
+        req.to_argb.buffer.id = self._ffi_handle.handle
+        req.to_argb.dst_ptr = ctypes.addressof(dst.data)
+        req.to_argb.dst_format = dst.format
+        req.to_argb.dst_stride = dst.width
+        req.to_argb.dst_width = dst.width
+        req.to_argb.dst_height = dst.height
+
+        ffi_client = FfiClient()
+        ffi_client.request(req)
+
+    @staticmethod
+    def create(ffi_handle: FfiHandle, info: proto_video_frame.VideoFrameBufferInfo) -> 'VideoFrameBuffer':
+        """
+        Create the right class instance from the VideoFrameBufferInfo
+        """
+
+        if info.buffer_type == VideoFrameBufferType.NATIVE:
+            return NativeVideoFrameBuffer(ffi_handle, info)
+        elif info.buffer_type == VideoFrameBufferType.I420:
+            return I420Buffer(ffi_handle, info)
+        elif info.buffer_type == VideoFrameBufferType.I420A:
+            return I420ABuffer(ffi_handle, info)
+        elif info.buffer_type == VideoFrameBufferType.I422:
+            return I422Buffer(ffi_handle, info)
+        elif info.buffer_type == VideoFrameBufferType.I444:
+            return I444Buffer(ffi_handle, info)
+        elif info.buffer_type == VideoFrameBufferType.I010:
+            return I010Buffer(ffi_handle, info)
+        elif info.buffer_type == VideoFrameBufferType.NV12:
+            return NV12Buffer(ffi_handle, info)
+
+
+class NativeVideoFrameBuffer(VideoFrameBuffer):
+    def __init__(self, ffi_handle: FfiHandle, info: proto_video_frame.VideoFrameBufferInfo):
+        super().__init__(ffi_handle, info)
+
+
+class PlanarYuvBuffer(VideoFrameBuffer):
+    def __init__(self, ffi_handle: FfiHandle, info: proto_video_frame.VideoFrameBufferInfo):
+        super().__init__(ffi_handle, info)
+
+    @property
+    def chroma_width(self) -> int:
+        return self._info.yuv.chroma_width
+
+    @property
+    def chroma_height(self) -> int:
+        return self._info.yuv.chroma_height
+
+    @property
+    def stride_y(self) -> int:
+        return self._info.yuv.stride_y
+
+    @property
+    def stride_u(self) -> int:
+        return self._info.yuv.stride_u
+
+    @property
+    def stride_v(self) -> int:
+        return self._info.yuv.stride_v
+
+
+class PlanarYuv8Buffer(PlanarYuvBuffer):
+    def __init__(self, ffi_handle: FfiHandle, info: proto_video_frame.VideoFrameBufferInfo):
+        super().__init__(ffi_handle, info)
+
+    @property
+    def data_y(self):
+        arr = ctypes.cast(self._info.yuv.data_y_ptr, ctypes.POINTER(
+            ctypes.c_uint8 * self._info.yuv.stride_y * self._info.height)).contents
+        return arr
+
+    @property
+    def data_u(self):
+        arr = ctypes.cast(self._info.yuv.data_u_ptr, ctypes.POINTER(
+            ctypes.c_uint8 * self._info.yuv.stride_u * self._info.yuv.chroma_height)).contents
+        return arr
+
+    @property
+    def data_v(self):
+        arr = ctypes.cast(self._info.yuv.data_v_ptr, ctypes.POINTER(
+            ctypes.c_uint8 * self._info.yuv.stride_v * self._info.yuv.chroma_height)).contents
+        return arr
+
+
+class PlanarYuv16Buffer(PlanarYuvBuffer):
+    def __init__(self, ffi_handle: FfiHandle, info: proto_video_frame.VideoFrameBufferInfo):
+        super().__init__(ffi_handle, info)
+
+    @property
+    def data_y(self):
+        arr = ctypes.cast(self._info.yuv.data_y_ptr, ctypes.POINTER(
+            ctypes.c_uint16 * self._info.yuv.stride_y / 2 * self._info.height)).contents
+        return arr
+
+    @property
+    def data_u(self):
+        arr = ctypes.cast(self._info.yuv.data_u_ptr, ctypes.POINTER(
+            ctypes.c_uint16 * self._info.yuv.stride_u / 2 * self._info.yuv.chroma_height)).contents
+        return arr
+
+    @property
+    def data_v(self):
+        arr = ctypes.cast(self._info.yuv.data_v_ptr, ctypes.POINTER(
+            ctypes.c_uint16 * self._info.yuv.stride_v / 2 * self._info.yuv.chroma_height)).contents
+        return arr
+
+
+class BiplanaraYuv8Buffer(VideoFrameBuffer):
+    def __init__(self, ffi_handle: FfiHandle, info: proto_video_frame.VideoFrameBufferInfo):
+        super().__init__(ffi_handle, info)
+
+    @property
+    def data_y(self):
+        arr = ctypes.cast(self._info.bi_yuv.data_y_ptr, ctypes.POINTER(
+            ctypes.c_uint8 * self._info.bi_yuv.stride_y * self._info.height)).contents
+        return arr
+
+    @property
+    def data_uv(self):
+        arr = ctypes.cast(self._info.bi_yuv.data_uv_ptr, ctypes.POINTER(
+            ctypes.c_uint8 * self._info.bi_yuv.stride_uv * self._info.bi_yuv.chroma_height)).contents
+        return arr
+
+
+class I420Buffer(PlanarYuv8Buffer):
+    def __init__(self, ffi_handle: FfiHandle, info: proto_video_frame.VideoFrameBufferInfo):
+        super().__init__(ffi_handle, info)
+
+
+class I420ABuffer(PlanarYuv8Buffer):
+    def __init__(self, ffi_handle: FfiHandle, info: proto_video_frame.VideoFrameBufferInfo):
+        super().__init__(ffi_handle, info)
+
+    @property
+    def data_a(self):
+        arr = ctypes.cast(self._info.yuv.data_a_ptr, ctypes.POINTER(
+            ctypes.c_uint8 * self._info.yuv.stride_a * self._info.height)).contents
+        return arr
+
+
+class I422Buffer(PlanarYuv8Buffer):
+    def __init__(self, ffi_handle: FfiHandle, info: proto_video_frame.VideoFrameBufferInfo):
+        super().__init__(ffi_handle, info)
+
+
+class I444Buffer(PlanarYuv8Buffer):
+    def __init__(self, ffi_handle: FfiHandle, info: proto_video_frame.VideoFrameBufferInfo):
+        super().__init__(ffi_handle, info)
+
+
+class I010Buffer(PlanarYuv16Buffer):
+    def __init__(self, ffi_handle: FfiHandle, info: proto_video_frame.VideoFrameBufferInfo):
+        super().__init__(ffi_handle, info)
+
+
+class NV12Buffer(BiplanaraYuv8Buffer):
+    def __init__(self, ffi_handle: FfiHandle, info: proto_video_frame.VideoFrameBufferInfo):
+        super().__init__(ffi_handle, info)
+
+
+class ArgbFrame:
+    """
+    Mainly used to simplify the usage of to_argb method
+    So the users don't need to deal with ctypes
+    """
+
+    def __init__(self, format: VideoFormatType, width: int, height: int) -> None:
+        self._format = format
+        self.width = width
+        self.height = height
+        self.data = (ctypes.c_uint8 * (width * height *
+                     ctypes.sizeof(ctypes.c_uint32)))()  # alloc frame
+
+    @property
+    def format(self) -> VideoFormatType:
+        return self._format

livekit/video_stream.py

@@ -0,0 +1,72 @@
+from pyee.asyncio import AsyncIOEventEmitter
+from ._ffi_client import (FfiClient, FfiHandle)
+from livekit import (Track, Room, Participant)
+from ._proto import track_pb2 as proto_track
+from ._proto import ffi_pb2 as proto_ffi
+from ._proto import video_frame_pb2 as proto_video_frame
+from .video_frame import (VideoFrame, VideoFrameBuffer)
+
+
+class VideoStream(AsyncIOEventEmitter):
+    _streams: dict[int, 'VideoStream'] = {}
+    _initialized = False
+
+    @classmethod
+    def initalize(cls):
+        if cls._initialized:
+            return
+
+        cls._initialized = True
+        ffi_client = FfiClient()
+        ffi_client.add_listener('video_stream_event',
+                                cls._on_video_stream_event)
+
+    @classmethod
+    def _on_video_stream_event(cls, event: proto_video_frame.VideoStreamEvent):
+        stream = cls._streams.get(event.handle.id)
+        if stream is None:
+            return
+
+        which = event.WhichOneof('message')
+        if which == 'frame_received':
+            frame_info = event.frame_received.frame
+            buffer_info = event.frame_received.buffer
+            ffi_handle = FfiHandle(buffer_info.handle.id)
+
+            frame = VideoFrame(frame_info)
+            buffer = VideoFrameBuffer.create(ffi_handle, buffer_info)
+            stream._on_frame_received(frame, buffer)
+
+    def __init__(self, track: Track):
+        super().__init__()
+        self.initalize()
+
+        room = track._room()
+        if room is None:
+            raise ValueError("track's room is not valid anymore")
+
+        participant = track._participant()
+        if participant is None:
+            raise ValueError("track's participant is not valid anymore")
+
+        req = proto_ffi.FfiRequest()
+        new_video_stream = req.new_video_stream
+        new_video_stream.room_handle.id = room._ffi_handle.handle
+        new_video_stream.track_sid = track.sid
+        new_video_stream.participant_sid = participant.sid
+        new_video_stream.type = proto_video_frame.VideoStreamType.VIDEO_STREAM_NATIVE
+
+        ffi_client = FfiClient()
+        resp = ffi_client.request(req)
+        stream_info = resp.new_video_stream.stream
+
+        self._streams[stream_info.handle.id] = self
+        self._ffi_handle = FfiHandle(stream_info.handle.id)
+        self._info = stream_info
+        self._track = track
+
+    def _on_frame_received(self, frame: VideoFrame, buffer: VideoFrameBuffer):
+        self.emit('frame_received', frame, buffer)
+
+    def __del__(self):
+        self._streams.pop(self._ffi_handle.handle, None)

livekit-0.0.1.dist-info/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

livekit-0.0.1.dist-info/METADATA

@@ -0,0 +1,22 @@
+Metadata-Version: 2.1
+Name: livekit
+Version: 0.0.1
+Summary: A sample Python project
+Home-page: https://github.com/livekit/client-sdk-python
+Project-URL: Website, https://livekit.io/
+Project-URL: Source, https://github.com/livekit/client-sdk-python/
+Keywords: webrtc,livekit
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3 :: Only
+Requires-Python: >=3.7, <4
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pyee (>=9.0.0)
+

livekit-0.0.1.dist-info/RECORD

@@ -0,0 +1,19 @@
+livekit/__init__.py,sha256=HyfFzpIyRxO3OWdEwJ0eamVLOUxjp4dARcCPh1FdnPk,804
+livekit/_ffi_client.py,sha256=5h0dsFI3DfV8OsH-u-JoFLuz5zp1VUoc4IT0XOwFKRw,3163
+livekit/liblivekit_ffi.dylib,sha256=o0RrOCtu6f_Rf2VLaDY12nNwurYEldeu8YlkNZD2SN4,27826513
+livekit/participant.py,sha256=1T1I-HdJBU85l8BBuWF--r5t8wA3X-rTAyVI0tflmsc,851
+livekit/room.py,sha256=fwO-cOpgjprfHMstCCprPmnLpv6r7cQwAdmVcUNwuxw,5738
+livekit/track.py,sha256=vn8pzEMmRIkus1AZ9GPViLmq3mWCFPIANwAa0fAz8t4,2094
+livekit/track_publication.py,sha256=8ucbQ5hip95xOtQJazAJYv9FjORB9KNqt7Jts3VMoY4,1294
+livekit/video_frame.py,sha256=u5XxlJh6WrBO8e-iS-GkxeQXguFG6f3kfiLc_Sdx3Xo,7652
+livekit/video_stream.py,sha256=PrInW4O035Re29VKuULYGGT_KyrldIymI_EZSIcmx1g,2544
+livekit/lib/darwin/arm64/liblivekit_ffi.dylib,sha256=Z-2XX_F3TVZrxfbh_OEsfXZk-sbcNOTecJ4vcbWhXzg,27826513
+livekit/lib/darwin/x86_64/liblivekit_ffi.dylib,sha256=tpGLzJd3xgyqFivM49Saved1NoJPqZmFJjypA56U9Lk,32760856
+livekit/lib/linux/x86_64/liblivekit_ffi.so,sha256=kTB2ENi6H3wEVsIzB7Gm9c03SIV5KZqBedPLs1rDJHs,34487208
+livekit/lib/windows/arm64/livekit_ffi.dll,sha256=ysOLOSt-W-jiOlIz0TfYk4an5CXWIerBdsNqR5zq0Z4,21245952
+livekit/lib/windows/x86_64/livekit_ffi.dll,sha256=0Y3OZqIGuoxh-6O8sXjI_SPTtxS1hoK2yTKE_fPKwJQ,21245952
+livekit-0.0.1.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+livekit-0.0.1.dist-info/METADATA,sha256=kDOc99GAY7XXunEgxYVlxh56MY090Dc0EwPgX7u0ozU,850
+livekit-0.0.1.dist-info/WHEEL,sha256=pkctZYzUS4AYVn6dJ-7367OJZivF2e8RA9b_ZBjif18,92
+livekit-0.0.1.dist-info/top_level.txt,sha256=OoDok3xUmXbZRvOrfvvXB-Juu4DX79dlq188E19YHoo,8
+livekit-0.0.1.dist-info/RECORD,,

livekit-0.0.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.40.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

livekit-0.0.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+livekit