intitial commit

.gitignore

@@ -0,0 +1,4 @@
+environment.yml
+.DS_Store
+.env
+Dockerfile

app.py

@@ -0,0 +1,336 @@
+import gradio as gr
+from dotenv import load_dotenv
+import os
+import pandas as pd
+import uuid
+from datetime import datetime
+
+
+
+use_local_llm = False
+
+
+sentences_URL = "https://docs.google.com/spreadsheets/d/1w_MHR9coQQ7egMWbqMP8HkEysr31gKnqH2ysBzjQYfk/edit#gid=1183579691"
+csv_sentence_URL = sentences_URL.replace('/edit#gid=', '/export?format=csv&gid=')
+
+def get_sheets_sentences():
+
+    try:
+        csv_sheets_sentences_df = pd.read_csv(csv_sentence_URL)
+        print("### Successfully read CSV file from sheets")
+    except:
+        print("### Error reading CSV file from sheets")
+        return None
+
+    return csv_sheets_sentences_df
+
+# Define a function to set the client based on the selection
+def set_client(selection):
+
+    global use_local_llm
+
+    if selection == "Llama3":
+        import ollama
+        client = ollama.Client(host='http://10.236.173.45:11434')
+        use_local_llm = True
+        print("Using Llama3")
+        gr.Info(f"Using {selection}. Type in the chatbox to start.")
+        print(client.chat( # prime the model
+            model='llama3:70b',
+            messages=[{"role": "system", "content": "Get ready."}],
+            keep_alive= -1, # to prevent reloading model
+            options = {
+                'num_predict':1
+            }
+        ))
+        print("### Llama3 model loaded")
+    else:
+        from openai import OpenAI
+        
+        # Load environment variables from .env file
+        load_dotenv()
+        client = OpenAI(
+            api_key=os.getenv('OPENAI_API_KEY')
+        )
+        #OPEN_AI_KEY = ""
+        #client = OpenAI(api_key=OPEN_AI_KEY)  # gross
+        use_local_llm = False
+        print("Using OpenAI")
+        gr.Info(f"Using {selection}. Type in the chatbox to start.")
+    return client
+
+# Initialise the client (default to OpenAI)
+client = set_client("OpenAI")
+
+#file_path = 'anki_japanese_english_pairs.csv'
+file_path = 'GPT generated Japanese English sentence pairs - Sheet2.csv'
+
+def get_sentence_pair(level):
+    
+    # Load the CSV file
+    #df = pd.read_csv(file_path)
+
+    df = get_sheets_sentences()
+
+    print(df.head())
+
+    if level == None:
+        level = 'Easy'
+        print("### Level not found - default to Easy")
+
+    # Filter the DataFrame based on the desired level
+    filtered_df = df[df['Difficulty'] == level]
+
+    # If the filtered DataFrame is empty, return None
+    if filtered_df.empty:
+        print("### No sentences found for this level")
+        return None
+    
+    print(filtered_df.head())
+
+    # Select a random row from the filtered DataFrame
+    random_row = filtered_df.sample(1)
+
+    # Extract the Japanese and English sentences
+    japanese_sentence = str(random_row.iloc[0, 0])
+    english_sentence = str(random_row.iloc[0, 1])
+
+    print(f"### Level: {level}")
+    print(f"### Japanese sentence: {japanese_sentence}")
+    print(f"### English sentence: {english_sentence}")
+
+    return (japanese_sentence, english_sentence)
+
+def generate_system_prompt(chat_id, japanese_sentence, english_sentence):
+
+    # removed_from_system_prompt = f'''
+
+    #  - Do not respond in Japanese - always respond in English even if the student uses Japanese with you.
+    #  '''
+
+    system_prompt = f'''
+    **Translation Training Session**
+
+    **Feedback form:**
+    [Feedback Form](https://docs.google.com/forms/d/e/1FAIpQLSdqllTmXz8tEGsXSQnX1dSxbOTHxsAeBLepdDYj8DNSTYautw/viewform?usp=pp_url&entry.1679182700={chat_id})
+
+    You are an assistant to help with Japanese to English translation practice. 
+    Help students enhance their translation skills.
+
+    **Guidelines:**
+    - Use hints to improve the translation iteratively.
+    - Do not give the correct translation (model answer) directly. Let the student work it out.
+    - Provide your feedback as a list where possible.
+   
+    - Where the translation is correct, don't ask for another attempt. Translations are correct where they are grammatically accurate and convey the same meaning as the model answer.
+    - When the translation is correct, always provide the user with the feedback form.
+    - Where possible make any corrections bold.
+    - Always explain any corrections you make clearly and concisely.
+    - Don't say you are making a correction if you are not changing anything about the provided translation.
+    - When giving hints, don't reveal the correct translation and don't repeat the same hint.
+    - When asked about the words, give the translation for each word individually, not the full sentence translation.
+    - Use Japanese quotes for Japanese text. I.e. 「問題」.
+    - Don't ask whether you should provide the feedback form, just provide it when the translation is correct.
+    - Do not ask if the student would like the feedback form, just provide it.
+
+    **Japanese Sentence to Translate:**
+    "{japanese_sentence}"
+
+    **English Sentence model answer:**
+    "{english_sentence}"
+
+    **Execute the following tasks:**
+    1. Welcome the student. Ask the student to translate the Japanese Sentence to English. Show the Japanese sentence to the student.
+    2. Suggest simple corrections (i.e., spelling, grammar, and punctuation). Where relevant, provide hints to improve the translation.
+    3. If the translation is correct or or there are only minor errors, go to step 4. If not, ask for another translation attempt for the same sentence until the translation is correct (or close). 
+    4. When the translation is correct or the student gives up, provide the user with the feedback form (to get their thoughts on the chat). It is very important to show this form to the student.
+    
+    **Feedback form:**
+    [Feedback Form](https://docs.google.com/forms/d/e/1FAIpQLSdqllTmXz8tEGsXSQnX1dSxbOTHxsAeBLepdDYj8DNSTYautw/viewform?usp=pp_url&entry.1679182700={chat_id})
+    '''
+
+    return system_prompt
+
+
+def print_chat(openai_format):
+    for message in openai_format:
+        print(f"{message['role'].capitalize()}: {message['content']}")
+
+
+def predict(message, history, chat_id, sentence_pair, level='Easy'):
+
+    print("### initial predict chat_id:", chat_id)
+    print("history length", len(history))
+    print("### sentence_pair:", sentence_pair)
+
+    # if not chat_id:
+    #     chat_id = str(uuid.uuid4())[:8]
+
+    if not sentence_pair:
+        print("### Sentence not found - getting new sentence pair")
+        japanese_sentence, english_sentence = get_sentence_pair(level=level)
+    else:
+        japanese_sentence, english_sentence = sentence_pair[0], sentence_pair[1]
+
+    history_openai_format = [{"role": "system", "content": generate_system_prompt(chat_id, japanese_sentence, english_sentence)}]
+ 
+    for human, assistant in history:#[1:]:
+        history_openai_format.append({"role": "user", "content": human })
+        history_openai_format.append({"role": "assistant", "content":assistant})
+    history_openai_format.append({"role": "user", "content": message})
+
+    if use_local_llm:
+        stream = client.chat(
+            model='llama3:70b',
+            messages=history_openai_format,
+            stream=True,
+            keep_alive= -1, # to prevent reloading model
+            options = {
+                #'temperature': 1.5, # very creative
+                'temperature': 0.2 # very conservative (good for correct syntax)
+
+            }
+        )
+
+        partial_message = ""
+        response_text = ""
+        for chunk in stream:
+            response_text += chunk['message']['content'] # steve added for full response text for export
+            partial_message = partial_message + chunk['message']['content']
+            yield partial_message
+    else:
+  
+        response = client.chat.completions.create(
+            model='gpt-3.5-turbo',
+            messages= history_openai_format,
+            temperature=0.2,
+            stream=True
+        )
+
+        partial_message = ""
+        response_text = ""
+        for chunk in response:
+            if chunk.choices[0].delta.content is not None:
+                response_text += chunk.choices[0].delta.content # steve added for full response text for export
+                partial_message = partial_message + chunk.choices[0].delta.content
+                yield partial_message
+
+    # after display to user, for export and print
+    history_openai_format.append({"role": "assistant", "content": response_text})
+
+    #print("### final chat_id:", chat_id)
+    export_conversation(history_openai_format, chat_id)
+    print_chat(history_openai_format)
+
+    #return chat_id
+
+css = """
+h1 {
+    text-align: center;
+    display: block;
+}
+"""
+
+def generate_unique_id():
+    return str(uuid.uuid4())[:8]
+
+# TODO: Add LLM type to messages; add difficulty level to messages
+def export_conversation(history_openai_format, chat_id):
+
+    export_file_name = f"chat_{chat_id}.txt"
+
+    with open(export_file_name, "a") as file:
+
+        if file.tell() == 0:  
+            timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+            file.write(f"Chat started: {chat_id} {timestamp}\n\n")
+
+        for message in history_openai_format:
+            #timestamp = datetime.now().strftime("%H:%M:%S")
+            #file.write(f"{timestamp}\t{message['role'].capitalize()}: {message['content']}\n")
+            file.write(f"{message['role'].capitalize()}: {message['content']}\n")
+
+def reset(input):
+    return [], []
+
+with gr.Blocks(css=css) as app:
+    gr.Markdown("""# <center><font size=8>{}</center>""".format("Hi, it's Tammy!"))
+    
+    with gr.Row():
+
+        with gr.Column(scale=1):
+
+            gr.Markdown("""## Instructions""")
+            gr.Markdown("""
+                **Welcome to Tammy!**
+                - Type your message in the textbox and press enter or Submit to send.  
+                - Click Retry if the chatbot is stuck or the response is a little strange.
+                - Your chats are recorded for quality assurance and training purposes. Behave.
+            """)
+
+
+            difficulty_level = gr.Dropdown(choices=["Easy", "Intermediate", "Advanced"], value="Easy", label="Difficulty Level", interactive=True)
+            # llm_type = gr.Dropdown(choices=["Llama3", "OpenAI"], value="OpenAI", label="Choose LLM Type")
+
+            # Define a function to handle changes in dropdown
+            # def update_client(llm):
+            #     global client
+            #     client = set_client(llm)
+
+            # Button to apply the change
+            # apply_btn = gr.Button("Apply")
+            # apply_btn.click(fn=update_client, inputs=llm_type, outputs=None)
+
+            # gr.Markdown(f"""[Click here](https://docs.google.com/forms/d/e/1FAIpQLSdqllTmXz8tEGsXSQnX1dSxbOTHxsAeBLepdDYj8DNSTYautw/viewform?usp=pp_url&entry.1679182700={chat_id})
+            # """)
+        
+        with gr.Column(scale=3):
+
+            bot = gr.Chatbot(render=False, height=550)
+             
+            sentence_pair_state = gr.State(get_sentence_pair(level=difficulty_level.value))
+            chat_id = gr.State(generate_unique_id)
+
+            #print("### ui chat_id:", chat_id)
+
+            chat = gr.ChatInterface(
+                predict, 
+                chatbot=bot,
+                additional_inputs=[chat_id, sentence_pair_state, difficulty_level],
+                examples=[
+                    ["Help me start", None, None, None], 
+                    ["Give me a hint", None, None, None], 
+                    ["I need more help", None, None, None], 
+                    ["What do you mean?", None, None, None], 
+                    ["What do the words mean?", None, None, None],
+                    ["Let's stop now", None, None, None]
+                ],
+            )
+
+            difficulty_level.input(fn=reset, inputs=difficulty_level, outputs=[bot, chat.chatbot_state])
+
+            def update_sentence_pair(level):
+
+                global sentence_pair_state
+                gr.Info(f"New {level} sentence selected. Type in the chatbox to start.")
+                print("### updating level:", level)
+                sentence_pair = get_sentence_pair(level)
+                print("### new sentence pair:", sentence_pair)
+                sentence_pair_state = gr.State(sentence_pair)
+                return sentence_pair
+
+            # def clear_chat_history(level):
+            #     bot.clear()
+            #     gr.Info(f"New {level} sentence selected. Type in the chatbox to start.")
+            #     print("### updating level:", level)
+            #     sentence_pair.data = get_sentence_pair(level=level)
+
+            #difficulty_level.change(clear_chat_history, inputs=difficulty_level, outputs=sentence_pair)
+
+
+            difficulty_level.change(update_sentence_pair, inputs=difficulty_level, outputs=sentence_pair_state)
+
+        
+app.launch()
+
+

requirements.txt

@@ -0,0 +1,5 @@
+gradio==4.27.0
+ollama==0.1.8
+openai==1.23.3
+pandas==2.2.2
+python-dotenv==1.0.1