final

.gitignore

@@ -1 +1,2 @@
-cache
+cache
+.env

2t.py

@@ -0,0 +1,28 @@
+from openai import OpenAI
+def predict(message, history, api_key):
+    print('in predict')
+    client = OpenAI(api_key=api_key)
+    history_openai_format = []
+    for human, assistant in history:
+        history_openai_format.append({"role": "user", "content": human})
+        history_openai_format.append({"role": "assistant", "content": assistant})
+    history_openai_format.append({"role": "user", "content": message})
+    print(history_openai_format)
+    response = client.chat.completions.create(
+        model='gpt-4o',
+        messages=history_openai_format,
+        temperature=1.0,
+        stream=True
+    )
+
+    partial_message = ""
+    for chunk in response:
+        #print(chunk)
+        if chunk.choices[0].delta.content:
+            #print(111, chunk.choices[0].delta.content)
+            partial_message += chunk.choices[0].delta.content
+            yield partial_message
+
+
+for msg in predict('Hi',[],'sk-proj-FuXWodUyfcvTYcc6K9ekT3BlbkFJ2eV3qu7UZOAWlW2eWRLQ'):
+    print(msg)

3t_dropdown copy 2.py

@@ -0,0 +1,100 @@
+import gradio as gr
+from openai import OpenAI
+import time
+import html
+
+def predict(message, history, character, api_key, progress=gr.Progress()):
+    client = OpenAI(api_key=api_key)
+    history_openai_format = []
+    for human, assistant in history:
+        history_openai_format.append({"role": "user", "content": human})
+        history_openai_format.append({"role": "assistant", "content": assistant})
+    history_openai_format.append({"role": "user", "content": message})
+
+    response = client.chat.completions.create(
+        model='gpt-4',
+        messages=history_openai_format,
+        temperature=1.0,
+        stream=True
+    )
+
+    partial_message = ""
+    for chunk in progress.tqdm(response, desc="Generating"):
+        if chunk.choices[0].delta.content:
+            partial_message += chunk.choices[0].delta.content
+            yield partial_message
+        time.sleep(0.01)
+
+def format_history(history):
+    html_content = ""
+    for human, ai in history:
+        human_formatted = html.escape(human).replace('\n', '<br>')
+        html_content += f'<div class="message user-message"><strong>You:</strong> {human_formatted}</div>'
+        if ai:
+            ai_formatted = html.escape(ai).replace('\n', '<br>')
+            html_content += f'<div class="message ai-message"><strong>AI:</strong> {ai_formatted}</div>'
+    return html_content
+
+css = """
+#chat-display {
+    height: 600px;
+    overflow-y: auto;
+    border: 1px solid #ccc;
+    padding: 10px;
+    margin-bottom: 10px;
+}
+.message {
+    margin-bottom: 10px;
+    word-wrap: break-word;
+}
+.user-message {
+    background-color: #e6f3ff;
+    padding: 5px;
+    border-radius: 5px;
+}
+.ai-message {
+    background-color: #f0f0f0;
+    padding: 5px;
+    border-radius: 5px;
+}
+"""
+
+def user(user_message, history, character, api_key):
+    if user_message.strip() == "":
+        return "", history, format_history(history)
+    history.append([user_message, None])
+    formatted_history = format_history(history)
+
+    # Start bot response generation
+    bot_message_generator = predict(user_message, history[:-1], character, api_key)
+    for chunk in bot_message_generator:
+        history[-1][1] = chunk
+        formatted_history = format_history(history)
+        yield "", history, formatted_history
+
+with gr.Blocks(css=css) as demo:
+    gr.Markdown("<h1 style='text-align: center; margin-bottom: 1rem'>My Chatbot</h1>")
+    
+    chat_history = gr.State([])
+    chat_display = gr.HTML(elem_id="chat-display")
+    msg = gr.Textbox(
+        label="Your message", 
+        lines=1,
+        placeholder="Type your message here... (Press Enter to send)"
+    )
+    clear = gr.Button("Clear")
+
+    dropdown = gr.Dropdown(
+        ["Character 1", "Character 2", "Character 3", "Character 4", "Character 5", "Character 6", "Character 7", "Character 8", "Character 9", "Character 10", "Character 11", "Character 12", "Character 13"],
+        label="Characters",
+        info="Select the character that you'd like to speak to",
+        value="Character 1"
+    )
+    api_key = gr.Textbox(type="password", label="OpenAI API Key")
+
+    msg.submit(user, [msg, chat_history, dropdown, api_key], [msg, chat_history, chat_display])
+    clear.click(lambda: ([], []), None, [chat_history, chat_display], queue=False)
+    dropdown.change(lambda x: ([], []), dropdown, [chat_history, chat_display])
+
+demo.queue()
+demo.launch(max_threads=20)

3t_dropdown copy 3.py

@@ -0,0 +1,179 @@
+import gradio as gr
+from openai import OpenAI
+import time
+import html
+
+def predict(message, history, character, api_key, progress=gr.Progress()):
+    client = OpenAI(api_key=api_key)
+    history_openai_format = []
+    for human, assistant in history:
+        history_openai_format.append({"role": "user", "content": human})
+        history_openai_format.append({"role": "assistant", "content": assistant})
+    history_openai_format.append({"role": "user", "content": message})
+
+    response = client.chat.completions.create(
+        model='gpt-4',
+        messages=history_openai_format,
+        temperature=1.0,
+        stream=True
+    )
+
+    partial_message = ""
+    for chunk in progress.tqdm(response, desc="Generating"):
+        if chunk.choices[0].delta.content:
+            partial_message += chunk.choices[0].delta.content
+            yield partial_message
+        time.sleep(0.01)
+
+def format_history(history):
+    html_content = ""
+    for human, ai in history:
+        human_formatted = html.escape(human).replace('\n', '<br>')
+        html_content += f'<div class="message user-message"><strong>You:</strong> {human_formatted}</div>'
+        if ai:
+            ai_formatted = html.escape(ai).replace('\n', '<br>')
+            html_content += f'<div class="message ai-message"><strong>AI:</strong> {ai_formatted}</div>'
+    return html_content
+
+css = """
+#chat-display {
+    height: 600px;
+    overflow-y: auto;
+    border: 1px solid #ccc;
+    padding: 10px;
+    margin-bottom: 10px;
+}
+#chat-display::-webkit-scrollbar {
+    width: 10px;
+}
+#chat-display::-webkit-scrollbar-track {
+    background: #f1f1f1;
+}
+#chat-display::-webkit-scrollbar-thumb {
+    background: #888;
+}
+#chat-display::-webkit-scrollbar-thumb:hover {
+    background: #555;
+}
+.message {
+    margin-bottom: 10px;
+    word-wrap: break-word;
+    overflow-wrap: break-word;
+}
+.user-message, .ai-message {
+    padding: 5px;
+    border-radius: 5px;
+    max-height: 300px;
+    overflow-y: auto;
+}
+.user-message {
+    background-color: #e6f3ff;
+}
+.ai-message {
+    background-color: #f0f0f0;
+}
+.user-message::-webkit-scrollbar, .ai-message::-webkit-scrollbar {
+    width: 5px;
+}
+.user-message::-webkit-scrollbar-thumb, .ai-message::-webkit-scrollbar-thumb {
+    background: #888;
+}
+"""
+
+js = """
+let lastScrollTop = 0;
+let isNearBottom = true;
+
+function updateScroll() {
+    const chatDisplay = document.getElementById('chat-display');
+    if (!chatDisplay) return;
+
+    const currentScrollTop = chatDisplay.scrollTop;
+    const scrollHeight = chatDisplay.scrollHeight;
+    const clientHeight = chatDisplay.clientHeight;
+
+    // Check if user was near bottom before update
+    isNearBottom = (currentScrollTop + clientHeight >= scrollHeight - 50);
+
+    if (isNearBottom) {
+        chatDisplay.scrollTop = scrollHeight;
+    } else {
+        chatDisplay.scrollTop = lastScrollTop;
+    }
+
+    lastScrollTop = chatDisplay.scrollTop;
+}
+
+// Set up a MutationObserver to watch for changes in the chat display
+const observer = new MutationObserver(updateScroll);
+const config = { childList: true, subtree: true };
+
+// Start observing the chat display for configured mutations
+document.addEventListener('DOMContentLoaded', (event) => {
+    const chatDisplay = document.getElementById('chat-display');
+    if (chatDisplay) {
+        observer.observe(chatDisplay, config);
+        
+        // Also update scroll on manual scroll
+        chatDisplay.addEventListener('scroll', function() {
+            lastScrollTop = chatDisplay.scrollTop;
+            isNearBottom = (chatDisplay.scrollTop + chatDisplay.clientHeight >= chatDisplay.scrollHeight - 50);
+        });
+    }
+
+    // Add event listener for Enter key
+    const textbox = document.querySelector('#component-13 input');  // Update this selector if needed
+    if (textbox) {
+        textbox.addEventListener('keydown', function(e) {
+            if (e.key === 'Enter' && !e.shiftKey) {
+                e.preventDefault();
+                document.querySelector('#component-13 button').click();
+            }
+        });
+    }
+});
+"""
+
+def user(user_message, history, character, api_key):
+    if user_message.strip() == "":
+        return "", history, format_history(history)
+    history.append([user_message, None])
+    formatted_history = format_history(history)
+
+    # Start bot response generation
+    bot_message_generator = predict(user_message, history[:-1], character, api_key)
+    for chunk in bot_message_generator:
+        history[-1][1] = chunk
+        formatted_history = format_history(history)
+        yield "", history, formatted_history
+
+with gr.Blocks(css=css, js=js) as demo:
+    gr.Markdown("<h1 style='text-align: center; margin-bottom: 1rem'>My Chatbot</h1>")
+    
+    chat_history = gr.State([])
+    chat_display = gr.HTML(elem_id="chat-display")
+    with gr.Row():
+        msg = gr.Textbox(
+            label="Your message", 
+            lines=1,
+            placeholder="Type your message here... (Press Enter to send)",
+            elem_id="user-input"
+        )
+        send_btn = gr.Button("Send")
+    clear = gr.Button("Clear")
+
+    dropdown = gr.Dropdown(
+        ["Character 1", "Character 2", "Character 3", "Character 4", "Character 5", "Character 6", "Character 7", "Character 8", "Character 9", "Character 10", "Character 11", "Character 12", "Character 13"],
+        label="Characters",
+        info="Select the character that you'd like to speak to",
+        value="Character 1"
+    )
+    api_key = gr.Textbox(type="password", label="OpenAI API Key")
+
+    send_btn.click(user, [msg, chat_history, dropdown, api_key], [msg, chat_history, chat_display])
+    msg.submit(user, [msg, chat_history, dropdown, api_key], [msg, chat_history, chat_display])
+    clear.click(lambda: ([], []), None, [chat_history, chat_display], queue=False)
+    dropdown.change(lambda x: ([], []), dropdown, [chat_history, chat_display])
+
+demo.queue()
+demo.launch(max_threads=20)

3t_dropdown copy.py

@@ -0,0 +1,34 @@
+import gradio as gr
+
+def converse(message, history, character):
+    print("User message:", message)
+    print("Chat history:", history)
+    print("Selected character:", character)
+    
+    # Your chatbot logic here
+    response = f"You said: {message}. You're talking to {character}."
+    
+    return response
+
+def reset(character):
+    return [], []
+
+# Gradio app
+with gr.Blocks() as demo:
+    gr.Markdown(f"<h1 style='text-align: center; margin-bottom: 1rem'>{'My Chatbot'}</h1>")
+    bot = gr.Chatbot(render=False)
+    dropdown = gr.Dropdown(
+        ["Character 1", "Character 2", "Character 3", "Character 4", "Character 5", "Character 6", "Character 7", "Character 8", "Character 9", "Character 10", "Character 11", "Character 12", "Character 13"],
+        label="Characters",
+        info="Select the character that you'd like to speak to",
+        value="Character 1"
+    )
+    chat = gr.ChatInterface(
+        fn=converse,
+        chatbot=bot,
+        additional_inputs=dropdown
+    )
+    dropdown.change(fn=reset, inputs=dropdown, outputs=[bot, chat.chatbot_state])
+
+demo.queue()
+demo.launch()

3t_dropdown.py

@@ -0,0 +1,159 @@
+import gradio as gr
+from openai import OpenAI
+import time
+import html
+
+def predict(message, history, character, api_key, progress=gr.Progress()):
+    client = OpenAI(api_key=api_key)
+    history_openai_format = []
+    for human, assistant in history:
+        history_openai_format.append({"role": "user", "content": human})
+        history_openai_format.append({"role": "assistant", "content": assistant})
+    history_openai_format.append({"role": "user", "content": message})
+
+    response = client.chat.completions.create(
+        model='gpt-4',
+        messages=history_openai_format,
+        temperature=1.0,
+        stream=True
+    )
+
+    partial_message = ""
+    for chunk in progress.tqdm(response, desc="Generating"):
+        if chunk.choices[0].delta.content:
+            partial_message += chunk.choices[0].delta.content
+            yield partial_message
+        time.sleep(0.01)
+
+def format_history(history):
+    html_content = ""
+    for human, ai in history:
+        human_formatted = html.escape(human).replace('\n', '<br>')
+        html_content += f'<div class="message user-message"><strong>You:</strong> {human_formatted}</div>'
+        if ai:
+            ai_formatted = html.escape(ai).replace('\n', '<br>')
+            html_content += f'<div class="message ai-message"><strong>AI:</strong> {ai_formatted}</div>'
+    return html_content
+
+css = """
+#chat-display {
+    height: 600px;
+    overflow-y: auto;
+    border: 1px solid #ccc;
+    padding: 10px;
+    margin-bottom: 10px;
+}
+.message {
+    margin-bottom: 10px;
+    word-wrap: break-word;
+    overflow-wrap: break-word;
+}
+.user-message, .ai-message {
+    padding: 5px;
+    border-radius: 5px;
+    max-height: 300px;
+    overflow-y: auto;
+}
+.user-message {
+    background-color: #e6f3ff;
+}
+.ai-message {
+    background-color: #f0f0f0;
+}
+"""
+
+js = """
+let lastScrollHeight = 0;
+let lastScrollTop = 0;
+let isNearBottom = true;
+
+function updateScroll() {
+    const chatDisplay = document.getElementById('chat-display');
+    if (!chatDisplay) return;
+
+    const newScrollHeight = chatDisplay.scrollHeight;
+    const scrollDifference = newScrollHeight - lastScrollHeight;
+    
+    if (isNearBottom) {
+        chatDisplay.scrollTop = newScrollHeight;
+    } else {
+        chatDisplay.scrollTop = lastScrollTop + scrollDifference;
+    }
+
+    lastScrollHeight = newScrollHeight;
+    lastScrollTop = chatDisplay.scrollTop;
+    
+    isNearBottom = (chatDisplay.scrollTop + chatDisplay.clientHeight >= chatDisplay.scrollHeight - 50);
+}
+
+// Set up a MutationObserver to watch for changes in the chat display
+const observer = new MutationObserver(updateScroll);
+const config = { childList: true, subtree: true };
+
+// Start observing the chat display for configured mutations
+document.addEventListener('DOMContentLoaded', (event) => {
+    const chatDisplay = document.getElementById('chat-display');
+    if (chatDisplay) {
+        observer.observe(chatDisplay, config);
+        
+        // Update scroll state on manual scroll
+        chatDisplay.addEventListener('scroll', function() {
+            lastScrollTop = chatDisplay.scrollTop;
+            isNearBottom = (chatDisplay.scrollTop + chatDisplay.clientHeight >= chatDisplay.scrollHeight - 50);
+        });
+    }
+});
+"""
+
+def user(user_message, history, character, api_key):
+    if user_message.strip() == "":
+        return "", history, format_history(history)
+    history.append([user_message, None])
+    formatted_history = format_history(history)
+    return "", history, formatted_history
+
+def bot(history, character, api_key):
+    if not history:
+        return history, format_history(history)
+    user_message = history[-1][0]
+    bot_message_generator = predict(user_message, history[:-1], character, api_key)
+    for chunk in bot_message_generator:
+        history[-1][1] = chunk
+        yield history, format_history(history)
+
+with gr.Blocks(css=css, js=js) as demo:
+    gr.Markdown("<h1 style='text-align: center; margin-bottom: 1rem'>My Chatbot</h1>")
+    
+    chat_history = gr.State([])
+    chat_display = gr.HTML(elem_id="chat-display")
+    with gr.Row():
+        msg = gr.Textbox(
+            label="Your message", 
+            lines=1,
+            placeholder="Type your message here... (Press Enter to send)"
+        )
+        send_btn = gr.Button("Send")
+    clear = gr.Button("Clear")
+
+    dropdown = gr.Dropdown(
+        ["Character 1", "Character 2", "Character 3", "Character 4", "Character 5", "Character 6", "Character 7", "Character 8", "Character 9", "Character 10", "Character 11", "Character 12", "Character 13"],
+        label="Characters",
+        info="Select the character that you'd like to speak to",
+        value="Character 1"
+    )
+    api_key = gr.Textbox(type="password", label="OpenAI API Key")
+
+    def send_message(user_message, history, character, api_key):
+        return user(user_message, history, character, api_key)
+
+    send_btn.click(send_message, [msg, chat_history, dropdown, api_key], [msg, chat_history, chat_display]).then(
+        bot, [chat_history, dropdown, api_key], [chat_history, chat_display]
+    )
+    msg.submit(send_message, [msg, chat_history, dropdown, api_key], [msg, chat_history, chat_display]).then(
+        bot, [chat_history, dropdown, api_key], [chat_history, chat_display]
+    )
+    clear.click(lambda: ([], []), None, [chat_history, chat_display], queue=False)
+    dropdown.change(lambda x: ([], []), dropdown, [chat_history, chat_display])
+
+demo.queue()
+demo.launch(max_threads=20)

3t_dropdown_CHAT.py

@@ -0,0 +1,152 @@
+import gradio as gr
+from openai import OpenAI
+import time
+import html
+
+def predict(message, history, character, api_key, progress=gr.Progress()):
+    client = OpenAI(api_key=api_key)
+    history_openai_format = []
+    for human, assistant in history:
+        history_openai_format.append({"role": "user", "content": human})
+        history_openai_format.append({"role": "assistant", "content": assistant})
+    history_openai_format.append({"role": "user", "content": message})
+
+    response = client.chat.completions.create(
+        model='gpt-4',
+        messages=history_openai_format,
+        temperature=1.0,
+        stream=True
+    )
+
+    partial_message = ""
+    for chunk in progress.tqdm(response, desc="Generating"):
+        if chunk.choices[0].delta.content:
+            partial_message += chunk.choices[0].delta.content
+            yield partial_message
+        time.sleep(0.01)
+
+def format_history(history):
+    html_content = ""
+    for human, ai in history:
+        human_formatted = html.escape(human).replace('\n', '<br>')
+        html_content += f'<div class="message user-message"><strong>You:</strong> {human_formatted}</div>'
+        if ai:
+            ai_formatted = html.escape(ai).replace('\n', '<br>')
+            html_content += f'<div class="message ai-message"><strong>AI:</strong> {ai_formatted}</div>'
+    return html_content
+
+css = """
+#chat-display {
+    height: 600px;
+    overflow-y: auto;
+    border: 1px solid #ccc;
+    padding: 10px;
+    margin-bottom: 10px;
+}
+#chat-display::-webkit-scrollbar {
+    width: 10px;
+}
+#chat-display::-webkit-scrollbar-track {
+    background: #f1f1f1;
+}
+#chat-display::-webkit-scrollbar-thumb {
+    background: #888;
+}
+#chat-display::-webkit-scrollbar-thumb:hover {
+    background: #555;
+}
+.message {
+    margin-bottom: 10px;
+    max-height: 300px;
+    overflow-y: auto;
+    word-wrap: break-word;
+}
+.user-message {
+    background-color: #e6f3ff;
+    padding: 5px;
+    border-radius: 5px;
+}
+.ai-message {
+    background-color: #f0f0f0;
+    padding: 5px;
+    border-radius: 5px;
+}
+"""
+
+js = """
+function maintainScroll(element_id) {
+    let element = document.getElementById(element_id);
+    let shouldScroll = element.scrollTop + element.clientHeight === element.scrollHeight;
+    let previousScrollTop = element.scrollTop;
+    
+    return function() {
+        if (!shouldScroll) {
+            element.scrollTop = previousScrollTop;
+        } else {
+            element.scrollTop = element.scrollHeight;
+        }
+    }
+}
+
+let scrollMaintainer = maintainScroll('chat-display');
+setInterval(scrollMaintainer, 100);
+
+// Add event listener for Ctrl+Enter and prevent default Enter behavior
+document.addEventListener('DOMContentLoaded', (event) => {
+    const textbox = document.querySelector('#your_message textarea');
+    textbox.addEventListener('keydown', function(e) {
+        if (e.ctrlKey && e.key === 'Enter') {
+            e.preventDefault();
+            document.querySelector('#your_message button').click();
+        } else if (e.key === 'Enter' && !e.shiftKey) {
+            e.preventDefault();
+            const start = this.selectionStart;
+            const end = this.selectionEnd;
+            this.value = this.value.substring(0, start) + "\\n" + this.value.substring(end);
+            this.selectionStart = this.selectionEnd = start + 1;
+        }
+    });
+});
+"""
+
+with gr.Blocks(css=css, js=js) as demo:
+    gr.Markdown("<h1 style='text-align: center; margin-bottom: 1rem'>My Chatbot</h1>")
+    
+    chat_history = gr.State([])
+    chat_display = gr.HTML(elem_id="chat-display")
+    msg = gr.Textbox(
+        label="Your message", 
+        lines=2, 
+        max_lines=10, 
+        placeholder="Type your message here... (Press Ctrl+Enter to send, Enter for new line)",
+        elem_id="your_message"
+    )
+    clear = gr.Button("Clear")
+
+    dropdown = gr.Dropdown(
+        ["Character 1", "Character 2", "Character 3", "Character 4", "Character 5", "Character 6", "Character 7", "Character 8", "Character 9", "Character 10", "Character 11", "Character 12", "Character 13"],
+        label="Characters",
+        info="Select the character that you'd like to speak to",
+        value="Character 1"
+    )
+    api_key = gr.Textbox(type="password", label="OpenAI API Key")
+
+    def user(user_message, history):
+        history.append([user_message, None])
+        return "", history, format_history(history)
+
+    def bot(history, character, api_key):
+        user_message = history[-1][0]
+        bot_message_generator = predict(user_message, history[:-1], character, api_key)
+        for chunk in bot_message_generator:
+            history[-1][1] = chunk
+            yield history, format_history(history)
+
+    msg.submit(user, [msg, chat_history], [msg, chat_history, chat_display]).then(
+        bot, [chat_history, dropdown, api_key], [chat_history, chat_display]
+    )
+    clear.click(lambda: ([], []), None, [chat_history, chat_display], queue=False)
+    dropdown.change(lambda x: ([], []), dropdown, [chat_history, chat_display])
+
+demo.queue()
+demo.launch(max_threads=20)

app copy 2.py

@@ -0,0 +1,67 @@
+import gradio as gr
+from transformers import pipeline, AutoTokenizer, AutoModelForCausalLM
+import numpy as np
+import torch
+
+transcriber = pipeline("automatic-speech-recognition", model="openai/whisper-base.en")
+
+# Load a GPT-2 model for general question answering
+tokenizer = AutoTokenizer.from_pretrained("gpt2-medium", cache_dir="./cache")
+model = AutoModelForCausalLM.from_pretrained("gpt2-medium", cache_dir="./cache")
+
+def transcribe(audio):
+    if audio is None:
+        return "No audio recorded."
+    sr, y = audio
+    y = y.astype(np.float32)
+    y /= np.max(np.abs(y))
+    
+    return transcriber({"sampling_rate": sr, "raw": y})["text"]
+
+def answer(question):
+    input_ids = tokenizer.encode(f"Q: {question}\nA:", return_tensors="pt")
+    
+    # Generate a response
+    with torch.no_grad():
+        output = model.generate(input_ids, max_length=150, num_return_sequences=1, 
+                                temperature=0.7, top_k=50, top_p=0.95)
+    
+    response = tokenizer.decode(output[0], skip_special_tokens=True)
+    
+    # Extract only the answer part
+    answer = response.split("A:")[-1].strip()
+    print(answer)
+    return response
+
+def process_audio(audio):
+    if audio is None:
+        return "No audio recorded.", ""
+    transcription = transcribe(audio)
+    answer_result = answer(transcription)
+    return transcription, answer_result
+
+def clear_all():
+    return None, "", ""
+
+with gr.Blocks() as demo:
+    gr.Markdown("# Audio Transcription and Question Answering")
+    
+    audio_input = gr.Audio(label="Audio Input", sources=["microphone"], type="numpy")
+    transcription_output = gr.Textbox(label="Transcription")
+    answer_output = gr.Textbox(label="Answer Result", lines=10)
+    
+    clear_button = gr.Button("Clear")
+    
+    audio_input.stop_recording(
+        fn=process_audio,
+        inputs=[audio_input],
+        outputs=[transcription_output, answer_output]
+    )
+    
+    clear_button.click(
+        fn=clear_all,
+        inputs=[],
+        outputs=[audio_input, transcription_output, answer_output]
+    )
+
+demo.launch()

app copy 3.py

@@ -0,0 +1,26 @@
+
+from openai import OpenAI
+import gradio as gr
+
+api_key = "sk-proj-FuXWodUyfcvTYcc6K9ekT3BlbkFJ2eV3qu7UZOAWlW2eWRLQ"  # Replace with your key
+client = OpenAI(api_key=api_key)
+
+def predict(message, history):
+    history_openai_format = []
+    for human, assistant in history:
+        history_openai_format.append({"role": "user", "content": human })
+        history_openai_format.append({"role": "assistant", "content":assistant})
+    history_openai_format.append({"role": "user", "content": message})
+  
+    response = client.chat.completions.create(model='gpt-3.5-turbo',
+    messages= history_openai_format,
+    temperature=1.0,
+    stream=True)
+
+    partial_message = ""
+    for chunk in response:
+        if chunk.choices[0].delta.content is not None:
+              partial_message = partial_message + chunk.choices[0].delta.content
+              yield partial_message
+
+gr.ChatInterface(predict).launch()

app copy 4.py

@@ -0,0 +1,43 @@
+from openai import OpenAI
+import gradio as gr
+
+def predict(message, history, api_key):
+    client = OpenAI(api_key=api_key)
+    
+    history_openai_format = []
+    for human, assistant in history:
+        history_openai_format.append({"role": "user", "content": human})
+        history_openai_format.append({"role": "assistant", "content": assistant})
+    history_openai_format.append({"role": "user", "content": message})
+
+    response = client.chat.completions.create(
+        model='gpt-3.5-turbo',
+        messages=history_openai_format,
+        temperature=1.0,
+        stream=True
+    )
+
+    partial_message = ""
+    for chunk in response:
+        if chunk.choices[0].delta.content is not None:
+            partial_message += chunk.choices[0].delta.content
+            yield partial_message
+
+def chat_with_api_key(api_key, message, history):
+    return predict(message, history, api_key)
+
+with gr.Blocks() as demo:
+    api_key = gr.Textbox(label="API Key", placeholder="Enter your API key", type="password")
+    message = gr.Textbox(label="Message")
+    state = gr.State([])
+    output = gr.Textbox(label="Output")
+
+    def update_output(api_key, message, state):
+        response = chat_with_api_key(api_key, message, state)
+        state.append((message, response))
+        return response, state
+
+    btn = gr.Button("Submit")
+    btn.click(update_output, inputs=[api_key, message, state], outputs=[output, state])
+
+    demo.launch()

app copy 5.py

@@ -0,0 +1,100 @@
+from openai import OpenAI
+import gradio as gr
+from transformers import pipeline
+import numpy as np
+
+transcriber = pipeline("automatic-speech-recognition", model="openai/whisper-base.en")
+qa_model = pipeline("question-answering", model="distilbert-base-cased-distilled-squad")
+
+def predict(message, history, api_key):
+    print('in predict')
+    client = OpenAI(api_key=api_key)
+    history_openai_format = []
+    if 0:
+        for human, assistant in history:
+            history_openai_format.append({"role": "user", "content": human})
+            history_openai_format.append({"role": "assistant", "content": assistant})
+    history_openai_format.append({"role": "user", "content": message})
+
+    response = client.chat.completions.create(
+        model='gpt-4o',
+        messages=history_openai_format,
+        temperature=1.0,
+        stream=True
+    )
+
+    partial_message = ""
+    for chunk in response:
+        if chunk.choices[0].delta.content:
+            print(111, chunk.choices[0].delta.content)
+            partial_message += chunk.choices[0].delta.content
+            yield partial_message
+
+def chat_with_api_key(api_key, message, history):
+    print('in chat_with_api_key')
+    accumulated_message = ""
+    for partial_message in predict(message, history, api_key):
+        accumulated_message = partial_message
+        history.append((message, accumulated_message))
+        yield accumulated_message, history
+
+def transcribe(audio):
+    if audio is None:
+        return "No audio recorded."
+    sr, y = audio
+    y = y.astype(np.float32)
+    y /= np.max(np.abs(y))
+    
+    return transcriber({"sampling_rate": sr, "raw": y})["text"]
+
+def answer(transcription):
+    context = "You are chatbot answering general questions"
+    print(transcription)
+    result = qa_model(question=transcription, context=context)
+    print(result)
+    return result['answer']
+
+
+
+def clear_all():
+    return None, "", ""
+
+with gr.Blocks() as demo:
+    with gr.Row():
+        api_key = gr.Textbox(label="API Key", placeholder="Enter your API key", type="password")
+        message = gr.Textbox(label="Message")
+    
+    gr.Markdown("# Audio Transcription and Question Answering")
+    with gr.Row():    
+        audio_input = gr.Audio(label="Audio Input", sources=["microphone"], type="numpy")
+        with gr.Column():
+            transcription_output = gr.Textbox(label="Transcription")
+            clear_button = gr.Button("Clear")
+    state = gr.State([])
+    output = gr.Textbox(label="Output", lines=10)
+
+    def update_output(api_key, audio_input, state):
+        print('in update_output')
+        message = transcribe(audio_input)
+        responses = chat_with_api_key(api_key, message, state)
+        accumulated_response = ""
+        for response, updated_state in responses:
+            accumulated_response = response
+            yield accumulated_response, updated_state
+
+    btn = gr.Button("Submit")
+    btn.click(update_output, inputs=[api_key, message, state], outputs=[output, state])
+
+    audio_input.stop_recording(
+        fn=update_output,
+        inputs=[api_key, audio_input, state],
+        outputs=[output, state]
+    )
+    
+    clear_button.click(
+        fn=clear_all,
+        inputs=[],
+        outputs=[audio_input, transcription_output, output]
+    )
+
+    demo.launch()

app copy 6_blocked_scroll.py

@@ -0,0 +1,102 @@
+import gradio as gr
+from transformers import pipeline
+import numpy as np
+from openai import OpenAI
+
+transcriber = pipeline("automatic-speech-recognition", model="openai/whisper-base.en")
+qa_model = pipeline("question-answering", model="distilbert-base-cased-distilled-squad")
+
+def predict(message, history, api_key):
+    print('in predict')
+    client = OpenAI(api_key=api_key)
+    history_openai_format = []
+    for human, assistant in history:
+        history_openai_format.append({"role": "user", "content": human})
+        history_openai_format.append({"role": "assistant", "content": assistant})
+    history_openai_format.append({"role": "user", "content": message})
+
+    response = client.chat.completions.create(
+        model='gpt-4o',
+        messages=history_openai_format,
+        temperature=1.0,
+        stream=True
+    )
+
+    partial_message = ""
+    for chunk in response:
+        if chunk.choices[0].delta.content:
+            print(111, chunk.choices[0].delta.content)
+            partial_message += chunk.choices[0].delta.content
+            yield partial_message
+
+def chat_with_api_key(api_key, message, history):
+    print('in chat_with_api_key')
+    accumulated_message = ""
+    for partial_message in predict(message, history, api_key):
+        accumulated_message = partial_message
+        history.append((message, accumulated_message))
+        # yield accumulated_message, history
+        yield message,[[message, accumulated_message]]
+
+def transcribe(audio):
+    if audio is None:
+        return "No audio recorded."
+    sr, y = audio
+    y = y.astype(np.float32)
+    y /= np.max(np.abs(y))
+    
+    return transcriber({"sampling_rate": sr, "raw": y})["text"]
+
+def answer(transcription):
+    context = "You are a chatbot answering general questions"
+    result = qa_model(question=transcription, context=context)
+    return result['answer']
+
+def process_audio(audio):
+    if audio is None:
+        return "No audio recorded.", []
+    transcription = transcribe(audio)
+    answer_result = answer(transcription)
+    return transcription, [[transcription, answer_result]]
+
+def update_output(api_key, audio_input, state):
+    print('in update_output')
+    message = transcribe(audio_input)
+    responses = chat_with_api_key(api_key, message, state)
+    accumulated_response = ""
+    for response, updated_state in responses:
+        accumulated_response = response
+        yield accumulated_response, updated_state
+
+def clear_all():
+    return None, "", []
+
+with gr.Blocks() as demo:
+    answer_output = gr.Chatbot(label="Answer Result")
+    with gr.Row():    
+        audio_input = gr.Audio(label="Audio Input", sources=["microphone"], type="numpy")
+        with gr.Column():
+            api_key = gr.Textbox(label="API Key", placeholder="Enter your API key", type="password")
+            transcription_output = gr.Textbox(label="Transcription")
+            clear_button = gr.Button("Clear")
+    state = gr.State([])
+    if 1:
+        audio_input.stop_recording(
+            fn=update_output,
+            inputs=[api_key, audio_input, state],
+            outputs=[transcription_output, answer_output]
+        )
+    if 0:
+        audio_input.stop_recording(
+            fn=process_audio,
+            inputs=[audio_input],
+            outputs=[transcription_output, answer_output]
+        )
+    
+    clear_button.click(
+        fn=clear_all,
+        inputs=[],
+        outputs=[audio_input, transcription_output, answer_output]
+    )
+
+demo.launch()

app copy 6_record_chatbot.py

@@ -0,0 +1,53 @@
+import gradio as gr
+from transformers import pipeline
+import numpy as np
+
+transcriber = pipeline("automatic-speech-recognition", model="openai/whisper-base.en")
+qa_model = pipeline("question-answering", model="distilbert-base-cased-distilled-squad")
+
+def transcribe(audio):
+    if audio is None:
+        return "No audio recorded."
+    sr, y = audio
+    y = y.astype(np.float32)
+    y /= np.max(np.abs(y))
+    
+    return transcriber({"sampling_rate": sr, "raw": y})["text"]
+
+def answer(transcription):
+    context = "You are a chatbot answering general questions"
+    result = qa_model(question=transcription, context=context)
+    return result['answer']
+
+def process_audio(audio):
+    if audio is None:
+        return "No audio recorded.", []
+    transcription = transcribe(audio)
+    answer_result = answer(transcription)
+    return transcription, [[transcription, answer_result]]
+
+def clear_all():
+    return None, "", []
+
+with gr.Blocks() as demo:
+    gr.Markdown("# Audio Transcription and Question Answering")
+    
+    audio_input = gr.Audio(label="Audio Input", sources=["microphone"], type="numpy")
+    transcription_output = gr.Textbox(label="Transcription")
+    answer_output = gr.Chatbot(label="Answer Result")
+    
+    clear_button = gr.Button("Clear")
+    
+    audio_input.stop_recording(
+        fn=process_audio,
+        inputs=[audio_input],
+        outputs=[transcription_output, answer_output]
+    )
+    
+    clear_button.click(
+        fn=clear_all,
+        inputs=[],
+        outputs=[audio_input, transcription_output, answer_output]
+    )
+
+demo.launch()

app copy 6_working.py

@@ -0,0 +1,102 @@
+import gradio as gr
+from transformers import pipeline
+import numpy as np
+from openai import OpenAI
+
+transcriber = pipeline("automatic-speech-recognition", model="openai/whisper-base.en")
+qa_model = pipeline("question-answering", model="distilbert-base-cased-distilled-squad")
+
+def predict(message, history, api_key):
+    print('in predict')
+    client = OpenAI(api_key=api_key)
+    history_openai_format = []
+    for human, assistant in history:
+        history_openai_format.append({"role": "user", "content": human})
+        history_openai_format.append({"role": "assistant", "content": assistant})
+    history_openai_format.append({"role": "user", "content": message})
+
+    response = client.chat.completions.create(
+        model='gpt-4o',
+        messages=history_openai_format,
+        temperature=1.0,
+        stream=True
+    )
+
+    partial_message = ""
+    for chunk in response:
+        if chunk.choices[0].delta.content:
+            print(111, chunk.choices[0].delta.content)
+            partial_message += chunk.choices[0].delta.content
+            yield partial_message
+
+def chat_with_api_key(api_key, message, history):
+    print('in chat_with_api_key')
+    accumulated_message = ""
+    for partial_message in predict(message, history, api_key):
+        accumulated_message = partial_message
+        history.append((message, accumulated_message))
+        # yield accumulated_message, history
+        yield message,[[message, accumulated_message]]
+
+def transcribe(audio):
+    if audio is None:
+        return "No audio recorded."
+    sr, y = audio
+    y = y.astype(np.float32)
+    y /= np.max(np.abs(y))
+    
+    return transcriber({"sampling_rate": sr, "raw": y})["text"]
+
+def answer(transcription):
+    context = "You are a chatbot answering general questions"
+    result = qa_model(question=transcription, context=context)
+    return result['answer']
+
+def process_audio(audio):
+    if audio is None:
+        return "No audio recorded.", []
+    transcription = transcribe(audio)
+    answer_result = answer(transcription)
+    return transcription, [[transcription, answer_result]]
+
+def update_output(api_key, audio_input, state):
+    print('in update_output')
+    message = transcribe(audio_input)
+    responses = chat_with_api_key(api_key, message, state)
+    accumulated_response = ""
+    for response, updated_state in responses:
+        accumulated_response = response
+        yield accumulated_response, updated_state
+
+def clear_all():
+    return None, "", []
+
+with gr.Blocks() as demo:
+    answer_output = gr.Chatbot(label="Answer Result")
+    with gr.Row():    
+        audio_input = gr.Audio(label="Audio Input", sources=["microphone"], type="numpy")
+        with gr.Column():
+            api_key = gr.Textbox(label="API Key", placeholder="Enter your API key", type="password")
+            transcription_output = gr.Textbox(label="Transcription")
+            clear_button = gr.Button("Clear")
+    state = gr.State([])
+    if 1:
+        audio_input.stop_recording(
+            fn=update_output,
+            inputs=[api_key, audio_input, state],
+            outputs=[transcription_output, answer_output]
+        )
+    if 0:
+        audio_input.stop_recording(
+            fn=process_audio,
+            inputs=[audio_input],
+            outputs=[transcription_output, answer_output]
+        )
+    
+    clear_button.click(
+        fn=clear_all,
+        inputs=[],
+        outputs=[audio_input, transcription_output, answer_output]
+    )
+
+demo.launch()

app copy _6_working.py

@@ -0,0 +1,101 @@
+from openai import OpenAI
+import gradio as gr
+from transformers import pipeline
+import numpy as np
+
+transcriber = pipeline("automatic-speech-recognition", model="openai/whisper-base.en")
+qa_model = pipeline("question-answering", model="distilbert-base-cased-distilled-squad")
+
+def predict(message, history, api_key):
+    print('in predict')
+    client = OpenAI(api_key=api_key)
+    history_openai_format = []
+    if 0:
+        for human, assistant in history:
+            history_openai_format.append({"role": "user", "content": human})
+            history_openai_format.append({"role": "assistant", "content": assistant})
+    history_openai_format.append({"role": "user", "content": message})
+
+    response = client.chat.completions.create(
+        model='gpt-4o',
+        messages=history_openai_format,
+        temperature=1.0,
+        stream=True
+    )
+
+    partial_message = ""
+    for chunk in response:
+        if chunk.choices[0].delta.content:
+            print(111, chunk.choices[0].delta.content)
+            partial_message += chunk.choices[0].delta.content
+            yield partial_message
+
+def chat_with_api_key(api_key, message, history):
+    print('in chat_with_api_key')
+    accumulated_message = ""
+    for partial_message in predict(message, history, api_key):
+        accumulated_message = partial_message
+        history.append((message, accumulated_message))
+        yield accumulated_message, history
+
+def transcribe(audio):
+    if audio is None:
+        return "No audio recorded."
+    sr, y = audio
+    y = y.astype(np.float32)
+    y /= np.max(np.abs(y))
+    
+    return transcriber({"sampling_rate": sr, "raw": y})["text"]
+
+
+
+
+def clear_all():
+    return None, "", ""
+
+with gr.Blocks() as demo:
+    #output = gr.Textbox(label="Output", elem_id="output")
+    chatbot = gr.Chatbot(label="Chat Output")
+    with gr.Row():
+        api_key = gr.Textbox(label="API Key", placeholder="Enter your API key", type="password")
+        message = gr.Textbox(label="Message")
+    
+    gr.Markdown("# Audio Transcription and Question Answering")
+    with gr.Row():    
+        audio_input = gr.Audio(label="Audio Input", sources=["microphone"], type="numpy")
+        with gr.Column():
+            transcription_output = gr.Textbox(label="Transcription")
+            clear_button = gr.Button("Clear")
+    state = gr.State([])
+    
+
+    def update_output(api_key, audio_input, state):
+        print('in update_output')
+        message = transcribe(audio_input)
+        responses = chat_with_api_key(api_key, message, state)
+        accumulated_response = ""
+        for response, updated_state in responses:
+            accumulated_response = response
+            yield accumulated_response, updated_state
+
+    btn = gr.Button("Submit")
+    btn.click(update_output, inputs=[api_key, message, state], outputs=[chatbot, state])
+
+    audio_input.stop_recording(
+        fn=update_output,
+        inputs=[api_key, audio_input, state],
+        outputs=[chatbot, state]
+    )
+    
+    clear_button.click(
+        fn=clear_all,
+        inputs=[],
+        outputs=[audio_input, transcription_output, chatbot]
+    )
+    gr.HTML("""
+    <style>
+    #output {
+        overflow-y: auto;
+        max-height: 800px;
+    }""")
+    demo.launch()

app.py

@@ -1,13 +1,42 @@
 import gradio as gr
-from transformers import pipeline, AutoTokenizer, AutoModelForCausalLM
+from transformers import pipeline
 import numpy as np
-import torch
+from openai import OpenAI
 
 transcriber = pipeline("automatic-speech-recognition", model="openai/whisper-base.en")
+qa_model = pipeline("question-answering", model="distilbert-base-cased-distilled-squad")
 
-# Load a GPT-2 model for general question answering
-tokenizer = AutoTokenizer.from_pretrained("gpt2-medium", cache_dir="./cache")
-model = AutoModelForCausalLM.from_pretrained("gpt2-medium", cache_dir="./cache")
+def predict(message, history, api_key):
+    print('in predict')
+    client = OpenAI(api_key=api_key)
+    history_openai_format = []
+    for human, assistant in history:
+        history_openai_format.append({"role": "user", "content": human})
+        history_openai_format.append({"role": "assistant", "content": assistant})
+    history_openai_format.append({"role": "user", "content": message})
+
+    response = client.chat.completions.create(
+        model='gpt-4o',
+        messages=history_openai_format,
+        temperature=1.0,
+        stream=True
+    )
+
+    partial_message = ""
+    for chunk in response:
+        if chunk.choices[0].delta.content:
+            print(111, chunk.choices[0].delta.content)
+            partial_message += chunk.choices[0].delta.content
+            yield partial_message
+
+def chat_with_api_key(api_key, message, history):
+    print('in chat_with_api_key')
+    accumulated_message = ""
+    for partial_message in predict(message, history, api_key):
+        accumulated_message = partial_message
+        history.append((message, accumulated_message))
+        # yield accumulated_message, history
+        yield message,[[message, accumulated_message]]
 
 def transcribe(audio):
     if audio is None:
@@ -18,45 +47,51 @@ def transcribe(audio):
     
     return transcriber({"sampling_rate": sr, "raw": y})["text"]
 
-def answer(question):
-    input_ids = tokenizer.encode(f"Q: {question}\nA:", return_tensors="pt")
-    
-    # Generate a response
-    with torch.no_grad():
-        output = model.generate(input_ids, max_length=150, num_return_sequences=1, 
-                                temperature=0.7, top_k=50, top_p=0.95)
-    
-    response = tokenizer.decode(output[0], skip_special_tokens=True)
-    
-    # Extract only the answer part
-    answer = response.split("A:")[-1].strip()
-    print(answer)
-    return response
+def answer(transcription):
+    context = "You are a chatbot answering general questions"
+    result = qa_model(question=transcription, context=context)
+    return result['answer']
 
 def process_audio(audio):
     if audio is None:
-        return "No audio recorded.", ""
+        return "No audio recorded.", []
     transcription = transcribe(audio)
     answer_result = answer(transcription)
-    return transcription, answer_result
+    return transcription, [[transcription, answer_result]]
+
+def update_output(api_key, audio_input, state):
+    print('in update_output')
+    message = transcribe(audio_input)
+    responses = chat_with_api_key(api_key, message, state)
+    accumulated_response = ""
+    for response, updated_state in responses:
+        accumulated_response = response
+        yield accumulated_response, updated_state
 
 def clear_all():
-    return None, "", ""
+    return None, "", []
 
 with gr.Blocks() as demo:
-    gr.Markdown("# Audio Transcription and Question Answering")
-    
-    audio_input = gr.Audio(label="Audio Input", sources=["microphone"], type="numpy")
-    transcription_output = gr.Textbox(label="Transcription")
-    answer_output = gr.Textbox(label="Answer Result", lines=10)
-    
-    clear_button = gr.Button("Clear")
-    
-    audio_input.stop_recording(
-        fn=process_audio,
-        inputs=[audio_input],
-        outputs=[transcription_output, answer_output]
-    )
+    answer_output = gr.Chatbot(label="Answer Result")
+    with gr.Row():    
+        audio_input = gr.Audio(label="Audio Input", sources=["microphone"], type="numpy")
+        with gr.Column():
+            api_key = gr.Textbox(label="API Key", placeholder="Enter your API key", type="password")
+            transcription_output = gr.Textbox(label="Transcription")
+            clear_button = gr.Button("Clear")
+    state = gr.State([])
+    if 1:
+        audio_input.stop_recording(
+            fn=update_output,
+            inputs=[api_key, audio_input, state],
+            outputs=[transcription_output, answer_output]
+        )
+    if 0:
+        audio_input.stop_recording(
+            fn=process_audio,
+            inputs=[audio_input],
+            outputs=[transcription_output, answer_output]
+        )
     
     clear_button.click(
         fn=clear_all,
@@ -64,4 +99,5 @@ with gr.Blocks() as demo:
         outputs=[audio_input, transcription_output, answer_output]
     )
 
-demo.launch()
+
+demo.launch()

app_Chat_working.py

@@ -0,0 +1,53 @@
+from openai import OpenAI
+import gradio as gr
+
+def predict(message, history, api_key):
+    print('in predict')
+    client = OpenAI(api_key=api_key)
+    history_openai_format = []
+    for human, assistant in history:
+        history_openai_format.append({"role": "user", "content": human})
+        history_openai_format.append({"role": "assistant", "content": assistant})
+    history_openai_format.append({"role": "user", "content": message})
+
+    response = client.chat.completions.create(
+        model='gpt-4o',
+        messages=history_openai_format,
+        temperature=1.0,
+        stream=True
+    )
+
+    partial_message = ""
+    for chunk in response:
+        if chunk.choices[0].delta.content:
+            print(111, chunk.choices[0].delta.content)
+            partial_message += chunk.choices[0].delta.content
+            yield partial_message
+
+def chat_with_api_key(api_key, message, history):
+    print('in chat_with_api_key')
+    accumulated_message = ""
+    for partial_message in predict(message, history, api_key):
+        accumulated_message = partial_message
+        history.append((message, accumulated_message))
+        yield accumulated_message, history
+
+with gr.Blocks() as demo:
+    with gr.Row():
+        api_key = gr.Textbox(label="API Key", placeholder="Enter your API key", type="password")
+        message = gr.Textbox(label="Message")
+    state = gr.State([])
+    output = gr.Textbox(label="Output", lines=10)
+
+    def update_output(api_key, message, state):
+        print('in update_output')
+        responses = chat_with_api_key(api_key, message, state)
+        accumulated_response = ""
+        for response, updated_state in responses:
+            accumulated_response = response
+            yield accumulated_response, updated_state
+
+    btn = gr.Button("Submit")
+    btn.click(update_output, inputs=[api_key, message, state], outputs=[output, state])
+
+    demo.launch()