Upload 5 files

LICENSE

@@ -0,0 +1,22 @@
+
+MIT License
+
+Copyright (c) 2025
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to do so, subject to the
+following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -0,0 +1,37 @@
+
+---
+title: Agente de Edição XML para Premiere
+emoji: 🎬
+colorFrom: blue
+colorTo: purple
+sdk: gradio
+sdk_version: 4.29.0
+app_file: app.py
+pinned: false
+---
+
+# Agente de Edição XML para Premiere (24 fps, com LLM)
+
+Este Space lê uma transcrição com timecodes (hh:mm:ss:ff) e um XML de sequência do Adobe Premiere (FCP XML), seleciona de 2 a 5 trechos "fortes" com ajuda de **LLM (Gemini)** e recria a timeline usando apenas esses cortes, mantendo áudio e vídeo sincronizados — sem criar nova `<sequence>` e sem adicionar mídias externas.
+
+## Como usar
+1. Envie **o XML (FCP XML) da sequência** exportado do Premiere.
+2. Envie **um `.txt` com a transcrição**, em que cada linha pode ser:
+   - `hh:mm:ss:ff - hh:mm:ss:ff Texto...`
+   - `[hh:mm:ss:ff - hh:mm:ss:ff] Texto...`
+   - `hh:mm:ss:ff Texto...` (assume janela ~4s).
+3. (Opcional) Marque **Usar LLM (Gemini)** para seleção semântica dos trechos.
+4. Baixe o **XML editado**.
+
+## LLM (Gemini)
+- Configure a variável de ambiente **GEMINI_API_KEY** no Space (Settings → Repository secrets) para ativar o LLM.
+- Se o LLM não estiver disponível, o app **usa heurística local** (palavras‑chave de emoção/quebra/aprendizado/viralização) e segue idêntico no restante do pipeline.
+
+## Detalhes
+- Base temporal: **24 fps** (`timebase=24`, `ntsc=FALSE` forçados).
+- Edita **a mesma `<sequence>`**, limpa clipitems originais e recria somente os cortes escolhidos, preservando trilhas e referências de arquivo.
+- Espera estrutura padrão: `media/video/track` e `media/audio/track`, cada um contendo ao menos um `clipitem` de referência.
+- Em projetos multicam/multitrilha complexos, ajuste a função que seleciona o `clipitem` molde.
+
+## Licença
+MIT

app.py

@@ -0,0 +1,286 @@
+
+import os
+import re
+import xml.etree.ElementTree as ET
+from dataclasses import dataclass
+from typing import List
+import gradio as gr
+
+# Optional LLM (Gemini)
+USE_LLM_DEFAULT = True  # default checked
+GEMINI_API_KEY = os.getenv("GEMINI_API_KEY", "").strip()
+
+LLM_AVAILABLE = False
+LLM_MODEL_NAME = "gemini-2.5-flash"
+try:
+    if GEMINI_API_KEY:
+        import google.generativeai as genai
+        genai.configure(api_key=GEMINI_API_KEY)
+        LLM = genai.GenerativeModel(LLM_MODEL_NAME)
+        LLM_AVAILABLE = True
+    else:
+        LLM = None
+except Exception:
+    LLM = None
+    LLM_AVAILABLE = False
+
+# Config
+FPS = 24
+OUTPUT_DIR = "./Output"
+os.makedirs(OUTPUT_DIR, exist_ok=True)
+
+@dataclass
+class Segment:
+    start_tc: str
+    end_tc: str
+    start_f: int
+    end_f: int
+    text: str
+    score: float
+
+# ---- Timecode helpers ----
+def parse_timecode_to_frames(tc: str, fps: int = FPS) -> int:
+    m = re.match(r"^\s*(\d{2}):(\d{2}):(\d{2})[:;](\d{2})\s*$", tc)
+    if not m:
+        raise ValueError(f"Invalid timecode: {tc}")
+    hh, mm, ss, ff = map(int, m.groups())
+    return hh*3600*fps + mm*60*fps + ss*fps + ff
+
+def frames_to_timecode(frames: int, fps: int = FPS) -> str:
+    hh = frames // (3600*fps)
+    rem = frames % (3600*fps)
+    mm = rem // (60*fps)
+    rem = rem % (60*fps)
+    ss = rem // fps
+    ff = rem % fps
+    return f"{hh:02d}:{mm:02d}:{ss:02d}:{ff:02d}"
+
+# ---- Transcript parsing & scoring ----
+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_point = re.compile(r"^(\d{2}:\d{2}:\d{2}[:;]\d{2})\s+(.*)$")
+    for l in lines:
+        m = pat_range.match(l)
+        if m:
+            s, e, text = m.groups()
+            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:
+                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  # default window
+                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:
+    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"]
+    kw_learn   = ["aprendi", "descobri", "lição", "entendi", "percebi", "insight", "melhorou", "piorou"]
+    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
+    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."""
+    if not LLM_AVAILABLE:
+        return candidates
+    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}"
+    )
+    try:
+        r = LLM.generate_content(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:
+            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]:
+    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
+    segs.sort(key=lambda x: x.score, reverse=True)
+    top = segs[:12]
+    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)))]
+
+# ---- XML editing ----
+def get_sequence(root: ET.Element) -> ET.Element:
+    seq = root.find(".//sequence")
+    if seq is None:
+        raise ValueError("Nenhuma <sequence> encontrada no XML.")
+    return seq
+
+def ensure_rate_24fps(element: ET.Element):
+    rate = element.find("./rate")
+    if rate is None:
+        rate = ET.SubElement(element, "rate")
+    tb = rate.find("timebase")
+    if tb is None:
+        tb = ET.SubElement(rate, "timebase")
+    tb.text = str(FPS)
+    ntsc = rate.find("ntsc")
+    if ntsc is None:
+        ntsc = ET.SubElement(rate, "ntsc")
+    ntsc.text = "FALSE"
+
+def deep_copy(elem: ET.Element) -> ET.Element:
+    new = ET.Element(elem.tag, attrib=elem.attrib)
+    new.text = elem.text
+    new.tail = elem.tail
+    for child in list(elem):
+        new.append(deep_copy(child))
+    return new
+
+def clear_clipitems(track_elem: ET.Element):
+    for ci in list(track_elem.findall("./clipitem")):
+        track_elem.remove(ci)
+
+def first_clipitem_ref(track_elem: ET.Element):
+    return track_elem.find("./clipitem")
+
+def copy_file_ref(from_clip: ET.Element, to_clip: ET.Element):
+    src_file = from_clip.find("./file")
+    if src_file is not None:
+        old = to_clip.find("./file")
+        if old is not None:
+            to_clip.remove(old)
+        to_clip.append(deep_copy(src_file))
+
+def build_clipitem(template_ci: ET.Element, cid: str, start_f: int, end_f: int, in_f: int, out_f: int, linked_ids):
+    ci = ET.Element("clipitem", {"id": cid})
+    name = template_ci.find("name")
+    ci_name = ET.SubElement(ci, "name")
+    ci_name.text = name.text if name is not None else cid
+
+    rate = template_ci.find("rate")
+    ci.append(deep_copy(rate) if rate is not None else ET.Element("rate"))
+    ensure_rate_24fps(ci)
+
+    for tag, val in [("start", start_f), ("end", end_f), ("in", in_f), ("out", out_f)]:
+        t = ET.SubElement(ci, tag)
+        t.text = str(val)
+
+    copy_file_ref(template_ci, ci)
+
+    for lid in linked_ids:
+        link = ET.SubElement(ci, "link")
+        linkclipref = ET.SubElement(link, "linkclipref")
+        linkclipref.text = lid
+        mediatype = ET.SubElement(link, "mediatype")
+        mediatype.text = "video" if "-v" in lid else "audio"
+    return ci
+
+def edit_sequence_with_segments(tree: ET.ElementTree, segs: List[Segment]) -> ET.ElementTree:
+    root = tree.getroot()
+    seq = get_sequence(root)
+    ensure_rate_24fps(seq)
+
+    video_track = seq.find("./media/video/track")
+    audio_track = seq.find("./media/audio/track")
+
+    if video_track is None or audio_track is None:
+        raise ValueError("Estrutura de trilhas não encontrada (esperado media/video/track e media/audio/track).")
+
+    v_tpl = first_clipitem_ref(video_track)
+    a_tpl = first_clipitem_ref(audio_track)
+    if v_tpl is None or a_tpl is None:
+        raise ValueError("Não há clipitem de referência em V1 e/ou A1.")
+
+    clear_clipitems(video_track)
+    clear_clipitems(audio_track)
+
+    cursor = 0
+    for idx, s in enumerate(segs, start=1):
+        dur = s.end_f - s.start_f
+        start = cursor
+        end   = cursor + dur
+
+        v_id = f"clipitem-v-cut{idx}"
+        a_id = f"clipitem-a-cut{idx}"
+
+        v_ci = build_clipitem(v_tpl, v_id, start, end, s.start_f, s.end_f, [a_id])
+        a_ci = build_clipitem(a_tpl, a_id, start, end, s.start_f, s.end_f, [v_id])
+
+        video_track.append(v_ci)
+        audio_track.append(a_ci)
+
+        cursor = end
+
+    return tree
+
+# ---- Gradio app ----
+def process_xml_and_transcript(premiere_xml_file, transcript_txt_file, use_llm):
+    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)
+
+    tree = ET.parse(premiere_xml_file.name)
+    tree = edit_sequence_with_segments(tree, segs)
+
+    base = os.path.splitext(os.path.basename(premiere_xml_file.name))[0]
+    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"
+    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"
+
+    status = f"LLM disponível: {LLM_AVAILABLE} | LLM ligado na UI: {use_llm}"
+    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.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])
+
+if __name__ == "__main__":
+    demo.launch()

huggingface.yaml

@@ -0,0 +1,5 @@
+
+sdk: gradio
+sdk_version: 4.29.0
+python_version: 3.10
+app_file: app.py

requirements.txt

@@ -0,0 +1,3 @@
+
+gradio>=4.29.0
+google-generativeai>=0.7.0