Delete s

s

@@ -1,218 +0,0 @@
-import asyncio
-import shutil
-import subprocess
-import requests
-import time
-import os
-import logging
-import gradio as gr  # Import Gradio
-
-from langchain_core.prompts import ChatPromptTemplate
-from langchain_groq import ChatGroq
-from langchain.memory import ConversationBufferMemory
-from langchain.prompts import (
-    MessagesPlaceholder,
-    SystemMessagePromptTemplate,
-    HumanMessagePromptTemplate,
-)
-from langchain.chains import LLMChain
-
-from deepgram import (
-    DeepgramClient,
-    DeepgramClientOptions,
-    LiveTranscriptionEvents,
-    LiveOptions,
-    Microphone,
-)
-
-# Configure logging
-logging.basicConfig(level=logging.DEBUG, format='%(asctime)s - %(levelname)s - %(message)s')
-
-class LanguageModelProcessor:
-    def __init__(self):
-        self.llm = ChatGroq(temperature=0, model_name="mixtral-8x7b-32768", groq_api_key="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")
-        self.memory = ConversationBufferMemory(memory_key="chat_history", return_messages=True)
-
-        system_prompt = "You are a conversational assistant named Eliza. Use short, conversational responses as if you're having a live conversation. Your response should be under 20 words. Do not respond with any code, only conversation string"
-        
-        self.prompt = ChatPromptTemplate.from_messages([
-            SystemMessagePromptTemplate.from_template(system_prompt),
-            MessagesPlaceholder(variable_name="chat_history"),
-            HumanMessagePromptTemplate.from_template("{text}")
-        ])
-
-        self.conversation = LLMChain(
-            llm=self.llm,
-            prompt=self.prompt,
-            memory=self.memory
-        )
-
-    def process(self, text):
-        self.memory.chat_memory.add_user_message(text)  # Add user message to memory
-
-        start_time = time.time()
-
-        # Go get the response from the LLM
-        response = self.conversation.invoke({"text": text})
-        end_time = time.time()
-
-        self.memory.chat_memory.add_ai_message(response['text'])  # Add AI response to memory
-
-        elapsed_time = int((end_time - start_time) * 1000)
-        logging.debug(f"LLM ({elapsed_time}ms): {response['text']}")
-        return response['text']
-
-class TextToSpeech:
-    DG_API_KEY = "101eb2de35d298cdf2a15c76b1726d8ce82394d6"
-    MODEL_NAME = "aura-helios-en"  # Example model name, change as needed
-
-    @staticmethod
-    def is_installed(lib_name: str) -> bool:
-        lib = shutil.which(lib_name)
-        return lib is not None
-
-    def speak(self, text):
-        if not self.is_installed("ffplay"):
-            raise ValueError("ffplay not found. Please install FFmpeg to stream audio.")
-
-        DEEPGRAM_URL = f"https://api.deepgram.com/v1/speak?model={self.MODEL_NAME}&encoding=linear16&sample_rate=24000"
-        headers = {
-            "Authorization": f"Token {self.DG_API_KEY}",
-            "Content-Type": "application/json"
-        }
-        payload = {
-            "text": text
-        }
-
-        logging.debug(f"Sending request to Deepgram API with text: {text}")
-
-        player_command = ["ffplay", "-autoexit", "-", "-nodisp"]
-        player_process = subprocess.Popen(
-            player_command,
-            stdin=subprocess.PIPE,
-            stdout=subprocess.DEVNULL,
-            stderr=subprocess.PIPE,  # Capture stderr to check for errors
-        )
-
-        start_time = time.time()  # Record the time before sending the request
-        first_byte_time = None  # Initialize a variable to store the time when the first byte is received
-
-        with requests.post(DEEPGRAM_URL, stream=True, headers=headers, json=payload) as r:
-            logging.debug(f"Response Status Code: {r.status_code}")  # Log the status code
-            if r.status_code != 200:
-                logging.error(f"Error: {r.text}")  # Log the error message if the response is not OK
-                return  # Exit if there's an error
-
-            for chunk in r.iter_content(chunk_size=1024):
-                if chunk:
-                    if first_byte_time is None:  # Check if this is the first chunk received
-                        first_byte_time = time.time()  # Record the time when the first byte is received
-                        ttfb = int((first_byte_time - start_time)*1000)  # Calculate the time to first byte
-                        logging.debug(f"TTS Time to First Byte (TTFB): {ttfb}ms")
-                    player_process.stdin.write(chunk)
-                    player_process.stdin.flush()
-
-        if player_process.stdin:
-            player_process.stdin.close()
-
-        # Check for any errors in stderr
-        stderr_output = player_process.stderr.read()
-        if stderr_output:
-            logging.error(f"Error during audio playback: {stderr_output.decode()}")
-
-        player_process.wait()
-
-async def get_transcript(callback):
-    transcription_complete = asyncio.Event()  # Event to signal transcription completion
-
-    try:
-        DEEPGRAM_API_KEY = "101eb2de35d298cdf2a15c76b1726d8ce82394d6"  # Replace with your actual API key
-        config = DeepgramClientOptions(options={"keepalive": "true"})
-        deepgram: DeepgramClient = DeepgramClient(DEEPGRAM_API_KEY, config)  # Pass the API key here
-
-        dg_connection = deepgram.listen.asynclive.v("1")
-        logging.info("Listening...")
-
-        async def on_message(self, result, **kwargs):
-            sentence = result.channel.alternatives[0].transcript
-            
-            if not result.speech_final:
-                transcript_collector.add_part(sentence)
-            else:
-                transcript_collector.add_part(sentence)
-                full_sentence = transcript_collector.get_full_transcript()
-                if len(full_sentence.strip()) > 0:
-                    full_sentence = full_sentence.strip()
-                    logging.info(f"Human: {full_sentence}")
-                    callback(full_sentence)  # Call the callback with the full_sentence
-                    transcript_collector.reset()
-                    transcription_complete.set()  # Signal to stop transcription and exit
-
-        dg_connection.on(LiveTranscriptionEvents.Transcript, on_message)
-
-        options = LiveOptions(
-            model="nova-2",
-            punctuate=True,
-            language="en-US",
-            encoding="linear16",
-            channels=1,
-            sample_rate=16000,
-            endpointing=300,
-            smart_format=True,
-        )
-
-        await dg_connection.start(options)
-
-        microphone = Microphone(dg_connection.send)
-        microphone.start()
-
-        await transcription_complete.wait()  # Wait for the transcription to complete instead of looping indefinitely
-
-        microphone.finish()
-        await dg_connection.finish()
-
-    except Exception as e:
-        logging.error(f"Could not open socket: {e}")
-        return
-
-class ConversationManager:
-    def __init__(self):
-        self.transcription_response = ""
-        self.llm = LanguageModelProcessor()
-
-    async def main(self):
-        def handle_full_sentence(full_sentence):
-            self.transcription_response = full_sentence
-
-        while True:
-            await get_transcript(handle_full_sentence)
-            
-            if "goodbye" in self.transcription_response.lower():
-                break
-            
-            llm_response = self.llm.process(self.transcription_response)
-
-            tts = TextToSpeech()
-            tts.speak(llm_response)
-
-            self.transcription_response = ""
-
-# Gradio Interface
-def gradio_interface(user_input):
-    manager = ConversationManager()
-    llm_processor = LanguageModelProcessor()
-    response = llm_processor.process(user_input)  # Remove asyncio.run since process is not async
-    tts = TextToSpeech()
-    tts.speak(response)
-    return response
-
-if __name__ == "__main__":
-    # Create and launch Gradio interface
-    demo = gr.Interface(
-        fn=gradio_interface,
-        inputs=gr.Textbox(label="Enter your message"),
-        outputs=gr.Textbox(label="Response"),
-        title="Voice Assistant",
-        description="Interact with the voice assistant. Type your message and listen to the response."
-    ).queue()  # Add queue() for handling multiple requests
-    demo.launch(share=True)