Update app.py

app.py

@@ -1,746 +1,155 @@
 import gradio as gr
-import subprocess
 import os
 import tempfile
-import shutil
-import json
-import datetime
 from pathlib import Path
-import uuid
-import threading
-import asyncio
-from concurrent.futures import ThreadPoolExecutor
-import multiprocessing
-
-# 獲取 CPU 核心數用於並行處理
-CPU_COUNT = multiprocessing.cpu_count()
-MAX_WORKERS = max(1, CPU_COUNT - 1)  # 保留一個核心給系統
-
-# 創建必要的目錄
-SAVE_DIR = "auto_editor_saves"
-HISTORY_DIR = os.path.join(SAVE_DIR, "history")
-CONFIG_FILE = os.path.join(SAVE_DIR, "user_config.json")
-PROCESSED_FILES_DIR = os.path.join(SAVE_DIR, "processed_files")
-CACHE_DIR = os.path.join(SAVE_DIR, "cache")
-
-for directory in [SAVE_DIR, HISTORY_DIR, PROCESSED_FILES_DIR, CACHE_DIR]:
-    os.makedirs(directory, exist_ok=True)
-
-# 優化的預設參數配置（針對速度優化）
-SPEED_OPTIMIZED_CONFIG = {
-    "edit_mode": "Audio",  # Audio 模式通常比 Video 快
-    "margin": 0.1,  # 較小的邊距
-    "silence_threshold": 0.05,  # 稍微提高閾值，減少處理片段
-    "frame_margin": 0,  # 降低畫面邊距
-    "video_speed": 1.0,
-    "export_format": "與輸入相同",  # 避免格式轉換
-    "keep_audio": True,
-    "auto_save_enabled": True,
-    "keep_history_days": 3,  # 減少保留天數
-    "enable_fast_mode": True,  # 新增快速模式
-    "parallel_processing": True,  # 啟用並行處理
-    "use_gpu_acceleration": False,  # CPU 環境
-    "compress_output": False,  # 避免額外壓縮
-    "preview_mode": False  # 預覽模式（更快但品質略低）
-}
-
-def get_file_hash(file_path):
-    """計算檔案雜湊值用於快取"""
-    import hashlib
-    hash_md5 = hashlib.md5()
-    try:
-        with open(file_path, "rb") as f:
-            for chunk in iter(lambda: f.read(4096), b""):
-                hash_md5.update(chunk)
-        return hash_md5.hexdigest()
-    except:
-        return None
+import subprocess
+import shutil
 
-def check_cache(file_path, config):
-    """檢查是否有快取的處理結果"""
+def setup_environment():
+    """設置環境和必要的系統包"""
     try:
-        file_hash = get_file_hash(file_path)
-        if not file_hash:
-            return None
-            
-        config_str = json.dumps(config, sort_keys=True)
-        cache_key = f"{file_hash}_{hash(config_str)}"
-        cache_file = os.path.join(CACHE_DIR, f"{cache_key}.json")
-        
-        if os.path.exists(cache_file):
-            with open(cache_file, 'r', encoding='utf-8') as f:
-                cache_data = json.load(f)
-                output_file = cache_data.get('output_file')
-                if output_file and os.path.exists(output_file):
-                    return output_file, cache_data.get('log', '')
+        # 安裝FFmpeg (如果需要)
+        subprocess.run(["apt", "update"], check=True, capture_output=True)
+        subprocess.run(["apt", "install", "-y", "ffmpeg"], check=True, capture_output=True)
     except:
         pass
-    return None
 
-def save_cache(file_path, config, output_file, log):
-    """保存處理結果到快取"""
-    try:
-        file_hash = get_file_hash(file_path)
-        if not file_hash:
-            return
-            
-        config_str = json.dumps(config, sort_keys=True)
-        cache_key = f"{file_hash}_{hash(config_str)}"
-        cache_file = os.path.join(CACHE_DIR, f"{cache_key}.json")
-        
-        cache_data = {
-            'output_file': output_file,
-            'log': log,
-            'created_at': datetime.datetime.now().isoformat()
-        }
-        
-        with open(cache_file, 'w', encoding='utf-8') as f:
-            json.dump(cache_data, f, ensure_ascii=False, indent=2)
-    except:
-        pass
-
-def optimize_video_for_processing(input_path):
-    """預處理影片以提升處理速度"""
-    try:
-        file_size = os.path.getsize(input_path) / (1024 * 1024)  # MB
-        
-        # 如果檔案超過 100MB，建議壓縮
-        if file_size > 100:
-            optimized_path = os.path.join(CACHE_DIR, f"optimized_{os.path.basename(input_path)}")
-            
-            # 使用 FFmpeg 快速壓縮（降低解析度和位元率）
-            compress_cmd = [
-                'ffmpeg', '-i', input_path,
-                '-c:v', 'libx264',  # 使用 H.264 編碼
-                '-preset', 'ultrafast',  # 最快編碼預設
-                '-crf', '28',  # 稍微降低品質以提升速度
-                '-c:a', 'aac',  # 音訊使用 AAC
-                '-b:a', '128k',  # 降低音訊位元率
-                '-y', optimized_path  # 覆蓋輸出
-            ]
-            
-            result = subprocess.run(compress_cmd, capture_output=True, text=True, timeout=120)
-            if result.returncode == 0 and os.path.exists(optimized_path):
-                return optimized_path, f"已預壓縮 ({file_size:.1f}MB → {os.path.getsize(optimized_path)/(1024*1024):.1f}MB)"
-        
-        return input_path, ""
-    except:
-        return input_path, ""
-
-def build_optimized_command(input_path, config):
-    """構建優化的 auto-editor 命令"""
-    cmd = ['auto-editor', input_path]
-    
-    # 基本編輯參數
-    if config['edit_mode'] != "自動檢測":
-        cmd.extend(['--edit', config['edit_mode'].lower()])
+def download_and_clone_repo():
+    """克隆GitHub倉庫"""
+    repo_url = "https://github.com/SamurAIGPT/AI-Youtube-Shorts-Generator.git"
+    repo_dir = "./AI-Youtube-Shorts-Generator"
     
-    # 速度優化參數
-    if config.get('enable_fast_mode', True):
-        # 快速模式：減少精確度換取速度
-        cmd.extend(['--frame_margin', '0'])  # 最小畫面邊距
-        if config['margin'] > 0:
-            cmd.extend(['--margin', f"{min(config['margin'], 0.1)}sec"])  # 限制邊距
-    else:
-        # 標準模式
-        if config['margin'] > 0:
-            cmd.extend(['--margin', f"{config['margin']}sec"])
-        if config['frame_margin'] > 0:
-            cmd.extend(['--frame_margin', str(config['frame_margin'])])
+    if not os.path.exists(repo_dir):
+        subprocess.run(["git", "clone", repo_url], check=True)
     
-    # 靜音閾值優化
-    threshold = max(config['silence_threshold'], 0.03)  # 最小閾值避免過度處理
-    cmd.extend(['--silent_threshold', str(threshold)])
-    
-    # 影片速度
-    if config['video_speed'] != 1.0:
-        cmd.extend(['--video_speed', str(config['video_speed'])])
-    
-    # CPU 優化參數
-    if config.get('parallel_processing', True):
-        cmd.extend(['--temp_dir', CACHE_DIR])  # 使用快取目錄
-    
-    # 預覽模式（犧牲一點品質換取速度）
-    if config.get('preview_mode', False):
-        cmd.extend(['--quality', 'draft'])
-    
-    return cmd
+    return repo_dir
 
-async def process_video_async(input_path, config, output_path, progress_callback=None):
-    """異步處理影片"""
-    def run_command():
-        cmd = build_optimized_command(input_path, config)
-        cmd.extend(['--output', output_path])
-        
-        # 使用 Popen 以便實時獲取進度
-        process = subprocess.Popen(
-            cmd,
-            stdout=subprocess.PIPE,
-            stderr=subprocess.PIPE,
-            text=True,
-            bufsize=1,
-            universal_newlines=True
-        )
-        
-        stdout_lines = []
-        stderr_lines = []
-        
-        # 實時讀取輸出
-        while True:
-            output = process.stdout.readline()
-            if output == '' and process.poll() is not None:
-                break
-            if output:
-                stdout_lines.append(output.strip())
-                if progress_callback:
-                    progress_callback(output.strip())
-        
-        # 讀取剩餘錯誤輸出
-        stderr_output = process.stderr.read()
-        if stderr_output:
-            stderr_lines.append(stderr_output)
-        
-        return process.returncode, '\n'.join(stdout_lines), '\n'.join(stderr_lines)
+def process_youtube_video(youtube_url, openai_api_key, progress=gr.Progress()):
+    """處理YouTube視頻生成Shorts"""
     
-    # 在執行緒池中運行
-    loop = asyncio.get_event_loop()
-    with ThreadPoolExecutor(max_workers=1) as executor:
-        return await loop.run_in_executor(executor, run_command)
-
-def edit_video_optimized(input_file, edit_mode, margin, silence_threshold, frame_margin,
-                        video_speed, export_format, keep_audio, auto_save_enabled, 
-                        enable_fast_mode, parallel_processing, preview_mode):
+    if not youtube_url or not openai_api_key:
+        return None, "請提供YouTube URL和OpenAI API Key"
     
-    if not input_file:
-        return "請上傳檔案。", None, "", "暫無處理記錄", "等待中..."
+    progress(0.1, desc="初始化環境...")
+    setup_environment()
     
-    # 合併配置
-    current_config = {
-        "edit_mode": edit_mode,
-        "margin": margin,
-        "silence_threshold": silence_threshold,
-        "frame_margin": frame_margin,
-        "video_speed": video_speed,
-        "export_format": export_format,
-        "keep_audio": keep_audio,
-        "auto_save_enabled": auto_save_enabled,
-        "enable_fast_mode": enable_fast_mode,
-        "parallel_processing": parallel_processing,
-        "preview_mode": preview_mode
-    }
+    progress(0.2, desc="克隆項目代碼...")
+    repo_dir = download_and_clone_repo()
     
-    input_path = input_file.name
-    start_time = datetime.datetime.now()
+    # 設置環境變量
+    env = os.environ.copy()
+    env["OPENAI_API"] = openai_api_key
     
     try:
-        # 檢查快取
-        cache_result = check_cache(input_path, current_config)
-        if cache_result and auto_save_enabled:
-            cached_file, cached_log = cache_result
-            processing_time = "< 1秒 (來自快取)"
-            status = f"⚡ 快取命中！\n檔案大小: {os.path.getsize(cached_file)/(1024*1024):.1f} MB\n處理時間: {processing_time}"
-            return status, cached_file, cached_log, get_processing_history(), "✅ 完成 (快取)"
-        
-        # 預處理優化
-        optimized_path, pre_log = optimize_video_for_processing(input_path)
+        progress(0.3, desc="開始處理視頻...")
         
-        # 設定輸出路徑
-        file_extension = Path(input_path).suffix
-        if export_format == "與輸入相同":
-            output_extension = file_extension
-        else:
-            output_extension = f".{export_format.lower()}"
+        # 切換到項目目錄
+        original_dir = os.getcwd()
+        os.chdir(repo_dir)
         
-        timestamp = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
-        original_name = Path(input_path).stem
-        output_filename = f"{original_name}_edited_{timestamp}{output_extension}"
-        
-        if auto_save_enabled:
-            output_path = os.path.join(PROCESSED_FILES_DIR, output_filename)
-        else:
-            with tempfile.NamedTemporaryFile(suffix=output_extension, delete=False) as tmp_file:
-                output_path = tmp_file.name
+        # 安裝項目依賴
+        subprocess.run(["pip", "install", "-r", "requirements.txt"], 
+                      check=True, env=env)
         
-        # 構建優化命令
-        cmd = build_optimized_command(optimized_path, current_config)
-        cmd.extend(['--output', output_path])
+        progress(0.5, desc="下載和分析視頻...")
         
-        # 執行處理
-        progress_log = ["🚀 開始處理..."]
+        # 創建臨時輸入文件來模擬用戶輸入
+        with tempfile.NamedTemporaryFile(mode='w', delete=False, suffix='.txt') as f:
+            f.write(youtube_url + '\n')
+            input_file = f.name
         
-        def update_progress(line):
-            if "%" in line or "進度" in line.lower() or "progress" in line.lower():
-                progress_log.append(f"📊 {line}")
+        # 運行主程序
+        with open(input_file, 'r') as f:
+            result = subprocess.run(
+                ["python", "main.py"], 
+                stdin=f,
+                capture_output=True, 
+                text=True, 
+                env=env,
+                timeout=300  # 5分鐘超時
+            )
         
-        # 使用優化的超時時間
-        timeout = 300 if enable_fast_mode else 600  # 快速模式 5分鐘，標準模式 10分鐘
+        progress(0.8, desc="生成Shorts視頻...")
         
-        process = subprocess.Popen(
-            cmd,
-            stdout=subprocess.PIPE,
-            stderr=subprocess.PIPE,
-            text=True
-        )
+        # 清理臨時文件
+        os.unlink(input_file)
         
-        stdout, stderr = process.communicate(timeout=timeout)
+        # 查找生成的視頻文件
+        output_files = []
+        for ext in ['*.mp4', '*.mov', '*.avi']:
+            output_files.extend(Path('.').glob(f"**/{ext}"))
         
-        processing_time = datetime.datetime.now() - start_time
-        processing_seconds = processing_time.total_seconds()
+        os.chdir(original_dir)
         
-        if process.returncode == 0:
-            file_size = os.path.getsize(output_path) / (1024 * 1024)
-            
-            # 計算處理速度
-            input_size = os.path.getsize(input_path) / (1024 * 1024)
-            speed_ratio = input_size / processing_seconds if processing_seconds > 0 else 0
-            
-            status = f"✅ 編輯完成！\n"
-            if pre_log:
-                status += f"{pre_log}\n"
-            status += f"檔案: {output_filename}\n大小: {file_size:.1f} MB\n"
-            status += f"處理時間: {processing_seconds:.1f}秒\n"
-            status += f"處理速度: {speed_ratio:.1f} MB/秒"
-            
-            if auto_save_enabled:
-                status += f"\n💾 已自動保存"
-            
-            log_output = f"命令: {' '.join(cmd)}\n\n{pre_log}\n\n標準輸出:\n{stdout}"
-            
-            # 保存到快取
-            if auto_save_enabled:
-                save_cache(input_path, current_config, output_path, log_output)
-                save_to_history(input_path, current_config, output_path, status, log_output)
-            
-            # 清理臨時檔案
-            if optimized_path != input_path:
-                try:
-                    os.remove(optimized_path)
-                except:
-                    pass
-            
-            return status, output_path, log_output, get_processing_history(), "✅ 完成"
+        progress(1.0, desc="處理完成!")
         
+        if output_files:
+            # 返回第一個找到的視頻文件
+            video_path = str(output_files[0])
+            return video_path, f"成功生成 {len(output_files)} 個Shorts視頻!"
         else:
-            error_msg = f"❌ 處理失敗\n處理時間: {processing_seconds:.1f}秒\n錯誤: {stderr}"
-            log_output = f"命令: {' '.join(cmd)}\n\n錯誤輸出:\n{stderr}\n\n標準輸出:\n{stdout}"
-            
-            if auto_save_enabled:
-                save_to_history(input_path, current_config, None, error_msg, log_output)
+            return None, f"處理完成但未找到輸出視頻。\n控制台輸出：\n{result.stdout}\n錯誤：\n{result.stderr}"
             
-            return error_msg, None, log_output, get_processing_history(), "❌ 失敗"
-    
     except subprocess.TimeoutExpired:
-        error_msg = f"⏰ 處理超時 ({timeout//60}分鐘限制)"
-        if auto_save_enabled:
-            save_to_history(input_path, current_config, None, error_msg, "處理超時")
-        return error_msg, None, "建議使用快速模式或較小檔案", get_processing_history(), "⏰ 超時"
-    
-    except Exception as e:
-        error_msg = f"❌ 系統錯誤: {str(e)}"
-        if auto_save_enabled:
-            save_to_history(input_path, current_config, None, error_msg, str(e))
-        return error_msg, None, f"例外錯誤: {str(e)}", get_processing_history(), "❌ 錯誤"
-
-# [保留之前的其他函數：load_user_config, save_user_config, save_to_history, get_processing_history, cleanup_old_files, get_file_info, export_settings]
-
-def load_user_config():
-    """載入使用者設定"""
-    try:
-        if os.path.exists(CONFIG_FILE):
-            with open(CONFIG_FILE, 'r', encoding='utf-8') as f:
-                config = json.load(f)
-                return {**SPEED_OPTIMIZED_CONFIG, **config}
-    except Exception as e:
-        print(f"載入配置失敗: {e}")
-    return SPEED_OPTIMIZED_CONFIG.copy()
-
-def save_user_config(config):
-    """保存使用者設定"""
-    try:
-        with open(CONFIG_FILE, 'w', encoding='utf-8') as f:
-            json.dump(config, f, ensure_ascii=False, indent=2)
-        return "✅ 設定已保存"
-    except Exception as e:
-        return f"❌ 保存設定失敗: {e}"
-
-def save_to_history(input_file, config, output_file, status, log):
-    """保存處理歷史"""
-    try:
-        timestamp = datetime.datetime.now()
-        history_id = str(uuid.uuid4())[:8]
-        
-        history_record = {
-            "id": history_id,
-            "timestamp": timestamp.isoformat(),
-            "input_file": os.path.basename(input_file) if input_file else "unknown",
-            "config": config,
-            "output_file": os.path.basename(output_file) if output_file else None,
-            "status": status,
-            "log": log[:500] if log else ""  # 限制日誌長度
-        }
-        
-        history_file = os.path.join(HISTORY_DIR, f"{timestamp.strftime('%Y%m%d_%H%M%S')}_{history_id}.json")
-        with open(history_file, 'w', encoding='utf-8') as f:
-            json.dump(history_record, f, ensure_ascii=False, indent=2)
-        
-        return history_id
-    except Exception as e:
-        print(f"保存歷史失敗: {e}")
-        return None
-
-def get_processing_history():
-    """獲取處理歷史"""
-    try:
-        history_files = sorted([f for f in os.listdir(HISTORY_DIR) if f.endswith('.json')], reverse=True)
-        history = []
-        
-        for file_name in history_files[:15]:  # 減少到15條以提升載入速度
-            try:
-                with open(os.path.join(HISTORY_DIR, file_name), 'r', encoding='utf-8') as f:
-                    record = json.load(f)
-                    timestamp = datetime.datetime.fromisoformat(record['timestamp'])
-                    status_icon = "✅" if "完成" in record['status'] else ("⚡" if "快取" in record['status'] else "❌")
-                    history.append(f"{status_icon} {timestamp.strftime('%m/%d %H:%M')} - {record['input_file']}")
-            except:
-                continue
-        
-        return "\n".join(history) if history else "暫無處理記錄"
-    except:
-        return "讀取歷史記錄失敗"
-
-def cleanup_old_files(days=3):  # 減少為3天
-    """清理舊檔案"""
-    try:
-        cutoff_date = datetime.datetime.now() - datetime.timedelta(days=days)
-        
-        # 清理歷史記錄
-        for file_name in os.listdir(HISTORY_DIR):
-            file_path = os.path.join(HISTORY_DIR, file_name)
-            if os.path.getctime(file_path) < cutoff_date.timestamp():
-                os.remove(file_path)
-        
-        # 清理處理過的檔案
-        for file_name in os.listdir(PROCESSED_FILES_DIR):
-            file_path = os.path.join(PROCESSED_FILES_DIR, file_name)
-            if os.path.getctime(file_path) < cutoff_date.timestamp():
-                os.remove(file_path)
-        
-        # 清理快取
-        for file_name in os.listdir(CACHE_DIR):
-            if file_name.endswith('.json') or file_name.startswith('optimized_'):
-                file_path = os.path.join(CACHE_DIR, file_name)
-                if os.path.getctime(file_path) < cutoff_date.timestamp():
-                    os.remove(file_path)
-                
-        return f"✅ 已清理 {days} 天前的檔案"
+        return None, "處理超時。請嘗試較短的視頻或檢查網絡連接。"
     except Exception as e:
-        return f"❌ 清理失敗: {e}"
+        os.chdir(original_dir)
+        return None, f"處理過程中出���錯誤：{str(e)}"
 
-def get_file_info(file):
-    if file is None:
-        return "未選擇檔案"
-    
-    try:
-        file_size = os.path.getsize(file.name) / (1024 * 1024)  # MB
-        file_ext = Path(file.name).suffix
-        
-        # 添加處理時間預估
-        if file_size < 10:
-            time_estimate = "< 1分鐘"
-        elif file_size < 50:
-            time_estimate = "1-3分鐘"
-        elif file_size < 100:
-            time_estimate = "3-5分鐘"
-        else:
-            time_estimate = "5-10分鐘 (建議開啟快速模式)"
-        
-        return f"檔案: {Path(file.name).name}\n大小: {file_size:.1f} MB\n格式: {file_ext}\n預估處理時間: {time_estimate}"
-    except:
-        return "無法讀取檔案資訊"
-
-def export_settings(edit_mode, margin, silence_threshold, frame_margin, video_speed, 
-                   export_format, keep_audio, enable_fast_mode, parallel_processing, preview_mode):
-    """匯出當前設定"""
-    settings = {
-        "edit_mode": edit_mode,
-        "margin": margin,
-        "silence_threshold": silence_threshold,
-        "frame_margin": frame_margin,
-        "video_speed": video_speed,
-        "export_format": export_format,
-        "keep_audio": keep_audio,
-        "enable_fast_mode": enable_fast_mode,
-        "parallel_processing": parallel_processing,
-        "preview_mode": preview_mode,
-        "exported_at": datetime.datetime.now().isoformat()
-    }
-    
-    export_filename = f"auto_editor_settings_{datetime.datetime.now().strftime('%Y%m%d_%H%M%S')}.json"
-    export_path = os.path.join(SAVE_DIR, export_filename)
-    
-    try:
-        with open(export_path, 'w', encoding='utf-8') as f:
-            json.dump(settings, f, ensure_ascii=False, indent=2)
-        return export_path, f"✅ 設定已匯出到 {export_filename}"
-    except Exception as e:
-        return None, f"❌ 匯出失敗: {e}"
-
-# 載入優化設定
-user_config = load_user_config()
-
-# 建立速度優化版介面
-with gr.Blocks(
-    title="Auto-Editor 速度優化版", 
-    theme=gr.themes.Soft(),
-    css="""
-    .gradio-container {max-width: 1400px !important}
-    .status-box {font-family: monospace; white-space: pre-wrap;}
-    .speed-indicator {background: linear-gradient(45deg, #00ff00, #ffff00); padding: 5px; border-radius: 5px;}
-    .history-box {font-family: monospace; font-size: 12px; max-height: 150px; overflow-y: auto;}
-    """
-) as iface:
-    
+# 創建Gradio界面
+with gr.Blocks(title="AI YouTube Shorts Generator") as demo:
     gr.Markdown("""
-    # 🚀 Auto-Editor 速度優化版 (極速處理)
+    # 🎬 AI YouTube Shorts Generator
     
-    **🔥 速度優化特色:**
-    - ⚡ **智能快取**: 相同檔案+參數的處理結果會被快取，再次處理秒出結果
-    - 🔄 **預處理優化**: 大檔案自動壓縮，提升處理速度
-    - 🎯 **快速模式**: 犧牲少量品質換取 2-3倍處理速度
-    - 💻 **並行處理**: 充分利用多核心 CPU 加速處理
-    - 📊 **實時進度**: 顯示處理進度和速度統計
-    - 🗂️ **智能參數**: 預設參數已針對速度優化
+    將長視頻自動轉換為吸引人的YouTube Shorts！
     
-    **⏱️ 處理速度提升:**
-    - 小檔案 (<10MB): 通常 < 30秒
-    - 中檔案 (10-50MB): 1-2分鐘  
-    - 大檔案 (50-100MB): 2-5分鐘
-    - 快取命中: < 1秒 ⚡
+    ## 功能特點：
+    - 🎯 自動提取視頻亮點
+    - 🗣️ 智能說話者檢測  
+    - ✂️ 垂直格式裁剪
+    - 🤖 基於GPT-4的內容分析
     """)
     
-    with gr.Row():
-        # 左側：檔案和基本設定
-        with gr.Column(scale=2):
-            gr.Markdown("### 📁 檔案輸入")
-            
-            input_file = gr.File(
-                label="上傳影片或音訊檔案 (建議 <100MB)",
-                file_types=['video', 'audio'],
-                file_count="single"
-            )
-            
-            file_info = gr.Textbox(
-                label="檔案資訊 & 時間預估",
-                interactive=False,
-                lines=4
-            )
-            
-            gr.Markdown("### ⚙️ 基本編輯設定")
-            
-            edit_mode = gr.Dropdown(
-                label="編輯模式",
-                choices=["自動檢測", "Audio", "Video", "Subtitle", "Motion"],
-                value=user_config["edit_mode"],
-                info="💡 Audio 模式通常比 Video 快 2-3倍"
-            )
-            
-            margin = gr.Slider(
-                label="邊距時間 (秒)",
-                minimum=0,
-                maximum=1.0,  # 減少最大值提升速度
-                value=user_config["margin"],
-                step=0.05,
-                info="⚡ 較小值處理更快"
-            )
-            
-            silence_threshold = gr.Slider(
-                label="靜音閾值",
-                minimum=0.03,  # 提高最小值
-                maximum=0.3,
-                value=user_config["silence_threshold"],
-                step=0.01,
-                info="⚡ 較高值處理更快，但可能遺漏輕微聲音"
-            )
-        
-        # 右側：速度優化設定
-        with gr.Column(scale=2):
-            gr.Markdown("### 🚀 速度優化選項")
-            
-            enable_fast_mode = gr.Checkbox(
-                label="🔥 啟用快速模式",
-                value=user_config.get("enable_fast_mode", True),
-                info="犧牲少量品質換取 2-3倍速度提升"
-            )
-            
-            parallel_processing = gr.Checkbox(
-                label="💻 啟用並行處理",
-                value=user_config.get("parallel_processing", True),
-                info=f"使用多核心 CPU ({CPU_COUNT} 核心可用)"
-            )
-            
-            preview_mode = gr.Checkbox(
-                label="👁️ 預覽模式",
-                value=user_config.get("preview_mode", False),
-                info="更快處理但輸出品質稍低，適合測試參數"
-            )
-            
-            gr.Markdown("### 🔧 輸出設定")
-            
-            export_format = gr.Dropdown(
-                label="輸出格式",
-                choices=["與輸入相同", "MP4", "MP3", "WAV"],  # 減少選項
-                value=user_config["export_format"],
-                info="💡 保持原格式最快"
-            )
-            
-            video_speed = gr.Slider(
-                label="影片速度倍率",
-                minimum=0.5,
-                maximum=3.0,
-                value=user_config["video_speed"],
-                step=0.25
-            )
-            
-            auto_save_enabled = gr.Checkbox(
-                label="💾 啟用自動保存 & 快取",
-                value=user_config["auto_save_enabled"],
-                info="啟用快取功能，相同處理秒出結果"
-            )
-    
-    # 進度和控制區域
     with gr.Row():
         with gr.Column(scale=1):
-            edit_btn = gr.Button(
-                "🚀 開始極速處理",
-                variant="primary",
-                size="lg"
+            youtube_url = gr.Textbox(
+                label="YouTube視頻URL", 
+                placeholder="https://www.youtube.com/watch?v=...",
+                info="請輸入要處理的YouTube視頻鏈接"
             )
             
-            progress_status = gr.Textbox(
-                label="⚡ 處理進度",
-                lines=2,
-                elem_classes=["speed-indicator"],
-                interactive=False
+            openai_key = gr.Textbox(
+                label="OpenAI API Key", 
+                type="password",
+                placeholder="sk-...",
+                info="需要GPT-4訪問權限的API Key"
             )
-        
-        with gr.Column(scale=1):
-            with gr.Row():
-                export_settings_btn = gr.Button("匯出設定", size="sm")
-                cleanup_btn = gr.Button("清理快取", size="sm")
             
-            export_status = gr.Textbox(
-                label="系統狀態",
-                lines=2,
-                interactive=False
-            )
-    
-    # 輸出結果區域
-    gr.Markdown("### 📤 處理結果")
-    
-    with gr.Row():
-        with gr.Column(scale=2):
-            status_output = gr.Textbox(
-                label="📊 處理狀態 & 統計",
-                lines=8,
-                elem_classes=["status-box"]
-            )
+            process_btn = gr.Button("🚀 生成Shorts", variant="primary")
             
-            download_file = gr.File(
-                label="⬇️ 下載處理完成的檔案",
-                interactive=False
-            )
-        
-        with gr.Column(scale=2):
-            log_output = gr.Textbox(
-                label="📋 詳細日誌",
-                lines=8,
-                elem_classes=["status-box"],
-                show_copy_button=True
-            )
-    
-    # 簡化的歷史記錄
-    gr.Markdown("### 📈 最近處理記錄")
-    processing_history = gr.Textbox(
-        label="最近15次處理 (⚡=快取命中, ✅=成功, ❌=失敗)",
-        lines=6,
-        elem_classes=["history-box"],
-        value=get_processing_history(),
-        interactive=False
-    )
-    
-    exported_file = gr.File(
-        label="匯出的設定檔",
-        interactive=False,
-        visible=False
-    )
+        with gr.Column(scale=1):
+            output_video = gr.Video(label="生成的Shorts視頻")
+            output_message = gr.Textbox(label="處理狀態", lines=5)
     
-    # 速度優化提示
     gr.Markdown("""
-    ### 💡 極速處理技巧
-    
-    **🔥 最快設定組合:**
-    - ✅ 啟用快速模式 + 並行處理
-    - ✅ 使用 Audio 編輯模式（對影片也有效）
-    - ✅ 邊距時間設為 0.1秒 或更低
-    - ✅ 靜音閾值稍微提高到 0.05-0.08
-    - ✅ 保持與輸入相同的格式
-    
-    **⚡ 快取系統:**
-    - 相同檔案 + 相同參數 = 秒出結果
-    - 修改參數前建議先測試小檔案
-    - 定期清理快取釋放空間
-    
-    **📊 處理速度參考:**
-    - 音訊檔案: 2-5x 實時速度
-    - 影片檔案: 0.5-2x 實時速度  
-    - 快取命中: 幾乎瞬間完成
-    
-    **🎯 大檔案策略:**
-    - 系統會自動預壓縮 >100MB 的檔案
-    - 建議先用預覽模式測試參數
-    - 可將長影片分段處理後合併
+    ## 使用說明：
+    1. 輸入YouTube視頻URL
+    2. 提供OpenAI API Key (需要GPT-4權限)
+    3. 點擊生成按鈕等待處理完成
+    4. 下載生成的Shorts視頻
+    
+    ## 注意事項：
+    - 處理時間取決於視頻長度，通常需要2-5分鐘
+    - 確保YouTube視頻可以公開訪問
+    - API Key將用於內容分析，不會被保存
     """)
     
-    # 事件綁定
-    input_file.change(
-        fn=get_file_info,
-        inputs=[input_file],
-        outputs=[file_info]
-    )
-    
-    edit_btn.click(
-        fn=edit_video_optimized,
-        inputs=[
-            input_file, edit_mode, margin, silence_threshold,
-            frame_margin, video_speed, export_format, keep_audio, auto_save_enabled,
-            enable_fast_mode, parallel_processing, preview_mode
-        ],
-        outputs=[status_output, download_file, log_output, processing_history, progress_status]
-    )
-    
-    export_settings_btn.click(
-        fn=export_settings,
-        inputs=[edit_mode, margin, silence_threshold, frame_margin, video_speed, 
-               export_format, keep_audio, enable_fast_mode, parallel_processing, preview_mode],
-        outputs=[exported_file, export_status]
-    )
-    
-    cleanup_btn.click(
-        fn=cleanup_old_files,
-        inputs=[],
-        outputs=[export_status]
+    process_btn.click(
+        fn=process_youtube_video,
+        inputs=[youtube_url, openai_key],
+        outputs=[output_video, output_message],
+        show_progress=True
     )
 
 if __name__ == "__main__":
-    # 啟動時清理並顯示系統資訊
-    print(f"🚀 Auto-Editor 速度優化版啟動")
-    print(f"💻 CPU 核心數: {CPU_COUNT}")
-    print(f"🧵 最大工作執行緒: {MAX_WORKERS}")
-    
-    cleanup_old_files(3)
-    
-    iface.launch(
-        server_name="0.0.0.0",
-        server_port=7860,
-        show_error=True
-    )
+    demo.launch()