Update app.py

app.py

@@ -7,177 +7,90 @@ from transformers import pipeline
 from sentence_transformers import SentenceTransformer
 import faiss
 import numpy as np
+import pandas as pd
 
 # Initialize models and variables
 summarizer = pipeline("summarization", model="sshleifer/distilbart-cnn-12-6")
 embedding_model = SentenceTransformer('all-MiniLM-L6-v2')
-faiss_index = None  # Renamed from 'index' to 'faiss_index'
+faiss_index = None
 bookmarks = []
 fetch_cache = {}
 
-# Helper functions
-
 def parse_bookmarks(file_content):
-    soup = BeautifulSoup(file_content, 'html.parser')
-    extracted_bookmarks = []
-    for link in soup.find_all('a'):
-        url = link.get('href')
-        title = link.text
-        if url and title:
-            extracted_bookmarks.append({'url': url, 'title': title})
-    return extracted_bookmarks
+    # [Same as before]
 
 def fetch_url_info(bookmark):
-    url = bookmark['url']
-    if url in fetch_cache:
-        bookmark.update(fetch_cache[url])
-        return bookmark
-
-    try:
-        response = requests.get(url, timeout=5)
-        bookmark['etag'] = response.headers.get('ETag', 'N/A')
-        bookmark['status_code'] = response.status_code
-
-        if response.status_code >= 400:
-            bookmark['dead_link'] = True
-            bookmark['content'] = ''
-        else:
-            bookmark['dead_link'] = False
-            soup = BeautifulSoup(response.content, 'html.parser')
-            meta_tags = {meta.get('name', ''): meta.get('content', '') for meta in soup.find_all('meta')}
-            bookmark['meta_tags'] = meta_tags
-            bookmark['content'] = soup.get_text(separator=' ', strip=True)
-    except Exception as e:
-        bookmark['dead_link'] = True
-        bookmark['etag'] = 'N/A'
-        bookmark['status_code'] = 'N/A'
-        bookmark['meta_tags'] = {}
-        bookmark['content'] = ''
-    finally:
-        fetch_cache[url] = {
-            'etag': bookmark.get('etag'),
-            'status_code': bookmark.get('status_code'),
-            'dead_link': bookmark.get('dead_link'),
-            'meta_tags': bookmark.get('meta_tags'),
-            'content': bookmark.get('content'),
-        }
-    return bookmark
+    # [Same as before]
 
 def generate_summary(bookmark):
-    content = bookmark.get('content', '')
-    if content:
-        # Limit content to first 2000 characters to save resources
-        content = content[:2000]
-        summary = summarizer(content, max_length=50, min_length=25, do_sample=False)
-        bookmark['summary'] = summary[0]['summary_text']
-    else:
-        bookmark['summary'] = 'No content available to summarize.'
-    return bookmark
+    # [Same as before]
 
 def vectorize_and_index(bookmarks):
-    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))
-    return faiss_idx, embeddings
-
-def process_uploaded_file(file):
-    global bookmarks, faiss_index
-    if file is None:
-        return "Please upload a bookmarks HTML file."
-
-    # Decode the binary data to a string
-    file_content = file.decode('utf-8')
-    bookmarks = parse_bookmarks(file_content)
-
-    for bookmark in bookmarks:
-        fetch_url_info(bookmark)
-        generate_summary(bookmark)
-
-    faiss_index, embeddings = vectorize_and_index(bookmarks)
-    return f"Successfully processed {len(bookmarks)} bookmarks."
-
-def chatbot_response(user_query):
-    if faiss_index is None or not bookmarks:
-        return "No bookmarks available. Please upload and process your bookmarks first."
-
-    # Vectorize user query
-    user_embedding = embedding_model.encode([user_query])
-    D, I = faiss_index.search(np.array(user_embedding), k=5)  # Retrieve top 5 matches
-
-    # Generate response
-    response = ""
-    for idx in I[0]:
-        bookmark = bookmarks[idx]
-        response += f"Title: {bookmark['title']}\nURL: {bookmark['url']}\nSummary: {bookmark['summary']}\n\n"
-    return response.strip()
+    # [Same as before]
 
 def display_bookmarks():
-    bookmark_list = []
+    data = []
     for i, bookmark in enumerate(bookmarks):
         status = "Dead Link" if bookmark.get('dead_link') else "Active"
-        bookmark_list.append([i, bookmark['title'], bookmark['url'], status])
-    return bookmark_list
+        css_class = "dead-link" if bookmark.get('dead_link') else ""
+        data.append({
+            'Index': i,
+            'Title': bookmark['title'],
+            'URL': bookmark['url'],
+            'Status': status,
+            'ETag': bookmark.get('etag', 'N/A'),
+            'Summary': bookmark.get('summary', ''),
+            'css_class': css_class
+        })
+    df = pd.DataFrame(data)
+    return df
+
+def process_uploaded_file(file):
+    # [Updated as per Step 3]
+
+def chatbot_response(user_query):
+    # [Same as before]
 
 def edit_bookmark(bookmark_idx, new_title, new_url):
-    global faiss_index  # Reference the global faiss_index variable
-    try:
-        bookmark_idx = int(bookmark_idx)
-        bookmarks[bookmark_idx]['title'] = new_title
-        bookmarks[bookmark_idx]['url'] = new_url
-        fetch_url_info(bookmarks[bookmark_idx])
-        generate_summary(bookmarks[bookmark_idx])
-        # Rebuild the FAISS index
-        faiss_index, embeddings = vectorize_and_index(bookmarks)
-        return "Bookmark updated successfully."
-    except Exception as e:
-        return f"Error: {str(e)}"
+    # [Update outputs to include the updated bookmarks list]
+    message, updated_df = "Bookmark updated successfully.", display_bookmarks()
+    return message, updated_df
 
 def delete_bookmark(bookmark_idx):
-    global faiss_index  # Reference the global faiss_index variable
-    try:
-        bookmark_idx = int(bookmark_idx)
-        bookmarks.pop(bookmark_idx)
-        # Rebuild the FAISS index
-        if bookmarks:
-            faiss_index, embeddings = vectorize_and_index(bookmarks)
-        else:
-            faiss_index = None  # No bookmarks left
-        return "Bookmark deleted successfully."
-    except Exception as e:
-        return f"Error: {str(e)}"
+    # [Update outputs to include the updated bookmarks list]
+    message, updated_df = "Bookmark deleted successfully.", display_bookmarks()
+    return message, updated_df
 
 def build_app():
-    with gr.Blocks() as demo:
+    with gr.Blocks(css="app.css") as demo:
         gr.Markdown("# Bookmark Manager App")
 
         with gr.Tab("Upload and Process Bookmarks"):
-            upload = gr.File(label="Upload Bookmarks HTML File", type='binary')  # Updated here
+            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",
+                headers=["Index", "Title", "URL", "Status", "ETag", "Summary"],
+                datatype=["number", "str", "str", "str", "str", "str"],
+                interactive=False
+            )
 
             process_button.click(
                 process_uploaded_file,
                 inputs=upload,
-                outputs=output_text
+                outputs=[output_text, bookmark_table]
             )
 
         with gr.Tab("Chat with Bookmarks"):
-            user_input = gr.Textbox(label="Ask about your bookmarks")
-            chat_output = gr.Textbox(label="Chatbot Response")
-            chat_button = gr.Button("Send")
-
-            chat_button.click(
-                chatbot_response,
-                inputs=user_input,
-                outputs=chat_output
-            )
+            # [Same as before]
 
         with gr.Tab("Manage Bookmarks"):
-            bookmark_table = gr.Dataframe(
-                headers=["Index", "Title", "URL", "Status"],
-                datatype=["number", "str", "str", "str"],
+            manage_output = gr.Textbox(label="Manage Output")
+            bookmark_table_manage = gr.Dataframe(
+                label="Bookmarks",
+                headers=["Index", "Title", "URL", "Status", "ETag", "Summary"],
+                datatype=["number", "str", "str", "str", "str", "str"],
                 interactive=False
             )
             refresh_button = gr.Button("Refresh Bookmark List")
@@ -189,24 +102,23 @@ def build_app():
 
             edit_button = gr.Button("Edit Bookmark")
             delete_button = gr.Button("Delete Bookmark")
-            manage_output = gr.Textbox(label="Manage Output")
 
             refresh_button.click(
                 display_bookmarks,
                 inputs=None,
-                outputs=bookmark_table
+                outputs=bookmark_table_manage
             )
 
             edit_button.click(
                 edit_bookmark,
                 inputs=[index_input, new_title_input, new_url_input],
-                outputs=manage_output
+                outputs=[manage_output, bookmark_table_manage]
             )
 
             delete_button.click(
                 delete_bookmark,
                 inputs=index_input,
-                outputs=manage_output
+                outputs=[manage_output, bookmark_table_manage]
             )
 
     demo.launch()