Update app.py

app.py

@@ -8,7 +8,6 @@
 import early_env  # <<< must be FIRST to sanitize threading/env before anything else
 
 import os
-import logging
 from pathlib import Path
 from typing import Optional, Tuple, Dict, Any, Callable
 
@@ -36,12 +35,11 @@ def patched_get_type(schema):
 except Exception:
     pass  # No fatal error if Gradio patch fails
 
-# 3️⃣ Set up logging early for debugging
-logging.basicConfig(
-    level=logging.INFO,
-    format="%(asctime)s - %(levelname)s - %(name)s - %(message)s"
-)
-logger = logging.getLogger("BackgroundFX")
+# 3️⃣ Initialize logging EARLY (before importing modules that emit logs)
+from utils.logging_setup import setup_logging, make_logger
+setup_logging(app_name="backgroundfx")  # LOG_LEVEL env var respected; defaults to DEBUG in dev
+logger = make_logger("entrypoint")
+logger.info("Entrypoint starting…")
 
 # 4️⃣ Import your modular code (assuming your project structure)
 from core.exceptions import ModelLoadingError, VideoProcessingError
@@ -51,8 +49,10 @@ def patched_get_type(schema):
 from models.loaders.model_loader import ModelLoader
 from processing.video.video_processor import CoreVideoProcessor, ProcessorConfig
 from processing.audio.audio_processor import AudioProcessor
-from utils.cv_processing import PROFESSIONAL_BACKGROUNDS, validate_video_file
-# If you have TwoStage: from processing.two_stage.two_stage_processor import TwoStageProcessor, CHROMA_PRESETS
+
+# NOTE: You previously imported from utils.cv_processing; adjust if needed.
+# Here we import from your unified utils (the file you showed me earlier).
+from utils import PROFESSIONAL_BACKGROUNDS, validate_video_file
 
 # 5️⃣ CSP-safe fallback model stubs
 class CSPSafeSAM2:
@@ -65,13 +65,22 @@ def predict(self, point_coords=None, point_labels=None, box=None, multimask_outp
         return np.ones((n, h, w), dtype=bool), np.array([0.9, 0.8, 0.7][:n]), np.ones((n, h, w), dtype=np.float32)
 
 class CSPSafeMatAnyone:
-    def step(self, image_tensor, mask_tensor=None, objects=None, first_frame_pred=False):
+    def step(self, image_tensor, mask_tensor=None, objects=None, first_frame_pred=False, **kwargs):
         import torch
-        shape = getattr(image_tensor, 'shape', (1, 3, 256, 256))
-        return torch.ones((shape[0], 1, shape[2], shape[3]))
+        # image_tensor is CHW or NCHW (guard in ModelLoader handles it)
+        if hasattr(image_tensor, "shape"):
+            if len(image_tensor.shape) == 3:
+                _, H, W = image_tensor.shape
+            elif len(image_tensor.shape) == 4:
+                _, _, H, W = image_tensor.shape
+            else:
+                H, W = 256, 256
+        else:
+            H, W = 256, 256
+        return torch.ones((1, 1, H, W))
     def output_prob_to_mask(self, output_prob):
         return (output_prob > 0.5).float()
-    def process(self, image, mask):
+    def process(self, image, mask, **kwargs):
         return mask
 
 # 6️⃣ Application main processor object
@@ -84,50 +93,78 @@ def __init__(self):
         self.audio_proc = AudioProcessor()
         self.models_loaded = False
         self.core_processor = None
+        logger.info("VideoBackgroundApp initialized (device=%s)", self.device_mgr.get_optimal_device())
 
     def load_models(self, progress_callback: Optional[Callable]=None) -> str:
-        logger.info("Loading models (CSP-safe)...")
+        logger.info("Loading models (CSP-safe)…")
         try:
             sam2, matanyone = self.model_loader.load_all_models(progress_callback=progress_callback)
         except Exception as e:
-            logger.warning(f"Model loading failed ({e}) - Using CSP-safe fallbacks")
+            logger.warning("Model loading failed (%s) - Using CSP-safe fallbacks", e)
             sam2, matanyone = None, None
+
         sam2_model = getattr(sam2, "model", sam2) if sam2 else CSPSafeSAM2()
         matanyone_model = getattr(matanyone, "model", matanyone) if matanyone else CSPSafeMatAnyone()
+
+        # CoreVideoProcessor expects a models manager; provide minimal adapter
         self.core_processor = CoreVideoProcessor(config=ProcessorConfig(), models=None)
         self.core_processor.models = type('FakeModelManager', (), {
-            'get_sam2': lambda self: sam2_model,
-            'get_matanyone': lambda self: matanyone_model
+            'get_sam2': lambda self_: sam2_model,
+            'get_matanyone': lambda self_: matanyone_model
         })()
+
         self.models_loaded = True
-        return "Models loaded (CSP-safe, fallback mode if no AI models loaded)."
+        logger.info("Models ready (SAM2=%s, MatAnyOne=%s)",
+                    type(sam2_model).__name__, type(matanyone_model).__name__)
+        return "Models loaded (CSP-safe; fallbacks in use if actual AI models failed)."
 
     def process_video(self, video, bg_style, custom_bg_file):
         if not self.models_loaded:
             return None, "Models not loaded yet"
+
+        logger.info("process_video called (video=%s, bg_style=%s, custom_bg=%s)",
+                    video, bg_style, getattr(custom_bg_file, "name", None))
+
         import time
         output_path = f"/tmp/output_{int(time.time())}.mp4"
-        cfg = PROFESSIONAL_BACKGROUNDS.get(bg_style, PROFESSIONAL_BACKGROUNDS["minimalist"])
+
+        # Background config
         if custom_bg_file:
             cfg = {"custom_path": custom_bg_file.name}
-        ok, msg = validate_video_file(video)
+        else:
+            # Safe default: ensure value exists in dict
+            style = bg_style if bg_style in PROFESSIONAL_BACKGROUNDS else "office"
+            cfg = PROFESSIONAL_BACKGROUNDS.get(style, PROFESSIONAL_BACKGROUNDS["office"])
+
+        # Validate input video (your `validate_video_file` returns bool)
+        ok = validate_video_file(video)
         if not ok:
-            return None, f"Invalid video: {msg}"
+            logger.warning("Invalid/unreadable video: %s", video)
+            return None, "Invalid or unreadable video file"
+
         try:
             result = self.core_processor.process_video(
                 input_path=video,
                 output_path=output_path,
                 bg_config=cfg
             )
+            logger.info("Core processing done → %s", output_path)
+
             output_with_audio = self.audio_proc.add_audio_to_video(video, output_path)
-            return output_with_audio, f"Processing complete ({result.get('frames', 'n/a')} frames, {bg_style})"
+            logger.info("Audio merged → %s", output_with_audio)
+
+            frames = (result.get('frames') if isinstance(result, dict) else None) or "n/a"
+            return output_with_audio, f"Processing complete ({frames} frames, style={bg_style})"
+
         except Exception as e:
+            logger.exception("Processing failed")
             return None, f"Processing failed: {e}"
 
 # 7️⃣ Gradio interface CSP-safe
 def create_csp_safe_gradio():
     import gradio as gr
     app = VideoBackgroundApp()
+
     with gr.Blocks(
         title="BackgroundFX Pro - CSP Safe",
         analytics_enabled=False,
@@ -141,9 +178,11 @@ def create_csp_safe_gradio():
         with gr.Row():
             with gr.Column():
                 video = gr.Video(label="Upload Video")
+                # Ensure default choice exists in PROFESSIONAL_BACKGROUNDS (use 'office')
+                choices = list(PROFESSIONAL_BACKGROUNDS.keys())
                 bg_style = gr.Dropdown(
-                    choices=list(PROFESSIONAL_BACKGROUNDS.keys()),
-                    value="minimalist",
+                    choices=choices,
+                    value="office",
                     label="Background Style"
                 )
                 custom_bg = gr.File(label="Custom Background (Optional)", file_types=["image"])
@@ -155,9 +194,14 @@ def create_csp_safe_gradio():
                 out_video = gr.Video(label="Processed Video")
 
         def safe_load():
-            return app.load_models()
+            msg = app.load_models()
+            logger.info("UI: models loaded")
+            return msg
+
         def safe_process(vid, style, custom_bg_file):
+            logger.info("UI: starting processing (style=%s)", style)
             return app.process_video(vid, style, custom_bg_file)
+
         btn_load.click(fn=safe_load, outputs=[status])
         btn_run.click(fn=safe_process, inputs=[video, bg_style, custom_bg], outputs=[out_video, status])