falta guardar bien

app.py

@@ -14,6 +14,11 @@ import gspread
 from  groq import Client
 import random, string
 
+from pydrive.auth import GoogleAuth
+from pydrive.drive import GoogleDrive
+import json
+
+
 # Initialize Google Sheets client
 client = init_google_sheets_client()
 sheet = client.open(google_sheets_name)
@@ -68,48 +73,103 @@ chat_history = []
 model_history = []
 
 
-# Function to save comment and score
-def save_comment_score(chat_responses, score, comment, story_name, user_name, system_prompt, models):
+
+
+
+
+from pydrive.auth import GoogleAuth
+from pydrive.drive import GoogleDrive
+import json
+
+# Autenticación y creación del cliente de Google Drive
+gauth = GoogleAuth()
+gauth.LocalWebserverAuth()  # Esto abrirá una ventana del navegador para autenticarse
+drive = GoogleDrive(gauth)
+
+def save_comment_score(score, comment, story_name, user_name, system_prompt, models):
     print("Saving comment and score...")
-    print(chat_responses)
+    print(chat_history)
     print(model_history)
     full_chat_history = ""
 
-    # Create formatted chat history with roles
-    #and model in model_history
-    for message in chat_responses:
-        print(message['role'])
-        if message['role'] == 'user':  # User message
-            full_chat_history += f"User: {message['content']}\n"
-        if message['role'] == 'assistant':  # Assistant message
-            full_chat_history += f"Model:{model_history.pop(0)} Assistant: {message['content']}\n"
-
-    timestamp = datetime.now(timezone.utc) - timedelta(hours=3)  # Adjust to GMT-3
-    timestamp_str = timestamp.strftime("%Y-%m-%d %H:%M:%S")
-    model_name = (' ').join(models)
-    # Append data to local data storage
-    print(full_chat_history)
-    data.append([
-        timestamp_str,
-        user_name,
-        model_name,
-        system_prompt,
-        story_name,
-        full_chat_history,
-        score,
-        comment
-    ])
-
-    # Append data to Google Sheets
-    try:
-        user_sheet = client.open(google_sheets_name).worksheet(user_name)
-    except gspread.exceptions.WorksheetNotFound:
-        user_sheet = client.open(google_sheets_name).add_worksheet(title=user_name, rows="100", cols="20")
+    # Save all_answers to Google Drive
+    file_name = 'all_answers.json'
+    
+    # Check if the file already exists in Google Drive
+    file_list = drive.ListFile({'q': f"title='{file_name}' and trashed=false"}).GetList()
+    if file_list:
+        # File exists, download it
+        gfile = file_list[0]
+        gfile.GetContentFile(file_name)
+        with open(file_name, 'r') as json_file:
+            existing_data = json.load(json_file)
+        existing_data.append(all_answers)
+    else:
+        # File does not exist, create new data
+        existing_data = [all_answers]
+    
+    # Save updated data to the file
+    with open(file_name, 'w') as json_file:
+        json.dump(existing_data, json_file)
+    
+    # Upload the file to Google Drive
+    gfile = drive.CreateFile({'title': file_name})
+    gfile.SetContentFile(file_name)
+    gfile.Upload()
+    print(f"File {file_name} uploaded to Google Drive.")
     
-    user_sheet.append_row([timestamp_str, user_name, model_name, system_prompt, story_name, full_chat_history, score, comment])
+    return None
+
+
+
+
 
-    df = pd.DataFrame(data, columns=["Timestamp", "User Name", "Model Name", "System Prompt", "Story Name", "Chat History", "Score", "Comment"])
-    return df[["Chat History", "Score", "Comment"]], gr.update(value="")  # Show only the required columns and clear the comment input box
+
+
+
+
+# Function to save comment and score
+#def save_comment_score(score, comment, story_name, user_name, system_prompt, models):
+#    print("Saving comment and score...")
+#    print(chat_history)
+#    print(model_history)
+#    full_chat_history = ""
+#
+#    # Create formatted chat history with roles
+#    #and model in model_history
+#    for message in chat_history:
+#        print(message['role'])
+#        if message['role'] == 'user':  # User message
+#            full_chat_history += f"User: {message['content']}\n"
+#        if message['role'] == 'assistant':  # Assistant message
+#            full_chat_history += f"Model:{model_history.pop(0)} Assistant: {message['content']}\n"
+#
+#    timestamp = datetime.now(timezone.utc) - timedelta(hours=3)  # Adjust to GMT-3
+#    timestamp_str = timestamp.strftime("%Y-%m-%d %H:%M:%S")
+#    model_name = (' ').join(models)
+#    # Append data to local data storage
+#    print(full_chat_history)
+#    data.append([
+#        timestamp_str,
+#        user_name,
+#        model_name,
+#        system_prompt,
+#        story_name,
+#        full_chat_history,
+#        score,
+#        comment
+#    ])
+#
+#    # Append data to Google Sheets
+#    try:
+#        user_sheet = client.open(google_sheets_name).worksheet(user_name)
+#    except gspread.exceptions.WorksheetNotFound:
+#        user_sheet = client.open(google_sheets_name).add_worksheet(title=user_name, rows="100", cols="20")
+#    
+#    user_sheet.append_row([timestamp_str, user_name, model_name, system_prompt, story_name, full_chat_history, score, comment])
+#
+#    df = pd.DataFrame(data, columns=["Timestamp", "User Name", "Model Name", "System Prompt", "Story Name", "Chat History", "Score", "Comment"])
+#    return df[["Chat History", "Score", "Comment"]], gr.update(value="")  # Show only the required columns and clear the comment input box
 
 
 # Function to handle interaction with model
@@ -157,7 +217,6 @@ Here is the story:
            print("Story title does not match.")
 
 
-
 #i=[story_dropdown, model_dropdown, system_prompt_dropdown],
 #o=[chatbot_output, chat_history_json, data_table, selected_story_textbox])
 #recibo varios respuestas las muestro nomas, agrego al contexto solo la que se
@@ -165,32 +224,37 @@ Here is the story:
 
 def send_multiple_selected_story(title, models, system_prompt):
     global model_history
-    global chatbot_aswser_list
+    global chatbot_answser_list
+    global all_answers
     resp_list = []
     print(models)
     #iterate over words
-    shuffle_models = randomize_key_order(all_models)
-    for index, model in enumerate(shuffle_models):
-       if model in models:
-           #respuesta consulta,
-           resp, context, _ = send_selected_story(title, model, system_prompt)
-           chatbot_aswser_list[alphabet[index]] = {'response': resp, 'model': model}
-           try:
-                print(resp)
-                resp_list.append(gr.Chatbot(value=[resp], visible=True, type='messages'))
-           except gr.exceptions.Error:
-                print(f"error for en modelo {model}")
-       else:
-            try:
-                resp_list.append(gr.Chatbot(type='messages', visible=False))
-            except gr.exceptions.Error:
-                print(f"error, else en modelo {model}")
-
+    #shuffle_models = randomize_key_order(all_models)
+    random.shuffle(models)
+    print(f"models shuffled: {models}")
+    for index, model in enumerate(models):
+        resp, context, _ = send_selected_story(title, model, system_prompt)
+        chatbot_answser_list[alphabet[index]] = {'response': resp, 'model': model}
+        try:
+             print(resp)
+             resp_list.append(gr.Chatbot(value=[resp], visible=True, type='messages'))
+        except gr.exceptions.Error:
+             print(f"error for en modelo {model}")
+    
+    
+    rest = [model for model in model_list if model not in models]
+    for model in rest:
+        try:
+            resp_list.append(gr.Chatbot(type='messages', visible=False))
+        except gr.exceptions.Error:
+            print(f"error, else en modelo {model}")
+    
     try:
         resp_list.insert(0, gr.Chatbot(value=context, type='messages'))
+        #chat_history ya se hace en send_selected_story
     except gr.exceptions.Error:
         print(f"error en main output\n {context}")
-    #return main_output, resp_list[0], resp_list[1], resp_list[2], resp_list[3], models, story,
+
     return resp_list
 
 #inputs=[user_input, chatbot_main_output, model_checkbox, chat_radio, assistant_user_input, chatbot_resp[0],  chatbot_resp[1], chatbot_resp[2], chatbot_resp[3]],# interaction_count],
@@ -207,46 +271,71 @@ def remove_metadata(json_array):
 
 # dont know the correct model beacuse it shuffles each time
 #selected model it's only the index in radio input
-def multiple_interact(query, history, models, selected_model, assistant_user_input): #, interaction_count)
+def multiple_interact(query, models, selected_model, assistant_user_input): #, interaction_count)
     print(f'chat_checkbox: {selected_model}')
     resp_list = []
     print(model_history)
     #quito history ahora es una variable global
+        
 
     if selected_model == "user_input":
-        history.append({"role": "assistant", "content": assistant_user_input})
-        history.append({"role": "user", "content": query})
+        chat_history.append({"role": "assistant", "content": assistant_user_input})
+        chat_history.append({"role": "user", "content": query})
+        
+        dialog = {
+            "context":  remove_metadata(chat_history),
+            "assistant": assistant_user_input + chatbot_answser_list.values(),
+            "selected": "user_input",
+            }
   
     else:
-        #chats = [chat1, chat2, chat3, chat4]
-        #chatbot_aswser_list
+        dialog = {
+            "context":  remove_metadata(chat_history),
+            "assistant": chatbot_answser_list.values(),
+            "selected": None,
+            }
+        
+        #chatbot_answser_list
         #get the previous answer of the selected model
         for index, model in enumerate(models):
             if alphabet[index] == selected_model:
-                selected_model_history = chatbot_aswser_list[selected_model]['response']
+                selected_model_history = chatbot_answser_list[selected_model]['response']
                 print(f"selected_model_history: {selected_model_history}")
-                history.append(selected_model_history)
-                history.append({"role": "user","content": query.strip()})
-    
+                chat_history.append(selected_model_history)
+                chat_history.append({"role": "user","content": query.strip()})
+                #si es la correcta guardarla
+                dialog["selected"] = chatbot_answser_list[selected_model]['model']
+                break
+    #APPE
+    all_answers.append(dialog)
     #save to csv
     selected_model_history = {} #reset history 
     
-    
-    aux_history = remove_metadata(history)
+    #creo que no precisa
+    aux_history = remove_metadata(chat_history)
     #print(aux_history)
     
 
-    #shuffle all models then iterate over them
-    shuffle_models = randomize_key_order(all_models)
-    for index, model in enumerate(shuffle_models):
-        if model in models:
-            response = interact_groq(aux_history, model).strip()
-            resp_list.append(gr.Chatbot(value=[{"role": "assistant", "content": response}], type='messages'))
-            chatbot_aswser_list[alphabet[index]] = {'response': response, 'model': model}
-        else:
-            resp_list.append(gr.Chatbot(value=None, type='messages', visible=False))
-
-    main_output = gr.Chatbot(value=history, type='messages')
+    #no es models es....
+    random.shuffle(active_models)
+    for index, model in enumerate(active_models):
+        resp = interact_groq(aux_history, model)
+        resp = {"role": "assistant", "content": resp.strip()}
+        chatbot_answser_list[alphabet[index]] = {'response': resp, 'model': model}
+        try:
+             print(resp)
+             resp_list.append(gr.Chatbot(value=[resp], visible=True, type='messages'))
+        except gr.exceptions.Error:
+             print(f"error for en modelo {model}")
+    
+    rest = [model for model in model_list if model not in active_models]
+    for model in rest:
+        try:
+            resp_list.append(gr.Chatbot(type='messages', visible=False))
+        except gr.exceptions.Error:
+            print(f"error, else en modelo {model}")
+
+    resp_list.insert(0, gr.Chatbot(value=aux_history, type='messages'))
     model_history.append(selected_model)
     print(model_history)
 
@@ -294,8 +383,10 @@ chatbot_list = []
 model_list = list(all_models.keys())
 active_models = []
 #chatbot_answer_list['model'] = "respuesta aqui"
-chatbot_aswser_list = {}
+chatbot_answser_list = {}
+all_answers = {} #save all answers of all chatbots
 # Create the chat interface using Gradio Blocks
+active_models = []
 with gr.Blocks() as demo:
     with gr.Tabs():
         with gr.TabItem("Chat"):
@@ -348,10 +439,6 @@ with gr.Blocks() as demo:
                         label = f"Model {alphabet[i % len(alphabet)]}"
                         aux = gr.Chatbot(label=label, visible=False, type='messages')
                         chatbot_list.append(aux)   
-                    
-                    #for model in model_list:
-                    #    aux = gr.Chatbot(label=f"Model {model}", visible=False, type='messages')
-                    #    chatbot_list.append(aux)
                         
                 user_input = gr.Textbox(placeholder="Type your message here...", label="User Input")
                 #chat_radio = gr.Radio(choices=list(model_list)+["user_input"], label="Sent something to continue...", value=[model_list[0]])
@@ -395,16 +482,16 @@ with gr.Blocks() as demo:
    #luego retorno:
    #en
 
-    #send_multiple_message_button.click(
-    #   fn=multiple_interact,
-    #   inputs=[user_input, chatbot_main_output, model_checkbox, chat_radio, assistant_user_input],# interaction_count],
-    #   outputs=[chatbot_list],
-    #   )
+    send_multiple_message_button.click(
+       fn=multiple_interact,
+       inputs=[user_input, model_checkbox, chat_radio, assistant_user_input],# interaction_count],
+       outputs=chatbot_list,
+       )
 
 #quiza tenga que guardar una variable con los valores de los checkbox
-    #save_button_multievaluation.click(
-    #    fn=save_comment_score,
-    #    inputs=[chatbot_main_output, score_input, comment_input, story_dropdown, user_dropdown, system_prompt_dropdown,  model_checkbox],
-    #    outputs=[data_table, comment_input])
+    save_button_multievaluation.click(
+        fn=save_comment_score,
+        inputs=[score_input, comment_input, story_dropdown, user_dropdown, system_prompt_dropdown,  model_checkbox],
+        outputs=[data_table, comment_input])
 
 demo.launch()