Update app.py

app.py

@@ -1,4 +1,3 @@
-
 import os
 import re
 import xml.etree.ElementTree as ET
@@ -7,7 +6,7 @@ from typing import List
 import gradio as gr
 
 # Optional LLM (Gemini)
-USE_LLM_DEFAULT = True  # default checked
+USE_LLM_DEFAULT = True
 GEMINI_API_KEY = os.getenv("GEMINI_API_KEY", "").strip()
 
 LLM_AVAILABLE = False
@@ -59,7 +58,7 @@ def frames_to_timecode(frames: int, fps: int = FPS) -> str:
 def parse_transcript(txt: str) -> List[Segment]:
     lines = [l.strip() for l in txt.splitlines() if l.strip()]
     results: List[Segment] = []
-    pat_range = re.compile(r"^\[?\s*(\d{2}:\d{2}:\d{2}[:;]\d{2})\s*[-–]\s*(\d{2}:\d{2}:\d{2}[:;]\d{2})\s*\]?\s+(.*)$")
+    pat_range = re.compile(r"^\[?\s*(\d{2}:\d{2}:\d{2}[:;]\d{2})\s*[-—]\s*(\d{2}:\d{2}:\d{2}[:;]\d{2})\s*\]?\s+(.*)$")
     pat_point = re.compile(r"^(\d{2}:\d{2}:\d{2}[:;]\d{2})\s+(.*)$")
     for l in lines:
         m = pat_range.match(l)
@@ -78,14 +77,15 @@ def parse_transcript(txt: str) -> List[Segment]:
             s, text = m.groups()
             try:
                 s_f = parse_timecode_to_frames(s)
-                e_f = s_f + 4*FPS  # default window
+                e_f = s_f + 4*FPS
                 e = frames_to_timecode(e_f)
                 results.append(Segment(s, e, s_f, e_f, text, 0.0))
             except Exception:
                 continue
     return results
 
-def keyword_score(text: str) -> float:
+def keyword_score(text: str, custom_keywords: str = "", weight_emotion: float = 2.0, 
+                  weight_break: float = 1.5, weight_learn: float = 1.2, weight_viral: float = 1.0) -> float:
     t = text.lower()
     kw_emotion = ["medo", "coragem", "raiva", "chorei", "feliz", "triste", "emocion", "culpa", "vergonha", "orgulho"]
     kw_break   = ["nunca", "de repente", "contraintuitivo", "ninguém te conta", "parei", "decidi", "quebrei", "virada"]
@@ -93,48 +93,71 @@ def keyword_score(text: str) -> float:
     kw_viral   = ["segredo", "verdade", "por trás", "3 passos", "passo a passo", "como eu", "ninguém fala"]
 
     score = 0.0
-    for kw in kw_emotion: score += 2.0 if kw in t else 0.0
-    for kw in kw_break:   score += 1.5 if kw in t else 0.0
-    for kw in kw_learn:   score += 1.2 if kw in t else 0.0
-    for kw in kw_viral:   score += 1.0 if kw in t else 0.0
+    for kw in kw_emotion: score += weight_emotion if kw in t else 0.0
+    for kw in kw_break:   score += weight_break if kw in t else 0.0
+    for kw in kw_learn:   score += weight_learn if kw in t else 0.0
+    for kw in kw_viral:   score += weight_viral if kw in t else 0.0
+    
+    # Custom keywords
+    if custom_keywords.strip():
+        custom_kw_list = [kw.strip().lower() for kw in custom_keywords.split(",") if kw.strip()]
+        for kw in custom_kw_list:
+            score += 3.0 if kw in t else 0.0
+    
     score += 0.2 * text.count("!")
     score += 0.0005 * len(text)
     return score
 
-def llm_rank_segments(candidates: List[Segment]) -> List[Segment]:
-    """Ask the LLM to pick 2–5 best segments by narrative strength."""
+def llm_rank_segments(candidates: List[Segment], num_segments: int, custom_instructions: str = "") -> List[Segment]:
+    """Ask the LLM to pick segments based on criteria."""
     if not LLM_AVAILABLE:
-        return candidates
+        return candidates[:num_segments]
+    
     sample = "\n".join([f"{i}. [{c.start_tc}-{c.end_tc}] {c.text[:300]}" for i, c in enumerate(candidates)])
-    prompt = (
-        "Você é um editor. Selecione de 2 a 5 trechos mais fortes pela emoção, quebra de expectativa e aprendizado, "
-        "mantendo uma mini-narrativa coerente. Responda apenas com índices (0-based) separados por vírgula.\n\n"
-        f"{sample}"
+    
+    base_prompt = (
+        f"Você é um editor profissional. Selecione exatamente {num_segments} trechos mais fortes "
+        "pela emoção, quebra de expectativa e aprendizado, mantendo uma mini-narrativa coerente.\n\n"
     )
+    
+    if custom_instructions.strip():
+        base_prompt += f"INSTRUÇÕES ADICIONAIS: {custom_instructions}\n\n"
+    
+    base_prompt += "Responda apenas com índices (0-based) separados por vírgula.\n\n" + sample
+    
     try:
-        r = LLM.generate_content(prompt, generation_config={"temperature": 0.2})
+        r = LLM.generate_content(base_prompt, generation_config={"temperature": 0.2})
         txt = (r.text or "").strip()
         idxs = [int(x) for x in re.findall(r"\d+", txt)]
         idxs = [i for i in idxs if 0 <= i < len(candidates)]
-        if 2 <= len(idxs) <= 5:
+        if len(idxs) >= num_segments:
+            return [candidates[i] for i in idxs[:num_segments]]
+        elif len(idxs) > 0:
             return [candidates[i] for i in idxs]
-    except Exception:
-        pass
-    return candidates[:min(5, max(2, len(candidates)))]
-
-def select_segments(transcript_txt: str, use_llm: bool) -> List[Segment]:
+    except Exception as e:
+        print(f"Erro no LLM: {e}")
+    
+    return candidates[:num_segments]
+
+def select_segments(transcript_txt: str, use_llm: bool, num_segments: int, 
+                   custom_keywords: str, custom_instructions: str,
+                   weight_emotion: float, weight_break: float, 
+                   weight_learn: float, weight_viral: float) -> List[Segment]:
     segs = parse_transcript(transcript_txt)
     if not segs:
         raise ValueError("Nenhum trecho válido encontrado na transcrição.")
+    
     for s in segs:
-        s.score = keyword_score(s.text)
-    # Heuristic pre-filter
+        s.score = keyword_score(s.text, custom_keywords, weight_emotion, weight_break, weight_learn, weight_viral)
+    
     segs.sort(key=lambda x: x.score, reverse=True)
-    top = segs[:12]
+    top = segs[:min(20, len(segs))]
+    
     if use_llm and LLM_AVAILABLE:
-        ranked = llm_rank_segments(top)
-        return ranked[:min(5, max(2, len(ranked)))]
-    return top[:min(5, max(2, len(top)))]
+        ranked = llm_rank_segments(top, num_segments, custom_instructions)
+        return ranked
+    
+    return top[:num_segments]
 
 # ---- XML editing ----
 def get_sequence(root: ET.Element) -> ET.Element:
@@ -242,13 +265,18 @@ def edit_sequence_with_segments(tree: ET.ElementTree, segs: List[Segment]) -> ET
     return tree
 
 # ---- Gradio app ----
-def process_xml_and_transcript(premiere_xml_file, transcript_txt_file, use_llm):
+def process_xml_and_transcript(premiere_xml_file, transcript_txt_file, use_llm, 
+                               num_segments, custom_keywords, custom_instructions,
+                               weight_emotion, weight_break, weight_learn, weight_viral):
     if premiere_xml_file is None or transcript_txt_file is None:
         return "Envie o XML do Premiere e a transcrição em .txt.", None, f"LLM disponível: {LLM_AVAILABLE}"
+    
     with open(transcript_txt_file.name, "r", encoding="utf-8") as f:
         transcript = f.read()
 
-    segs = select_segments(transcript, use_llm and LLM_AVAILABLE)
+    segs = select_segments(transcript, use_llm and LLM_AVAILABLE, num_segments,
+                          custom_keywords, custom_instructions,
+                          weight_emotion, weight_break, weight_learn, weight_viral)
 
     tree = ET.parse(premiere_xml_file.name)
     tree = edit_sequence_with_segments(tree, segs)
@@ -257,30 +285,86 @@ def process_xml_and_transcript(premiere_xml_file, transcript_txt_file, use_llm):
     out_path = os.path.join(OUTPUT_DIR, f"{base}_EDITADO.xml")
     tree.write(out_path, encoding="utf-8", xml_declaration=True)
 
-    resumo = "Cortes aplicados (24 fps):\n"
+    resumo = f"✂️ {len(segs)} cortes aplicados (24 fps):\n\n"
     for i, s in enumerate(segs, 1):
-        resumo += f"{i}. {s.start_tc} -> {s.end_tc} | {s.end_f - s.start_f} frames | {s.text[:120]}\n"
+        dur_sec = (s.end_f - s.start_f) / FPS
+        resumo += f"{i}. {s.start_tc} → {s.end_tc} ({dur_sec:.1f}s)\n"
+        resumo += f"   Score: {s.score:.1f} | {s.text[:150]}\n\n"
 
-    status = f"LLM disponível: {LLM_AVAILABLE} | LLM ligado na UI: {use_llm}"
+    status = f"✓ LLM disponível: {LLM_AVAILABLE} | LLM usado: {use_llm and LLM_AVAILABLE}"
     return resumo, out_path, status
 
-with gr.Blocks() as demo:
-    gr.Markdown("# Agente de Edição XML para Premiere (24 fps) — Modo LLM")
-    gr.Markdown("Lê transcrição com timecodes e edita **a mesma sequência** no XML do Premiere. "
-                "Mantenha V/A sincronizados, sem mídias externas, sem nova `<sequence>`.")
-
+with gr.Blocks(theme=gr.themes.Soft()) as demo:
+    gr.Markdown("# 🎬 Agente de Edição XML para Premiere (Controles Avançados)")
+    gr.Markdown("Edite sua sequência do Premiere com controle total sobre a seleção de trechos.")
+    
     with gr.Row():
-        xml_in = gr.File(label="XML da sequência do Premiere (FCP XML)", file_types=[".xml"])
-        txt_in = gr.File(label="Transcrição (.txt) hh:mm:ss:ff", file_types=[".txt"])
-
-    use_llm = gr.Checkbox(label="Usar LLM (Gemini) para seleção semântica", value=USE_LLM_DEFAULT and LLM_AVAILABLE)
-    run_btn = gr.Button("Processar")
-    resumo_out = gr.Textbox(label="Resumo dos cortes aplicados")
-    file_out = gr.File(label="Download do XML Editado")
-    status_out = gr.Textbox(label="Status do LLM", interactive=False)
-
-    run_btn.click(process_xml_and_transcript, inputs=[xml_in, txt_in, use_llm],
-                  outputs=[resumo_out, file_out, status_out])
+        with gr.Column():
+            xml_in = gr.File(label="📁 XML da sequência (FCP XML)", file_types=[".xml"])
+            txt_in = gr.File(label="📄 Transcrição (.txt) com timecodes", file_types=[".txt"])
+        
+        with gr.Column():
+            gr.Markdown("### ⚙️ Configurações")
+            use_llm = gr.Checkbox(
+                label="🤖 Usar LLM (Gemini) para seleção semântica", 
+                value=USE_LLM_DEFAULT and LLM_AVAILABLE,
+                info="Usa IA para escolher os melhores trechos narrativamente"
+            )
+            num_segments = gr.Slider(
+                minimum=2, maximum=10, step=1, value=5,
+                label="📊 Número de segmentos a selecionar",
+                info="Quantos trechos incluir no vídeo final"
+            )
+    
+    with gr.Accordion("🎯 Palavras-chave Personalizadas", open=False):
+        custom_keywords = gr.Textbox(
+            label="Adicione palavras-chave importantes (separadas por vírgula)",
+            placeholder="Exemplo: transformação, resultado, método, estratégia",
+            info="Trechos com essas palavras terão prioridade máxima (peso 3.0)"
+        )
+    
+    with gr.Accordion("📝 Instruções em Texto Livre para o LLM", open=False):
+        custom_instructions = gr.Textbox(
+            label="Instruções adicionais para o LLM",
+            placeholder="Exemplo: Prefira trechos que mostrem resultados concretos e evite introduções longas",
+            lines=3,
+            info="Só funciona se o LLM estiver ativado"
+        )
+    
+    with gr.Accordion("⚖️ Ajuste Fino dos Pesos de Pontuação", open=False):
+        gr.Markdown("Ajuste a importância de cada categoria na pontuação heurística:")
+        with gr.Row():
+            weight_emotion = gr.Slider(0, 5, value=2.0, step=0.1, label="Emoção")
+            weight_break = gr.Slider(0, 5, value=1.5, step=0.1, label="Quebra de expectativa")
+        with gr.Row():
+            weight_learn = gr.Slider(0, 5, value=1.2, step=0.1, label="Aprendizado")
+            weight_viral = gr.Slider(0, 5, value=1.0, step=0.1, label="Viralização")
+    
+    run_btn = gr.Button("🚀 Processar e Gerar XML Editado", variant="primary", size="lg")
+    
+    gr.Markdown("---")
+    
+    with gr.Row():
+        with gr.Column(scale=2):
+            resumo_out = gr.Textbox(label="📋 Resumo dos cortes aplicados", lines=15)
+        with gr.Column(scale=1):
+            status_out = gr.Textbox(label="ℹ️ Status", interactive=False)
+            file_out = gr.File(label="💾 Download do XML Editado")
+    
+    run_btn.click(
+        process_xml_and_transcript, 
+        inputs=[xml_in, txt_in, use_llm, num_segments, custom_keywords, 
+                custom_instructions, weight_emotion, weight_break, weight_learn, weight_viral],
+        outputs=[resumo_out, file_out, status_out]
+    )
+    
+    gr.Markdown("""
+    ### 💡 Dicas de uso:
+    - **Modo Heurístico**: Desative o LLM e ajuste os pesos para controle total baseado em palavras-chave
+    - **Modo LLM**: Ative o LLM e use as instruções em texto livre para guiar a seleção semanticamente
+    - **Híbrido**: Combine palavras-chave personalizadas + instruções LLM para máximo controle
+    - **Palavras-chave**: Adicione termos específicos do seu nicho que devem ter alta prioridade
+    """)
 
 if __name__ == "__main__":
-    demo.launch()
+    demo.launch()