Update app.py

app.py

@@ -1,13 +1,6 @@
 # ============================================================================
 # ULTIMATE FACE SWAP - 100% QUALITY + HEAD SWAP (WITH HAIR!)
-# 
-# UPGRADES:
-# 1. ✅ CodeFormer instead of GFPGAN (superior quality - 100%!)
-# 2. ✅ Head swap mode (includes hair, ears, neck!)
-# 3. ✅ Dual restoration (CodeFormer + GFPGAN together = maximum quality)
-# 4. ✅ Higher fidelity weight (0.5 → 0.2 for more detail)
-# 5. ✅ Small previews (400x300)
-# 6. ✅ FIXED: MoviePy import error
+# Fixed for Hugging Face Spaces deployment
 # ============================================================================
 
 print("="*80)
@@ -19,9 +12,9 @@ import subprocess, sys
 print("\n[1/7] Installing packages...")
 subprocess.check_call([
     sys.executable, "-m", "pip", "install", "-q",
-    "gradio", "insightface==0.7.3", "onnxruntime-gpu", 
-    "opencv-python-headless", "moviepy==2.0.0.dev2", "numpy", "scipy", "tqdm",
-    "gfpgan", "basicsr", "facexlib", "imageio-ffmpeg"
+    "gradio==4.44.1", "insightface==0.7.3", "onnxruntime", 
+    "opencv-python-headless", "moviepy==1.0.3", "numpy", "scipy", "tqdm",
+    "gfpgan", "basicsr", "facexlib", "torch", "torchvision"
 ])
 print("✓ Installed")
 
@@ -38,27 +31,21 @@ from insightface.model_zoo import get_model
 try:
     from moviepy.editor import VideoFileClip, ImageSequenceClip
 except ImportError:
-    try:
-        from moviepy import VideoFileClip, ImageSequenceClip
-    except ImportError:
-        # Final fallback - install older stable version
-        print("  Installing moviepy 1.0.3...")
-        subprocess.check_call([sys.executable, "-m", "pip", "install", "-q", "moviepy==1.0.3"])
-        from moviepy.editor import VideoFileClip, ImageSequenceClip
+    from moviepy import VideoFileClip, ImageSequenceClip
 
 from tqdm import tqdm
 print("✓ Imported")
 
 # ============================================================================
-# SECTION 1: FACE DETECTION
+# SECTION 1: FACE DETECTION (CPU MODE)
 # ============================================================================
 print("\n[3/7] Loading face detector...")
-face_app = FaceAnalysis(name="buffalo_l")
-face_app.prepare(ctx_id=0, det_size=(640, 640))
-print("✓ Face detector loaded")
+face_app = FaceAnalysis(name="buffalo_l", providers=['CPUExecutionProvider'])
+face_app.prepare(ctx_id=-1, det_size=(640, 640))  # ctx_id=-1 for CPU
+print("✓ Face detector loaded (CPU mode)")
 
 # ============================================================================
-# SECTION 2: INSWAPPER MODEL
+# SECTION 2: INSWAPPER MODEL (CPU MODE)
 # ============================================================================
 print("\n[4/7] Loading INSwapper...")
 
@@ -75,18 +62,18 @@ try:
         urllib.request.urlretrieve(url, model_path)
         print(f"  ✓ Downloaded ({os.path.getsize(model_path) // 1_000_000}MB)")
     
-    swapper = get_model(model_path, download=False, download_zip=False)
+    swapper = get_model(model_path, download=False, download_zip=False, providers=['CPUExecutionProvider'])
     
     SWAPPER_LOADED = True
-    print("✓ INSwapper loaded")
+    print("✓ INSwapper loaded (CPU mode)")
     
 except Exception as e:
     print(f"✗ INSwapper failed: {e}")
 
 # ============================================================================
-# SECTION 3: CODEFORMER (SUPERIOR TO GFPGAN!)
+# SECTION 3: CODEFORMER (SIMPLIFIED FOR CPU)
 # ============================================================================
-print("\n[5/7] Loading CodeFormer (best quality)...")
+print("\n[5/7] Loading CodeFormer...")
 
 codeformer_net = None
 CODEFORMER_LOADED = False
@@ -96,7 +83,6 @@ try:
     from basicsr.utils.download_util import load_file_from_url
     from basicsr.utils import imwrite, img2tensor, tensor2img
     from facexlib.utils.face_restoration_helper import FaceRestoreHelper
-    from torchvision.transforms.functional import normalize
     import torch
     
     # Download CodeFormer model
@@ -110,7 +96,6 @@ try:
         print("  ✓ Downloaded")
     
     # Load CodeFormer network
-    from basicsr.utils import get_root_logger
     from basicsr.archs import build_network
     
     codeformer_net = build_network({
@@ -125,7 +110,8 @@ try:
     codeformer_net.load_state_dict(checkpoint['params_ema'])
     codeformer_net.eval()
     
-    device = 'cuda' if torch.cuda.is_available() else 'cpu'
+    # Always use CPU for Spaces
+    device = 'cpu'
     codeformer_net = codeformer_net.to(device)
     
     # Face helper for detection and alignment
@@ -140,7 +126,7 @@ try:
     )
     
     CODEFORMER_LOADED = True
-    print("✓ CodeFormer loaded - Maximum quality mode!")
+    print("✓ CodeFormer loaded (CPU mode)")
     
 except Exception as e:
     print(f"⚠ CodeFormer failed: {e}")
@@ -149,7 +135,7 @@ except Exception as e:
 # ============================================================================
 # SECTION 4: GFPGAN (BACKUP/COMPLEMENTARY)
 # ============================================================================
-print("\n[6/7] Loading GFPGAN (complementary)...")
+print("\n[6/7] Loading GFPGAN...")
 
 gfpgan_restorer = None
 GFPGAN_LOADED = False
@@ -172,11 +158,12 @@ try:
         upscale=2,
         arch='clean',
         channel_multiplier=2,
-        bg_upsampler=None
+        bg_upsampler=None,
+        device='cpu'  # Force CPU
     )
     
     GFPGAN_LOADED = True
-    print("✓ GFPGAN loaded (complementary mode)")
+    print("✓ GFPGAN loaded (CPU mode)")
     
 except Exception as e:
     print(f"⚠ GFPGAN unavailable: {e}")
@@ -230,18 +217,15 @@ def detect_faces_with_preview(image):
     return cv2.cvtColor(preview_small, cv2.COLOR_BGR2RGB), faces
 
 # ============================================================================
-# CODEFORMER RESTORATION FUNCTION (100% QUALITY!)
+# CODEFORMER RESTORATION FUNCTION
 # ============================================================================
 
 def restore_with_codeformer(face_img, fidelity_weight=0.2):
-    """
-    Apply CodeFormer restoration with LOW fidelity (0.2 = more AI detail)
-    Lower fidelity = more enhancement, higher quality!
-    """
+    """Apply CodeFormer restoration"""
     import torch
-    from torchvision.transforms.functional import normalize
+    from torchvision.transforms import functional as F
     
-    device = 'cuda' if torch.cuda.is_available() else 'cpu'
+    device = 'cpu'
     
     # Prepare image
     face_img = cv2.resize(face_img, (512, 512), interpolation=cv2.INTER_LINEAR)
@@ -249,7 +233,7 @@ def restore_with_codeformer(face_img, fidelity_weight=0.2):
     face_img = torch.from_numpy(face_img).permute(2, 0, 1).unsqueeze(0).to(device)
     
     # Normalize
-    normalize(face_img, (0.5, 0.5, 0.5), (0.5, 0.5, 0.5), inplace=True)
+    face_img = F.normalize(face_img, (0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
     
     # Run CodeFormer
     with torch.no_grad():
@@ -262,15 +246,11 @@ def restore_with_codeformer(face_img, fidelity_weight=0.2):
     return output
 
 # ============================================================================
-# ENHANCED FACE SWAP (100% QUALITY + HEAD SWAP MODE!)
+# ENHANCED FACE SWAP
 # ============================================================================
 
 def swap_face_in_frame(frame, source_face, target_face_idx=None, include_hair=False):
-    """
-    Enhanced face swap with:
-    - CodeFormer for maximum quality
-    - Optional head swap mode (includes hair!)
-    """
+    """Enhanced face swap with restoration"""
     if not SWAPPER_LOADED:
         return frame
     
@@ -289,40 +269,31 @@ def swap_face_in_frame(frame, source_face, target_face_idx=None, include_hair=Fa
         for target_face in target_faces:
             result = swapper.get(result, target_face, source_face, paste_back=True)
     
-    # CRITICAL: Apply CodeFormer for 100% quality!
+    # Apply restoration
     if CODEFORMER_LOADED and codeformer_net:
         try:
             swapped_faces = face_app.get(result)
             
             for face in swapped_faces:
                 x1, y1, x2, y2 = face.bbox.astype(int)
-                
-                # Expand region for head swap mode
                 h, w = result.shape[:2]
                 
                 if include_hair:
-                    # HEAD SWAP: Include hair, ears, neck!
-                    pad = int(max(x2-x1, y2-y1) * 0.6)  # 60% padding
+                    pad = int(max(x2-x1, y2-y1) * 0.6)
                 else:
-                    # FACE SWAP: Just face
-                    pad = int(max(x2-x1, y2-y1) * 0.3)  # 30% padding
+                    pad = int(max(x2-x1, y2-y1) * 0.3)
                 
                 x1 = max(0, x1 - pad)
                 y1 = max(0, y1 - pad)
                 x2 = min(w, x2 + pad)
                 y2 = min(h, y2 + pad)
                 
-                # Extract region
                 face_region = result[y1:y2, x1:x2].copy()
                 original_size = (x2-x1, y2-y1)
                 
-                # Apply CodeFormer with LOW fidelity (0.2 = maximum quality!)
                 restored_face = restore_with_codeformer(face_region, fidelity_weight=0.2)
-                
-                # Resize back
                 restored_face = cv2.resize(restored_face, original_size, interpolation=cv2.INTER_LANCZOS4)
                 
-                # Optional: Apply GFPGAN too for dual restoration
                 if GFPGAN_LOADED and gfpgan_restorer:
                     try:
                         _, _, restored_face = gfpgan_restorer.enhance(
@@ -334,16 +305,14 @@ def swap_face_in_frame(frame, source_face, target_face_idx=None, include_hair=Fa
                     except:
                         pass
                 
-                # Put restored face back
                 result[y1:y2, x1:x2] = restored_face
                 
-            print("  ✓ CodeFormer applied - 100% quality!")
+            print("  ✓ CodeFormer applied")
             
         except Exception as e:
             print(f"  ⚠ CodeFormer error: {e}")
     
     elif GFPGAN_LOADED and gfpgan_restorer:
-        # Fallback to GFPGAN only
         try:
             swapped_faces = face_app.get(result)
             
@@ -368,7 +337,7 @@ def swap_face_in_frame(frame, source_face, target_face_idx=None, include_hair=Fa
                 
                 result[y1:y2, x1:x2] = restored_face
                 
-            print("  ✓ GFPGAN applied - 90% quality")
+            print("  ✓ GFPGAN applied")
             
         except Exception as e:
             print(f"  ⚠ GFPGAN error: {e}")
@@ -380,7 +349,7 @@ def swap_face_in_frame(frame, source_face, target_face_idx=None, include_hair=Fa
 # ============================================================================
 
 def process_video(video_path, source_face, target_face_index, include_hair, progress_fn):
-    """Process video with 100% quality + optional head swap"""
+    """Process video with face swap"""
     
     if not SWAPPER_LOADED:
         raise ValueError("INSwapper not loaded!")
@@ -395,11 +364,6 @@ def process_video(video_path, source_face, target_face_index, include_hair, prog
     else:
         print("FACE SWAP MODE: Swapping face only")
     
-    if CODEFORMER_LOADED:
-        print("Using CodeFormer - 100% quality!")
-    elif GFPGAN_LOADED:
-        print("Using GFPGAN - 90% quality")
-    
     processed_frames = []
     
     for i, frame in enumerate(clip.iter_frames()):
@@ -528,7 +492,7 @@ def handle_generate(source_choice, target_choice, include_hair, progress=gr.Prog
         
         progress(1.0, desc="Complete!")
         
-        status = "✅ DONE - 100% QUALITY!\n\n"
+        status = "✅ DONE!\n\n"
         status += "Applied:\n"
         status += "✓ INSwapper face swap\n"
         if include_hair:
@@ -537,9 +501,9 @@ def handle_generate(source_choice, target_choice, include_hair, progress=gr.Prog
             status += "✓ FACE SWAP (face only)\n"
         
         if CODEFORMER_LOADED:
-            status += "✓ CodeFormer restoration (100% quality!)\n"
+            status += "✓ CodeFormer restoration\n"
         elif GFPGAN_LOADED:
-            status += "✓ GFPGAN restoration (90% quality)\n"
+            status += "✓ GFPGAN restoration\n"
         
         return result, status
         
@@ -555,8 +519,8 @@ print("\n[7/7] Building interface...")
 
 with gr.Blocks(theme=gr.themes.Soft(), title="Ultimate Face Swap") as demo:
     
-    gr.Markdown("# 🔥 ULTIMATE - 100% QUALITY + HEAD SWAP!")
-    gr.Markdown("### CodeFormer (superior to GFPGAN) + Head Swap Mode!")
+    gr.Markdown("# 🔥 ULTIMATE FACE SWAP + HEAD SWAP!")
+    gr.Markdown("### Professional face swapping with enhancement")
     
     if SWAPPER_LOADED:
         gr.Markdown("✅ **INSwapper Loaded**")
@@ -564,77 +528,14 @@ with gr.Blocks(theme=gr.themes.Soft(), title="Ultimate Face Swap") as demo:
         gr.Markdown("❌ **INSwapper Failed**")
     
     if CODEFORMER_LOADED:
-        gr.Markdown("✅ **CodeFormer Active** - 100% quality guaranteed!")
+        gr.Markdown("✅ **CodeFormer Active**")
     elif GFPGAN_LOADED:
-        gr.Markdown("⚠️ **GFPGAN Only** - 90% quality")
+        gr.Markdown("✅ **GFPGAN Active**")
     else:
-        gr.Markdown("⚠️ **No restoration** - 85% quality")
+        gr.Markdown("⚠️ **No restoration available**")
     
     with gr.Row():
         with gr.Column():
             gr.Markdown("### 📸 Source Image")
             source_image = gr.Image(type="numpy", label="Upload Source Face")
-            source_preview = gr.Image(label="Detected (1/4 size)", height=300)
-            source_status = gr.Textbox(label="Status", lines=2)
-            source_dropdown = gr.Dropdown(label="Select Face")
-        
-        with gr.Column():
-            gr.Markdown("### 🎬 Target Video")
-            target_video = gr.Video(label="Upload Target Video")
-            target_preview = gr.Image(label="Detected (1/4 size)", height=300)
-            target_status = gr.Textbox(label="Status", lines=2)
-            target_dropdown = gr.Dropdown(label="Select Person")
-    
-    gr.Markdown("### 🚀 Generate Video")
-    
-    head_swap_checkbox = gr.Checkbox(
-        value=False,
-        label="🔥 HEAD SWAP MODE (includes hair, ears, neck!)"
-    )
-    
-    generate_button = gr.Button(
-        "🎭 Generate 100% Quality Video!",
-        variant="primary",
-        size="lg"
-    )
-    
-    generation_status = gr.Textbox(label="Status", lines=6)
-    result_video = gr.Video(label="Result")
-    
-    # Events
-    source_image.change(
-        handle_source_image,
-        inputs=[source_image],
-        outputs=[source_preview, source_status, source_dropdown]
-    )
-    
-    target_video.change(
-        handle_target_video,
-        inputs=[target_video],
-        outputs=[target_preview, target_status, target_dropdown]
-    )
-    
-    generate_button.click(
-        handle_generate,
-        inputs=[source_dropdown, target_dropdown, head_swap_checkbox],
-        outputs=[result_video, generation_status]
-    )
-
-print("✓ Interface built")
-
-print("\n" + "="*80)
-print("LAUNCHING - 100% QUALITY + HEAD SWAP MODE!")
-print("="*80)
-
-if SWAPPER_LOADED and CODEFORMER_LOADED:
-    print("✅ All systems ready - 100% quality + head swap available!")
-elif SWAPPER_LOADED:
-    print("⚠️  CodeFormer unavailable - quality limited to 90%")
-else:
-    print("❌ INSwapper failed")
-
-demo.queue()
-demo.launch(share=True)
-
-print("\n✅ Running!")
-print("="*80)
+            source_preview = gr.Image(label