Update app.py

app.py

@@ -7,6 +7,7 @@
 FIXED: All issues identified by Grok4 - robust error handling, variable scope, codec fallbacks
 FIXED: Added SSR mode disable for Gradio compatibility
 FIXED: Audio preservation - no more missing audio in processed videos
+UPDATE: Enhanced logging for initialization errors, isolated matanyone imports to avoid GUI crashes
 """
 import cv2
 import numpy as np
@@ -49,6 +50,7 @@ def patched_get_type(schema):
     
 except (ImportError, AttributeError) as e:
     print(f"❌ CRITICAL: Gradio patch failed: {e}")
+    logger.error(f"Gradio patch failed: {e}")
 
 # Import utilities - CRITICAL: Use these functions, don't duplicate!
 from utilities import (
@@ -65,8 +67,10 @@ def patched_get_type(schema):
 try:
     from two_stage_processor import TwoStageProcessor, CHROMA_PRESETS
     TWO_STAGE_AVAILABLE = True
-except ImportError:
+    logger.info("Two-stage processor available")
+except ImportError as e:
     TWO_STAGE_AVAILABLE = False
+    logger.warning(f"Two-stage processor not available: {e}")
 
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
@@ -101,7 +105,6 @@ def get_device():
     """Automatically detect the best available device (CPU or GPU) with robust error handling"""
     try:
         if torch.cuda.is_available():
-            # Try to get device name safely
             try:
                 device_name = torch.cuda.get_device_name(0)
                 logger.info(f"Using GPU: {device_name}")
@@ -109,7 +112,6 @@ def get_device():
                 logger.warning(f"Could not get GPU name: {e}, but CUDA is available")
                 device_name = "CUDA GPU"
             
-            # Test CUDA functionality
             try:
                 test_tensor = torch.tensor([1.0], device='cuda')
                 del test_tensor
@@ -169,7 +171,6 @@ def create_video_writer(output_path: str, fps: float, width: int, height: int) -
     for fourcc_str, ext in codecs_to_try:
         try:
             fourcc = cv2.VideoWriter_fourcc(*fourcc_str)
-            # Ensure output has correct extension
             if not output_path.endswith(ext):
                 base = os.path.splitext(output_path)[0]
                 test_path = base + ext
@@ -197,7 +198,6 @@ def _prog(pct: float, desc: str):
         if progress_callback:
             progress_callback(pct, desc)
 
-        # Format progress info for display in the UI
         if "Frame" in desc and "|" in desc:
             parts = desc.split("|")
             frame_info = parts[0].strip() if len(parts) > 0 else ""
@@ -221,61 +221,61 @@ def _prog(pct: float, desc: str):
     try:
         _prog(0.1, "Initializing SAM2...")
 
-        # Check HF token and environment
         hf_token = os.getenv('HF_TOKEN')
         if not hf_token:
             logger.warning("No HF_TOKEN found, downloads may be rate limited")
 
-        # Download checkpoint with caching and robust error handling
-        # Use the correct Facebook repository path
         try:
             checkpoint_path = hf_hub_download(
-                repo_id="facebook/sam2-hiera-large",  # FIXED: Correct repository
+                repo_id="facebook/sam2-hiera-large",
                 filename="sam2_hiera_large.pt",
                 cache_dir=str(CACHE_DIR / "sam2_checkpoint"),
                 force_download=False,
                 token=hf_token
             )
+            logger.info(f"SAM2 checkpoint downloaded to {checkpoint_path}")
         except Exception as e:
             logger.error(f"Failed to download SAM2 checkpoint: {e}")
             raise Exception(f"SAM2 checkpoint download failed: {e}")
 
-        # Import and build
         try:
             from sam2.build_sam import build_sam2
             from sam2.sam2_image_predictor import SAM2ImagePredictor
+            logger.info("SAM2 modules imported successfully")
         except ImportError as e:
+            logger.error(f"SAM2 import failed: {e}")
             raise Exception(f"SAM2 import failed: {e}. Make sure SAM2 is properly installed.")
 
-        # Build model with explicit config
         try:
             sam2_model = build_sam2("sam2_hiera_l.yaml", checkpoint_path)
             sam2_model.to(device)
-            sam2_model.eval()  # Set to evaluation mode for inference
+            sam2_model.eval()
             predictor = SAM2ImagePredictor(sam2_model)
+            logger.info(f"SAM2 model built and moved to {device}")
         except Exception as e:
+            logger.error(f"SAM2 model creation failed: {e}")
             raise Exception(f"SAM2 model creation failed: {e}")
 
-        # Test the predictor with dummy data - ROBUST TYPES
         _prog(0.8, "Testing SAM2 functionality...")
         test_image = np.zeros((256, 256, 3), dtype=np.uint8)
         predictor.set_image(test_image)
         
-        # Ensure correct types and shapes for SAM2
-        test_points = np.array([[128.0, 128.0]], dtype=np.float32)  # Explicit float32
-        test_labels = np.array([1], dtype=np.int32)  # Explicit int32
+        test_points = np.array([[128.0, 128.0]], dtype=np.float32)
+        test_labels = np.array([1], dtype=np.int32)
         
         try:
-            with torch.no_grad():  # Disable gradients for inference
+            with torch.no_grad():
                 masks, scores, _ = predictor.predict(
                     point_coords=test_points,
                     point_labels=test_labels,
                     multimask_output=False
                 )
         except Exception as e:
+            logger.error(f"SAM2 prediction test failed: {e}")
             raise Exception(f"SAM2 prediction test failed: {e}")
 
         if masks is None or len(masks) == 0:
+            logger.error("SAM2 predictor test failed - no masks generated")
             raise Exception("SAM2 predictor test failed - no masks generated")
 
         _prog(1.0, "SAM2 loaded and validated successfully!")
@@ -301,21 +301,23 @@ def _prog(pct: float, desc: str):
 
         try:
             from matanyone import InferenceCore
+            logger.info("Successfully imported MatAnyone InferenceCore")
         except ImportError as e:
+            logger.error(f"MatAnyone import failed: {e}")
             raise Exception(f"MatAnyone import failed: {e}. Make sure MatAnyone is properly installed.")
 
         try:
             processor = InferenceCore("PeiqingYang/MatAnyone")
+            logger.info("MatAnyone InferenceCore initialized")
         except Exception as e:
+            logger.error(f"MatAnyone model loading failed: {e}")
             raise Exception(f"MatAnyone model loading failed: {e}")
 
-        # Test MatAnyone with dummy data
         _prog(0.8, "Testing MatAnyone functionality...")
         test_image = np.zeros((256, 256, 3), dtype=np.uint8)
         test_mask = np.zeros((256, 256), dtype=np.uint8)
         test_mask[64:192, 64:192] = 255
 
-        # Test the processor
         try:
             if hasattr(processor, 'process') or hasattr(processor, '__call__'):
                 logger.info("MatAnyone processor interface detected")
@@ -362,6 +364,7 @@ def load_models_with_validation(progress_callback: Optional[callable] = None) ->
 
     with loading_lock:
         if models_loaded and not PROCESS_CANCELLED.is_set():
+            logger.info("Models already loaded and validated")
             return "Models already loaded and validated"
 
         try:
@@ -372,24 +375,27 @@ def load_models_with_validation(progress_callback: Optional[callable] = None) ->
             if progress_callback:
                 progress_callback(0.0, f"Starting model loading on {DEVICE}...")
 
-            # Load SAM2 with validation
             sam2_predictor = load_sam2_predictor_fixed(device=DEVICE, progress_callback=progress_callback)
 
             if PROCESS_CANCELLED.is_set():
+                logger.info("Model loading cancelled by user")
                 return "Model loading cancelled by user"
 
-            # Load MatAnyone with validation
             matanyone_model = load_matanyone_fixed(progress_callback=progress_callback)
 
             if PROCESS_CANCELLED.is_set():
+                logger.info("Model loading cancelled by user")
                 return "Model loading cancelled by user"
 
             models_loaded = True
 
-            # Initialize two-stage processor if available
             if TWO_STAGE_AVAILABLE:
-                two_stage_processor = TwoStageProcessor(sam2_predictor, matanyone_model)
-                logger.info("Two-stage processor initialized")
+                try:
+                    two_stage_processor = TwoStageProcessor(sam2_predictor, matanyone_model)
+                    logger.info("Two-stage processor initialized")
+                except Exception as e:
+                    logger.warning(f"Two-stage processor initialization failed: {e}")
+                    TWO_STAGE_AVAILABLE = False
 
             load_time = time.time() - start_time
             message = f"SUCCESS: SAM2 + MatAnyone loaded and validated in {load_time:.1f}s on {DEVICE}"
@@ -421,17 +427,20 @@ def process_video_fixed(
     global PROCESS_CANCELLED
 
     if PROCESS_CANCELLED.is_set():
+        logger.info("Processing cancelled by user")
         return None, "Processing cancelled by user"
 
     if not models_loaded:
+        logger.error("Models not loaded")
         return None, "Models not loaded. Call load_models_with_validation() first."
 
     if not video_path or not os.path.exists(video_path):
+        logger.error(f"Video file not found: {video_path}")
         return None, f"Video file not found: {video_path}"
 
-    # Validate video file
     is_valid, validation_msg = validate_video_file(video_path)
     if not is_valid:
+        logger.error(f"Invalid video: {validation_msg}")
         return None, f"Invalid video: {validation_msg}"
 
     def _prog(pct: float, desc: str):
@@ -441,7 +450,6 @@ def _prog(pct: float, desc: str):
         if progress_callback:
             progress_callback(pct, desc)
 
-        # Update processing info file
         if "Frame" in desc and "|" in desc:
             parts = desc.split("|")
             frame_info = parts[0].strip() if len(parts) > 0 else ""
@@ -466,29 +474,30 @@ def _prog(pct: float, desc: str):
     try:
         _prog(0.0, f"Starting {'TWO-STAGE' if use_two_stage else 'SINGLE-STAGE'} processing on {DEVICE}...")
 
-        # Check if two-stage mode is requested
         if use_two_stage:
             if not TWO_STAGE_AVAILABLE:
+                logger.error("Two-stage mode not available")
                 return None, "Two-stage mode not available. Please add two_stage_processor.py file."
 
             if two_stage_processor is None:
+                logger.error("Two-stage processor not initialized")
                 return None, "Two-stage processor not initialized. Please reload models."
 
             _prog(0.05, "Starting TWO-STAGE green screen processing...")
 
-            # Get video dimensions
             cap = cv2.VideoCapture(video_path)
             frame_width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
             frame_height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
             cap.release()
 
-            # Prepare background
             if background_choice == "custom" and custom_background_path:
                 if not os.path.exists(custom_background_path):
+                    logger.error(f"Custom background not found: {custom_background_path}")
                     return None, f"Custom background not found: {custom_background_path}"
 
                 background = cv2.imread(custom_background_path)
                 if background is None:
+                    logger.error("Could not read custom background image")
                     return None, "Could not read custom background image."
                 background_name = "Custom Image"
             else:
@@ -497,12 +506,11 @@ def _prog(pct: float, desc: str):
                     background = create_professional_background(bg_config, frame_width, frame_height)
                     background_name = bg_config["name"]
                 else:
+                    logger.error(f"Invalid background selection: {background_choice}")
                     return None, f"Invalid background selection: {background_choice}"
 
-            # Get chroma settings
             chroma_settings = CHROMA_PRESETS.get(chroma_preset, CHROMA_PRESETS['standard'])
 
-            # Run two-stage pipeline
             timestamp = int(time.time())
             final_output = f"/tmp/twostage_final_{timestamp}.mp4"
 
@@ -515,42 +523,39 @@ def _prog(pct: float, desc: str):
             )
 
             if PROCESS_CANCELLED.is_set():
+                logger.info("Processing cancelled by user")
                 return None, "Processing cancelled by user"
 
             if result is None:
+                logger.error(f"Two-stage processing failed: {message}")
                 return None, message
 
-            # Add audio back - FIXED VERSION
             _prog(0.9, "Adding audio...")
             final_with_audio = f"/tmp/twostage_audio_{timestamp}.mp4"
 
-            # First, check if input video has audio
             audio_check_success = run_ffmpeg_command([
                 'ffprobe', '-v', 'quiet', '-select_streams', 'a:0', 
                 '-show_entries', 'stream=codec_name', '-of', 'csv=p=0', video_path
             ], "Checking for audio stream")
 
             if audio_check_success:
-                # Input has audio - copy it with video
                 audio_success = run_ffmpeg_command([
                     'ffmpeg', '-y', '-i', final_output, '-i', video_path,
-                    '-c:v', 'copy',  # Copy video without re-encoding (faster)
+                    '-c:v', 'copy',
                     '-c:a', 'aac', '-b:a', '192k', '-ac', '2', '-ar', '48000',
-                    '-map', '0:v:0', '-map', '1:a:0', '-shortest', final_with_audio  # Removed the '?'
+                    '-map', '0:v:0', '-map', '1:a:0', '-shortest', final_with_audio
                 ], "Two-stage audio processing with original audio")
                 
                 if not audio_success or not os.path.exists(final_with_audio):
                     logger.warning("Failed with original audio, trying fallback method...")
-                    # Fallback: try different mapping
                     audio_success = run_ffmpeg_command([
                         'ffmpeg', '-y', '-i', video_path, '-i', final_output,
                         '-c:v', 'libx264', '-crf', '18', '-preset', 'fast',
-                        '-c:a', 'copy',  # Copy audio without re-encoding
+                        '-c:a', 'copy',
                         '-map', '1:v:0', '-map', '0:a:0', '-shortest', final_with_audio
                     ], "Fallback two-stage audio processing")
             else:
                 logger.info("Input video has no audio stream")
-                # No audio in source - just use processed video
                 try:
                     shutil.copy2(final_output, final_with_audio)
                     audio_success = True
@@ -581,11 +586,11 @@ def _prog(pct: float, desc: str):
 
             return final_output, success_message
 
-        # Single-stage processing
         _prog(0.05, f"Starting SINGLE-STAGE processing on {DEVICE}...")
 
         cap = cv2.VideoCapture(video_path)
         if not cap.isOpened():
+            logger.error("Could not open video file")
             return None, "Could not open video file."
 
         fps = cap.get(cv2.CAP_PROP_FPS)
@@ -595,23 +600,24 @@ def _prog(pct: float, desc: str):
 
         if total_frames == 0:
             cap.release()
+            logger.error("Video appears to be empty")
             return None, "Video appears to be empty."
 
-        # Log video info
         logger.info(f"Video info: {frame_width}x{frame_height}, {fps}fps, {total_frames} frames, processing on {DEVICE}")
 
-        # Prepare background
         background = None
         background_name = ""
 
         if background_choice == "custom" and custom_background_path:
             if not os.path.exists(custom_background_path):
                 cap.release()
+                logger.error(f"Custom background not found: {custom_background_path}")
                 return None, f"Custom background not found: {custom_background_path}"
 
             background = cv2.imread(custom_background_path)
             if background is None:
                 cap.release()
+                logger.error("Could not read custom background image")
                 return None, "Could not read custom background image."
             background_name = "Custom Image"
         else:
@@ -621,36 +627,35 @@ def _prog(pct: float, desc: str):
                 background_name = bg_config["name"]
             else:
                 cap.release()
+                logger.error(f"Invalid background selection: {background_choice}")
                 return None, f"Invalid background selection: {background_choice}"
 
         if background is None:
             cap.release()
+            logger.error("Failed to create background")
             return None, "Failed to create background."
 
         timestamp = int(time.time())
 
         _prog(0.1, f"Processing {total_frames} frames with {'TWO-STAGE' if use_two_stage else 'SINGLE-STAGE'} processing on {DEVICE}...")
 
-        # FIXED: Ensure output_path is always defined
         if preview_mask or preview_greenscreen:
             output_path = f"/tmp/preview_{timestamp}.mp4"
         else:
             output_path = f"/tmp/output_{timestamp}.mp4"
 
-        # ROBUST: Create video writer with codec fallback
         final_writer, actual_output_path = create_video_writer(output_path, fps, frame_width, frame_height)
         if final_writer is None:
             cap.release()
+            logger.error("Could not create output video file with any codec")
             return None, "Could not create output video file with any codec."
 
-        # Update output_path to actual path (may have different extension)
         output_path = actual_output_path
 
         frame_count = 0
         successful_frames = 0
         last_refined_mask = None
 
-        # Processing stats
         start_time = time.time()
 
         try:
@@ -662,13 +667,11 @@ def _prog(pct: float, desc: str):
                 if not ret:
                     break
 
-                # Skip frames if FRAME_SKIP > 1
                 if frame_count % FRAME_SKIP != 0:
                     frame_count += 1
                     continue
 
                 try:
-                    # Update progress with detailed timing info and ETA
                     elapsed_time = time.time() - start_time
                     current_fps = frame_count / elapsed_time if elapsed_time > 0 else 0
                     remaining_frames = total_frames - frame_count
@@ -677,37 +680,30 @@ def _prog(pct: float, desc: str):
 
                     progress_msg = f"Frame {frame_count + 1}/{total_frames} | {elapsed_time:.1f}s | {current_fps:.1f} fps | ETA: {eta_display} | Device: {DEVICE}"
 
-                    # Log and display progress with clamped percentage
                     logger.info(progress_msg)
                     pct = min(1.0, 0.1 + (frame_count / max(1, total_frames)) * 0.8)
                     _prog(pct, progress_msg)
 
-                    # CRITICAL: Use functions from utilities.py, not local implementations!
-                    # SAM2 segmentation using utilities function
                     mask = segment_person_hq(frame, sam2_predictor)
 
                     if preview_mask:
-                        # Save mask visualization - proper green color in BGR format
                         mask_vis = np.zeros_like(frame)
-                        mask_vis[..., 1] = mask  # Put mask in green channel (BGR format)
+                        mask_vis[..., 1] = mask
                         final_writer.write(mask_vis.astype(np.uint8))
                         frame_count += 1
                         continue
 
-                    # MatAnyone refinement on keyframes using utilities function
                     if (frame_count % KEYFRAME_INTERVAL == 0) or (last_refined_mask is None):
                         refined_mask = refine_mask_hq(frame, mask, matanyone_model)
                         last_refined_mask = refined_mask.copy()
                         logger.info(f"Keyframe refinement at frame {frame_count} on {DEVICE}")
                     else:
-                        # Blend SAM2 mask with last refined mask for temporal smoothness
                         alpha = 0.7
                         refined_mask = cv2.addWeighted(mask, alpha, last_refined_mask, 1-alpha, 0)
 
                     if preview_greenscreen:
-                        # Create green screen preview
                         green_bg = np.zeros_like(frame)
-                        green_bg[:, :] = [0, 255, 0]  # Pure green
+                        green_bg[:, :] = [0, 255, 0]
                         preview_frame = frame.copy()
                         mask_3ch = cv2.cvtColor(refined_mask, cv2.COLOR_GRAY2BGR)
                         mask_norm = mask_3ch.astype(float) / 255
@@ -716,22 +712,19 @@ def _prog(pct: float, desc: str):
                         frame_count += 1
                         continue
 
-                    # CRITICAL: Use replace_background_hq from utilities which has the transparency fix!
                     result_frame = replace_background_hq(frame, refined_mask, background)
                     final_writer.write(result_frame.astype(np.uint8))
                     successful_frames += 1
 
                 except Exception as frame_error:
                     logger.warning(f"Error processing frame {frame_count}: {frame_error}")
-                    # Write original frame if processing fails
                     final_writer.write(frame)
 
                 frame_count += 1
 
-                # Memory management
                 if frame_count % MEMORY_CLEANUP_INTERVAL == 0:
                     gc.collect()
-                    if DEVICE.type == 'cuda':  # Use consistent device checking
+                    if DEVICE.type == 'cuda':
                         torch.cuda.empty_cache()
                     elapsed = time.time() - start_time
                     fps_actual = frame_count / elapsed
@@ -739,7 +732,6 @@ def _prog(pct: float, desc: str):
                     logger.info(f"Progress: {frame_count}/{total_frames}, FPS: {fps_actual:.1f}, ETA: {eta:.0f}s, Device: {DEVICE}")
 
         finally:
-            # ALWAYS cleanup resources
             cap.release()
             final_writer.release()
 
@@ -750,12 +742,13 @@ def _prog(pct: float, desc: str):
                     os.remove(output_path)
             except:
                 pass
+            logger.info("Processing cancelled by user")
             return None, "Processing cancelled by user"
 
         if successful_frames == 0:
+            logger.error("No frames were processed successfully with AI")
             return None, "No frames were processed successfully with AI."
 
-        # Calculate processing stats
         total_time = time.time() - start_time
         avg_fps = frame_count / total_time if total_time > 0 else 0
 
@@ -764,37 +757,32 @@ def _prog(pct: float, desc: str):
         if preview_mask or preview_greenscreen:
             final_output = output_path
         else:
-            # Add audio back for final output - FIXED VERSION
             _prog(0.9, "Adding audio...")
             final_output = f"/tmp/final_{timestamp}.mp4"
 
-            # First, check if input video has audio
             audio_check_success = run_ffmpeg_command([
                 'ffprobe', '-v', 'quiet', '-select_streams', 'a:0', 
                 '-show_entries', 'stream=codec_name', '-of', 'csv=p=0', video_path
             ], "Checking for audio stream")
 
             if audio_check_success:
-                # Input has audio - copy it with video
                 audio_success = run_ffmpeg_command([
                     'ffmpeg', '-y', '-i', output_path, '-i', video_path,
-                    '-c:v', 'copy',  # Copy video without re-encoding (faster)
+                    '-c:v', 'copy',
                     '-c:a', 'aac', '-b:a', '192k', '-ac', '2', '-ar', '48000',
-                    '-map', '0:v:0', '-map', '1:a:0', '-shortest', final_output  # Removed the '?' 
+                    '-map', '0:v:0', '-map', '1:a:0', '-shortest', final_output
                 ], "Audio processing with original audio")
                 
                 if not audio_success or not os.path.exists(final_output):
                     logger.warning("Failed with original audio, trying fallback method...")
-                    # Fallback: try different mapping
                     audio_success = run_ffmpeg_command([
                         'ffmpeg', '-y', '-i', video_path, '-i', output_path,
                         '-c:v', 'libx264', '-crf', '18', '-preset', 'fast',
-                        '-c:a', 'copy',  # Copy audio without re-encoding
+                        '-c:a', 'copy',
                         '-map', '1:v:0', '-map', '0:a:0', '-shortest', final_output
                     ], "Fallback audio processing")
             else:
                 logger.info("Input video has no audio stream")
-                # No audio in source - just use processed video
                 try:
                     shutil.copy2(output_path, final_output)
                     audio_success = True
@@ -811,7 +799,6 @@ def _prog(pct: float, desc: str):
                     logger.error(f"Failed to copy video: {e}")
                     final_output = output_path
 
-            # Cleanup intermediate file
             try:
                 if os.path.exists(output_path) and output_path != final_output:
                     os.remove(output_path)
@@ -851,28 +838,46 @@ def main():
         print(f"Device: {DEVICE}")
         print("Loading UI components...")
 
-        # Import UI components
-        from ui_components import create_interface
+        try:
+            from ui_components import create_interface
+            logger.info("Successfully imported ui_components")
+        except ImportError as e:
+            logger.error(f"Failed to import ui_components: {e}")
+            logger.error(f"Full traceback: {traceback.format_exc()}")
+            raise Exception(f"UI components import failed: {e}")
 
         os.makedirs("/tmp/MyAvatar/My_Videos/", exist_ok=True)
         CACHE_DIR.mkdir(exist_ok=True, parents=True)
 
         print("Creating interface...")
-        demo = create_interface()
+        try:
+            demo = create_interface()
+            logger.info("Gradio interface created successfully")
+        except Exception as e:
+            logger.error(f"Failed to create Gradio interface: {e}")
+            logger.error(f"Full traceback: {traceback.format_exc()}")
+            raise Exception(f"Gradio interface creation failed: {e}")
 
         print("Launching...")
-        # Fixed for HF Spaces - share=True is required when localhost not accessible
-        demo.queue().launch(
-            server_name="0.0.0.0",
-            server_port=7860,
-            share=True,  # Required for HF Spaces
-            show_error=True,
-            debug=True
-        )
+        try:
+            demo.queue().launch(
+                server_name="0.0.0.0",
+                server_port=7860,
+                share=True,
+                show_error=True,
+                debug=True
+            )
+            logger.info("Gradio server launched successfully")
+        except Exception as e:
+            logger.error(f"Gradio launch failed: {e}")
+            logger.error(f"Full traceback: {traceback.format_exc()}")
+            raise Exception(f"Gradio launch failed: {e}")
 
     except Exception as e:
         logger.error(f"Startup failed: {e}")
+        logger.error(f"Full traceback: {traceback.format_exc()}")
         print(f"Startup failed: {e}")
+        raise
 
 if __name__ == "__main__":
     main()