revise to add google slides api

.gitignore

@@ -0,0 +1,2 @@
+.env
+*.json

app.py

@@ -1,38 +1,98 @@
 import gradio as gr
 from utils import *
-import openai
+from save_data import add_new_data, get_sheet_service
 
-def greet(task, human_input, cooperate_style):
-    merged_answer = "xxx"
-    return f"Given task :{task},\nthe {cooperate_style} answer based of ai and human input \"{human_input}\" is:\n {merged_answer}. "
+class SessionManager:
+    def __init__(self):
+        self.sessions = []
 
-def get_answer(task, human_input, cooperate_style):
-    if cooperate_style=="sequential":
-            merged_text = merge_texts_sequential(task, human_input)
-            print(f"AI merged text: {merged_text}")
+    def add_session(self, task, human_input, cooperate_style):
+        session = {
+            "task": task,
+            "human_input": human_input,
+            "cooperate_style": cooperate_style,
+            "ai_output": None,
+            "merged_output": None,
+            "evaluation": None
+        }
+        self.sessions.append(session)
+        return len(self.sessions) - 1
+
+    def update_output(self, index, output,output_type = 'merged_output'):
+        self.sessions[index][output_type] = output
+
+    def get_session(self, index):
+        return self.sessions[index]
+
+    def save_session_to_sheet(self, index, service, SHEET_ID):
+        session = self.sessions[index]
+        new_row = list(session.values())
+        add_new_data(new_row, service, SHEET_ID, num_of_columns=6)  # 6 columns in the sheet
+
+
+def handle_interaction(task, human_input, cooperate_style, session_manager, api_key):
+    session_index = session_manager.add_session(task, human_input, cooperate_style)
+    if cooperate_style == "sequential":
+        output = merge_texts_sequential(task, human_input, api_key)
+        session_manager.update_output(session_index, output, 'ai_output')
+        ai_output = output
     else:
-        generated_text = generate_text_with_gpt(task)
-        print(f"AI provided text: {generated_text}")    
-        merged_text = merge_texts_parallel(task, human_input, generated_text)
-    return merged_text
-
-with gr.Blocks() as demo:
-    task = gr.Textbox(label="Please Give a task description.")
-    human_input = gr.Textbox(label="Please provide a human answer.", value = "Write a poem about the moon.")
-    cooperate_style = gr.Radio(['sequential', 'parallel'], label="What type of cooperation would you like?")
-    greet_btn = gr.Button("Create!")
-    output = gr.Textbox(label="Answer with cooperation")
-    
-    greet_btn.click(fn=get_answer, 
-                    inputs=[task, human_input, cooperate_style], 
-                    outputs=output, 
-                    api_name="answer")
+        ai_output = generate_text_with_gpt(task, api_key) 
+        session_manager.update_output(session_index, ai_output, 'ai_output')
+        output = merge_texts_parallel(task, human_input, ai_output, api_key)
+    session_manager.update_output(session_index, output, 'merged_output')
+    return ai_output, output, session_index
+
+def evaluate_interaction(session_index, session_manager, api_key):
+    session = session_manager.get_session(session_index)
+    evaluation = get_evaluation_with_gpt(session['task'], session['merged_output'], api_key)
+    session['evaluation'] = evaluation
+    return evaluation
     
-    evaluate_btn = gr.Button("Evaluate")
-    evaluation_results = gr.Textbox(label="Evaluation results.")
-    evaluate_btn.click(fn= evaluation,
-                        inputs=[task, output],
-                        outputs= evaluation_results,
-                        api_name = "evaluate")
-    demo.launch(share=True)
+def save_data(session_index, session_manager, service, SHEET_ID):
+    session_manager.save_session_to_sheet(session_index, service, SHEET_ID)
+    return "Data has been saved to Google Sheets."
+
+if __name__ == "__main__":
+    api_key = get_api_key(local=False)
+    service, SHEET_ID = get_sheet_service(local=False)
+    session_manager = SessionManager()
+
+    with gr.Blocks() as app:
+        with gr.Row():
+            task = gr.Textbox(label="Task Description")
+            human_input = gr.Textbox(label="Human Input")
+        with gr.Row():
+            cooperate_style = gr.Radio(choices=['sequential', 'parallel'], label="Cooperation Style")
+            submit_btn = gr.Button("Create")
+        with gr.Row():
+            ai_output = gr.Textbox(label="AI Output (if it is sequential)")
+            merged_output = gr.Textbox(label="Merged Output given with cooperation")
+            session_index = gr.Number(label="Session Index", visible=False)
+
+        submit_btn.click(
+            fn=lambda task, human_input, cooperate_style: handle_interaction(task, human_input, cooperate_style, session_manager, api_key),
+            inputs=[task, human_input, cooperate_style],
+            outputs=[ai_output, merged_output, session_index]
+        )
+
+        evaluate_btn = gr.Button("Evaluate")
+        evaluation_result = gr.Textbox(label="Evaluation Result")
+
+        evaluate_btn.click(
+            fn=lambda session_index: evaluate_interaction(session_index, session_manager, api_key),
+            inputs=[session_index],
+            outputs=[evaluation_result]
+        )
+
+        save_btn = gr.Button("Save Data")
+        save_result = gr.Label()
+
+        save_btn.click(
+            fn=lambda session_index: save_data(session_index, session_manager, service, SHEET_ID),
+            inputs=[session_index],
+            outputs=[save_result]
+        )
 
+        app.launch(share=True)
+        

configs.py

@@ -1 +0,0 @@
-OPEN_API_KEY = "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"

requirements.txt

@@ -1,2 +1,3 @@
 openai
-gradio
+gradio
+python-dotenv

save_data.py

@@ -0,0 +1,74 @@
+import os
+from google.oauth2 import service_account
+from googleapiclient.discovery import build
+import json
+
+
+import os
+
+def load_envs(local=False):
+    """Load the environment variables."""
+    if local:
+        from dotenv import load_dotenv
+        load_dotenv()
+    service_account_info = json.loads(os.environ['GOOGLE_APPLICATION_CREDENTIALS_JSON'])
+    SHEET_ID = os.environ['SHEET_ID']
+    return service_account_info, SHEET_ID
+
+
+def get_sheet_service(local=False):
+    """Get the google sheet service object."""
+    service_account_info, SHEET_ID = load_envs(local=local)
+    # verify the service_account_info
+    credentials = service_account.Credentials.from_service_account_info(
+        service_account_info,
+        scopes=['https://www.googleapis.com/auth/spreadsheets']
+    )
+
+    # build the service object
+    service = build('sheets', 'v4', credentials=credentials)
+    return service, SHEET_ID
+
+def col_letter(col_num):
+    """Convert a column number to a column letter (1-indexed)."""
+    letter = ''
+    while col_num > 0:
+        col_num, remainder = divmod(col_num - 1, 26)
+        letter = chr(65 + remainder) + letter
+    return letter
+
+def add_new_data(new_row, service, SPREADSHEET_ID, num_of_columns = 5):
+    """Add new data to the spreadsheet.
+    new_row: list of data to be added. """
+    # read the existing data
+    range_to_read = f'Sheet1!A:{col_letter(num_of_columns)}'
+
+    result = service.spreadsheets().values().get(
+        spreadsheetId=SPREADSHEET_ID,
+        range=range_to_read
+    ).execute()
+    values = result.get('values', [])
+    number_of_rows = len(values)
+    new_row = [new_row]
+    range_to_write = f'Sheet1!A{number_of_rows + 1}'
+
+    request_body = {
+        'values': new_row
+    }
+    response = service.spreadsheets().values().append(
+        spreadsheetId=SPREADSHEET_ID,
+        range=range_to_write,
+        valueInputOption='RAW',
+        insertDataOption='INSERT_ROWS',
+        body=request_body
+    ).execute()
+
+    print(f"Added new row at position {number_of_rows + 1}")
+
+
+
+if __name__ == "__main__":
+    service, SHEET_ID = get_sheet_service(local=True)
+    new_row = ["test1", "test2", "test3", "test4", "test5"]
+    add_new_data(new_row, service, SHEET_ID)
+

utils.py

@@ -1,5 +1,12 @@
 import openai 
-from configs import OPEN_API_KEY
+import os
+
+def get_api_key(local = False):
+    if local:
+        from dotenv import load_dotenv
+        load_dotenv()
+    return os.getenv('OPEN_API_KEY')
+
 def get_user_input(prompt):
     return input(prompt)
 
@@ -23,37 +30,37 @@ def describe_task():
         task_description = "Write a poem about the moon in 3 lines."
     return task_description
 
-# def get_api_key():
-#     return configs.api_key  # get the API key from the configs file
+def generate_text_with_gpt(prompts, api_key = None):
+    """Generate text using the GPT-3 model."""
+    if api_key:
+        openai.api_key = api_key
 
-def generate_text_with_gpt(promts):
-    client = openai.OpenAI(api_key=OPEN_API_KEY)
-    
     try:
-        response = client.chat.completions.create(
-        model="gpt-3.5-turbo",
-        messages=[
-            {"role": "system", "content": promts},
+        response = openai.ChatCompletion.create(
+            model="gpt-3.5-turbo",
+            messages=[
+                {"role": "system", "content": "Please assist."},
+                {"role": "user", "content": prompts}
             ]
         )
-        return response.choices[0].message.content
+        return response['choices'][0]['message']['content']
     except Exception as e:
-        print(f"Error occured when generating texts: {e}")
+        print(f"Error occurred when generating texts: {e}")
         return ""
 
-def merge_texts_parallel(task_description, human_text, ai_text):
+def merge_texts_parallel(task_description, human_text, ai_text, api_key = None):
     prompt = f"Given the task as :{task_description}, there are two answers provided:\n" + \
              f"The first answer:  {human_text}\nThe second answer: {ai_text}\n" + \
              f"Merge the two answers into one in a coherent way: "
-    return generate_text_with_gpt(prompt)
+    return generate_text_with_gpt(prompt, api_key)
 
-def merge_texts_sequential(task_description, human_text):
+def merge_texts_sequential(task_description, human_text, api_key = None):
     prompt = f"Given the task as :{task_description}, the human answer is: {human_text}\n" + \
              f"Provide an answer of your own but make sure it is coherent and should be based on the human answer: "
-    return generate_text_with_gpt(prompt)
+    return generate_text_with_gpt(prompt, api_key)
 
-def evaluation(task_description, text):
+def get_evaluation_with_gpt(task_description, text, api_key = None):
     prompt = f"Given the task as :{task_description}, the answer provided is: {text}\n" + \
              f"Evaluate the answer and provide scores between 0 and 10,\n" + \
              f"where criteria for evaluation are correctness, relevance, novelty, fluency, and aesthetic Value:"
-    return generate_text_with_gpt(prompt)
+    return generate_text_with_gpt(prompt, api_key)