Update app.py

app.py

@@ -9,7 +9,7 @@ import numpy as np
 import asyncio
 import aiohttp
 import re
-import pandas as pd
+import base64
 
 # Initialize models and variables
 embedding_model = SentenceTransformer('all-MiniLM-L6-v2')
@@ -168,35 +168,53 @@ def vectorize_and_index(bookmarks):
     faiss_idx.add(np.array(embeddings))
     return faiss_idx, embeddings
 
-def bookmarks_to_dataframe():
-    data = []
+def display_bookmarks():
+    cards = ''
     for i, bookmark in enumerate(bookmarks):
-        index = i + 1
+        index = i + 1  # Start index at 1
         status = "Dead Link" if bookmark.get('dead_link') else "Active"
-        data.append({
-            'Index': index,
-            'Title': bookmark['title'],
-            'URL': bookmark['url'],
-            'Category': bookmark.get('category', 'Uncategorized'),
-            'Status': status,
-            'Summary': bookmark.get('summary', ''),
-        })
-    df = pd.DataFrame(data)
-    return df
+        title = bookmark['title']
+        url = bookmark['url']
+        etag = bookmark.get('etag', 'N/A')
+        summary = bookmark.get('summary', '')
+        category = bookmark.get('category', 'Uncategorized')
+
+        # Apply inline styles for dead links
+        if bookmark.get('dead_link'):
+            card_style = "border: 2px solid #D32F2F;"
+            text_style = "color: #D32F2F;"
+        else:
+            card_style = ""
+            text_style = ""
+
+        card_html = f'''
+        <div class="card" style="{card_style}">
+            <div class="card-content">
+                <h3 style="{text_style}">{index}. {title}</h3>
+                <p style="{text_style}"><strong>Category:</strong> {category}</p>
+                <p style="{text_style}"><strong>URL:</strong> <a href="{url}" target="_blank" style="{text_style}">{url}</a></p>
+                <p style="{text_style}"><strong>Status:</strong> {status}</p>
+                <p style="{text_style}"><strong>ETag:</strong> {etag}</p>
+                <p style="{text_style}"><strong>Summary:</strong> {summary}</p>
+            </div>
+        </div>
+        '''
+        cards += card_html
+    return cards
 
 def process_uploaded_file(file):
     global bookmarks, faiss_index
     if file is None:
-        return "Please upload a bookmarks HTML file.", pd.DataFrame()
+        return "Please upload a bookmarks HTML file.", ''
     try:
         file_content = file.decode('utf-8')
     except UnicodeDecodeError:
-        return "Error decoding the file. Please ensure it's a valid HTML file.", pd.DataFrame()
+        return "Error decoding the file. Please ensure it's a valid HTML file.", ''
 
     bookmarks = parse_bookmarks(file_content)
 
     if not bookmarks:
-        return "No bookmarks found in the uploaded file.", pd.DataFrame()
+        return "No bookmarks found in the uploaded file.", ''
 
     # Asynchronously fetch bookmark info
     asyncio.run(process_bookmarks_async(bookmarks))
@@ -208,8 +226,8 @@ def process_uploaded_file(file):
 
     faiss_index, embeddings = vectorize_and_index(bookmarks)
     message = f"Successfully processed {len(bookmarks)} bookmarks."
-    bookmark_df = bookmarks_to_dataframe()
-    return message, bookmark_df
+    bookmark_html = display_bookmarks()
+    return message, bookmark_html
 
 def chatbot_response(user_query):
     if faiss_index is None or not bookmarks:
@@ -228,30 +246,31 @@ def chatbot_response(user_query):
             response += f"{index}. Title: {bookmark['title']}\nURL: {bookmark['url']}\nCategory: {bookmark.get('category', 'Uncategorized')}\nSummary: {bookmark['summary']}\n\n"
     return response.strip()
 
-def edit_bookmark(row):
+def edit_bookmark(bookmark_idx, new_title, new_url, new_category):
     global faiss_index
     try:
-        bookmark_idx = int(row['Index']) - 1  # Adjust index to match list (starting at 0)
+        bookmark_idx = int(bookmark_idx) - 1  # Adjust index to match list (starting at 0)
         if bookmark_idx < 0 or bookmark_idx >= len(bookmarks):
-            return "Invalid bookmark index.", bookmarks_to_dataframe()
-        bookmarks[bookmark_idx]['title'] = row['Title']
-        bookmarks[bookmark_idx]['url'] = row['URL']
-        bookmarks[bookmark_idx]['category'] = row['Category']
+            return "Invalid bookmark index.", display_bookmarks()
+        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."
-        updated_df = bookmarks_to_dataframe()
-        return message, updated_df
+        updated_html = display_bookmarks()
+        return message, updated_html
     except Exception as e:
-        return f"Error: {str(e)}", bookmarks_to_dataframe()
+        return f"Error: {str(e)}", display_bookmarks()
 
-def delete_bookmarks(selected_indices):
+def delete_bookmarks(indices_str):
     global faiss_index
     try:
-        indices = sorted([int(idx) - 1 for idx in selected_indices], reverse=True)
+        indices = [int(idx.strip()) - 1 for idx in indices_str.split(',') if idx.strip().isdigit()]
+        indices = sorted(indices, reverse=True)
         for idx in indices:
             if 0 <= idx < len(bookmarks):
                 bookmarks.pop(idx)
@@ -261,10 +280,10 @@ def delete_bookmarks(selected_indices):
         else:
             faiss_index = None
         message = "Selected bookmarks deleted successfully."
-        updated_df = bookmarks_to_dataframe()
-        return message, updated_df
+        updated_html = display_bookmarks()
+        return message, updated_html
     except Exception as e:
-        return f"Error: {str(e)}", bookmarks_to_dataframe()
+        return f"Error: {str(e)}", display_bookmarks()
 
 def export_bookmarks():
     if not bookmarks:
@@ -280,7 +299,10 @@ def export_bookmarks():
         dl.append(dt)
     soup.append(dl)
     html_content = str(soup)
-    return html_content
+    # Encode the HTML content to base64 for download
+    b64 = base64.b64encode(html_content.encode()).decode()
+    href = f'data:text/html;base64,{b64}'
+    return href
 
 def build_app():
     with gr.Blocks(css="app.css") as demo:
@@ -290,16 +312,16 @@ def build_app():
             upload = gr.File(label="Upload Bookmarks HTML File", type='binary')
             process_button = gr.Button("Process Bookmarks")
             output_text = gr.Textbox(label="Output")
-            bookmark_table = gr.Dataframe(label="Bookmarks", interactive=False)
+            bookmark_display = gr.HTML(label="Bookmarks")
 
-            def update_bookmark_table(file):
-                message, df = process_uploaded_file(file)
-                return message, df
+            def update_bookmark_display(file):
+                message, html_content = process_uploaded_file(file)
+                return message, html_content
 
             process_button.click(
-                update_bookmark_table,
+                update_bookmark_display,
                 inputs=upload,
-                outputs=[output_text, bookmark_table]
+                outputs=[output_text, bookmark_display]
             )
 
         with gr.Tab("Chat with Bookmarks"):
@@ -315,50 +337,59 @@ def build_app():
 
         with gr.Tab("Manage Bookmarks"):
             manage_output = gr.Textbox(label="Manage Output")
-            bookmark_table_manage = gr.Dataframe(label="Bookmarks", interactive=True)
-            selected_indices = gr.Textbox(label="Selected Indices (comma-separated)", visible=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.File(label="Download Exported Bookmarks", interactive=False)
-
-            def update_manage_table():
-                df = bookmarks_to_dataframe()
-                return df
-
-            def delete_selected_bookmarks(dataframe):
-                selected_indices = dataframe['Index'].tolist()
-                message, updated_df = delete_bookmarks(selected_indices)
-                return message, updated_df
-
-            def export_bookmarks_file():
-                content = export_bookmarks()
-                if content:
-                    with open('bookmarks.html', 'w', encoding='utf-8') as f:
-                        f.write(content)
-                    return 'bookmarks.html'
-                else:
-                    return None
+            download_link = gr.HTML(label="Download Exported Bookmarks")
+
+            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():
+                html_content = display_bookmarks()
+                return html_content
 
-            bookmark_table_manage.change(
+            refresh_button.click(
+                update_manage_display,
+                inputs=None,
+                outputs=bookmark_display_manage
+            )
+
+            edit_button.click(
                 edit_bookmark,
-                inputs=bookmark_table_manage,
-                outputs=[manage_output, bookmark_table_manage]
+                inputs=[index_input, new_title_input, new_url_input, new_category_input],
+                outputs=[manage_output, bookmark_display_manage]
             )
 
             delete_button.click(
-                delete_selected_bookmarks,
-                inputs=bookmark_table_manage,
-                outputs=[manage_output, bookmark_table_manage]
+                delete_bookmarks,
+                inputs=indices_input,
+                outputs=[manage_output, 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."
+
             export_button.click(
-                export_bookmarks_file,
+                provide_download_link,
                 inputs=None,
                 outputs=download_link
             )
 
-            # Initial load of the bookmarks table
-            bookmark_table_manage.value = update_manage_table()
+            # Initial load of the bookmarks display
+            bookmark_display_manage.value = update_manage_display()
 
     demo.launch()