Update app.py

app.py

@@ -193,8 +193,10 @@ def generate_summary(bookmark):
         bookmark['summary'] = bookmark.get('title', 'No summary available.')
         return bookmark
 
-# Function to parse bookmarks from HTML
 def parse_bookmarks(file_content):
+    """
+    Parse bookmarks from HTML file.
+    """
     logger.info("Parsing bookmarks")
     try:
         soup = BeautifulSoup(file_content, 'html.parser')
@@ -210,8 +212,10 @@ def parse_bookmarks(file_content):
         logger.error("Error parsing bookmarks: %s", e)
         raise
 
-# Asynchronous function to fetch URL info
 async def fetch_url_info(session, bookmark):
+    """
+    Fetch information about a URL asynchronously.
+    """
     url = bookmark['url']
     if url in fetch_cache:
         bookmark.update(fetch_cache[url])
@@ -230,8 +234,7 @@ async def fetch_url_info(session, bookmark):
             else:
                 bookmark['dead_link'] = False
                 content = await response.text()
-                bookmark['html_content'] = content  # Store HTML content for summary generation
-                soup = BeautifulSoup(content, 'html.parser')
+                bookmark['html_content'] = content
                 bookmark['description'] = ''  # Will be set by generate_summary function
                 logger.info(f"Fetched information for {url}")
     except Exception as e:
@@ -251,8 +254,10 @@ async def fetch_url_info(session, bookmark):
         }
     return bookmark
 
-# Asynchronous processing of bookmarks
 async def process_bookmarks_async(bookmarks_list):
+    """
+    Process all bookmarks asynchronously.
+    """
     logger.info("Processing bookmarks asynchronously")
     try:
         async with aiohttp.ClientSession() as session:
@@ -266,8 +271,10 @@ async def process_bookmarks_async(bookmarks_list):
         logger.error(f"Error in asynchronous processing of bookmarks: {e}")
         raise
 
-# Assign category to a bookmark
 def assign_category(bookmark):
+    """
+    Assign a category to a bookmark based on its content.
+    """
     if bookmark.get('dead_link'):
         bookmark['category'] = 'Dead Link'
         logger.info(f"Assigned category 'Dead Link' to bookmark: {bookmark.get('url')}")
@@ -314,8 +321,10 @@ def assign_category(bookmark):
         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_list):
+    """
+    Create vector embeddings for bookmarks and build FAISS index.
+    """
     logger.info("Vectorizing summaries and building FAISS index")
     try:
         summaries = [bookmark['summary'] for bookmark in bookmarks_list]
@@ -329,12 +338,14 @@ def vectorize_and_index(bookmarks_list):
         logger.error(f"Error in vectorizing and indexing: {e}")
         raise
 
-# Generate HTML display for bookmarks
 def display_bookmarks():
+    """
+    Generate HTML display for bookmarks.
+    """
     logger.info("Generating HTML display for bookmarks")
     cards = ''
     for i, bookmark in enumerate(bookmarks):
-        index = i + 1  # Start index at 1
+        index = i + 1
         status = "❌ Dead Link" if bookmark.get('dead_link') else "✅ Active"
         title = bookmark['title']
         url = bookmark['url']
@@ -342,7 +353,6 @@ def display_bookmarks():
         summary = bookmark.get('summary', '')
         category = bookmark.get('category', 'Uncategorized')
 
-        # Apply inline styles using CSS variables
         if bookmark.get('dead_link'):
             card_style = "border: 2px solid var(--error-color);"
             text_style = "color: var(--error-color);"
@@ -365,35 +375,46 @@ def display_bookmarks():
     logger.info("HTML display generated")
     return cards
 
-# Process the uploaded file
 def process_uploaded_file(file):
+    """
+    Process the uploaded bookmarks file.
+    """
+    global bookmarks, faiss_index
+    logger.info("Processing uploade
+
+def process_uploaded_file(file):
+    """
+    Process the uploaded bookmarks file.
+    """
     global bookmarks, faiss_index
     logger.info("Processing uploaded file")
+    
     if file is None:
         logger.warning("No file uploaded")
-        return "Please upload a bookmarks HTML file.", '', gr.update(choices=[]), display_bookmarks()
+        return "Please upload a bookmarks HTML file.", ''
+
     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.", '', gr.update(choices=[]), display_bookmarks()
+        return "Error decoding the file. Please ensure it's a valid HTML file.", ''
 
     try:
         bookmarks = parse_bookmarks(file_content)
     except Exception as e:
         logger.error(f"Error parsing bookmarks: {e}")
-        return "Error parsing the bookmarks HTML file.", '', gr.update(choices=[]), display_bookmarks()
+        return "Error parsing the bookmarks HTML file.", ''
 
     if not bookmarks:
         logger.warning("No bookmarks found in the uploaded file")
-        return "No bookmarks found in the uploaded file.", '', gr.update(choices=[]), display_bookmarks()
+        return "No bookmarks found in the uploaded file.", ''
 
     # 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.", '', gr.update(choices=[]), display_bookmarks()
+        return "Error processing bookmarks.", ''
 
     # Generate summaries and assign categories
     for bookmark in bookmarks:
@@ -404,73 +425,85 @@ def process_uploaded_file(file):
         faiss_index, embeddings = vectorize_and_index(bookmarks)
     except Exception as e:
         logger.error(f"Error building FAISS index: {e}")
-        return "Error building search index.", '', gr.update(choices=[]), display_bookmarks()
+        return "Error building search index.", ''
 
     message = f"✅ Successfully processed {len(bookmarks)} bookmarks."
     logger.info(message)
     bookmark_html = display_bookmarks()
 
-    # Update bookmark_selector choices
-    choices = [f"{i+1}. {bookmark['title']} (Category: {bookmark['category']})" for i, bookmark in enumerate(bookmarks)]
-    bookmark_selector_update = gr.update(choices=choices, value=[])
+    return message, bookmark_html
 
-    # Update bookmark_display_manage
-    bookmark_display_manage_update = display_bookmarks()
-
-    return message, bookmark_html, bookmark_selector_update, bookmark_display_manage_update
+def update_bookmark_selector():
+    """
+    Update the bookmark selector choices for the Manage Bookmarks tab.
+    """
+    choices = [f"{i+1}. {bookmark['title']} (Category: {bookmark['category']})" 
+              for i, bookmark in enumerate(bookmarks)]
+    return gr.update(choices=choices, value=[])
 
-# Delete selected bookmarks
 def delete_selected_bookmarks(selected_indices):
+    """
+    Delete selected bookmarks.
+    """
     global bookmarks, faiss_index
     if not selected_indices:
-        return "⚠️ No bookmarks selected.", gr.update(choices=[]), display_bookmarks()
+        return "⚠️ No bookmarks selected.", gr.update(choices=[]), ''
+
     indices = [int(s.split('.')[0])-1 for s in selected_indices]
     indices = sorted(indices, reverse=True)
     for idx in indices:
         if 0 <= idx < len(bookmarks):
             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)
-    # Update bookmark_selector choices
-    choices = [f"{i+1}. {bookmark['title']} (Category: {bookmark['category']})" for i, bookmark in enumerate(bookmarks)]
-    bookmark_selector_update = gr.update(choices=choices, value=[])
-    # Update bookmarks display
+    
+    # Update display and selector
+    bookmark_selector_update = update_bookmark_selector()
     bookmarks_html = display_bookmarks()
+    
     return message, bookmark_selector_update, bookmarks_html
 
-# Edit category of selected bookmarks
 def edit_selected_bookmarks_category(selected_indices, new_category):
+    """
+    Edit category of selected bookmarks.
+    """
     if not selected_indices:
-        return "⚠️ No bookmarks selected.", '', gr.update()
+        return "⚠️ No bookmarks selected.", gr.update(choices=[]), ''
     if not new_category:
-        return "⚠️ No new category selected.", '', gr.update()
+        return "⚠️ No new category selected.", gr.update(choices=[]), ''
+
     indices = [int(s.split('.')[0])-1 for s in selected_indices]
     for idx in indices:
         if 0 <= idx < len(bookmarks):
             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)
-    # Update bookmark_selector choices
-    choices = [f"{i+1}. {bookmark['title']} (Category: {bookmark['category']})" for i, bookmark in enumerate(bookmarks)]
-    bookmark_selector_update = gr.update(choices=choices, value=[])
-    # Update bookmarks display
+    
+    # Update display and selector
+    bookmark_selector_update = update_bookmark_selector()
     bookmarks_html = display_bookmarks()
+    
     return message, bookmark_selector_update, bookmarks_html
 
-# Export bookmarks to HTML
 def export_bookmarks():
+    """
+    Export bookmarks to HTML file.
+    """
     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("<!DOCTYPE NETSCAPE-Bookmark-file-1><Title>Bookmarks</Title><H1>Bookmarks</H1>", 'html.parser')
         dl = soup.new_tag('DL')
         for bookmark in bookmarks:
@@ -481,7 +514,6 @@ def export_bookmarks():
             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")
@@ -490,11 +522,13 @@ def export_bookmarks():
         logger.error(f"Error exporting bookmarks: {e}")
         return "⚠️ Error exporting bookmarks."
 
-# Chatbot response using Groq Cloud API
 def chatbot_response(user_query):
+    """
+    Generate chatbot response using Groq Cloud API.
+    """
     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."
+        return "⚠️ API key not set. Please set the GROQ_API_KEY environment variable."
 
     if not bookmarks:
         logger.warning("No bookmarks available for chatbot")
@@ -503,26 +537,23 @@ def chatbot_response(user_query):
     logger.info(f"Chatbot received query: {user_query}")
 
     try:
-        # Limit the number of bookmarks to prevent exceeding token limits
-        max_bookmarks = 50  # Adjust as needed
+        max_bookmarks = 50
         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.
+        You are an assistant that helps users find relevant bookmarks from their collection based on their queries.
 
-User Query:
-{user_query}
+        User Query:
+        {user_query}
 
-Bookmarks:
-{bookmark_data}
+        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.
-"""
+        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',
             messages=[
@@ -533,7 +564,6 @@ Please identify the most relevant bookmarks that match the user's query. Provide
             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
@@ -541,11 +571,12 @@ Please identify the most relevant bookmarks that match the user's query. Provide
     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():
+    """
+    Build and launch the Gradio app.
+    """
     try:
         logger.info("Building Gradio app")
         with gr.Blocks(css="app.css") as demo:
@@ -553,7 +584,7 @@ def build_app():
             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.
+            Welcome to **SmartMarks**, your intelligent assistant for managing browser bookmarks. SmartMarks leverages AI to help you organize, search, and interact with your bookmarks seamlessly.
 
             ---
 
@@ -564,8 +595,6 @@ def build_app():
             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.
             """)
 
             # Upload and Process Bookmarks Tab
@@ -573,33 +602,21 @@ def build_app():
                 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.
+                ### 📝 **Steps:**
+                1. Click on the "Upload Bookmarks HTML File" button
+                2. Select your bookmarks file
+                3. Click "Process Bookmarks" to analyze and organize your bookmarks
                 """)
 
                 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")
-
-                # Initialize Manage Bookmarks components
-                bookmark_selector = gr.CheckboxGroup(label="✅ Select Bookmarks", choices=[])
-                bookmark_display_manage = gr.HTML(label="📄 Manage Bookmarks Display")
+                bookmark_display = gr.HTML(label="📄 Processed Bookmarks")
 
                 process_button.click(
                     process_uploaded_file,
                     inputs=upload,
-                    outputs=[output_text, bookmark_display, bookmark_selector, bookmark_display_manage]
+                    outputs=[output_text, bookmark_display]
                 )
 
             # Chat with Bookmarks Tab
@@ -607,21 +624,15 @@ def build_app():
                 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:**
-                   - 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.
+                Ask questions about your bookmarks and get relevant results.
                 """)
 
-                user_input = gr.Textbox(label="✍️ Ask about your bookmarks", placeholder="e.g., Do I have any bookmarks about GenerativeAI?")
-                chat_output = gr.Textbox(label="💬 Chatbot Response", interactive=False)
+                user_input = gr.Textbox(
+                    label="✍️ Ask about your bookmarks",
+                    placeholder="e.g., Do I have any bookmarks about AI?"
+                )
                 chat_button = gr.Button("📨 Send")
+                chat_output = gr.Textbox(label="💬 Response", interactive=False)
 
                 chat_button.click(
                     chatbot_response,
@@ -634,39 +645,28 @@ def build_app():
                 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.
+                Select bookmarks to delete or edit their categories.
                 """)
 
-                manage_output = gr.Textbox(label="🔄 Manage Output", interactive=False)
-                bookmark_display_manage = gr.HTML(label="📄 Manage Bookmarks Display")
-                bookmark_selector = gr.CheckboxGroup(label="✅ Select Bookmarks", choices=[])
+                manage_output = gr.Textbox(label="🔄 Status", interactive=False)
+                bookmark_selector = gr.CheckboxGroup(
+                    label="✅ Select Bookmarks",
+                    choices=[]
+                )
+                new_category = gr.Dropdown(
+                    label="🆕 New Category",
+                    choices=CATEGORIES,
+                    value="Uncategorized"
+                )
 
-                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")
+                    delete_button = gr.Button("🗑️ Delete Selected")
+                    edit_category_button = gr.Button("✏️ Edit Category")
+                    export_button = gr.Button("💾 Export")
+
+                bookmark_display_manage = gr.HTML(label="📄 Bookmarks")
+                download_link = gr.HTML(label="📥 Download")
 
-                # Define button actions
                 delete_button.click(
                     delete_selected_bookmarks,
                     inputs=bookmark_selector,
@@ -675,23 +675,15 @@ def build_app():
 
                 edit_category_button.click(
                     edit_selected_bookmarks_category,
-                    inputs=[bookmark_selector, new_category_input],
+                    inputs=[bookmark_selector, new_category],
                     outputs=[manage_output, bookmark_selector, bookmark_display_manage]
                 )
 
                 export_button.click(
                     export_bookmarks,
-                    inputs=None,
                     outputs=download_link
                 )
 
-                # Initialize display after processing bookmarks
-                process_button.click(
-                    process_uploaded_file,
-                    inputs=upload,
-                    outputs=[output_text, bookmark_display, bookmark_selector, bookmark_display_manage]
-                )
-
         logger.info("Launching Gradio app")
         demo.launch(debug=True)
     except Exception as e: