Update core/app.py

core/app.py

@@ -4,7 +4,36 @@
 Refactored modular architecture - orchestrates specialized components
 """
 
+# 0️⃣ Early threading/OMP sanitization (prevents libgomp + interop warnings)
 import os
+def _clean_int_env(name: str, default: str | None = None):
+    val = os.environ.get(name)
+    if val is None:
+        if default is not None:
+            os.environ[name] = str(default)
+        return
+    try:
+        int(str(val).strip())
+    except ValueError:
+        if default is None:
+            os.environ.pop(name, None)
+        else:
+            os.environ[name] = str(default)
+
+_clean_int_env("OMP_NUM_THREADS", "2")
+_clean_int_env("MKL_NUM_THREADS", "2")
+_clean_int_env("OPENBLAS_NUM_THREADS", "2")
+_clean_int_env("NUMEXPR_NUM_THREADS", "2")
+
+try:
+    import torch  # call thread setters BEFORE heavy parallel work starts
+    if hasattr(torch, "set_num_interop_threads"):
+        torch.set_num_interop_threads(2)
+    if hasattr(torch, "set_num_threads"):
+        torch.set_num_threads(2)
+except Exception:
+    pass
+
 import logging
 import threading
 from pathlib import Path
@@ -21,7 +50,7 @@
 try:
     import gradio_client.utils as gc_utils
     original_get_type = gc_utils.get_type
-    
+
     def patched_get_type(schema):
         if not isinstance(schema, dict):
             if isinstance(schema, bool):
@@ -32,7 +61,7 @@ def patched_get_type(schema):
                 return "number"
             return "string"
         return original_get_type(schema)
-    
+
     gc_utils.get_type = patched_get_type
     logger.info("Gradio schema patch applied successfully")
 except Exception as e:
@@ -74,30 +103,30 @@ class VideoProcessor:
     """
     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.device_manager = DeviceManager()
         self.memory_manager = MemoryManager(self.device_manager.get_optimal_device())
-        
+
         # Initialize ModelLoader with DeviceManager and MemoryManager (as per actual implementation)
         self.model_loader = ModelLoader(self.device_manager, self.memory_manager)
-        
+
         self.audio_processor = AudioProcessor()
         self.progress_tracker = None
-        
+
         # Initialize core processor (will be set up after models load)
         self.core_processor = None
         self.two_stage_processor = None
-        
+
         # State management
         self.models_loaded = False
         self.loading_lock = threading.Lock()
         self.cancel_event = threading.Event()
-        
+
         logger.info(f"VideoProcessor initialized 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"""
         try:
@@ -105,29 +134,29 @@ def _initialize_progress_tracker(self, video_path: str, progress_callback: Optio
             cap = cv2.VideoCapture(video_path)
             total_frames = 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")
         except Exception as e:
             logger.warning(f"Could not initialize progress tracker: {e}")
             # Fallback to basic tracker
             self.progress_tracker = ProgressTracker(100, progress_callback)
-    
+
     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()}")
-                
+
                 # Add detailed debugging for the IndexError
                 try:
                     # Load models using load_all_models which returns tuple of (LoadedModel, LoadedModel)
@@ -135,47 +164,47 @@ def load_models(self, progress_callback: Optional[Callable] = None) -> str:
                         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}")
-                
+
                 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()}")
                     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"
-                
+
                 # Initialize core processor with the model loader (it expects a models object)
                 self.core_processor = CoreVideoProcessor(
                     config=self.config,
                     models=self.model_loader  # Pass the whole model_loader object
                 )
-                
+
                 # 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:
@@ -195,19 +224,19 @@ def load_models(self, progress_callback: Optional[Callable] = None) -> str:
                             logger.warning("  - SAM2 predictor is None")
                         if matanyone_model is None:
                             logger.warning("  - MatAnyone model is 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"
                 else:
                     message += "\n⚠️ Two-stage processor not available"
-                
+
                 logger.info(message)
                 return message
-                
+
             except AttributeError as e:
                 self.models_loaded = False
                 error_msg = f"Model loading failed - method not found: {str(e)}"
@@ -223,7 +252,7 @@ def load_models(self, progress_callback: Optional[Callable] = None) -> str:
                 error_msg = f"Unexpected error during model loading: {str(e)}"
                 logger.error(error_msg)
                 return error_msg
-    
+
     def process_video(
         self,
         video_path: str,
@@ -236,30 +265,30 @@ def process_video(
         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."
-        
+
         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)
-        
+
         # Validate input file
         is_valid, validation_msg = validate_video_file(video_path)
         if not is_valid:
             return None, f"Invalid video: {validation_msg}"
-        
+
         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,
@@ -271,14 +300,14 @@ def process_video(
                     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)}"
         except Exception as e:
             logger.error(f"Unexpected error during video processing: {e}")
             return None, f"Unexpected error: {str(e)}"
-    
+
     def _process_single_stage(
         self,
         video_path: str,
@@ -289,24 +318,24 @@ def _process_single_stage(
         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")
-        
+
         # 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}
         )
-        
+
         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(
@@ -315,7 +344,7 @@ def _process_single_stage(
             )
         else:
             final_video_path = output_path
-        
+
         success_msg = (
             f"Processing completed successfully!\n"
             f"Frames processed: {result.get('frames', 'unknown')}\n"
@@ -323,9 +352,9 @@ def _process_single_stage(
             f"Mode: Single-stage\n"
             f"Device: {self.device_manager.get_optimal_device()}"
         )
-        
+
         return final_video_path, success_msg
-    
+
     def _process_two_stage(
         self,
         video_path: str,
@@ -335,33 +364,33 @@ def _process_two_stage(
         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
         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 using core processor
         background = self.core_processor.prepare_background(
             background_choice, custom_background_path, frame_width, frame_height
         )
         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")
-        
+
         chroma_settings = CHROMA_PRESETS.get(chroma_preset, CHROMA_PRESETS['standard'])
-        
+
         logger.info(f"Starting two-stage processing with chroma preset: {chroma_preset}")
         result, message = self.two_stage_processor.process_full_pipeline(
             video_path,
@@ -370,10 +399,10 @@ def _process_two_stage(
             chroma_settings=chroma_settings,
             progress_callback=progress_callback
         )
-        
+
         if result is None:
             return None, message
-        
+
         success_msg = (
             f"Two-stage processing completed!\n"
             f"Background: {background_choice}\n"
@@ -381,9 +410,9 @@ def _process_two_stage(
             f"Quality: Cinema-grade with AI models\n"
             f"Device: {self.device_manager.get_optimal_device()}"
         )
-        
+
         return result, success_msg
-    
+
     def get_status(self) -> Dict[str, Any]:
         """Get comprehensive status of all components"""
         base_status = {
@@ -393,7 +422,7 @@ def get_status(self) -> Dict[str, Any]:
             'memory_usage': self.memory_manager.get_memory_usage(),
             'config': self.config.to_dict()
         }
-        
+
         # Add model-specific status if available
         if self.model_loader:
             base_status['model_loader_available'] = True
@@ -403,28 +432,28 @@ def get_status(self) -> Dict[str, Any]:
             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
-    
+
     def cancel_processing(self):
         """Cancel any ongoing processing"""
         self.cancel_event.set()
         logger.info("Processing cancellation requested")
-    
+
     def cleanup_resources(self):
         """Clean up all resources"""
         self.memory_manager.cleanup_aggressive()
@@ -482,20 +511,19 @@ def main():
         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")
-        
+
         # Import and create UI
         from ui_components import create_interface
         demo = create_interface()
-        
-        # Launch application
+
+        # Launch application (no share=True on Spaces)
         demo.queue().launch(
             server_name="0.0.0.0",
             server_port=7860,
-            share=True,
             show_error=True,
             debug=False
         )
-        
+
     except Exception as e:
         logger.error(f"Application startup failed: {e}")
         raise
@@ -505,4 +533,4 @@ def main():
 
 
 if __name__ == "__main__":
-    main()
+    main()