Update app.py

app.py

@@ -10,8 +10,15 @@ import asyncio
 import aiohttp
 import re
 import base64
+import logging
+
+# Set up logging
+logging.basicConfig(filename='app.log', level=logging.INFO,
+                    format='%(asctime)s %(levelname)s %(name)s %(message)s')
+logger = logging.getLogger(__name__)
 
 # Initialize models and variables
+logger.info("Initializing models and variables")
 embedding_model = SentenceTransformer('all-MiniLM-L6-v2')
 faiss_index = None
 bookmarks = []
@@ -44,14 +51,20 @@ CATEGORIES = [
 ]
 
 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.strip()
-        if url and title:
-            extracted_bookmarks.append({'url': url, 'title': title})
-    return extracted_bookmarks
+    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
 
 async def fetch_url_info(session, bookmark):
     url = bookmark['url']
@@ -60,6 +73,7 @@ async def fetch_url_info(session, bookmark):
         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
@@ -67,6 +81,7 @@ async def fetch_url_info(session, bookmark):
             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()
@@ -83,11 +98,13 @@ async def fetch_url_info(session, bookmark):
                     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'),
@@ -98,12 +115,18 @@ async def fetch_url_info(session, bookmark):
     return bookmark
 
 async def process_bookmarks_async(bookmarks):
-    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("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
 
 def generate_summary(bookmark):
     description = bookmark.get('description', '')
@@ -115,11 +138,13 @@ def generate_summary(bookmark):
             bookmark['summary'] = title
         else:
             bookmark['summary'] = 'No summary available.'
+    logger.info(f"Generated summary for bookmark: {bookmark.get('url')}")
     return 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()
@@ -153,22 +178,32 @@ def assign_category(bookmark):
         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
 
 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
+    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
 
 def display_bookmarks():
+    logger.info("Generating HTML display for bookmarks")
     cards = ''
     for i, bookmark in enumerate(bookmarks):
         index = i + 1  # Start index at 1
@@ -200,42 +235,67 @@ def display_bookmarks():
         </div>
         '''
         cards += card_html
+    logger.info("HTML display generated")
     return cards
 
 def process_uploaded_file(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.", ''
     try:
         file_content = file.decode('utf-8')
-    except UnicodeDecodeError:
+    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.", ''
 
-    bookmarks = parse_bookmarks(file_content)
+    try:
+        bookmarks = parse_bookmarks(file_content)
+    except Exception as e:
+        logger.error(f"Error parsing bookmarks: {e}")
+        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.", ''
 
     # Asynchronously fetch bookmark info
-    asyncio.run(process_bookmarks_async(bookmarks))
+    try:
+        asyncio.run(process_bookmarks_async(bookmarks))
+    except Exception as e:
+        logger.error(f"Error processing bookmarks asynchronously: {e}")
+        return "Error processing bookmarks.", ''
 
     # Generate summaries and assign categories
     for bookmark in bookmarks:
         generate_summary(bookmark)
         assign_category(bookmark)
 
-    faiss_index, embeddings = vectorize_and_index(bookmarks)
+    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.", ''
+
     message = f"Successfully processed {len(bookmarks)} bookmarks."
+    logger.info(message)
     bookmark_html = display_bookmarks()
     return message, bookmark_html
 
 def chatbot_response(user_query):
     if faiss_index is None or 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}")
     # 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
+    try:
+        user_embedding = embedding_model.encode([user_query])
+        D, I = faiss_index.search(np.array(user_embedding), k=5)  # Retrieve top 5 matches
+    except Exception as e:
+        logger.error(f"Error in chatbot vectorization or search: {e}")
+        return "Error processing your query."
 
     # Generate response
     response = ""
@@ -244,6 +304,7 @@ def chatbot_response(user_query):
             bookmark = bookmarks[idx]
             index = idx + 1  # Start index at 1
             response += f"{index}. Title: {bookmark['title']}\nURL: {bookmark['url']}\nCategory: {bookmark.get('category', 'Uncategorized')}\nSummary: {bookmark['summary']}\n\n"
+    logger.info("Chatbot response generated")
     return response.strip()
 
 def edit_bookmark(bookmark_idx, new_title, new_url, new_category):
@@ -251,7 +312,9 @@ def edit_bookmark(bookmark_idx, new_title, new_url, new_category):
     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
@@ -261,9 +324,11 @@ def edit_bookmark(bookmark_idx, new_title, new_url, new_category):
         # 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()
 
 def delete_bookmarks(indices_str):
@@ -271,8 +336,10 @@ def delete_bookmarks(indices_str):
     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:
@@ -280,31 +347,41 @@ def delete_bookmarks(indices_str):
         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()
 
 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
-    # 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}'
-    return href
 
 def build_app():
+    logger.info("Building Gradio app")
     with gr.Blocks(css="app.css") as demo:
         gr.Markdown("<h1>Bookmark Manager App</h1>")
 
@@ -315,8 +392,7 @@ def build_app():
             bookmark_display = gr.HTML(label="Bookmarks")
 
             def update_bookmark_display(file):
-                message, html_content = process_uploaded_file(file)
-                return message, html_content
+                return process_uploaded_file(file)
 
             process_button.click(
                 update_bookmark_display,
@@ -354,8 +430,7 @@ def build_app():
             edit_button = gr.Button("Edit Bookmark")
 
             def update_manage_display():
-                html_content = display_bookmarks()
-                return html_content
+                return display_bookmarks()
 
             refresh_button.click(
                 update_manage_display,
@@ -391,6 +466,7 @@ def build_app():
             # Initial load of the bookmarks display
             bookmark_display_manage.value = update_manage_display()
 
+    logger.info("Launching Gradio app")
     demo.launch()
 
 if __name__ == "__main__":