Update core/app.py

core/app.py

@@ -4,27 +4,27 @@
 Refactored modular architecture - orchestrates specialized components
 """
 
-import early_env  # <<< centralizes the OMP/torch thread fix; must be first
+# 0) Early env/threading hygiene (must be first)
+import early_env  # sets OMP/MKL/OPENBLAS + torch threads safely
 
-import os
 import logging
 import threading
 from pathlib import Path
 from typing import Optional, Tuple, Dict, Any, Callable
 
-# Configure logging first
+# 1) Logging
 logging.basicConfig(
     level=logging.INFO,
-    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+    format="%(asctime)s - %(name)s - %(levelname)s - %(message)s"
 )
-logger = logging.getLogger(__name__)
+logger = logging.getLogger("core.app")
 
-# Apply Gradio schema patch early (before other imports)
+# 2) Patch Gradio schema early (HF Spaces quirk)
 try:
     import gradio_client.utils as gc_utils
-    original_get_type = gc_utils.get_type
+    _orig_get_type = gc_utils.get_type
 
-    def patched_get_type(schema):
+    def _patched_get_type(schema):
         if not isinstance(schema, dict):
             if isinstance(schema, bool):
                 return "boolean"
@@ -33,18 +33,15 @@ def patched_get_type(schema):
             if isinstance(schema, (int, float)):
                 return "number"
             return "string"
-        return original_get_type(schema)
+        return _orig_get_type(schema)
 
-    gc_utils.get_type = patched_get_type
-    logger.info("Gradio schema patch applied successfully")
+    gc_utils.get_type = _patched_get_type
+    logger.info("Gradio schema patch applied")
 except Exception as e:
-    logger.error(f"Gradio patch failed: {e}")
+    logger.warning(f"Gradio patch failed: {e}")
 
-# Import configuration from new location
-from processing.video.video_processor import ProcessorConfig
+# 3) Core config + components
 from config.app_config import get_config
-
-# Import core components from new locations
 from core.exceptions import ModelLoadingError, VideoProcessingError
 from utils.hardware.device_manager import DeviceManager
 from utils.system.memory_manager import MemoryManager
@@ -53,179 +50,133 @@ def patched_get_type(schema):
 from processing.audio.audio_processor import AudioProcessor
 from utils.monitoring.progress_tracker import ProgressTracker
 
-# Import existing utilities (temporary during migration)
-from utilities import (
-    segment_person_hq,
-    refine_mask_hq,
-    replace_background_hq,
-    create_professional_background,
-    PROFESSIONAL_BACKGROUNDS,
-    validate_video_file
-)
-
-# Import two-stage processor if available
+# Optional two-stage processor
 try:
     from processing.two_stage.two_stage_processor import TwoStageProcessor, CHROMA_PRESETS
     TWO_STAGE_AVAILABLE = True
-except ImportError:
+except Exception:
     TWO_STAGE_AVAILABLE = False
-    CHROMA_PRESETS = {'standard': {}}
+    CHROMA_PRESETS = {"standard": {}}
+
+# Validation helper for inputs (lives with CV utils)
+from utils.cv_processing import validate_video_file
 
 
 class VideoProcessor:
     """
-    Main video processing orchestrator - coordinates all specialized components
+    Main video processing orchestrator - coordinates all specialized components.
     """
-
     def __init__(self):
-        """Initialize the video processor with all required components"""
-        self.config = get_config()  # Use singleton config
+        self.config = get_config()  # singleton-style app config
         self.device_manager = DeviceManager()
+
+        # Memory manager now requires a device object/string
         self.memory_manager = MemoryManager(self.device_manager.get_optimal_device())
 
-        # Initialize ModelLoader with DeviceManager and MemoryManager (as per actual implementation)
+        # Model loader takes device + memory managers
         self.model_loader = ModelLoader(self.device_manager, self.memory_manager)
 
         self.audio_processor = AudioProcessor()
-        self.progress_tracker = None
+        self.core_processor: CoreVideoProcessor | None = None
+        self.two_stage_processor: TwoStageProcessor | None = None
 
-        # Initialize core processor (will be set up after models load)
-        self.core_processor = None
-        self.two_stage_processor = None
-
-        # State management
+        # State
         self.models_loaded = False
         self.loading_lock = threading.Lock()
         self.cancel_event = threading.Event()
+        self.progress_tracker: ProgressTracker | None = None
 
-        logger.info(f"VideoProcessor initialized on device: {self.device_manager.get_optimal_device()}")
+        logger.info(f"VideoProcessor on device: {self.device_manager.get_optimal_device()}")
 
-    def _initialize_progress_tracker(self, video_path: str, progress_callback: Optional[Callable] = None):
-        """Initialize progress tracker with video frame count"""
+    # ---------- Progress ----------
+    def _init_progress(self, video_path: str, cb: Optional[Callable] = None):
         try:
             import cv2
             cap = cv2.VideoCapture(video_path)
-            total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
+            total = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
             cap.release()
-
-            if total_frames <= 0:
-                total_frames = 100  # Fallback estimate
-
-            self.progress_tracker = ProgressTracker(total_frames, progress_callback)
-            logger.info(f"Progress tracker initialized for {total_frames} frames")
+            if total <= 0:
+                total = 100
+            self.progress_tracker = ProgressTracker(total, cb)
         except Exception as e:
-            logger.warning(f"Could not initialize progress tracker: {e}")
-            # Fallback to basic tracker
-            self.progress_tracker = ProgressTracker(100, progress_callback)
+            logger.warning(f"Progress init failed: {e}")
+            self.progress_tracker = ProgressTracker(100, cb)
 
+    # ---------- Load Models ----------
     def load_models(self, progress_callback: Optional[Callable] = None) -> str:
-        """Load and validate all AI models"""
         with self.loading_lock:
             if self.models_loaded:
                 return "Models already loaded and validated"
 
             try:
                 self.cancel_event.clear()
-
                 if progress_callback:
-                    progress_callback(0.0, f"Starting model loading on {self.device_manager.get_optimal_device()}")
+                    progress_callback(0.0, f"Loading on {self.device_manager.get_optimal_device()}")
 
-                # Add detailed debugging for the IndexError
                 try:
-                    # Load models using load_all_models which returns tuple of (LoadedModel, LoadedModel)
-                    sam2_result, matanyone_result = self.model_loader.load_all_models(
+                    sam2_loaded, mat_loaded = self.model_loader.load_all_models(
                         progress_callback=progress_callback,
                         cancel_event=self.cancel_event
                     )
-
                 except IndexError as e:
                     import traceback
-                    logger.error(f"IndexError in load_all_models: {e}")
-                    logger.error(f"Full traceback:\n{traceback.format_exc()}")
-
-                    # Get more context about where exactly the error happened
                     tb = traceback.extract_tb(e.__traceback__)
-                    for frame in tb:
-                        logger.error(f"  File: {frame.filename}, Line: {frame.lineno}, Function: {frame.name}")
-                        logger.error(f"    Code: {frame.line}")
-
-                    # Re-raise with more context
-                    raise ModelLoadingError(f"Model loading failed with IndexError at line {tb[-1].lineno}: {e}")
-
+                    where = f"{tb[-1].filename}:{tb[-1].lineno}" if tb else "unknown"
+                    logger.error(f"IndexError in load_all_models at {where}: {e}")
+                    raise ModelLoadingError(f"Model loading failed (IndexError @ {where}): {e}")
                 except Exception as e:
                     import traceback
-                    logger.error(f"Unexpected error in load_all_models: {e}")
-                    logger.error(f"Error type: {type(e).__name__}")
-                    logger.error(f"Full traceback:\n{traceback.format_exc()}")
+                    logger.error(f"Unexpected error in load_all_models: {e}\n{traceback.format_exc()}")
                     raise
 
                 if self.cancel_event.is_set():
                     return "Model loading cancelled"
 
-                # Extract actual models from LoadedModel wrappers for two-stage processor
-                sam2_predictor = sam2_result.model if sam2_result else None
-                matanyone_model = matanyone_result.model if matanyone_result else None
-
-                # Check if at least one model loaded successfully
-                success = sam2_predictor is not None or matanyone_model is not None
-
-                if not success:
-                    return "Model loading failed - check logs for details"
+                # Unwrap actual model refs for two-stage
+                sam2_predictor = sam2_loaded.model if sam2_loaded else None
+                mat_model = mat_loaded.model if mat_loaded else None
+                if (sam2_predictor is None) and (mat_model is None):
+                    return "Model loading failed - see logs"
 
-                # Initialize core processor with the model loader (it expects a models object)
+                # Core processor expects a "models" provider (we pass the loader itself)
                 self.core_processor = CoreVideoProcessor(
                     config=self.config,
-                    models=self.model_loader  # Pass the whole model_loader object
+                    models=self.model_loader
                 )
 
-                # Initialize two-stage processor if available and models loaded
-                if TWO_STAGE_AVAILABLE:
-                    if sam2_predictor is not None or matanyone_model is not None:
-                        try:
-                            # Two-stage processor needs the actual models
-                            self.two_stage_processor = TwoStageProcessor(
-                                sam2_predictor=sam2_predictor,
-                                matanyone_model=matanyone_model
-                            )
-                            logger.info("✅ Two-stage processor initialized with AI models")
-                        except Exception as e:
-                            logger.warning(f"Two-stage processor init failed: {e}")
-                            self.two_stage_processor = None
-                    else:
-                        logger.warning("Two-stage processor not initialized - models not available")
-                        if sam2_predictor is None:
-                            logger.warning("  - SAM2 predictor is None")
-                        if matanyone_model is None:
-                            logger.warning("  - MatAnyone model is None")
+                # Optional 2-stage
+                if TWO_STAGE_AVAILABLE and (sam2_predictor or mat_model):
+                    try:
+                        self.two_stage_processor = TwoStageProcessor(
+                            sam2_predictor=sam2_predictor,
+                            matanyone_model=mat_model
+                        )
+                        logger.info("Two-stage processor initialized")
+                    except Exception as e:
+                        logger.warning(f"Two-stage init failed: {e}")
+                        self.two_stage_processor = None
 
                 self.models_loaded = True
-                message = self.model_loader.get_load_summary()
-
-                # Add two-stage status to message
-                if self.two_stage_processor is not None:
-                    message += "\n✅ Two-stage processor ready with AI models"
+                msg = self.model_loader.get_load_summary()
+                if self.two_stage_processor:
+                    msg += "\n✅ Two-stage processor ready"
                 else:
-                    message += "\n⚠️ Two-stage processor not available"
-
-                logger.info(message)
-                return message
+                    msg += "\n⚠️ Two-stage processor not available"
+                logger.info(msg)
+                return msg
 
-            except AttributeError as e:
-                self.models_loaded = False
-                error_msg = f"Model loading failed - method not found: {str(e)}"
-                logger.error(error_msg)
-                return error_msg
-            except ModelLoadingError as e:
+            except (AttributeError, ModelLoadingError) as e:
                 self.models_loaded = False
-                error_msg = f"Model loading failed: {str(e)}"
-                logger.error(error_msg)
-                return error_msg
+                err = f"Model loading failed: {e}"
+                logger.error(err)
+                return err
             except Exception as e:
                 self.models_loaded = False
-                error_msg = f"Unexpected error during model loading: {str(e)}"
-                logger.error(error_msg)
-                return error_msg
+                err = f"Unexpected error during model loading: {e}"
+                logger.error(err)
+                return err
 
+    # ---------- Process ----------
     def process_video(
         self,
         video_path: str,
@@ -235,51 +186,37 @@ def process_video(
         use_two_stage: bool = False,
         chroma_preset: str = "standard",
         preview_mask: bool = False,
-        preview_greenscreen: bool = False
+        preview_greenscreen: bool = False,
     ) -> Tuple[Optional[str], str]:
-        """Process video with the specified parameters"""
 
         if not self.models_loaded or not self.core_processor:
-            return None, "Models not loaded. Please load models first."
+            return None, "Models not loaded. Please click “Load Models” first."
 
         if self.cancel_event.is_set():
             return None, "Processing cancelled"
 
-        # Initialize progress tracker with video frame count
-        self._initialize_progress_tracker(video_path, progress_callback)
+        self._init_progress(video_path, progress_callback)
 
-        # Validate input file
-        is_valid, validation_msg = validate_video_file(video_path)
-        if not is_valid:
-            return None, f"Invalid video: {validation_msg}"
+        ok, why = validate_video_file(video_path)
+        if not ok:
+            return None, f"Invalid video: {why}"
 
         try:
-            # Route to appropriate processing method
             if use_two_stage:
                 if not TWO_STAGE_AVAILABLE:
-                    return None, "Two-stage processing not available - module not found"
-
-                if self.two_stage_processor is None:
-                    return None, "Two-stage processor not initialized - models may not be loaded properly"
-
-                logger.info("Using two-stage processing pipeline with AI models")
-                return self._process_two_stage(
-                    video_path, background_choice, custom_background_path,
-                    progress_callback, chroma_preset
-                )
+                    return None, "Two-stage processing not available on this build"
+                if not self.two_stage_processor:
+                    return None, "Two-stage processor not initialized (models not ready?)"
+                return self._process_two_stage(video_path, background_choice, custom_background_path, progress_callback, chroma_preset)
             else:
-                logger.info("Using single-stage processing pipeline")
-                return self._process_single_stage(
-                    video_path, background_choice, custom_background_path,
-                    progress_callback, preview_mask, preview_greenscreen
-                )
+                return self._process_single_stage(video_path, background_choice, custom_background_path, progress_callback, preview_mask, preview_greenscreen)
 
         except VideoProcessingError as e:
-            logger.error(f"Video processing failed: {e}")
-            return None, f"Processing failed: {str(e)}"
+            logger.error(f"Processing failed: {e}")
+            return None, f"Processing failed: {e}"
         except Exception as e:
-            logger.error(f"Unexpected error during video processing: {e}")
-            return None, f"Unexpected error: {str(e)}"
+            logger.error(f"Unexpected processing error: {e}")
+            return None, f"Unexpected error: {e}"
 
     def _process_single_stage(
         self,
@@ -288,45 +225,36 @@ def _process_single_stage(
         custom_background_path: Optional[str],
         progress_callback: Optional[Callable],
         preview_mask: bool,
-        preview_greenscreen: bool
+        preview_greenscreen: bool,
     ) -> Tuple[Optional[str], str]:
-        """Process video using single-stage pipeline"""
 
-        # Generate output path
         import time
-        timestamp = int(time.time())
-        output_dir = Path(self.config.output_dir) / "single_stage"
-        output_dir.mkdir(parents=True, exist_ok=True)
-        output_path = str(output_dir / f"processed_{timestamp}.mp4")
+        ts = int(time.time())
+        out_dir = Path(self.config.output_dir) / "single_stage"
+        out_dir.mkdir(parents=True, exist_ok=True)
+        out_path = str(out_dir / f"processed_{ts}.mp4")
 
-        # Process video using core processor
         result = self.core_processor.process_video(
             input_path=video_path,
-            output_path=output_path,
-            bg_config={'background_choice': background_choice, 'custom_path': custom_background_path}
+            output_path=out_path,
+            bg_config={"background_choice": background_choice, "custom_path": custom_background_path}
         )
-
         if not result:
             return None, "Video processing failed"
 
-        # Add audio if not in preview mode
         if not (preview_mask or preview_greenscreen):
-            final_video_path = self.audio_processor.add_audio_to_video(
-                original_video=video_path,
-                processed_video=output_path
-            )
+            final_path = self.audio_processor.add_audio_to_video(original_video=video_path, processed_video=out_path)
         else:
-            final_video_path = output_path
+            final_path = out_path
 
-        success_msg = (
-            f"Processing completed successfully!\n"
-            f"Frames processed: {result.get('frames', 'unknown')}\n"
+        msg = (
+            "Processing completed.\n"
+            f"Frames: {result.get('frames', 'unknown')}\n"
             f"Background: {background_choice}\n"
             f"Mode: Single-stage\n"
             f"Device: {self.device_manager.get_optimal_device()}"
         )
-
-        return final_video_path, success_msg
+        return final_path, msg
 
     def _process_two_stage(
         self,
@@ -334,117 +262,82 @@ def _process_two_stage(
         background_choice: str,
         custom_background_path: Optional[str],
         progress_callback: Optional[Callable],
-        chroma_preset: str
+        chroma_preset: str,
     ) -> Tuple[Optional[str], str]:
-        """Process video using two-stage pipeline"""
-
         if self.two_stage_processor is None:
             return None, "Two-stage processor not available"
 
-        # Get video dimensions for background preparation
-        import cv2
+        import cv2, time
         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))
+        w = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
+        h = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
         cap.release()
 
-        # Prepare background using core processor
-        background = self.core_processor.prepare_background(
-            background_choice, custom_background_path, frame_width, frame_height
-        )
+        background = self.core_processor.prepare_background(background_choice, custom_background_path, w, h)
         if background is None:
             return None, "Failed to prepare background"
 
-        # Process with two-stage pipeline
-        import time
-        timestamp = int(time.time())
-        output_dir = Path(self.config.output_dir) / "two_stage"
-        output_dir.mkdir(parents=True, exist_ok=True)
-        final_output = str(output_dir / f"final_{timestamp}.mp4")
+        ts = int(time.time())
+        out_dir = Path(self.config.output_dir) / "two_stage"
+        out_dir.mkdir(parents=True, exist_ok=True)
+        final_out = str(out_dir / f"final_{ts}.mp4")
 
-        chroma_settings = CHROMA_PRESETS.get(chroma_preset, CHROMA_PRESETS['standard'])
+        chroma = CHROMA_PRESETS.get(chroma_preset, CHROMA_PRESETS["standard"])
+        logger.info(f"Two-stage with preset: {chroma_preset}")
 
-        logger.info(f"Starting two-stage processing with chroma preset: {chroma_preset}")
         result, message = self.two_stage_processor.process_full_pipeline(
-            video_path,
-            background,
-            final_output,
-            chroma_settings=chroma_settings,
-            progress_callback=progress_callback
+            video_path, background, final_out, chroma_settings=chroma, progress_callback=progress_callback
         )
-
         if result is None:
             return None, message
 
-        success_msg = (
-            f"Two-stage processing completed!\n"
+        msg = (
+            "Two-stage processing completed.\n"
             f"Background: {background_choice}\n"
             f"Chroma Preset: {chroma_preset}\n"
-            f"Quality: Cinema-grade with AI models\n"
             f"Device: {self.device_manager.get_optimal_device()}"
         )
+        return result, msg
 
-        return result, success_msg
-
+    # ---------- Status / Control ----------
     def get_status(self) -> Dict[str, Any]:
-        """Get comprehensive status of all components"""
-        base_status = {
-            'models_loaded': self.models_loaded,
-            'two_stage_available': TWO_STAGE_AVAILABLE and self.two_stage_processor is not None,
-            'device': str(self.device_manager.get_optimal_device()),
-            'memory_usage': self.memory_manager.get_memory_usage(),
-            'config': self.config.to_dict()
+        status = {
+            "models_loaded": self.models_loaded,
+            "two_stage_available": TWO_STAGE_AVAILABLE and (self.two_stage_processor is not None),
+            "device": str(self.device_manager.get_optimal_device()),
+            "memory_usage": self.memory_manager.get_memory_usage(),
+            "config": self.config.to_dict(),
+            "core_processor_loaded": self.core_processor is not None,
         }
+        try:
+            status["sam2_loaded"] = self.model_loader.get_sam2() is not None
+            status["matanyone_loaded"] = self.model_loader.get_matanyone() is not None
+        except Exception:
+            status["sam2_loaded"] = False
+            status["matanyone_loaded"] = False
 
-        # Add model-specific status if available
-        if self.model_loader:
-            base_status['model_loader_available'] = True
-            try:
-                base_status['sam2_loaded'] = self.model_loader.get_sam2() is not None
-                base_status['matanyone_loaded'] = self.model_loader.get_matanyone() is not None
-            except AttributeError:
-                base_status['sam2_loaded'] = False
-                base_status['matanyone_loaded'] = False
-
-        # Add processing status if available
-        if self.core_processor:
-            base_status['core_processor_loaded'] = True
-
-        # Add two-stage processor status
-        if self.two_stage_processor:
-            base_status['two_stage_processor_ready'] = True
-        else:
-            base_status['two_stage_processor_ready'] = False
-
-        # Add progress tracking if available
         if self.progress_tracker:
-            base_status['progress'] = self.progress_tracker.get_all_progress()
-
-        return base_status
+            status["progress"] = self.progress_tracker.get_all_progress()
+        return status
 
     def cancel_processing(self):
-        """Cancel any ongoing processing"""
         self.cancel_event.set()
-        logger.info("Processing cancellation requested")
+        logger.info("Cancellation requested")
 
     def cleanup_resources(self):
-        """Clean up all resources"""
         self.memory_manager.cleanup_aggressive()
         if self.model_loader:
             self.model_loader.cleanup()
         logger.info("Resources cleaned up")
 
 
-# Global processor instance for application
+# Singleton for UI callbacks
 processor = VideoProcessor()
 
-
-# Backward compatibility functions for existing UI
+# Back-compat wrappers used by ui/callbacks.py
 def load_models_with_validation(progress_callback: Optional[Callable] = None) -> str:
-    """Load models with validation - backward compatibility wrapper"""
     return processor.load_models(progress_callback)
 
-
 def process_video_fixed(
     video_path: str,
     background_choice: str,
@@ -453,55 +346,43 @@ def process_video_fixed(
     use_two_stage: bool = False,
     chroma_preset: str = "standard",
     preview_mask: bool = False,
-    preview_greenscreen: bool = False
+    preview_greenscreen: bool = False,
 ) -> Tuple[Optional[str], str]:
-    """Process video - backward compatibility wrapper"""
     return processor.process_video(
         video_path, background_choice, custom_background_path,
-        progress_callback, use_two_stage, chroma_preset,
-        preview_mask, preview_greenscreen
+        progress_callback, use_two_stage, chroma_preset, preview_mask, preview_greenscreen
     )
 
-
 def get_model_status() -> Dict[str, Any]:
-    """Get model status - backward compatibility wrapper"""
     return processor.get_status()
 
-
 def get_cache_status() -> Dict[str, Any]:
-    """Get cache status - backward compatibility wrapper"""
+    # For now same as status; can add cache metrics later
     return processor.get_status()
 
-
-# For backward compatibility
 PROCESS_CANCELLED = processor.cancel_event
 
 
 def main():
-    """Main application entry point"""
     try:
-        logger.info("Starting Video Background Replacement application")
+        logger.info("Starting BackgroundFX Pro")
         logger.info(f"Device: {processor.device_manager.get_optimal_device()}")
-        logger.info(f"Two-stage module available: {TWO_STAGE_AVAILABLE}")
-        logger.info("Modular architecture loaded successfully")
+        logger.info(f"Two-stage available: {TWO_STAGE_AVAILABLE}")
 
-        # Import and create UI
-        from ui_components import create_interface
+        # NOTE: UI was split into ui/components.py
+        from ui.components import create_interface
         demo = create_interface()
 
-        # Launch application (no share=True on Spaces)
         demo.queue().launch(
             server_name="0.0.0.0",
             server_port=7860,
             show_error=True,
             debug=False
         )
-
     except Exception as e:
-        logger.error(f"Application startup failed: {e}")
+        logger.error(f"Startup failed: {e}")
         raise
     finally:
-        # Cleanup on exit
         processor.cleanup_resources()