Update app.py

app.py

@@ -1,50 +1,662 @@
----
-title: ElevenLabs TTS Pro
-emoji: 🎤
-colorFrom: blue
-colorTo: green
-sdk: gradio
-sdk_version: 4.0.0
-app_file: app.py
-pinned: false
----
+# app.py cho Hugging Face Spaces
+# -*- coding: utf-8 -*-
 
-# 🎤 ElevenLabs TTS Pro
+import os, re, time, random, json, tempfile, shutil
+from pathlib import Path
+import requests
+import gradio as gr
+from pydub import AudioSegment
+import natsort
+import asyncio
+from concurrent.futures import ThreadPoolExecutor
+import hashlib
 
-Công cụ chuyển văn bản thành giọng nói chuyên nghiệp sử dụng API của ElevenLabs.
+# ==================== HÀM GỐC ====================
+def merge_audio_files(input_folder, format, output_filename, silence_ms=300):
+    audio_files = [f for f in os.listdir(input_folder) if f.lower().endswith(f".{format.lower()}")]
+    if not audio_files:
+        return None
+    audio_files = natsort.natsorted(audio_files)
+    combined = AudioSegment.from_file(os.path.join(input_folder, audio_files[0]), format=format.lower())
+    for audio_file in audio_files[1:]:
+        audio = AudioSegment.from_file(os.path.join(input_folder, audio_file), format=format.lower())
+        combined += AudioSegment.silent(duration=silence_ms)
+        combined += audio
+    output_path = f"{output_filename}.{format.lower()}"
+    combined.export(output_path, format=format.lower())
+    return output_path
 
-## 🚀 Tính năng
+def check_api_key(api_key):
+    try:
+        res = requests.get(
+            "https://api.elevenlabs.io/v1/user",
+            headers={"xi-api-key": api_key.strip()},
+            timeout=10
+        )
+        if res.status_code == 200:
+            sub = res.json().get("subscription", {})
+            return {
+                "valid": True,
+                "remaining": sub.get("character_limit", 0) - sub.get("character_count", 0),
+                "total": sub.get("character_limit", 0)
+            }
+        return {"valid": False, "message": f"Status code: {res.status_code}"}
+    except Exception as e:
+        return {"valid": False, "message": str(e)}
 
-- 🤖 Hỗ trợ nhiều API keys của ElevenLabs
-- 🎭 Tạo giọng nói với nhiều thông số tùy chỉnh
-- 📝 Hỗ trợ văn bản dài, tự động chia đoạn
-- 💾 Xuất file audio (MP3, WAV, OGG, FLAC)
-- 📄 Tạo file phụ đề SRT tự động
-- 📁 Tải cấu hình từ file (TXT, JSON, ENV)
+def generate_voice(text, api_key, voice_id, model_id,
+                   stability=0.7, similarity=0.8, style=0.0, speed=0.75, speaker_boost=True):
+    time.sleep(random.uniform(0.5, 1.5))  # Giảm delay để nhanh hơn
+    url = f"https://api.elevenlabs.io/v1/text-to-speech/{voice_id}"
+    headers = {"xi-api-key": api_key.strip(), "Content-Type": "application/json"}
+    payload = {
+        "text": text,
+        "model_id": model_id,
+        "voice_settings": {
+            "stability": stability,
+            "similarity_boost": similarity,
+            "style": style,
+            "speed": speed,
+            "use_speaker_boost": speaker_boost
+        }
+    }
+    try:
+        res = requests.post(url, headers=headers, json=payload, timeout=30)
+        if res.status_code == 200:
+            return res.content
+        elif res.status_code == 429:
+            time.sleep(2)  # Giảm thời gian chờ
+            return None
+        else:
+            return None
+    except:
+        return None
+    return None
 
-## 🔧 Cách sử dụng
+def parse_text_blocks(raw_text, max_length=200):
+    blocks = []
+    current = ""
+    for s in re.split(r'(?<=[.!?])\s+', raw_text):
+        if len(current) + len(s) <= max_length:
+            if current:
+                current += " " + s
+            else:
+                current = s
+        else:
+            if current:
+                blocks.append(current.strip())
+            current = s
+    if current:
+        blocks.append(current.strip())
+    return blocks
 
-1. **Nhập API Keys**: Lấy từ [ElevenLabs](https://elevenlabs.io/) và nhập vào ô API Keys
-2. **Nhập Voice ID**: Voice ID từ ElevenLabs (VD: `21m00Tcm4TlvDq8ikWAM`)
-3. **Nhập văn bản**: Văn bản cần chuyển thành giọng nói
-4. **Tùy chỉnh thông số**: Stability, Similarity, Style, Speed
-5. **Nhấn "Bắt đầu Tạo Giọng nói"**
+def estimate_credit(text):
+    return len(text) + 50
 
-## 📁 Định dạng file hỗ trợ
+def ms_to_srt_time(ms):
+    h = ms // 3600000
+    m = (ms % 3600000) // 60000
+    s = (ms % 60000) // 1000
+    ms = ms % 1000
+    return f"{h:02d}:{m:02d}:{s:02d},{ms:03d}"
 
-- **API Keys**: `.txt`, `.json`, `.env`
-- **Voice IDs**: `.txt`, `.json`
-- **Văn bản**: `.txt`, `.json`
+def create_srt(voice_dir, texts, silence_ms=300):
+    files_audio = natsort.natsorted([f for f in os.listdir(voice_dir) if f.startswith("voice_")])
+    current_time = 0
+    srt_lines = []
+    for idx, (fname, text) in enumerate(zip(files_audio, texts), start=1):
+        try:
+            audio = AudioSegment.from_file(os.path.join(voice_dir, fname))
+            start = current_time
+            end = start + len(audio)
+            srt_lines.append(str(idx))
+            srt_lines.append(f"{ms_to_srt_time(start)} --> {ms_to_srt_time(end)}")
+            srt_lines.append(text.strip())
+            srt_lines.append("")
+            current_time = end + silence_ms
+        except:
+            continue
+    if srt_lines:
+        srt_path = os.path.join(voice_dir, "output_full.srt")
+        with open(srt_path, "w", encoding="utf-8") as f:
+            f.write("\n".join(srt_lines))
+        return srt_path
+    return None
 
-## ⚠️ Lưu ý
+def extract_api_keys_from_content(content):
+    """Trích xuất API keys từ nội dung"""
+    api_keys = []
+    
+    # Tìm tất cả chuỗi bắt đầu bằng sk_
+    pattern = r'sk_[a-zA-Z0-9]{20,}'
+    matches = re.findall(pattern, content)
+    api_keys.extend(matches)
+    
+    # Tìm trong định dạng KEY=sk_...
+    lines = content.splitlines()
+    for line in lines:
+        line = line.strip()
+        if '=' in line:
+            parts = line.split('=', 1)
+            if len(parts) == 2 and parts[1].strip().startswith('sk_'):
+                api_keys.append(parts[1].strip())
+    
+    # Loại bỏ trùng lặp
+    unique_keys = []
+    for key in api_keys:
+        if key and key not in unique_keys:
+            unique_keys.append(key)
+    
+    return unique_keys
 
-- Cần có API key hợp lệ từ ElevenLabs
-- Giới hạn ký tự theo gói subscription của bạn
-- File tạo ra sẽ được lưu tạm thời và tự động xóa sau phiên làm việc
+def extract_voice_ids_from_content(content):
+    """Trích xuất Voice IDs từ nội dung"""
+    voice_ids = []
+    
+    # Voice ID thường có độ dài cố định
+    pattern = r'[a-zA-Z0-9]{20,}'
+    matches = re.findall(pattern, content)
+    
+    lines = content.splitlines()
+    for line in lines:
+        line = line.strip()
+        if len(line) > 15 and ' ' not in line:  # Voice ID thường không có khoảng trắng
+            voice_ids.append(line)
+    
+    # Loại bỏ trùng lặp
+    unique_voices = []
+    for vid in voice_ids:
+        if vid and vid not in unique_voices:
+            unique_voices.append(vid)
+    
+    return unique_voices[:10]  # Giới hạn 10 voice IDs
 
-## 🛠️ Công nghệ sử dụng
+def get_output_folder():
+    """Tạo thư mục output tạm thời"""
+    output_dir = os.path.join(tempfile.gettempdir(), "elevenlabs_tts", hashlib.md5(str(time.time()).encode()).hexdigest()[:8])
+    os.makedirs(output_dir, exist_ok=True)
+    return output_dir
 
-- Gradio: Giao diện web
-- ElevenLabs API: TTS engine
-- Pydub: Xử lý audio
-- Python 3.8+
+def check_all_api_keys(api_keys_text):
+    """Kiểm tra tất cả API keys"""
+    api_keys = [k.strip() for k in api_keys_text.splitlines() if k.strip()]
+    results = []
+    
+    if not api_keys:
+        return "❌ Vui lòng nhập ít nhất một API key!"
+    
+    for i, key in enumerate(api_keys, 1):
+        result = check_api_key(key)
+        if result.get("valid"):
+            results.append(f"✓ Key {i}: Hợp lệ | Còn lại: {result['remaining']:,}/{result['total']:,} ký tự")
+        else:
+            results.append(f"✗ Key {i}: Không hợp lệ ({result.get('message', 'Unknown error')})")
+    
+    return "\n".join(results)
+
+async def process_tts_async(api_keys_text, voice_id, text_input, model_id, 
+                           format_type, stability, similarity, style, speed, 
+                           speaker_boost, progress=gr.Progress()):
+    """Xử lý TTS không đồng bộ"""
+    try:
+        # Chuẩn bị dữ liệu
+        api_keys = [k.strip() for k in api_keys_text.splitlines() if k.strip()]
+        if not api_keys:
+            raise ValueError("Vui lòng nhập ít nhất một API key!")
+        
+        if not voice_id.strip():
+            raise ValueError("Vui lòng nhập Voice ID!")
+        
+        if not text_input.strip():
+            raise ValueError("Vui lòng nhập văn bản cần chuyển đổi!")
+        
+        # Tạo thư mục output
+        output_dir = get_output_folder()
+        
+        # Phân tích văn bản
+        texts = parse_text_blocks(text_input.strip())
+        if not texts:
+            raise ValueError("Không thể phân tích văn bản!")
+        
+        progress(0, desc="🔄 Đang khởi tạo...")
+        
+        # Kiểm tra API keys
+        valid_keys = []
+        progress(0.1, desc="🔍 Đang kiểm tra API keys...")
+        
+        for key in api_keys:
+            info = check_api_key(key)
+            if info.get("valid") and info["remaining"] > 600:
+                valid_keys.append([key, info["remaining"]])
+        
+        if not valid_keys:
+            raise ValueError("Không có API key hợp lệ hoặc đủ hạn ngạch!")
+        
+        # Xử lý từng đoạn văn bản
+        audio_files = []
+        current_key_index = 0
+        
+        for i, text in enumerate(texts):
+            progress_percent = 0.1 + (i / len(texts)) * 0.7
+            progress(progress_percent, desc=f"🎤 Đang tạo đoạn {i+1}/{len(texts)}...")
+            
+            success = False
+            attempts = 0
+            
+            while attempts < len(valid_keys) and not success:
+                key, remaining = valid_keys[current_key_index]
+                need = estimate_credit(text)
+                
+                if remaining < need:
+                    valid_keys.pop(current_key_index)
+                    current_key_index %= max(len(valid_keys), 1)
+                    attempts += 1
+                    continue
+                
+                audio = generate_voice(
+                    text, key, voice_id.strip(), model_id,
+                    stability=stability/100,
+                    similarity=similarity/100,
+                    style=style/100,
+                    speed=speed/100,
+                    speaker_boost=speaker_boost
+                )
+                
+                if audio:
+                    filename = f"voice_{i+1:03d}.{format_type.lower()}"
+                    filepath = os.path.join(output_dir, filename)
+                    with open(filepath, "wb") as f:
+                        f.write(audio)
+                    audio_files.append(filepath)
+                    valid_keys[current_key_index][1] -= need
+                    success = True
+                else:
+                    valid_keys.pop(current_key_index)
+                    current_key_index %= max(len(valid_keys), 1)
+                    attempts += 1
+            
+            if not success:
+                raise ValueError(f"Không thể tạo đoạn {i+1} với tất cả API keys!")
+        
+        # Merge audio files
+        progress(0.8, desc="🔗 Đang merge file audio...")
+        merged_file = merge_audio_files(output_dir, format_type, os.path.join(output_dir, "output_full"))
+        
+        # Tạo file SRT
+        progress(0.9, desc="📝 Đang tạo file phụ đề...")
+        srt_file = create_srt(output_dir, texts)
+        
+        # Đọc file đã tạo
+        output_files = []
+        if merged_file and os.path.exists(merged_file):
+            output_files.append(merged_file)
+        
+        if srt_file and os.path.exists(srt_file):
+            output_files.append(srt_file)
+        
+        # Thêm các file audio riêng lẻ
+        for audio_file in audio_files[:3]:  # Chỉ hiển thị 3 file đầu
+            if os.path.exists(audio_file):
+                output_files.append(audio_file)
+        
+        progress(1.0, desc="✅ Hoàn thành!")
+        
+        return {
+            "message": f"✅ Đã tạo thành công {len(texts)} đoạn audio!",
+            "output_dir": output_dir,
+            "files": output_files
+        }
+        
+    except Exception as e:
+        return {
+            "message": f"❌ Lỗi: {str(e)}",
+            "output_dir": None,
+            "files": []
+        }
+
+# ==================== GRADIO INTERFACE ====================
+with gr.Blocks(title="🎤 ElevenLabs TTS Pro - Web Edition", theme=gr.themes.Soft()) as demo:
+    gr.Markdown("""
+    # 🎤 ElevenLabs TTS Pro - Web Edition
+    **Công cụ chuyển văn bản thành giọng nói chuyên nghiệp**
+    
+    > Phiên bản Web chạy trên Hugging Face Spaces
+    """)
+    
+    with gr.Tabs():
+        with gr.TabItem("⚙️ Cấu hình chính"):
+            with gr.Row():
+                with gr.Column(scale=2):
+                    gr.Markdown("### 🔑 Cấu hình API Keys")
+                    api_keys_text = gr.Textbox(
+                        label="API Keys (mỗi key một dòng)",
+                        placeholder="sk_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\nsk_yyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyy",
+                        lines=5,
+                        info="Nhập một hoặc nhiều API keys từ ElevenLabs"
+                    )
+                    
+                    with gr.Row():
+                        check_api_btn = gr.Button("🔍 Kiểm tra API Keys", variant="secondary")
+                        clear_api_btn = gr.Button("🗑️ Xóa", variant="secondary")
+                    
+                    api_check_result = gr.Textbox(label="Kết quả kiểm tra", interactive=False, lines=3)
+                    
+                    # File upload cho API keys
+                    api_file = gr.File(
+                        label="📁 Tải API Keys từ file",
+                        file_types=[".txt", ".json", ".env"],
+                        type="binary"
+                    )
+                    
+                with gr.Column(scale=1):
+                    gr.Markdown("### 🎤 Cài đặt Voice")
+                    voice_id = gr.Textbox(
+                        label="Voice ID",
+                        placeholder="21m00Tcm4TlvDq8ikWAM",
+                        info="Voice ID từ ElevenLabs"
+                    )
+                    
+                    # File upload cho Voice IDs
+                    voice_file = gr.File(
+                        label="📁 Tải Voice IDs từ file",
+                        file_types=[".txt", ".json"],
+                        type="binary"
+                    )
+                    
+                    model_id = gr.Dropdown(
+                        label="Model",
+                        choices=["eleven_turbo_v2_5", "eleven_flash_v2_5", "eleven_multilingual_v2"],
+                        value="eleven_multilingual_v2"
+                    )
+                    
+                    format_type = gr.Dropdown(
+                        label="Định dạng file",
+                        choices=["MP3", "WAV", "OGG", "FLAC"],
+                        value="MP3"
+                    )
+            
+            gr.Markdown("### ⚙️ Thông số Giọng nói")
+            with gr.Row():
+                stability = gr.Slider(minimum=0, maximum=100, value=95, label="Stability")
+                similarity = gr.Slider(minimum=0, maximum=100, value=80, label="Similarity")
+            
+            with gr.Row():
+                style = gr.Slider(minimum=0, maximum=100, value=40, label="Style")
+                speed = gr.Slider(minimum=70, maximum=120, value=80, label="Speed")
+            
+            speaker_boost = gr.Checkbox(label="Speaker Boost", value=True)
+        
+        with gr.TabItem("📝 Văn bản"):
+            text_input = gr.Textbox(
+                label="Văn bản cần chuyển đổi",
+                placeholder="Nhập văn bản cần chuyển đổi thành giọng nói tại đây...",
+                lines=10
+            )
+            
+            with gr.Row():
+                text_file = gr.File(
+                    label="📁 Tải văn bản từ file",
+                    file_types=[".txt", ".json"],
+                    type="binary"
+                )
+                clear_text_btn = gr.Button("🗑️ Xóa văn bản", variant="secondary")
+            
+            text_stats = gr.Textbox(label="📊 Thống kê", interactive=False, lines=2)
+        
+        with gr.TabItem("🚀 Xử lý & Kết quả"):
+            with gr.Row():
+                with gr.Column():
+                    process_btn = gr.Button("🚀 Bắt đầu Tạo Giọng nói", variant="primary", size="lg")
+                    status_text = gr.Textbox(label="Trạng thái", interactive=False, lines=3)
+                    
+                    gr.Markdown("### 📁 Kết quả")
+                    output_files = gr.File(
+                        label="File đã tạo",
+                        file_count="multiple",
+                        interactive=False
+                    )
+                    
+                    output_message = gr.Markdown("")
+                with gr.Column():
+                    gr.Markdown("### 📊 Logs xử lý")
+                    progress_bar = gr.ProgressBar()
+                    logs_text = gr.Textbox(
+                        label="Logs",
+                        interactive=False,
+                        lines=15,
+                        max_lines=50
+                    )
+    
+    # ==================== CALLBACK FUNCTIONS ====================
+    
+    def update_text_stats(text):
+        """Cập nhật thống kê văn bản"""
+        char_count = len(text)
+        if text.strip():
+            blocks = parse_text_blocks(text)
+            block_count = len(blocks)
+            estimated_credits = char_count + (block_count * 50)
+            return f"📊 {char_count:,} ký tự | {block_count} đoạn | Ước tính: {estimated_credits:,} credits"
+        return "📊 0 ký tự | 0 đoạn | Ước tính: 0 credits"
+    
+    def clear_api_keys():
+        """Xóa API keys"""
+        return "", "✅ Đã xóa API keys"
+    
+    def clear_text():
+        """Xóa văn bản"""
+        return "", update_text_stats("")
+    
+    def process_api_file(file):
+        """Xử lý file API keys"""
+        if file is None:
+            return "", "⚠ Chưa chọn file"
+        
+        try:
+            content = file.read().decode('utf-8', errors='ignore')
+            api_keys = extract_api_keys_from_content(content)
+            
+            if api_keys:
+                return "\n".join(api_keys), f"✅ Đã tải {len(api_keys)} API keys từ file"
+            else:
+                return "", "⚠ Không tìm thấy API keys trong file"
+        except Exception as e:
+            return "", f"❌ Lỗi: {str(e)}"
+    
+    def process_voice_file(file):
+        """Xử lý file Voice IDs"""
+        if file is None:
+            return "", "⚠ Chưa chọn file"
+        
+        try:
+            content = file.read().decode('utf-8', errors='ignore')
+            voice_ids = extract_voice_ids_from_content(content)
+            
+            if voice_ids:
+                return voice_ids[0], f"✅ Đã tải {len(voice_ids)} Voice IDs (sử dụng đầu tiên)"
+            else:
+                return "", "��� Không tìm thấy Voice IDs trong file"
+        except Exception as e:
+            return "", f"❌ Lỗi: {str(e)}"
+    
+    def process_text_file(file):
+        """Xử lý file văn bản"""
+        if file is None:
+            return "", "⚠ Chưa chọn file"
+        
+        try:
+            content = file.read().decode('utf-8', errors='ignore')
+            
+            # Thử phân tích JSON
+            try:
+                data = json.loads(content)
+                if isinstance(data, dict) and 'text' in data:
+                    content = data['text']
+                elif isinstance(data, dict) and 'content' in data:
+                    content = data['content']
+                elif isinstance(data, list):
+                    content = '\n'.join(str(item) for item in data)
+            except:
+                pass  # Không phải JSON, giữ nguyên
+            
+            return content, f"✅ Đã tải văn bản ({len(content):,} ký tự)"
+        except Exception as e:
+            return "", f"❌ Lỗi: {str(e)}"
+    
+    def process_tts(api_keys_text, voice_id, text_input, model_id, format_type, 
+                   stability, similarity, style, speed, speaker_boost, progress=gr.Progress()):
+        """Xử lý TTS chính"""
+        logs = []
+        
+        def log_message(msg):
+            logs.append(f"[{time.strftime('%H:%M:%S')}] {msg}")
+            return "\n".join(logs[-20:])  # Giữ 20 dòng cuối
+        
+        try:
+            # Kiểm tra đầu vào
+            if not api_keys_text.strip():
+                return {
+                    status_text: "❌ Vui lòng nhập API keys!",
+                    logs_text: log_message("❌ Lỗi: Chưa nhập API keys"),
+                    output_files: None,
+                    output_message: "### ❌ Lỗi: Vui lòng nhập API keys"
+                }
+            
+            if not voice_id.strip():
+                return {
+                    status_text: "❌ Vui lòng nhập Voice ID!",
+                    logs_text: log_message("❌ Lỗi: Chưa nhập Voice ID"),
+                    output_files: None,
+                    output_message: "### ❌ Lỗi: Vui lòng nhập Voice ID"
+                }
+            
+            if not text_input.strip():
+                return {
+                    status_text: "❌ Vui lòng nhập văn bản!",
+                    logs_text: log_message("❌ Lỗi: Chưa nhập văn bản"),
+                    output_files: None,
+                    output_message: "### ❌ Lỗi: Vui lòng nhập văn bản"
+                }
+            
+            logs_text_value = log_message("🚀 Bắt đầu xử lý TTS...")
+            status_text_value = "🔄 Đang khởi tạo..."
+            progress(0, desc="Đang khởi tạo...")
+            
+            # Xử lý không đồng bộ
+            loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(loop)
+            
+            result = loop.run_until_complete(
+                process_tts_async(
+                    api_keys_text, voice_id, text_input, model_id, format_type,
+                    stability, similarity, style, speed, speaker_boost, progress
+                )
+            )
+            
+            loop.close()
+            
+            logs_text_value = log_message(result["message"])
+            
+            if result["files"]:
+                status_text_value = "✅ Hoàn thành!"
+                message = f"### ✅ Hoàn thành!\n\nĐã tạo {len([f for f in result['files'] if 'voice_' in str(f)])} file audio\n[📥 Tải xuống file đã tạo](#)"
+                return {
+                    status_text: status_text_value,
+                    logs_text: logs_text_value,
+                    output_files: result["files"],
+                    output_message: message
+                }
+            else:
+                status_text_value = "❌ Thất bại"
+                message = f"### ❌ Thất bại\n\n{result['message']}"
+                return {
+                    status_text: status_text_value,
+                    logs_text: logs_text_value,
+                    output_files: None,
+                    output_message: message
+                }
+                
+        except Exception as e:
+            error_msg = f"❌ Lỗi hệ thống: {str(e)}"
+            return {
+                status_text: "❌ Lỗi hệ thống",
+                logs_text: log_message(error_msg),
+                output_files: None,
+                output_message: f"### ❌ Lỗi hệ thống\n\n{str(e)}"
+            }
+    
+    # ==================== EVENT HANDLERS ====================
+    
+    # Text stats update
+    text_input.change(
+        fn=update_text_stats,
+        inputs=[text_input],
+        outputs=[text_stats]
+    )
+    
+    # API keys check
+    check_api_btn.click(
+        fn=check_all_api_keys,
+        inputs=[api_keys_text],
+        outputs=[api_check_result]
+    )
+    
+    # Clear buttons
+    clear_api_btn.click(
+        fn=clear_api_keys,
+        inputs=[],
+        outputs=[api_keys_text, api_check_result]
+    )
+    
+    clear_text_btn.click(
+        fn=clear_text,
+        inputs=[],
+        outputs=[text_input, text_stats]
+    )
+    
+    # File upload handlers
+    api_file.upload(
+        fn=process_api_file,
+        inputs=[api_file],
+        outputs=[api_keys_text, api_check_result]
+    ).then(
+        fn=check_all_api_keys,
+        inputs=[api_keys_text],
+        outputs=[api_check_result]
+    )
+    
+    voice_file.upload(
+        fn=process_voice_file,
+        inputs=[voice_file],
+        outputs=[voice_id, status_text]
+    )
+    
+    text_file.upload(
+        fn=process_text_file,
+        inputs=[text_file],
+        outputs=[text_input, status_text]
+    ).then(
+        fn=update_text_stats,
+        inputs=[text_input],
+        outputs=[text_stats]
+    )
+    
+    # Main TTS process
+    process_btn.click(
+        fn=process_tts,
+        inputs=[
+            api_keys_text, voice_id, text_input, model_id, format_type,
+            stability, similarity, style, speed, speaker_boost
+        ],
+        outputs=[status_text, logs_text, output_files, output_message]
+    )
+
+# ==================== LAUNCH APP ====================
+if __name__ == "__main__":
+    demo.queue()  # Enable queuing for async operations
+    demo.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        share=False,
+        debug=False
+    )