Update app.py

app.py

@@ -3,151 +3,140 @@ import gradio as gr
 from gradio.components import Audio, Textbox
 import os
 import re
+import tiktoken
 from transformers import GPT2Tokenizer
 import whisper
 import pandas as pd
 from datetime import datetime, timezone, timedelta
 import notion_df
-import tiktoken
+import concurrent.futures
 
-openai.api_key = os.environ["OPENAI_API_KEY"]
-tokenizer = GPT2Tokenizer.from_pretrained('gpt2')
+# Define the tokenizer and model
+tokenizer = GPT2Tokenizer.from_pretrained('gpt2-medium')
+model = openai.api_key = os.environ["OPENAI_API_KEY"]
 
+# Define the initial message and messages list
 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]
 
+# Define the answer counter
 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.""")
+# Define the Notion API key
+API_KEY = os.environ["API_KEY"]
 
 def transcribe(audio, text):
     global messages
     global answer_count
-    transcript = {'text': ''}
-    input_text = []
+
+    # Transcribe the audio if provided
     if audio is not None:
         audio_file = open(audio, "rb")
         transcript = openai.Audio.transcribe("whisper-1", audio_file, language="en")
         messages.append({"role": "user", "content": transcript["text"]})
 
+    # Tokenize the text input
     if text is not 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})
 
-        # Tokenize the sentences using the GPT-2 tokenizer
-        sentence_tokens = [tokenizer.encode(sentence) for sentence in sentences]
-
-        # Flatten the list of tokens
-        input_tokens = [token for sentence in sentence_tokens for token in sentence]
-
-        # Check if adding the input tokens would exceed the token limit
-        num_tokens = num_tokens_from_messages(messages)
-        if num_tokens + len(input_tokens) > 2200:
-            # Reset the messages list and answer counter
-            messages = [initial_message]
-            answer_count = 0
-            input_text = 'Can you click the Submit button one more time? (say Yes)'
-
-        else:
-            # Add the input tokens to the messages list
-            input_text = tokenizer.decode(input_tokens)
 
-    messages.append({"role": "user", "content": transcript["text"] + input_text})
-    
-    # Check if the accumulated tokens have exceeded the limit
-    num_tokens = num_tokens_from_messages(messages)
+    # Check if the accumulated tokens have exceeded 2096
+    num_tokens = sum(len(tokenizer.encode(message["content"])) for message in 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"
+        chat_transcript = "\n\n".join([f"[ANSWER {answer_count}]{message['role']}: {message['content']}" for message in messages if message['role'] != 'system'])
+
         # Append the number of tokens used to the end of the chat transcript
-        chat_transcript += f"Number of tokens used: {num_tokens}\n\n"
-        
+        chat_transcript += f"\n\nNumber of tokens used: {num_tokens}\n\n"
+
         # Get the current time in Eastern Time (ET)
         now_et = datetime.now(timezone(timedelta(hours=-5)))
         # Format the time as string (YY-MM-DD HH:MM)
         published_date = now_et.strftime('%m-%d-%y %H:%M')
-        
+
         # Upload the chat transcript to Notion
         df = pd.DataFrame([chat_transcript])
-        notion_df.upload(df, 'https://www.notion.so/personal-5e3978680ca848bda844452129955138?pvs=4', title=str(published_date), api_key=API_KEY)
-        
+        notion_df.upload(df, 'https://www.notion.so/US-62e861a0b35f43da8ef9a7789512b8c2?pvs=4', title=str(published_date), api_key=API_KEY)
+
         # Reset the messages list and answer counter
         messages = [initial_message]
         answer_count = 0
-
-    # Increment the answer counter
-    answer_count += 1
+    else:
+        # Increment the answer counter
+        answer_count += 1
 
     # Generate the system message using the OpenAI API
-    system_message = openai.ChatCompletion.create(
-        model="gpt-3.5-turbo",
-        messages=messages,
-        max_tokens=2000
-    )["choices"][0]["message"]
-
-
+    with concurrent.futures.ThreadPoolExecutor() as executor:
+        prompt = [{"text": f"{message['role']}: {message['content']}\n\n"} for message in messages]
+        system_message = openai.ChatCompletion.create(
+            model="gpt-3.5-turbo",
+            messages=messages,
+            max_tokens=2000
+        )["choices"][0]["message"]
+    # Wait for the completion of the OpenAI API call
+        
     # Add the system message to the messages list
-    messages.append({"role": "system", "content": system_message})
-
+    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"
+    chat_transcript = "\n\n".join([f"[ANSWER {answer_count}]{message['role']}: {message['content']}" for message in messages if message['role'] != 'system'])
     
     # Append the number of tokens used to the end of the chat transcript
-    num_tokens = num_tokens_from_messages(messages)
+    chat_transcript += f"\n\nNumber of tokens used: {num_tokens}\n\n"
     
-    # Get the current time in Eastern Time (ET)
-    now_et = datetime.now(timezone(timedelta(hours=-5)))
-    # Format the time as string (YY-MM-DD HH:MM)
-    published_date = now_et.strftime('%m-%d-%y %H:%M')
-    chat_transcript_copy = chat_transcript
-    chat_transcript_copy += f"Number of tokens used: {num_tokens}\n\n"
+    # Save the chat transcript to a file
+    with open("conversation_history.txt", "a") as f:
+        f.write(chat_transcript)
     
     # Upload the chat transcript to Notion
-    df = pd.DataFrame([chat_transcript_copy])
-    notion_df.upload(df, 'https://www.notion.so/personal-5e3978680ca848bda844452129955138?pvs=4', title=str(published_date), api_key=API_KEY)
+    now_et = datetime.now(timezone(timedelta(hours=-5)))
+    published_date = now_et.strftime('%m-%d-%y %H:%M')
+    df = pd.DataFrame([chat_transcript])
+    notion_df.upload(df, 'https://www.notion.so/US-62e861a0b35f43da8ef9a7789512b8c2?pvs=4', title=str(published_date), api_key=API_KEY)
     
     # Return the chat transcript
     return chat_transcript
-
+    
+# Define the input and output components for Gradio
 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()
 
+# Define the Gradio interface
 iface = gr.Interface(
     fn=transcribe,
     inputs=[audio_input, text_input],
-    outputs="text",
-    title="YENA",
-    description="Tutor YENA")
-
-# Launch Gradio interface
-iface.launch()
-
+    outputs=[output_text],
+    title="USMLE Tutor Chatbot",
+    description="A chatbot for USMLE test preparation",
+    theme="compact",
+    layout="vertical",
+    allow_flagging=False
+    )
+
+# Run the Gradio interface
+iface.launch()