Spaces:
Sleeping
Sleeping
Download app8.py from amitkumar1508in/frazcvchatbot: direct link, hf CLI and curl.
- Browser
- Download file 12.7 kB
-
https://huggingface.co/spaces/amitkumar1508in/frazcvchatbot/resolve/main/app8.py
- Command line
-
hf download hf://spaces/amitkumar1508in/frazcvchatbot/app8.py
-
curl -L -o app8.py https://huggingface.co/spaces/amitkumar1508in/frazcvchatbot/resolve/main/app8.py
12.7 kB
| from dotenv import load_dotenv | |
| from openai import OpenAI | |
| import json | |
| import os | |
| import requests | |
| from pypdf import PdfReader | |
| import gradio as gr | |
| import glob | |
| import random | |
| import threading | |
| import time | |
| # Load environment variables from .env file | |
| load_dotenv(override=True) | |
| def push(text): | |
| """ | |
| Sends a push notification using the Pushover API. | |
| This function requires PUSHOVER_TOKEN and PUSHOVER_USER | |
| to be set as environment variables. | |
| """ | |
| requests.post( | |
| "https://api.pushover.net/1/messages.json", | |
| data={ | |
| "token": os.getenv("PUSHOVER_TOKEN"), | |
| "user": os.getenv("PUSHOVER_USER"), | |
| "message": text, | |
| } | |
| ) | |
| def record_user_details(email, name="Name not provided", notes="not provided"): | |
| """ | |
| Records a user's details and sends a push notification. | |
| """ | |
| push(f"Recording {name} with email {email} and notes {notes}") | |
| return {"recorded": "ok"} | |
| def record_unknown_question(question): | |
| """ | |
| Records an unanswered question and sends a push notification. | |
| """ | |
| push(f"Recording {question}") | |
| return {"recorded": "ok"} | |
| def get_local_images(): | |
| """ | |
| Selects four unique random image paths from me/images. | |
| """ | |
| image_paths = glob.glob('me/images/*') | |
| if len(image_paths) < 4: | |
| # Fallback if there are fewer than 4 images | |
| return image_paths + [None] * (4 - len(image_paths)) | |
| return random.sample(image_paths, 4) | |
| def browse_for_image(): | |
| """ | |
| Fetches a list of images that are likely to be of movie actresses. | |
| Note: A real-time web search for specific images is not possible in this environment. | |
| This function returns a hardcoded set of working image URLs. | |
| """ | |
| # Using a different set of reliable, working URLs from Pexels | |
| return [ | |
| "https://images.pexels.com/photos/1036620/pexels-photo-1036620.jpeg?auto=compress&cs=tinysrgb&dpr=2&h=750&w=1260", | |
| "https://images.pexels.com/photos/1181699/pexels-photo-1181699.jpeg?auto=compress&cs=tinysrgb&dpr=2&h=750&w=1260", | |
| "https://images.pexels.com/photos/1755385/pexels-photo-1755385.jpeg?auto=compress&cs=tinysrgb&dpr=2&h=750&w=1260", | |
| "https://images.pexels.com/photos/3777931/pexels-photo-3777931.jpeg?auto=compress&cs=tinysrgb&dpr=2&h=750&w=1260", | |
| "https://images.pexels.com/photos/1381556/pexels-photo-1381556.jpeg?auto=compress&cs=tinysrgb&w=1260&h=750&dpr=2", | |
| "https://images.pexels.com/photos/1239291/pexels-photo-1239291.jpeg?auto=compress&cs=tinysrgb&w=1260&h=750&dpr=2", | |
| "https://images.pexels.com/photos/157675/fashion-men-s-accessories-road-travel-157675.jpeg?auto=compress&cs=tinysrgb&w=1260&h=750&dpr=2", | |
| "https://images.pexels.com/photos/1029193/pexels-photo-1029193.jpeg?auto=compress&cs=tinysrgb&w=1260&h=750&dpr=2", | |
| "https://images.pexels.com/photos/1036623/pexels-photo-1036623.jpeg?auto=compress&cs=tinysrgb&w=1260&h=750&dpr=2", | |
| "https://images.pexels.com/photos/1239292/pexels-photo-1239292.jpeg?auto=compress&cs=tinysrgb&w=1260&h=750&dpr=2", | |
| "https://images.pexels.com/photos/220453/pexels-photo-220453.jpeg?auto=compress&cs=tinysrgb&w=1260&h=750&dpr=2", | |
| "https://images.pexels.com/photos/1036625/pexels-photo-1036625.jpeg?auto=compress&cs=tinysrgb&w=1260&h=750&dpr=2" | |
| ] | |
| def get_next_images(history): | |
| """ | |
| Selects the next four images to display. The first time, it shows images from the local | |
| 'me/images' folder. Subsequent clicks will fetch new, random images from the internet. | |
| """ | |
| # Check if this is the first click or if we are already displaying internet images | |
| if not history or not all(path.startswith('me/images') for path in history): | |
| # Fetch new random images from the internet | |
| all_internet_images = browse_for_image() | |
| new_images = random.sample(all_internet_images, 4) | |
| history = new_images | |
| return new_images[0], new_images[1], new_images[2], new_images[3], history | |
| else: | |
| # Initial display of local images | |
| unshown_images = [path for path in get_local_images() if path not in history] | |
| if len(unshown_images) >= 4: | |
| selected_images = random.sample(unshown_images, 4) | |
| history.extend(selected_images) | |
| return selected_images[0], selected_images[1], selected_images[2], selected_images[3], history | |
| else: | |
| # Local images exhausted, switch to internet images | |
| all_internet_images = browse_for_image() | |
| new_images = random.sample(all_internet_images, 4) | |
| history = new_images | |
| return new_images[0], new_images[1], new_images[2], new_images[3], history | |
| def reset_images(): | |
| """ | |
| Resets the displayed images to the initial set from the local 'me/images' folder. | |
| """ | |
| initial_images = get_local_images() | |
| return initial_images[0], initial_images[1], initial_images[2], initial_images[3], initial_images | |
| # Tool definitions for function calling | |
| record_user_details_json = { | |
| "name": "record_user_details", | |
| "description": "Use this tool to record that a user is interested in being in 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 | |
| } | |
| } | |
| 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 couldn't be answered" | |
| }, | |
| }, | |
| "required": ["question"], | |
| "additionalProperties": False | |
| } | |
| } | |
| tools = [ | |
| {"type": "function", "function": record_user_details_json}, | |
| {"type": "function", "function": record_unknown_question_json} | |
| ] | |
| class Me: | |
| def __init__(self): | |
| # Initialize the Gemini client using the OpenAI library with the specified base URL and model. | |
| # This allows using the OpenAI-compatible API endpoint for Gemini. | |
| # Make sure to have GOOGLE_API_KEY set in your environment or .env file. | |
| google_api_key = os.getenv("GOOGLE_API_KEY") | |
| self.gemini = OpenAI(api_key=google_api_key, base_url="https://generativelanguage.googleapis.com/v1beta/openai/") | |
| self.model_name = "gemini-2.0-flash" | |
| self.name = "Aneet Padda" | |
| # Read the LinkedIn profile from the PDF | |
| reader = PdfReader("me/aneetinfo.pdf") | |
| self.linkedin = "" | |
| for page in reader.pages: | |
| text = page.extract_text() | |
| if text: | |
| self.linkedin += text | |
| # Read the summary from the text file | |
| with open("me/summary.txt", "r", encoding="utf-8") as f: | |
| self.summary = f.read() | |
| def handle_tool_call(self, tool_calls): | |
| """ | |
| Executes the function calls returned by the model. | |
| """ | |
| results = [] | |
| for tool_call in tool_calls: | |
| tool_name = tool_call.function.name | |
| arguments = json.loads(tool_call.function.arguments) | |
| print(f"Tool called: {tool_name}", flush=True) | |
| 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 system_prompt(self): | |
| """ | |
| Generates the system prompt for the model. | |
| """ | |
| system_prompt = f"You are acting as {self.name}. You are answering questions on {self.name}'s website, \ | |
| particularly questions related to {self.name}'s career, background, skills and experience. \ | |
| Your responsibility is to represent {self.name} for interactions on the website as faithfully as possible. \ | |
| You are given a summary of {self.name}'s background and LinkedIn profile which you can use to answer questions. \ | |
| Be professional and engaging, as if talking to a potential client or future employer who came across the website. \ | |
| If you don't know the answer to any question, use your record_unknown_question tool to record the question that you couldn't answer, even if it's about something trivial or unrelated to career. \ | |
| If the user is engaging in discussion, try to steer them towards getting in touch via email; ask for their email and record it using your record_user_details tool." | |
| system_prompt += f"\n\n## Summary:\n{self.summary}\n\n## LinkedIn Profile:\n{self.linkedin}\n\n" | |
| system_prompt += f"With this context, please chat with the user, always staying in character as {self.name}." | |
| return system_prompt | |
| def chat(self, message, history): | |
| """ | |
| Handles the chat conversation with the model. | |
| """ | |
| # Send a notification for every user message received. | |
| push(f"New user question: {message}") | |
| messages = [{"role": "system", "content": self.system_prompt()}] + history + [{"role": "user", "content": message}] | |
| done = False | |
| while not done: | |
| # Use the gemini client to create the chat completion | |
| response = self.gemini.chat.completions.create(model=self.model_name, messages=messages, tools=tools) | |
| if response.choices[0].finish_reason=="tool_calls": | |
| message = response.choices[0].message | |
| tool_calls = message.tool_calls | |
| results = self.handle_tool_call(tool_calls) | |
| messages.append(message) | |
| messages.extend(results) | |
| else: | |
| done = True | |
| return response.choices[0].message.content | |
| if __name__ == "__main__": | |
| # Custom CSS for the single fixed image and overall layout | |
| custom_css = """ | |
| .image-container { | |
| display: flex; | |
| justify-content: space-around; | |
| padding: 20px; | |
| z-index: 1000; | |
| box-shadow: 0 4px 8px rgba(0,0,0,0.1); | |
| } | |
| .image-item { | |
| width: 200px; | |
| height: 200px; | |
| border-radius: 10px; | |
| overflow: hidden; | |
| } | |
| """ | |
| me = Me() | |
| # Initial images to display | |
| initial_images = get_local_images() | |
| with gr.Blocks(css=custom_css) as demo: | |
| # A state to keep track of the images we have already displayed | |
| image_history = gr.State(initial_images) | |
| # A fixed-position container for the four images | |
| with gr.Row(elem_classes=["image-container"]): | |
| image_display_1 = gr.Image(value=initial_images[0], label=None, show_label=False, elem_classes=["image-item"]) | |
| image_display_2 = gr.Image(value=initial_images[1], label=None, show_label=False, elem_classes=["image-item"]) | |
| image_display_3 = gr.Image(value=initial_images[2], label=None, show_label=False, elem_classes=["image-item"]) | |
| image_display_4 = gr.Image(value=initial_images[3], label=None, show_label=False, elem_classes=["image-item"]) | |
| # A button to manually change the images | |
| with gr.Row(): | |
| change_image_button = gr.Button("Show Another Image") | |
| refresh_button = gr.Button("Refresh") | |
| gr.ChatInterface(me.chat, type="messages") | |
| # The button's click event will trigger the image update and history tracking | |
| change_image_button.click( | |
| fn=get_next_images, | |
| inputs=image_history, | |
| outputs=[image_display_1, image_display_2, image_display_3, image_display_4, image_history] | |
| ) | |
| # The refresh button will reset the images and the history | |
| refresh_button.click( | |
| fn=reset_images, | |
| outputs=[image_display_1, image_display_2, image_display_3, image_display_4, image_history] | |
| ) | |
| demo.launch() | |