Update app.py

app.py

@@ -276,29 +276,29 @@ def process_uploaded_file(file):
     logger.info("Processing uploaded file")
     if file is None:
         logger.warning("No file uploaded")
-        return "Please upload a bookmarks HTML file.", ''
+        return "Please upload a bookmarks HTML file.", '', gr.update(), ''
     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.", ''
+        return "Error decoding the file. Please ensure it's a valid HTML file.", '', gr.update(), ''
 
     try:
         bookmarks = parse_bookmarks(file_content)
     except Exception as e:
         logger.error(f"Error parsing bookmarks: {e}")
-        return "Error parsing the bookmarks HTML file.", ''
+        return "Error parsing the bookmarks HTML file.", '', gr.update(), ''
 
     if not bookmarks:
         logger.warning("No bookmarks found in the uploaded file")
-        return "No bookmarks found in the uploaded file.", ''
+        return "No bookmarks found in the uploaded file.", '', gr.update(), ''
 
     # 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.", ''
+        return "Error processing bookmarks.", '', gr.update(), ''
 
     # Generate summaries and assign categories
     for bookmark in bookmarks:
@@ -309,12 +309,90 @@ 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.", ''
+        return "Error building search index.", '', gr.update(), ''
 
     message = f"Successfully processed {len(bookmarks)} bookmarks."
     logger.info(message)
     bookmark_html = display_bookmarks()
-    return message, bookmark_html
+
+    # 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 bookmark_display_manage
+    bookmark_display_manage_update = display_bookmarks()
+
+    return message, bookmark_html, bookmark_selector_update, bookmark_display_manage_update
+
+# Delete selected bookmarks
+def delete_selected_bookmarks(selected_indices):
+    global bookmarks, faiss_index
+    if not selected_indices:
+        return "No bookmarks selected.", gr.update(), ''
+    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
+    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):
+    if not selected_indices:
+        return "No bookmarks selected.", '', gr.update()
+    if not new_category:
+        return "No new category selected.", '', gr.update()
+    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
+    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
+    bookmarks_html = display_bookmarks()
+    return message, bookmark_selector_update, bookmarks_html
+
+# Export bookmarks to HTML
+def export_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("<!DOCTYPE NETSCAPE-Bookmark-file-1><Title>Bookmarks</Title><H1>Bookmarks</H1>", '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'<a href="{href}" download="bookmarks.html">Download Exported Bookmarks</a>'
+    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):
@@ -371,82 +449,6 @@ Please identify the most relevant bookmarks that match the user's query. Provide
         print(error_message)  # Ensure error appears in Hugging Face Spaces logs
         return error_message
 
-# Edit a bookmark
-def edit_bookmark(bookmark_idx, new_title, new_url, new_category):
-    global faiss_index
-    try:
-        bookmark_idx = int(bookmark_idx) - 1  # Adjust index to match list (starting at 0)
-        if bookmark_idx < 0 or bookmark_idx >= len(bookmarks):
-            logger.warning(f"Invalid bookmark index for editing: {bookmark_idx + 1}")
-            return "Invalid bookmark index.", display_bookmarks()
-        logger.info(f"Editing bookmark at index {bookmark_idx + 1}")
-        bookmarks[bookmark_idx]['title'] = new_title
-        bookmarks[bookmark_idx]['url'] = new_url
-        bookmarks[bookmark_idx]['category'] = new_category
-        # Re-fetch bookmark info
-        asyncio.run(process_bookmarks_async([bookmarks[bookmark_idx]]))
-        generate_summary(bookmarks[bookmark_idx])
-        # Rebuild the FAISS index
-        faiss_index, embeddings = vectorize_and_index(bookmarks)
-        message = "Bookmark updated successfully."
-        logger.info(message)
-        updated_html = display_bookmarks()
-        return message, updated_html
-    except Exception as e:
-        logger.error(f"Error editing bookmark: {e}")
-        return f"Error: {str(e)}", display_bookmarks()
-
-# Delete selected bookmarks
-def delete_bookmarks(indices_str):
-    global faiss_index
-    try:
-        indices = [int(idx.strip()) - 1 for idx in indices_str.split(',') if idx.strip().isdigit()]
-        indices = sorted(indices, reverse=True)
-        logger.info(f"Deleting bookmarks at indices: {indices}")
-        for idx in indices:
-            if 0 <= idx < len(bookmarks):
-                logger.info(f"Deleting bookmark at index {idx + 1}")
-                bookmarks.pop(idx)
-        # Rebuild the FAISS index
-        if bookmarks:
-            faiss_index, embeddings = vectorize_and_index(bookmarks)
-        else:
-            faiss_index = None
-        message = "Selected bookmarks deleted successfully."
-        logger.info(message)
-        updated_html = display_bookmarks()
-        return message, updated_html
-    except Exception as e:
-        logger.error(f"Error deleting bookmarks: {e}")
-        return f"Error: {str(e)}", display_bookmarks()
-
-# Export bookmarks to HTML
-def export_bookmarks():
-    if not bookmarks:
-        logger.warning("No bookmarks to export")
-        return None
-    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:
-            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 href
-    except Exception as e:
-        logger.error(f"Error exporting bookmarks: {e}")
-        return None
-
 # Build the Gradio app
 def build_app():
     try:
@@ -464,9 +466,9 @@ def build_app():
                     return process_uploaded_file(file)
 
                 process_button.click(
-                    update_bookmark_display,
+                    process_uploaded_file,
                     inputs=upload,
-                    outputs=[output_text, bookmark_display]
+                    outputs=[output_text, bookmark_display, gr.State(), gr.State()]
                 )
 
             with gr.Tab("Chat with Bookmarks"):
@@ -481,59 +483,46 @@ def build_app():
                 )
 
             with gr.Tab("Manage Bookmarks"):
-                manage_output = gr.Textbox(label="Manage Output")
+                manage_output = gr.Textbox(label="Manage Output", interactive=False)
                 bookmark_display_manage = gr.HTML(label="Bookmarks")
-                refresh_button = gr.Button("Refresh Bookmark List")
-
-                indices_input = gr.Textbox(label="Bookmark Indices to Delete (comma-separated)")
-                delete_button = gr.Button("Delete Selected Bookmarks")
-                export_button = gr.Button("Export Bookmarks")
-                download_link = gr.HTML(label="Download Exported Bookmarks")
+                bookmark_selector = gr.CheckboxGroup(label="Select Bookmarks", choices=[])
 
+                new_category_input = gr.Dropdown(label="New Category", choices=CATEGORIES)
                 with gr.Row():
-                    index_input = gr.Number(label="Bookmark Index (Starting from 1)", precision=0)
-                    new_title_input = gr.Textbox(label="New Title")
-                    new_url_input = gr.Textbox(label="New URL")
-                    new_category_input = gr.Dropdown(label="New Category", choices=CATEGORIES)
-
-                edit_button = gr.Button("Edit Bookmark")
-
-                def update_manage_display():
-                    return display_bookmarks()
-
-                refresh_button.click(
-                    update_manage_display,
-                    inputs=None,
-                    outputs=bookmark_display_manage
-                )
+                    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")
 
-                edit_button.click(
-                    edit_bookmark,
-                    inputs=[index_input, new_title_input, new_url_input, new_category_input],
-                    outputs=[manage_output, bookmark_display_manage]
-                )
+                # Update the bookmark display and selector when the app loads
+                bookmark_display_manage.value = display_bookmarks()
+                bookmark_selector.choices = [f"{i+1}. {bookmark['title']} (Category: {bookmark['category']})" for i, bookmark in enumerate(bookmarks)]
 
+                # Define button actions
                 delete_button.click(
-                    delete_bookmarks,
-                    inputs=indices_input,
-                    outputs=[manage_output, bookmark_display_manage]
+                    delete_selected_bookmarks,
+                    inputs=bookmark_selector,
+                    outputs=[manage_output, bookmark_selector, bookmark_display_manage]
                 )
 
-                def provide_download_link():
-                    href = export_bookmarks()
-                    if href:
-                        return f'<a href="{href}" download="bookmarks.html">Download Exported Bookmarks</a>'
-                    else:
-                        return "No bookmarks to export."
+                edit_category_button.click(
+                    edit_selected_bookmarks_category,
+                    inputs=[bookmark_selector, new_category_input],
+                    outputs=[manage_output, bookmark_selector, bookmark_display_manage]
+                )
 
                 export_button.click(
-                    provide_download_link,
+                    export_bookmarks,
                     inputs=None,
                     outputs=download_link
                 )
 
-                # Initial load of the bookmarks display
-                bookmark_display_manage.value = update_manage_display()
+                # Update the bookmark display and selector 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)