Added function to send push notification for unknown question

app.py

@@ -1,238 +1,243 @@
-from dotenv import load_dotenv
-from openai import OpenAI
-import json
-import os
-import requests
-import gradio as gr
-import fitz  # PyMuPDF
-
-# load the environment variables
-load_dotenv(override=True)
-
-# Setting up pushover for notification
-pushover_user = os.getenv("PUSHOVER_USER")
-pushover_token = os.getenv("PUSHOVER_TOKEN")
-pushover_url = "https://api.pushover.net/1/messages.json"
-
-# function to send notifications
-def push(message: str):
-    if pushover_user and pushover_token:
-        payload = {"user": pushover_user, "token": pushover_token, "message": message}
-        try:
-            requests.post(pushover_url, data=payload, timeout=5)
-        except requests.exceptions.RequestError as e:
-            print(f"Pushover notification failed: {e}")
-    else:
-        print("Pushover credentials not found. Skipping notification")
-
-# Function to record the user details
-def record_user_details(email: str, name: str='Name not provided', notes: str='Notes not provided'):
-    push(f"Recording interest from {name} with email {email} and notes {notes}")
-    return {"recorded": "ok"}
-
-# Tool to record user details
-record_user_details_json = {
-    "name": "record_user_details",
-    "description": "Use this tool to record that a user is interested in being touch and provided an email address",
-    "parameters": {
-        "type": "object",
-        "properties": {
-            "email": {"type": "string", "description": "The email address of this user"},
-            "name": {"type": "string", "description": "The user's name, if they provided it"},
-            "notes": {"type": "string", "description": "Any additional information about the conversation that's worth recording to give context"}
-        },
-        "required": ["email"],
-        "additionalProperties": False
-    }
-}
-
-# Tool to log unanswered questions
-record_unknown_question_json = {
-    "name": "record_unknown_question",
-    "description": "Always use this tool to record any question that couldn't be answered as you didn't know the answer",
-    "parameters": {
-        "type": "object",
-        "properties": {
-            "question": {"type": "string", "description": "The question that you couldn't answered"}
-        },
-        "required": ["question"],
-        "additionalProperties": False
-    }
-}
-
-# List of tools for the LLM
-tools = [
-    {"type": "function", "function": record_user_details_json},
-    {"type": "function", "function": record_unknown_question_json}
-]
-
-class ResumeChatbot:
-    def __init__(self):
-        self.open_ai = OpenAI()
-
-    def extract_text_from_pdf(self, pdf_path):
-        """Extracts text from a given PDF file path."""
-        try:
-            doc = fitz.open(pdf_path)
-            full_text = ""
-            for page in doc:
-                full_text += page.get_text()
-            return full_text
-        except Exception as e:
-            print(f"Error reading PDF: {e}")
-            return None
-
-    def handle_tool_call(self, tool_calls):
-        results = []
-        for tool_call in tool_calls:
-            tool_name = tool_call.function.name
-            arguments = json.loads(tool_call.function.arguments)
-            tool = globals().get(tool_name)
-            result = tool(**arguments) if tool else {}
-            results.append({
-                "role": "tool",
-                "content": json.dumps(result),
-                "tool_call_id": tool_call.id
-            })
-        return results
-
-    def get_system_prompt(self, resume_text):
-        system_prompt = f"""
-        You are acting as an expert assistant representing the individual whose resume is provided below.
-        Your task is to answer questions strictly based on the information contained in the resume.
-        Do not fabricate or assume any details that are not explicitly mentioned in the resume.
-
-        If asked about improvements or suggestions, respond with clear, concise, and focused points only.
-        Keep your answers compact and to the point, and expand only if the user explicitly asks for more details.
-
-        If a user asks a question you cannot answer from the resume, use the record_unknown_question tool to log the unanswered query.
-
-        If the user expresses interest in following up or staying in touch, politely ask for their name and email,
-        then record it using the record_user_details tool.
-
-        Resume Content:
-        {resume_text}
-        """
-        return system_prompt
-
-    def chat(self, message: str, history: list, resume_text: str):
-        system_prompt = self.get_system_prompt(resume_text)
-        
-        # Convert Gradio chat_history to OpenAI messages format
-        formatted_history = []
-        for user_msg, bot_msg in history:
-            if user_msg is not None: # User messages are not None when they've actually typed something
-                formatted_history.append({"role": "user", "content": user_msg})
-            if bot_msg is not None: # Bot messages are not None when they've responded
-                formatted_history.append({"role": "assistant", "content": bot_msg})
-
-        # Construct the full message history: system prompt, formatted chat history, and new user message
-        messages = [{"role": "system", "content": system_prompt}] + formatted_history + [{"role": "user", "content": message}]
-        
-        done = False  # Flag to track when the chat loop should stop
-
-        while not done:
-            # Call the OpenAI chat model with messages and available tools
-            response = self.open_ai.chat.completions.create(
-                model="gpt-4o-mini",       # Model to use
-                messages=messages,          # Full conversation history
-                tools=tools                 # Pass in tools so the LLM can invoke them
-            )
-
-            # Check how the model decided to end its generation
-            finish_reason = response.choices[0].finish_reason
-
-            # If the model wants to call a tool, handle the tool calls
-            if finish_reason == "tool_calls":
-                message_response = response.choices[0].message        # Extract the message containing the tool call
-                tool_calls = message_response.tool_calls            # Get the list of tool calls
-                results = self.handle_tool_call(tool_calls)         # Run the tools and get their results
-                messages.append(message_response)                   # Add the original tool call message to history
-                messages.extend(results)                            # Add tool results to message history for LLM to continue
-            else:
-                # If no tool call is needed, we're done and can return the final response
-                done = True
-
-        # Return the final message content from the model as the assistant's reply
-        return response.choices[0].message.content
-
-# Create a single instance of the Me class
-chatbot_instance = ResumeChatbot()
-
-def upload_and_process_resume(file_obj):
-    """
-    Gradio function to handle file uploads.
-    It extracts text from the uploaded PDF and stores it.
-    """
-    if file_obj is None:
-        return None, [], "Please upload a PDF resume to begin."
-
-    # The file_obj has a .name attribute which is the temporary path to the uploaded file
-    resume_text = chatbot_instance.extract_text_from_pdf(file_obj.name)
-    
-    if resume_text is None or not resume_text.strip():
-        return None, [], "Could not read text from the uploaded PDF. Please try another file."
-    
-    # Clear chat history and provide a welcome message
-    # The welcome message is structured to fit Gradio's chat history format
-    initial_message = "Thank you for uploading the resume. How can I help you today?"
-    chat_history = [[None, initial_message]] # User message is None for the initial bot message
-    return resume_text, chat_history, "" # returns resume_text to state, updated chatbot, and clears textbox
-
-def respond(message: str, chat_history: list, resume_state: str):
-    """
-    Gradio function to handle the chat interaction.
-    It gets the resume text from the session's state.
-    """
-    if not resume_state:
-        # If no resume has been uploaded yet
-        chat_history.append([message, "Please upload a resume before starting the conversation."])
-        return "", chat_history
-    
-    # Get the bot's response
-    # The chat_history passed to chatbot_instance.chat is still in Gradio's format
-    bot_message = chatbot_instance.chat(message, chat_history, resume_state)
-    chat_history.append([message, bot_message]) # Append the new user message and bot response to Gradio's history
-    return "", chat_history # Clears the textbox and returns the updated history
-
-# --- Gradio Interface ---
-if __name__ == "__main__":
-    with gr.Blocks(theme=gr.themes.Soft(), title="Resume Chatbot") as demo:
-        # State to hold the extracted resume text for the user's session
-        resume_text_state = gr.State(None)
-
-        gr.Markdown("# Chat with a Resume")
-        gr.Markdown("Upload a PDF resume below, then ask questions about it.")
-
-        with gr.Row():
-            with gr.Column(scale=1):
-                file_uploader = gr.File(
-                    label="Upload PDF Resume",
-                    file_types=[".pdf"],
-                    type="filepath" # Passes the temporary filepath to the function
-                )
-            with gr.Column(scale=2):
-                chatbot = gr.Chatbot(label="Conversation", height=500)
-                msg_box = gr.Textbox(label="Your Question", placeholder="e.g., What are the key skills mentioned?")
-                submit_btn = gr.Button("Send")
-
-        # Event handler for the file upload
-        file_uploader.upload(
-            fn=upload_and_process_resume,
-            inputs=[file_uploader],
-            outputs=[resume_text_state, chatbot, msg_box]
-        )
-
-        # Event handlers for chat submission
-        msg_box.submit(
-            fn=respond,
-            inputs=[msg_box, chatbot, resume_text_state],
-            outputs=[msg_box, chatbot]
-        )
-        submit_btn.click(
-            fn=respond,
-            inputs=[msg_box, chatbot, resume_text_state],
-            outputs=[msg_box, chatbot]
-        )
-
+from dotenv import load_dotenv
+from openai import OpenAI
+import json
+import os
+import requests
+import gradio as gr
+import fitz  # PyMuPDF
+
+# load the environment variables
+load_dotenv(override=True)
+
+# Setting up pushover for notification
+pushover_user = os.getenv("PUSHOVER_USER")
+pushover_token = os.getenv("PUSHOVER_TOKEN")
+pushover_url = "https://api.pushover.net/1/messages.json"
+
+# function to send notifications
+def push(message: str):
+    if pushover_user and pushover_token:
+        payload = {"user": pushover_user, "token": pushover_token, "message": message}
+        try:
+            requests.post(pushover_url, data=payload, timeout=5)
+        except requests.exceptions.RequestError as e:
+            print(f"Pushover notification failed: {e}")
+    else:
+        print("Pushover credentials not found. Skipping notification")
+
+# Function to record the user details
+def record_user_details(email: str, name: str='Name not provided', notes: str='Notes not provided'):
+    push(f"Recording interest from {name} with email {email} and notes {notes}")
+    return {"recorded": "ok"}
+
+# Function to record unknown questions
+def record_unknown_question(question):
+    push(f"Recording {question} asked that I couldn't answer")
+    return {"recorded": "ok"}
+
+# Tool to record user details
+record_user_details_json = {
+    "name": "record_user_details",
+    "description": "Use this tool to record that a user is interested in being touch and provided an email address",
+    "parameters": {
+        "type": "object",
+        "properties": {
+            "email": {"type": "string", "description": "The email address of this user"},
+            "name": {"type": "string", "description": "The user's name, if they provided it"},
+            "notes": {"type": "string", "description": "Any additional information about the conversation that's worth recording to give context"}
+        },
+        "required": ["email"],
+        "additionalProperties": False
+    }
+}
+
+# Tool to log unanswered questions
+record_unknown_question_json = {
+    "name": "record_unknown_question",
+    "description": "Always use this tool to record any question that couldn't be answered as you didn't know the answer",
+    "parameters": {
+        "type": "object",
+        "properties": {
+            "question": {"type": "string", "description": "The question that you couldn't answered"}
+        },
+        "required": ["question"],
+        "additionalProperties": False
+    }
+}
+
+# List of tools for the LLM
+tools = [
+    {"type": "function", "function": record_user_details_json},
+    {"type": "function", "function": record_unknown_question_json}
+]
+
+class ResumeChatbot:
+    def __init__(self):
+        self.open_ai = OpenAI()
+
+    def extract_text_from_pdf(self, pdf_path):
+        """Extracts text from a given PDF file path."""
+        try:
+            doc = fitz.open(pdf_path)
+            full_text = ""
+            for page in doc:
+                full_text += page.get_text()
+            return full_text
+        except Exception as e:
+            print(f"Error reading PDF: {e}")
+            return None
+
+    def handle_tool_call(self, tool_calls):
+        results = []
+        for tool_call in tool_calls:
+            tool_name = tool_call.function.name
+            arguments = json.loads(tool_call.function.arguments)
+            tool = globals().get(tool_name)
+            result = tool(**arguments) if tool else {}
+            results.append({
+                "role": "tool",
+                "content": json.dumps(result),
+                "tool_call_id": tool_call.id
+            })
+        return results
+
+    def get_system_prompt(self, resume_text):
+        system_prompt = f"""
+        You are acting as an expert assistant representing the individual whose resume is provided below.
+        Your task is to answer questions strictly based on the information contained in the resume.
+        Do not fabricate or assume any details that are not explicitly mentioned in the resume.
+
+        If asked about improvements or suggestions, respond with clear, concise, and focused points only.
+        Keep your answers compact and to the point, and expand only if the user explicitly asks for more details.
+
+        If a user asks a question you cannot answer from the resume, use the record_unknown_question tool to log the unanswered query.
+
+        If the user expresses interest in following up or staying in touch, politely ask for their name and email,
+        then record it using the record_user_details tool.
+
+        Resume Content:
+        {resume_text}
+        """
+        return system_prompt
+
+    def chat(self, message: str, history: list, resume_text: str):
+        system_prompt = self.get_system_prompt(resume_text)
+        
+        # Convert Gradio chat_history to OpenAI messages format
+        formatted_history = []
+        for user_msg, bot_msg in history:
+            if user_msg is not None: # User messages are not None when they've actually typed something
+                formatted_history.append({"role": "user", "content": user_msg})
+            if bot_msg is not None: # Bot messages are not None when they've responded
+                formatted_history.append({"role": "assistant", "content": bot_msg})
+
+        # Construct the full message history: system prompt, formatted chat history, and new user message
+        messages = [{"role": "system", "content": system_prompt}] + formatted_history + [{"role": "user", "content": message}]
+        
+        done = False  # Flag to track when the chat loop should stop
+
+        while not done:
+            # Call the OpenAI chat model with messages and available tools
+            response = self.open_ai.chat.completions.create(
+                model="gpt-4o-mini",       # Model to use
+                messages=messages,          # Full conversation history
+                tools=tools                 # Pass in tools so the LLM can invoke them
+            )
+
+            # Check how the model decided to end its generation
+            finish_reason = response.choices[0].finish_reason
+
+            # If the model wants to call a tool, handle the tool calls
+            if finish_reason == "tool_calls":
+                message_response = response.choices[0].message        # Extract the message containing the tool call
+                tool_calls = message_response.tool_calls            # Get the list of tool calls
+                results = self.handle_tool_call(tool_calls)         # Run the tools and get their results
+                messages.append(message_response)                   # Add the original tool call message to history
+                messages.extend(results)                            # Add tool results to message history for LLM to continue
+            else:
+                # If no tool call is needed, we're done and can return the final response
+                done = True
+
+        # Return the final message content from the model as the assistant's reply
+        return response.choices[0].message.content
+
+# Create a single instance of the Me class
+chatbot_instance = ResumeChatbot()
+
+def upload_and_process_resume(file_obj):
+    """
+    Gradio function to handle file uploads.
+    It extracts text from the uploaded PDF and stores it.
+    """
+    if file_obj is None:
+        return None, [], "Please upload a PDF resume to begin."
+
+    # The file_obj has a .name attribute which is the temporary path to the uploaded file
+    resume_text = chatbot_instance.extract_text_from_pdf(file_obj.name)
+    
+    if resume_text is None or not resume_text.strip():
+        return None, [], "Could not read text from the uploaded PDF. Please try another file."
+    
+    # Clear chat history and provide a welcome message
+    # The welcome message is structured to fit Gradio's chat history format
+    initial_message = "Thank you for uploading the resume. How can I help you today?"
+    chat_history = [[None, initial_message]] # User message is None for the initial bot message
+    return resume_text, chat_history, "" # returns resume_text to state, updated chatbot, and clears textbox
+
+def respond(message: str, chat_history: list, resume_state: str):
+    """
+    Gradio function to handle the chat interaction.
+    It gets the resume text from the session's state.
+    """
+    if not resume_state:
+        # If no resume has been uploaded yet
+        chat_history.append([message, "Please upload a resume before starting the conversation."])
+        return "", chat_history
+    
+    # Get the bot's response
+    # The chat_history passed to chatbot_instance.chat is still in Gradio's format
+    bot_message = chatbot_instance.chat(message, chat_history, resume_state)
+    chat_history.append([message, bot_message]) # Append the new user message and bot response to Gradio's history
+    return "", chat_history # Clears the textbox and returns the updated history
+
+# --- Gradio Interface ---
+if __name__ == "__main__":
+    with gr.Blocks(theme=gr.themes.Soft(), title="Resume Chatbot") as demo:
+        # State to hold the extracted resume text for the user's session
+        resume_text_state = gr.State(None)
+
+        gr.Markdown("# Chat with a Resume")
+        gr.Markdown("Upload a PDF resume below, then ask questions about it.")
+
+        with gr.Row():
+            with gr.Column(scale=1):
+                file_uploader = gr.File(
+                    label="Upload PDF Resume",
+                    file_types=[".pdf"],
+                    type="filepath" # Passes the temporary filepath to the function
+                )
+            with gr.Column(scale=2):
+                chatbot = gr.Chatbot(label="Conversation", height=500)
+                msg_box = gr.Textbox(label="Your Question", placeholder="e.g., What are the key skills mentioned?")
+                submit_btn = gr.Button("Send")
+
+        # Event handler for the file upload
+        file_uploader.upload(
+            fn=upload_and_process_resume,
+            inputs=[file_uploader],
+            outputs=[resume_text_state, chatbot, msg_box]
+        )
+
+        # Event handlers for chat submission
+        msg_box.submit(
+            fn=respond,
+            inputs=[msg_box, chatbot, resume_text_state],
+            outputs=[msg_box, chatbot]
+        )
+        submit_btn.click(
+            fn=respond,
+            inputs=[msg_box, chatbot, resume_text_state],
+            outputs=[msg_box, chatbot]
+        )
+
     demo.launch()