refactor: rename webrtc... to app_interface...

webrtc_av_queue_actor.py → app_interface_actor.py

@@ -6,13 +6,19 @@ import numpy as np
 
 
 @ray.remote
-class WebRtcAVQueueActor:
+class AppInterfaceActor:
     def __init__(self):
         self.audio_input_queue = Queue(maxsize=3000)  # Adjust the size as needed
         self.video_input_queue = Queue(maxsize=10)  # Adjust the size as needed
         self.audio_output_queue = Queue(maxsize=3000)  # Adjust the size as needed
         self.video_output_queue = Queue(maxsize=10)  # Adjust the size as needed
 
+    @staticmethod
+    def get_singleton():
+        return AppInterfaceActor.options(
+            name="AppInterfaceActor",
+            get_if_exists=True,
+        ).remote()
 
     async def enqueue_video_input_frame(self, shared_tensor_ref):
         if self.video_input_queue.full():

streamlit_av_queue.py

@@ -8,7 +8,7 @@ import cv2
 import numpy as np
 import ray
 from ray.util.queue import Queue
-from webrtc_av_queue_actor import WebRtcAVQueueActor
+from app_interface_actor import AppInterfaceActor
 import pydub
 import torch
 
@@ -19,10 +19,7 @@ class StreamlitAVQueue:
         self._listening = True
         self._looking = False
         self._lock = threading.Lock()
-        self.queue_actor = WebRtcAVQueueActor.options(
-            name="WebRtcAVQueueActor", 
-            get_if_exists=True,
-            ).remote()
+        self.app_interface_actor = AppInterfaceActor.get_singleton()
         self._video_output_frame = None 
         
     def set_looking_listening(self, looking, listening: bool):
@@ -38,14 +35,14 @@ class StreamlitAVQueue:
         try:
             with self._lock:
                 should_look = self._looking
-            next_video_output_frame = await self.queue_actor.get_video_output_frame.remote()
+            next_video_output_frame = await self.app_interface_actor.get_video_output_frame.remote()
             if next_video_output_frame is not None:
                 self._video_output_frame = next_video_output_frame
             for i, frame in enumerate(frames):
                 user_image = frame.to_ndarray(format="rgb24")
                 if should_look:
                     shared_tensor_ref = ray.put(user_image)
-                    await self.queue_actor.enqueue_video_input_frame.remote(shared_tensor_ref)
+                    await self.app_interface_actor.enqueue_video_input_frame.remote(shared_tensor_ref)
                 if self._video_output_frame is not None:
                     frame = self._video_output_frame
                     # resize user image to 1/4 size
@@ -85,7 +82,7 @@ class StreamlitAVQueue:
                     sound_chunk += sound
                 shared_buffer = np.array(sound_chunk.get_array_of_samples())
                 shared_buffer_ref = ray.put(shared_buffer)
-                await self.queue_actor.enqueue_audio_input_frame.remote(shared_buffer_ref)
+                await self.app_interface_actor.enqueue_audio_input_frame.remote(shared_buffer_ref)
         except Exception as e:
             print (e)
             
@@ -97,7 +94,7 @@ class StreamlitAVQueue:
                 # print (f"frame: {frame.format.name}, {frame.layout.name}, {frame.sample_rate}, {frame.samples}")
                 assert frame.format.bytes == 2
                 assert frame.format.name == 's16'
-                frame_as_bytes = await self.queue_actor.get_audio_output_frame.remote()
+                frame_as_bytes = await self.app_interface_actor.get_audio_output_frame.remote()
                 if frame_as_bytes:
                     # print(f"frame_as_bytes: {len(frame_as_bytes)}")
                     assert len(frame_as_bytes) == frame.samples * frame.format.bytes
@@ -116,15 +113,15 @@ class StreamlitAVQueue:
         return new_frames
 
     async def get_audio_input_frames_async(self) -> List[av.AudioFrame]:
-        shared_buffers = await self.queue_actor.get_audio_input_frames.remote()
+        shared_buffers = await self.app_interface_actor.get_audio_input_frames.remote()
         return shared_buffers
 
     async def get_video_frames_async(self) -> List[av.AudioFrame]:
-        shared_tensors = await self.queue_actor.get_video_input_frames.remote()
+        shared_tensors = await self.app_interface_actor.get_video_input_frames.remote()
         return shared_tensors
     
     def get_audio_output_queue(self)->Queue:
-        return self.queue_actor.get_audio_output_queue.remote()
+        return self.app_interface_actor.get_audio_output_queue.remote()
     
     def get_video_output_queue(self)->Queue:
-        return self.queue_actor.get_video_output_queue.remote()
+        return self.app_interface_actor.get_video_output_queue.remote()