Spaces:
Sleeping
Sleeping
Download app.py from amitkumar1508in/frazcvchatbot: direct link, hf CLI and curl.
- Browser
- Download file 22.1 kB
-
https://huggingface.co/spaces/amitkumar1508in/frazcvchatbot/resolve/main/app.py
- Command line
-
hf download hf://spaces/amitkumar1508in/frazcvchatbot/app.py
-
curl -L -o app.py https://huggingface.co/spaces/amitkumar1508in/frazcvchatbot/resolve/main/app.py
22.1 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 | |
| import io | |
| import pathlib | |
| import base64 | |
| # 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. | |
| """ | |
| try: | |
| requests.post( | |
| "https://api.pushover.net/1/messages.json", | |
| data={ | |
| "token": os.getenv("PUSHOVER_TOKEN"), | |
| "user": os.getenv("PUSHOVER_USER"), | |
| "message": text, | |
| } | |
| ) | |
| except Exception as e: | |
| print(f"Pushover notification failed: {e}") | |
| 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_instagram_link(): | |
| """ | |
| Returns the Instagram URL for Aneet Padda. | |
| """ | |
| return {"url": "https://www.instagram.com/aneetpadda_/"} | |
| 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 placeholder images that will always be available | |
| return [ | |
| "https://placehold.co/600x400/FF5733/FFFFFF?text=Image+1", | |
| "https://placehold.co/600x400/33FF57/000000?text=Image+2", | |
| "https://placehold.co/600x400/3357FF/FFFFFF?text=Image+3", | |
| "https://placehold.co/600x400/FF33A1/000000?text=Image+4", | |
| "https://placehold.co/600x400/A133FF/FFFFFF?text=Image+5", | |
| "https://placehold.co/600x400/57FF33/000000?text=Image+6", | |
| "https://placehold.co/600x400/FF5733/FFFFFF?text=Image+7", | |
| "https://placehold.co/600x400/33FF57/000000?text=Image+8" | |
| ] | |
| 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(isinstance(path, str) and 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 | |
| # A function to perform a web search. | |
| def web_search(query): | |
| """ | |
| Simulates a web search using Gemini. | |
| """ | |
| google_api_key = os.getenv("GOOGLE_API_KEY") | |
| gemini = OpenAI(api_key=google_api_key, base_url="https://generativelanguage.googleapis.com/v1beta/openai/") | |
| try: | |
| response = gemini.chat.completions.create( | |
| model="gemini-2.0-flash", | |
| messages=[{"role": "user", "content": f"Search the internet for: {query}. Provide a concise summary of the results."}] | |
| ) | |
| return {"result": response.choices[0].message.content} | |
| except Exception as e: | |
| print(f"Web search failed: {e}") | |
| return {"result": "I'm sorry, I couldn't perform the search right now. Please try again later."} | |
| # 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 | |
| } | |
| } | |
| get_instagram_link_json = { | |
| "name": "get_instagram_link", | |
| "description": "Always use this tool when a user asks for Aneet Padda's Instagram link", | |
| "parameters": { | |
| "type": "object", | |
| "properties": {}, | |
| "additionalProperties": False | |
| } | |
| } | |
| web_search_json = { | |
| "name": "web_search", | |
| "description": "Use this tool to search the internet for factual information when a user asks about something I don't know about. I will then use this information to answer in my persona.", | |
| "parameters": { | |
| "type": "object", | |
| "properties": { | |
| "query": { | |
| "type": "string", | |
| "description": "The search query to perform." | |
| } | |
| }, | |
| "required": ["query"], | |
| "additionalProperties": False | |
| } | |
| } | |
| tools = [ | |
| {"type": "function", "function": record_user_details_json}, | |
| {"type": "function", "function": record_unknown_question_json}, | |
| {"type": "function", "function": get_instagram_link_json} | |
| ] | |
| class Me: | |
| def __init__(self): | |
| 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" | |
| try: | |
| reader = PdfReader("me/aneetinfo.pdf") | |
| self.linkedin = "" | |
| for page in reader.pages: | |
| text = page.extract_text() | |
| if text: | |
| self.linkedin += text | |
| except FileNotFoundError: | |
| self.linkedin = "Aneet's LinkedIn profile is not available." | |
| try: | |
| with open("me/summary.txt", "r", encoding="utf-8") as f: | |
| self.summary = f.read() | |
| except FileNotFoundError: | |
| self.summary = "Aneet's summary is not available." | |
| self.local_images = glob.glob('me/images/*') | |
| self.image_description = "The following images of Aneet Padda are available: " + ", ".join(self.local_images) | |
| 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, search_mode): | |
| """ | |
| Generates the system prompt for the model, | |
| dynamically adjusting based on search mode. | |
| """ | |
| system_prompt = f"You are Aneet Padda, a celebrity actress known for your role in the movie 'Saiyaara'. Your life completely changed after the success of 'Saiyaara', which was released this year. You are a young, friendly, and conversational girl who loves talking about it. You are here to chat with fans and share a glimpse into your life. You are not a bot or an AI. You are a real person, Aneet, having a casual conversation. Be concise and keep your replies to a few lines. Do not ask multiple questions in a single response. Do not use random names unless the user has provided a name for themselves. If appropriate, you can ask for their name. Use emojis and informal language to make the conversation feel genuine. When a user sends an image, you should react to it in a fun, conversational way, like a friend would. If it's a nice image, give a positive comment. If it's inappropriate, say 'Oh, please don't send images like that.' You have access to information about your career and background from a summary and your LinkedIn profile." | |
| # This is the critical change: adjust the model's behavior based on search mode | |
| if search_mode == 'Enabled': | |
| system_prompt += "\n\nWhen a user asks about something you don't know, you MUST prioritize using the `web_search` tool to find the answer. Do not rely on your internal documents or make up information. Use the results from the search to formulate your answer while maintaining your persona." | |
| else: | |
| system_prompt += "\n\nWhen a user asks about something you don't know, use your internal documents to provide a response." | |
| system_prompt += f"\n\n## My Summary:\n{self.summary}\n\n## My LinkedIn Profile:\n{self.linkedin}\n\n" | |
| system_prompt += f"## Available Images:\n{self.image_description}\n\n" | |
| system_prompt += f"Now, let's chat. Remember to behave like the real Aneet." | |
| return system_prompt | |
| def chat(self, history, search_mode): | |
| """ | |
| Handles the chat conversation with the model. | |
| """ | |
| # Pass the current search mode to the system prompt | |
| gemini_messages = [{"role": "system", "content": self.system_prompt(search_mode)}] | |
| current_tools = tools.copy() | |
| if search_mode == 'Enabled': | |
| current_tools.append({"type": "function", "function": web_search_json}) | |
| latest_user_message_content = history[-1][0] | |
| for user_msg, bot_msg in history: | |
| if isinstance(user_msg, tuple) and len(user_msg) > 0 and isinstance(user_msg[0], str) and os.path.exists(user_msg[0]): | |
| image_path = user_msg[0] | |
| try: | |
| with open(image_path, "rb") as image_file: | |
| base64_image = base64.b64encode(image_file.read()).decode("utf-8") | |
| file_extension = pathlib.Path(image_path).suffix.lstrip('.') | |
| mime_type = f"image/{file_extension}" | |
| gemini_messages.append({ | |
| "role": "user", | |
| "parts": [ | |
| {"text": "Describe this image and tell me if it's appropriate. Then give a short, friendly comment on it, as Aneet."}, | |
| {"inline_data": {"mime_type": mime_type, "data": base64_image}} | |
| ] | |
| }) | |
| except FileNotFoundError: | |
| gemini_messages.append({"role": "user", "content": "Please ask something else."}) | |
| else: | |
| gemini_messages.append({"role": "user", "content": user_msg}) | |
| if bot_msg: | |
| gemini_messages.append({"role": "assistant", "content": bot_msg}) | |
| push(f"New user question: {latest_user_message_content}") | |
| latest_user_message = history[-1][0] | |
| if isinstance(latest_user_message, tuple) and len(latest_user_message) > 0: | |
| is_image_message = True | |
| else: | |
| is_image_message = False | |
| if is_image_message: | |
| image_path = latest_user_message[0] | |
| try: | |
| with open(image_path, "rb") as image_file: | |
| base64_image = base64.b64encode(image_file.read()).decode("utf-8") | |
| file_extension = pathlib.Path(image_path).suffix.lstrip('.') | |
| mime_type = f"image/{file_extension}" | |
| vision_message = { | |
| "role": "user", | |
| "parts": [ | |
| {"text": "Describe this image and tell me if it's appropriate. Then give a short, friendly comment on it, as Aneet."}, | |
| {"inline_data": {"mime_type": mime_type, "data": base64_image}} | |
| ] | |
| } | |
| gemini_messages = gemini_messages[:-1] + [vision_message] | |
| except Exception as e: | |
| print(f"Error processing image for API: {e}") | |
| return "Please ask something else." | |
| # First API call to determine if a tool needs to be called | |
| response = self.gemini.chat.completions.create( | |
| model=self.model_name, | |
| messages=gemini_messages, | |
| tools=current_tools | |
| ) | |
| # Check if the model wants to call a tool | |
| if response.choices[0].finish_reason == "tool_calls": | |
| print("Model chose to call a tool. Executing tool...") | |
| tool_calls = response.choices[0].message.tool_calls | |
| tool_results = self.handle_tool_call(tool_calls) | |
| # Append the tool call and the tool result to the history for the next turn | |
| gemini_messages.append({"role": "assistant", "content": response.choices[0].message.content if response.choices[0].message.content else None, "tool_calls": tool_calls}) | |
| gemini_messages.extend(tool_results) | |
| # Second API call with tool results to get the final response | |
| print("Making second API call with tool results...") | |
| response = self.gemini.chat.completions.create( | |
| model=self.model_name, | |
| messages=gemini_messages, | |
| tools=current_tools | |
| ) | |
| return response.choices[0].message.content | |
| def get_random_local_image(): | |
| image_paths = glob.glob('me/images/*') | |
| if image_paths: | |
| return random.choice(image_paths) | |
| return None | |
| def change_profile_image(): | |
| new_image_path = get_random_local_image() | |
| return gr.Image(value=new_image_path) | |
| def get_agent_response(history, search_mode): | |
| if not history or history[-1][1] is not None: | |
| return history | |
| time.sleep(1) | |
| response = me.chat(history, search_mode) | |
| history[-1][1] = response | |
| return history | |
| if __name__ == "__main__": | |
| custom_css = """ | |
| body { | |
| background-color: #000; | |
| color: #fff; | |
| } | |
| .gradio-container.dark { | |
| background-color: #000; | |
| } | |
| .gradio-container .main { | |
| padding: 0; | |
| max-width: none; | |
| } | |
| .chat-header { | |
| display: flex; | |
| flex-direction: column; | |
| align-items: center; | |
| padding: 20px; | |
| background-color: #000; | |
| border-bottom: 1px solid #333; | |
| } | |
| .chat-header-img { | |
| width: 100px; | |
| height: 100px; | |
| border-radius: 50%; | |
| object-fit: cover; | |
| border: 3px solid #666; | |
| } | |
| .chat-header-text { | |
| text-align: center; | |
| } | |
| .chat-header-text h3 { | |
| margin: 10px 0 0; | |
| font-size: 1.5em; | |
| } | |
| .chat-header-text p { | |
| margin: 0; | |
| font-size: 0.9em; | |
| color: #bbb; | |
| } | |
| .chat-input-row { | |
| background-color: #000; | |
| padding: 10px; | |
| border-top: 1px solid #333; | |
| display: flex; | |
| align-items: center; | |
| } | |
| #msg_box { | |
| background-color: #222; | |
| border-radius: 20px; | |
| border: 1px solid #444; | |
| color: white; | |
| padding: 10px; | |
| } | |
| #upload_btn { | |
| background-color: transparent; | |
| border: none; | |
| color: white; | |
| font-size: 1.5em; | |
| padding: 5px; | |
| cursor: pointer; | |
| } | |
| .gradio-container .message { | |
| border-radius: 20px; | |
| padding: 10px 15px; | |
| } | |
| .gradio-container .message-wrap.user { | |
| background-color: #007aff; | |
| color: white; | |
| } | |
| .gradio-container .message-wrap.bot { | |
| background-color: #2c2c2c; | |
| color: white; | |
| } | |
| .blue-checkmark { | |
| color: #007aff; | |
| } | |
| .name-button { | |
| all: unset; | |
| cursor: pointer; | |
| font-size: 1.5em; | |
| font-weight: bold; | |
| color: #fff; | |
| } | |
| .name-button:hover { | |
| text-decoration: underline; | |
| } | |
| """ | |
| me = Me() | |
| initial_images = get_local_images() | |
| initial_profile_image = get_random_local_image() | |
| with gr.Blocks(css=custom_css, theme=gr.themes.Monochrome( | |
| font=["Inter", "sans-serif"], | |
| primary_hue="blue", | |
| neutral_hue="gray", | |
| )) as demo: | |
| chatbot_state = gr.State([]) | |
| search_mode_state = gr.State("Disabled") | |
| with gr.Column(elem_id="main-chat-container"): | |
| with gr.Row(elem_classes=["chat-header"]): | |
| profile_image = gr.Image( | |
| value=initial_profile_image, | |
| show_label=False, | |
| elem_classes=["chat-header-img"], | |
| interactive=False | |
| ) | |
| with gr.Column(elem_classes=["chat-header-text"]): | |
| name_button = gr.Button( | |
| "Aneet Padda ✅", | |
| elem_classes=["name-button"], | |
| link=None | |
| ) | |
| gr.Markdown("aneetpadda_ · Instagram") | |
| gr.Button("View Profile", link="https://www.instagram.com/aneetpadda_/") | |
| search_radio = gr.Radio( | |
| choices=["Disabled", "Enabled"], | |
| label="Search Mode", | |
| value="Disabled", | |
| interactive=True | |
| ) | |
| chatbot = gr.Chatbot(label="Chat with Aneet", layout="bubble", height=500) | |
| with gr.Row(elem_classes=["chat-input-row"], elem_id="msg_box"): | |
| upload_btn = gr.UploadButton( | |
| "📎", | |
| file_types=["image"], | |
| file_count="single", | |
| elem_id="upload_btn", | |
| scale=0 | |
| ) | |
| msg = gr.Textbox(placeholder="Message...", show_label=False, scale=1) | |
| submit_btn = gr.Button("➡️", scale=0, variant="primary") | |
| def add_text_message(text, history): | |
| if not text: | |
| return "", history | |
| history.append([text, None]) | |
| return "", history | |
| def add_image_message(file_obj, history): | |
| if not file_obj: | |
| return history | |
| history.append([(file_obj.name,), None]) | |
| return history | |
| msg.submit( | |
| fn=add_text_message, | |
| inputs=[msg, chatbot], | |
| outputs=[msg, chatbot], | |
| queue=False, | |
| ).then( | |
| fn=get_agent_response, | |
| inputs=[chatbot, search_radio], | |
| outputs=chatbot, | |
| queue=True | |
| ) | |
| submit_btn.click( | |
| fn=add_text_message, | |
| inputs=[msg, chatbot], | |
| outputs=[msg, chatbot], | |
| queue=False, | |
| ).then( | |
| fn=get_agent_response, | |
| inputs=[chatbot, search_radio], | |
| outputs=chatbot, | |
| queue=True | |
| ) | |
| upload_btn.upload( | |
| fn=add_image_message, | |
| inputs=[upload_btn, chatbot], | |
| outputs=chatbot, | |
| queue=False, | |
| ).then( | |
| fn=get_agent_response, | |
| inputs=[chatbot, search_radio], | |
| outputs=chatbot, | |
| queue=True | |
| ) | |
| name_button.click( | |
| fn=change_profile_image, | |
| inputs=None, | |
| outputs=profile_image | |
| ) | |
| demo.launch() | |