Delete app.py

app.py

@@ -1,240 +0,0 @@
-
-import re
-import os
-import xml.etree.ElementTree as ET
-from dataclasses import dataclass
-from typing import List
-import gradio as gr
-
-# Configuration
-FPS = 24
-OUTPUT_DIR = "./Output"
-os.makedirs(OUTPUT_DIR, exist_ok=True)
-
-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}"
-
-@dataclass
-class Segment:
-    start_tc: str
-    end_tc: str
-    start_f: int
-    end_f: int
-    text: str
-    score: float
-
-def parse_transcript(txt: str) -> List[Segment]:
-    lines = [l.strip() for l in txt.splitlines() if l.strip()]
-    results = []
-    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
-                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 select_segments(transcript_txt: str) -> 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)
-    segs.sort(key=lambda x: x.score, reverse=True)
-    k = min(5, max(2, len(segs)))
-    return segs[:k]
-
-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
-
-def process_xml_and_transcript(premiere_xml_file, transcript_txt_file):
-    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
-
-    with open(transcript_txt_file.name, "r", encoding="utf-8") as f:
-        transcript = f.read()
-
-    segments = select_segments(transcript)
-
-    tree = ET.parse(premiere_xml_file.name)
-    tree = edit_sequence_with_segments(tree, segments)
-
-    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(segments, 1):
-        resumo += f"{i}. {s.start_tc} -> {s.end_tc} | {s.end_f - s.start_f} frames | {s.text[:120]}\n"
-
-    return resumo, out_path
-
-demo = gr.Interface(
-    fn=process_xml_and_transcript,
-    inputs=[
-        gr.File(label="XML da sequência do Premiere (FCP XML)", file_types=[".xml"]),
-        gr.File(label="Transcrição (.txt) com timecodes hh:mm:ss:ff", file_types=[".txt"]),
-    ],
-    outputs=[
-        gr.Textbox(label="Resumo dos cortes aplicados"),
-        gr.File(label="Download do XML Editado"),
-    ],
-    title="Agente de Edição XML para Premiere (24 fps)",
-    description=(
-        "Lê a transcrição com timecodes e recria a timeline na mesma sequência, com 2–5 trechos fortes. "
-        "Não cria nova sequência, não adiciona mídias externas e mantém trilhas originais."
-    ),
-    allow_flagging="never",
-)
-
-if __name__ == "__main__":
-    demo.launch()