Upload app.py

app.py

@@ -0,0 +1,849 @@
+import gradio as gr
+import subprocess
+import os
+import sys
+import json
+import psutil
+import shutil
+import datetime
+import time
+import urllib.parse
+from fastapi import FastAPI
+from fastapi.staticfiles import StaticFiles
+import uvicorn
+
+
+import re
+import library # Module for Library Logic
+import subtitle_handler as subs # Module for Subtitles
+import subtitle_editor as editor # Module for Editor Logic
+
+# Path to the main script
+MAIN_SCRIPT_PATH = os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))), "main_improved.py")
+WORKING_DIR = os.path.dirname(MAIN_SCRIPT_PATH)
+sys.path.append(WORKING_DIR)
+
+from i18n.i18n import I18nAuto
+i18n = I18nAuto()
+
+# --- PRESETS DEFINITIONS ---
+FACE_PRESETS = {
+    "Default (Balanced)": {"thresh": 0.35, "two_face": 0.60, "conf": 0.40, "dead_zone": 150},
+    "Stable (Focus Main)": {"thresh": 0.60, "two_face": 0.80, "conf": 0.60, "dead_zone": 200},
+    "Sensitive (Catch All)": {"thresh": 0.10, "two_face": 0.40, "conf": 0.30, "dead_zone": 100},
+    "High Precision": {"thresh": 0.40, "two_face": 0.65, "conf": 0.75, "dead_zone": 150},
+}
+
+EXPERIMENTAL_PRESETS = {
+    "Default (Off)": {"focus": False, "mar": 0.03, "score": 1.5, "motion": False, "motion_th": 3.0, "motion_sens": 0.05, "decay": 2.0},
+    "Active Speaker (Balanced)": {"focus": True, "mar": 0.03, "score": 1.5, "motion": True, "motion_th": 3.0, "motion_sens": 0.05, "decay": 2.0},
+    "Active Speaker (Sensitive)": {"focus": True, "mar": 0.02, "score": 1.0, "motion": True, "motion_th": 2.0, "motion_sens": 0.10, "decay": 1.0},
+    "Active Speaker (Stable)": {"focus": True, "mar": 0.05, "score": 2.5, "motion": False, "motion_th": 5.0, "motion_sens": 0.02, "decay": 3.0},
+}
+# ---------------------------
+
+VIRALS_DIR = os.path.join(WORKING_DIR, "VIRALS")
+MODELS_DIR = os.path.join(WORKING_DIR, "models")
+
+# Ensure directories exist
+if not os.path.exists(VIRALS_DIR):
+    os.makedirs(VIRALS_DIR, exist_ok=True)
+if not os.path.exists(MODELS_DIR):
+    os.makedirs(MODELS_DIR, exist_ok=True)
+
+# Global variables
+current_process = None
+
+# Helpers
+def convert_color_to_ass(hex_color, alpha="00"):
+    if not hex_color or not hex_color.startswith("#"):
+        return f"&H{alpha}FFFFFF&"
+    hex_clean = hex_color.lstrip('#')
+    if len(hex_clean) == 6:
+        r = hex_clean[0:2]
+        g = hex_clean[2:4]
+        b = hex_clean[4:6]
+        return f"&H{alpha}{b}{g}{r}&"
+    return f"&H{alpha}FFFFFF&"
+
+def kill_process():
+    global current_process
+    if current_process:
+        try:
+            parent = psutil.Process(current_process.pid)
+            for child in parent.children(recursive=True):
+                child.kill()
+            parent.kill()
+            current_process = None
+            return i18n("Process terminated.")
+        except Exception as e:
+            return i18n("Error terminating process: {}").format(e)
+    return i18n("No process running.")
+
+GEMINI_MODELS = [
+    'gemini-3-pro-preview',
+    'gemini-2.5-flash',
+    'gemini-2.5-flash-preview-09-2025',
+    'gemini-2.5-flash-lite',
+    'gemini-2.5-flash-lite-preview-09-2025',
+    'gemini-2.5-pro',
+    'gemini-2.0-flash',
+    'gemini-2.0-flash-lite'
+]
+
+G4F_MODELS = [
+    'gpt-4o',
+    'gpt-4o-mini',
+    'gpt-4',
+    'o1-mini',
+    'o1',
+    'deepseek-r1',
+    'deepseek-v3',
+    'llama-3.3-70b',
+    'llama-3.1-405b',
+    'claude-3.5-sonnet',
+    'claude-3.7-sonnet',
+    'gemini-2.0-flash',
+    'qwen-2.5-72b'
+]
+
+def get_local_models():
+    if not os.path.exists(MODELS_DIR): return []
+    return [f for f in os.listdir(MODELS_DIR) if f.endswith(".gguf")]
+
+
+
+def apply_face_preset(preset_name):
+    if preset_name not in FACE_PRESETS:
+        return [gr.update() for _ in range(4)] # No change
+    
+    p = FACE_PRESETS[preset_name]
+    return p["thresh"], p["two_face"], p["conf"], p["dead_zone"]
+
+def apply_experimental_preset(preset_name):
+    if preset_name not in EXPERIMENTAL_PRESETS:
+        return [gr.update() for _ in range(7)] # No change
+        
+    p = EXPERIMENTAL_PRESETS[preset_name]
+    return p["focus"], p["mar"], p["score"], p["motion"], p["motion_th"], p["motion_sens"], p["decay"]
+
+# Subtitle logic moved to subtitle_handler.py
+
+
+def run_viral_cutter(input_source, project_name, url, video_file, segments, viral, themes, min_duration, max_duration, model, ai_backend, api_key, ai_model_name, chunk_size, workflow, face_model, face_mode, face_detect_interval, 
+                     face_filter_thresh, face_two_thresh, face_conf_thresh, face_dead_zone, focus_active_speaker, active_speaker_mar, active_speaker_score_diff, include_motion, active_speaker_motion_threshold, active_speaker_motion_sensitivity, active_speaker_decay,
+                     use_custom_subs, font_name, font_size, font_color, highlight_color, outline_color, outline_thickness, shadow_color, shadow_size, is_bold, is_italic, is_uppercase, vertical_pos, alignment,
+                     h_size, w_block, gap, mode, under, strike, border_s, remove_punc, video_quality, use_youtube_subs, translate_target):
+    
+    global current_process
+    yield "", gr.update(value=i18n("Running..."), interactive=False), gr.update(visible=True), None 
+
+    cmd = [sys.executable, MAIN_SCRIPT_PATH]
+    
+    # Input Source Logic
+    if input_source == "Existing Project":
+        if not project_name:
+             yield i18n("Error: No project selected."), gr.update(value=i18n("Start Processing"), interactive=True), gr.update(visible=False), None
+             return
+        full_project_path = os.path.join(VIRALS_DIR, project_name)
+        cmd.extend(["--project-path", full_project_path])
+    elif input_source == "Upload Video":
+        if not video_file:
+             yield i18n("Error: No video file uploaded."), gr.update(value=i18n("Start Processing"), interactive=True), gr.update(visible=False), None
+             return
+        
+        # Determine project name from filename
+        original_filename = os.path.basename(video_file)
+        name_no_ext = os.path.splitext(original_filename)[0]
+        # Sanitize: Allow alphanumeric, space, dash, underscore
+        safe_name = "".join([c for c in name_no_ext if c.isalnum() or c in " _-"]).strip()
+        if not safe_name: safe_name = "Untitled_Upload"
+        
+        # Always append timestamp as requested
+        timestamp = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
+        project_name_upload = f"{safe_name}_{timestamp}"
+        project_path = os.path.join(VIRALS_DIR, project_name_upload)
+             
+        os.makedirs(project_path, exist_ok=True)
+        
+        target_path = os.path.join(project_path, "input.mp4")
+        shutil.copy(video_file, target_path)
+        
+        cmd.extend(["--project-path", project_path])
+        # Skip YouTube subs as it is a local upload
+        cmd.append("--skip-youtube-subs")
+        
+    else:
+        if url: cmd.extend(["--url", url])
+        # Pass Video Quality
+        if video_quality: cmd.extend(["--video-quality", video_quality])
+        # Pass Subtitle Option (if False, we skip)
+        if not use_youtube_subs: cmd.append("--skip-youtube-subs")
+        
+    # Translation
+    if translate_target and translate_target != "None":
+            cmd.extend(["--translate-target", translate_target])
+
+    
+    cmd.extend(["--segments", str(int(segments))])
+    if viral: cmd.append("--viral")
+    if themes: cmd.extend(["--themes", themes])
+    cmd.extend(["--min-duration", str(int(min_duration))])
+    cmd.extend(["--max-duration", str(int(max_duration))])
+    cmd.extend(["--model", model])
+    cmd.extend(["--ai-backend", ai_backend])
+    if api_key: cmd.extend(["--api-key", api_key])
+    
+    # New AI Params
+    if ai_model_name: cmd.extend(["--ai-model-name", str(ai_model_name)])
+    if chunk_size: cmd.extend(["--chunk-size", str(int(chunk_size))])
+
+    workflow_map = {"Full": "1", "Cut Only": "2", "Subtitles Only": "3"}
+    cmd.extend(["--workflow", workflow_map.get(workflow, "1")])
+    cmd.extend(["--face-model", face_model])
+    cmd.extend(["--face-mode", face_mode])
+    if face_detect_interval: cmd.extend(["--face-detect-interval", str(face_detect_interval)])
+    
+    # New Face Params
+    if face_filter_thresh is not None: cmd.extend(["--face-filter-threshold", str(face_filter_thresh)])
+    if face_two_thresh is not None: cmd.extend(["--face-two-threshold", str(face_two_thresh)])
+    if face_conf_thresh is not None: cmd.extend(["--face-confidence-threshold", str(face_conf_thresh)])
+    if face_dead_zone is not None: cmd.extend(["--face-dead-zone", str(face_dead_zone)])
+
+
+    
+    cmd.append("--skip-prompts")
+    
+    if focus_active_speaker:
+        cmd.append("--focus-active-speaker")
+        if active_speaker_mar is not None: cmd.extend(["--active-speaker-mar", str(active_speaker_mar)])
+        if active_speaker_score_diff is not None: cmd.extend(["--active-speaker-score-diff", str(active_speaker_score_diff)])
+        if include_motion: cmd.append("--include-motion")
+        if active_speaker_motion_threshold is not None: cmd.extend(["--active-speaker-motion-threshold", str(active_speaker_motion_threshold)])
+        if active_speaker_motion_sensitivity is not None: cmd.extend(["--active-speaker-motion-sensitivity", str(active_speaker_motion_sensitivity)])
+        if active_speaker_decay is not None: cmd.extend(["--active-speaker-decay", str(active_speaker_decay)])
+
+    cmd.append("--skip-prompts") # Always skip prompts in WebUI to prevent freezing
+
+    if use_custom_subs:
+        subtitle_config = {
+            "font": font_name, "base_size": int(font_size), "base_color": convert_color_to_ass(font_color), "highlight_color": convert_color_to_ass(highlight_color),
+            "outline_color": convert_color_to_ass(outline_color), "outline_thickness": outline_thickness, "shadow_color": convert_color_to_ass(shadow_color),
+            "shadow_size": shadow_size, "vertical_position": vertical_pos, "alignment": alignment, "bold": 1 if is_bold else 0, "italic": 1 if is_italic else 0, 
+            "underline": 1 if under else 0, "strikeout": 1 if strike else 0, "border_style": border_s, "words_per_block": int(w_block), "gap_limit": gap,
+            "mode": mode, "highlight_size": int(h_size), "remove_punctuation": remove_punc
+        }
+        # Uppercase is handled in main script or logic? 
+        # Actually subtitle_config doesn't seem to natively support "uppercase" in get_subtitle_config default, but app.py was using it. 
+        # I should probably add it back if I want to support it, but user said "PROHIBITED to remove existing ones".
+        # I'll re-add 'uppercase': 1 if is_uppercase else 0 to the dict if the backend supports it, otherwise it's just ignored.
+        # But wait, main_improved.py doesn't have 'uppercase' in get_subtitle_config. 
+        # I'll keep it in the dict just in case logic uses it elsewhere or if I missed it.
+        # Actually, standard ASS doesn't support uppercase flag directly in Style, it needs to be text transform.
+        # But I'll leave it in the dict.
+        subtitle_config["uppercase"] = 1 if is_uppercase else 0
+
+        subtitle_config_path = os.path.join(WORKING_DIR, "temp_subtitle_config.json")
+        try:
+            with open(subtitle_config_path, "w", encoding="utf-8") as f:
+                json.dump(subtitle_config, f, indent=4)
+            cmd.extend(["--subtitle-config", subtitle_config_path])
+        except Exception: pass 
+    
+    env = os.environ.copy()
+    env["PYTHONUNBUFFERED"] = "1"
+    try:
+        current_process = subprocess.Popen(cmd, cwd=WORKING_DIR, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True, bufsize=1, universal_newlines=True, env=env)
+        logs = ""
+        project_folder_path = None
+        if input_source == "Existing Project" and project_name:
+             # If using existing project, we already know the path, but let's see if logs confirm it
+             project_folder_path = os.path.join(VIRALS_DIR, project_name)
+
+        while True:
+            line = current_process.stdout.readline()
+            if not line and current_process.poll() is not None:
+                break
+            
+            if line:
+                logs += line
+                if "Project Folder:" in line:
+                    parts = line.split("Project Folder:")
+                    if len(parts) > 1: project_folder_path = parts[1].strip()
+                yield logs, gr.update(visible=True, interactive=False), gr.update(visible=True), None
+    except Exception as e:
+        logs += f"\nError running process: {str(e)}\n"
+        yield logs, gr.update(visible=True, interactive=False), gr.update(visible=True), None
+    finally:
+        if current_process:
+            if current_process.stdout:
+                try:
+                    current_process.stdout.close()
+                except Exception: pass
+            if current_process.poll() is None:
+                # If we are here, it means we finished reading or errored out, but process is still running.
+                # If it was a normal break from loop, process should be done or close to done.
+                # If we are stopping, current_process.terminate() might be needed outside? 
+                # But here we just wait.
+                try:
+                    current_process.wait()
+                except Exception: pass
+            current_process = None
+    
+    # Wait to ensure filesystem flush
+    time.sleep(1.0)
+    
+    html_output = ""
+    if project_folder_path and os.path.exists(project_folder_path):
+        html_output = library.generate_project_gallery(project_folder_path, is_full_path=True)
+    else:
+        html_output = f"<h3>{i18n('Error: Project folder could not be determined from logs.')}</h3>"
+    yield logs, gr.update(value=i18n("Start Processing"), interactive=True), gr.update(visible=False), html_output
+
+css = """
+/* Global Dark Theme Overrides */
+body, .gradio-container {
+    background-color: #0b0b0b !important;
+    color: #ffffff !important;
+}
+
+/* Force dark background for specific inputs that might be white */
+input[type="password"], textarea, select {
+    background-color: #1f1f1f !important;
+    color: #ffffff !important;
+    border: 1px solid #333 !important;
+}
+
+/* Hide Footer */
+footer {visibility: hidden}
+
+/* Container Width */
+.gradio-container {
+    max-width: 98% !important; 
+    width: 98% !important;
+    margin: 0 auto !important;
+}
+"""
+
+import header
+
+with gr.Blocks(title=i18n("ViralCutter WebUI"), theme=gr.themes.Default(primary_hue="orange", neutral_hue="slate"), css=css) as demo:
+    gr.Markdown(header.badges)
+    gr.Markdown(header.description)
+    with gr.Tabs():
+        with gr.Tab(i18n("Create New")):
+             with gr.Row():
+                with gr.Column(scale=1):
+                    input_source = gr.Radio([(i18n("YouTube URL"), "YouTube URL"), (i18n("Existing Project"), "Existing Project"), (i18n("Upload Video"), "Upload Video")], label=i18n("Input Source"), value="Upload Video")
+                    
+                    url_input = gr.Textbox(label=i18n("YouTube URL"), placeholder="https://www.youtube.com/watch?v=...", visible=True)
+                    video_upload = gr.File(label=i18n("Upload Video"), file_count="single", file_types=["video"], visible=False)
+                    
+                    with gr.Row():
+                        video_quality_input = gr.Dropdown(choices=["best", "1080p", "720p", "480p"], label=i18n("Video Quality"), value="best")
+                        translate_input = gr.Dropdown(choices=["None", "pt", "en", "es", "fr", "de", "it", "ru", "ja", "ko", "zh-CN"], label=i18n("Translate Subtitles To"), value="None")
+                        use_youtube_subs_input = gr.Checkbox(label=i18n("Use YouTube Subs"), value=True, info=i18n("Download and use official subtitles if available. (Recommended, it speeds up the process)"))
+
+                    project_selector = gr.Dropdown(choices=[], label=i18n("Select Project"), visible=False)
+                    
+                    def on_source_change(source):
+                        if source == "YouTube URL":
+                            return gr.update(visible=True), gr.update(visible=False), gr.update(visible=False), gr.update(value="Full") 
+                        elif source == "Upload Video":
+                             return gr.update(visible=False), gr.update(visible=False), gr.update(visible=True), gr.update(value="Full")
+                        else:
+                            # Load projects
+                            projs = library.get_existing_projects()
+                            return gr.update(visible=False), gr.update(choices=projs, visible=True), gr.update(visible=False), gr.update(value="Subtitles Only")
+                    
+                    
+                    with gr.Row():
+                        segments_input = gr.Number(label=i18n("Segments"), value=3, precision=0)
+                        viral_input = gr.Checkbox(label=i18n("Viral Mode"), value=True)
+                    themes_input = gr.Textbox(label=i18n("Themes"), placeholder=i18n("funny, sad..."), visible=False)
+                    viral_input.change(lambda x: gr.update(visible=not x), viral_input, themes_input)
+                    with gr.Row():
+                        min_dur_input = gr.Number(label=i18n("Min Duration (s)"), value=15)
+                        max_dur_input = gr.Number(label=i18n("Max Duration (s)"), value=90)
+                with gr.Column(scale=1):
+                    with gr.Row():
+                        ai_backend_input = gr.Dropdown(choices=[(i18n("Gemini"), "gemini"), (i18n("G4F"), "g4f"), (i18n("Local (GGUF)"), "local"), (i18n("Manual"), "manual")], label=i18n("AI Backend"), value="gemini", scale=2)
+                        api_key_input = gr.Textbox(label=i18n("Gemini API Key"), type="password", scale=3)
+                    
+                    # New Dynamic Inputs
+                    with gr.Row():
+                        ai_model_input = gr.Dropdown(choices=GEMINI_MODELS, label=i18n("AI Model"), value=GEMINI_MODELS[1], allow_custom_value=True, visible=True, scale=5)
+                        refresh_models_btn = gr.Button("🔄", size="sm", visible=False, scale=0, min_width=50) # Only local
+                        chunk_size_input = gr.Number(label=i18n("Chunk Size"), value=20000, precision=0, scale=2)
+                    
+                    # Update listeners with logic to hide/show API key
+                    def update_ai_ui(backend):
+                        show_api = (backend == "gemini")
+                        show_refresh = (backend == "local")
+                        
+                        # Definições padrão para evitar que fiquem vazios
+                        new_choices = []
+                        new_val = ""
+                        new_chunk = 20000
+                        
+                        if backend == "gemini":
+                            new_choices = GEMINI_MODELS
+                            new_val = GEMINI_MODELS[1]
+                            new_chunk = 20000
+                        elif backend == "g4f":
+                            new_choices = G4F_MODELS
+                            new_val = G4F_MODELS[0]
+                            new_chunk = 3000
+                        elif backend == "local":
+                            models = get_local_models()
+                            new_choices = models if models else [i18n("No models found")]
+                            new_val = new_choices[0]
+                            new_chunk = 15000
+                        else: # Manual
+                             pass
+
+                        return (
+                            gr.update(visible=show_api), # API Key Visibility (Fixes hole 1)
+                            gr.update(choices=new_choices, value=new_val, visible=(backend != "manual")), # Model Dropdown
+                            gr.update(visible=show_refresh), # Refresh Button
+                            gr.update(value=new_chunk) # Chunk Size
+                        )
+
+                    def refresh_local_models():
+                        models = get_local_models()
+                        val = models[0] if models else i18n("No models found")
+                        return gr.update(choices=models, value=val)
+
+                    refresh_models_btn.click(refresh_local_models, outputs=ai_model_input)
+                    ai_backend_input.change(update_ai_ui, inputs=ai_backend_input, outputs=[api_key_input, ai_model_input, refresh_models_btn, chunk_size_input])
+
+                    model_input = gr.Dropdown(["tiny", "small", "medium", "large", "large-v1", "large-v2", "large-v3", "turbo", "large-v3-turbo", "distil-large-v2", "distil-medium.en", "distil-small.en", "distil-large-v3"], label=i18n("Whisper Model"), value="large-v3-turbo")
+                    with gr.Row():
+                        workflow_input = gr.Dropdown(choices=[(i18n("Full"), "Full"), (i18n("Cut Only"), "Cut Only"), (i18n("Subtitles Only"), "Subtitles Only")], label=i18n("Workflow"), value="Full")
+                        face_model_input = gr.Dropdown(["insightface", "mediapipe"], label=i18n("Face Model"), value="insightface")
+                    with gr.Row():
+                        face_mode_input = gr.Dropdown(choices=[(i18n("Auto"), "auto"), ("1", "1"), ("2", "2")], label=i18n("Face Mode"), value="auto")
+                        face_detect_interval_input = gr.Textbox(label=i18n("Face Det. Interval"), value="0.17,1.0")
+                    
+                    
+                    # Update listeners now that all components are defined
+                    input_source.change(on_source_change, inputs=input_source, outputs=[url_input, project_selector, video_upload, workflow_input])
+             
+             with gr.Accordion(i18n("Advanced Face Settings"), open=False):
+                 face_preset_input = gr.Dropdown(choices=[(i18n(k), k) for k in FACE_PRESETS.keys()], label=i18n("Configuration Presets"), value="Default (Balanced)", interactive=True)
+                 with gr.Row():
+                      face_filter_thresh_input = gr.Slider(label=i18n("Ignore Small Faces (0.0 - 1.0)"), minimum=0.0, maximum=1.0, value=0.35, step=0.05, info=i18n("Relative size to ignore background."))
+                      face_two_thresh_input = gr.Slider(label=i18n("Threshold for 2 Faces (0.0 - 1.0)"), minimum=0.0, maximum=1.0, value=0.60, step=0.05, info=i18n("Size of 2nd face to activate split mode."))
+                      face_conf_thresh_input = gr.Slider(label=i18n("Minimum Confidence (0.0 - 1.0)"), minimum=0.0, maximum=1.0, value=0.40, step=0.05, info=i18n("Ignore detections with low confidence."))
+                      face_dead_zone_input = gr.Slider(label=i18n("Dead Zone (Stabilization)"), minimum=0, maximum=200, value=150, step=5, info=i18n("Movement pixels to ignore."))
+                 
+                 face_preset_input.change(apply_face_preset, inputs=face_preset_input, outputs=[face_filter_thresh_input, face_two_thresh_input, face_conf_thresh_input, face_dead_zone_input])
+
+                 with gr.Accordion(i18n("Experimental: Active Speaker & Motion"), open=False):
+                        experimental_preset_input = gr.Dropdown(choices=[(i18n(k), k) for k in EXPERIMENTAL_PRESETS.keys()], label=i18n("Configuration Presets"), value="Default (Off)", interactive=True)
+                        focus_active_speaker_input = gr.Checkbox(label=i18n("Experimental: Focus on Speaker"), value=False, info=i18n("Tries to focus only on the speaking person instead of split screen."))
+                        with gr.Row():
+                            active_speaker_mar_input = gr.Slider(label=i18n("MAR Threshold (Mouth Open)"), minimum=0.01, maximum=0.20, value=0.03, step=0.005, info=i18n("Mouth open sensitivity."))
+                            active_speaker_score_diff_input = gr.Slider(label=i18n("Score Difference"), minimum=0.5, maximum=10.0, value=1.5, step=0.5, info=i18n("Minimum difference to focus on 1 face."))
+                            
+                        with gr.Row():
+                            include_motion_input = gr.Checkbox(label=i18n("Consider Motion"), value=False, info=i18n("Increases score with motion (gestures)."))
+                            
+                        with gr.Row():
+                            active_speaker_motion_threshold_input = gr.Slider(label=i18n("Motion Dead Zone"), minimum=0.0, maximum=20.0, value=3.0, step=0.5, info=i18n("Pixels ignored."))
+                            active_speaker_motion_sensitivity_input = gr.Slider(label=i18n("Motion Sensitivity"), minimum=0.01, maximum=0.5, value=0.05, step=0.01, info=i18n("Points per pixel."))
+                            active_speaker_decay_input = gr.Slider(label=i18n("Switch Speed"), minimum=0.5, maximum=5.0, value=2.0, step=0.5, info=i18n("Speed to lose focus."))
+
+                        experimental_preset_input.change(apply_experimental_preset, inputs=experimental_preset_input, outputs=[focus_active_speaker_input, active_speaker_mar_input, active_speaker_score_diff_input, include_motion_input, active_speaker_motion_threshold_input, active_speaker_motion_sensitivity_input, active_speaker_decay_input])
+             with gr.Accordion(i18n("Subtitle Settings (alpha)"), open=False):
+                preset_input = gr.Dropdown(choices=[(i18n("Manual"), "Manual")] + [(i18n(k), k) for k in subs.SUBTITLE_PRESETS.keys()], label=i18n("Quick Presets"), value="Hormozi (Classic)")
+                use_custom_subs = gr.Checkbox(label=i18n("Enable Subtitle Customization (Includes Preset)"), value=True)
+                
+                # Previews (Always Visible)
+                preview_html = gr.HTML(value=f"<div style='text-align:center; padding:10px; color:#666;'>{i18n('Select options or preset to preview')}</div>")
+                
+                with gr.Row():
+                    preview_vid_btn = gr.Button(i18n("🎬 Render Animated Preview (Slow)"), size="sm")
+                preview_vid = gr.Video(label=i18n("Animated Preview"), height=300, autoplay=True, interactive=False)
+                
+                with gr.Accordion(i18n("Advanced Settings"), open=False):
+                    gr.Markdown(f"### {i18n('Appearance')}")
+                    with gr.Row():
+                        font_name_input = gr.Textbox(label=i18n("Font Name"), value="Montserrat-Regular")
+                        font_size_input = gr.Slider(label=i18n("Font Size (Base)"), minimum=8, maximum=80, value=12)
+                        highlight_size_input = gr.Slider(label=i18n("Highlight Size"), minimum=8, maximum=80, value=14)
+                    
+                    with gr.Row():
+                        font_color_input = gr.ColorPicker(label=i18n("Base Color"), value="#FFFFFF")
+                        highlight_color_input = gr.ColorPicker(label=i18n("Highlight Color"), value="#00FF00")
+                        outline_color_input = gr.ColorPicker(label=i18n("Outline Color"), value="#000000")
+                        shadow_color_input = gr.ColorPicker(label=i18n("Shadow Color"), value="#000000")
+                    
+                    gr.Markdown(f"### {i18n('Styling & Effects')}")
+                    with gr.Row():
+                        outline_thickness_input = gr.Slider(label=i18n("Outline Thickness"), minimum=0, maximum=10, value=1.5)
+                        shadow_size_input = gr.Slider(label=i18n("Shadow Size"), minimum=0, maximum=10, value=2)
+                        border_style_input = gr.Dropdown(choices=[(i18n("Outline"), 1), (i18n("Opaque Box"), 3)], label=i18n("Border Style"), value=1)
+                    
+                    with gr.Row():
+                        bold_input = gr.Checkbox(label=i18n("Bold"))
+                        italic_input = gr.Checkbox(label=i18n("Italic"))
+                        uppercase_input = gr.Checkbox(label=i18n("Uppercase"))
+                        remove_punc_input = gr.Checkbox(label=i18n("Remove Punctuation"), value=True)
+                        underline_input = gr.Checkbox(label=i18n("Underline"))
+                        strikeout_input = gr.Checkbox(label=i18n("Strikeout"))
+                        
+                    gr.Markdown(f"### {i18n('Positioning & Layout')}")
+                    with gr.Row():
+                        vertical_pos_input = gr.Slider(label=i18n("V-Pos (Margin V)"), minimum=0, maximum=500, value=210)
+                        alignment_input = gr.Dropdown(choices=[(i18n("Left"), 1), (i18n("Center"), 2), (i18n("Right"), 3)], label=i18n("Alignment"), value=2)
+                        gap_limit_input = gr.Slider(label=i18n("Gap Limit"), minimum=0.0, maximum=5.0, value=0.5, step=0.1)
+                        mode_input = gr.Dropdown(choices=[(i18n("Highlight"), "highlight"), (i18n("Word by Word"), "word_by_word"), (i18n("No Highlight"), "no_highlight")], label=i18n("Mode"), value="highlight")
+                        words_per_block_input = gr.Slider(label=i18n("Words per Block"), minimum=1, maximum=20, value=3, step=1)
+
+                manual_inputs = [
+                    font_name_input, font_size_input, font_color_input, highlight_color_input, 
+                    outline_color_input, outline_thickness_input, shadow_color_input, shadow_size_input, 
+                    bold_input, italic_input, uppercase_input,
+                    highlight_size_input, words_per_block_input, gap_limit_input, mode_input,
+                    underline_input, strikeout_input, border_style_input,
+                    vertical_pos_input, alignment_input,
+                    remove_punc_input
+                ]
+                
+                # Update manual inputs when preset changes
+                preset_input.change(subs.apply_preset, inputs=[preset_input], outputs=manual_inputs)
+                
+                # Auto-update PREVIEW HTML on any change
+                for inp in manual_inputs:
+                    inp.change(subs.generate_preview_html, inputs=manual_inputs, outputs=preview_html)
+                
+                # Render video button
+                preview_vid_btn.click(
+                    subs.render_preview_video,
+                    inputs=manual_inputs,
+                    outputs=preview_vid
+                )
+                
+                # Initial load
+                demo.load(subs.generate_preview_html, inputs=manual_inputs, outputs=preview_html)
+                demo.load(subs.apply_preset, inputs=[preset_input], outputs=manual_inputs) # Apply default preset on load
+
+             with gr.Row():
+                 start_btn = gr.Button(i18n("Start Processing"), variant="primary")
+                 stop_btn = gr.Button(i18n("Stop"), variant="stop", visible=False)
+             stop_btn.click(kill_process, outputs=[])
+             logs_output = gr.Textbox(label=i18n("Logs"), lines=10, autoscroll=True, elem_id="logs_output")
+             
+             # Force scroll to bottom via JS
+             logs_output.change(fn=None, inputs=[], outputs=[], js="""
+                function() {
+                    var ta = document.querySelector('#logs_output textarea');
+                    if(ta) {
+                        ta.scrollTop = ta.scrollHeight;
+                    }
+                }
+             """)
+             results_html = gr.HTML(label=i18n("Results"))
+             
+             # MUST pass all all new inputs to the run function
+             start_btn.click(run_viral_cutter, inputs=[
+                 input_source, project_selector, url_input, video_upload, segments_input, viral_input, themes_input, min_dur_input, max_dur_input, 
+                 model_input, ai_backend_input, api_key_input, ai_model_input, chunk_size_input, 
+                 workflow_input, face_model_input, face_mode_input, face_detect_interval_input, 
+                 face_filter_thresh_input, face_two_thresh_input, face_conf_thresh_input, face_dead_zone_input, focus_active_speaker_input, 
+                 active_speaker_mar_input, active_speaker_score_diff_input, include_motion_input, active_speaker_motion_threshold_input, active_speaker_motion_sensitivity_input, active_speaker_decay_input,
+                 use_custom_subs, 
+                 # Expanded Manual Inputs mapping
+                 font_name_input, font_size_input, font_color_input, highlight_color_input, 
+                 outline_color_input, outline_thickness_input, shadow_color_input, shadow_size_input, 
+                 bold_input, italic_input, uppercase_input, vertical_pos_input, alignment_input,
+                 # New Inputs
+                 highlight_size_input, words_per_block_input, gap_limit_input, mode_input, 
+                 underline_input, strikeout_input, border_style_input, remove_punc_input,
+                 video_quality_input, use_youtube_subs_input, translate_input
+             ], outputs=[logs_output, start_btn, stop_btn, results_html])
+
+
+        with gr.Tab(i18n("Subtitle Editor")):
+            gr.Markdown(f"### {i18n('Edit Subtitles (Smart Mode)')}")
+            
+            with gr.Group():
+                editor_project_dropdown = gr.Dropdown(choices=library.get_existing_projects(), label=i18n("Select Project"), value=None)
+                editor_refresh_btn = gr.Button(i18n("Refresh"), size="sm")
+            
+            with gr.Group():
+                editor_file_dropdown = gr.Dropdown(choices=[], label=i18n("Select Subtitle File"), interactive=True)
+                editor_load_btn = gr.Button(i18n("Load Subtitles"), variant="secondary")
+
+            # Hidden state to store full path of currently loaded JSON
+            current_json_path = gr.State()
+
+            # The Dataframe Editor
+            # Headers: Start, End, Text
+            subtitle_dataframe = gr.Dataframe(
+                headers=["Start", "End", "Text"],
+                datatype=["str", "str", "str"],
+                col_count=(3, "fixed"),
+                interactive=True,
+                label=i18n("Subtitle Segments"),
+                wrap=True
+            )
+
+            with gr.Row():
+                editor_save_btn = gr.Button(i18n("💾 Save Changes"), variant="primary")
+                editor_render_single_btn = gr.Button(i18n("⚡ Render This Segment (Very-Fast)"), variant="secondary")
+                editor_render_all_btn = gr.Button(i18n("🎬 Render All (Fast)"), variant="stop")
+            
+            editor_status = gr.Textbox(label=i18n("Status"), interactive=False)
+
+            # --- Callbacks for Editor ---
+            editor_refresh_btn.click(library.refresh_projects, outputs=editor_project_dropdown)
+
+            def update_file_list(proj_name):
+                if not proj_name: return gr.update(choices=[])
+                proj_path = os.path.join(VIRALS_DIR, proj_name)
+                files = editor.list_editable_files(proj_path)
+                return gr.update(choices=files, value=files[0] if files else None)
+
+            editor_project_dropdown.change(update_file_list, inputs=editor_project_dropdown, outputs=editor_file_dropdown)
+
+            def load_subs(proj_name, file_name):
+                if not proj_name or not file_name:
+                    return [], None, i18n("Please select project and file.")
+                
+                full_path = os.path.join(VIRALS_DIR, proj_name, 'subs', file_name)
+                data = editor.load_transcription_for_editor(full_path)
+                return data, full_path, i18n("Loaded {} segments.").format(len(data))
+
+            editor_load_btn.click(load_subs, inputs=[editor_project_dropdown, editor_file_dropdown], outputs=[subtitle_dataframe, current_json_path, editor_status])
+
+            def save_subs(json_path, df):
+                if not json_path: return i18n("No file loaded.")
+                data_list = df.values.tolist() if hasattr(df, 'values') else df
+                msg = editor.save_editor_changes(json_path, data_list)
+                return msg
+
+            editor_save_btn.click(save_subs, inputs=[current_json_path, subtitle_dataframe], outputs=editor_status)
+
+            def render_single(json_path, use_custom, font_name, font_size, font_color, highlight_color, 
+                              outline_color, outline_thickness, shadow_color, shadow_size, 
+                              is_bold, is_italic, is_uppercase, 
+                              h_size, w_block, gap, mode, under, strike, border_s, 
+                              vertical_pos, alignment, remove_punc):
+                
+                if not json_path: return i18n("No file loaded.")
+                
+                subtitle_config_path = os.path.join(WORKING_DIR, "temp_subtitle_config.json")
+                
+                # Save config if custom subs enabled
+                if use_custom:
+                    subtitle_config = {
+                        "font": font_name, "base_size": int(font_size), 
+                        "base_color": convert_color_to_ass(font_color), 
+                        "highlight_color": convert_color_to_ass(highlight_color),
+                        "outline_color": convert_color_to_ass(outline_color), 
+                        "outline_thickness": outline_thickness, 
+                        "shadow_color": convert_color_to_ass(shadow_color),
+                        "shadow_size": shadow_size, "vertical_position": vertical_pos, 
+                        "alignment": alignment, "bold": 1 if is_bold else 0, 
+                        "italic": 1 if is_italic else 0, 
+                        "underline": 1 if under else 0, "strikeout": 1 if strike else 0, 
+                        "border_style": border_s, "words_per_block": int(w_block), 
+                        "gap_limit": gap, "mode": mode, "highlight_size": int(h_size),
+                        "uppercase": 1 if is_uppercase else 0,
+                        "remove_punctuation": remove_punc
+                    }
+                    try:
+                        with open(subtitle_config_path, "w", encoding="utf-8") as f:
+                            json.dump(subtitle_config, f, indent=4)
+                    except Exception: pass
+                else:
+                    # Remove temp config if it exists to ensure defaults are used
+                    try:
+                        if os.path.exists(subtitle_config_path):
+                            os.remove(subtitle_config_path)
+                    except Exception: pass
+                
+                # We expect user to SAVE first, but we could auto-save.
+                # For now assume saved.
+                msg = editor.render_specific_video(json_path)
+                return msg
+
+            editor_render_single_btn.click(
+                render_single, 
+                inputs=[current_json_path, use_custom_subs] + manual_inputs, 
+                outputs=editor_status
+            )
+
+            def render_all(proj_name, use_custom, font_name, font_size, font_color, highlight_color, 
+                           outline_color, outline_thickness, shadow_color, shadow_size, 
+                           is_bold, is_italic, is_uppercase, 
+                           h_size, w_block, gap, mode, under, strike, border_s, 
+                           vertical_pos, alignment, remove_punc):
+                if not proj_name: return i18n("No project selected.")
+                
+                # Save config
+                if use_custom:
+                    subtitle_config = {
+                        "font": font_name, "base_size": int(font_size), 
+                        "base_color": convert_color_to_ass(font_color), 
+                        "highlight_color": convert_color_to_ass(highlight_color),
+                        "outline_color": convert_color_to_ass(outline_color), 
+                        "outline_thickness": outline_thickness, 
+                        "shadow_color": convert_color_to_ass(shadow_color),
+                        "shadow_size": shadow_size, "vertical_position": vertical_pos, 
+                        "alignment": alignment, "bold": 1 if is_bold else 0, 
+                        "italic": 1 if is_italic else 0, 
+                        "underline": 1 if under else 0, "strikeout": 1 if strike else 0, 
+                        "border_style": border_s, "words_per_block": int(w_block), 
+                        "gap_limit": gap, "mode": mode, "highlight_size": int(h_size),
+                        "uppercase": 1 if is_uppercase else 0,
+                        "remove_punctuation": remove_punc
+                    }
+                    subtitle_config_path = os.path.join(WORKING_DIR, "temp_subtitle_config.json")
+                    try:
+                        with open(subtitle_config_path, "w", encoding="utf-8") as f:
+                            json.dump(subtitle_config, f, indent=4)
+                    except Exception: pass
+
+                proj_path = os.path.join(VIRALS_DIR, proj_name)
+                
+                # IMPORTANT: Pass the config file path to the command
+                subtitle_config_path = os.path.join(WORKING_DIR, "temp_subtitle_config.json")
+                cmd = [sys.executable, MAIN_SCRIPT_PATH, "--project-path", proj_path, "--workflow", "3", "--skip-prompts"]
+                
+                if use_custom and os.path.exists(subtitle_config_path):
+                     cmd.extend(["--subtitle-config", subtitle_config_path])
+
+                try:
+                    subprocess.Popen(cmd, cwd=WORKING_DIR)
+                    return i18n("Render All started in background... Check terminal/logs.")
+                except Exception as e:
+                    return i18n("Error starting render: {}").format(e)
+
+            editor_render_all_btn.click(
+                render_all, 
+                inputs=[editor_project_dropdown, use_custom_subs] + manual_inputs, 
+                outputs=editor_status
+            )
+
+
+        with gr.Tab(i18n("Library")):
+            gr.Markdown(f"### {i18n('Existing Projects')}")
+            with gr.Row():
+                project_dropdown = gr.Dropdown(choices=library.get_existing_projects(), label=i18n("Select Project"), value=None)
+                refresh_btn = gr.Button(i18n("Refresh List"))
+            project_gallery_html = gr.HTML()
+            refresh_btn.click(library.refresh_projects, outputs=project_dropdown)
+            def on_select_project(proj_name): return library.generate_project_gallery(proj_name)
+            project_dropdown.change(on_select_project, project_dropdown, project_gallery_html)
+    
+    gr.Markdown(f"""
+        <hr>
+        <div style='text-align: center; font-size: 0.9em; color: #777;'>
+            <p>
+                <strong>{i18n('Desenvolvido por Rafael Godoy')}</strong>
+                <br>
+                {i18n('Apoie o projeto, qualquer valor é bem-vindo:')} 
+                <a href='https://nubank.com.br/pagar/1ls6a4/0QpSSbWBSq' target='_blank'><strong>{i18n('Apoiar via PIX')}</strong></a>
+                <br>
+                {i18n('100% local • open source • sem assinatura')} 
+            </p>
+        </div>
+        """)
+if __name__ == "__main__":
+    import webbrowser
+    import threading
+    import time
+    import argparse
+
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--colab", action="store_true", help="Run in Google Colab mode")
+    args = parser.parse_args()
+
+    if args.colab:
+        print("Running in Colab mode. Generating public link with Static Mounts...")
+        library.set_url_mode("fastapi")
+        
+        # Broaden allowed paths for Colab
+        allowed_dirs = [VIRALS_DIR, WORKING_DIR, os.getcwd(), "."]
+        
+        # Explicitly set static paths
+        try:
+            gr.set_static_paths(paths=allowed_dirs)
+            print(f"DEBUG: Registered static paths: {allowed_dirs}")
+        except AttributeError:
+            print("DEBUG: gr.set_static_paths not available")
+        
+        print(f"DEBUG: Allowed paths for Gradio: {allowed_dirs}")
+        
+        # Launch with prevent_thread_lock to allow mounting
+        app, local_url, share_url = demo.queue().launch(
+            share=True, 
+            allowed_paths=allowed_dirs,
+            prevent_thread_lock=True
+        )
+        
+        # Mount the VIRALS directory explicitly
+        app.mount("/virals", StaticFiles(directory=VIRALS_DIR), name="virals")
+        print(f"Mounted /virals to {VIRALS_DIR}")
+        
+        demo.block_thread()
+    else:
+        # Check environment
+        is_windows = (os.name == 'nt')
+        
+        library.set_url_mode("fastapi")
+        allowed_dirs = [VIRALS_DIR, WORKING_DIR, os.getcwd(), "."]
+        try:
+            gr.set_static_paths(paths=allowed_dirs)
+        except AttributeError: pass
+        
+        from fastapi.responses import FileResponse
+        from fastapi import BackgroundTasks
+
+        # Helper to attach routes to any FastAPI app (whether created by Gradio or us)
+        def attach_extra_routes(fastapi_app):
+            fastapi_app.mount("/virals", StaticFiles(directory=VIRALS_DIR), name="virals")
+            
+            @fastapi_app.get("/export_xml_api")
+            def export_xml_api(project: str, segment: int, background_tasks: BackgroundTasks, format: str = "premiere"):
+                try:
+                    project_path = os.path.join(VIRALS_DIR, project)
+                    script_path = os.path.join(WORKING_DIR, "scripts", "export_xml.py")
+                    cmd = [sys.executable, script_path, "--project", project_path, "--segment", str(segment), "--format", format]
+                    subprocess.run(cmd, check=True)
+                    proj_name = os.path.basename(project_path)
+                    zip_filename = f"export_{proj_name}_seg{segment}.zip"
+                    file_path = os.path.join(project_path, zip_filename)
+                    if os.path.exists(file_path):
+                        return FileResponse(file_path, filename=zip_filename, media_type='application/zip')
+                    else:
+                        return {"error": f"File generation failed. Expected: {file_path}"}
+                except Exception as e:
+                    return {"error": str(e)}
+            
+            print(f"Mounted /virals to {VIRALS_DIR}")
+
+        if is_windows:
+            print("Running in Windows environment (using Gradio launch for convenience).")
+            # Windows: Use demo.launch() for convenience (auto-browser, etc)
+            app, local_url, share_url = demo.queue().launch(
+                share=False, 
+                allowed_paths=allowed_dirs, 
+                inbrowser=True,
+                server_name="0.0.0.0",
+                server_port=7860,
+                prevent_thread_lock=True
+            )
+            attach_extra_routes(app)
+            demo.block_thread()
+        else:
+            print("Running in Linux/Container environment (using Uvicorn for stability).")
+            # Linux/HF: Use Uvicorn for explicit loop control
+            app = FastAPI()
+            attach_extra_routes(app)
+            # Disable SSR to prevent Node proxying issues on HF Spaces
+            app = gr.mount_gradio_app(app, demo.queue(), path="/", allowed_paths=allowed_dirs, ssr_mode=False)
+            uvicorn.run(app, host="0.0.0.0", port=7860)