Update app.py

app.py

@@ -189,71 +189,125 @@ def _normalize_audio_to_wav(in_path: str) -> str:
 # FOND / GRAPHISME (PIL rapide)
 # ============================================================
 def make_background(titre, sous_titre, texte_ecran, theme, logo_path, logo_pos, img_fond, fond_mode="plein écran"):
-    c = THEMES[theme]
-    primary = tuple(c["primary"]); secondary = tuple(c["secondary"])
-    bg = Image.new("RGB", (W, H), primary)
-    if img_fond and os.path.exists(img_fond):
-        img = Image.open(img_fond).convert("RGB")
-        if fond_mode == "plein écran":
-            img = img.resize((W, H))
-            img = img.filter(ImageFilter.GaussianBlur(1))
-            overlay = Image.new("RGBA", (W, H), (*primary, 90))
-            bg = Image.alpha_composite(img.convert("RGBA"), overlay).convert("RGB")
-        elif fond_mode == "moitié gauche":
-            img = img.resize((W//2, H))
-            mask = Image.linear_gradient("L").resize((W//2, H))
-            color = Image.new("RGB", (W//2, H), primary)
-            comp = Image.composite(img, color, ImageOps.invert(mask))
-            bg.paste(comp, (0, 0))
-        elif fond_mode == "moitié droite":
-            img = img.resize((W//2, H))
-            mask = Image.linear_gradient("L").resize((W//2, H))
-            color = Image.new("RGB", (W//2, H), primary)
-            comp = Image.composite(color, img, mask)
-            bg.paste(comp, (W//2, 0))
-        elif fond_mode == "moitié bas":
-            img = img.resize((W, H//2))
-            mask = Image.linear_gradient("L").rotate(90).resize((W, H//2))
-            color = Image.new("RGB", (W, H//2), primary)
-            comp = Image.composite(color, img, mask)
-            bg.paste(comp, (0, H//2))
-
-    draw = ImageDraw.Draw(bg)
-    f_title = ImageFont.truetype(FONT_BOLD, 84)
-    f_sub   = ImageFont.truetype(FONT_REG, 44)
-    f_text  = ImageFont.truetype(FONT_REG, 40)
-    f_small = ImageFont.truetype(FONT_REG, 30)
-
-    draw.rectangle([(0, 0), (W, 96)], fill=secondary)
-    draw.rectangle([(0, H-96), (W, H)], fill=secondary)
-
-    _draw_text_shadow(draw, (MARGIN_X, 30), "CPAS BRUXELLES • SERVICE PUBLIC", f_small)
-    _draw_text_shadow(draw, (W//2-280, H-72), "📞 0800 35 550 • 🌐 cpasbru.irisnet.be", f_small)
-    _draw_text_shadow(draw, (MARGIN_X, SAFE_Y_TOP), titre, f_title)
-    _draw_text_shadow(draw, (MARGIN_X, SAFE_Y_TOP + 100), sous_titre, f_sub)
-
-    y = SAFE_Y_TOP + 200
-    for line in texte_ecran.split("\n"):
-        for l in _wrap_text("• " + line.strip("• "), f_text, W - MARGIN_X*2, draw):
-            _draw_text_shadow(draw, (MARGIN_X, y), l, f_text)
-            y += 55
-
-    # Cherchez cette partie dans make_background() et remplacez-la :
-    if logo_path and os.path.exists(logo_path):
-        logo = Image.open(logo_path).convert("RGBA")
-        logo.thumbnail((260, 260))
-        lw, lh = logo.size
-        if logo_pos == "haut-gauche":
-            pos = (50, 50)
-        elif logo_pos == "haut-droite":
-            pos = (W - lw - 50, 50)
-        else:
-            pos = ((W - lw)//2, 50)
-        bg.paste(logo, pos, logo)
-    
-        out = os.path.join(TMP_DIR, f"fond_{uuid.uuid4().hex[:6]}.png")
-        bg.save(out)
-        return out
+    try:
+        print(f"[Fond] Création du fond - Thème: {theme}")
+        
+        # Validation des entrées
+        if not titre:
+            titre = "Titre CPAS"
+        if not theme or theme not in THEMES:
+            theme = list(THEMES.keys())[0]
+            print(f"[Fond] Thème invalide, utilisation par défaut: {theme}")
+        
+        c = THEMES[theme]
+        primary = tuple(c["primary"])
+        secondary = tuple(c["secondary"])
+        
+        # Créer le fond de base
+        bg = Image.new("RGB", (W, H), primary)
+        draw = ImageDraw.Draw(bg)
+        
+        # Application de l'image de fond si fournie
+        if img_fond and os.path.exists(img_fond):
+            try:
+                img = Image.open(img_fond).convert("RGB")
+                if fond_mode == "plein écran":
+                    img = img.resize((W, H))
+                    img = img.filter(ImageFilter.GaussianBlur(1))
+                    overlay = Image.new("RGBA", (W, H), (*primary, 90))
+                    bg = Image.alpha_composite(img.convert("RGBA"), overlay).convert("RGB")
+                elif fond_mode == "moitié gauche":
+                    img = img.resize((W//2, H))
+                    mask = Image.linear_gradient("L").resize((W//2, H))
+                    color = Image.new("RGB", (W//2, H), primary)
+                    comp = Image.composite(img, color, ImageOps.invert(mask))
+                    bg.paste(comp, (0, 0))
+                elif fond_mode == "moitié droite":
+                    img = img.resize((W//2, H))
+                    mask = Image.linear_gradient("L").resize((W//2, H))
+                    color = Image.new("RGB", (W//2, H), primary)
+                    comp = Image.composite(color, img, mask)
+                    bg.paste(comp, (W//2, 0))
+                elif fond_mode == "moitié bas":
+                    img = img.resize((W, H//2))
+                    mask = Image.linear_gradient("L").rotate(90).resize((W, H//2))
+                    color = Image.new("RGB", (W, H//2), primary)
+                    comp = Image.composite(color, img, mask)
+                    bg.paste(comp, (0, H//2))
+                draw = ImageDraw.Draw(bg)  # Recréer le draw après modification
+                print(f"[Fond] Image de fond appliquée: {fond_mode}")
+            except Exception as e:
+                print(f"[Fond] Erreur image de fond: {e}")
+        
+        # Chargement des polices avec fallback
+        try:
+            f_title = ImageFont.truetype(FONT_BOLD, 84)
+            f_sub = ImageFont.truetype(FONT_REG, 44)
+            f_text = ImageFont.truetype(FONT_REG, 40)
+            f_small = ImageFont.truetype(FONT_REG, 30)
+        except Exception as e:
+            print(f"[Fond] Erreur polices, utilisation par défaut: {e}")
+            # Polices par défaut
+            f_title = ImageFont.load_default()
+            f_sub = ImageFont.load_default()
+            f_text = ImageFont.load_default()
+            f_small = ImageFont.load_default()
+        
+        # Bandes colorées
+        draw.rectangle([(0, 0), (W, 96)], fill=secondary)
+        draw.rectangle([(0, H-96), (W, H)], fill=secondary)
+        
+        # Textes
+        _draw_text_shadow(draw, (MARGIN_X, 30), "CPAS BRUXELLES • SERVICE PUBLIC", f_small)
+        _draw_text_shadow(draw, (W//2-280, H-72), "📞 0800 35 550 • 🌐 cpasbru.irisnet.be", f_small)
+        _draw_text_shadow(draw, (MARGIN_X, SAFE_Y_TOP), titre, f_title)
+        _draw_text_shadow(draw, (MARGIN_X, SAFE_Y_TOP + 100), sous_titre, f_sub)
+        
+        # Texte écran avec wrap
+        y = SAFE_Y_TOP + 200
+        if texte_ecran:
+            for line in texte_ecran.split("\n"):
+                wrapped_lines = _wrap_text("• " + line.strip("• "), f_text, W - MARGIN_X*2, draw)
+                for l in wrapped_lines:
+                    _draw_text_shadow(draw, (MARGIN_X, y), l, f_text)
+                    y += 55
+        
+        # Logo
+        if logo_path and os.path.exists(logo_path):
+            try:
+                logo = Image.open(logo_path).convert("RGBA")
+                logo.thumbnail((260, 260))
+                lw, lh = logo.size
+                if logo_pos == "haut-gauche":
+                    pos = (50, 50)
+                elif logo_pos == "haut-droite":
+                    pos = (W - lw - 50, 50)
+                else:  # centre
+                    pos = ((W - lw)//2, 50)
+                bg.paste(logo, pos, logo)
+                print(f"[Fond] Logo appliqué: {logo_pos}")
+            except Exception as e:
+                print(f"[Fond] Erreur logo: {e}")
+        
+        # Sauvegarde garantie
+        out_path = os.path.join(TMP_DIR, f"fond_{uuid.uuid4().hex[:6]}.png")
+        bg.save(out_path)
+        print(f"[Fond] ✅ Fond créé avec succès: {out_path}")
+        return out_path
+        
+    except Exception as e:
+        print(f"[Fond] ❌ ERREUR CRITIQUE: {e}")
+        print(f"[Fond] Traceback: {traceback.format_exc()}")
+        # Fallback absolu
+        try:
+            emergency_bg = Image.new("RGB", (W, H), (0, 82, 147))
+            out_path = os.path.join(TMP_DIR, f"emergency_fond_{uuid.uuid4().hex[:6]}.png")
+            emergency_bg.save(out_path)
+            print(f"[Fond] ✅ Fond d'urgence créé: {out_path}")
+            return out_path
+        except Exception as e2:
+            print(f"[Fond] ❌ Même le fallback a échoué: {e2}")
+            return None
 
 # ============================================================
 # SUPPRESSION DE LA PARTIE SADTALKER (plus nécessaire)
@@ -265,27 +319,29 @@ def _prepare_video_presentateur(video_path, audio_duration, position, plein_ecra
     import moviepy.video.fx.all as vfx
     
     try:
-        print(f"[Préparation vidéo] Chargement: {video_path}")
+        print(f"[Video] Chargement: {video_path}")
+        if not os.path.exists(video_path):
+            print(f"[Video] ❌ Fichier introuvable: {video_path}")
+            return None
+            
         v = VideoFileClip(video_path).without_audio()
-        print(f"[Préparation vidéo] Durée vidéo: {v.duration}s, Audio: {audio_duration}s")
+        print(f"[Video] Durée vidéo: {v.duration}s, Audio: {audio_duration}s")
         
         # Ajuster la durée à celle de l'audio
         if v.duration < audio_duration:
-            # Si la vidéo est plus courte, la boucler
-            print(f"[Préparation vidéo] Bouclage vidéo ({v.duration}s -> {audio_duration}s)")
+            print(f"[Video] Bouclage nécessaire ({v.duration}s -> {audio_duration}s)")
             v = v.fx(vfx.loop, duration=audio_duration)
         elif v.duration > audio_duration:
-            # Si la vidéo est plus longue, la couper
-            print(f"[Préparation vidéo] Découpage vidéo ({v.duration}s -> {audio_duration}s)")
+            print(f"[Video] Découpage nécessaire ({v.duration}s -> {audio_duration}s)")
             v = v.subclip(0, audio_duration)
         
         # Ajuster la taille et la position
         if plein_ecran:
-            print(f"[Préparation vidéo] Mode plein écran")
+            print(f"[Video] Mode plein écran")
             v = v.resize((W, H)).set_position(("center", "center"))
         else:
-            print(f"[Préparation vidéo] Mode incrustation, position: {position}")
-            v = v.resize(width=520)  # Taille réduite pour le coin
+            print(f"[Video] Mode incrustation, position: {position}")
+            v = v.resize(width=520)
             pos_map = {
                 "bottom-right": ("right", "bottom"),
                 "bottom-left": ("left", "bottom"),
@@ -295,11 +351,12 @@ def _prepare_video_presentateur(video_path, audio_duration, position, plein_ecra
             }
             v = v.set_position(pos_map.get(position, ("right", "bottom")))
         
-        print(f"[Préparation vidéo] Vidéo préparée avec succès")
+        print(f"[Video] ✅ Vidéo préparée avec succès")
         return v
+        
     except Exception as e:
-        print(f"[Préparation vidéo] Erreur : {e}")
-        print(f"[Préparation vidéo] Traceback: {traceback.format_exc()}")
+        print(f"[Video] ❌ Erreur préparation: {e}")
+        print(f"[Video] Traceback: {traceback.format_exc()}")
         return None
 
 # ============================================================
@@ -380,30 +437,49 @@ def build_capsule(titre, sous_titre, texte_voix, texte_ecran, theme,
         except Exception as e:
             print(f"[Audio] Normalisation échouée ({e}), on garde {audio_mp}")
 
- 
-    # 2) Fond (PIL)
+    # 2) Fond (PIL) - SECTION CORRIGÉE
+    print(f"[Capsule] Génération du fond...")
     fond_path = make_background(titre, sous_titre, texte_ecran, theme,
                                 logo_path, logo_pos, image_fond, fond_mode)
+    
+    # VÉRIFICATION ROBUSTE DU FOND
+    if fond_path is None:
+        print(f"[Capsule] ❌ fond_path est None, création d'urgence")
+        try:
+            emergency_bg = Image.new("RGB", (W, H), (0, 82, 147))
+            fond_path = os.path.join(TMP_DIR, f"emergency_{uuid.uuid4().hex[:6]}.png")
+            emergency_bg.save(fond_path)
+            print(f"[Capsule] ✅ Fond d'urgence créé: {fond_path}")
+        except Exception as e:
+            print(f"[Capsule] ❌ Impossible de créer le fond d'urgence: {e}")
+            fond_path = None
 
     # 3) MoviePy (imports lents ici seulement)
     from moviepy.editor import ImageClip, AudioFileClip, CompositeVideoClip, VideoFileClip
+    from moviepy.video.VideoClip import ColorClip
     import moviepy.video.fx.all as vfx
 
     audio = AudioFileClip(audio_wav)
     dur = float(audio.duration or 5.0)
     target_fps = 25
     
-    # CORRECTION : Vérifier que le fond existe
-    if not os.path.exists(fond_path):
-        print(f"❌ Fichier fond manquant, création d'urgence: {fond_path}")
-        emergency_bg = Image.new("RGB", (W, H), (0, 82, 147))
-        fond_path = os.path.join(TMP_DIR, f"emergency_{uuid.uuid4().hex[:6]}.png")
-        emergency_bg.save(fond_path)
-    
-    bg = ImageClip(fond_path).set_duration(dur)
+    # CHARGEMENT ROBUSTE DU FOND
+    clips = []
+    if fond_path and os.path.exists(fond_path):
+        try:
+            bg = ImageClip(fond_path).set_duration(dur)
+            clips.append(bg)
+            print(f"[Capsule] ✅ Fond chargé: {fond_path}")
+        except Exception as e:
+            print(f"[Capsule] ❌ Erreur ImageClip, fallback ColorClip: {e}")
+            bg = ColorClip(size=(W, H), color=(0, 82, 147)).set_duration(dur)
+            clips.append(bg)
+    else:
+        print(f"[Capsule] ❌ Aucun fond valide, utilisation ColorClip")
+        bg = ColorClip(size=(W, H), color=(0, 82, 147)).set_duration(dur)
+        clips.append(bg)
 
     # 4) Vidéo présentateur (au lieu de SadTalker)
-    clips = [bg]
     if video_presentateur and os.path.exists(video_presentateur):
         print(f"[Capsule] Vidéo présentateur trouvée: {video_presentateur}")
         v_presentateur = _prepare_video_presentateur(
@@ -413,12 +489,12 @@ def build_capsule(titre, sous_titre, texte_voix, texte_ecran, theme,
             plein
         )
         if v_presentateur:
-            print(f"[Capsule] Vidéo présentateur ajoutée avec succès")
+            print(f"[Capsule] ✅ Vidéo présentateur ajoutée")
             clips.append(v_presentateur)
         else:
-            print(f"[Capsule] Échec de préparation de la vidéo présentateur")
+            print(f"[Capsule] ❌ Échec préparation vidéo présentateur")
     else:
-        print(f"[Capsule] Aucune vidéo présentateur fournie ou fichier introuvable: {video_presentateur}")
+        print(f"[Capsule] Aucune vidéo présentateur: {video_presentateur}")
 
     # 5) Composition + export
     final = CompositeVideoClip(clips).set_audio(audio.set_fps(44100))
@@ -438,7 +514,7 @@ def build_capsule(titre, sous_titre, texte_voix, texte_ecran, theme,
     })
     _save_manifest()
 
-    # 7) Nettoyage
+    # 7) Nettoyage CORRIGÉ
     try:
         audio.close()
         final.close()
@@ -450,9 +526,10 @@ def build_capsule(titre, sous_titre, texte_voix, texte_ecran, theme,
         if audio_wav != audio_mp and os.path.exists(audio_wav): 
             os.remove(audio_wav)
     except Exception as e:
-        print(f"[Clean] Erreur nettoyage : {e}")
+        print(f"[Clean] Erreur nettoyage: {e}")
     gc.collect()
 
+    return out, f"✅ Capsule {langue.upper()} créée ({dur:.1f}s, voix {speaker or voix_type})", srt_path
 # ============================================================
 # GESTION / ASSEMBLAGE
 # ============================================================