Update src/database.py

src/database.py

@@ -4,7 +4,6 @@ Database module for handling conversation persistence using Supabase.
 
 import os
 import json
-import logging
 from datetime import datetime
 import requests
 from dotenv import load_dotenv
@@ -12,11 +11,6 @@ from dotenv import load_dotenv
 # Load environment variables
 load_dotenv()
 
-# Set up logging
-logging.basicConfig(level=logging.INFO, 
-                    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
-logger = logging.getLogger('database')
-
 class SupabaseClient:
     def __init__(self):
         """Initialize Supabase client with credentials from environment variables."""
@@ -24,11 +18,8 @@ class SupabaseClient:
         self.supabase_key = os.getenv('SUPABASE_KEY')
         
         if not self.supabase_url or not self.supabase_key:
-            logger.error("Supabase credentials not found in environment variables")
             raise ValueError("Supabase credentials not found in environment variables. "
                             "Please set SUPABASE_URL and SUPABASE_KEY.")
-        
-        logger.info(f"Initialized Supabase client with URL: {self.supabase_url[:20]}...")
     
     def _make_request(self, method, endpoint, data=None, params=None):
         """Make a request to Supabase API."""
@@ -40,65 +31,40 @@ class SupabaseClient:
             "Prefer": "return=representation"
         }
         
-        logger.debug(f"Making {method} request to {endpoint}")
-        
-        try:
-            if method == "GET":
-                response = requests.get(url, headers=headers, params=params)
-            elif method == "POST":
-                logger.debug(f"POST data: {json.dumps(data)[:500]}...")
-                response = requests.post(url, headers=headers, json=data)
-            elif method == "PUT":
-                response = requests.put(url, headers=headers, json=data)
-            elif method == "DELETE":
-                response = requests.delete(url, headers=headers, params=params)
-            else:
-                raise ValueError(f"Unsupported method: {method}")
-                
-            # Check response status and log appropriately
-            if response.status_code >= 400:
-                logger.error(f"API error: {method} {endpoint} returned {response.status_code}: {response.text}")
-            else:
-                logger.debug(f"API success: {method} {endpoint} returned {response.status_code}")
-                
-            return response
-            
-        except requests.RequestException as e:
-            logger.error(f"Request error: {str(e)}")
-            raise
+        if method == "GET":
+            response = requests.get(url, headers=headers, params=params)
+        elif method == "POST":
+            response = requests.post(url, headers=headers, json=data)
+        elif method == "PUT":
+            response = requests.put(url, headers=headers, json=data)
+        elif method == "DELETE":
+            response = requests.delete(url, headers=headers, params=params)
+        else:
+            raise ValueError(f"Unsupported method: {method}")
+        
+        return response
 
     def create_conversation(self, consultation_id):
         """Create a new conversation record in the database."""
-        logger.info(f"Creating conversation with ID: {consultation_id}")
-        
         data = {
             "consultation_id": consultation_id,
             "created_at": datetime.now().isoformat(),
             "is_active": True
         }
         
-        try:
-            response = self._make_request(
-                "POST", 
-                "/rest/v1/conversations", 
-                data=data
-            )
-            
-            if response.status_code not in (200, 201):
-                logger.error(f"Failed to create conversation: {response.text}")
-                raise Exception(f"Failed to create conversation: {response.text}")
-            
-            logger.info(f"Successfully created conversation: {consultation_id}")
-            return response.json()
-            
-        except Exception as e:
-            logger.error(f"Error creating conversation: {str(e)}")
-            raise
+        response = self._make_request(
+            "POST", 
+            "/rest/v1/conversations", 
+            data=data
+        )
+        
+        if response.status_code not in (200, 201):
+            raise Exception(f"Failed to create conversation: {response.text}")
+        
+        return response.json()
     
     def save_message(self, consultation_id, message):
         """Save a single message to the database."""
-        logger.info(f"Saving message for conversation: {consultation_id}, role: {message.get('role')}")
-        
         # Normalize message format for database storage
         message_data = {
             "consultation_id": consultation_id,
@@ -113,149 +79,93 @@ class SupabaseClient:
         
         if "evidence" in message:
             # Convert evidence to string for storage
-            try:
-                message_data["evidence"] = json.dumps(message.get("evidence"))
-            except Exception as e:
-                logger.error(f"Error serializing evidence: {str(e)}")
-                message_data["evidence"] = "[]"
+            message_data["evidence"] = json.dumps(message.get("evidence"))
         
-        try:
-            # First verify that the consultation_id exists
-            verify_params = {"consultation_id": f"eq.{consultation_id}"}
-            verify_response = self._make_request("GET", "/rest/v1/conversations", params=verify_params)
-            
-            if verify_response.status_code != 200 or len(verify_response.json()) == 0:
-                logger.error(f"Conversation {consultation_id} not found, creating it first")
-                self.create_conversation(consultation_id)
-            
-            # Now save the message
-            response = self._make_request(
-                "POST", 
-                "/rest/v1/messages", 
-                data=message_data
-            )
-            
-            if response.status_code not in (200, 201):
-                logger.error(f"Failed to save message: {response.text}")
-                raise Exception(f"Failed to save message: {response.text}")
-            
-            logger.info(f"Successfully saved message for conversation: {consultation_id}")
-            return response.json()
-            
-        except Exception as e:
-            logger.error(f"Error saving message: {str(e)}")
-            raise
+        response = self._make_request(
+            "POST", 
+            "/rest/v1/messages", 
+            data=message_data
+        )
+        
+        if response.status_code not in (200, 201):
+            raise Exception(f"Failed to save message: {response.text}")
+        
+        return response.json()
     
     def get_conversation_history(self, consultation_id):
         """Retrieve full conversation history for a given consultation ID."""
-        logger.info(f"Retrieving conversation history for: {consultation_id}")
-        
         params = {
             "consultation_id": f"eq.{consultation_id}",
             "order": "timestamp.asc"
         }
         
-        try:
-            response = self._make_request(
-                "GET", 
-                "/rest/v1/messages", 
-                params=params
-            )
-            
-            if response.status_code != 200:
-                logger.error(f"Failed to retrieve conversation history: {response.text}")
-                raise Exception(f"Failed to retrieve conversation history: {response.text}")
-            
-            # Convert database format back to application format
-            messages = response.json()
-            history = []
-            
-            logger.info(f"Retrieved {len(messages)} messages for conversation: {consultation_id}")
+        response = self._make_request(
+            "GET", 
+            "/rest/v1/messages", 
+            params=params
+        )
+        
+        if response.status_code != 200:
+            raise Exception(f"Failed to retrieve conversation history: {response.text}")
+        
+        # Convert database format back to application format
+        messages = response.json()
+        history = []
+        
+        for msg in messages:
+            message_dict = {
+                "role": msg["role"],
+                "content": msg["content"]
+            }
             
-            for msg in messages:
-                message_dict = {
-                    "role": msg["role"],
-                    "content": msg["content"]
-                }
-                
-                if msg.get("explanation"):
-                    message_dict["explanation"] = msg["explanation"]
-                
-                if msg.get("evidence"):
-                    # Parse evidence JSON string back to object
-                    try:
-                        message_dict["evidence"] = json.loads(msg["evidence"])
-                    except:
-                        message_dict["evidence"] = []
-                
-                history.append(message_dict)
+            if msg.get("explanation"):
+                message_dict["explanation"] = msg["explanation"]
             
-            return history
+            if msg.get("evidence"):
+                # Parse evidence JSON string back to object
+                try:
+                    message_dict["evidence"] = json.loads(msg["evidence"])
+                except:
+                    message_dict["evidence"] = []
             
-        except Exception as e:
-            logger.error(f"Error retrieving conversation history: {str(e)}")
-            raise
+            history.append(message_dict)
+        
+        return history
     
     def delete_conversation(self, consultation_id):
         """Delete a completed conversation from the database."""
-        logger.info(f"Deleting conversation: {consultation_id}")
+        # First delete all messages
+        msg_params = {"consultation_id": f"eq.{consultation_id}"}
+        self._make_request("DELETE", "/rest/v1/messages", params=msg_params)
         
-        try:
-            # First delete all messages
-            msg_params = {"consultation_id": f"eq.{consultation_id}"}
-            msg_response = self._make_request("DELETE", "/rest/v1/messages", params=msg_params)
-            
-            if msg_response.status_code != 200:
-                logger.warning(f"Failed to delete messages for conversation {consultation_id}: {msg_response.text}")
-            
-            # Then delete conversation record
-            conv_params = {"consultation_id": f"eq.{consultation_id}"}
-            response = self._make_request("DELETE", "/rest/v1/conversations", params=conv_params)
-            
-            if response.status_code != 200:
-                logger.error(f"Failed to delete conversation: {response.text}")
-                raise Exception(f"Failed to delete conversation: {response.text}")
-            
-            logger.info(f"Successfully deleted conversation: {consultation_id}")
-            return True
-            
-        except Exception as e:
-            logger.error(f"Error deleting conversation: {str(e)}")
-            raise
+        # Then delete conversation record
+        conv_params = {"consultation_id": f"eq.{consultation_id}"}
+        response = self._make_request("DELETE", "/rest/v1/conversations", params=conv_params)
+        
+        if response.status_code != 200:
+            raise Exception(f"Failed to delete conversation: {response.text}")
+        
+        return True
         
     def get_active_conversations(self):
         """Get list of active conversations."""
-        logger.info("Retrieving active conversations")
-        
         params = {
             "is_active": "eq.true",
             "order": "created_at.desc"
         }
         
-        try:
-            response = self._make_request(
-                "GET", 
-                "/rest/v1/conversations", 
-                params=params
-            )
-            
-            if response.status_code != 200:
-                logger.error(f"Failed to retrieve active conversations: {response.text}")
-                raise Exception(f"Failed to retrieve active conversations: {response.text}")
-            
-            conversations = response.json()
-            logger.info(f"Retrieved {len(conversations)} active conversations")
-            return conversations
-            
-        except Exception as e:
-            logger.error(f"Error retrieving active conversations: {str(e)}")
-            raise
+        response = self._make_request(
+            "GET", 
+            "/rest/v1/conversations", 
+            params=params
+        )
+        
+        if response.status_code != 200:
+            raise Exception(f"Failed to retrieve active conversations: {response.text}")
+        
+        return response.json()
 
 # Initialize database client
 def get_db_client():
     """Get database client instance."""
-    try:
-        return SupabaseClient()
-    except Exception as e:
-        logger.error(f"Error initializing database client: {str(e)}")
-        raise 
+    return SupabaseClient()