Update core/app.py

core/app.py

@@ -236,6 +236,66 @@ def process_video(
         preview_mask: bool = False,
         preview_greenscreen: bool = False,
     ) -> Tuple[Optional[str], Optional[str], str]:
+        
+        # ===== BACKGROUND PATH DEBUG & FIX =====
+        logger.info("=" * 60)
+        logger.info("BACKGROUND PATH DEBUGGING")
+        logger.info(f"background_choice: {background_choice}")
+        logger.info(f"custom_background_path type: {type(custom_background_path)}")
+        logger.info(f"custom_background_path value: {custom_background_path}")
+        
+        # Fix 1: Handle if Gradio sends a dict
+        if isinstance(custom_background_path, dict):
+            original = custom_background_path
+            custom_background_path = custom_background_path.get('name') or custom_background_path.get('path')
+            logger.info(f"Extracted path from dict: {original} -> {custom_background_path}")
+        
+        # Fix 2: Handle PIL Image objects
+        try:
+            from PIL import Image
+            if isinstance(custom_background_path, Image.Image):
+                import tempfile
+                with tempfile.NamedTemporaryFile(suffix='.png', delete=False) as tmp:
+                    custom_background_path.save(tmp.name)
+                    custom_background_path = tmp.name
+                    logger.info(f"Saved PIL Image to: {custom_background_path}")
+        except ImportError:
+            pass
+        
+        # Fix 3: Verify file exists when using custom background
+        if background_choice == "custom" or custom_background_path:
+            if custom_background_path:
+                if Path(custom_background_path).exists():
+                    logger.info(f"✅ Background file exists: {custom_background_path}")
+                else:
+                    logger.warning(f"⚠️ Background file does not exist: {custom_background_path}")
+                    # Try to find it in Gradio temp directories
+                    import glob
+                    patterns = [
+                        "/tmp/gradio*/**/*.jpg",
+                        "/tmp/gradio*/**/*.jpeg", 
+                        "/tmp/gradio*/**/*.png",
+                        "/tmp/**/*.jpg",
+                        "/tmp/**/*.jpeg",
+                        "/tmp/**/*.png",
+                    ]
+                    for pattern in patterns:
+                        files = glob.glob(pattern, recursive=True)
+                        if files:
+                            # Get the most recent file
+                            newest = max(files, key=os.path.getmtime)
+                            logger.info(f"Found potential background: {newest}")
+                            # Only use it if it was created in the last 5 minutes
+                            if (time.time() - os.path.getmtime(newest)) < 300:
+                                custom_background_path = newest
+                                logger.info(f"✅ Using recent temp file: {custom_background_path}")
+                                break
+            else:
+                logger.error("❌ Custom background mode but path is None!")
+        
+        logger.info(f"Final custom_background_path: {custom_background_path}")
+        logger.info("=" * 60)
+        
         if not self.models_loaded or not self.core_processor:
             return None, None, "Models not loaded. Please click 'Load Models' first."
         if self.cancel_event.is_set():
@@ -305,7 +365,11 @@ def _process_single_stage(
         preview_mask: bool,
         preview_greenscreen: bool,
     ) -> Tuple[Optional[str], Optional[str], str]:
-        import time
+        
+        # Additional debug logging for single-stage
+        logger.info(f"[Single-stage] background_choice: {background_choice}")
+        logger.info(f"[Single-stage] custom_background_path: {custom_background_path}")
+        
         ts = int(time.time())
         out_dir = Path(self.config.output_dir) / "single_stage"
         out_dir.mkdir(parents=True, exist_ok=True)
@@ -361,7 +425,12 @@ def _process_two_stage(
     ) -> Tuple[Optional[str], Optional[str], str]:
         if self.two_stage_processor is None:
             return None, None, "Two-stage processor not available"
-        import cv2, time
+        
+        # Additional debug logging for two-stage
+        logger.info(f"[Two-stage] background_choice: {background_choice}")
+        logger.info(f"[Two-stage] custom_background_path: {custom_background_path}")
+        
+        import cv2
         cap = cv2.VideoCapture(video_path)
         if not cap.isOpened():
             return None, None, "Could not open input video"
@@ -502,27 +571,72 @@ def main():
         logger.info("Starting BackgroundFX Pro")
         logger.info(f"Device: {processor.device_manager.get_optimal_device()}")
         logger.info(f"Two-stage available: {TWO_STAGE_AVAILABLE}")
+        
         # 🔹 Quiet model self-check (defaults to async; set SELF_CHECK_MODE=sync to block)
         if schedule_startup_selfcheck is not None:
             try:
                 schedule_startup_selfcheck(mode=os.getenv("SELF_CHECK_MODE", "async"))
             except Exception as e:
                 logger.error(f"Startup self-check skipped: {e}", exc_info=True)
+        
         # Log model loader type
         try:
             from models.loaders.model_loader import ModelLoader
             logger.info("Using split loader architecture")
         except Exception:
             logger.info("Using legacy loader")
-        from ui.ui_components import create_interface
-        demo = create_interface()
-        demo.queue().launch(
-            server_name="0.0.0.0",
-            server_port=7860,
-            show_error=True,
-            debug=False,
-        )
+        
+        # FIXED: Move UI import inside main() to avoid circular dependency
+        # and add better error handling
+        try:
+            # Import here to break circular dependency
+            from ui import ui_components
+            
+            # Now get the create_interface function
+            if hasattr(ui_components, 'create_interface'):
+                create_interface = ui_components.create_interface
+            else:
+                logger.error("create_interface not found in ui_components")
+                logger.error(f"Available attributes: {dir(ui_components)}")
+                raise ImportError("create_interface function not found")
+                
+        except ImportError as e:
+            logger.error(f"Failed to import UI components: {e}")
+            import traceback
+            traceback.print_exc()
+            
+            # Try alternate import method
+            try:
+                logger.info("Trying alternate import method...")
+                import importlib
+                ui_components = importlib.import_module('ui.ui_components')
+                create_interface = getattr(ui_components, 'create_interface')
+                logger.info("Alternate import successful")
+            except Exception as e2:
+                logger.error(f"Alternate import also failed: {e2}")
+                logger.info("System initialized but UI unavailable. Exiting.")
+                return
+        
+        # Create and launch the interface
+        try:
+            demo = create_interface()
+            demo.queue().launch(
+                server_name="0.0.0.0",
+                server_port=7860,
+                show_error=True,
+                debug=False,
+            )
+        except Exception as e:
+            logger.error(f"Failed to launch Gradio interface: {e}")
+            import traceback
+            traceback.print_exc()
+            
+    except Exception as e:
+        logger.error(f"Fatal error in main: {e}")
+        import traceback
+        traceback.print_exc()
     finally:
         processor.cleanup_resources()
+
 if __name__ == "__main__":
     main()