better track types

livekit-rtc/livekit/rtc/participant.py

@@ -704,7 +704,7 @@ async def publish_track(
                 raise PublishTrackError(cb.publish_track.error)
 
             track_publication = LocalTrackPublication(cb.publish_track.publication)
-            track_publication.track = track
+            track_publication._track = track
             track._info.sid = track_publication.sid
             self._track_publications[track_publication.sid] = track_publication
 
@@ -739,7 +739,7 @@ async def unpublish_track(self, track_sid: str) -> None:
                 raise UnpublishTrackError(cb.unpublish_track.error)
 
             publication = self._track_publications.pop(track_sid)
-            publication.track = None
+            publication._track = None
             queue.task_done()
         finally:
             self._room_queue.unsubscribe(queue)

livekit-rtc/livekit/rtc/room.py

@@ -508,8 +508,8 @@ def _on_room_event(self, event: proto_room.RoomEvent):
         elif which == "local_track_published":
             sid = event.local_track_published.track_sid
             lpublication = self.local_participant.track_publications[sid]
-            track = lpublication.track
-            self.emit("local_track_published", lpublication, track)
+            ltrack = lpublication.track
+            self.emit("local_track_published", lpublication, ltrack)
         elif which == "local_track_unpublished":
             sid = event.local_track_unpublished.publication_sid
             lpublication = self.local_participant.track_publications[sid]
@@ -535,23 +535,23 @@ def _on_room_event(self, event: proto_room.RoomEvent):
             track_info = owned_track_info.info
             rparticipant = self._remote_participants[event.track_subscribed.participant_identity]
             rpublication = rparticipant.track_publications[track_info.sid]
-            rpublication.subscribed = True
+            rpublication._subscribed = True
             if track_info.kind == TrackKind.KIND_VIDEO:
                 remote_video_track = RemoteVideoTrack(owned_track_info)
-                rpublication.track = remote_video_track
+                rpublication._track = remote_video_track
                 self.emit("track_subscribed", remote_video_track, rpublication, rparticipant)
             elif track_info.kind == TrackKind.KIND_AUDIO:
                 remote_audio_track = RemoteAudioTrack(owned_track_info)
-                rpublication.track = remote_audio_track
+                rpublication._track = remote_audio_track
                 self.emit("track_subscribed", remote_audio_track, rpublication, rparticipant)
         elif which == "track_unsubscribed":
             identity = event.track_unsubscribed.participant_identity
             rparticipant = self._remote_participants[identity]
             rpublication = rparticipant.track_publications[event.track_unsubscribed.track_sid]
-            track = rpublication.track
-            rpublication.track = None
-            rpublication.subscribed = False
-            self.emit("track_unsubscribed", track, rpublication, rparticipant)
+            rtrack = rpublication.track
+            rpublication._track = None
+            rpublication._subscribed = False
+            self.emit("track_unsubscribed", rtrack, rpublication, rparticipant)
         elif which == "track_subscription_failed":
             identity = event.track_subscription_failed.participant_identity
             rparticipant = self._remote_participants[identity]
@@ -828,4 +828,4 @@ def __repr__(self) -> str:
         if self._first_sid_future.done():
             sid = self._first_sid_future.result()
 
-        return f"rtc.Room(sid={sid}, name={self.name}, metadata={self.metadata}, connection_state={self._connection_state})"
+        return f"rtc.Room(sid={sid}, name={self.name}, metadata={self.metadata}, connection_state={ConnectionState.Name(self._connection_state)})"

livekit-rtc/livekit/rtc/track_publication.py

@@ -12,22 +12,26 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from typing import Optional
+from typing import Optional, cast
 import asyncio
 
 from ._ffi_client import FfiHandle, FfiClient
 from ._proto import e2ee_pb2 as proto_e2ee
 from ._proto import ffi_pb2 as proto_ffi
 from ._proto import track_pb2 as proto_track
-from .track import Track
+from .track import Track, LocalTrack, RemoteTrack
 
 
 class TrackPublication:
     def __init__(self, owned_info: proto_track.OwnedTrackPublication):
         self._info = owned_info.info
-        self.track: Optional[Track] = None
+        self._track: Optional[Track] = None
         self._ffi_handle = FfiHandle(owned_info.handle.id)
 
+    @property
+    def track(self) -> Optional[Track]:
+        return self._track
+
     @property
     def sid(self) -> str:
         return self._info.sid
@@ -74,6 +78,10 @@ def __init__(self, owned_info: proto_track.OwnedTrackPublication):
         super().__init__(owned_info)
         self._first_subscription: asyncio.Future[None] = asyncio.Future()
 
+    @property
+    def track(self) -> Optional[LocalTrack]:
+        return cast(Optional[LocalTrack], self._track)
+
     async def wait_for_subscription(self) -> None:
         await asyncio.shield(self._first_subscription)
 
@@ -84,7 +92,15 @@ def __repr__(self) -> str:
 class RemoteTrackPublication(TrackPublication):
     def __init__(self, owned_info: proto_track.OwnedTrackPublication):
         super().__init__(owned_info)
-        self.subscribed = False
+        self._subscribed = False
+
+    @property
+    def track(self) -> Optional[RemoteTrack]:
+        return cast(Optional[RemoteTrack], self._track)
+
+    @property
+    def subscribed(self) -> bool:
+        return self._subscribed
 
     def set_subscribed(self, subscribed: bool):
         req = proto_ffi.FfiRequest()