delete core.py

core.py

@@ -1,354 +0,0 @@
-"""
-Core functions for video transcription and cutting.
-"""
-
-import whisper
-import subprocess
-from pathlib import Path
-from dataclasses import dataclass
-from typing import List, Tuple
-import tempfile
-import os
-
-@dataclass
-class Segment:
-    """Representa um segmento de transcrição com timestamps."""
-    start: float
-    end: float
-    text: str
-    
-    def __repr__(self):
-        return f"Segment({self.start:.1f}-{self.end:.1f}: {self.text[:50]}...)"
-
-
-def transcribe(video_file: str, model_size: str = "small") -> List[Segment]:
-    """
-    Transcreve um vídeo usando Whisper.
-    
-    Args:
-        video_file: Caminho do arquivo de vídeo
-        model_size: Tamanho do modelo Whisper (tiny, base, small, medium, large)
-        
-    Returns:
-        Lista de Segments com texto e timestamps
-    """
-    print(f"🎙️ Carregando modelo Whisper: {model_size}")
-    model = whisper.load_model(model_size)
-    
-    print(f"🎬 Transcrevendo: {video_file}")
-    result = model.transcribe(video_file, language="pt", verbose=False)
-    
-    segments = []
-    for seg in result["segments"]:
-        segments.append(Segment(
-            start=seg["start"],
-            end=seg["end"],
-            text=seg["text"].strip()
-        ))
-    
-    print(f"✓ Transcrição completa: {len(segments)} segmentos")
-    return segments
-
-
-def extract_video_segment(
-    input_video: str,
-    output_video: str,
-    start_time: float,
-    end_time: float
-) -> bool:
-    """
-    Extrai um segmento do vídeo usando FFmpeg.
-    
-    Args:
-        input_video: Vídeo de entrada
-        output_video: Vídeo de saída
-        start_time: Tempo inicial em segundos
-        end_time: Tempo final em segundos
-        
-    Returns:
-        True se sucesso
-    """
-    duration = end_time - start_time
-    
-    cmd = [
-        "ffmpeg", "-y",
-        "-ss", str(start_time),
-        "-i", input_video,
-        "-t", str(duration),
-        "-c:v", "libx264",
-        "-c:a", "aac",
-        "-strict", "experimental",
-        output_video
-    ]
-    
-    try:
-        subprocess.run(cmd, check=True, capture_output=True)
-        return True
-    except subprocess.CalledProcessError as e:
-        print(f"❌ Erro ao extrair segmento: {e}")
-        return False
-
-
-def apply_aspect_ratio(
-    input_video: str,
-    output_video: str,
-    ar_mode: str
-) -> bool:
-    """
-    Aplica aspect ratio ao vídeo com crop centralizado.
-    
-    Args:
-        input_video: Vídeo de entrada
-        output_video: Vídeo de saída
-        ar_mode: Modo ("Original", "Vertical 9:16", "Quadrado 1:1", "Retrato 4:5")
-        
-    Returns:
-        True se sucesso
-    """
-    if ar_mode == "Original":
-        import shutil
-        shutil.copy(input_video, output_video)
-        return True
-    
-    # Mapeia modos para dimensões
-    ar_dims = {
-        "Vertical 9:16": (1080, 1920),
-        "Quadrado 1:1": (1080, 1080),
-        "Retrato 4:5": (1080, 1350),
-    }
-    
-    if ar_mode not in ar_dims:
-        print(f"⚠️ Modo inválido: {ar_mode}")
-        return False
-    
-    width, height = ar_dims[ar_mode]
-    
-    # Comando FFmpeg com scale e crop centralizado
-    cmd = [
-        "ffmpeg", "-y",
-        "-i", input_video,
-        "-vf", f"scale={width}:{height}:force_original_aspect_ratio=increase,crop={width}:{height}",
-        "-c:a", "copy",
-        output_video
-    ]
-    
-    try:
-        subprocess.run(cmd, check=True, capture_output=True)
-        return True
-    except subprocess.CalledProcessError as e:
-        print(f"❌ Erro ao aplicar aspect ratio: {e}")
-        return False
-
-
-def generate_linear_cuts(
-    video_file: str,
-    segments: List[Segment],
-    output_dir: str,
-    min_len: float = 600,
-    max_len: float = 900,
-    ideal_len: float = 900,
-    k: int = 2,
-    gap_threshold: float = 0.60,
-    pad: float = 0.08,
-    ar_mode: str = "Original",
-    face_tracking: bool = False
-) -> List[str]:
-    """
-    Gera k cortes lineares do vídeo.
-    
-    Args:
-        video_file: Vídeo de entrada
-        segments: Lista de Segments da transcrição
-        output_dir: Diretório de saída
-        min_len: Duração mínima em segundos
-        max_len: Duração máxima em segundos
-        ideal_len: Duração ideal em segundos
-        k: Número de cortes a gerar
-        gap_threshold: Threshold para gaps entre segmentos
-        pad: Padding em segundos
-        ar_mode: Modo de aspect ratio
-        face_tracking: Se True, usa face tracking (TODO)
-        
-    Returns:
-        Lista de caminhos dos vídeos gerados
-    """
-    if not segments:
-        return []
-    
-    Path(output_dir).mkdir(parents=True, exist_ok=True)
-    
-    # Calcula duração total
-    total_duration = segments[-1].end - segments[0].start
-    
-    # Divide em k partes aproximadamente iguais
-    target_duration = min(max_len, max(min_len, total_duration / k))
-    
-    outputs = []
-    current_start = segments[0].start
-    
-    for i in range(k):
-        # Encontra fim do corte
-        target_end = current_start + target_duration
-        
-        # Ajusta para não cortar no meio de uma frase
-        best_end = target_end
-        for seg in segments:
-            if abs(seg.end - target_end) < gap_threshold and seg.end > current_start:
-                best_end = seg.end
-                break
-        
-        # Garante que não excede máximo
-        if best_end - current_start > max_len:
-            best_end = current_start + max_len
-        
-        # Aplica padding
-        start_with_pad = max(0, current_start - pad)
-        end_with_pad = best_end + pad
-        
-        # Extrai segmento
-        temp_file = Path(output_dir) / f"temp_linear_{i+1}.mp4"
-        final_file = Path(output_dir) / f"cut_linear_{i+1}.mp4"
-        
-        print(f"✂️ Gerando corte {i+1}/{k}: {start_with_pad:.1f}s - {end_with_pad:.1f}s")
-        
-        if extract_video_segment(video_file, str(temp_file), start_with_pad, end_with_pad):
-            # Aplica aspect ratio se necessário
-            if ar_mode != "Original":
-                if apply_aspect_ratio(str(temp_file), str(final_file), ar_mode):
-                    temp_file.unlink()
-                    outputs.append(str(final_file))
-                else:
-                    temp_file.rename(final_file)
-                    outputs.append(str(final_file))
-            else:
-                temp_file.rename(final_file)
-                outputs.append(str(final_file))
-        
-        # Próximo início
-        current_start = best_end + gap_threshold
-        
-        # Para se chegou no fim
-        if current_start >= segments[-1].end:
-            break
-    
-    return outputs
-
-
-def generate_creative_cuts(
-    video_file: str,
-    segments: List[Segment],
-    output_dir: str,
-    min_len: float = 600,
-    max_len: float = 900,
-    ideal_len: float = 900,
-    min_blocks: int = 3,
-    max_blocks: int = 8,
-    k: int = 2,
-    gap_threshold: float = 0.60,
-    pad: float = 0.08,
-    ar_mode: str = "Original",
-    face_tracking: bool = False
-) -> List[str]:
-    """
-    Gera k cortes criativos com múltiplos blocos não-contíguos.
-    
-    Args:
-        Similar a generate_linear_cuts, mas com:
-        min_blocks: Mínimo de blocos por corte
-        max_blocks: Máximo de blocos por corte
-        
-    Returns:
-        Lista de caminhos dos vídeos gerados
-    """
-    if not segments or len(segments) < min_blocks:
-        return []
-    
-    Path(output_dir).mkdir(parents=True, exist_ok=True)
-    
-    outputs = []
-    
-    for i in range(k):
-        # Seleciona blocos aleatórios
-        import random
-        num_blocks = random.randint(min_blocks, min(max_blocks, len(segments)))
-        
-        # Seleciona segmentos espaçados
-        step = max(1, len(segments) // num_blocks)
-        selected_indices = [j * step for j in range(num_blocks)]
-        selected_segments = [segments[idx] for idx in selected_indices if idx < len(segments)]
-        
-        # Extrai cada bloco
-        block_files = []
-        for j, seg in enumerate(selected_segments):
-            block_file = Path(output_dir) / f"temp_creative_{i+1}_block_{j+1}.mp4"
-            
-            start = max(0, seg.start - pad)
-            end = seg.end + pad
-            
-            if extract_video_segment(video_file, str(block_file), start, end):
-                block_files.append(str(block_file))
-        
-        if not block_files:
-            continue
-        
-        # Concatena blocos
-        concat_file = Path(output_dir) / f"temp_creative_{i+1}_concat.mp4"
-        if concatenate_videos(block_files, str(concat_file)):
-            # Aplica aspect ratio
-            final_file = Path(output_dir) / f"cut_creative_{i+1}.mp4"
-            
-            if ar_mode != "Original":
-                if apply_aspect_ratio(str(concat_file), str(final_file), ar_mode):
-                    concat_file.unlink()
-                    outputs.append(str(final_file))
-                else:
-                    concat_file.rename(final_file)
-                    outputs.append(str(final_file))
-            else:
-                concat_file.rename(final_file)
-                outputs.append(str(final_file))
-            
-            # Limpa blocos temporários
-            for bf in block_files:
-                Path(bf).unlink(missing_ok=True)
-    
-    return outputs
-
-
-def concatenate_videos(video_files: List[str], output_file: str) -> bool:
-    """
-    Concatena múltiplos vídeos em um único arquivo.
-    
-    Args:
-        video_files: Lista de vídeos a concatenar
-        output_file: Arquivo de saída
-        
-    Returns:
-        True se sucesso
-    """
-    if not video_files:
-        return False
-    
-    # Cria arquivo de lista para FFmpeg
-    with tempfile.NamedTemporaryFile(mode='w', suffix='.txt', delete=False) as f:
-        list_file = f.name
-        for vf in video_files:
-            f.write(f"file '{os.path.abspath(vf)}'\n")
-    
-    try:
-        cmd = [
-            "ffmpeg", "-y",
-            "-f", "concat",
-            "-safe", "0",
-            "-i", list_file,
-            "-c", "copy",
-            output_file
-        ]
-        
-        subprocess.run(cmd, check=True, capture_output=True)
-        return True
-    except subprocess.CalledProcessError as e:
-        print(f"❌ Erro ao concatenar: {e}")
-        return False
-    finally:
-        Path(list_file).unlink(missing_ok=True)