refactor so we have in and then i can add out

charles_actor.py

@@ -56,7 +56,7 @@ class CharlesActor:
             if len(self._debug_queue) > 0:
                 prompt = self._debug_queue.pop(0)
                 self._respond_to_prompt_actor.enqueue_prompt.remote(prompt)
-            audio_frames = await self._streamlit_av_queue.get_audio_frames_async()    
+            audio_frames = await self._streamlit_av_queue.get_in_audio_frames_async()    
             if len(audio_frames) > 0:
                 total_audio_frames += len(audio_frames)
                 # Concatenate all audio frames into a single buffer

streamlit_av_queue.py

@@ -6,15 +6,15 @@ import threading
 
 import numpy as np
 import ray
-from input_av_queue_actor import InputAVQueueActor
+from webrtc_av_queue_actor import WebRtcAVQueueActor
 import pydub
 import torch
 
 class StreamlitAVQueue:
     def __init__(self, audio_bit_rate=16000):
         self._audio_bit_rate = audio_bit_rate
-        self.queue_actor = InputAVQueueActor.options(
-            name="InputAVQueueActor", 
+        self.queue_actor = WebRtcAVQueueActor.options(
+            name="WebRtcAVQueueActor", 
             get_if_exists=True,
             ).remote() 
             
@@ -26,7 +26,7 @@ class StreamlitAVQueue:
             for frame in frames:
                 shared_tensor = torch.from_numpy(frame.to_ndarray())
                 shared_tensor_ref = ray.put(shared_tensor)
-                self.queue_actor.enqueue_video_frame.remote(shared_tensor_ref)
+                self.queue_actor.enqueue_in_video_frame.remote(shared_tensor_ref)
         except Exception as e:
             print (e)
         return frames
@@ -50,7 +50,7 @@ class StreamlitAVQueue:
                     sound_chunk += sound
                 shared_buffer = np.array(sound_chunk.get_array_of_samples())
                 shared_buffer_ref = ray.put(shared_buffer)
-                self.queue_actor.enqueue_audio_frame.remote(shared_buffer_ref)
+                self.queue_actor.enqueue_in_audio_frame.remote(shared_buffer_ref)
         except Exception as e:
             print (e)
             
@@ -66,10 +66,10 @@ class StreamlitAVQueue:
             new_frames.append(new_frame)    
         return new_frames
 
-    async def get_audio_frames_async(self) -> List[av.AudioFrame]:
-        shared_buffers = await self.queue_actor.get_audio_frames.remote()
+    async def get_in_audio_frames_async(self) -> List[av.AudioFrame]:
+        shared_buffers = await self.queue_actor.get_in_audio_frames.remote()
         return shared_buffers
 
     async def get_video_frames_async(self) -> List[av.AudioFrame]:
-        shared_tensors = await self.queue_actor.get_video_frames.remote()
+        shared_tensors = await self.queue_actor.get_in_video_frames.remote()
         return shared_tensors

input_av_queue_actor.py → webrtc_av_queue_actor.py

@@ -6,38 +6,38 @@ import numpy as np
 
 
 @ray.remote
-class InputAVQueueActor:
+class WebRtcAVQueueActor:
     def __init__(self):
-        self.audio_queue = Queue(maxsize=100)  # Adjust the size as needed
-        self.video_queue = Queue(maxsize=100)  # Adjust the size as needed
+        self.in_audio_queue = Queue(maxsize=100)  # Adjust the size as needed
+        self.in_video_queue = Queue(maxsize=100)  # Adjust the size as needed
 
-    def enqueue_video_frame(self, shared_tensor_ref):
-        if self.video_queue.full():
-            evicted_item = self.video_queue.get()
+    def enqueue_in_video_frame(self, shared_tensor_ref):
+        if self.in_video_queue.full():
+            evicted_item = self.in_video_queue.get()
             del evicted_item
-        self.video_queue.put(shared_tensor_ref)
+        self.in_video_queue.put(shared_tensor_ref)
 
-    def enqueue_audio_frame(self, shared_buffer_ref):
-        if self.audio_queue.full():
-            evicted_item = self.audio_queue.get()
+    def enqueue_in_audio_frame(self, shared_buffer_ref):
+        if self.in_audio_queue.full():
+            evicted_item = self.in_audio_queue.get()
             del evicted_item
-        self.audio_queue.put(shared_buffer_ref)
+        self.in_audio_queue.put(shared_buffer_ref)
 
 
-    def get_audio_frames(self):
+    def get_in_audio_frames(self):
         audio_frames = []
-        if self.audio_queue.empty():
+        if self.in_audio_queue.empty():
             return audio_frames
-        while not self.audio_queue.empty():
-            shared_tensor_ref = self.audio_queue.get()
+        while not self.in_audio_queue.empty():
+            shared_tensor_ref = self.in_audio_queue.get()
             audio_frames.append(shared_tensor_ref)
         return audio_frames
 
-    def get_video_frames(self):
+    def get_in_video_frames(self):
         video_frames = []
-        if self.video_queue.empty():
+        if self.in_video_queue.empty():
             return video_frames
-        while not self.video_queue.empty():
-            shared_tensor_ref = self.video_queue.get()
+        while not self.in_video_queue.empty():
+            shared_tensor_ref = self.in_video_queue.get()
             video_frames.append(shared_tensor_ref)
         return video_frames