Upload 6 files

README.md

@@ -1,13 +1,25 @@
----
-title: EditorCortes
-emoji: 🚀
-colorFrom: yellow
-colorTo: yellow
-sdk: gradio
-sdk_version: 5.47.2
-app_file: app.py
-pinned: false
-short_description: Edita cortes para qualquer lugar
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+
+# Editor de cortes automático — Hugging Face Space
+
+Esta é a versão web (Gradio) do seu app de **Editor de cortes**. Ela reusa a mesma lógica de transcrição (faster-whisper) e exportação com `ffmpeg-python`, mas sem Qt.
+
+## Como usar no Spaces
+1. Crie um novo Space (tipo **Gradio**).
+2. Faça upload destes arquivos na raiz do Space:
+   - `app.py`
+   - `core.py`
+   - `requirements.txt`
+   - `packages.txt`
+3. (Opcional) Se quiser GPU, defina o hardware do Space como **T4** ou superior nas configurações.
+4. Clique em **Restart** / **Deploy**.
+
+## Uso
+- Envie um vídeo (`.mp4`, `.mov`, `.mkv`, `.avi`).
+- Clique em **Transcrever**.
+- Gere **Cortes simples** ou **Criativos** com os parâmetros desejados.
+- Os arquivos finais aparecem para download.
+
+## Observações
+- `packages.txt` instala `ffmpeg` no contêiner do Space.
+- `requirements.txt` inclui `gradio`, `faster-whisper`, `sentence-transformers`, `torch` etc.
+- Para melhor desempenho de `faster-whisper`, use **GPU**.

app.py

@@ -0,0 +1,92 @@
+
+import gradio as gr
+from pathlib import Path
+import shutil
+import os
+from core import transcribe, generate_linear_cuts, generate_creative_cuts, Segment
+
+SPACE_OUT = Path("outputs"); SPACE_OUT.mkdir(exist_ok=True, parents=True)
+
+def do_transcribe(video_file, model_size):
+    if video_file is None:
+        return [], "Selecione um vídeo."
+    segs = transcribe(video_file, model_size=model_size)
+    # show a small preview of transcript
+    preview = "\n".join([f"[{s.start:.1f}–{s.end:.1f}] {s.text}" for s in segs[:12]])
+    return segs, f"Transcrição ok. Segmentos: {len(segs)}\n\nPrévia:\n{preview}"
+
+def run_linear(segs, video_file, out_subdir, min_len, max_len, ideal_len, k, gap, pad, ar_mode):
+    if not segs:
+        return [], "Transcreva antes de cortar."
+    workdir = SPACE_OUT / (out_subdir or "cortes")
+    outs = generate_linear_cuts(video_file, segs, str(workdir),
+                                min_len=min_len, max_len=max_len, ideal_len=ideal_len,
+                                k=k, gap_threshold=gap, pad=pad, ar_mode=ar_mode)
+    links = [str(Path(p)) for p in outs]
+    return links, f"Gerados: {len(links)} arquivo(s)."
+
+def run_creative(segs, video_file, out_subdir, min_len, max_len, ideal_len, minb, maxb, k, gap, pad, ar_mode):
+    if not segs:
+        return [], "Transcreva antes de cortar."
+    workdir = SPACE_OUT / (out_subdir or "cortes")
+    outs = generate_creative_cuts(video_file, segs, str(workdir),
+                                  min_len=min_len, max_len=max_len, ideal_len=ideal_len,
+                                  min_blocks=minb, max_blocks=maxb,
+                                  k=k, gap_threshold=gap, pad=pad, ar_mode=ar_mode)
+    links = [str(Path(p)) for p in outs]
+    return links, f"Gerados: {len(links)} arquivo(s)."
+
+with gr.Blocks(title="Editor de cortes automático — Space") as demo:
+    gr.Markdown("# Editor de cortes automático — Space (Gradio)\nDo desktop para o navegador. Carregue um vídeo, transcreva e gere cortes simples ou criativos.")
+    with gr.Row():
+        with gr.Column(scale=1):
+            video = gr.Video(label="Vídeo de entrada", interactive=True)
+            model_size = gr.Dropdown(choices=["tiny","base","small","medium"], value="small", label="Modelo Whisper")
+            out_subdir = gr.Textbox(label="Subpasta de saída", value="editor_de_cortes_automatico")
+            transcribe_btn = gr.Button("1) Transcrever", variant="primary")
+            transcript_preview = gr.Textbox(label="Status / Prévia", lines=10)
+        with gr.Column(scale=1):
+            with gr.Tab("Cortes simples"):
+                min_len = gr.Number(value=600, label="Mín (s)")
+                max_len = gr.Number(value=900, label="Máx (s)")
+                ideal_len = gr.Number(value=900, label="Ideal (s)")
+                k = gr.Number(value=2, label="Qtd cortes")
+                gap = gr.Number(value=0.60, label="Gap (s)")
+                pad = gr.Number(value=0.08, label="Pad (s)")
+                ar_mode = gr.Dropdown(choices=["Original","Vertical 9:16","Quadrado 1:1","Retrato 4:5"], value="Original", label="Formato")
+                go_linear = gr.Button("2) Gerar cortes simples")
+                out_linear = gr.Files(label="Arquivos gerados (simples)")
+                status_linear = gr.Textbox(label="Status", lines=2)
+            with gr.Tab("Cortes criativos"):
+                minb = gr.Number(value=3, label="Blocos min")
+                maxb = gr.Number(value=8, label="Blocos máx")
+                k2 = gr.Number(value=2, label="Qtd cortes")
+                gap2 = gr.Number(value=0.60, label="Gap (s)")
+                pad2 = gr.Number(value=0.08, label="Pad (s)")
+                ar_mode2 = gr.Dropdown(choices=["Original","Vertical 9:16","Quadrado 1:1","Retrato 4:5"], value="Original", label="Formato")
+                go_creative = gr.Button("3) Gerar cortes criativos")
+                out_creative = gr.Files(label="Arquivos gerados (criativos)")
+                status_creative = gr.Textbox(label="Status", lines=2)
+
+    segs_state = gr.State([])
+
+    transcribe_btn.click(
+        do_transcribe,
+        inputs=[video, model_size],
+        outputs=[segs_state, transcript_preview],
+    )
+
+    go_linear.click(
+        run_linear,
+        inputs=[segs_state, video, out_subdir, min_len, max_len, ideal_len, k, gap, pad, ar_mode],
+        outputs=[out_linear, status_linear],
+    )
+
+    go_creative.click(
+        run_creative,
+        inputs=[segs_state, video, out_subdir, min_len, max_len, ideal_len, minb, maxb, k2, gap2, pad2, ar_mode2],
+        outputs=[out_creative, status_creative],
+    )
+
+if __name__ == "__main__":
+    demo.launch()

core.py

@@ -0,0 +1,443 @@
+
+from __future__ import annotations
+import os
+from dataclasses import dataclass
+from pathlib import Path
+from typing import List, Tuple, Dict, Any
+
+import numpy as np
+
+# Third-party deps
+try:
+    import ffmpeg  # ffmpeg-python
+except Exception as e:
+    ffmpeg = None
+try:
+    from faster_whisper import WhisperModel
+except Exception as e:
+    WhisperModel = None
+
+# -------- Data structures --------
+@dataclass
+class Segment:
+    start: float
+    end: float
+    text: str
+    conf: float
+
+@dataclass
+class ClipCandidate:
+    start: float
+    end: float
+    score: float
+    text: str
+
+# -------- Heuristics (same as desktop) --------
+KEYWORDS_HOOK = [
+    "segredo", "ninguém te conta", "o erro", "o truque", "como", "aprendi",
+    "descobri", "vale ouro", "a verdade", "você precisa", "atenção", "não faça", "vou te falar"
+]
+KEYWORDS_PAYOFF = [
+    "portanto", "então", "resultado", "conclusão", "resumo", "é por isso", "fica assim",
+    "no final", "o ponto é", "por fim", "pra encerrar"
+]
+
+def chunk_sentences(segments: List[Segment], max_gap: float = 0.7, max_len: float = 45.0):
+    blocks = []
+    cur = {"start": None, "end": None, "text": []}
+    for s in segments:
+        if cur["start"] is None:
+            cur["start"] = s.start; cur["end"] = s.end; cur["text"] = [s.text]
+        else:
+            gap = s.start - cur["end"]
+            if gap <= max_gap and (s.end - cur["start"]) <= max_len:
+                cur["end"] = s.end; cur["text"].append(s.text)
+            else:
+                blocks.append({"start": float(cur["start"]), "end": float(cur["end"]), "text": " ".join(cur["text"]).strip()})
+                cur = {"start": s.start, "end": s.end, "text": [s.text]}
+    if cur["start"] is not None:
+        blocks.append({"start": float(cur["start"]), "end": float(cur["end"]), "text": " ".join(cur["text"]).strip()})
+    return blocks
+
+def score_hook(txt: str) -> float:
+    low = txt.lower(); s = 0.0
+    for w in KEYWORDS_HOOK:
+        if w in low: s += 1.0
+    s += 0.3 * low.count("!")
+    if "?" in low: s += 0.5
+    if len(low.split()) <= 22: s += 0.6
+    return s
+
+def score_payoff(txt: str) -> float:
+    low = txt.lower(); s = 0.0
+    for w in KEYWORDS_PAYOFF:
+        if w in low: s += 1.0
+    return s
+
+# -------- VideoExport helpers (ffmpeg) --------
+class VideoExport:
+    @staticmethod
+    def vf_for_mode(ar_mode: str) -> str | None:
+        if not ar_mode or "Original" in ar_mode:
+            return None
+        if "9:16" in ar_mode:
+            return "crop=floor(ih*9/16):ih:(iw-floor(ih*9/16))/2:0,scale=1080:1920"
+        if "1:1" in ar_mode or "Quadrado" in ar_mode:
+            return "crop=min(iw\\,ih):min(iw\\,ih):(iw-min(iw\\,ih))/2:(ih-min(iw\\,ih))/2,scale=1080:1080"
+        if "4:5" in ar_mode or "Retrato" in ar_mode:
+            return "crop=floor(ih*4/5):ih:(iw-floor(ih*4/5))/2:0,scale=1080:1350"
+        return None
+
+    @staticmethod
+    def tighten_parts(segments: List[Segment], start: float, end: float,
+                      gap_threshold: float = 0.6, pad: float = 0.08):
+        segs = [s for s in segments if s.end > start and s.start < end]
+        if not segs:
+            return [(start, max(start + 0.5, end))]
+        trimmed = []
+        for s in segs:
+            s0 = max(start, float(s.start)); s1 = min(end, float(s.end))
+            if s1 > s0: trimmed.append((s0, s1))
+        if not trimmed:
+            return [(start, max(start + 0.5, end))]
+        parts = []
+        cur_s, cur_e = trimmed[0][0] - pad, trimmed[0][1] + pad
+        cur_s = max(start, cur_s)
+        for (a0, a1), (b0, b1) in zip(trimmed[:-1], trimmed[1:]):
+            gap = b0 - a1
+            if gap <= gap_threshold:
+                cur_e = b1 + pad
+            else:
+                cur_e = min(end, max(cur_e, cur_s + 0.25))
+                parts.append((cur_s, cur_e))
+                cur_s = max(start, b0 - pad)
+                if parts and cur_s < parts[-1][1]:
+                    cur_s = parts[-1][1] + 0.01
+                cur_e = b1 + pad
+        cur_e = min(end, max(cur_e, cur_s + 0.25))
+        parts.append((cur_s, cur_e))
+        sane = []
+        for s, e in parts:
+            s = max(start, s); e = min(end, e)
+            if e > s + 0.05: sane.append((s, e))
+        if not sane:
+            sane = [(start, max(start + 0.5, end))]
+        return sane
+
+    @staticmethod
+    def export_part(src: str, start: float, end: float, out_path: str, ar_mode: str = "Original"):
+        if ffmpeg is None:
+            raise RuntimeError("ffmpeg-python não instalado")
+        s = max(0.0, float(start)); e = max(float(end), s + 0.25); dur = max(0.25, e - s)
+        vf = VideoExport.vf_for_mode(ar_mode)
+        inp = ffmpeg.input(src, ss=s)
+        if vf:
+            stream = inp.output(
+                out_path, t=dur, vcodec="libx264", acodec="aac",
+                video_bitrate="4000k", audio_bitrate="160k",
+                vf=vf, movflags="+faststart"
+            )
+        else:
+            stream = inp.output(
+                out_path, t=dur, vcodec="libx264", acodec="aac",
+                video_bitrate="4000k", audio_bitrate="160k",
+                movflags="+faststart"
+            )
+        (stream.overwrite_output().global_args("-loglevel", "error").run())
+
+    @staticmethod
+    def concat_parts(part_paths: List[str], out_path: str, reencode_if_needed: bool = False):
+        if ffmpeg is None:
+            raise RuntimeError("ffmpeg-python não instalado")
+        import tempfile
+        with tempfile.NamedTemporaryFile("w", delete=False, suffix=".txt", encoding="utf-8", newline="\n") as f:
+            for p in part_paths:
+                safe = Path(p).resolve().as_posix().replace("'", r"\'")
+                f.write(f"file '{safe}'\n")
+            list_path = f.name
+        inp = ffmpeg.input(list_path, format="concat", safe=0)
+        out = (inp.output(out_path, vcodec="libx264", acodec="aac", movflags="+faststart")
+               if reencode_if_needed else
+               inp.output(out_path, c="copy", movflags="+faststart"))
+        (out.overwrite_output().global_args("-loglevel", "error").run())
+
+    @staticmethod
+    def export_tightened_clip(src: str, segments: List[Segment],
+                              start: float, end: float, out_path: str,
+                              gap_threshold: float = 0.6, pad: float = 0.08,
+                              tmp_dir: str | None = None,
+                              ar_mode: str = "Original"):
+        if ffmpeg is None:
+            raise RuntimeError("ffmpeg-python não instalado")
+        base_tmp = Path(tmp_dir or Path(out_path).parent).resolve()
+        base_tmp.mkdir(parents=True, exist_ok=True)
+        parts = VideoExport.tighten_parts(segments, start, end, gap_threshold=gap_threshold, pad=pad)
+        part_paths = []
+        for i, (s, e) in enumerate(parts, 1):
+            tmp = (base_tmp / f"_tmp_{Path(out_path).stem}_{i:03d}.mp4").resolve().as_posix()
+            VideoExport.export_part(src, s, e, tmp, ar_mode=ar_mode)
+            part_paths.append(tmp)
+        try:
+            VideoExport.concat_parts(part_paths, Path(out_path).resolve().as_posix(), reencode_if_needed=False)
+        except Exception:
+            VideoExport.concat_parts(part_paths, Path(out_path).resolve().as_posix(), reencode_if_needed=True)
+        for p in part_paths:
+            try: os.remove(p)
+            except Exception: pass
+
+# -------- Transcription --------
+def transcribe(video_path: str, model_size: str = "small") -> List[Segment]:
+    if WhisperModel is None:
+        raise RuntimeError("faster-whisper não está instalado.")
+    model = WhisperModel(model_size, device="cuda" if _has_cuda() else "cpu")
+    segments, info = model.transcribe(video_path, language="pt", vad_filter=False)
+    result = []
+    import numpy as np
+    for seg in segments:
+        conf = getattr(seg, "avg_logprob", None)
+        if conf is None: conf = -0.5
+        conf = float(np.clip(conf, -1, 1))
+        result.append(Segment(seg.start, seg.end, seg.text.strip(), conf))
+    return result
+
+def _has_cuda():
+    try:
+        import torch
+        return torch.cuda.is_available()
+    except Exception:
+        return False
+
+# -------- Linear cuts --------
+def generate_linear_cuts(src_path: str, segments: List[Segment], out_dir: str,
+                         min_len: int = 600, max_len: int = 900, ideal_len: int = 900,
+                         k: int = 3, gap_threshold: float = 0.6, pad: float = 0.08,
+                         ar_mode: str = "Original") -> list[str]:
+    outdir = Path(out_dir); outdir.mkdir(parents=True, exist_ok=True)
+    clips = _generate_candidates(segments, float(min_len), float(max_len), float(ideal_len))
+    if not clips:
+        return []
+    top = _select_top(clips, k=int(k))
+    outputs = []
+    for idx, clip in enumerate(top, 1):
+        out_path = outdir / f"simples_{idx:02d}.mp4"
+        VideoExport.export_tightened_clip(src_path, segments, clip.start, clip.end, str(out_path),
+                                          gap_threshold=float(gap_threshold), pad=float(pad),
+                                          tmp_dir=str(outdir), ar_mode=ar_mode)
+        outputs.append(str(out_path))
+    return outputs
+
+def _generate_candidates(segs: List[Segment], min_len: float, max_len: float, ideal_len: float) -> List[ClipCandidate]:
+    clips: List[ClipCandidate] = []
+    n = len(segs)
+    for i in range(n):
+        start = segs[i].start
+        text_parts, confs = [], []
+        end = start
+        for j in range(i, n):
+            end = segs[j].end
+            dur = end - start
+            if dur > max_len: break
+            text_parts.append(segs[j].text); confs.append(segs[j].conf)
+            if dur >= min_len:
+                t = " ".join(text_parts)
+                score = _score_text(t) + (float(np.mean(confs)) if confs else 0.0)
+                gap = segs[j+1].start - segs[j].end if j + 1 < n else 0.0
+                if gap >= 0.6: score += 0.3
+                ideal = 1.0 - abs((dur - ideal_len) / max(ideal_len, 1.0))
+                score += 0.4 * ideal
+                clips.append(ClipCandidate(start, end, float(score), t))
+    return clips
+
+def _score_text(t: str) -> float:
+    low = t.lower(); s = 0.0
+    for w in KEYWORDS_HOOK:
+        if w in low: s += 0.6
+    for w in ["resultado", "portanto", "então", "conclus", "resumo"]:
+        if w in low: s += 0.3
+    s += 0.2 * low.count("!")
+    s += 0.1 * sum(ch.isdigit() for ch in low)
+    if low.strip().startswith(("como ", "por que", "o que", "qual ", "você ", "descobri", "aprendi")):
+        s += 0.4
+    return s
+
+def _select_top(clips: List[ClipCandidate], k: int = 8) -> List[ClipCandidate]:
+    clips = sorted(clips, key=lambda c: c.score, reverse=True)
+    selected: List[ClipCandidate] = []
+    for c in clips:
+        if len(selected) >= k: break
+        if all(_iou_1d((c.start, c.end), (s.start, s.end)) < 0.3 for s in selected):
+            selected.append(c)
+    return selected
+
+def _iou_1d(a: Tuple[float, float], b: Tuple[float, float]) -> float:
+    s1, e1 = a; s2, e2 = b
+    inter = max(0.0, min(e1, e2) - max(s1, s2))
+    uni = (e1 - s1) + (e2 - s2) - inter
+    return inter / uni if uni > 0 else 0.0
+
+# -------- Creative cuts (non-linear) --------
+def generate_creative_cuts(src_path: str, segments: List[Segment], out_dir: str,
+                           min_len: int = 600, max_len: int = 900, ideal_len: int = 900,
+                           min_blocks: int = 3, max_blocks: int = 8,
+                           k: int = 2, gap_threshold: float = 0.6, pad: float = 0.08,
+                           ar_mode: str = "Original") -> list[str]:
+    from sentence_transformers import SentenceTransformer
+    outdir = Path(out_dir); outdir.mkdir(parents=True, exist_ok=True)
+
+    blocks = chunk_sentences(segments, max_gap=0.7, max_len=45.0)
+    if len(blocks) < int(min_blocks):
+        return []
+
+    embedder = SentenceTransformer("all-MiniLM-L6-v2")
+    emb = embedder.encode([b['text'] for b in blocks], show_progress_bar=False, normalize_embeddings=True)
+    emb = np.asarray(emb, dtype=np.float32)
+
+    hook_scores = np.array([score_hook(b['text']) for b in blocks], dtype=float)
+    payoff_scores = np.array([score_payoff(b['text']) for b in blocks], dtype=float)
+
+    sequences = _assemble_sequences(blocks, emb, hook_scores, payoff_scores,
+                                    min_len=float(min_len), max_len=float(max_len), ideal_len=float(ideal_len),
+                                    max_blocks=int(max_blocks))
+    outputs = []
+    if not sequences:
+        # Fallback greedy
+        outs = _fallback_beam_greedy(outdir, blocks, emb, hook_scores, segments, src_path,
+                                     gap_threshold=float(gap_threshold), pad=float(pad), ar_mode=ar_mode,
+                                     max_len=float(max_len))
+        return outs
+
+    for idx, seq in enumerate(sequences[: int(k)], 1):
+        out_path = outdir / f"criativo_{idx:02d}.mp4"
+        part_paths = []
+        for j, b in enumerate(seq, 1):
+            s, e = float(b["start"]), float(b["end"])
+            tmp = (outdir / f"_tmp_comp{idx:02d}_{j:03d}.mp4").resolve().as_posix()
+            VideoExport.export_tightened_clip(src_path, segments, s, e, tmp,
+                                              gap_threshold=float(gap_threshold), pad=float(pad),
+                                              tmp_dir=str(outdir), ar_mode=ar_mode)
+            part_paths.append(tmp)
+        try:
+            VideoExport.concat_parts(part_paths, out_path.resolve().as_posix(), reencode_if_needed=False)
+        except Exception:
+            VideoExport.concat_parts(part_paths, out_path.resolve().as_posix(), reencode_if_needed=True)
+        for p in part_paths:
+            try: os.remove(p)
+            except Exception: pass
+        outputs.append(str(out_path))
+    return outputs
+
+# --- internal helpers for creative ---
+def _assemble_sequences(blocks: List[Dict[str, Any]], emb: np.ndarray,
+                        hook_scores: np.ndarray, payoff_scores: np.ndarray,
+                        min_len: float, max_len: float, ideal_len: float, max_blocks: int):
+    N = len(blocks)
+    idx_sorted = np.argsort(-hook_scores)
+    top_ganchos = idx_sorted[: max(5, N // 10)]
+    sequences = []
+    W_HOOK, W_SIM, W_PAY, W_IDEAL, W_DIVER = 1.2, 1.0, 0.9, 0.5, 0.2
+
+    for h in top_ganchos:
+        init = ([h], blocks[h]["end"] - blocks[h]["start"], W_HOOK * hook_scores[h])
+        beam = [init]
+        for _ in range(max_blocks - 1):
+            new_beam = []
+            for inds, dur, sc in beam:
+                unused = [i for i in range(N) if i not in inds]
+                if not unused: new_beam.append((inds, dur, sc)); continue
+                last = inds[-1]; last_end = blocks[last]["end"]
+                v_last = emb[last]
+                sims = emb[unused] @ v_last
+                cand_order = np.argsort(-sims)[:20]
+                for cpos in cand_order:
+                    j = unused[cpos]; b = blocks[j]
+                    jump = abs(b["start"] - last_end)
+                    if b["start"] >= last_end and jump < 30.0:  # anti-linear
+                        continue
+                    d_add = b["end"] - b["start"]; dur2 = dur + d_add
+                    if dur2 > max_len: continue
+                    pen = 0.0
+                    if b["start"] >= last_end and (b["start"] - last_end) <= 20.0:
+                        pen += 0.9
+                    elif b["start"] >= last_end and (b["start"] - last_end) <= 40.0:
+                        pen += 0.4
+                    diversity = 0.0
+                    if len(inds) >= 2:
+                        prev = blocks[inds[-2]]
+                        jump_prev = abs(blocks[last]["start"] - prev["end"])
+                        if abs(jump - jump_prev) > 10.0: diversity = 1.0
+                    gain = W_SIM * float(sims[cpos]) + W_DIVER * diversity - pen
+                    new_beam.append((inds + [j], dur2, sc + gain))
+            new_beam.sort(key=lambda x: x[2], reverse=True)
+            beam = new_beam[:20]
+
+        finished = []
+        for inds, dur, sc in beam:
+            unused = [i for i in range(N) if i not in inds]
+            best_end = (inds, dur, sc)
+            for j in unused:
+                b = blocks[j]; last = inds[-1]; last_end = blocks[last]["end"]
+                jump = abs(b["start"] - last_end)
+                if b["start"] >= last_end and jump < 30.0: continue
+                d_add = b["end"] - b["start"]
+                if dur + d_add > max_len: continue
+                sc2 = sc + W_PAY * payoff_scores[j]
+                cand = (inds + [j], dur + d_add, sc2)
+                if cand[1] >= min_len and cand[2] > best_end[2]: best_end = cand
+            dur_eff = best_end[1]
+            ideal = 1.0 - abs((dur_eff - ideal_len) / max(ideal_len, 1.0))
+            finished.append((best_end[0], best_end[1], best_end[2] + W_IDEAL * ideal))
+
+        for inds, dur, sc in sorted(finished, key=lambda x: x[2], reverse=True)[:3]:
+            if dur < min_len or dur > max_len: continue
+            sequences.append([blocks[i] for i in inds])
+
+    uniq, seen = [], set()
+    for seq in sequences:
+        key = tuple((round(b["start"], 1), round(b["end"], 1)) for b in seq)
+        if key in seen: continue
+        seen.add(key); uniq.append(seq)
+    return uniq
+
+def _fallback_beam_greedy(outdir: Path, blocks: List[dict], emb: np.ndarray, hook_scores: np.ndarray,
+                          segments: List[Segment], src_path: str,
+                          gap_threshold: float, pad: float, ar_mode: str, max_len: float) -> list[str]:
+    outputs = []
+    if len(blocks) == 0: return outputs
+    h = int(np.argmax(hook_scores))
+    used = {h}; seq = [blocks[h]]
+    dur = float(blocks[h]['end'] - blocks[h]['start'])
+    while dur < max_len and len(seq) < 8:
+        last_idx = blocks.index(seq[-1]); last_end = blocks[last_idx]["end"]
+        sims = emb @ emb[last_idx]; order = np.argsort(-sims)
+        picked = None
+        for j in order:
+            if j in used: continue
+            b = blocks[j]
+            if b["start"] >= last_end:
+                jump = b["start"] - last_end
+                if jump < 30.0: continue
+            d_add = b["end"] - b["start"]
+            if dur + d_add <= max_len:
+                picked = j; break
+        if picked is None: break
+        used.add(picked); seq.append(blocks[picked])
+        dur += float(blocks[picked]['end'] - blocks[picked]['start'])
+    if dur < 60:  # require minimum 1 min to avoid trivially short outputs
+        return outputs
+    out_path = outdir / "Corte criativo.mp4"
+    part_paths = []
+    for j, b in enumerate(seq, 1):
+        s, e = float(b['start']), float(b['end'])
+        tmp = (outdir / f"_tmp_greedy_{j:03d}.mp4").resolve().as_posix()
+        VideoExport.export_tightened_clip(src_path, segments, s, e, tmp,
+                                          gap_threshold=float(gap_threshold), pad=float(pad),
+                                          tmp_dir=str(outdir), ar_mode=ar_mode)
+        part_paths.append(tmp)
+    try:
+        VideoExport.concat_parts(part_paths, out_path.resolve().as_posix(), reencode_if_needed=False)
+    except Exception:
+        VideoExport.concat_parts(part_paths, out_path.resolve().as_posix(), reencode_if_needed=True)
+    for p in part_paths:
+        try: os.remove(p)
+        except Exception: pass
+    outputs.append(str(out_path)); return outputs

huggingface.yaml

@@ -0,0 +1,10 @@
+{
+  "title": "Editor de cortes autom\u00e1tico (Space)",
+  "emoji": "\ud83c\udfac",
+  "colorFrom": "green",
+  "colorTo": "gray",
+  "sdk": "gradio",
+  "sdk_version": "4.44.0",
+  "app_file": "app.py",
+  "pinned": false
+}

packages.txt

@@ -0,0 +1 @@
+ffmpeg

requirements (1).txt

@@ -0,0 +1,9 @@
+# Runtime deps (Space)
+gradio>=4.44.0
+faster-whisper>=1.0.0
+ffmpeg-python>=0.2.0
+numpy>=1.24
+rich>=13.0
+sentence-transformers>=3.0.0
+torch
+# optional for GPU wheels (let HF pick the right one)