fix: ui_app will start charles_app when not in debug mode

app_interface_actor.py

@@ -3,7 +3,7 @@ from ray.util.queue import Queue
 from ray.actor import ActorHandle
 import torch
 import numpy as np
-
+import pid_helper
 
 @ray.remote
 class AppInterfaceActor:
@@ -14,6 +14,7 @@ class AppInterfaceActor:
         self.video_output_queue = Queue(maxsize=10)  # Adjust the size as needed
         self.debug_str = ""
         self.state = "Initializing"
+        self.charles_app_pids = []
 
     @staticmethod
     def get_singleton():
@@ -77,7 +78,29 @@ class AppInterfaceActor:
             shared_tensor = await self.video_input_queue.get_async()
             video_frames.append(shared_tensor)
         return video_frames
-    
+
+# pid helpers
+    async def add_charles_app_pid(self, pid:int):
+        self.charles_app_pids.append(pid)
+
+    async def get_charles_app_pids(self)->[int]:
+        # prune dead pids
+        running_charles_app_pids = []
+        for pid in self.charles_app_pids:
+            if pid_helper.is_pid_running(pid):
+                running_charles_app_pids.append(pid)
+        self.charles_app_pids = running_charles_app_pids
+        return self.charles_app_pids
+
+    async def is_charles_app_running(self)->bool:
+        # prune dead pids
+        running_charles_app_pids = []
+        for pid in self.charles_app_pids:
+            if pid_helper.is_pid_running(pid):
+                running_charles_app_pids.append(pid)
+        self.charles_app_pids = running_charles_app_pids
+        return len(self.charles_app_pids) > 0
+
 # debug helpers
     async def get_debug_output(self)->str:
         return self.debug_str

charles_app.py

@@ -8,6 +8,7 @@ from response_state_manager import ResponseStateManager
 from respond_to_prompt_async import RespondToPromptAsync
 import asyncio
 import subprocess
+import pid_helper
 
 class CharlesApp:
     def __init__(self):
@@ -30,6 +31,7 @@ class CharlesApp:
         self.set_state("001 - creating AppInterfaceActor")
         from app_interface_actor import AppInterfaceActor
         self._app_interface_actor = AppInterfaceActor.get_singleton()
+        await self._app_interface_actor.add_charles_app_pid.remote(pid_helper.get_current_pid())
         self._audio_output_queue = await self._app_interface_actor.get_audio_output_queue.remote()
 
         self.set_state("002 - creating ResponseStateManager")

pid_helper.py

@@ -0,0 +1,28 @@
+import os
+import platform
+import psutil
+
+def is_pid_running(pid: int) -> bool:
+    system = platform.system()
+    
+    if system == "Linux" or system == "Darwin":  # Linux or macOS
+        try:
+            os.kill(pid, 0)
+            return True
+        except OSError:
+            return False
+    
+    elif system == "Windows":
+        try:
+            process = psutil.Process(pid)
+            return True
+        except psutil.NoSuchProcess:
+            return False
+    
+    else:
+        raise NotImplementedError(f"Unsupported operating system: {system}")
+
+def get_current_pid() -> int:
+    return os.getpid()
+
+

ui_app.py

@@ -29,6 +29,8 @@ load_dotenv()
 
 webrtc_ctx = None
 
+debug_charles_app = os.getenv('DEBUG_CHARLES_APP', 'false').lower() == 'true'
+charles_app_running = False
 
 @st.cache_resource
 def init_ray():
@@ -45,17 +47,6 @@ def init_ray():
         else:
             ray.init(namespace="project_charles")
 
-# @st.cache_resource
-# def get_charles_actor():
-#     charles_actor_instance = None
-#     charles_actor_proc = subprocess.Popen([sys.executable, "charles_actor.py"])
-#     while charles_actor_instance == None:
-#         try:
-#             charles_actor_instance = ray.get_actor("CharlesApp")
-#         except ValueError as e:
-#             time.sleep(0.1) # give the subprocess a chance to start
-#     return charles_actor_instance
-
 @st.cache_resource
 def get_streamlit_av_queue():
     from streamlit_av_queue import StreamlitAVQueue
@@ -68,11 +59,16 @@ def get_app_interface_instance():
     app_interface_instance = AppInterfaceActor.get_singleton()
     return app_interface_instance
 
+@st.cache_resource
+def create_charles_app()->int:
+    charles_app_proc = subprocess.Popen([sys.executable, "charles_app.py"])
+    return charles_app_proc.pid
+
+
+
 async def main():
     # Initialize Ray
     ray_status = init_ray()
-    while not ray.is_initialized():
-        await asyncio.sleep(0.1)
     # get ray actors
     app_interface_instance = get_app_interface_instance()
     await asyncio.sleep(0.1)
@@ -128,17 +124,25 @@ async def main():
 
     try:
         while True:
+            charles_app_running = await app_interface_instance.is_charles_app_running.remote()
             if not webrtc_ctx.state.playing:
                 system_one_audio_status.write("Camera has stopped.")
                 await asyncio.sleep(0.1)
                 continue
-            # if charles_actor is None:
-            #     system_one_audio_status.write("Looking for Charles actor...")
-            #     charles_actor = get_charles_actor()
-            #     if charles_actor is None:
-            #         await asyncio.sleep(0.1)
-            #         continue
-            #     system_one_audio_status.write("Found Charles actor.")
+            if not charles_app_running and debug_charles_app:
+                system_one_audio_status.write("Start Charles app from your debugger...")
+                await asyncio.sleep(0.1)
+                continue
+            if not charles_app_running:
+                print("Starting Charles app...")
+                system_one_audio_status.write("Starting Charles app...")
+                chalres_app_pid = create_charles_app()
+                print(f"Started Charles app with PID {chalres_app_pid}")
+                await asyncio.sleep(.1)
+                pids = await app_interface_instance.get_charles_app_pids.remote()
+                assert chalres_app_pid in pids, f"Charles app PID {chalres_app_pid} not found in {pids}"
+                assert len(pids) == 1, f"Expected 1 PID, found {len(pids)}"
+                continue
             try:
                 streamlit_av_queue.set_looking_listening(looking, listening)
                 charles_debug_str = await app_interface_instance.get_debug_output.remote()
@@ -148,7 +152,7 @@ async def main():
             except Exception as e:
                 # assume we disconnected
                 charles_actor = None
-            await asyncio.sleep(0.1)
+            await asyncio.sleep(0.01)
 
     except Exception as e:
         print(f"An error occurred: {e}")