Update app.py

app.py

@@ -54,19 +54,13 @@ 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(txt: str) -> List[Segment]:
+def parse_transcript_full(txt: str) -> List[Segment]:
+    """Parse transcrição mantendo ranges originais"""
     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_point = re.compile(r"^(\d{2}:\d{2}:\d{2}[:;]\d{2})\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+(.*)$")
     
     for l in lines:
         m = pat_range.match(l)
@@ -79,18 +73,6 @@ def parse_transcript(txt: str) -> List[Segment]:
                     results.append(Segment(s, e, s_f, e_f, text, 0.0))
             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
     
     return results
 
@@ -110,88 +92,12 @@ 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 do usuário"""
-    # Procura por padrões como "10 minutos", "5 min", "15 minutes"
+    """Extrai duração em minutos das instruções"""
     patterns = [
         r"(\d+)\s*minutos?",
         r"(\d+)\s*min\b",
-        r"(\d+)\s*minutes?",
         r"(\d+)m\b"
     ]
     
@@ -202,53 +108,125 @@ 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 selecionar segmentos baseado em instruções"""
+    """Usa IA para processar instruções em linguagem natural"""
     if not LLM_AVAILABLE:
         raise ValueError("IA não disponível. Configure GEMINI_API_KEY")
     
-    total_duration_min = get_total_duration(segs) / 60
+    # Detecta se pede duração específica
     target_duration = extract_duration_from_instructions(instructions)
     
-    # Cria resumo dos segmentos (agrupados para prompt menor)
-    segment_summary = []
+    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 = []
     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])
-        segment_summary.append(f"Grupo {i//5}: [{start_tc}-{end_tc}] ({duration:.0f}s) {combined_text[:200]}")
+        segments_summary.append(f"Grupo {i//5}: [{start_tc}-{end_tc}] {combined_text[:200]}")
     
-    prompt = f"""Você é um editor de vídeo profissional.
-
-INSTRUÇÕES DO USUÁRIO:
-{instructions}
+    prompt = f"""Você é um editor profissional.
 
-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
+INSTRUÇÕES: {instructions}
 
-SEGMENTOS (agrupados de 5 em 5):
-{chr(10).join(segment_summary[:50])}
+SEGMENTOS (agrupados):
+{chr(10).join(segments_summary[:40])}
 
-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."""
+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)"""
 
     try:
-        response = LLM.generate_content(prompt, generation_config={"temperature": 0.4, "max_output_tokens": 500})
+        response = LLM.generate_content(prompt, generation_config={"temperature": 0.4})
         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
@@ -257,36 +235,19 @@ Selecione pelo menos 10-20 grupos para ter duração adequada."""
                 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]
-        
-        # 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 = segs[::step][:num_segments]
         
-        # Mescla segmentos próximos
-        final_segs = merge_close_segments(unique_segs, max_gap_seconds=3.0)
+        selected_segs.sort(key=lambda x: x.start_f)
         
-        final_duration = get_total_duration(final_segs)
-        print(f"✓ Selecionados {len(final_segs)} trechos, duração total: {final_duration/60:.1f} min")
+        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")
         
-        return final_segs
+        return selected_segs[:num_segments * 3]  # Retorna mais segmentos
         
     except Exception as e:
-        print(f"Erro na IA: {e}")
-        raise
+        print(f"Erro: {e}")
+        return segs[:num_segments]
 
 # ============ KEYWORD SCORING ============
 def keyword_score(text: str, custom_keywords: str = "", weights: dict = None) -> float:
@@ -294,10 +255,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", "emocion"]
+    kw_emotion = ["medo", "coragem", "raiva", "chorei", "feliz", "triste"]
     kw_break   = ["nunca", "de repente", "contraintuitivo", "virada"]
-    kw_learn   = ["aprendi", "descobri", "lição", "entendi", "percebi"]
-    kw_viral   = ["segredo", "verdade", "3 passos", "como eu"]
+    kw_learn   = ["aprendi", "descobri", "lição", "entendi"]
+    kw_viral   = ["segredo", "verdade", "3 passos"]
 
     score = 0.0
     for kw in kw_emotion: score += weights["emotion"] if kw in t else 0.0
@@ -310,7 +271,6 @@ 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 ============
@@ -319,7 +279,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 timecodes
+    # Priority 1: Manual
     manual_ranges = parse_manual_timecodes(manual_timecodes)
     if manual_ranges:
         result_segs = []
@@ -338,21 +298,17 @@ def select_segments(transcript_txt: str, use_llm: bool, num_segments: int,
                 print(f"Erro: {e}")
         return result_segs if result_segs else []
     
-    # Priority 2: AI with natural instructions
-    segs = parse_transcript(transcript_txt)
+    # Parse transcript
+    segs = parse_transcript_full(transcript_txt)
     if not segs:
-        raise ValueError("Nenhum trecho encontrado na transcrição")
+        raise ValueError("Nenhum trecho encontrado")
     
+    # 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)
@@ -453,21 +409,20 @@ 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 do Premiere", None, f"LLM: {LLM_AVAILABLE}"
+        return "❌ Envie o XML", 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 para usar IA", None, f"LLM: {LLM_AVAILABLE}"
+            return "❌ Envie a transcrição", None, f"LLM: {LLM_AVAILABLE}"
         if not LLM_AVAILABLE:
-            return "❌ IA não disponível. Configure GEMINI_API_KEY", None, f"LLM: False"
+            return "❌ Configure GEMINI_API_KEY", None, f"LLM: False"
         with open(txt_file.name, "r", encoding="utf-8") as f:
             transcript = f.read()
     else:
@@ -492,7 +447,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 = get_total_duration(segs)
+        total_duration = sum((s.end_f - s.start_f) / FPS for s in segs)
         
         resumo = f"✂️ {len(segs)} cortes | Duração: {total_duration/60:.1f} min | Modo: {mode}\n\n"
         for i, s in enumerate(segs, 1):
@@ -502,36 +457,23 @@ 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: {total_duration/60:.1f} min | LLM: {LLM_AVAILABLE}"
+        status = f"✓ {mode} | Duração: {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 ============
+# ============ CSS & GRADIO APP ============
 css = """
-: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;
-}
+: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; }
 """
 
-# ============ GRADIO APP ============
 with gr.Blocks(theme=gr.themes.Soft(), css=css) as demo:
-    gr.Markdown("# Agente de Edição XML - Premiere Pro")
-    gr.Markdown("Edite sequências do Premiere com IA ou controle manual")
+    gr.Markdown("# Editor XML Premiere - IA")
+    gr.Markdown("Cortes inteligentes com linguagem natural")
     
     with gr.Row():
         xml_in = gr.File(label="XML do Premiere", file_types=[".xml"])
@@ -541,34 +483,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 (RECOMENDADO)", open=True):
+    with gr.Accordion("IA - Linguagem Natural", open=True):
         gr.Markdown("""
-**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"
+**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"
         """)
         natural_instructions = gr.Textbox(
-            label="Instruções para a IA",
-            placeholder='Ex: "Crie um corte de 10 minutos com os melhores momentos distribuídos pelo vídeo"',
+            label="Instruções",
+            placeholder='Ex: "Extraia um corte de 10 minutos começando da parte do tenista"',
             lines=3
         )
     
     with gr.Accordion("Minutagens Manuais", open=False):
         manual_timecodes = gr.Textbox(
-            label="Timecodes exatos (um por linha)",
-            placeholder="00:01:23:15 - 00:02:45:10\n00:05:30:00 - 00:07:15:22",
+            label="Timecodes exatos",
+            placeholder="00:01:23:15 - 00:02:45:10",
             lines=4
         )
     
-    with gr.Accordion("Modo Automático (Palavras-chave)", open=False):
-        custom_keywords = gr.Textbox(label="Palavras-chave personalizadas (separadas por vírgula)")
+    with gr.Accordion("Modo Automático", open=False):
+        custom_keywords = gr.Textbox(label="Palavras-chave")
         with gr.Row():
-            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")
+            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")
         with gr.Row():
-            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")
+            weight_learn = gr.Slider(0, 5, 1.2, 0.1, label="Aprendizado")
+            weight_viral = gr.Slider(0, 5, 1.0, 0.1, label="Viral")
     
     run_btn = gr.Button("Processar XML", variant="primary", size="lg")