remove old files

Agent/character_properties.py

@@ -1,9 +0,0 @@
-class CharacterProperties:
-    def __init__(self, happiness, energy, confidence, fear, excitement, wanderlust, restful):
-        self.happiness = happiness
-        self.energy = energy
-        self.confidence = confidence
-        self.fear = fear
-        self.excitement = excitement
-        self.wanderlust = wanderlust
-        self.restful = restful

Agent/character_state.py

@@ -1,26 +0,0 @@
-
-
-from Agent.character_properties import CharacterProperties
-
-
-class CharacterState:
-    def __init__(self, name, fixed_traits, properties):
-        self.name = name
-        self.fixed_traits = fixed_traits
-        self.properties = properties
-
-charles_properties = CharacterProperties(
-    happiness = 0.85,
-    energy = 0.9,
-    confidence = 0.8,
-    fear = 0.2,
-    excitement = 0.75,
-    wanderlust = 0.95,
-    restful = 0.8
-)
-
-charles_state = CharacterState(
-    name = 'Charles Petrescu',
-    fixed_traits = ['quirky', 'honest', 'inquisitive', 'adventurous', 'friendly', 'random', 'knowledgeable', 'humorous'],
-    properties = charles_properties
-)

debug_000.py

@@ -1,74 +0,0 @@
-import os
-import subprocess
-from elevenlabs import generate, play
-from elevenlabs import set_api_key
-from elevenlabs import generate, stream
-from dotenv import load_dotenv
-load_dotenv()
-
-account_sid = os.environ["ELEVENLABS_API_KEY"]
-voice_id="2OviOUQc1JsQRQgNkVBj"
-model_id="eleven_monolingual_v1"
-set_api_key(account_sid)
-
-def stream_tts(prompt):
-        audio_stream = generate(
-            text=prompt,
-            voice=voice_id,
-            model=model_id,
-            stream_chunk_size=4096,
-            stream=True,
-            )
-        return audio_stream
-
-prompts=[
-    "erm",
-    "Cabbages, my dear friend!",
-    "Did you know that the world's largest cabbage weighed 62.71 kilograms?",
-    "Simply remarkable!",
-    "How are you today?",
-]
-
-mpv_command = ["mpv", "--no-cache", "--no-terminal", "--", "fd://0"]
-mpv_process = subprocess.Popen(
-    mpv_command,
-    stdin=subprocess.PIPE,
-    stdout=subprocess.DEVNULL,
-    stderr=subprocess.DEVNULL,
-)
-
-load_chunks = False
-load_chunks = os.path.exists("chunks.pkl")
-
-# check if chunks.pkl exists
-if load_chunks:
-    # try open chunks
-    with open("chunks.pkl", "rb") as f:
-        import pickle
-        chunks = pickle.load(f)
-        for chunk in chunks:
-            mpv_process.stdin.write(chunk)
-            mpv_process.stdin.flush()
-
-else:
-    chunks = []
-
-    for prompt in prompts:
-        for chunk in stream_tts(prompt):
-            if chunk is not None:
-                chunks.append(chunk)
-                mpv_process.stdin.write(chunk)  # type: ignore
-                mpv_process.stdin.flush()  # type: ignore
-
-    # save chunks to file as a pickled list of bytes
-    with open("chunks.pkl", "wb") as f:
-        import pickle
-        pickle.dump(chunks, f)
-    with open("chunks.mp3", "wb") as f:
-        for chunk in chunks:
-            f.write(chunk)
-
-
-if mpv_process.stdin:
-    mpv_process.stdin.close()
-mpv_process.wait()

debug_001.py

@@ -1,64 +0,0 @@
-import io
-import os
-import subprocess
-import av
-import numpy as np
-
-
-mpv_command = ["mpv", "--no-cache", "--no-terminal", "--", "fd://0"]
-mpv_process = subprocess.Popen(
-    mpv_command,
-    stdin=subprocess.PIPE,
-    stdout=subprocess.DEVNULL,
-    stderr=subprocess.DEVNULL,
-)
-
-load_chunks = False
-load_chunks = os.path.exists("chunks.pkl")
-
-
-audio_frames = []
-
-# try open chunks
-with open("chunks.pkl", "rb") as f:
-    import pickle
-    chunks = pickle.load(f)
-    append = False
-    for chunk in chunks:
-        mpv_process.stdin.write(chunk)
-        mpv_process.stdin.flush()
-        # np_chunk = np.frombuffer(chunk, dtype=np.int16)
-        # aa = av.AudioFrame.from_ndarray(chunk)
-        try:
-            if append:
-                bytes_io.write(chunk)
-                append = False
-                bytes_io.seek(0)
-            else:
-                bytes_io = io.BytesIO(chunk)
-            container = av.open(bytes_io, 'r', format='mp3')
-            audio_stream = next(s for s in container.streams if s.type == 'audio')
-            for frame in container.decode(audio_stream):
-                # Convert the audio frame to a NumPy array
-                array = frame.to_ndarray()
-
-                # Now you can use av.AudioFrame.from_ndarray
-                audio_frame = av.AudioFrame.from_ndarray(array, format='flt', layout='mono')
-                audio_frame.sample_rate = 44100
-
-                audio_frames.append(audio_frame)
-
-        except Exception as e:
-            print (e)
-            append = True
-            bytes_io.seek(0, io.SEEK_END)
-            continue
-
-    # with open("frames.pkl", "wb") as f:
-    #     import pickle
-    #     pickle.dump(audio_frames, f)
-
-
-if mpv_process.stdin:
-    mpv_process.stdin.close()
-mpv_process.wait()

debug_app.py

@@ -1,106 +0,0 @@
-import logging
-import traceback
-from typing import List
-
-import av
-import numpy as np
-import streamlit as st
-from streamlit_webrtc import WebRtcMode, webrtc_streamer
-import pydub
-
-from dotenv import load_dotenv
-from ffmpeg_converter_actor import FFMpegConverterActor
-load_dotenv()
-from sample_utils.turn import get_ice_servers
-
-logger = logging.getLogger(__name__)
-
-
-import os
-
-import ray
-from ray.util.queue import Queue
-if not ray.is_initialized():
-    # Try to connect to a running Ray cluster
-    ray_address = os.getenv('RAY_ADDRESS')
-    if ray_address:
-        ray.init(ray_address, namespace="project_charles")
-    else:
-        ray.init(namespace="project_charles")
-
-
-
-
-def video_frame_callback(
-    frame: av.VideoFrame,
-) -> av.VideoFrame:
-    return frame
-
-
-with open("chunks.pkl", "rb") as f:
-    import pickle
-    debug_chunks = pickle.load(f)
-
-    converter_queue = Queue(maxsize=100)
-    converter_actor = FFMpegConverterActor.remote(converter_queue)
-    ray.get(converter_actor.start_process.remote())
-    converter_actor.run.remote()
-    for chunk in debug_chunks:
-        ray.get(converter_actor.push_chunk.remote(chunk))
-
-
-# emptry array of type int16
-sample_buffer = np.zeros((0), dtype=np.int16)
-
-def process_frame(old_frame):
-
-    try:
-        output_channels = 2
-        output_sample_rate = 44100
-        required_samples = old_frame.samples
-
-        if not converter_queue.empty():
-            frame_as_bytes = converter_queue.get()
-            # print(f"frame_as_bytes: {len(frame_as_bytes)}")
-            samples = np.frombuffer(frame_as_bytes, dtype=np.int16)
-        else: 
-            # create a byte array of zeros
-            samples = np.zeros((required_samples * 2 * 1), dtype=np.int16)
-
-        # Duplicate mono channel for stereo
-        if output_channels == 2:
-            samples = np.vstack((samples, samples)).reshape((-1,), order='F')
-
-        samples = samples.reshape(1, -1)
-
-        layout = 'stereo' if output_channels == 2 else 'mono'
-        new_frame = av.AudioFrame.from_ndarray(samples, format='s16', layout=layout)
-        new_frame.sample_rate = old_frame.sample_rate
-        new_frame.pts = old_frame.pts
-        return new_frame
-    except Exception as e:
-        print (e)
-        traceback.print_exc() 
-        raise(e)
-
-
-
-def audio_frame_callback(old_frame: av.AudioFrame) -> av.AudioFrame:
-    new_frame = process_frame(old_frame)
-
-    # print (f"frame:     {old_frame}, pts: {old_frame.pts}")
-    # print (f"new_frame: {new_frame}, pts: {new_frame.pts}")
-
-    return new_frame
-    # return old_frame
-
-
-webrtc_streamer(
-    key="delay",
-    mode=WebRtcMode.SENDRECV,
-    rtc_configuration={"iceServers": get_ice_servers()},
-
-    video_frame_callback=video_frame_callback,
-    audio_frame_callback=audio_frame_callback,
-
-)

legacy_to_delete/chat_pipeline.py

@@ -1,96 +0,0 @@
-import asyncio
-import time
-from clip_transform import CLIPTransform
-from chat_service import ChatService
-from dotenv import load_dotenv
-from text_to_speech_service import TextToSpeechService
-from concurrent.futures import ThreadPoolExecutor
-from local_speaker_service import LocalSpeakerService
-from chat_service import ChatService
-from legacy_to_delete.pipeline import Pipeline, Node, Job
-from typing import List
-
-class ChatJob(Job):
-    def __init__(self, data, chat_service: ChatService):
-        super().__init__(data)
-        self.chat_service = chat_service
-
-class Node1(Node):
-    next_id = 0
-
-    async def process_job(self, job: ChatJob):
-        # input job.data is the input string
-        # output job.data is the next sentance
-        async for sentence in job.chat_service.get_responses_as_sentances_async(job.data):
-            if job.chat_service.ignore_sentence(sentence):
-                continue
-            print(f"{sentence}")
-            new_job = ChatJob(sentence, job.chat_service)
-            new_job.id = self.next_id
-            self.next_id += 1
-            yield new_job
-    
-class Node2(Node):
-    next_id = 0
-
-    async def process_job(self, job: ChatJob):
-        # input job.data is the sentance
-        # output job.data is the streamed speech bytes
-        async for chunk in job.chat_service.get_speech_chunks_async(job.data):
-            new_job = ChatJob(chunk, job.chat_service)
-            new_job.id = self.next_id
-            self.next_id += 1
-            yield new_job
-
-
-class Node3(Node):
-    # sync_size = 64
-    # sync = []
-
-    async def process_job(self, job: ChatJob):
-        # input job.data is the streamed speech bytes
-        # Node3.sync.append(job.data)
-        job.chat_service.enqueue_speech_bytes_to_play([job.data])
-        yield job
-        # if len(Node3.sync) >= Node3.sync_size:
-        #     audio_chunks = Node3.sync[:Node3.sync_size]
-        #     Node3.sync = Node3.sync[Node3.sync_size:]
-        #     job.chat_service.enqueue_speech_bytes_to_play(audio_chunks)
-        # yield job
-
-class ChatPipeline():
-    def __init__(self):
-        load_dotenv()
-        self.pipeline = Pipeline()
-        self.audio_processor = LocalSpeakerService()
-        self.chat_service = ChatService(self.audio_processor, voice_id="2OviOUQc1JsQRQgNkVBj") # Chales003
-
-    def __enter__(self):
-        return self
-
-    def __exit__(self, exc_type, exc_value, traceback):
-        self.audio_processor.close()
-        self.audio_processor = None
-    
-    def __del__(self):
-        if self.audio_processor:
-            self.audio_processor.close()
-            self.audio_processor = None
-
-    async def start(self):
-        self.node1_queue = asyncio.Queue()
-        self.node2_queue = asyncio.Queue()
-        self.node3_queue = asyncio.Queue()
-        self.sync = []
-        await self.pipeline.add_node(Node1, 1, self.node1_queue, self.node2_queue, sequential_node=True)
-        await self.pipeline.add_node(Node2, 1, self.node2_queue, self.node3_queue, sequential_node=True)
-        await self.pipeline.add_node(Node3, 1, self.node3_queue, None, sequential_node=True)
-
-    async def enqueue(self, prompt):
-        job = ChatJob(prompt, self.chat_service)
-        await self.pipeline.enqueue_job(job)
-
-    async def wait_until_all_jobs_idle(self):
-        # TODO - implement this
-        while True:
-            await asyncio.sleep(0.1)

legacy_to_delete/debug.py

@@ -1,157 +0,0 @@
-import asyncio
-import time
-import traceback
-from chat_pipeline import ChatPipeline
-from clip_transform import CLIPTransform
-from chat_service import ChatService
-from dotenv import load_dotenv
-from text_to_speech_service import TextToSpeechService
-from concurrent.futures import ThreadPoolExecutor
-from local_speaker_service import LocalSpeakerService
-from chat_service import ChatService
-
-def time_sentance_lenghts():
-    load_dotenv()
-
-    print ("Initializing Chat")
-    # audio_processor = AudioStreamProcessor()
-    user_speech_service0 = TextToSpeechService(voice_id="Adam")
-    prompts = [
-        "hello, i am a long sentance, how are you today? Tell me about your shadow self?",
-        "a shorter sentance",
-        "Jung believed that the process of self-discovery and personal growth involves confronting and integrating the shadow self into the conscious mind.",
-        "By doing so, we become more self-aware and more fully actualized individuals.",
-    ]
-
-    print ("Timing prompts\n")
-    for prompt in prompts:
-        start_time = time.time()
-        start_stream_time = time.time()
-        stream = user_speech_service0.stream(prompt)
-        audio = b""
-        for chunk in stream:
-            if chunk is not None:
-                audio += chunk
-        end_stream_time = time.time()
-        from elevenlabs import play
-        start_speech_time = time.time()
-        play(audio)
-        end_speech_time = time.time()
-        end_time = time.time()
-        total_time = (end_time - start_time)
-        stream_time = (end_stream_time - start_stream_time)
-        speech_time = (end_speech_time - start_speech_time)
-        stream_multiple = speech_time / stream_time
-        print(f"Stream time: {stream_time:.4f}, Acutual audio time: {speech_time:.4f}, a multiple of {stream_multiple:.2f}. for prompt: {prompt}")
-
-    print ("\nChat success")
-
-def test_sentance_lenghts():
-    load_dotenv()
-
-    print ("Initializing Chat")
-    audio_processor = LocalSpeakerService()
-    user_speech_service0 = TextToSpeechService(voice_id="Adam")
-    user_speech_service1 = TextToSpeechService(voice_id="Adam")
-    user_speech_service2 = TextToSpeechService(voice_id="Adam")
-    user_speech_service3 = TextToSpeechService(voice_id="Adam")
-
-    prompts = [
-        "hello, i am a long sentance, how are you today? Tell me about your shadow self?",
-        "a shorter sentance",
-        "Jung believed that the process of self-discovery and personal growth involves confronting and integrating the shadow self into the conscious mind.",
-        "By doing so, we become more self-aware and more fully actualized individuals.",
-    ]
-    first = True
-    stream1 = user_speech_service1.stream(prompts[1])
-    stream0 = user_speech_service0.stream(prompts[0])
-    time.sleep(5)
-    stream2 = user_speech_service2.stream(prompts[2])
-    stream3 = user_speech_service3.stream(prompts[3])
-    audio_processor.add_audio_stream(stream0)
-    audio_processor.add_audio_stream(stream1)
-    audio_processor.add_audio_stream(stream2)
-    audio_processor.add_audio_stream(stream3)
-    audio_processor.close()
-    from elevenlabs import generate, play
-    speech0 = generate(prompts[0], voice="Adam")
-    speech1 = generate(prompts[1], voice="Adam")
-    speech2 = generate(prompts[2], voice="Adam")
-    speech3 = generate(prompts[3], voice="Adam")
-    play(speech0)
-    play(speech1)
-    play(speech2)
-    play(speech1)
-    play(speech3)
-    play(speech1)
-    # for prompt in prompts:
-    #     stream = user_speech_service.stream(prompt)
-    #     if first:
-    #         first = False
-    #         time.sleep(5)
-    #     audio_processor.add_audio_stream(stream)
-    audio_processor.close()
-    print ("Chat success")
-
-def run_debug_code():
-    load_dotenv()
-
-    # print ("Initializing CLIP templates")
-    # clip_transform = CLIPTransform()
-    # print ("CLIP success")
-
-    print ("Initializing Chat")
-    # chat_service = ChatService()
-    audio_processor = LocalSpeakerService()
-    chat_service = ChatService(audio_processor, voice_id="2OviOUQc1JsQRQgNkVBj") # Chales003
-
-    user_speech_service = TextToSpeechService(voice_id="Adam")
-
-    # user_speech_service.print_voices() # if you want to see your custom voices
-
-    prompts = [
-        "hello, how are you today?",
-        "tell me about your shadow self?",
-        "hmm, interesting, tell me more about that.",
-        "wait, that is so interesting, what else?",
-    ]
-    for prompt in prompts:
-        print ("")
-        print (f'prompt: "{prompt}"')
-        stream = user_speech_service.stream(prompt)
-        audio_processor.add_audio_stream(stream)
-
-        print ("")
-        print (f'response:')
-        response = chat_service.respond_to(prompt)
-
-    audio_processor.close()
-    print ("Chat success")
-
-async def run_pipeline():
-    load_dotenv()
-
-    try:
-        chat_pipeline = ChatPipeline()
-        await chat_pipeline.start()
-        prompts = [
-            "hello, how are you today?",
-            "tell me about your shadow self?",
-            "hmm, interesting, tell me more about that.",
-            "wait, that is so interesting, what else?",
-        ]
-        for prompt in prompts:
-            await chat_pipeline.enqueue(prompt)
-        await chat_pipeline.wait_until_all_jobs_idle()
-    except KeyboardInterrupt:
-        print("Pipeline interrupted by user")
-    except Exception as e:
-        traceback.print_exc()
-        print(f"An error occurred: {e}")
-
-if __name__ == '__main__':
-    # time_sentance_lenghts()
-    # test_sentance_lenghts()
-    # run_debug_code()
-    asyncio.run(run_pipeline())
-    

legacy_to_delete/pipeline.py

@@ -1,112 +0,0 @@
-import asyncio
-import traceback
-
-class Job:
-    def __init__(self, data):
-        self._id = None
-        self.data = data
-
-
-class Node:
-    # def __init__(self, worker_id: int, input_queue, output_queue, buffer=None, job_sync=None):
-    def __init__(self, worker_id: int, input_queue, output_queue=None, job_sync=None, sequential_node=False ):
-        self.worker_id = worker_id
-        self.input_queue = input_queue
-        self.output_queue = output_queue
-        self.buffer = {}
-        self.job_sync = job_sync
-        self.sequential_node = sequential_node
-        self.next_i = 0
-        self._jobs_dequeued = 0
-        self._jobs_processed = 0
-        # throw an error if job_sync is not None and sequential_node is False
-        if self.job_sync is not None and self.sequential_node == False:
-            raise ValueError('job_sync is not None and sequential_node is False')
-
-    async def run(self):
-        try:
-            while True:
-                job: Job = await self.input_queue.get()
-                self._jobs_dequeued += 1
-                if self.sequential_node == False:
-                    async for job in self.process_job(job):
-                        if self.output_queue is not None:
-                            await self.output_queue.put(job)
-                        if self.job_sync is not None:
-                            self.job_sync.append(job)
-                    self._jobs_processed += 1
-                else:
-                    # ensure that jobs are processed in order
-                    self.buffer[job.id] = job
-                    while self.next_i in self.buffer:
-                        job = self.buffer.pop(self.next_i)
-                        async for job in self.process_job(job):
-                            if self.output_queue is not None:
-                                await self.output_queue.put(job)
-                            if self.job_sync is not None:
-                                self.job_sync.append(job)
-                        self._jobs_processed += 1
-                        self.next_i += 1
-        except Exception as e:
-            print(f"An error occurred in node: {self.__class__.__name__} worker: {self.worker_id}: {e}")
-            traceback.print_exc()
-            raise  # Re-raises the last exception.
-
-    async def process_job(self, job: Job):
-        raise NotImplementedError()
-    
-class Pipeline:
-    def __init__(self):
-        self.input_queues = []
-        self.root_queue = None
-        # self.output_queues = []
-        # self.job_sysncs = []
-        self.nodes= []
-        self.node_workers = {}
-        self.tasks = []
-        self._job_id = 0
-
-    async def add_node(self, node: Node, num_workers=1, input_queue=None, output_queue=None, job_sync=None, sequential_node=False ):
-        # input_queue must not be None
-        if input_queue is None:
-            raise ValueError('input_queue is None')
-        # job_sync nodes must be sequential_nodes
-        if job_sync is not None and sequential_node == False:
-            raise ValueError('job_sync is not None and sequential_node is False')
-        # sequential_nodes should one have 1 worker
-        if sequential_node == True and num_workers != 1:
-            raise ValueError('sequentaial nodes can only have one node (sequential_node is True and num_workers is not 1)')
-        # output queue must not equal input_queue
-        if output_queue == input_queue:
-            raise ValueError('output_queue must not be the same as input_queue')        
-
-        node_name = node.__name__
-        if node_name not in self.nodes:
-            self.nodes.append(node_name)
-
-        # if input_queue is None then this is the root node
-        if len(self.input_queues) == 0:
-            self.root_queue = input_queue
-
-        self.input_queues.append(input_queue)
-
-        for i in range(num_workers):
-            worker_id = i
-            node_worker = node(worker_id, input_queue, output_queue, job_sync, sequential_node)
-            if node_name not in self.node_workers:
-                self.node_workers[node_name] = []
-            self.node_workers[node_name].append(node_worker)
-            task = asyncio.create_task(node_worker.run())
-            self.tasks.append(task)
-
-    async def enqueue_job(self, job: Job):
-        job.id = self._job_id
-        self._job_id += 1
-        await self.root_queue.put(job)
-
-    async def close(self):
-        for task in self.tasks:
-            task.cancel()
-        await asyncio.gather(*self.tasks, return_exceptions=True)
-
-        

tests/test_pipeline.py

@@ -1,86 +0,0 @@
-import asyncio
-import random
-import time
-import unittest
-import sys
-import os
-sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
-
-from legacy_to_delete.pipeline import Pipeline, Node, Job
-
-
-class Node1(Node):
-    async def process_job(self, job: Job):
-        job.data += f' (processed by node 1, worker {self.worker_id})'
-        yield job
-
-
-class Node2(Node):
-    async def process_job(self, job: Job):
-        sleep_duration = 0.08 + 0.04 * random.random()
-        await asyncio.sleep(sleep_duration)
-        job.data += f' (processed by node 2, worker {self.worker_id})'
-        yield job
-
-
-class Node3(Node):
-    async def process_job(self, job: Job):
-        job.data += f' (processed by node 3, worker {self.worker_id})'
-        print(f'{job.id} - {job.data}')
-        yield job
-
-
-class TestPipeline(unittest.TestCase):
-    def setUp(self):
-        pass
-
-    async def _test_pipeline_edge_cases(self):
-        # must have a input queue
-        with self.assertRaises(ValueError):
-            await self.pipeline.add_node(Node1, 1, None, None)
-        # too output queue must not equal from input queue
-        node1_queue = asyncio.Queue()
-        with self.assertRaises(ValueError):
-            await self.pipeline.add_node(Node1, 1, node1_queue, node1_queue)
-
-
-    async def _test_pipeline(self, num_jobs):
-        node1_queue = asyncio.Queue()
-        node2_queue = asyncio.Queue()
-        node3_queue = asyncio.Queue()
-        await self.pipeline.add_node(Node1, 1, node1_queue, node2_queue)
-        await self.pipeline.add_node(Node2, 5, node2_queue, node3_queue)
-        await self.pipeline.add_node(Node3, 1, node3_queue, job_sync=self.job_sync, sequential_node=True)
-        for i in range(num_jobs):
-            job = Job("")
-            await self.pipeline.enqueue_job(job)
-        while True:
-            if len(self.job_sync) == num_jobs:
-                break
-            await asyncio.sleep(0.1)
-        await self.pipeline.close()
-
-    def test_pipeline_edge_cases(self):
-        self.pipeline = Pipeline()
-        self.job_sync = []
-        asyncio.run(self._test_pipeline_edge_cases())
-
-
-    def test_pipeline_keeps_order(self):
-        self.pipeline = Pipeline()
-        self.job_sync = []
-        num_jobs = 100
-        start_time = time.time()
-        asyncio.run(self._test_pipeline(num_jobs))
-        end_time = time.time()
-        print(f"Pipeline processed in {end_time - start_time} seconds.")
-        self.assertEqual(len(self.job_sync), num_jobs)
-        for i, job in enumerate(self.job_sync):
-            self.assertEqual(i, job.id)
-
-
-if __name__ == '__main__':
-    unittest.main()
-    # test = TestPipeline()
-    # test.setUp()
-    # test.test_pipeline()