Update app.py

app.py

@@ -159,7 +159,7 @@ def get_page_metadata(soup):
 
 async def generate_summary_async(bookmark):
     async with llm_semaphore:
-        generate_summary(bookmark)
+        await asyncio.get_event_loop().run_in_executor(None, generate_summary, bookmark)
 
 def generate_summary(bookmark):
     """
@@ -270,7 +270,7 @@ Be concise and objective.
 
 async def assign_category_async(bookmark):
     async with llm_semaphore:
-        assign_category(bookmark)
+        await asyncio.get_event_loop().run_in_executor(None, assign_category, bookmark)
 
 def assign_category(bookmark):
     """
@@ -452,6 +452,10 @@ async def process_bookmarks_llm(bookmarks_list):
     tasks = []
     for bookmark in bookmarks_list:
         tasks.append(generate_summary_async(bookmark))
+    await asyncio.gather(*tasks)
+
+    tasks = []
+    for bookmark in bookmarks_list:
         tasks.append(assign_category_async(bookmark))
     await asyncio.gather(*tasks)
     logger.info("Completed LLM processing of bookmarks")
@@ -585,9 +589,167 @@ def process_uploaded_file(file):
 
     return message, bookmark_html, gr.update(choices=choices), bookmark_html
 
-# The rest of the code remains unchanged (e.g., delete_selected_bookmarks, edit_selected_bookmarks_category, etc.)
+def delete_selected_bookmarks(selected_indices):
+    """
+    Delete selected bookmarks and remove their vectors from the FAISS index.
+    """
+    global bookmarks, faiss_index
+    if not selected_indices:
+        return "⚠️ No bookmarks selected.", gr.update(choices=[]), display_bookmarks()
+
+    ids_to_delete = []
+    indices_to_delete = []
+    for s in selected_indices:
+        idx = int(s.split('.')[0]) - 1
+        if 0 <= idx < len(bookmarks):
+            bookmark_id = bookmarks[idx]['id']
+            ids_to_delete.append(bookmark_id)
+            indices_to_delete.append(idx)
+            logger.info(f"Deleting bookmark at index {idx + 1}")
+
+    # Remove vectors from FAISS index
+    if faiss_index is not None and ids_to_delete:
+        faiss_index.remove_ids(np.array(ids_to_delete, dtype=np.int64))
+
+    # Remove bookmarks from the list (reverse order to avoid index shifting)
+    for idx in sorted(indices_to_delete, reverse=True):
+        bookmarks.pop(idx)
+
+    message = "🗑️ Selected bookmarks deleted successfully."
+    logger.info(message)
+    choices = [f"{i+1}. {bookmark['title']} (Category: {bookmark['category']})"
+               for i, bookmark in enumerate(bookmarks)]
+
+    return message, gr.update(choices=choices), display_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(choices=[]), display_bookmarks()
+    if not new_category:
+        return "⚠️ No new category selected.", gr.update(choices=[]), display_bookmarks()
+
+    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 choices and display
+    choices = [f"{i+1}. {bookmark['title']} (Category: {bookmark['category']})"
+              for i, bookmark in enumerate(bookmarks)]
+
+    return message, gr.update(choices=choices), display_bookmarks()
+
+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")
+        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)
+        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}", exc_info=True)
+        return "⚠️ Error exporting bookmarks."
+
+def chatbot_response(user_query):
+    """
+    Generate chatbot response using the FAISS index and embeddings.
+    """
+    if not bookmarks or faiss_index is None:
+        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}")
+
+    try:
+        # Encode the user query
+        query_vector = embedding_model.encode([user_query]).astype('float32')
+
+        # Search the FAISS index
+        k = 5  # Number of results to return
+        distances, ids = faiss_index.search(query_vector, k)
+        ids = ids.flatten()
+
+        # Retrieve the bookmarks
+        id_to_bookmark = {bookmark['id']: bookmark for bookmark in bookmarks}
+        matching_bookmarks = [id_to_bookmark.get(id) for id in ids if id in id_to_bookmark]
+
+        if not matching_bookmarks:
+            return "No relevant bookmarks found for your query."
+
+        # Format the response
+        bookmarks_info = "\n".join([
+            f"Title: {bookmark['title']}\nURL: {bookmark['url']}\nSummary: {bookmark['summary']}"
+            for bookmark in matching_bookmarks
+        ])
+
+        # Use the LLM via Groq Cloud API to generate a response
+        prompt = f"""
+A user asked: "{user_query}"
+
+Based on the bookmarks below, provide a helpful answer to the user's query, referencing the relevant bookmarks.
+
+Bookmarks:
+{bookmarks_info}
+
+Provide a concise and helpful response.
+"""
+
+        retries = 0
+        max_retries = 5
+        while retries <= max_retries:
+            try:
+                response = openai.ChatCompletion.create(
+                    model='llama-3.1-70b-versatile',
+                    messages=[
+                        {"role": "user", "content": prompt}
+                    ],
+                    max_tokens=500,
+                    temperature=0.7,
+                )
+                break  # Exit loop if successful
+            except openai.error.RateLimitError as e:
+                retry_after = extract_retry_after(str(e)) or exponential_backoff(retries)
+                logger.warning(f"Rate limit exceeded. Retrying after {retry_after} seconds.")
+                time.sleep(retry_after)
+                retries += 1
+            except Exception as e:
+                error_message = f"⚠️ Error processing your query: {str(e)}"
+                logger.error(error_message, exc_info=True)
+                return error_message
+
+        answer = response['choices'][0]['message']['content'].strip()
+        logger.info("Chatbot response generated using Groq Cloud API")
+        return answer
+
+    except Exception as e:
+        error_message = f"⚠️ Error processing your query: {str(e)}"
+        logger.error(error_message, exc_info=True)
+        return error_message
 
-# Build and launch the Gradio app
 def build_app():
     """
     Build and launch the Gradio app.