Update src/capsule_builder.py

src/capsule_builder.py

@@ -1,5 +1,5 @@
-import os, json, uuid, gc, traceback
-from moviepy.editor import ImageClip, AudioFileClip, CompositeVideoClip
+import os, json, uuid, gc, traceback, shutil, time
+from moviepy.editor import ImageClip, AudioFileClip, CompositeVideoClip, TextClip
 from moviepy.video.VideoClip import ColorClip
 
 from .config import OUT_DIR, TMP_DIR, MANIFEST_PATH, W, H
@@ -9,7 +9,7 @@ from .video_utils import prepare_video_presentateur, write_srt, write_video_with
 
 capsules = []
 
-# Load manifest on import
+# Charger le manifeste existant
 if os.path.exists(MANIFEST_PATH):
     try:
         data = json.load(open(MANIFEST_PATH, "r", encoding="utf-8"))
@@ -18,18 +18,20 @@ if os.path.exists(MANIFEST_PATH):
     except Exception:
         pass
 
+
 def _save_manifest():
     with open(MANIFEST_PATH, "w", encoding="utf-8") as f:
         json.dump({"capsules": capsules}, f, ensure_ascii=False, indent=2)
 
+
 def build_capsule(titre, sous_titre, texte_voix, texte_ecran, theme,
                   image_fond=None, logo_path=None, logo_pos="haut-gauche",
-                  fond_mode="plein écran",
-                  video_presentateur=None, voix_type="Féminine",
-                  position_presentateur="bottom-right", plein=False,
-                  moteur_voix="Edge-TTS (recommandé)", langue="fr", speaker=None):
+                  fond_mode="plein écran", video_presentateur=None,
+                  voix_type="Féminine", position_presentateur="bottom-right",
+                  plein=False, moteur_voix="Edge-TTS (recommandé)",
+                  langue="fr", speaker=None):
 
-    # 1) TTS
+    # 1️⃣ TTS
     try:
         audio_mp = tts_edge(texte_voix, voice=speaker or ("fr-FR-DeniseNeural" if langue == "fr" else "nl-NL-MaaikeNeural"))
     except Exception as e:
@@ -43,10 +45,18 @@ 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
+    # 2️⃣ Fond
     print("[Capsule] Génération du fond...")
     fond_path = make_background(titre, sous_titre, texte_ecran, theme,
                                 logo_path, logo_pos, image_fond, fond_mode)
+
+    if fond_path and not os.path.exists(fond_path):
+        # Correction chemin TMP_DIR
+        alt_path = os.path.join(os.getcwd(), "_tmp_capsules", os.path.basename(fond_path))
+        if os.path.exists(alt_path):
+            fond_path = alt_path
+            print(f"[Capsule] ⚙️ Correction du chemin fond: {fond_path}")
+
     if fond_path is None:
         print("[Capsule] ❌ fond_path est None, création d'urgence")
         from PIL import Image
@@ -59,7 +69,7 @@ def build_capsule(titre, sous_titre, texte_voix, texte_ecran, theme,
             print(f"[Capsule] ❌ Impossible de créer le fond d'urgence: {e}")
             fond_path = None
 
-    # 3) Composition MoviePy
+    # 3️⃣ Composition vidéo
     audio = AudioFileClip(audio_wav)
     dur = float(audio.duration or 5.0)
     target_fps = 25
@@ -79,26 +89,24 @@ def build_capsule(titre, sous_titre, texte_voix, texte_ecran, theme,
         bg = ColorClip(size=(W, H), color=(0, 82, 147)).set_duration(dur)
         clips.append(bg)
 
+    # 4️⃣ Présentateur
+    v_presentateur = None
+    has_text = bool(texte_ecran and texte_ecran.strip())
+    plein_auto = plein if not has_text else False
+
     if video_presentateur and os.path.exists(video_presentateur):
         ext = os.path.splitext(video_presentateur)[1].lower()
-        v_presentateur = None
-    
-        # --- Vidéo ---
         if ext in [".mp4", ".mov", ".avi", ".mkv"]:
             print(f"[Capsule] Vidéo présentateur trouvée: {video_presentateur}")
             v_presentateur = prepare_video_presentateur(
-                video_presentateur, dur, position_presentateur, plein
+                video_presentateur, dur, position_presentateur, plein_auto
             )
-    
-        # --- Image ---
         elif ext in [".jpg", ".jpeg", ".png", ".bmp", ".webp"]:
-            from moviepy.editor import ImageClip
             print(f"[Capsule] Image présentateur trouvée: {video_presentateur}")
             try:
                 img_clip = ImageClip(video_presentateur).set_duration(dur)
-                if plein:
+                if plein_auto:
                     img_clip = img_clip.resize((W, H)).set_position(("center", "center"))
-                    print("[Capsule] Image plein écran")
                 else:
                     img_clip = img_clip.resize(width=520)
                     pos_map = {
@@ -109,21 +117,33 @@ def build_capsule(titre, sous_titre, texte_voix, texte_ecran, theme,
                         "center": ("center", "center"),
                     }
                     img_clip = img_clip.set_position(pos_map.get(position_presentateur, ("right", "bottom")))
-                    print(f"[Capsule] Image positionnée : {position_presentateur}")
                 v_presentateur = img_clip
             except Exception as e:
                 print(f"[Capsule] ❌ Erreur image présentateur : {e}")
-    
-        # --- Ajout final ---
+
         if v_presentateur:
-            print(f"[Capsule] ✅ Présentateur ajouté (image ou vidéo)")
             clips.append(v_presentateur)
-        else:
-            print(f"[Capsule] ❌ Échec préparation présentateur")
+            print(f"[Capsule] ✅ Présentateur ajouté")
     else:
-        print(f"[Capsule] Aucune vidéo/image présentateur: {video_presentateur}")
+        print(f"[Capsule] Aucun présentateur: {video_presentateur}")
 
+    # 5️⃣ Overlay texte (par-dessus tout)
+    if texte_ecran and texte_ecran.strip():
+        try:
+            txt_clip = TextClip(
+                texte_ecran,
+                fontsize=50,
+                color='white',
+                font='DejaVu-Sans-Bold',
+                method='caption',
+                size=(W - 200, None)
+            ).set_position(('center', 'bottom')).set_duration(dur)
+            clips.append(txt_clip)
+            print("[Capsule] ✅ Overlay texte ajouté (bas centré)")
+        except Exception as e:
+            print(f"[Capsule] ⚠️ Overlay texte échoué : {e}")
 
+    # 6️⃣ Assemblage final
     final = CompositeVideoClip(clips).set_audio(audio.set_fps(44100))
     name = safe_name(f"{titre}_{langue}")
     out_base = os.path.join(OUT_DIR, name)
@@ -143,11 +163,12 @@ def build_capsule(titre, sous_titre, texte_voix, texte_ecran, theme,
     })
     _save_manifest()
 
+    # 7️⃣ Nettoyage
     try:
         audio.close()
         final.close()
         bg.close()
-        if 'v_presentateur' in locals() and v_presentateur is not None:
+        if v_presentateur:
             v_presentateur.close()
         if os.path.exists(audio_mp):
             os.remove(audio_mp)
@@ -159,12 +180,15 @@ def build_capsule(titre, sous_titre, texte_voix, texte_ecran, theme,
 
     return out, f"✅ Capsule {langue.upper()} créée ({dur:.1f}s, voix {speaker or voix_type})", srt_path
 
+
+# 🧾 Fonctions supplémentaires identiques à ta version originale
+
 def table_capsules():
-    import os
     return [[i+1, c["title"], c.get("langue","fr").upper(),
              f"{c['duration']}s", c["theme"], c["voice"], os.path.basename(c["file"])]
             for i, c in enumerate(capsules)]
 
+
 def assemble_final():
     if not capsules:
         return None, "❌ Aucune capsule."
@@ -183,6 +207,7 @@ def assemble_final():
             try: c.close()
             except: pass
 
+
 def supprimer_capsule(index):
     try:
         idx = int(index) - 1
@@ -198,6 +223,7 @@ def supprimer_capsule(index):
     except Exception as e:
         return f"❌ Erreur lors de la suppression : {e}", table_capsules()
 
+
 def deplacer_capsule(index, direction):
     try:
         idx = int(index) - 1
@@ -211,56 +237,40 @@ def deplacer_capsule(index, direction):
         return f"❌ Erreur de déplacement : {e}", table_capsules()
 
 
-import shutil, time
-
 def export_project_zip():
     """Crée un ZIP complet pour toutes les capsules (vidéos, srt, inputs, params, manifest)."""
     try:
         zip_root = os.path.join(TMP_DIR, f"zip_export_{int(time.time())}")
         os.makedirs(zip_root, exist_ok=True)
-        # Manifest global
         manifest = {"capsules": capsules}
         with open(os.path.join(zip_root, "manifest.json"), "w", encoding="utf-8") as f:
             json.dump(manifest, f, ensure_ascii=False, indent=2)
 
-        # Par capsule
         for i, cap in enumerate(capsules, 1):
             cap_dir = os.path.join(zip_root, f"capsule_{i}")
             os.makedirs(os.path.join(cap_dir, "inputs"), exist_ok=True)
-
-            # copy video + srt if exists
-            for key in ["file"]:
-                path = cap.get(key)
-                if path and os.path.exists(path):
-                    shutil.copy2(path, os.path.join(cap_dir, os.path.basename(path)))
-            # try to find srt next to file if not stored
-            if cap.get("file"):
-                base = os.path.splitext(os.path.basename(cap["file"]))[0]
-                # srt names are not strictly tied; we copy any srt in OUT_DIR too
+            if cap.get("file") and os.path.exists(cap["file"]):
+                shutil.copy2(cap["file"], os.path.join(cap_dir, os.path.basename(cap["file"])))
             for f in os.listdir(OUT_DIR):
                 if f.lower().endswith(".srt"):
                     shutil.copy2(os.path.join(OUT_DIR, f), os.path.join(cap_dir, f))
-
-            # inputs
             for k in ["image_fond", "logo", "video_presentateur"]:
                 p = cap.get("inputs", {}).get(k) if cap.get("inputs") else None
                 if p and os.path.exists(p):
                     shutil.copy2(p, os.path.join(cap_dir, "inputs", os.path.basename(p)))
-
-            # params.json per capsule
             with open(os.path.join(cap_dir, "params.json"), "w", encoding="utf-8") as pf:
                 json.dump(cap, pf, ensure_ascii=False, indent=2)
 
-        # zip
         zip_path = shutil.make_archive(os.path.join(TMP_DIR, f"capsules_export_{int(time.time())}"), "zip", zip_root)
         return zip_path
     except Exception as e:
         print(f"[Export] ❌ Erreur ZIP : {e}")
         return None
 
+
 def assemble_final_fast():
     """Concaténation instantanée sans réencodage (FFmpeg direct)."""
-    import subprocess, os
+    import subprocess
     if not capsules:
         return None, "❌ Aucune capsule."
     list_path = os.path.join(OUT_DIR, "concat_list.txt")
@@ -268,10 +278,6 @@ def assemble_final_fast():
         for c in capsules:
             f.write(f"file '{c['file']}'\n")
     out_path = os.path.join(OUT_DIR, "VIDEO_COMPLETE_FAST.mp4")
-    cmd = [
-        "ffmpeg", "-f", "concat", "-safe", "0", "-i", list_path,
-        "-c", "copy", out_path
-    ]
+    cmd = ["ffmpeg", "-f", "concat", "-safe", "0", "-i", list_path, "-c", "copy", out_path]
     subprocess.run(cmd, check=True)
     return out_path, "🎉 Vidéo finale assemblée instantanément (sans réencodage)"
-