Update app.py

app.py

@@ -38,6 +38,42 @@ st.set_page_config(
     page_icon="🔍"
 )
 
+# Debug logging
+debug_mode = False
+if "debug" not in st.session_state:
+    st.session_state.debug = debug_mode
+
+# Add debug toggle in sidebar
+with st.sidebar:
+    st.session_state.debug = st.toggle("Enable Debug Mode", value=debug_mode)
+
+def log_debug(message):
+    """Helper function to log debug messages only when debug mode is enabled"""
+    if st.session_state.debug:
+        st.write(f"DEBUG: {message}")
+
+# Function to check environment
+def check_environment():
+    import sys
+    import platform
+    
+    if st.session_state.debug:
+        st.sidebar.write("### Environment Info")
+        st.sidebar.write(f"Python version: {sys.version}")
+        st.sidebar.write(f"Platform: {platform.platform()}")
+        try:
+            import torch
+            st.sidebar.write(f"Torch version: {torch.__version__}")
+            st.sidebar.write(f"CUDA available: {torch.cuda.is_available()}")
+            if torch.cuda.is_available():
+                st.sidebar.write(f"CUDA version: {torch.version.cuda}")
+                st.sidebar.write(f"GPU: {torch.cuda.get_device_name(0)}")
+        except:
+            st.sidebar.write("Torch not available or error checking")
+
+# Run environment check
+check_environment()
+
 # Main title and description
 st.title("Deepfake Image Analyser")
 st.markdown("Analyse images for deepfake manipulation")
@@ -190,14 +226,29 @@ def load_detection_model_xception():
     """Loads the Xception model from our module"""
     with st.spinner("Loading Xception model for deepfake detection..."):
         try:
+            log_debug("Beginning Xception model loading")
+            from gradcam_xception import load_xception_model
             model = load_xception_model()
+            
             # Get the device
             device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+            log_debug(f"Using device: {device}")
+            
             model.to(device)
             model.eval()
+            log_debug("Xception model loaded successfully")
             return model, device
+        except ImportError as e:
+            st.error(f"Import Error: {str(e)}. Make sure gradcam_xception.py is present.")
+            log_debug("Import error with gradcam_xception.py module")
+            return None, None
         except Exception as e:
             st.error(f"Error loading Xception model: {str(e)}")
+            import traceback
+            error_details = traceback.format_exc()
+            if st.session_state.debug:
+                st.error(error_details)
+            log_debug(f"Error details: {error_details}")
             return None, None
 
 # ----- BLIP Image Captioning -----
@@ -422,11 +473,19 @@ def analyze_image_with_llm(image, gradcam_overlay, face_box, pred_label, confide
 def preprocess_image_xception(image):
     """Preprocesses image for Xception model input and face detection."""
     try:
-        st.write("Starting image preprocessing...")
+        log_debug("Starting image preprocessing for Xception model")
         face_detector = cv2.CascadeClassifier(cv2.data.haarcascades + 'haarcascade_frontalface_default.xml')
+        
+        # Ensure image is in correct format
+        if image is None:
+            log_debug("Image is None - this should never happen!")
+            return None, None, None
+        
+        # Get image shape for logging
         image_np = np.array(image.convert('RGB'))  # Ensure RGB
-        st.write(f"Image shape: {image_np.shape}")
+        log_debug(f"Image shape: {image_np.shape}")
         
+        # Face detection with detailed logs
         gray = cv2.cvtColor(image_np, cv2.COLOR_RGB2GRAY)
         faces = face_detector.detectMultiScale(gray, 1.1, 5)
 
@@ -434,12 +493,14 @@ def preprocess_image_xception(image):
         face_box_display = None  # For drawing on original image
 
         if len(faces) == 0:
+            log_debug("No face detected in the image, using whole image")
             st.warning("No face detected, using whole image for prediction/CAM.")
         else:
+            log_debug(f"Detected {len(faces)} faces in the image")
             areas = [w * h for (x, y, w, h) in faces]
             largest_idx = np.argmax(areas)
             x, y, w, h = faces[largest_idx]
-            st.write(f"Face detected at: x={x}, y={y}, w={w}, h={h}")
+            log_debug(f"Using largest face at: x={x}, y={y}, w={w}, h={h}")
             
             padding_x = int(w * 0.05)  # Use percentages as in gradcam_xception
             padding_y = int(h * 0.05)
@@ -455,18 +516,29 @@ def preprocess_image_xception(image):
         transform = get_xception_transform()
         # Apply transform to the selected region (face or whole image)
         input_tensor = transform(face_img_for_transform).unsqueeze(0)
-        st.write(f"Tensor shape: {input_tensor.shape}")
+        log_debug(f"Preprocessed tensor shape: {input_tensor.shape}")
 
         # Return tensor, original full image, and the display face box
         return input_tensor, image, face_box_display
+        
     except Exception as e:
         st.error(f"Error in preprocessing image: {str(e)}")
         import traceback
-        st.error(traceback.format_exc())
-        # Return defaults that won't break the pipeline
-        transform = get_xception_transform()
-        input_tensor = transform(image).unsqueeze(0)
-        return input_tensor, image, None
+        error_details = traceback.format_exc()
+        log_debug(f"Preprocessing error details: {error_details}")
+        if st.session_state.debug:
+            st.error(error_details)
+            
+        # Try a fallback method if possible
+        try:
+            log_debug("Trying fallback preprocessing method")
+            transform = get_xception_transform()
+            input_tensor = transform(image).unsqueeze(0)
+            return input_tensor, image, None
+        except Exception as fallback_e:
+            log_debug(f"Fallback also failed: {str(fallback_e)}")
+            st.error("Both preprocessing attempts failed. Please try another image.")
+            return None, None, None
 
 # Main app
 def main():
@@ -491,6 +563,54 @@ def main():
     if 'chat_history' not in st.session_state:
         st.session_state.chat_history = []
     
+    # Display Hugging Face Spaces information if debug mode is on
+    if st.session_state.debug:
+        with st.expander("Hugging Face Spaces Debugging Information", expanded=True):
+            st.markdown("""
+            ### Common Issues with Hugging Face Spaces
+            
+            1. **403/404 Errors**: Often caused by permission issues when accessing files or external resources.
+            
+            2. **Memory Limits**: Free spaces have limited memory (16GB). Large models may cause OOM errors.
+            
+            3. **Disk Space**: Limited to 10GB for persistent storage.
+            
+            4. **Network Restrictions**: Some external URLs might be blocked or restricted.
+            
+            ### Accessing Logs
+            To see detailed error logs in Hugging Face Spaces:
+            
+            1. Go to your Space dashboard
+            2. Click on "Logs" in the left sidebar
+            3. Check both "Build logs" and "Running logs" tabs
+            
+            In the running logs, look for Python tracebacks or error messages.
+            
+            ### This App's Setup
+            - All image processing is now done in-memory to avoid file permission issues
+            - Debug logging is available through this interface
+            - For large model loading issues, try using smaller models or increasing RAM allocation
+            """)
+            
+            # Add a test connection button
+            if st.button("Test Network Connection"):
+                try:
+                    import requests
+                    test_urls = [
+                        "https://huggingface.co/", 
+                        "https://www.google.com/",
+                        "https://jsonplaceholder.typicode.com/todos/1"
+                    ]
+                    
+                    for url in test_urls:
+                        try:
+                            response = requests.get(url, timeout=5)
+                            st.write(f"✅ {url}: Status {response.status_code}")
+                        except Exception as e:
+                            st.write(f"❌ {url}: Error - {str(e)}")
+                except Exception as e:
+                    st.error(f"Could not perform connection test: {str(e)}")
+    
     # Create expanders for each stage
     with st.expander("Stage 1: Model Loading", expanded=True):
         st.write("Please load the models using the buttons below:")
@@ -558,26 +678,53 @@ def main():
             uploaded_file = st.file_uploader("Choose an image...", type=["jpg", "jpeg", "png"])
             if uploaded_file is not None:
                 try:
-                    # Try to load directly from bytes to avoid file system issues
+                    # Direct in-memory handling - avoid writing to disk
                     file_bytes = uploaded_file.getvalue()
-                    uploaded_image = Image.open(io.BytesIO(file_bytes)).convert("RGB")
+                    # Log the file size for debugging
+                    st.write(f"Debug: Received file of size {len(file_bytes)} bytes")
+                    # Process directly in memory
+                    image_stream = io.BytesIO(file_bytes)
+                    uploaded_image = Image.open(image_stream).convert("RGB")
                     st.session_state.upload_method = "file"
+                    # Log success
+                    st.success("File loaded successfully in memory")
                 except Exception as e:
                     st.error(f"Error loading file: {str(e)}")
+                    import traceback
+                    st.error(traceback.format_exc())
         
         with upload_tab2:
             url = st.text_input("Enter image URL:")
             if url and url.strip():
                 try:
                     import requests
-                    response = requests.get(url, stream=True)
+                    # Log the URL (excluding any sensitive parts)
+                    display_url = url.split("?")[0] if "?" in url else url
+                    st.write(f"Debug: Attempting to fetch image from {display_url}")
+                    
+                    headers = {
+                        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36'
+                    }
+                    response = requests.get(url, stream=True, headers=headers, timeout=10)
+                    
                     if response.status_code == 200:
-                        uploaded_image = Image.open(io.BytesIO(response.content)).convert("RGB")
+                        # Log success and content type
+                        st.write(f"Debug: Received response - Content-Type: {response.headers.get('Content-Type', 'unknown')}")
+                        
+                        # Process directly in memory
+                        image_stream = io.BytesIO(response.content)
+                        uploaded_image = Image.open(image_stream).convert("RGB")
                         st.session_state.upload_method = "url"
+                        st.success(f"Image successfully loaded from URL - Size: {len(response.content)} bytes")
                     else:
                         st.error(f"Failed to load image from URL: Status code {response.status_code}")
+                        if response.status_code in [403, 401]:
+                            st.warning("This appears to be an access permissions issue. The server is refusing to serve this image.")
+                            st.info("Try using an image URL from a site that allows hotlinking, or upload a file directly.")
                 except Exception as e:
                     st.error(f"Error loading image from URL: {str(e)}")
+                    import traceback
+                    st.error(traceback.format_exc())
         
         # If we have an uploaded image, process it
         if uploaded_image is not None: