refactor environment_state_actor.py -> responce_state_manager.py

charles_app.py

@@ -4,7 +4,7 @@ import time
 import asyncio
 import os
 from clip_transform import CLIPTransform
-from environment_state_actor import EnvironmentStateActor, EnvironmentState
+from responce_state_manager import ResponceStateManager
 from respond_to_prompt_async import RespondToPromptAsync
 import asyncio
 import subprocess
@@ -13,14 +13,10 @@ class CharlesApp:
     def __init__(self):
         self._needs_init = True
         self._charles_actor_debug_output = ""
-        self._environment_state:EnvironmentState = EnvironmentState(episode=0, step=0)
         self._state = "Initializing"
         self._clip_transform = CLIPTransform()
         
     
-    def get_environment_state(self)->EnvironmentState:
-        return self._environment_state
-    
     def set_state(self, state, skip_print=False):
         self._state = state
         if not skip_print:
@@ -36,8 +32,8 @@ class CharlesApp:
         self._app_interface_actor = AppInterfaceActor.get_singleton()
         self._audio_output_queue = await self._app_interface_actor.get_audio_output_queue.remote()
 
-        self.set_state("002 - creating EnvironmentStateActor")
-        self._environment_state_actor = EnvironmentStateActor.remote()
+        self.set_state("002 - creating ResponceStateManager")
+        self._responce_state_manager = ResponceStateManager()
 
         self.set_state("003 - creating PromptManager")
         from prompt_manager import PromptManager
@@ -102,8 +98,7 @@ class CharlesApp:
         has_spoken_for_this_prompt = False
 
         while True:
-            env_state = await self._environment_state_actor.begin_next_step.remote()
-            self._environment_state = env_state
+            responce_step = self._responce_state_manager.begin_next_step()
             audio_frames = await self._app_interface_actor.dequeue_audio_input_frames_async.remote()    
             video_frames = await self._app_interface_actor.dequeue_video_input_frames_async.remote()
 
@@ -151,13 +146,13 @@ class CharlesApp:
                         if self._respond_to_prompt_task is not None:
                             await self._respond_to_prompt.terminate()
                             self._respond_to_prompt_task.cancel()
-                        self._respond_to_prompt = RespondToPromptAsync(self._environment_state_actor, self._audio_output_queue)
+                        self._respond_to_prompt = RespondToPromptAsync(self._responce_state_manager, self._audio_output_queue)
                         self._respond_to_prompt_task = asyncio.create_task(self._respond_to_prompt.run(prompt, self._prompt_manager.messages))
                         additional_prompt = None
                         previous_prompt = prompt
                         is_talking = False
                         has_spoken_for_this_prompt = False
-                        env_state = await self._environment_state_actor.reset_episode.remote()
+                        responce_step = self._responce_state_manager.reset_episode()
                         current_responses = []
                         speech_chunks_per_response = []
                     elif len(prompt) > 0 and prompt not in prompts_to_ignore:
@@ -171,23 +166,23 @@ class CharlesApp:
                                 self._respond_to_prompt_task.cancel()
                             self._respond_to_prompt_task = None
                             self._respond_to_prompt = None
-                            env_state = await self._environment_state_actor.reset_episode.remote()
+                            responce_step = self._responce_state_manager.reset_episode()
                             current_responses = []
                             speech_chunks_per_response = []                            
                         if additional_prompt is not None:
                             prompt = additional_prompt + ". " + prompt                        
                         human_preview_text = f"👨❓ {prompt}"
 
-            for new_response in env_state.llm_responses:
+            for new_response in responce_step.llm_responses:
                 # add_debug_output(f"🤖 {new_response}")
                 self._prompt_manager.append_assistant_message(new_response)
                 current_responses.append(new_response)
                 speech_chunks_per_response.append(0)
                 robot_preview_text = ""
-            if len(env_state.llm_preview):
-                robot_preview_text = f"🤖❓ {env_state.llm_preview}"
+            if len(responce_step.llm_preview):
+                robot_preview_text = f"🤖❓ {responce_step.llm_preview}"
 
-            for chunk in env_state.tts_raw_chunk_ids:
+            for chunk in responce_step.tts_raw_chunk_ids:
                 chunk = json.loads(chunk)
                 # prompt = chunk['prompt']
                 response_id = chunk['llm_sentence_id']

environment_state_actor.py → responce_state_manager.py

@@ -1,7 +1,6 @@
-import ray
 from datetime import datetime
 
-class EnvironmentState:
+class ResponceStep:
     def __init__(self, episode, step):
         self.timestamp = datetime.utcnow()
         self.episode = episode
@@ -16,8 +15,7 @@ class EnvironmentState:
         return f'episode={self.episode}, step={self.step}, timestamp={self.timestamp}, \nreward={self.reward}\nstate=({state})'
 
 
-@ray.remote
-class EnvironmentStateActor:
+class ResponceStateManager:
     def __init__(self):
         self.episode = 0
         self.step = 0
@@ -27,13 +25,13 @@ class EnvironmentStateActor:
     def reset_episode(self):
         self.episode += 1
         self.step = 0
-        self.state = EnvironmentState(self.episode, self.step)
+        self.state = ResponceStep(self.episode, self.step)
         return self.state
 
-    def begin_next_step(self)->EnvironmentState:
+    def begin_next_step(self)->ResponceStep:
         previous_state = self.state
         self.step += 1
-        self.state = EnvironmentState(self.episode, self.step)
+        self.state = ResponceStep(self.episode, self.step)
         return previous_state
 
     def add_reward(self, reward):
@@ -49,5 +47,5 @@ class EnvironmentStateActor:
     def add_tts_raw_chunk_id(self, chunk_id):
         self.state.tts_raw_chunk_ids.append(chunk_id)
 
-    def get_state(self)->EnvironmentState:
+    def get_state(self)->ResponceStep:
         return self.state

respond_to_prompt_async.py

@@ -6,7 +6,7 @@ import ray
 from chat_service import ChatService
 # from local_speaker_service import LocalSpeakerService
 from text_to_speech_service import TextToSpeechService
-from environment_state_actor import EnvironmentStateActor
+from responce_state_manager import ResponceStateManager
 from ffmpeg_converter import FFMpegConverter
 from agent_response import AgentResponse
 import json
@@ -14,14 +14,14 @@ import json
 class RespondToPromptAsync:
     def __init__(
             self, 
-            environment_state_actor:EnvironmentStateActor, 
+            responce_state_manager:ResponceStateManager, 
             audio_output_queue):
         voice_id="2OviOUQc1JsQRQgNkVBj"
         self.llm_sentence_queue = Queue(maxsize=100)
         self.speech_chunk_queue = Queue(maxsize=100)
         self.voice_id = voice_id
         self.audio_output_queue = audio_output_queue
-        self.environment_state_actor = environment_state_actor
+        self.responce_state_manager = responce_state_manager
         self.sentence_queues = []
         self.sentence_tasks = []    
         # self.ffmpeg_converter = FFMpegConverter.remote(audio_output_queue)
@@ -36,12 +36,12 @@ class RespondToPromptAsync:
                     is_complete_sentance = False
                 if not is_complete_sentance:
                     agent_response['llm_preview'] = text
-                    await self.environment_state_actor.set_llm_preview.remote(text)
+                    self.responce_state_manager.set_llm_preview(text)
                     continue
                 agent_response['llm_preview'] = ''
                 agent_response['llm_sentence'] = text
                 agent_response['llm_sentences'].append(text)
-                await self.environment_state_actor.add_llm_response_and_clear_llm_preview.remote(text)
+                self.responce_state_manager.add_llm_response_and_clear_llm_preview(text)
                 print(f"{agent_response['llm_sentence']} id: {agent_response['llm_sentence_id']} from prompt: {agent_response['prompt']}")
                 sentence_response = agent_response.make_copy()
                 new_queue = Queue()
@@ -65,7 +65,7 @@ class RespondToPromptAsync:
                 'chunk_count': chunk_count,
             }
             chunk_id_json = json.dumps(chunk_response)
-            await self.environment_state_actor.add_tts_raw_chunk_id.remote(chunk_id_json)
+            self.responce_state_manager.add_tts_raw_chunk_id(chunk_id_json)
             chunk_count += 1
 
     async def speech_to_converter(self):

ui_app.py

@@ -140,8 +140,6 @@ async def main():
             #         continue
             #     system_one_audio_status.write("Found Charles actor.")
             try:
-                # new_environment_state = await charles_actor.get_environment_state.remote()
-                # environment_state_ouput.markdown(f"{new_environment_state}")
                 streamlit_av_queue.set_looking_listening(looking, listening)
                 charles_debug_str = await app_interface_instance.get_debug_output.remote()
                 charles_actor_debug_output.markdown(charles_debug_str)