Create app.py

app.py

@@ -0,0 +1,193 @@
+import openai, subprocess
+import gradio as gr
+from gradio.components import Audio, Textbox
+
+import os
+import re
+import tiktoken
+from transformers import GPT2Tokenizer
+tokenizer = GPT2Tokenizer.from_pretrained('gpt2')
+import whisper
+
+import os
+import dropbox
+import datetime
+
+
+ACCESS_TOKEN = os.environ["ACCESS_TOKEN"]
+dbx = dropbox.Dropbox(ACCESS_TOKEN)
+openai.api_key = os.environ["OPENAI_API_KEY"]
+
+initial_message = {"role": "system", "content": 'You are a USMLE Tutor. Respond with ALWAYS layered "bullet points" (listing rather than sentences) to all input with a fun mneumonics to memorize that list. But you can answer up to 1200 words if the user requests longer response.'}
+messages = [initial_message]
+
+answer_count = 0
+
+# set up whisper model
+model = whisper.load_model("base")
+
+
+
+def num_tokens_from_messages(messages, model="gpt-3.5-turbo-0301"):
+    """Returns the number of tokens used by a list of messages."""
+    try:
+        encoding = tiktoken.encoding_for_model(model)
+    except KeyError:
+        encoding = tiktoken.get_encoding("cl100k_base")
+    if model == "gpt-3.5-turbo-0301":  # note: future models may deviate from this
+        num_tokens = 0
+        for message in messages:
+            num_tokens += 4  # every message follows <im_start>{role/name}\n{content}<im_end>\n
+            for key, value in message.items():
+                num_tokens += len(encoding.encode(value))
+                if key == "name":  # if there's a name, the role is omitted
+                    num_tokens += -1  # role is always required and always 1 token
+        num_tokens += 2  # every reply is primed with <im_start>assistant
+        return num_tokens
+    else:
+        raise NotImplementedError(f"""num_tokens_from_messages() is not presently implemented for model {model}.
+See https://github.com/openai/openai-python/blob/main/chatml.md for information on how messages are converted to tokens.""")
+
+def transcribe(audio, text):
+
+    global messages
+    global answer_count
+    transcript = None
+    
+    if audio is not None:
+        audio_file = open(audio, "rb")
+        transcript = openai.Audio.transcribe("whisper-1", audio_file, language="en")
+        # transcript = model.transcribe(audio_file, language="english")
+        messages.append({"role": "user", "content": transcript["text"]})
+        
+    if transcript is None:
+        # Split the input text into sentences
+        sentences = re.split("(?<=[.!?]) +", text)
+    
+        # Initialize a list to store the tokens
+        input_tokens = []
+    
+        # Add each sentence to the input_tokens list
+        for sentence in sentences:
+            # Tokenize the sentence using the GPT-2 tokenizer
+            sentence_tokens = tokenizer.encode(sentence)
+            # Check if adding the sentence would exceed the token limit
+            if len(input_tokens) + len(sentence_tokens) < 1440:
+                # Add the sentence tokens to the input_tokens list
+                input_tokens.extend(sentence_tokens)
+            else:
+                # If adding the sentence would exceed the token limit, truncate it
+                sentence_tokens = sentence_tokens[:1440-len(input_tokens)]
+                input_tokens.extend(sentence_tokens)
+                break
+        # Decode the input tokens into text
+        input_text = tokenizer.decode(input_tokens)
+    
+        # Add the input text to the messages list
+        messages.append({"role": "user", "content": input_text})
+    
+    # Check if the accumulated tokens have exceeded 2096
+    num_tokens = num_tokens_from_messages(messages)
+    if num_tokens > 2096:
+        # Concatenate the chat history
+        chat_transcript = ""
+        for message in messages:
+            if message['role'] != 'system':
+                chat_transcript += f"[ANSWER {answer_count}]" + message['role'] + ": " + message['content'] + "\n\n"
+        # Append the number of tokens used to the end of the chat transcript
+            
+        chat_transcript_copy = chat_transcript
+        chat_transcript_copy += f"Number of tokens used: {num_tokens}\n\n"
+        filename = datetime.datetime.now().strftime("%Y%m%d%H%M_conversation_history.txt")
+        dbx.files_upload(chat_transcript_copy.encode('utf-8'), f'/{filename}', mode=dropbox.files.WriteMode.overwrite, autorename=False, client_modified=None, mute=False)
+        dbx.files_upload(chat_transcript_copy.encode('utf-8'), '/conversation_history_note_backup.txt', mode=dropbox.files.WriteMode.overwrite, autorename=False, client_modified=None, mute=False)
+
+    if num_tokens > 2200:
+        # Reset the messages list and answer counter
+        messages = [initial_message]
+        answer_count = 0
+        input_text = 'input too many tokens to be corrected'
+        # Add the input text to the messages list
+        messages.append({"role": "user", "content": input_text})
+
+    # Increment the answer counter
+    answer_count += 1
+    # Add the answer counter to the system message
+    system_message = openai.ChatCompletion.create(
+        model="gpt-3.5-turbo",
+        messages=messages,
+        max_tokens=2000
+    )["choices"][0]["message"]
+    # Add the system message to the messages list
+    messages.append(system_message)
+
+    # Concatenate the chat history
+    chat_transcript = ""
+    for message in messages:
+        if message['role'] != 'system':
+            chat_transcript += f"[ANSWER {answer_count}]" + message['role'] + ": " + message['content'] + "\n\n"
+    # Append the number of tokens used to the end of the chat transcript
+    
+    with open("conversation_history.txt", "a") as f:
+        f.write(chat_transcript)
+        
+    chat_transcript_copy = chat_transcript
+    chat_transcript_copy += f"Number of tokens used: {num_tokens}\n\n"
+    filename = datetime.datetime.now().strftime("%Y%m%d%H_conversation_history.txt")
+    dbx.files_upload(chat_transcript_copy.encode('utf-8'), f'/{filename}', mode=dropbox.files.WriteMode.overwrite, autorename=False, client_modified=None, mute=False)
+    dbx.files_upload(chat_transcript_copy.encode('utf-8'), '/conversation_history.txt', mode=dropbox.files.WriteMode.overwrite, autorename=False, client_modified=None, mute=False)
+
+    return chat_transcript
+
+
+audio_input = Audio(source="microphone", type="filepath", label="Record your message")
+text_input = Textbox(label="Type your message", max_length=4096)
+
+output_text = gr.outputs.Textbox(label="Response")
+output_audio = Audio()
+
+iface = gr.Interface(
+    fn=transcribe,
+    inputs=[audio_input, text_input],
+    # outputs=(["audio", "text"]),
+    outputs="text",
+    title="Your Excellence Never Abates (YENA)",
+    description="Talk to the AI Tutor YENA",
+    capture_session=True,
+    autoplay=True)
+
+
+# Launch Gradio interface
+iface.launch()
+
+
+
+
+
+
+# from transformers import pipeline, T5Tokenizer
+# import pyttsx3
+# import threading
+# import time
+
+
+
+
+# Set up speech engine
+# engine = pyttsx3.init()
+
+# def speak(text):
+#     # Get the current rate of the engine
+#     rate = engine.getProperty('rate')
+
+#     # Calculate the estimated time in seconds based on the length of the message and the current rate
+#     estimated_time = len(text) / (rate / 10)
+
+#     # Speak the text using the text-to-speech engine
+    
+#     engine.say(text)
+#     engine.runAndWait()
+#     if engine._inLoop:
+#         # Wait for the speech engine to finish speaking
+#         time.sleep(estimated_time*1.5)
+#         engine.endLoop()