Update app.py

app.py

@@ -3,12 +3,26 @@ from openai import OpenAI
 import requests
 import json
 import os
+import logging
 from typing import Dict, List
+from datetime import datetime
+
+# Set up logging
+logging.basicConfig(
+    level=logging.DEBUG,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+    handlers=[
+        logging.FileHandler(f'raindrop_search_{datetime.now().strftime("%Y%m%d_%H%M%S")}.log'),
+        logging.StreamHandler()
+    ]
+)
+logger = logging.getLogger('RaindropSearchBot')
 
 OPENAI_API_KEY = os.getenv('openaikey')
 RAINDROP_TOKEN = os.getenv('raindroptoken')
 
 if not OPENAI_API_KEY or not RAINDROP_TOKEN:
+    logger.error("Missing environment variables")
     raise EnvironmentError(
         "Missing required environment variables. Please ensure 'openaikey' and 'raindroptoken' are set."
     )
@@ -18,8 +32,10 @@ class RaindropSearchBot:
         self.openai_api_key = OPENAI_API_KEY
         self.raindrop_api_token = RAINDROP_TOKEN
         self.client = OpenAI(api_key=self.openai_api_key)
+        logger.info("RaindropSearchBot initialized")
         
     def generate_search_query(self, user_request: str) -> str:
+        logger.info(f"Generating search query for request: {user_request}")
         prompt = f"""
         Convert the following request into a focused search query for Raindrop.io.
         Extract key concepts and create a search query that will work well with the Raindrop API.
@@ -30,53 +46,75 @@ class RaindropSearchBot:
         Format the search query for maximum relevance and recall.
         """
         
-        response = self.client.chat.completions.create(
-            model="gpt-4o-mini",
-            messages=[{"role": "user", "content": prompt}],
-            temperature=0.5,
-            max_tokens=1000
-        )
-        return response.choices[0].message.content
+        try:
+            response = self.client.chat.completions.create(
+                model="gpt-4o-mini",
+                messages=[{"role": "user", "content": prompt}],
+                temperature=0.5,
+                max_tokens=1000
+            )
+            generated_query = response.choices[0].message.content
+            logger.info(f"Generated search query: {generated_query}")
+            return generated_query
+        except Exception as e:
+            logger.error(f"Error generating search query: {str(e)}")
+            raise
 
     def search_raindrop(self, search_query: str) -> List[Dict]:
+        logger.info(f"Searching Raindrop with query: {search_query}")
+        
         headers = {
             "Authorization": f"Bearer {self.raindrop_api_token}",
             "Content-Type": "application/json"
         }
         
-        # Get all collections first
-        collections_response = requests.get(
-            "https://api.raindrop.io/rest/v1/collections",
-            headers=headers
-        )
-        
-        params = {
-            "search": search_query,
-            "page": 0,
-            "perpage": 50,  # Increased from 10 to 50
-            "sort": "-created"  # Sort by newest first
-        }
-        
-        # Search in all collections (0)
-        response = requests.get(
-            "https://api.raindrop.io/rest/v1/raindrops/0",
-            headers=headers,
-            params=params
-        )
-        
-        if response.status_code == 200:
-            items = response.json().get("items", [])
-            # Get filters to enhance search context
-            filters_response = requests.get(
-                "https://api.raindrop.io/rest/v1/filters/0",
+        try:
+            # First, let's test the API connection and token
+            test_response = requests.get(
+                "https://api.raindrop.io/rest/v1/user",
+                headers=headers
+            )
+            logger.info(f"API test response status: {test_response.status_code}")
+            if test_response.status_code != 200:
+                logger.error(f"API test failed: {test_response.text}")
+                return []
+
+            # Search parameters
+            params = {
+                "search": search_query,
+                "page": 0,
+                "perpage": 50,
+                "sort": "-created"
+            }
+            
+            # Log the full request details
+            logger.info(f"Making request to Raindrop API with params: {params}")
+            
+            # Make the search request
+            response = requests.get(
+                "https://api.raindrop.io/rest/v1/raindrops/0",
                 headers=headers,
-                params={"search": search_query}
+                params=params
             )
-            return items
-        return []
+            
+            logger.info(f"Search response status code: {response.status_code}")
+            
+            if response.status_code == 200:
+                data = response.json()
+                items = data.get("items", [])
+                logger.info(f"Found {len(items)} results")
+                logger.debug(f"Response data: {json.dumps(data, indent=2)}")
+                return items
+            else:
+                logger.error(f"Search failed with status {response.status_code}: {response.text}")
+                return []
+                
+        except Exception as e:
+            logger.error(f"Error during Raindrop search: {str(e)}", exc_info=True)
+            return []
 
     def generate_summary(self, item: Dict) -> str:
-        """Generate a summary for a single bookmark using GPT-4."""
+        logger.info(f"Generating summary for item: {item.get('title', 'No Title')}")
         content = f"""
         Title: {item.get('title', 'No Title')}
         Description: {item.get('excerpt', '')}
@@ -97,48 +135,64 @@ class RaindropSearchBot:
                 temperature=0.3,
                 max_tokens=150
             )
-            return response.choices[0].message.content
+            summary = response.choices[0].message.content
+            logger.info(f"Generated summary: {summary}")
+            return summary
         except Exception as e:
+            logger.error(f"Error generating summary: {str(e)}")
             return "Summary generation failed"
 
     def format_results(self, results: List[Dict]) -> str:
+        logger.info(f"Formatting {len(results)} results")
+        
         if not results:
+            logger.warning("No results to format")
             return "No results found."
             
         formatted_output = "🔍 Search Results:\n\n"
         for idx, item in enumerate(results, 1):
+            logger.debug(f"Formatting item {idx}: {item.get('title', 'No Title')}")
+            
             formatted_output += f"{idx}. {item.get('title', 'No Title')}\n"
             formatted_output += f"   Link: {item.get('link', 'No Link')}\n"
             
-            # Add tags if present
             if item.get('tags'):
                 formatted_output += f"   Tags: {', '.join(item['tags'])}\n"
             
-            # Add type and created date
             formatted_output += f"   Type: {item.get('type', 'unknown')} | Created: {item.get('created', 'unknown')}\n"
             
-            # Add summary
             summary = self.generate_summary(item)
-            formatted_output += f"   Summary: {summary}\n"
-            
-            formatted_output += "\n"
+            formatted_output += f"   Summary: {summary}\n\n"
             
+        logger.info("Results formatting completed")
         return formatted_output
     
     def process_request(self, user_request: str) -> str:
+        logger.info(f"Processing new request: {user_request}")
         try:
             search_query = self.generate_search_query(user_request)
+            logger.info(f"Using search query: {search_query}")
+            
             results = self.search_raindrop(search_query)
-            return self.format_results(results)
+            logger.info(f"Found {len(results)} results")
+            
+            formatted_results = self.format_results(results)
+            logger.info("Request processing completed")
+            return formatted_results
+            
         except Exception as e:
-            return f"An error occurred: {str(e)}"
+            logger.error(f"Error processing request: {str(e)}", exc_info=True)
+            return f"An error occurred: {str(e)}\nPlease check the logs for more details."
 
 # Initialize the bot
 bot = RaindropSearchBot()
 
 # Create Gradio interface
 def chatbot_interface(user_input: str) -> str:
-    return bot.process_request(user_input)
+    logger.info(f"New interface request received: {user_input}")
+    result = bot.process_request(user_input)
+    logger.info("Interface request completed")
+    return result
 
 # Define and launch the Gradio interface
 with gr.Blocks(title="Raindrop.io Link Search Assistant", theme=gr.themes.Soft()) as demo:
@@ -184,4 +238,5 @@ with gr.Blocks(title="Raindrop.io Link Search Assistant", theme=gr.themes.Soft()
     """)
 
 if __name__ == "__main__":
+    logger.info("Starting Gradio interface")
     demo.launch(share=True)