Update app.py

app.py

@@ -2,28 +2,40 @@ import gradio as gr
 import subprocess
 import json
 import requests
+import re
+import pandas as pd
+import openai
 from bs4 import BeautifulSoup
 
-"""
-General helper functions
-"""
+# Simple function to strip html
 
 def strip_html_tags(html_text):
     # Use BeautifulSoup to parse and clean HTML content
     soup = BeautifulSoup(html_text, 'html.parser')
     return soup.get_text()
 
-"""
-Padlet API Interactions
-"""
-def api_call(input_text):
+def html_posts_to_table(html_posts):
 
-    #TODO: Refactor to be one function that can get OR post
+    subject_pattern = r"Subject: (.*?)\n"
+    body_text_pattern = r"Body Text: (.*?)\n"
 
+    subjects = re.findall(subject_pattern, html_posts)
+    body_texts = re.findall(body_text_pattern, html_posts)
+
+    data = {
+        'Subject': subjects,
+        'Body Text': body_texts
+    }
+
+    df = pd.DataFrame(data)
+
+    return(df)
+
+def api_call(board_id, api_key):
     curl_command = [
         'curl', '-s', '--request', 'GET',
         '--url', f"https://api.padlet.dev/v1/boards/{board_id}?include=posts%2Csections",
-        '--header', 'X-Api-Key: pdltp_0e380a0de1ff32d77b12dbcc030b1373199b7525681ddc81bd1b9ef3e4e3dd49577a23',
+        '--header', f"X-Api-Key: {api_key}",
         '--header', 'accept: application/vnd.api+json'
     ]
     
@@ -34,6 +46,7 @@ def api_call(input_text):
         # Extract the contents of all posts, stripping HTML tags from bodyHtml
         posts_data = response_data.get("included", [])
         post_contents = []
+
         for post in posts_data:
             if post.get("type") == "post":
                 attributes = post.get("attributes", {}).get("content", {})
@@ -41,23 +54,23 @@ def api_call(input_text):
                 body_html = attributes.get("bodyHtml", "")
                 
                 if subject:
-                    post_content = f"Subject: {subject}"
-                    if body_html:
-                        cleaned_body = strip_html_tags(body_html)
-                        post_content += f"\nBody Text: {cleaned_body}"
-                    
-                    post_contents.append(post_content)
-        
-        return "\n\n".join(post_contents) if post_contents else "No post contents found."
+                    cleaned_body = strip_html_tags(body_html)
+                    post_contents.append({"subject": subject, "content": cleaned_body})
+
+        if post_contents:
+            df = pd.DataFrame(post_contents)
+            return df
+        else:
+            return pd.DataFrame({"subject": ["No post contents found."], "content": [""]})
     except subprocess.CalledProcessError:
-        return "Error: Unable to fetch data using cURL."
+        return pd.DataFrame({"subject": ["Error: Unable to fetch data using cURL."], "content": [""]})
 
-def create_post(board_id, post_content):
+def create_post(subject, post_content, board_id, api_key):
 
     curl_command = [
         'curl', '-s', '--request', 'POST',
         '--url', f"https://api.padlet.dev/v1/boards/{board_id}/posts",
-        '--header', 'X-Api-Key: pdltp_0e380a0de1ff32d77b12dbcc030b1373199b7525681ddc81bd1b9ef3e4e3dd49577a23',
+        '--header', f"X-Api-Key: {api_key}",
         '--header', 'accept: application/vnd.api+json',
         '--header', 'content-type: application/vnd.api+json',
         '--data',
@@ -66,7 +79,8 @@ def create_post(board_id, post_content):
                 "type": "post",
                 "attributes": {
                     "content": {
-                        "subject": post_content
+                        "subject": subject,
+                        "body": post_content
                     }
                 }
             }
@@ -80,143 +94,66 @@ def create_post(board_id, post_content):
     except subprocess.CalledProcessError as e:
         return f"Error: Unable to create post - {str(e)}"
 
-"""
-LLM Functions
-"""
-        
-#Streaming endpoint 
-API_URL = "https://api.openai.com/v1/chat/completions" #os.getenv("API_URL") + "/generate_stream"
+def posts_to_prompt(padlet_posts):
+    post_prompt = padlet_posts.apply(lambda row: f"{row['subject']} {row['content']}", axis=1).str.cat(sep=', ')
+    return post_prompt
 
-#Inference function
-def predict(openai_gpt4_key, system_msg, api_result, top_p, temperature, chat_counter, chatbot=[], history=[]): 
+def remove_html_tags(text):
+    # Use a regular expression to remove HTML tags
+    clean = re.compile('<.*?>')
+    return re.sub(clean, '', text)
+
+def summarize_padlet_posts(padlet_posts, openai_api_key):
+    # Concatenate padlet post df
+    post_prompt = posts_to_prompt(padlet_posts)
+
+    # Set the system prompt with more specific instructions
+    system_prompt = (
+        "You are an AI assistant tasked with summarizing the main points of the following Padlet posts. "
+        "Please provide a concise summary of the posts based on their content."
+    )
+
+    # Set the prompt for the GPT-3.5 model
+    prompt = system_prompt + "\n" + post_prompt  # Added a newline after system_prompt
+
+    try:
+        # Make the API call to GPT-3.5
+        response = openai.Completion.create(
+            engine="text-davinci-003",  # GPT-3.5 engine
+            prompt=prompt,
+            max_tokens=1000,  # Limit response length for concise summaries
+            api_key=openai_api_key,
+            temperature=0.5  # Adjust temperature as needed
+        )
+
+        # Extract and return the summary, removing leading newlines and HTML tags
+        summary = response.choices[0].text.lstrip('\n')
+        summary = remove_html_tags(summary)
+        return summary
+    except Exception as e:
+        return f"Error: {str(e)}"
+
+def summarize_padlets(input_board_id, output_board_id, padlet_api, openai_api):
+
+    posts_to_summarize = api_call(input_board_id, padlet_api)
+
+    summary = summarize_padlet_posts(posts_to_summarize, openai_api)
+
+    create_post("Summary",summary, output_board_id, padlet_api)
 
-    headers = {
-    "Content-Type": "application/json",
-    "Authorization": f"Bearer {openai_gpt4_key}"  #Users will provide their own OPENAI_API_KEY 
-    }
-    print(f"system message is ^^ {system_msg}")
-    if system_msg.strip() == '':
-        initial_message = [{"role": "user", "content": f"{inputs}"},]
-        multi_turn_message = []
-    else:
-        initial_message= [{"role": "system", "content": system_msg},
-                   {"role": "user", "content": f"{inputs}"},]
-        multi_turn_message = [{"role": "system", "content": system_msg},]
-        
-    if chat_counter == 0 :
-        payload = {
-        "model": "gpt-4",
-        "messages": initial_message , 
-        "temperature" : 1.0,
-        "top_p":1.0,
-        "n" : 1,
-        "stream": True,
-        "presence_penalty":0,
-        "frequency_penalty":0,
-        }
-        print(f"chat_counter - {chat_counter}")
-    else: #if chat_counter != 0 :
-        messages=multi_turn_message # Of the type of - [{"role": "system", "content": system_msg},]
-        for data in chatbot:
-          user = {}
-          user["role"] = "user" 
-          user["content"] = data[0] 
-          assistant = {}
-          assistant["role"] = "assistant" 
-          assistant["content"] = data[1]
-          messages.append(user)
-          messages.append(assistant)
-        temp = {}
-        temp["role"] = "user" 
-        temp["content"] = inputs
-        messages.append(temp)
-        #messages
-        payload = {
-        "model": "gpt-4",
-        "messages": messages, # Of the type of [{"role": "user", "content": f"{inputs}"}],
-        "temperature" : temperature, #1.0,
-        "top_p": top_p, #1.0,
-        "n" : 1,
-        "stream": True,
-        "presence_penalty":0,
-        "frequency_penalty":0,}
-
-    chat_counter+=1
-
-    history.append(inputs)
-    print(f"Logging : payload is - {payload}")
-    # make a POST request to the API endpoint using the requests.post method, passing in stream=True
-    response = requests.post(API_URL, headers=headers, json=payload, stream=True)
-    print(f"Logging : response code - {response}")
-    token_counter = 0 
-    partial_words = "" 
-
-    counter=0
-    for chunk in response.iter_lines():
-        #Skipping first chunk
-        if counter == 0:
-          counter+=1
-          continue
-        # check whether each line is non-empty
-        if chunk.decode() :
-          chunk = chunk.decode()
-          # decode each line as response data is in bytes
-          if len(chunk) > 12 and "content" in json.loads(chunk[6:])['choices'][0]['delta']:
-              partial_words = partial_words + json.loads(chunk[6:])['choices'][0]["delta"]["content"]
-              if token_counter == 0:
-                history.append(" " + partial_words)
-              else:
-                history[-1] = partial_words
-              chat = [(history[i], history[i + 1]) for i in range(0, len(history) - 1, 2) ]  # convert to tuples of list
-              token_counter+=1
-              yield chat, history, chat_counter, response  # resembles {chatbot: chat, state: history}  
-                   
-#Resetting to blank
-def reset_textbox():
-    return gr.update(value='')
-
-#to set a component as visible=False
-def set_visible_false():
-    return gr.update(visible=False)
-
-#to set a component as visible=True
-def set_visible_true():
-    return gr.update(visible=True)
-
-# Create a Gradio Blocks interface
-title = "<h1>Padlet Summary Tool</h1>"
 iface = gr.Interface(
-    fn=predict,  # Use 'predict' as the function
+    fn=summarize_padlets,
     inputs=[
-        gr.blocks.Textbox(label="OpenAI GPT4 Key"),
-        gr.blocks.Textbox(label="System Message"),
-        gr.blocks.Textbox(label="API Result"),
-        gr.blocks.Textbox(label="Board ID to Fetch Data From", name="fetch_board_id"),
-        gr.blocks.Textbox(label="Board ID to Post Summary To", name="post_board_id"),
+        gr.inputs.Textbox(label="Input Board ID"),
+        gr.inputs.Textbox(label="Output Board ID"),
+        gr.inputs.Textbox(label="Padlet API Key", type="password"),
+        gr.inputs.Textbox(label="OpenAI API Key", type="password", placeholder="sk.."),
     ],
-    outputs=[
-        gr.blocks.Textbox(label="Summary"),
-        gr.blocks.Textbox(label="API Response"),
-    ],
-    title=title,
-    live=True,
+    outputs=gr.outputs.Textbox(label="Summary"),
+    live=False,  # Set to True to show the result without clicking a button
+    title="Padlet Summarization",
+    description="Summarize Padlet posts and create a summary post on another board using OpenAI GPT3.5.",
 )
 
-# Add event handlers to call 'create_post' when the "Create Post" button is clicked
-@gr.blocks.Button(label="Create Post")
-def create_post(inputs, output):
-    openai_gpt4_key, system_msg, api_result, fetch_board_id, post_board_id = (
-        inputs["OpenAI GPT4 Key"],
-        inputs["System Message"],
-        inputs["API Result"],
-        inputs["fetch_board_id"],
-        inputs["post_board_id"],
-    )
-    api_data = api_call(fetch_board_id)
-    summary = predict(openai_gpt4_key, system_msg, api_data, 1.0, 1.0, 0)
-    response = create_post(post_board_id, summary)
-    output["Summary"] = summary
-    output["API Response"] = response
-
-# Launch the interface
+# Run the Gradio interface
 iface.launch()