# app.py import gradio as gr from bs4 import BeautifulSoup import asyncio import aiohttp import re import base64 import logging import os import sys from sentence_transformers import SentenceTransformer import faiss import numpy as np import openai # Set up logging to output to the console logger = logging.getLogger(__name__) logger.setLevel(logging.INFO) console_handler = logging.StreamHandler(sys.stdout) console_handler.setLevel(logging.INFO) formatter = logging.Formatter('%(asctime)s %(levelname)s %(name)s %(message)s') console_handler.setFormatter(formatter) logger.addHandler(console_handler) # Initialize models and variables logger.info("Initializing models and variables") embedding_model = SentenceTransformer('all-MiniLM-L6-v2') faiss_index = None fetch_cache = {} # Define the categories CATEGORIES = [ "Social Media", "News and Media", "Education and Learning", "Entertainment", "Shopping and E-commerce", "Finance and Banking", "Technology", "Health and Fitness", "Travel and Tourism", "Food and Recipes", "Sports", "Arts and Culture", "Government and Politics", "Business and Economy", "Science and Research", "Personal Blogs and Journals", "Job Search and Careers", "Music and Audio", "Videos and Movies", "Reference and Knowledge Bases", "Dead Link", "Uncategorized", ] # Set up Groq Cloud API key and base URL GROQ_API_KEY = os.getenv('GROQ_API_KEY') if not GROQ_API_KEY: logger.error("GROQ_API_KEY environment variable not set.") # Set OpenAI API key and base URL to use Groq Cloud API openai.api_key = GROQ_API_KEY openai.api_base = "https://api.groq.com/openai/v1" # Corrected API base URL # Function to parse bookmarks from HTML def parse_bookmarks(file_content): logger.info("Parsing bookmarks") try: soup = BeautifulSoup(file_content, 'html.parser') extracted_bookmarks = [] for link in soup.find_all('a'): url = link.get('href') title = link.text.strip() if url and title: extracted_bookmarks.append({'url': url, 'title': title}) logger.info(f"Extracted {len(extracted_bookmarks)} bookmarks") return extracted_bookmarks except Exception as e: logger.error("Error parsing bookmarks: %s", e) raise # Asynchronous function to fetch URL info async def fetch_url_info(session, bookmark): url = bookmark['url'] if url in fetch_cache: bookmark.update(fetch_cache[url]) return bookmark try: logger.info(f"Fetching URL info for: {url}") async with session.get(url, timeout=5) as response: bookmark['etag'] = response.headers.get('ETag', 'N/A') bookmark['status_code'] = response.status if response.status >= 400: bookmark['dead_link'] = True bookmark['description'] = '' logger.warning(f"Dead link detected: {url} with status {response.status}") else: bookmark['dead_link'] = False content = await response.text() soup = BeautifulSoup(content, 'html.parser') # Extract meta description or Open Graph description meta_description = soup.find('meta', attrs={'name': 'description'}) og_description = soup.find('meta', attrs={'property': 'og:description'}) if og_description and og_description.get('content'): description = og_description.get('content') elif meta_description and meta_description.get('content'): description = meta_description.get('content') else: description = '' bookmark['description'] = description logger.info(f"Fetched description for {url}") except Exception as e: bookmark['dead_link'] = True bookmark['etag'] = 'N/A' bookmark['status_code'] = 'N/A' bookmark['description'] = '' logger.error(f"Error fetching URL info for {url}: {e}") finally: fetch_cache[url] = { 'etag': bookmark.get('etag'), 'status_code': bookmark.get('status_code'), 'dead_link': bookmark.get('dead_link'), 'description': bookmark.get('description'), } return bookmark # Asynchronous processing of bookmarks async def process_bookmarks_async(bookmarks): logger.info("Processing bookmarks asynchronously") try: async with aiohttp.ClientSession() as session: tasks = [] for bookmark in bookmarks: task = asyncio.ensure_future(fetch_url_info(session, bookmark)) tasks.append(task) await asyncio.gather(*tasks) logger.info("Completed processing bookmarks asynchronously") except Exception as e: logger.error(f"Error in asynchronous processing of bookmarks: {e}") raise # Generate summary for a bookmark def generate_summary(bookmark): description = bookmark.get('description', '') if description: bookmark['summary'] = description else: title = bookmark.get('title', '') if title: bookmark['summary'] = title else: bookmark['summary'] = 'No summary available.' logger.info(f"Generated summary for bookmark: {bookmark.get('url')}") return bookmark # Assign category to a bookmark def assign_category(bookmark): if bookmark.get('dead_link'): bookmark['category'] = 'Dead Link' logger.info(f"Assigned category 'Dead Link' to bookmark: {bookmark.get('url')}") return bookmark summary = bookmark.get('summary', '').lower() assigned_category = 'Uncategorized' # Keywords associated with each category category_keywords = { "Social Media": ["social media", "networking", "friends", "connect", "posts", "profile"], "News and Media": ["news", "journalism", "media", "headlines", "breaking news"], "Education and Learning": ["education", "learning", "courses", "tutorial", "university", "academy", "study"], "Entertainment": ["entertainment", "movies", "tv shows", "games", "comics", "fun"], "Shopping and E-commerce": ["shopping", "e-commerce", "buy", "sell", "marketplace", "deals", "store"], "Finance and Banking": ["finance", "banking", "investment", "money", "economy", "stock", "trading"], "Technology": ["technology", "tech", "gadgets", "software", "computers", "innovation"], "Health and Fitness": ["health", "fitness", "medical", "wellness", "exercise", "diet"], "Travel and Tourism": ["travel", "tourism", "destinations", "hotels", "flights", "vacation"], "Food and Recipes": ["food", "recipes", "cooking", "cuisine", "restaurant", "dining"], "Sports": ["sports", "scores", "teams", "athletics", "matches", "leagues"], "Arts and Culture": ["arts", "culture", "museum", "gallery", "exhibition", "artistic"], "Government and Politics": ["government", "politics", "policy", "election", "public service"], "Business and Economy": ["business", "corporate", "industry", "economy", "markets"], "Science and Research": ["science", "research", "experiment", "laboratory", "study", "scientific"], "Personal Blogs and Journals": ["blog", "journal", "personal", "diary", "thoughts", "opinions"], "Job Search and Careers": ["jobs", "careers", "recruitment", "resume", "employment", "hiring"], "Music and Audio": ["music", "audio", "songs", "albums", "artists", "bands"], "Videos and Movies": ["video", "movies", "film", "clips", "trailers", "cinema"], "Reference and Knowledge Bases": ["reference", "encyclopedia", "dictionary", "wiki", "knowledge", "information"], } for category, keywords in category_keywords.items(): for keyword in keywords: if re.search(r'\b' + re.escape(keyword) + r'\b', summary): assigned_category = category logger.info(f"Assigned category '{assigned_category}' to bookmark: {bookmark.get('url')}") break if assigned_category != 'Uncategorized': break bookmark['category'] = assigned_category if assigned_category == 'Uncategorized': logger.info(f"No matching category found for bookmark: {bookmark.get('url')}") return bookmark # Vectorize summaries and build FAISS index def vectorize_and_index(bookmarks): logger.info("Vectorizing summaries and building FAISS index") try: summaries = [bookmark['summary'] for bookmark in bookmarks] embeddings = embedding_model.encode(summaries) dimension = embeddings.shape[1] faiss_idx = faiss.IndexFlatL2(dimension) faiss_idx.add(np.array(embeddings)) logger.info("FAISS index built successfully") return faiss_idx, embeddings except Exception as e: logger.error(f"Error in vectorizing and indexing: {e}") raise # Generate HTML display for bookmarks def display_bookmarks(bookmarks_list): logger.info("Generating HTML display for bookmarks") cards = '' for i, bookmark in enumerate(bookmarks_list): index = i + 1 # Start index at 1 status = "❌ Dead Link" if bookmark.get('dead_link') else "✅ Active" title = bookmark['title'] url = bookmark['url'] etag = bookmark.get('etag', 'N/A') summary = bookmark.get('summary', '') category = bookmark.get('category', 'Uncategorized') # Assign CSS classes based on bookmark status if bookmark.get('dead_link'): card_classes = "card dead-link" else: card_classes = "card active-link" card_html = f'''

{index}. {title} {status}

Category: {category}

URL: {url}

ETag: {etag}

Summary: {summary}

''' cards += card_html logger.info("HTML display generated") return cards # Function to handle sending messages in chat def send_message(user_message, chat_history, state_bookmarks): if not user_message: return chat_history, chat_history # Append user message to chat history chat_history = chat_history + [(user_message, None)] # Generate chatbot response try: response = chatbot_response(user_message, state_bookmarks) except Exception as e: response = f"⚠️ Error: {str(e)}" # Append assistant response to chat history chat_history[-1] = (user_message, response) return chat_history, chat_history # Process the uploaded file def process_uploaded_file(file, state_bookmarks): logger.info("Processing uploaded file") if file is None: logger.warning("No file uploaded") return ( "⚠️ Please upload a bookmarks HTML file.", "", [], "", state_bookmarks # Return the unchanged state ) try: file_content = file.decode('utf-8') except UnicodeDecodeError as e: logger.error(f"Error decoding the file: {e}") return ( "⚠️ Error decoding the file. Please ensure it's a valid HTML file.", "", [], "", state_bookmarks # Return the unchanged state ) try: bookmarks = parse_bookmarks(file_content) except Exception as e: logger.error(f"Error parsing bookmarks: {e}") return ( "⚠️ Error parsing the bookmarks HTML file.", "", [], "", state_bookmarks # Return the unchanged state ) if not bookmarks: logger.warning("No bookmarks found in the uploaded file") return ( "⚠️ No bookmarks found in the uploaded file.", "", [], "", state_bookmarks # Return the unchanged state ) # Asynchronously fetch bookmark info try: asyncio.run(process_bookmarks_async(bookmarks)) except Exception as e: logger.error(f"Error processing bookmarks asynchronously: {e}") return ( "⚠️ Error processing bookmarks.", "", [], "", state_bookmarks # Return the unchanged state ) # Generate summaries and assign categories for bookmark in bookmarks: generate_summary(bookmark) assign_category(bookmark) try: faiss_index, embeddings = vectorize_and_index(bookmarks) except Exception as e: logger.error(f"Error building FAISS index: {e}") return ( "⚠️ Error building search index.", "", [], "", state_bookmarks # Return the unchanged state ) message = f"✅ Successfully processed {len(bookmarks)} bookmarks." logger.info(message) bookmark_html = display_bookmarks(bookmarks) # Update the shared state updated_state = bookmarks.copy() # Prepare Manage Bookmarks tab outputs choices = [f"{i+1}. {bookmark['title']} (Category: {bookmark['category']})" for i, bookmark in enumerate(bookmarks)] bookmarks_html_manage = display_bookmarks(bookmarks) return ( message, bookmark_html, choices, bookmarks_html_manage, updated_state # Return the updated state ) # Delete selected bookmarks def delete_selected_bookmarks(selected_indices, state_bookmarks): if not selected_indices: return "⚠️ No bookmarks selected.", gr.update(choices=[]), "" bookmarks = state_bookmarks.copy() indices = [] for s in selected_indices: try: idx = int(s.split('.')[0]) - 1 if 0 <= idx < len(bookmarks): indices.append(idx) else: logger.warning(f"Index out of range: {idx + 1}") except ValueError: logger.error(f"Invalid selection format: {s}") indices = sorted(indices, reverse=True) for idx in indices: logger.info(f"Deleting bookmark at index {idx + 1}") bookmarks.pop(idx) if bookmarks: faiss_index, embeddings = vectorize_and_index(bookmarks) else: faiss_index = None message = "🗑️ Selected bookmarks deleted successfully." logger.info(message) # Regenerate HTML display bookmarks_html = display_bookmarks(bookmarks) # Update the shared state updated_state = bookmarks.copy() # Update choices for selection choices = [f"{i+1}. {bookmark['title']} (Category: {bookmark['category']})" for i, bookmark in enumerate(bookmarks)] return message, gr.update(choices=choices), bookmarks_html # Edit category of selected bookmarks def edit_selected_bookmarks_category(selected_indices, new_category, state_bookmarks): if not selected_indices: return ( "⚠️ No bookmarks selected.", gr.update(choices=[f"{i+1}. {bookmark['title']} (Category: {bookmark['category']})" for i, bookmark in enumerate(state_bookmarks)]), display_bookmarks(state_bookmarks) ) if not new_category: return ( "⚠️ No new category selected.", gr.update(choices=[f"{i+1}. {bookmark['title']} (Category: {bookmark['category']})" for i, bookmark in enumerate(state_bookmarks)]), display_bookmarks(state_bookmarks) ) bookmarks = state_bookmarks.copy() indices = [] for s in selected_indices: try: idx = int(s.split('.')[0]) - 1 if 0 <= idx < len(bookmarks): indices.append(idx) else: logger.warning(f"Index out of range: {idx + 1}") except ValueError: logger.error(f"Invalid selection format: {s}") for idx in indices: bookmarks[idx]['category'] = new_category logger.info(f"Updated category for bookmark {idx + 1} to {new_category}") message = "✏️ Category updated for selected bookmarks." logger.info(message) # Regenerate HTML display bookmarks_html = display_bookmarks(bookmarks) # Update the shared state updated_state = bookmarks.copy() # Update choices for selection choices = [f"{i+1}. {bookmark['title']} (Category: {bookmark['category']})" for i, bookmark in enumerate(bookmarks)] return message, gr.update(choices=choices), bookmarks_html # Export bookmarks to HTML def export_bookmarks(state_bookmarks): bookmarks = state_bookmarks if not bookmarks: logger.warning("No bookmarks to export") return "⚠️ No bookmarks to export." try: logger.info("Exporting bookmarks to HTML") # Create an HTML content similar to the imported bookmarks file soup = BeautifulSoup("Bookmarks

Bookmarks

", 'html.parser') dl = soup.new_tag('DL') for bookmark in bookmarks: dt = soup.new_tag('DT') a = soup.new_tag('A', href=bookmark['url']) a.string = bookmark['title'] dt.append(a) dl.append(dt) soup.append(dl) html_content = str(soup) # Encode the HTML content to base64 for download b64 = base64.b64encode(html_content.encode()).decode() href = f'data:text/html;base64,{b64}' logger.info("Bookmarks exported successfully") return f'💾 Download Exported Bookmarks' except Exception as e: logger.error(f"Error exporting bookmarks: {e}") return "⚠️ Error exporting bookmarks." # Chatbot response using Groq Cloud API def chatbot_response(user_query, state_bookmarks): if not GROQ_API_KEY: logger.warning("GROQ_API_KEY not set.") return "⚠️ API key not set. Please set the GROQ_API_KEY environment variable in the Hugging Face Space settings." bookmarks = state_bookmarks if not bookmarks: logger.warning("No bookmarks available for chatbot") return "⚠️ No bookmarks available. Please upload and process your bookmarks first." logger.info(f"Chatbot received query: {user_query}") # Prepare the prompt for the LLM try: # Limit the number of bookmarks to prevent exceeding token limits max_bookmarks = 50 # Adjust as needed bookmark_data = "" for idx, bookmark in enumerate(bookmarks[:max_bookmarks]): bookmark_data += f"{idx+1}. Title: {bookmark['title']}\nURL: {bookmark['url']}\nSummary: {bookmark['summary']}\n\n" # Construct the prompt prompt = f""" You are an assistant that helps users find relevant bookmarks from their collection based on their queries. User Query: {user_query} Bookmarks: {bookmark_data} Please identify the most relevant bookmarks that match the user's query. Provide a concise list including the index, title, URL, and a brief summary. """ # Call the Groq Cloud API via the OpenAI client response = openai.ChatCompletion.create( model='llama3-8b-8192', # Verify this model name with Groq Cloud API documentation messages=[ {"role": "system", "content": "You help users find relevant bookmarks based on their queries."}, {"role": "user", "content": prompt} ], max_tokens=500, temperature=0.7, ) # Extract the response text answer = response['choices'][0]['message']['content'].strip() logger.info("Chatbot response generated using Groq Cloud API") return answer except Exception as e: error_message = f"⚠️ Error processing your query: {str(e)}" logger.error(error_message) print(error_message) # Ensure error appears in Hugging Face Spaces logs return error_message # Build the Gradio app def build_app(): try: logger.info("Building Gradio app") with gr.Blocks(theme=gr.themes.Default(), css="app.css") as demo: # Shared states state_bookmarks = gr.State([]) chat_history = gr.State([]) # General Overview gr.Markdown(""" # 📚 SmartMarks - AI Browser Bookmarks Manager Welcome to **SmartMarks**, your intelligent assistant for managing browser bookmarks. SmartMarks leverages AI to help you organize, search, and interact with your bookmarks seamlessly. Whether you're looking to categorize your links, retrieve information quickly, or maintain an updated list, SmartMarks has you covered. --- ## 🚀 **How to Use SmartMarks** SmartMarks is divided into three main sections: 1. **📂 Upload and Process Bookmarks:** Import your existing bookmarks and let SmartMarks analyze and categorize them for you. 2. **💬 Chat with Bookmarks:** Interact with your bookmarks using natural language queries to find relevant links effortlessly. 3. **🛠️ Manage Bookmarks:** View, edit, delete, and export your bookmarks with ease. Navigate through the tabs to explore each feature in detail. """) # Define Manage Bookmarks components outside the tab for global access bookmark_selector = gr.CheckboxGroup(label="✅ Select Bookmarks", choices=[]) bookmark_display_manage = gr.HTML(label="📄 Manage Bookmarks Display") # Upload and Process Bookmarks Tab with gr.Tab("Upload and Process Bookmarks"): gr.Markdown(""" ## 📂 **Upload and Process Bookmarks** ### 📝 **Steps to Upload and Process:** 1. **🔽 Upload Bookmarks File:** - Click on the **"📁 Upload Bookmarks HTML File"** button. - Select your browser's exported bookmarks HTML file from your device. 2. **⚙️ Process Bookmarks:** - After uploading, click on the **"⚙️ Process Bookmarks"** button. - SmartMarks will parse your bookmarks, fetch additional information, generate summaries, and categorize each link based on predefined categories. 3. **📄 View Processed Bookmarks:** - Once processing is complete, your bookmarks will be displayed in an organized and visually appealing format below. """) upload = gr.File(label="📁 Upload Bookmarks HTML File", type='binary') process_button = gr.Button("⚙️ Process Bookmarks") output_text = gr.Textbox(label="✅ Output", interactive=False) bookmark_display = gr.HTML(label="📄 Bookmarks") process_button.click( process_uploaded_file, inputs=[upload, state_bookmarks], outputs=[output_text, bookmark_display, bookmark_selector, bookmark_display_manage, state_bookmarks] ) # Chat with Bookmarks Tab with gr.Tab("Chat with Bookmarks"): gr.Markdown(""" ## 💬 **Chat with Bookmarks** ### 🤖 **How to Interact:** 1. **✍️ Enter Your Query:** - In the **"✍️ Ask about your bookmarks"** textbox, type your question or keyword related to your bookmarks. For example, "Do I have any bookmarks about GenerativeAI?" 2. **📨 Submit Your Query:** - You can either press the **Enter** key or click the **"📨 Send"** button to submit your query. 3. **📈 Receive AI-Driven Responses:** - SmartMarks will analyze your query and provide relevant bookmarks that match your request, making it easier to find specific links without manual searching. 4. **🗂️ View Chat History:** - All your queries and the corresponding AI responses are displayed in the chat history for your reference. """) with gr.Row(): chat_history_display = gr.Chatbot(label="🗨️ Chat History") with gr.Column(scale=1): chat_input = gr.Textbox( label="✍️ Ask about your bookmarks", placeholder="e.g., Do I have any bookmarks about GenerativeAI?", lines=1, interactive=True ) chat_button = gr.Button("📨 Send") # When user presses Enter in chat_input chat_input.submit( send_message, inputs=[chat_input, chat_history, state_bookmarks], outputs=[chat_history_display, chat_history] ) # When user clicks Send button chat_button.click( send_message, inputs=[chat_input, chat_history, state_bookmarks], outputs=[chat_history_display, chat_history] ) # Manage Bookmarks Tab with gr.Tab("Manage Bookmarks"): gr.Markdown(""" ## 🛠️ **Manage Bookmarks** ### 🗂️ **Features:** 1. **👁️ View Bookmarks:** - All your processed bookmarks are displayed here with their respective categories and summaries. 2. **✅ Select Bookmarks:** - Use the checkboxes next to each bookmark to select one, multiple, or all bookmarks you wish to manage. 3. **🗑️ Delete Selected Bookmarks:** - After selecting the desired bookmarks, click the **"🗑️ Delete Selected Bookmarks"** button to remove them from your list. 4. **✏️ Edit Categories:** - Select the bookmarks you want to re-categorize. - Choose a new category from the dropdown menu labeled **"🆕 New Category"**. - Click the **"✏️ Edit Category of Selected Bookmarks"** button to update their categories. 5. **💾 Export Bookmarks:** - Click the **"💾 Export Bookmarks"** button to download your updated bookmarks as an HTML file. - This file can be uploaded back to your browser to reflect the changes made within SmartMarks. """) manage_output = gr.Textbox(label="🔄 Manage Output", interactive=False) new_category_input = gr.Dropdown(label="🆕 New Category", choices=CATEGORIES, value="Uncategorized") with gr.Row(): delete_button = gr.Button("🗑️ Delete Selected Bookmarks") edit_category_button = gr.Button("✏️ Edit Category of Selected Bookmarks") export_button = gr.Button("💾 Export Bookmarks") download_link = gr.HTML(label="📥 Download Exported Bookmarks") refresh_button = gr.Button("🔄 Refresh Bookmarks") # Define button actions delete_button.click( delete_selected_bookmarks, inputs=[bookmark_selector, state_bookmarks], outputs=[manage_output, bookmark_selector, bookmark_display_manage] ) edit_category_button.click( edit_selected_bookmarks_category, inputs=[bookmark_selector, new_category_input, state_bookmarks], outputs=[manage_output, bookmark_selector, bookmark_display_manage] ) export_button.click( export_bookmarks, inputs=[state_bookmarks], outputs=download_link ) refresh_button.click( lambda bookmarks: ( [ f"{i+1}. {bookmark['title']} (Category: {bookmark['category']})" for i, bookmark in enumerate(bookmarks) ], display_bookmarks(bookmarks) ), inputs=[state_bookmarks], outputs=[bookmark_selector, bookmark_display_manage] ) logger.info("Launching Gradio app") demo.launch(debug=True) except Exception as e: logger.error(f"Error building the app: {e}") print(f"Error building the app: {e}") if __name__ == "__main__": build_app()