Update video_processor.py

video_processor.py

@@ -12,10 +12,11 @@
 from typing import Optional, Tuple, Dict, Any, Callable
 from pathlib import Path
 
-from app_config import ProcessingConfig
-from memory_manager import MemoryManager
-from progress_tracker import ProgressTracker
-from exceptions import VideoProcessingError, VideoFileError, BackgroundProcessingError, SegmentationError
+# Import modular components
+import app_config
+import memory_manager
+import progress_tracker
+import exceptions
 
 # Import utilities
 from utilities import (
@@ -35,11 +36,11 @@ class CoreVideoProcessor:
     """
     
     def __init__(self, sam2_predictor: Any, matanyone_model: Any, 
-                 config: ProcessingConfig, memory_manager: MemoryManager):
+                 config: app_config.ProcessingConfig, memory_mgr: memory_manager.MemoryManager):
         self.sam2_predictor = sam2_predictor
         self.matanyone_model = matanyone_model
         self.config = config
-        self.memory_manager = memory_manager
+        self.memory_manager = memory_mgr
         
         # Processing state
         self.processing_active = False
@@ -245,7 +246,7 @@ def _process_video_frames(
         """Process all video frames"""
         
         # Initialize progress tracking
-        progress_tracker = ProgressTracker(
+        prog_tracker = progress_tracker.ProgressTracker(
             total_frames=video_info['total_frames'],
             callback=progress_callback,
             track_performance=True
@@ -260,7 +261,7 @@ def _process_video_frames(
         self.frame_cache.clear()
         
         try:
-            progress_tracker.set_stage("Processing frames")
+            prog_tracker.set_stage("Processing frames")
             
             while True:
                 # Check for cancellation
@@ -280,7 +281,7 @@ def _process_video_frames(
                 
                 try:
                     # Update progress
-                    progress_tracker.update(frame_count, "Processing frame")
+                    prog_tracker.update(frame_count, "Processing frame")
                     
                     # Process frame
                     processed_frame = self._process_single_frame(
@@ -315,7 +316,7 @@ def _process_video_frames(
                         frame_count += 1
             
             # Finalize progress tracking
-            final_stats = progress_tracker.finalize()
+            final_stats = prog_tracker.finalize()
             
             return {
                 'success': successful_frames > 0,
@@ -376,13 +377,13 @@ def _segment_person(self, frame: np.ndarray, frame_number: int) -> np.ndarray:
             mask = segment_person_hq(frame, self.sam2_predictor)
             
             if mask is None or mask.size == 0:
-                raise SegmentationError(frame_number, "Segmentation returned empty mask")
+                raise exceptions.SegmentationError(frame_number, "Segmentation returned empty mask")
             
             return mask
             
         except Exception as e:
             self.stats['segmentation_errors'] += 1
-            raise SegmentationError(frame_number, f"Segmentation failed: {str(e)}")
+            raise exceptions.SegmentationError(frame_number, f"Segmentation failed: {str(e)}")
     
     def _should_refine_mask(self, frame_number: int) -> bool:
         """Determine if mask should be refined for this frame"""
@@ -524,18 +525,18 @@ def prepare_background(
         try:
             if background_choice == "custom" and custom_background_path:
                 if not os.path.exists(custom_background_path):
-                    raise BackgroundProcessingError("custom", f"File not found: {custom_background_path}")
+                    raise exceptions.BackgroundProcessingError("custom", f"File not found: {custom_background_path}")
                 
                 background = cv2.imread(custom_background_path)
                 if background is None:
-                    raise BackgroundProcessingError("custom", "Could not read custom background image")
+                    raise exceptions.BackgroundProcessingError("custom", "Could not read custom background image")
                 
                 logger.info(f"Loaded custom background: {custom_background_path}")
                 
             else:
                 # Use professional background
                 if background_choice not in PROFESSIONAL_BACKGROUNDS:
-                    raise BackgroundProcessingError(background_choice, "Unknown professional background")
+                    raise exceptions.BackgroundProcessingError(background_choice, "Unknown professional background")
                 
                 bg_config = PROFESSIONAL_BACKGROUNDS[background_choice]
                 background = create_professional_background(bg_config, width, height)
@@ -548,12 +549,12 @@ def prepare_background(
             
             # Validate background
             if background is None or background.size == 0:
-                raise BackgroundProcessingError(background_choice, "Background image is empty")
+                raise exceptions.BackgroundProcessingError(background_choice, "Background image is empty")
             
             return background
             
         except Exception as e:
-            if isinstance(e, BackgroundProcessingError):
+            if isinstance(e, exceptions.BackgroundProcessingError):
                 logger.error(str(e))
                 return None
             else: