Update app.py

app.py

@@ -43,6 +43,10 @@ fetch_cache = {}
 
 # Lock for thread-safe operations
 lock = threading.Lock()
+api_lock = threading.Lock()  # Added api_lock
+
+# Initialize last_api_call_time
+last_api_call_time = 0  # Added initialization
 
 # Define the categories
 CATEGORIES = [
@@ -70,35 +74,41 @@ CATEGORIES = [
     "Uncategorized",
 ]
 
-# Remove OpenAI dependencies
 # Define a function to generate responses using llama-3.1-70b-versatile
 def generate_llama_response(prompt):
     """
     Generate a response using the llama-3.1-70b-versatile model.
 
-    Replace the implementation below with the actual method to interact with your LLM.
-    This could be an API call to a local server, a cloud service, or any interface you have set up.
-
-    Example (pseudo-code):
-    response = requests.post("http://localhost:5000/generate", json={"prompt": prompt})
-    return response.json().get("response", "")
-
-    For demonstration purposes, we'll return a placeholder response.
+    This implementation assumes that the model is accessible via a local HTTP API endpoint.
+    Replace the URL and request parameters as per your actual setup.
     """
     try:
-        # Example implementation; replace with actual API call or method
-        # For instance, if using a local API:
-        # response = requests.post("http://localhost:5000/generate", json={"prompt": prompt})
-        # return response.json().get("response", "")
-        
-        # Placeholder response
         logger.info("Generating response using llama-3.1-70b-versatile")
-        # Simulate processing time
-        time.sleep(1)
-        return "This is a placeholder response from llama-3.1-70b-versatile."
+        api_url = "http://localhost:5000/generate"  # Replace with your actual endpoint
+        headers = {
+            'Content-Type': 'application/json',
+        }
+        payload = {
+            'prompt': prompt,
+            'max_tokens': 500,  # Adjust as needed
+            'temperature': 0.7,  # Adjust as needed
+        }
+        response = requests.post(api_url, json=payload, headers=headers, timeout=30)
+        response.raise_for_status()  # Raise an exception for HTTP errors
+        data = response.json()
+        generated_text = data.get('response', '').strip()
+        if not generated_text:
+            raise ValueError("Empty response received from the model.")
+        return generated_text
+    except requests.exceptions.RequestException as e:
+        logger.error(f"HTTP Request failed: {e}", exc_info=True)
+        return "Error generating response due to HTTP request failure."
+    except ValueError as ve:
+        logger.error(f"Value Error: {ve}", exc_info=True)
+        return "Error generating response: Received empty response from the model."
     except Exception as e:
-        logger.error(f"Error generating response from llama: {e}", exc_info=True)
-        return "Error generating response."
+        logger.error(f"Unexpected error: {e}", exc_info=True)
+        return "An unexpected error occurred while generating the response."
 
 def extract_main_content(soup):
     """
@@ -175,55 +185,51 @@ def generate_summary_and_assign_category(bookmark):
     """
     logger.info(f"Generating summary and assigning category for bookmark: {bookmark.get('url')}")
 
-    max_retries = 3
-    retry_count = 0
-
-    while retry_count < max_retries:
-        try:
-            # Rate Limiting Logic (if necessary)
-            with lock:
-                global last_api_call_time
-                current_time = time.time()
-                elapsed = current_time - last_api_call_time
-                if elapsed < 2:
-                    sleep_duration = 2 - elapsed
-                    logger.info(f"Sleeping for {sleep_duration:.2f} seconds to respect rate limits.")
-                    time.sleep(sleep_duration)
-                last_api_call_time = time.time()
-
-            # Prepare the prompt
-            html_content = bookmark.get('html_content', '')
-            soup = BeautifulSoup(html_content, 'html.parser')
-            metadata = get_page_metadata(soup)
-            main_content = extract_main_content(soup)
-
-            # Prepare content for the prompt
-            content_parts = []
-            if metadata['title']:
-                content_parts.append(f"Title: {metadata['title']}")
-            if metadata['description']:
-                content_parts.append(f"Description: {metadata['description']}")
-            if metadata['keywords']:
-                content_parts.append(f"Keywords: {metadata['keywords']}")
-            if main_content:
-                content_parts.append(f"Main Content: {main_content}")
-
-            content_text = '\n'.join(content_parts)
-
-            # Detect insufficient or erroneous content
-            error_keywords = ['Access Denied', 'Security Check', 'Cloudflare', 'captcha', 'unusual traffic']
-            if not content_text or len(content_text.split()) < 50:
-                use_prior_knowledge = True
-                logger.info(f"Content for {bookmark.get('url')} is insufficient. Instructing LLM to use prior knowledge.")
-            elif any(keyword.lower() in content_text.lower() for keyword in error_keywords):
-                use_prior_knowledge = True
-                logger.info(f"Content for {bookmark.get('url')} contains error messages. Instructing LLM to use prior knowledge.")
-            else:
-                use_prior_knowledge = False
+    try:
+        # Rate Limiting Logic
+        with api_lock:
+            global last_api_call_time
+            current_time = time.time()
+            elapsed = current_time - last_api_call_time
+            if elapsed < 2:
+                sleep_duration = 2 - elapsed
+                logger.info(f"Sleeping for {sleep_duration:.2f} seconds to respect rate limits.")
+                time.sleep(sleep_duration)
+            last_api_call_time = current_time
+
+        # Prepare the prompt
+        html_content = bookmark.get('html_content', '')
+        soup = BeautifulSoup(html_content, 'html.parser')
+        metadata = get_page_metadata(soup)
+        main_content = extract_main_content(soup)
+
+        # Prepare content for the prompt
+        content_parts = []
+        if metadata['title']:
+            content_parts.append(f"Title: {metadata['title']}")
+        if metadata['description']:
+            content_parts.append(f"Description: {metadata['description']}")
+        if metadata['keywords']:
+            content_parts.append(f"Keywords: {metadata['keywords']}")
+        if main_content:
+            content_parts.append(f"Main Content: {main_content}")
+
+        content_text = '\n'.join(content_parts)
+
+        # Detect insufficient or erroneous content
+        error_keywords = ['Access Denied', 'Security Check', 'Cloudflare', 'captcha', 'unusual traffic']
+        if not content_text or len(content_text.split()) < 50:
+            use_prior_knowledge = True
+            logger.info(f"Content for {bookmark.get('url')} is insufficient. Instructing LLM to use prior knowledge.")
+        elif any(keyword.lower() in content_text.lower() for keyword in error_keywords):
+            use_prior_knowledge = True
+            logger.info(f"Content for {bookmark.get('url')} contains error messages. Instructing LLM to use prior knowledge.")
+        else:
+            use_prior_knowledge = False
 
-            # Craft the prompt based on content availability
-            if use_prior_knowledge:
-                prompt = f"""
+        # Craft the prompt based on content availability
+        if use_prior_knowledge:
+            prompt = f"""
 You are a knowledgeable assistant with up-to-date information as of 2023.
 URL: {bookmark.get('url')}
 Provide:
@@ -235,8 +241,8 @@ Format:
 Summary: [Your summary]
 Category: [One category]
 """
-            else:
-                prompt = f"""
+        else:
+            prompt = f"""
 You are an assistant that creates concise webpage summaries and assigns categories.
 Content:
 {content_text}
@@ -250,46 +256,44 @@ Summary: [Your summary]
 Category: [One category]
 """
 
-            # Generate response using llama-3.1-70b-versatile
-            response = generate_llama_response(prompt)
+        # Generate response using llama-3.1-70b-versatile
+        response = generate_llama_response(prompt)
 
-            if not response:
-                raise ValueError("Empty response received from the model.")
+        if not response:
+            raise ValueError("Empty response received from the model.")
 
-            # Parse the response
-            summary_match = re.search(r"Summary:\s*(.*)", response)
-            category_match = re.search(r"Category:\s*(.*)", response)
+        # Parse the response
+        summary_match = re.search(r"Summary:\s*(.*)", response)
+        category_match = re.search(r"Category:\s*(.*)", response)
 
-            if summary_match:
-                bookmark['summary'] = summary_match.group(1).strip()
-            else:
-                bookmark['summary'] = 'No summary available.'
+        if summary_match:
+            bookmark['summary'] = summary_match.group(1).strip()
+        else:
+            bookmark['summary'] = 'No summary available.'
 
-            if category_match:
-                category = category_match.group(1).strip().strip('"')
-                if category in CATEGORIES:
-                    bookmark['category'] = category
-                else:
-                    bookmark['category'] = 'Uncategorized'
+        if category_match:
+            category = category_match.group(1).strip().strip('"')
+            if category in CATEGORIES:
+                bookmark['category'] = category
             else:
                 bookmark['category'] = 'Uncategorized'
+        else:
+            bookmark['category'] = 'Uncategorized'
 
-            # Optional: Simple keyword-based validation
-            summary_lower = bookmark['summary'].lower()
-            url_lower = bookmark['url'].lower()
-            if 'social media' in summary_lower or 'twitter' in summary_lower or 'x.com' in url_lower:
-                bookmark['category'] = 'Social Media'
-            elif 'wikipedia' in url_lower:
-                bookmark['category'] = 'Reference and Knowledge Bases'
+        # Optional: Simple keyword-based validation
+        summary_lower = bookmark['summary'].lower()
+        url_lower = bookmark['url'].lower()
+        if 'social media' in summary_lower or 'twitter' in summary_lower or 'x.com' in url_lower:
+            bookmark['category'] = 'Social Media'
+        elif 'wikipedia' in url_lower:
+            bookmark['category'] = 'Reference and Knowledge Bases'
 
-            logger.info("Successfully generated summary and assigned category")
-            break  # Exit the retry loop upon success
+        logger.info("Successfully generated summary and assigned category")
 
-        except Exception as e:
-            logger.error(f"Error generating summary and assigning category: {e}", exc_info=True)
-            bookmark['summary'] = 'No summary available.'
-            bookmark['category'] = 'Uncategorized'
-            break  # Exit the retry loop on exceptions
+    except Exception as e:
+        logger.error(f"Error generating summary and assigning category: {e}", exc_info=True)
+        bookmark['summary'] = 'No summary available.'
+        bookmark['category'] = 'Uncategorized'
 
 def parse_bookmarks(file_content):
     """
@@ -444,7 +448,7 @@ def display_bookmarks():
     logger.info("HTML display generated")
     return cards
 
-def process_uploaded_file(file, state_bookmarks):
+def process_uploaded_file(file, state_bookmarks, bookmark_selector):
     """
     Process the uploaded bookmarks file.
     """
@@ -453,23 +457,23 @@ def process_uploaded_file(file, state_bookmarks):
 
     if file is None:
         logger.warning("No file uploaded")
-        return "Please upload a bookmarks HTML file.", '', state_bookmarks, gr.CheckboxGroup.update(choices=[])
+        return "Please upload a bookmarks HTML file.", '', state_bookmarks, bookmark_selector.update(choices=[])
 
     try:
         file_content = file.decode('utf-8')
     except UnicodeDecodeError as e:
         logger.error(f"Error decoding the file: {e}", exc_info=True)
-        return "Error decoding the file. Please ensure it's a valid HTML file.", '', state_bookmarks, gr.CheckboxGroup.update(choices=[])
+        return "Error decoding the file. Please ensure it's a valid HTML file.", '', state_bookmarks, bookmark_selector.update(choices=[])
 
     try:
         bookmarks = parse_bookmarks(file_content)
     except Exception as e:
         logger.error(f"Error parsing bookmarks: {e}", exc_info=True)
-        return "Error parsing the bookmarks HTML file.", '', state_bookmarks, gr.CheckboxGroup.update(choices=[])
+        return "Error parsing the bookmarks HTML file.", '', state_bookmarks, bookmark_selector.update(choices=[])
 
     if not bookmarks:
         logger.warning("No bookmarks found in the uploaded file")
-        return "No bookmarks found in the uploaded file.", '', state_bookmarks, gr.CheckboxGroup.update(choices=[])
+        return "No bookmarks found in the uploaded file.", '', state_bookmarks, bookmark_selector.update(choices=[])
 
     # Assign unique IDs to bookmarks
     for idx, bookmark in enumerate(bookmarks):
@@ -489,7 +493,7 @@ def process_uploaded_file(file, state_bookmarks):
         faiss_index = vectorize_and_index(bookmarks)
     except Exception as e:
         logger.error(f"Error building FAISS index: {e}", exc_info=True)
-        return "Error building search index.", '', state_bookmarks, gr.CheckboxGroup.update(choices=[])
+        return "Error building search index.", '', state_bookmarks, bookmark_selector.update(choices=[])
 
     message = f"✅ Successfully processed {len(bookmarks)} bookmarks."
     logger.info(message)
@@ -502,15 +506,15 @@ def process_uploaded_file(file, state_bookmarks):
     # Update state
     state_bookmarks = bookmarks.copy()
 
-    return message, bookmark_html, state_bookmarks, gr.CheckboxGroup.update(choices=choices)
+    return message, bookmark_html, state_bookmarks, bookmark_selector.update(choices=choices)
 
-def delete_selected_bookmarks(selected_indices, state_bookmarks):
+def delete_selected_bookmarks(selected_indices, state_bookmarks, bookmark_selector, bookmark_display_manage):
     """
     Delete selected bookmarks and remove their vectors from the FAISS index.
     """
     global bookmarks, faiss_index
     if not selected_indices:
-        return "⚠️ No bookmarks selected.", gr.CheckboxGroup.update(choices=[]), display_bookmarks()
+        return "⚠️ No bookmarks selected.", bookmark_selector.update(choices=[]), display_bookmarks()
 
     ids_to_delete = []
     indices_to_delete = []
@@ -541,16 +545,16 @@ def delete_selected_bookmarks(selected_indices, state_bookmarks):
     # Update state
     state_bookmarks = bookmarks.copy()
 
-    return message, gr.CheckboxGroup.update(choices=choices), display_bookmarks()
+    return message, bookmark_selector.update(choices=choices), display_bookmarks()
 
-def edit_selected_bookmarks_category(selected_indices, new_category, state_bookmarks):
+def edit_selected_bookmarks_category(selected_indices, new_category, state_bookmarks, bookmark_selector, bookmark_display_manage):
     """
     Edit category of selected bookmarks.
     """
     if not selected_indices:
-        return "⚠️ No bookmarks selected.", gr.CheckboxGroup.update(choices=[]), display_bookmarks(), state_bookmarks
+        return "⚠️ No bookmarks selected.", bookmark_selector.update(choices=[]), display_bookmarks(), state_bookmarks
     if not new_category:
-        return "⚠️ No new category selected.", gr.CheckboxGroup.update(choices=[]), display_bookmarks(), state_bookmarks
+        return "⚠️ No new category selected.", bookmark_selector.update(choices=[]), display_bookmarks(), state_bookmarks
 
     indices = []
     for s in selected_indices:
@@ -577,7 +581,7 @@ def edit_selected_bookmarks_category(selected_indices, new_category, state_bookm
     # Update state
     state_bookmarks = bookmarks.copy()
 
-    return message, gr.CheckboxGroup.update(choices=choices), display_bookmarks(), state_bookmarks
+    return message, bookmark_selector.update(choices=choices), display_bookmarks(), state_bookmarks
 
 def export_bookmarks():
     """
@@ -625,7 +629,7 @@ def chatbot_response(user_query, chat_history):
         chat_history.append({"role": "user", "content": user_query})
 
         # Rate Limiting Logic (if necessary)
-        with lock:
+        with api_lock:
             global last_api_call_time
             current_time = time.time()
             elapsed = current_time - last_api_call_time
@@ -633,7 +637,7 @@ def chatbot_response(user_query, chat_history):
                 sleep_duration = 2 - elapsed
                 logger.info(f"Sleeping for {sleep_duration:.2f} seconds to respect rate limits.")
                 time.sleep(sleep_duration)
-            last_api_call_time = time.time()
+            last_api_call_time = current_time
 
         # Encode the query and search the FAISS index
         query_vector = embedding_model.encode([user_query]).astype('float32')
@@ -694,12 +698,6 @@ def build_app():
             # Initialize state
             state_bookmarks = gr.State([])
 
-            # Define 'bookmark_selector' once
-            bookmark_selector = gr.CheckboxGroup(
-                label="✅ Select Bookmarks",
-                choices=[]
-            )
-
             # General Overview
             gr.Markdown("""
 # 📚 SmartMarks - AI Browser Bookmarks Manager
@@ -744,8 +742,8 @@ Navigate through the tabs to explore each feature in detail.
 
                 process_button.click(
                     process_uploaded_file,
-                    inputs=[upload, state_bookmarks],
-                    outputs=[output_text, bookmark_display, state_bookmarks, bookmark_selector]
+                    inputs=[upload, state_bookmarks, None],  # 'bookmark_selector' is defined within "Manage Bookmarks" tab
+                    outputs=[output_text, bookmark_display, state_bookmarks, gr.State(None)]
                 )
 
             with gr.Tab("Chat with Bookmarks"):
@@ -815,8 +813,11 @@ Navigate through the tabs to explore each feature in detail.
                 bookmark_display_manage = gr.HTML(label="📄 Bookmarks")
 
                 with gr.Row():
-                    # Include 'bookmark_selector' directly in the layout
-                    bookmark_selector
+                    # Define 'bookmark_selector' within the tab
+                    bookmark_selector = gr.CheckboxGroup(
+                        label="✅ Select Bookmarks",
+                        choices=[]
+                    )
 
                 with gr.Row():
                     delete_button = gr.Button("🗑️ Delete Selected")