Update app.py

app.py

@@ -54,39 +54,44 @@ def frames_to_timecode(frames: int, fps: int = FPS) -> str:
     ff = rem % fps
     return f"{hh:02d}:{mm:02d}:{ss:02d}:{ff:02d}"
 
+def frames_to_seconds(frames: int, fps: int = FPS) -> float:
+    return frames / fps
+
+def seconds_to_frames(seconds: float, fps: int = FPS) -> int:
+    return int(seconds * fps)
+
 # ============ TRANSCRIPT PARSING ============
-def parse_transcript_full(txt: str) -> List[Segment]:
-    """Parse transcrição mantendo ranges originais"""
+def parse_transcript(txt: str) -> List[Segment]:
     lines = [l.strip() for l in txt.splitlines() if l.strip()]
     results: List[Segment] = []
     
-    # Aceita vários formatos: com ou sem colchetes, - ou —
-    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:
-        # Pula linhas com apenas "Desconhecido"
-        if l.strip() == "Desconhecido":
-            continue
-            
         m = pat_range.match(l)
         if m:
             s, e, text = m.groups()
-            text = text.strip()
-            
-            # Pula se não tiver texto
-            if not text or text == "Desconhecido":
-                continue
-                
             try:
                 s_f = parse_timecode_to_frames(s)
                 e_f = parse_timecode_to_frames(e)
                 if e_f > s_f:
                     results.append(Segment(s, e, s_f, e_f, text, 0.0))
-            except Exception as ex:
-                print(f"Erro ao processar linha: {l[:50]}... -> {ex}")
+            except Exception:
+                continue
+            continue
+        
+        m = pat_point.match(l)
+        if m:
+            s, text = m.groups()
+            try:
+                s_f = parse_timecode_to_frames(s)
+                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
     
-    print(f"✓ {len(results)} segmentos encontrados na transcrição")
     return results
 
 # ============ MANUAL TIMECODES ============
@@ -105,12 +110,88 @@ def parse_manual_timecodes(manual_input: str) -> List[Tuple[str, str]]:
     
     return manual_ranges
 
+# ============ SEGMENT PROCESSING ============
+def get_total_duration(segs: List[Segment]) -> float:
+    """Retorna duração total em segundos"""
+    return sum((s.end_f - s.start_f) / FPS for s in segs)
+
+def create_target_selection(segs: List[Segment], target_minutes: float, strategy: str = "distributed") -> List[Segment]:
+    """
+    Cria uma seleção de segmentos para atingir duração alvo.
+    strategy: 'distributed' = espalhado pelo vídeo, 'sequential' = em sequência
+    """
+    target_seconds = target_minutes * 60
+    total_available = get_total_duration(segs)
+    
+    if target_seconds > total_available:
+        print(f"Aviso: Duração solicitada ({target_minutes:.1f}min) maior que disponível ({total_available/60:.1f}min)")
+        return segs
+    
+    if strategy == "distributed":
+        # Distribui seleção ao longo do vídeo
+        ratio = target_seconds / total_available
+        selected = []
+        current_duration = 0
+        
+        # Seleciona proporcionalmente de cada parte
+        for seg in segs:
+            if current_duration >= target_seconds:
+                break
+            seg_duration = (seg.end_f - seg.start_f) / FPS
+            if ratio >= 0.8 or (current_duration + seg_duration <= target_seconds * 1.1):
+                selected.append(seg)
+                current_duration += seg_duration
+        
+        return selected
+    
+    else:  # sequential
+        selected = []
+        current_duration = 0
+        
+        for seg in segs:
+            if current_duration >= target_seconds:
+                break
+            selected.append(seg)
+            current_duration += (seg.end_f - seg.start_f) / FPS
+        
+        return selected
+
+def merge_close_segments(segs: List[Segment], max_gap_seconds: float = 3.0) -> List[Segment]:
+    """Mescla segmentos que estão próximos um do outro"""
+    if not segs:
+        return []
+    
+    segs_sorted = sorted(segs, key=lambda x: x.start_f)
+    merged = [segs_sorted[0]]
+    max_gap_frames = int(max_gap_seconds * FPS)
+    
+    for current in segs_sorted[1:]:
+        last = merged[-1]
+        gap = current.start_f - last.end_f
+        
+        if gap <= max_gap_frames and gap >= 0:
+            # Mescla os segmentos
+            merged[-1] = Segment(
+                start_tc=last.start_tc,
+                end_tc=current.end_tc,
+                start_f=last.start_f,
+                end_f=current.end_f,
+                text=last.text + " [...] " + current.text,
+                score=(last.score + current.score) / 2
+            )
+        else:
+            merged.append(current)
+    
+    return merged
+
 # ============ AI PROCESSING ============
 def extract_duration_from_instructions(instructions: str) -> float:
-    """Extrai duração em minutos das instruções"""
+    """Extrai duração em minutos das instruções do usuário"""
+    # Procura por padrões como "10 minutos", "5 min", "15 minutes"
     patterns = [
         r"(\d+)\s*minutos?",
         r"(\d+)\s*min\b",
+        r"(\d+)\s*minutes?",
         r"(\d+)m\b"
     ]
     
@@ -121,125 +202,53 @@ def extract_duration_from_instructions(instructions: str) -> float:
     
     return None
 
-def find_start_point_in_transcript(segs: List[Segment], instructions: str) -> int:
-    """Encontra o ponto de início baseado nas instruções"""
-    if not LLM_AVAILABLE:
-        return 0
-    
-    # Cria resumo dos segmentos
-    segments_text = "\n".join([
-        f"{i}. [{s.start_tc}-{s.end_tc}] {s.text[:150]}"
-        for i, s in enumerate(segs[:100])  # Primeiros 100 para não sobrecarregar
-    ])
-    
-    prompt = f"""Analise as instruções e encontre o índice do segmento onde deve COMEÇAR o corte.
-
-INSTRUÇÕES: {instructions}
-
-SEGMENTOS:
-{segments_text}
-
-RESPONDA APENAS com o NÚMERO do índice onde deve começar (exemplo: 45)
-Não adicione explicações."""
-
-    try:
-        response = LLM.generate_content(prompt, generation_config={"temperature": 0.2})
-        txt = (response.text or "").strip()
-        
-        # Extrai o primeiro número
-        match = re.search(r"\d+", txt)
-        if match:
-            idx = int(match.group())
-            if 0 <= idx < len(segs):
-                return idx
-    except Exception as e:
-        print(f"Erro ao buscar ponto inicial: {e}")
-    
-    return 0
-
-def create_continuous_cut(segs: List[Segment], start_idx: int, target_minutes: float) -> List[Segment]:
-    """Cria um corte contínuo de duração específica"""
-    if start_idx >= len(segs):
-        start_idx = 0
-    
-    target_seconds = target_minutes * 60
-    target_frames = int(target_seconds * FPS)
-    
-    start_segment = segs[start_idx]
-    start_frame = start_segment.start_f
-    end_frame = start_frame + target_frames
-    
-    # Cria um único segmento contínuo
-    end_tc = frames_to_timecode(end_frame)
-    
-    combined_text = " ".join([s.text for s in segs[start_idx:min(start_idx + 50, len(segs))]])[:500]
-    
-    result = Segment(
-        start_tc=start_segment.start_tc,
-        end_tc=end_tc,
-        start_f=start_frame,
-        end_f=end_frame,
-        text=f"Corte contínuo: {combined_text}...",
-        score=100.0
-    )
-    
-    return [result]
-
 def ai_select_segments(segs: List[Segment], instructions: str) -> List[Segment]:
-    """Usa IA para processar instruções em linguagem natural"""
+    """Usa IA para selecionar segmentos baseado em instruções"""
     if not LLM_AVAILABLE:
         raise ValueError("IA não disponível. Configure GEMINI_API_KEY")
     
-    # Detecta se pede duração específica
+    total_duration_min = get_total_duration(segs) / 60
     target_duration = extract_duration_from_instructions(instructions)
     
-    if target_duration:
-        # Modo: corte contínuo de X minutos
-        print(f"Modo: Corte contínuo de {target_duration} minutos")
-        
-        # Encontra ponto de início
-        start_idx = find_start_point_in_transcript(segs, instructions)
-        print(f"Iniciando do segmento {start_idx}: {segs[start_idx].start_tc}")
-        
-        # Cria corte contínuo
-        result = create_continuous_cut(segs, start_idx, target_duration)
-        
-        duration_min = (result[0].end_f - result[0].start_f) / FPS / 60
-        print(f"✓ Corte criado: {result[0].start_tc} → {result[0].end_tc} ({duration_min:.1f} min)")
-        
-        return result
-    
-    else:
-        # Modo: seleção de múltiplos trechos
-        print("Modo: Seleção de múltiplos trechos")
-        return ai_select_multiple_segments(segs, instructions, num_segments=5)
-
-def ai_select_multiple_segments(segs: List[Segment], instructions: str, num_segments: int = 5) -> List[Segment]:
-    """Seleciona múltiplos segmentos baseado em critérios"""
-    segments_summary = []
+    # Cria resumo dos segmentos (agrupados para prompt menor)
+    segment_summary = []
     for i in range(0, len(segs), 5):
         group = segs[i:i+5]
         start_tc = group[0].start_tc
         end_tc = group[-1].end_tc
+        duration = sum((s.end_f - s.start_f) / FPS for s in group)
         combined_text = " ".join([s.text[:100] for s in group])
-        segments_summary.append(f"Grupo {i//5}: [{start_tc}-{end_tc}] {combined_text[:200]}")
+        segment_summary.append(f"Grupo {i//5}: [{start_tc}-{end_tc}] ({duration:.0f}s) {combined_text[:200]}")
     
-    prompt = f"""Você é um editor profissional.
+    prompt = f"""Você é um editor de vídeo profissional.
+
+INSTRUÇÕES DO USUÁRIO:
+{instructions}
 
-INSTRUÇÕES: {instructions}
+INFORMAÇÕES:
+- Total disponível: {total_duration_min:.1f} minutos ({len(segs)} segmentos)
+- Duração alvo detectada: {target_duration if target_duration else 'não especificada'} minutos
 
-SEGMENTOS (agrupados):
-{chr(10).join(segments_summary[:40])}
+SEGMENTOS (agrupados de 5 em 5):
+{chr(10).join(segment_summary[:50])}
 
-Selecione 10-15 GRUPOS que atendem às instruções.
-RESPONDA APENAS com números separados por vírgula (ex: 0,3,7,12,18,25)"""
+TAREFA:
+1. Identifique quais GRUPOS de segmentos atendem às instruções
+2. Se foi solicitada duração específica, selecione grupos suficientes para atingi-la
+3. Distribua a seleção: pegue grupos do INÍCIO, MEIO e FIM do vídeo
+4. Retorne os NÚMEROS dos grupos selecionados
+
+RESPONDA APENAS com números separados por vírgula (ex: 0,2,5,8,12,15,20,25,30)
+Selecione pelo menos 10-20 grupos para ter duração adequada."""
 
     try:
-        response = LLM.generate_content(prompt, generation_config={"temperature": 0.4})
+        response = LLM.generate_content(prompt, generation_config={"temperature": 0.4, "max_output_tokens": 500})
         txt = (response.text or "").strip()
         
+        # Extrai números dos grupos
         group_indices = [int(x) for x in re.findall(r"\d+", txt)]
         
+        # Converte grupos em segmentos individuais
         selected_segs = []
         for group_idx in group_indices:
             start_idx = group_idx * 5
@@ -248,19 +257,36 @@ RESPONDA APENAS com números separados por vírgula (ex: 0,3,7,12,18,25)"""
                 selected_segs.extend(segs[start_idx:end_idx])
         
         if not selected_segs:
+            # Fallback: pega distribuído
             step = max(1, len(segs) // 30)
-            selected_segs = segs[::step][:num_segments]
+            selected_segs = segs[::step]
+        
+        # Remove duplicatas e ordena
+        seen = set()
+        unique_segs = []
+        for seg in selected_segs:
+            key = (seg.start_f, seg.end_f)
+            if key not in seen:
+                seen.add(key)
+                unique_segs.append(seg)
+        
+        unique_segs.sort(key=lambda x: x.start_f)
+        
+        # Ajusta para duração alvo se especificada
+        if target_duration:
+            unique_segs = create_target_selection(unique_segs, target_duration, "distributed")
         
-        selected_segs.sort(key=lambda x: x.start_f)
+        # Mescla segmentos próximos
+        final_segs = merge_close_segments(unique_segs, max_gap_seconds=3.0)
         
-        duration = sum((s.end_f - s.start_f) / FPS for s in selected_segs)
-        print(f"✓ {len(selected_segs)} trechos selecionados, duração: {duration/60:.1f} min")
+        final_duration = get_total_duration(final_segs)
+        print(f"✓ Selecionados {len(final_segs)} trechos, duração total: {final_duration/60:.1f} min")
         
-        return selected_segs[:num_segments * 3]  # Retorna mais segmentos
+        return final_segs
         
     except Exception as e:
-        print(f"Erro: {e}")
-        return segs[:num_segments]
+        print(f"Erro na IA: {e}")
+        raise
 
 # ============ KEYWORD SCORING ============
 def keyword_score(text: str, custom_keywords: str = "", weights: dict = None) -> float:
@@ -268,10 +294,10 @@ def keyword_score(text: str, custom_keywords: str = "", weights: dict = None) ->
         weights = {"emotion": 2.0, "break": 1.5, "learn": 1.2, "viral": 1.0}
     
     t = text.lower()
-    kw_emotion = ["medo", "coragem", "raiva", "chorei", "feliz", "triste"]
+    kw_emotion = ["medo", "coragem", "raiva", "chorei", "feliz", "triste", "emocion"]
     kw_break   = ["nunca", "de repente", "contraintuitivo", "virada"]
-    kw_learn   = ["aprendi", "descobri", "lição", "entendi"]
-    kw_viral   = ["segredo", "verdade", "3 passos"]
+    kw_learn   = ["aprendi", "descobri", "lição", "entendi", "percebi"]
+    kw_viral   = ["segredo", "verdade", "3 passos", "como eu"]
 
     score = 0.0
     for kw in kw_emotion: score += weights["emotion"] if kw in t else 0.0
@@ -284,6 +310,7 @@ def keyword_score(text: str, custom_keywords: str = "", weights: dict = None) ->
             if kw.strip().lower() in t:
                 score += 3.0
     
+    score += 0.2 * text.count("!")
     return score
 
 # ============ MAIN SELECTION LOGIC ============
@@ -292,7 +319,7 @@ def select_segments(transcript_txt: str, use_llm: bool, num_segments: int,
                    weight_emotion: float, weight_break: float, 
                    weight_learn: float, weight_viral: float) -> List[Segment]:
     
-    # Priority 1: Manual
+    # Priority 1: Manual timecodes
     manual_ranges = parse_manual_timecodes(manual_timecodes)
     if manual_ranges:
         result_segs = []
@@ -311,17 +338,21 @@ def select_segments(transcript_txt: str, use_llm: bool, num_segments: int,
                 print(f"Erro: {e}")
         return result_segs if result_segs else []
     
-    # Parse transcript
-    segs = parse_transcript_full(transcript_txt)
+    # Priority 2: AI with natural instructions
+    segs = parse_transcript(transcript_txt)
     if not segs:
-        raise ValueError("Nenhum trecho encontrado")
+        raise ValueError("Nenhum trecho encontrado na transcrição")
     
-    # Priority 2: AI with natural instructions
     if natural_instructions.strip() and use_llm and LLM_AVAILABLE:
         return ai_select_segments(segs, natural_instructions)
     
     # Priority 3: Automatic scoring
-    weights = {"emotion": weight_emotion, "break": weight_break, "learn": weight_learn, "viral": weight_viral}
+    weights = {
+        "emotion": weight_emotion,
+        "break": weight_break,
+        "learn": weight_learn,
+        "viral": weight_viral
+    }
     
     for s in segs:
         s.score = keyword_score(s.text, custom_keywords, weights)
@@ -422,20 +453,21 @@ def process_xml_and_transcript(xml_file, txt_file, use_llm, num_segments,
                                custom_keywords, manual_timecodes, natural_instructions,
                                weight_emotion, weight_break, weight_learn, weight_viral):
     if not xml_file:
-        return "❌ Envie o XML", None, f"LLM: {LLM_AVAILABLE}"
+        return "❌ Envie o XML do Premiere", None, f"LLM: {LLM_AVAILABLE}"
     
     manual_ranges = parse_manual_timecodes(manual_timecodes)
     has_instructions = natural_instructions.strip() != ""
     
+    # Determine mode
     if manual_ranges:
         mode = "MANUAL"
         transcript = ""
     elif has_instructions:
         mode = "IA (Linguagem Natural)"
         if not txt_file:
-            return "❌ Envie a transcrição", None, f"LLM: {LLM_AVAILABLE}"
+            return "❌ Envie a transcrição para usar IA", None, f"LLM: {LLM_AVAILABLE}"
         if not LLM_AVAILABLE:
-            return "❌ Configure GEMINI_API_KEY", None, f"LLM: False"
+            return "❌ IA não disponível. Configure GEMINI_API_KEY", None, f"LLM: False"
         with open(txt_file.name, "r", encoding="utf-8") as f:
             transcript = f.read()
     else:
@@ -460,7 +492,7 @@ def process_xml_and_transcript(xml_file, txt_file, use_llm, num_segments,
         out_path = os.path.join(OUTPUT_DIR, f"{base}_EDITADO.xml")
         tree.write(out_path, encoding="utf-8", xml_declaration=True)
         
-        total_duration = sum((s.end_f - s.start_f) / FPS for s in segs)
+        total_duration = get_total_duration(segs)
         
         resumo = f"✂️ {len(segs)} cortes | Duração: {total_duration/60:.1f} min | Modo: {mode}\n\n"
         for i, s in enumerate(segs, 1):
@@ -470,23 +502,36 @@ def process_xml_and_transcript(xml_file, txt_file, use_llm, num_segments,
                 resumo += f"   {s.text[:120]}...\n"
             resumo += "\n"
         
-        status = f"✓ {mode} | Duração: {total_duration/60:.1f} min | LLM: {LLM_AVAILABLE}"
+        status = f"✓ {mode} | Duração total: {total_duration/60:.1f} min | LLM: {LLM_AVAILABLE}"
         return resumo, out_path, status
         
     except Exception as e:
         return f"❌ Erro: {str(e)}", None, f"LLM: {LLM_AVAILABLE}"
 
-# ============ CSS & GRADIO APP ============
+# ============ CSS ============
 css = """
-:root { --primary: #39FF14; --text: #1a1a1a; }
-.gradio-container { font-family: system-ui, sans-serif !important; }
-.gradio-container h1, .gradio-container label { color: var(--text) !important; }
-.gradio-container button.primary { background: var(--primary) !important; color: #000 !important; font-weight: 700 !important; }
+:root {
+    --primary: #39FF14;
+    --text: #1a1a1a;
+    --muted: #6b7280;
+}
+.gradio-container {
+    font-family: system-ui, sans-serif !important;
+}
+.gradio-container h1, .gradio-container label {
+    color: var(--text) !important;
+}
+.gradio-container button.primary {
+    background: var(--primary) !important;
+    color: #000 !important;
+    font-weight: 700 !important;
+}
 """
 
+# ============ GRADIO APP ============
 with gr.Blocks(theme=gr.themes.Soft(), css=css) as demo:
-    gr.Markdown("# Editor XML Premiere - IA")
-    gr.Markdown("Cortes inteligentes com linguagem natural")
+    gr.Markdown("# Agente de Edição XML - Premiere Pro")
+    gr.Markdown("Edite sequências do Premiere com IA ou controle manual")
     
     with gr.Row():
         xml_in = gr.File(label="XML do Premiere", file_types=[".xml"])
@@ -496,34 +541,34 @@ with gr.Blocks(theme=gr.themes.Soft(), css=css) as demo:
         use_llm = gr.Checkbox(label="Usar IA", value=USE_LLM_DEFAULT and LLM_AVAILABLE)
         num_segments = gr.Slider(2, 20, 5, step=1, label="Segmentos (modo automático)")
     
-    with gr.Accordion("IA - Linguagem Natural", open=True):
+    with gr.Accordion("IA - Linguagem Natural (RECOMENDADO)", open=True):
         gr.Markdown("""
-**Exemplos:**
-- "Extraia um corte de 10 minutos começando da parte do tenista"
-- "Crie um corte de 15 minutos com os melhores momentos"
-- "Faça um corte de 5 minutos sobre superação"
+**Use linguagem natural para dar instruções:**
+- "Crie um corte de 10 minutos com os melhores momentos"
+- "Extraia 15 minutos das partes mais engraçadas"
+- "Faça um resumo de 5 minutos sobre superação"
         """)
         natural_instructions = gr.Textbox(
-            label="Instruções",
-            placeholder='Ex: "Extraia um corte de 10 minutos começando da parte do tenista"',
+            label="Instruções para a IA",
+            placeholder='Ex: "Crie um corte de 10 minutos com os melhores momentos distribuídos pelo vídeo"',
             lines=3
         )
     
     with gr.Accordion("Minutagens Manuais", open=False):
         manual_timecodes = gr.Textbox(
-            label="Timecodes exatos",
-            placeholder="00:01:23:15 - 00:02:45:10",
+            label="Timecodes exatos (um por linha)",
+            placeholder="00:01:23:15 - 00:02:45:10\n00:05:30:00 - 00:07:15:22",
             lines=4
         )
     
-    with gr.Accordion("Modo Automático", open=False):
-        custom_keywords = gr.Textbox(label="Palavras-chave")
+    with gr.Accordion("Modo Automático (Palavras-chave)", open=False):
+        custom_keywords = gr.Textbox(label="Palavras-chave personalizadas (separadas por vírgula)")
         with gr.Row():
-            weight_emotion = gr.Slider(0, 5, 2.0, 0.1, label="Emoção")
-            weight_break = gr.Slider(0, 5, 1.5, 0.1, label="Quebra")
+            weight_emotion = gr.Slider(0, 5, 2.0, 0.1, label="Peso: Emoção")
+            weight_break = gr.Slider(0, 5, 1.5, 0.1, label="Peso: Quebra")
         with gr.Row():
-            weight_learn = gr.Slider(0, 5, 1.2, 0.1, label="Aprendizado")
-            weight_viral = gr.Slider(0, 5, 1.0, 0.1, label="Viral")
+            weight_learn = gr.Slider(0, 5, 1.2, 0.1, label="Peso: Aprendizado")
+            weight_viral = gr.Slider(0, 5, 1.0, 0.1, label="Peso: Viral")
     
     run_btn = gr.Button("Processar XML", variant="primary", size="lg")