Upload 5 files

README.md

@@ -1,12 +1,29 @@
 ---
-title: ElevenLabs TTS Free
-emoji: 📈
-colorFrom: pink
-colorTo: blue
+title: Haidnt Elevenlabs Free
+emoji: 🌖
+colorFrom: yellow
+colorTo: red
 sdk: gradio
-sdk_version: 5.36.2
+sdk_version: 5.35.0
 app_file: app.py
 pinned: false
+short_description: FREE FOR EVERYONE
 ---
 
 Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+
+# 🎙️ Công cụ ElevenLabs TTS + Proxy (Miễn phí cho tất cả mọi người)
+
+Đây là công cụ **100% miễn phí**, dành cho tất cả mọi người – đặc biệt hỗ trợ cộng đồng cá nhân và phi thương mại.
+
+✅ Tự dùng API Key của bạn (không lưu)
+✅ Thêm giọng cá nhân hoá
+✅ Hỗ trợ proxy riêng (không lưu)
+✅ Có sẵn proxy công khai & bộ giọng mẫu chất lượng
+
+> ⚠️ **Lưu ý**: Đây là công cụ **phi thương mại**. Vui lòng **không rao bán, đổi tên hay sử dụng vào mục đích thương mại**.
+> 🛡️ Mọi API Key và Proxy đều chỉ lưu tạm, không ghi log, không gửi đi đâu cả.
+
+---
+
+🔗 Làm với ❤️ để phục vụ cộng đồng mã nguồn mở.

app.py

@@ -0,0 +1,1073 @@
+# Gradio_11Labs_Enhanced_with_Proxy.py
+# ============================================================================
+# 2025-07-09 – *Proxy + Full Voice Manager + UX Tweaks + Privacy Protection*
+# ---------------------------------------------------------------------------
+#  ✦ Proxy Tab: bulk add/test, auto/manual assign (≤3 keys/proxy), delete bad
+#  ✦ Batch Tab: refresh-all, live token count, total credit, verify key-proxy
+#                – "🌀 Tạo giọng nói" sits *above* textbox
+#                – auto-pick checkbox at bottom
+#  ✦ API-Key Tab: shows proxy **host** only (no creds/port)
+#  ✦ Voice Tab: restored original full manager (add/edit/delete/reset/export)
+#  ✦ Privacy: Hide sensitive info (API keys, proxy credentials, voice IDs)
+#  ✦ Session: Use gr.State for per-browser isolation, auto-clear after session ends
+# ---------------------------------------------------------------------------
+
+import gradio as gr
+import os, json, time, urllib.parse, requests, random
+from datetime import datetime
+import pandas as pd
+from dotenv import load_dotenv
+from elevenlabs.client import ElevenLabs
+import tempfile
+import uuid
+from functools import wraps
+
+def log_exception(e, context=""):
+    import traceback
+    tb = traceback.format_exc()
+    msg = f"❌ Lỗi ở {context}: {str(e)}\n{tb}"
+    print(msg)
+    return msg
+
+# === .env ===
+load_dotenv()
+DEFAULT_MODEL = os.getenv("ELEVENLABS_MODEL_ID", "eleven_multilingual_v2")
+DEFAULT_FORMAT = os.getenv("ELEVENLABS_OUTPUT_FORMAT", "mp3_44100")
+
+# === Default Data ===
+def load_default_voices():
+    """Load default voices from voices.json"""
+    try:
+        with open("voices.json", "r", encoding="utf-8") as f:
+            return json.load(f)
+    except:
+        return {}
+
+def load_default_proxies():
+    """Load default proxies from proxies.json"""
+    try:
+        with open("proxies.json", "r", encoding="utf-8") as f:
+            return json.load(f)
+    except:
+        return {}
+
+DEFAULT_VOICE_SETTINGS = {
+    "speed": 1.0,
+    "stability": 0.5,
+    "similarity_boost": 0.75,
+    "style_exaggeration": 0.0,
+    "use_speaker_boost": True,
+}
+
+MODELS = ["eleven_monolingual_v1", "eleven_multilingual_v1", "eleven_multilingual_v2"]
+
+# === Session Management ===
+def session_wrapper(func):
+    """Decorator to ensure session data access"""
+    @wraps(func)
+    def wrapper(*args, **kwargs):
+        return func(*args, **kwargs)
+    return wrapper
+
+# === Privacy helpers ===
+def mask_api_key(key):
+    """Mask API key: show first 4 and last 4 chars"""
+    if not key or len(key) < 8:
+        return key
+    return f"{key[:4]}...{key[-4:]}"
+
+def mask_voice_id(voice_id):
+    """Mask Voice ID: show first 3 and last 3 chars"""
+    if not voice_id or len(voice_id) < 6:
+        return voice_id
+    return f"{voice_id[:3]}...{voice_id[-3:]}"
+
+def mask_proxy_url(url):
+    """Mask credentials in proxy URL"""
+    try:
+        parsed = urllib.parse.urlparse(url)
+        if parsed.username and parsed.password:
+            masked_netloc = f"***:***@{parsed.hostname}"
+            if parsed.port:
+                masked_netloc += f":{parsed.port}"
+            return urllib.parse.urlunparse((
+                parsed.scheme, masked_netloc, parsed.path,
+                parsed.params, parsed.query, parsed.fragment
+            ))
+        return url
+    except:
+        return url
+
+def create_key_display_map(api_keys):
+    """Create mapping between real API key and display name"""
+    display_map = {}
+    reverse_map = {}
+    for i, key in enumerate(api_keys.keys(), 1):
+        display_name = f"Key-{i:02d} ({mask_api_key(key)})"
+        display_map[key] = display_name
+        reverse_map[display_name] = key
+    return display_map, reverse_map
+
+def get_key_choices_for_display(api_keys):
+    """Get list of masked API keys for display"""
+    display_map, _ = create_key_display_map(api_keys)
+    return list(display_map.values())
+
+def get_real_key_from_display(display_name, api_keys):
+    """Get real API key from display name"""
+    _, reverse_map = create_key_display_map(api_keys)
+    return reverse_map.get(display_name, display_name)
+
+def create_proxy_display_map(proxies):
+    """Create mapping between real proxy URL and display name"""
+    display_map = {}
+    reverse_map = {}
+    for i, url in enumerate(proxies.keys(), 1):
+        display_name = f"Proxy-{i:02d} ({mask_proxy_url(url)})"
+        display_map[url] = display_name
+        reverse_map[display_name] = url
+    return display_map, reverse_map
+
+def get_proxy_choices_for_display(proxies):
+    """Get list of masked proxies for display"""
+    display_map, _ = create_proxy_display_map(proxies)
+    return list(display_map.values())
+
+def get_real_proxy_from_display(display_name, proxies):
+    """Get real proxy URL from display name"""
+    _, reverse_map = create_proxy_display_map(proxies)
+    return reverse_map.get(display_name, display_name)
+
+# === Generic helpers ===
+def safe_get_default(choices, default_func):
+    """Safely get default value that exists in choices"""
+    if not choices:
+        return None
+    default = default_func()
+    return default if default in choices else choices[0]
+
+# === ElevenLabs ===
+def get_client(api_key):
+    return ElevenLabs(api_key=api_key)
+
+@session_wrapper
+def get_api_usage(api_key, bypass_proxy=False, proxies=None):
+    import urllib3
+    urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
+    proxy_url = None if bypass_proxy else get_proxy_of_key(api_key, proxies)
+    proxies_dict = {"http": proxy_url, "https": proxy_url} if proxy_url else None
+    try:
+        r = requests.get(
+            "https://api.elevenlabs.io/v1/user/subscription",
+            headers={"xi-api-key": api_key},
+            proxies=proxies_dict,
+            timeout=4,
+            verify=False if proxy_url else True
+        )
+        if r.status_code == 200:
+            d = r.json()
+            return {
+                "status": "✅ OK",
+                "used": d.get("character_count", 0),
+                "limit": d.get("character_limit", 0),
+                "tier": d.get("tier", ""),
+                "remaining": d.get("character_limit", 0) - d.get("character_count", 0),
+            }
+        return {"status": f"❌ {r.status_code}"}
+    except Exception as e:
+        return {"status": f"⚠️ {str(e).split(' ')[0]}"}
+
+def total_credit(api_keys):
+    return sum(v.get("remaining", 0) for v in api_keys.values())
+
+# === Proxy helpers ===
+@session_wrapper
+def proxy_host(url: str):
+    try:
+        return urllib.parse.urlsplit(url).hostname or ""
+    except:
+        return ""
+
+@session_wrapper
+def format_proxy_table(proxies):
+    rows = []
+    for url, info in proxies.items():
+        masked_url = mask_proxy_url(url)
+        masked_keys = [mask_api_key(k) for k in info.get("assigned_keys", [])]
+        sample_keys = ", ".join(masked_keys[:3]) + ("…" if len(masked_keys) > 3 else "")
+        rows.append([
+            masked_url,
+            info.get("status", "-"),
+            info.get("latency", "-"),
+            len(info.get("assigned_keys", [])),
+            sample_keys,
+            info.get("last_checked", "-"),
+        ])
+    return pd.DataFrame(rows, columns=["Proxy", "Status", "Latency (ms)", "#Keys", "Sample Keys", "Last check"])
+
+@session_wrapper
+def test_proxy_once(url: str, timeout=3):    # giảm timeout từ 6 -> 3
+    import urllib3
+    urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
+    proxies = {"http": url, "https": url}
+    t0 = time.time()
+    try:
+        r = requests.get("https://api.ipify.org?format=json", proxies=proxies, timeout=timeout, verify=False)
+        if r.status_code == 200:
+            return {"status": "✅ OK", "latency": int((time.time()-t0)*1000)}
+    except Exception as e:
+        return {"status": f"⚠️ {str(e).split(' ')[0]}", "latency": None}
+    return {"status": "❌ Failed", "latency": None}
+
+@session_wrapper
+def add_and_test_proxies(text, proxies_state):
+    try:
+        proxies = proxies_state.copy()
+        added = 0
+        for line in text.strip().splitlines():
+            p = line.strip()
+            if not p: continue
+            if p not in proxies:
+                proxies[p] = {"assigned_keys": []}
+                added += 1
+            proxies[p].update(test_proxy_once(p))
+            proxies[p]["last_checked"] = datetime.utcnow().isoformat(timespec="seconds")
+        return format_proxy_table(proxies), f"✅ Đã thêm/kiểm tra {added} proxy.", proxies
+    except Exception as e:
+        msg = log_exception(e, "add_and_test_proxies")
+        return None, msg, proxies_state
+
+@session_wrapper
+def refresh_proxy_status(proxies_state):
+    proxies = proxies_state.copy()
+    for url in proxies:
+        proxies[url].update(test_proxy_once(url))
+        proxies[url]["last_checked"] = datetime.utcnow().isoformat(timespec="seconds")
+    return format_proxy_table(proxies), "🔄 Đã refresh proxy.", proxies
+
+@session_wrapper
+def get_proxy_of_key(key, proxies):
+    for url, info in proxies.items():
+        if key in info.get("assigned_keys", []):
+            return url
+    return ""
+
+@session_wrapper
+def assign_proxy_to_key(proxy_display, api_key_display, proxies_state, api_keys_state):
+    proxy_url = get_real_proxy_from_display(proxy_display, proxies_state)
+    api_key = get_real_key_from_display(api_key_display, api_keys_state)
+    proxies = proxies_state.copy()
+    keys = api_keys_state.copy()
+    if proxy_url not in proxies:
+        return format_proxy_table(proxies), "❌ Proxy không tồn tại!", proxies, keys
+    status = proxies[proxy_url].get("status", "")
+    if not (status.startswith("✅") or "HTTPSConnectionPool" in status):
+        return format_proxy_table(proxies), "❌ Proxy không hoạt động!", proxies, keys
+    if api_key not in keys:
+        return format_proxy_table(proxies), "❌ API Key không tồn tại!", proxies, keys
+    for info in proxies.values():
+        if api_key in info.get("assigned_keys", []):
+            info["assigned_keys"].remove(api_key)
+    proxies[proxy_url].setdefault("assigned_keys", []).append(api_key)
+    return format_proxy_table(proxies), "✅ Đã gắn key.", proxies, keys
+
+@session_wrapper
+def smart_proxy_assignment(proxies_state, api_keys_state):
+    proxies = proxies_state.copy()
+    keys = api_keys_state.copy()
+    active_proxies = []
+    for url, info in proxies.items():
+        status = info.get("status", "")
+        if status.startswith("✅") or "HTTPSConnectionPool" in status:
+            active_proxies.append((url, info))
+    if not active_proxies:
+        return [], list(keys.keys()), "⚠️ Không gắn proxy – Đang dùng IP thật (Vẫn ổn nếu xài dưới 3 Key/ngày).", proxies
+    for url, info in proxies.items():
+        info["assigned_keys"] = []
+    key_list = list(keys.keys())
+    random.shuffle(key_list)
+    random.shuffle(active_proxies)
+    num_keys = len(key_list)
+    num_proxies = len(active_proxies)
+    assigned_keys = []
+    unassigned_keys = []
+    if num_proxies >= num_keys:
+        for i, key in enumerate(key_list):
+            active_proxies[i][1]["assigned_keys"].append(key)
+            assigned_keys.append(key)
+        message = f"✅ Gắn 1:1, {len(assigned_keys)} key được gắn với {len(assigned_keys)} proxy, dư {num_proxies - num_keys} proxy."
+    elif num_keys < 3 * num_proxies:
+        keys_per_proxy_base = num_keys // num_proxies
+        extra_keys = num_keys % num_proxies
+        key_index = 0
+        proxies_with_extra = 0
+        proxies_normal = 0
+        for i, (url, info) in enumerate(active_proxies):
+            keys_for_this_proxy = keys_per_proxy_base + (1 if i < extra_keys else 0)
+            for _ in range(keys_for_this_proxy):
+                if key_index < len(key_list):
+                    info["assigned_keys"].append(key_list[key_index])
+                    assigned_keys.append(key_list[key_index])
+                    key_index += 1
+            if keys_for_this_proxy > keys_per_proxy_base:
+                proxies_with_extra += 1
+            else:
+                proxies_normal += 1
+        if extra_keys > 0:
+            message = f"✅ Phân bổ hợp lý: {proxies_with_extra} proxy nhận {keys_per_proxy_base + 1} key, {proxies_normal} proxy nhận {keys_per_proxy_base} key."
+        else:
+            message = f"✅ Phân bổ đều: mỗi proxy nhận {keys_per_proxy_base} key."
+    else:
+        max_assignable = 3 * num_proxies
+        keys_to_assign = key_list[:max_assignable]
+        unassigned_keys = key_list[max_assignable:]
+        key_index = 0
+        for url, info in active_proxies:
+            for _ in range(3):
+                if key_index < len(keys_to_assign):
+                    info["assigned_keys"].append(keys_to_assign[key_index])
+                    assigned_keys.append(keys_to_assign[key_index])
+                    key_index += 1
+        message = f"✅ Mỗi proxy gắn 3 key, {len(assigned_keys)}/{num_keys} key được gắn."
+        if unassigned_keys:
+            message += f" ⚠️ {len(unassigned_keys)} key chưa gắn: {', '.join([mask_api_key(k) for k in unassigned_keys[:3]])}{'...' if len(unassigned_keys) > 3 else ''}"
+    return assigned_keys, unassigned_keys, message, proxies
+
+@session_wrapper
+def auto_assign(proxies_state, api_keys_state):
+    proxy_table, _, proxies = refresh_proxy_status(proxies_state)
+    assigned_keys, unassigned_keys, message, proxies = smart_proxy_assignment(proxies, api_keys_state)
+    return proxy_table, message, proxies
+
+@session_wrapper
+def delete_bad(proxies_state):
+    proxies = proxies_state.copy()
+    rem = []
+    for u, i in list(proxies.items()):
+        bad = i.get("status", "").startswith(("❌", "⚠️"))
+        if bad:
+            rem.append(u)
+            proxies.pop(u)
+    return format_proxy_table(proxies), f"🗑️ Đã xoá {len(rem)} proxy lỗi.", proxies
+
+@session_wrapper
+def filter_bad_proxies(proxies_state):
+    proxies = proxies_state.copy()
+    bad_proxies = {}
+    for url, info in proxies.items():
+        is_bad = info.get("status", "").startswith(("❌", "⚠️"))
+        if is_bad:
+            bad_proxies[url] = info
+    return format_proxy_table(bad_proxies)
+
+# === Voice helpers ===
+@session_wrapper
+def get_voice_list(voices_state):
+    return list(voices_state.keys())
+
+@session_wrapper
+def get_default_voice(voices_state):
+    lst = get_voice_list(voices_state)
+    return lst[0] if lst else None
+
+@session_wrapper
+def save_voice(name, voice_id, current_voice, voices_state):
+    try:
+        if not name or not voice_id:
+            return "❌ Cần nhập tên và ID!", get_voice_list(voices_state), get_voice_list(voices_state), current_voice, voices_state
+        voices = voices_state.copy()
+        for n, v in voices.items():
+            if v.get("voice_id") == voice_id and n != name:
+                return f"❌ Voice ID đã tồn tại ở '{n}'.", get_voice_list(voices), get_voice_list(voices), current_voice, voices
+        voices[name] = {"voice_id": voice_id, "settings": DEFAULT_VOICE_SETTINGS.copy()}
+        vl = get_voice_list(voices)
+        return f"✅ Đã lưu '{name}'", vl, vl, name, voices
+    except Exception as e:
+        msg = log_exception(e, "save_voice")
+        return msg, get_voice_list(voices_state), get_voice_list(voices_state), current_voice, voices_state
+
+@session_wrapper
+def load_voice_for_edit(name, voices_state):
+    voices = voices_state.copy()
+    v = voices.get(name, {})
+    cfg = v.get("settings", DEFAULT_VOICE_SETTINGS.copy())
+    if not name:
+        return "", "", *DEFAULT_VOICE_SETTINGS.values()
+    voice_id = v.get("voice_id", "")
+    masked_voice_id = mask_voice_id(voice_id)
+    return name, masked_voice_id, cfg["speed"], cfg["stability"], cfg["similarity_boost"], cfg["style_exaggeration"], cfg["use_speaker_boost"]
+
+@session_wrapper
+def delete_voice(name, confirm, cur, voices_state):
+    if not name:
+        return "❌ Chọn voice!", get_voice_list(voices_state), get_voice_list(voices_state), cur, voices_state
+    if not confirm:
+        return "⚠️ Hãy tick vào ô xác nhận xoá!", get_voice_list(voices_state), get_voice_list(voices_state), cur, voices_state
+    voices = voices_state.copy()
+    protected_voice_ids = {
+        "TxGEqnHWrfWFTfGW9XjX", "TX3LPaxmHKxFdv7VOQHJ", "ErXwobaYiN019PkySvjV",
+        "iP95p4xoKVk53GoZ742B", "VR6AewLTigWG4xSOukaG", "pNInz6obpgDQGcFmaJgB",
+        "nPczCjzI2devNBz1zQrb", "CwhRBWXzGAHq8TQ4Fs17", "5Q0t7uMcjvnagumLfvZi",
+        "29vD33N1CtxCmqQRPOHJ", "flq6f7yk4E4fJM5XTYuZ", "t0jbNlBVZ17f02VDIeMI",
+        "pqHfZKP75CvOlQylNhV4", "LcfcDJNUP1GQjkzn1xUU", "z9fAnlkpzviPz146aGWa",
+        "pMsXgVXv3BLzUgSXRplE", "XrExE9yKIg1WjnnlVkGX", "SAz9YHcvj6GT2YYXdXww",
+        "N2lVS1w4EtoT3dr4eOWO", "2EiwWnXFnvU5JabPnv8n", "p28fY1cl6tovhD2M4WEH",
+        "eC5XQ2bYx6LQHFG29bNv"
+    }
+    voice_info = voices.get(name)
+    if voice_info and voice_info.get("voice_id") in protected_voice_ids:
+        return "❌ Không được xoá voice mặc định!", get_voice_list(voices), get_voice_list(voices), cur, voices
+    if name in voices:
+        voices.pop(name)
+        lst = get_voice_list(voices)
+        new = lst[0] if lst else None
+        return f"🗑️ Đã xoá '{name}'", lst, lst, new, voices
+    return "❌ Không tìm thấy voice!", get_voice_list(voices), get_voice_list(voices), cur, voices
+
+@session_wrapper
+def reset_voice(name, confirm, cur, voices_state):
+    if not name:
+        return "❌ Chọn voice!", get_voice_list(voices_state), get_voice_list(voices_state), cur, voices_state
+    if not confirm:
+        return "⚠️ Hãy tick vào ô xác nhận reset!", get_voice_list(voices_state), get_voice_list(voices_state), cur, voices_state
+    voices = voices_state.copy()
+    if name in voices:
+        voices[name]["settings"] = DEFAULT_VOICE_SETTINGS.copy()
+        return f"✅ Đã reset '{name}'", get_voice_list(voices), get_voice_list(voices), name, voices
+    return "❌ Không tìm thấy voice!", get_voice_list(voices), get_voice_list(voices), cur, voices
+
+@session_wrapper
+def update_voice_cfg(name, speed, stab, sim, exag, boost, cur, voices_state):
+    if not name:
+        return "❌ Chọn voice!", get_voice_list(voices_state), get_voice_list(voices_state), cur, voices_state
+    voices = voices_state.copy()
+    voices.setdefault(name, {"voice_id": "", "settings": DEFAULT_VOICE_SETTINGS.copy()})
+    voices[name]["settings"] = {
+        "speed": speed,
+        "stability": stab,
+        "similarity_boost": sim,
+        "style_exaggeration": exag,
+        "use_speaker_boost": boost
+    }
+    return f"✅ Đã cập nhật '{name}'", get_voice_list(voices), get_voice_list(voices), name, voices
+
+@session_wrapper
+def voice_table(voices_state):
+    voices = voices_state.copy()
+    data = [[n, mask_voice_id(v.get("voice_id", "")), "✅" if v.get("settings") else "❌"] for n, v in voices.items()]
+    return pd.DataFrame(data, columns=["Tên Voice", "Voice ID", "Đã cấu hình"])
+
+# === API-Key helpers ===
+@session_wrapper
+def dataframe_with_keys(api_keys_state, proxies_state):
+    keys = api_keys_state.copy()
+    proxies = proxies_state.copy()
+    rows = []
+    for k, v in keys.items():
+        masked_key = mask_api_key(k)
+        rows.append([masked_key, v.get("status", ""), v.get("used", 0), v.get("limit", 0), v.get("tier", ""), v.get("remaining", 0), proxy_host(get_proxy_of_key(k, proxies))])
+    df = pd.DataFrame(rows, columns=["API Key", "Status", "Used", "Limit", "Tier", "Remaining", "Proxy Host"])
+    df = df.sort_values("Remaining", ascending=True)
+    return df
+
+@session_wrapper
+def get_sorted_keys_by_credit(api_keys_state):
+    keys = api_keys_state.copy()
+    if not keys:
+        return []
+    sorted_keys = sorted(keys.items(), key=lambda x: x[1].get("remaining", 0))
+    return [k for k, v in sorted_keys]
+
+@session_wrapper
+def lowest_key(api_keys_state):
+    keys = api_keys_state.copy()
+    if not keys:
+        return None
+    return sorted(keys.items(), key=lambda x: x[1].get("remaining", float("inf")))[0][0]
+
+@session_wrapper
+def save_and_show_keys(text, api_keys_state, proxies_state):
+    # --- Copy state hiện tại ---
+    keys = api_keys_state.copy()
+    proxies = proxies_state.copy()
+
+    # --- Đọc input, thu list new_keys ---
+    new_keys = []
+    for line in text.strip().splitlines():
+        k = line.strip()
+        if k and k not in keys:
+            new_keys.append(k)
+
+    # --- Nhánh 1: nếu không có key mới ---
+    if not new_keys:
+        df = dataframe_with_keys(keys, proxies)
+        message = "ℹ️ Không có key mới nào."
+        choices = get_key_choices_for_display(keys)
+        lowest = choices[0] if choices else None
+
+        return (
+            # Tab 2 outputs: key_df, key_dd, key_del_dd, key_sel, status_out, api_keys_state, total_credit_txt
+            df,
+            gr.update(choices=choices, value=lowest),  # dropdown “Chọn API Key”
+            gr.update(choices=choices, value=None),    # dropdown “Chọn API Key để xoá”
+            gr.update(choices=choices, value=None),    # dropdown “API Key”
+            message,
+            keys,
+            f"Tổng credit: {total_credit(keys):,}"
+        )
+
+    # --- Nhánh 2: có new_keys -> thêm vào state ---
+    added = len(new_keys)
+    for k in new_keys:
+        keys[k] = {"status": "⏳ Chưa kiểm tra", "remaining": 0}
+
+    # Gán proxy và kiểm tra usage cho các key mới
+    assigned_keys, unassigned_keys, assign_message, proxies = smart_proxy_assignment(proxies, keys)
+    checked = 0
+    for k in new_keys:
+        if k in assigned_keys:
+            keys[k] = get_api_usage(k, proxies=proxies)
+            checked += 1
+        else:
+            if not proxies:
+                keys[k] = get_api_usage(k, bypass_proxy=True, proxies=proxies)
+                checked += 1
+            else:
+                keys[k]["status"] = "⚠️ Chưa gắn proxy"
+    
+    active_proxies = [
+        p for p in proxies.values()
+        if p.get("status", "").startswith("✅") or "HTTPSConnectionPool" in p.get("status", "")
+    ]
+    if not active_proxies:
+        assign_message += " ⚠️ Không có proxy – Đang dùng IP thật (Vẫn ổn nếu xài dưới 3 key/ngày)"
+
+    # Build kết quả
+    df = dataframe_with_keys(keys, proxies)
+    if not active_proxies:
+        assign_message = "⚠️ Không gắn proxy – Đang dùng IP thật (Vẫn ổn nếu xài dưới 3 Key/ngày)"
+    message = f"✅ Thêm {added} key mới, kiểm tra {checked} key. {assign_message}"
+    choices = get_key_choices_for_display(keys)
+    lowest = choices[0] if choices else None
+
+    return (
+        # Tab 2 outputs: key_df, key_dd, key_del_dd, key_sel, status_out, api_keys_state, total_credit_txt
+        df,
+        gr.update(choices=choices, value=lowest),  # dropdown “Chọn API Key”
+        gr.update(choices=choices, value=None),    # dropdown “Chọn API Key để xoá”
+        gr.update(choices=choices, value=None),    # dropdown “API Key”
+        message,
+        keys,
+        f"Tổng credit: {total_credit(keys):,}"
+    )
+
+@session_wrapper
+def refresh_keys(api_keys_state, proxies_state):
+    keys = api_keys_state.copy()
+    for k in keys:
+        keys[k] = get_api_usage(k, proxies=proxies_state)
+    df = dataframe_with_keys(keys, proxies_state)
+    choices = get_key_choices_for_display(keys)
+    lowest = choices[0] if choices else None
+    return (
+      df,
+      gr.update(choices=choices, value=lowest),  # an toàn ngay cả khi choices = []
+      f"Tổng credit: {total_credit(keys):,}",
+      gr.update(choices=choices, value=None),
+      keys
+    )
+@session_wrapper
+def filter_api_keys_by_credit(threshold, api_keys_state, proxies_state):
+    keys = api_keys_state.copy()
+    filtered = {k: v for k, v in keys.items() if v.get("remaining", 0) < threshold}
+    rows = []
+    for k, v in filtered.items():
+        masked_key = mask_api_key(k)
+        rows.append([masked_key, v.get("status", ""), v.get("used", 0), v.get("limit", 0), v.get("tier", ""), v.get("remaining", 0), proxy_host(get_proxy_of_key(k, proxies_state))])
+    df = pd.DataFrame(rows, columns=["API Key", "Status", "Used", "Limit", "Tier", "Remaining", "Proxy Host"])
+    return df
+
+def remove_insufficient_keys(threshold, api_keys_state, proxies_state):
+    keys = api_keys_state.copy()
+    filtered = {k: v for k, v in keys.items() if v.get("remaining", 0) >= threshold}
+    choices = get_key_choices_for_display(filtered)
+    lowest = choices[0] if choices else None
+    return (
+        dataframe_with_keys(filtered, proxies_state),
+        gr.update(choices=choices, value=lowest),
+        gr.update(choices=choices, value=None),
+        gr.update(choices=choices, value=None),
+        filtered
+    )
+@session_wrapper
+def key_has_proxy(k, proxies_state):
+    return bool(get_proxy_of_key(k, proxies_state))
+
+@session_wrapper
+def tts_from_text(text, voice, model, fmt, key_display, auto, bypass_proxy, voices_state, api_keys_state, proxies_state):
+    if not text.strip():
+        return None, "Nội dung trống!", "", api_keys_state
+    keys = api_keys_state.copy()
+    proxies = proxies_state.copy()
+    voices = voices_state.copy()
+    tokens = len(text)
+    import urllib3
+    urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
+    if auto:
+        if bypass_proxy:
+            c = [(k, v["remaining"]) for k, v in keys.items() if v.get("remaining", 0) >= tokens]
+        else:
+            c = [(k, v["remaining"]) for k, v in keys.items() if v.get("remaining", 0) >= tokens and key_has_proxy(k, proxies)]
+            if not c:
+                c = [(k, v["remaining"]) for k, v in keys.items() if v.get("remaining", 0) >= tokens]
+                bypass_proxy = True  # chuyển sang dùng IP thật
+        if not c:
+            return None, "❌ Không có key đủ credit", "", keys
+        api_key = sorted(c, key=lambda x: x[1])[0][0]
+    else:
+        if not key_display:
+            return None, "❌ Chưa chọn key", "", keys
+        api_key = get_real_key_from_display(key_display, keys)
+        if not bypass_proxy and not key_has_proxy(api_key, proxies):
+            return None, "❌ Key chưa gắn proxy", "", keys
+    proxy_url = None if bypass_proxy else get_proxy_of_key(api_key, proxies)
+    try:
+        info = voices.get(voice, {})
+        if not info:
+            return None, "❌ Voice không tồn tại", "", keys
+        payload = {
+            "text": text,
+            "voice_settings": info.get("settings", DEFAULT_VOICE_SETTINGS),
+            "model_id": model
+        }
+        headers = {
+            "Accept": "audio/mpeg",
+            "Content-Type": "application/json",
+            "xi-api-key": api_key
+        }
+        url = f"https://api.elevenlabs.io/v1/text-to-speech/{info.get('voice_id')}"
+        proxies_dict = None
+        if not bypass_proxy and proxy_url:
+            proxies_dict = {"http": proxy_url, "https": proxy_url}
+        response = requests.post(
+            url,
+            json=payload,
+            headers=headers,
+            proxies=proxies_dict,
+            timeout=30,
+            verify=False if proxies_dict else True
+        )
+        if response.status_code != 200:
+            error_detail = response.text
+            if response.status_code == 401 and "detected_unusual_activity" in error_detail:
+                return None, f"❌ Key {mask_api_key(api_key)} bị chặn 'unusual activity'.", "", keys
+            else:
+                return None, f"❌ API Error {response.status_code}: {error_detail[:100]}", "", keys
+        ext = fmt.split('_')[0] if '_' in fmt else fmt
+        timestamp = int(time.time())
+        unique_id = str(uuid.uuid4())[:8]
+        filename = f"tts_{timestamp}_{unique_id}.{ext}"
+        temp_dir = tempfile.gettempdir()
+        file_path = os.path.join(temp_dir, filename)
+        with open(file_path, 'wb') as f:
+            f.write(response.content)
+        if not os.path.exists(file_path):
+            return None, "❌ Không thể tạo file audio", "", keys
+        keys[api_key] = get_api_usage(api_key, bypass_proxy, proxies)
+        proxy_status = "🔓 Direct" if bypass_proxy or not proxy_url else f"🛡️ Proxy"
+        success_msg = f"✅ Tạo {tokens} ký tự bằng key {mask_api_key(api_key)} ({proxy_status})"
+        credit_msg = f"Tổng credit: {total_credit(keys):,}"
+        return file_path, success_msg, credit_msg, keys
+    except Exception as e:
+        error_msg = str(e)
+        if "ProxyError" in error_msg or "ConnectError" in error_msg:
+            return None, f"❌ Lỗi kết nối proxy: {mask_proxy_url(proxy_url)}", "", keys
+        else:
+            return None, f"❌ Lỗi: {error_msg[:100]}", "", keys
+
+@session_wrapper
+def verify_key_proxy(key_display, api_keys_state, proxies_state):
+    api_key = get_real_key_from_display(key_display, api_keys_state)
+    proxy = get_proxy_of_key(api_key, proxies_state)
+    if not proxy:
+        return "🔴 Key chưa gắn proxy!"
+    proxies = {"http": proxy, "https": proxy}
+    try:
+        r = requests.get("https://api.elevenlabs.io/v1/user/subscription", headers={"xi-api-key": api_key}, proxies=proxies, timeout=8)
+        ip = requests.get("https://api.ipify.org?format=json", proxies=proxies, timeout=6).json().get("ip", "-")
+        return f"{'✅' if r.status_code == 200 else '❌'} ElevenLabs {r.status_code} | IP via proxy: {ip}"
+    except Exception as e:
+        return f"❌ Lỗi: {str(e).split(' ')[0]}"
+
+# === Refresh-all ===
+@session_wrapper
+def refresh_all(voices_state, api_keys_state, proxies_state):
+    voices = voices_state.copy()
+    keys = api_keys_state.copy()
+    proxies = proxies_state.copy()
+    voice_list = get_voice_list(voices)
+    key_df     = dataframe_with_keys(keys, proxies)
+    proxy_df   = format_proxy_table(proxies)
+    sorted_keys = get_key_choices_for_display(keys)
+    proxy_list  = get_proxy_choices_for_display(proxies)
+    total_credit_msg = f"Tổng credit: {total_credit(keys):,}"
+    lowest = sorted_keys[0] if sorted_keys else None
+    return (
+        voice_list,
+        voice_list,
+        gr.update(choices=sorted_keys, value=lowest),
+        gr.update(choices=sorted_keys, value=None),
+        gr.update(choices=sorted_keys, value=None),
+        proxy_list,
+        total_credit_msg,
+        key_df,
+        proxy_df,
+        voices,
+        keys,
+        proxies,
+    )
+@session_wrapper
+def refresh_keys_complete(api_keys_state, proxies_state):
+    keys = api_keys_state.copy()
+    for k in keys:
+        keys[k] = get_api_usage(k, proxies=proxies_state)
+    key_df = dataframe_with_keys(keys, proxies_state)
+    sorted_keys = get_key_choices_for_display(keys)
+    total_credit_msg = f"Tổng credit: {total_credit(keys):,}"
+    lowest = sorted_keys[0] if sorted_keys else None
+    return (
+        key_df,
+        gr.update(choices=sorted_keys, value=lowest),  # “Chọn API Key”
+        gr.update(choices=sorted_keys, value=None),    # “Chọn API Key để xoá”
+        gr.update(choices=sorted_keys, value=None),    # “API Key”
+        total_credit_msg,
+        lowest,
+        keys
+    )
+@session_wrapper
+def refresh_proxies_complete(proxies_state, api_keys_state):
+    proxies = proxies_state.copy()
+    for url in proxies:
+        proxies[url].update(test_proxy_once(url))
+        proxies[url]["last_checked"] = datetime.utcnow().isoformat(timespec="seconds")
+    keys = api_keys_state.copy()
+    key_df = dataframe_with_keys(keys, proxies)
+    proxy_df = format_proxy_table(proxies)
+    proxy_list = get_proxy_choices_for_display(proxies)
+    return proxy_df, "🔄 Đã refresh proxy.", proxy_list, key_df, proxies
+
+@session_wrapper
+def refresh_voices_complete(voices_state):
+    voices = voices_state.copy()
+    voice_list = get_voice_list(voices)
+    voice_df = voice_table(voices)
+    return voice_list, voice_list, voice_df, voices
+
+# === UI ===
+with gr.Blocks() as demo:
+    voices_state = gr.State(load_default_voices())
+    api_keys_state = gr.State({})
+    proxies_state = gr.State(load_default_proxies())
+
+    gr.Markdown("""
+    > 🟢 **Công cụ này hoàn toàn MIỄN PHÍ cho tất cả mọi người.**  
+    > ❌ Vui lòng KHÔNG rao bán, đổi tên hay thương mại hoá công cụ.  
+    > 🛡️ Mọi dữ liệu (API key, proxy) chỉ lưu tạm trong phiên, tự xóa khi đóng trình duyệt.
+    """)
+    gr.Markdown("# 🎙️ ElevenLabs TTS + Proxy Manager")
+    with gr.Tabs():
+        with gr.Tab("1. Xử lý Batch"):
+            with gr.Row():
+                voice_dd = gr.Dropdown(choices=get_voice_list(voices_state.value), value=get_default_voice(voices_state.value), label="Chọn Voice", allow_custom_value=True)
+                model_dd = gr.Dropdown(choices=MODELS, value=DEFAULT_MODEL, label="Model")
+                fmt_dd = gr.Dropdown(choices=["mp3_44100", "wav"], value=DEFAULT_FORMAT, label="Output")
+            with gr.Row():
+                key_dd = gr.Dropdown(choices=get_key_choices_for_display(api_keys_state.value), value=None, label="Chọn API Key", allow_custom_value=True)
+                key_credit = gr.Text(label="Credit hiện còn", interactive=False)
+                total_credit_txt = gr.Text(label="Tổng Credit", interactive=False)
+            def update_key_credit(display_key, api_keys_state):
+                if not display_key:
+                    return "-"
+                real_key = get_real_key_from_display(display_key, api_keys_state)
+                return f"{api_keys_state.get(real_key, {}).get('remaining', '-'):,}"
+            key_dd.change(update_key_credit, [key_dd, api_keys_state], key_credit)
+            refresh_all_btn = gr.Button("🔄 Refresh All")
+            verify_btn = gr.Button("⚡ Kiểm tra Proxy của API Key")
+            status_out = gr.Text(label="Trạng thái")
+            input_txt = gr.Textbox(lines=6, label="Nội dung")
+            token_info = gr.Text(label="Tổng ký tự")
+            input_txt.change(lambda t: f"{len(t)} ký tự", input_txt, token_info)
+            auto_cb = gr.Checkbox(value=True, label="Tự động chọn API Key có gắn proxy")
+            bypass_proxy_cb = gr.Checkbox(value=False, label="🔓 Tạm thời không dùng proxy (bypass)")
+            generate_btn = gr.Button("🌀 Tạo giọng nói")
+            audio_out = gr.Audio(label="Kết quả", type="filepath")
+        with gr.Tab("2. Quản lý API Key"):
+            api_in = gr.Textbox(lines=4, label="Nhập API Key (mỗi dòng)")
+            save_key_btn = gr.Button("📅 Lưu & Kiểm tra")
+            refresh_key_btn = gr.Button("🔄 Refresh danh sách")
+            key_df = gr.Dataframe(label="Danh sách API Key", interactive=False)
+            gr.Markdown("### Xoá API Key thủ công")
+            key_del_dd = gr.Dropdown(choices=get_key_choices_for_display(api_keys_state.value), value=None, label="Chọn API Key để xoá", allow_custom_value=True)
+            key_del_btn = gr.Button("🗑️ Xoá API Key đã chọn")
+            gr.Markdown("### Lọc API Key theo Credit")
+            filter_input = gr.Number(label="Lọc các API Key có số credit dưới", value=100)
+            filter_btn = gr.Button("🔍 Lọc API Key")
+            remove_low_btn = gr.Button("❌ Xoá các key không đủ credit")
+        with gr.Tab("3. Quản lý Voice ID"):
+            with gr.Row():
+                v_name = gr.Textbox(label="Tên Voice")
+                v_id = gr.Textbox(label="Voice ID")
+                v_select = gr.Dropdown(choices=get_voice_list(voices_state.value), value=get_default_voice(voices_state.value), label="Chọn Voice để sửa", allow_custom_value=True)
+            voice_status = gr.Textbox(label="Trạng thái", interactive=False)
+            with gr.Row():
+                save_voice_btn = gr.Button("💾 Lưu Voice mới")
+            with gr.Row():
+                del_voice_btn = gr.Button("🗑️ Xoá Voice đang chọn")
+            with gr.Row():
+                speed_sl = gr.Slider(0.70, 1.20, DEFAULT_VOICE_SETTINGS["speed"], step=0.01, label="Speed")
+                stab_sl = gr.Slider(0, 1, DEFAULT_VOICE_SETTINGS["stability"], step=0.05, label="Stability")
+                sim_sl = gr.Slider(0, 1, DEFAULT_VOICE_SETTINGS["similarity_boost"], step=0.05, label="Similarity")
+                ex_sl = gr.Slider(0, 1, DEFAULT_VOICE_SETTINGS["style_exaggeration"], step=0.05, label="Exaggeration")
+                boost_cb = gr.Checkbox(value=True, label="Speaker Boost")
+            upd_cfg_btn = gr.Button("💾 Lưu cấu hình Voice")
+            reset_cfg_btn = gr.Button("↻ Reset cấu hình Voice")
+            refresh_v_btn = gr.Button("🔄 Làm mới danh sách Voice")
+            with gr.Row():
+                reset_confirm_cb = gr.Checkbox(value=False, label="Đồng ý reset về mặc định")
+                gr.HTML("")
+                delete_confirm_cb = gr.Checkbox(value=False, label="Đồng ý xoá voice")
+            voice_df = gr.Dataframe(label="Danh sách Voice", interactive=False)
+        with gr.Tab("4. Quản lý Proxy"):
+            proxy_in = gr.Textbox(lines=4, label="Nhập proxy (mỗi dòng | http://user:pass@host:port)")
+            add_p_btn = gr.Button("💾 Lưu & Kiểm tra")
+            refresh_p_btn = gr.Button("🔄 Refresh trạng thái")
+            proxy_df = gr.Dataframe(label="Danh sách Proxy", interactive=False)
+            p_status = gr.Text(label="Trạng thái")
+            gr.Markdown("### Xoá Proxy thủ công")
+            proxy_del_dd = gr.Dropdown(choices=get_proxy_choices_for_display(proxies_state.value), value=None, label="Chọn Proxy để xoá", allow_custom_value=True)
+            proxy_del_btn = gr.Button("🗑️ Xoá Proxy đã chọn")
+            gr.Markdown("### Gắn Proxy với API Key")
+            with gr.Row():
+                proxy_sel = gr.Dropdown(choices=get_proxy_choices_for_display(proxies_state.value), value=None, label="Proxy", allow_custom_value=True)
+                key_sel = gr.Dropdown(choices=get_key_choices_for_display(api_keys_state.value), value=None, label="API Key", allow_custom_value=True)
+            assign_btn = gr.Button("↔️ Gắn thủ công")
+            auto_btn = gr.Button("🤖 Gắn tự động thông minh")
+            filter_bad_btn = gr.Button("🔍 Lọc Proxy lỗi")
+            del_bad_btn = gr.Button("🗑️ Xoá Proxy lỗi")
+
+    # Events setup
+    @session_wrapper
+    def delete_api_key_manual(display_key, api_keys_state, proxies_state):
+        if not display_key:
+            return dataframe_with_keys(api_keys_state, proxies_state), get_key_choices_for_display(api_keys_state), get_key_choices_for_display(api_keys_state), get_key_choices_for_display(api_keys_state), "❌ Chọn API Key để xoá!", api_keys_state
+        real_key = get_real_key_from_display(display_key, api_keys_state)
+        keys = api_keys_state.copy()
+        if real_key in keys:
+            del keys[real_key]
+        key_list = get_key_choices_for_display(keys)
+        return (
+          dataframe_with_keys(keys, proxies_state),
+          gr.update(choices=key_list, value=key_list[0]),  # key_dd
+          gr.update(choices=key_list, value=None),         # key_del_dd
+          gr.update(choices=key_list, value=None),         # key_sel
+          f"🗑️ Đã xoá key: {display_key}",
+          keys
+        )
+
+    @session_wrapper
+    def delete_proxy_manual(display_proxy, proxies_state):
+        if not display_proxy:
+            return format_proxy_table(proxies_state), get_proxy_choices_for_display(proxies_state), "❌ Chọn Proxy để xoá!", proxies_state
+        real_proxy = get_real_proxy_from_display(display_proxy, proxies_state)
+        proxies = proxies_state.copy()
+        if real_proxy in proxies:
+            del proxies[real_proxy]
+        proxy_list = get_proxy_choices_for_display(proxies)
+        return format_proxy_table(proxies), proxy_list, f"🗑️ Đã xoá proxy: {display_proxy}", proxies
+
+    @session_wrapper
+    def update_proxy_and_sync(text, proxies_state):
+        proxy_table, message, proxies = add_and_test_proxies(text, proxies_state)
+        proxy_choices = get_proxy_choices_for_display(proxies)
+        return proxy_table, message, proxy_choices, proxies
+
+    @session_wrapper
+    def auto_assign_and_sync(proxies_state, api_keys_state):
+        proxy_df_result, message, proxies = auto_assign(proxies_state, api_keys_state)
+        proxies_choices = get_proxy_choices_for_display(proxies)
+        sorted_keys = get_key_choices_for_display(api_keys_state)
+        api_key_df = dataframe_with_keys(api_keys_state, proxies)
+        return proxy_df_result, message, proxies_choices, sorted_keys, api_key_df, proxies
+
+    @session_wrapper
+    def assign_manual_and_sync(proxy_display, key_display, proxies_state, api_keys_state):
+        proxy_df_result, message, proxies, keys = assign_proxy_to_key(proxy_display, key_display, proxies_state, api_keys_state)
+        api_key_df = dataframe_with_keys(keys, proxies)
+        return proxy_df_result, message, api_key_df, proxies, keys
+
+    @session_wrapper
+    def delete_bad_and_sync(proxies_state):
+        proxy_table, message, proxies = delete_bad(proxies_state)
+        proxies_choices = get_proxy_choices_for_display(proxies)
+        return proxy_table, message, proxies_choices, proxies
+
+    # Gắn sự kiện
+    key_del_btn.click(
+        delete_api_key_manual,
+        [key_del_dd, api_keys_state, proxies_state],
+        [key_df, key_dd, key_del_dd, key_sel, status_out, api_keys_state]
+    )
+    proxy_del_btn.click(
+        delete_proxy_manual,
+        [proxy_del_dd, proxies_state],
+        [proxy_df, proxy_del_dd, p_status, proxies_state]
+    )
+    save_key_btn.click(
+        fn=save_and_show_keys,
+        inputs=[api_in, api_keys_state, proxies_state],
+        outputs=[key_df, key_dd, key_del_dd, key_sel, status_out, api_keys_state, total_credit_txt]
+    )
+    refresh_key_btn.click(
+        refresh_keys,
+        [api_keys_state, proxies_state],
+        [key_df, key_dd, total_credit_txt, key_sel, api_keys_state]
+    )
+    filter_btn.click(
+        filter_api_keys_by_credit,
+        [filter_input, api_keys_state, proxies_state],
+        key_df
+    )
+    remove_low_btn.click(
+        remove_insufficient_keys,
+        [filter_input, api_keys_state, proxies_state],
+        [key_df, key_dd, key_del_dd, key_sel, api_keys_state]
+    )
+    refresh_all_btn.click(
+        refresh_all,
+        [voices_state, api_keys_state, proxies_state],
+        [voice_dd, v_select, key_dd, key_del_dd, key_sel, proxy_sel, total_credit_txt, key_df, proxy_df, voices_state, api_keys_state, proxies_state]
+    )
+    verify_btn.click(
+        verify_key_proxy,
+        [key_dd, api_keys_state, proxies_state],
+        status_out
+    )
+    generate_btn.click(
+        tts_from_text,
+        [input_txt, voice_dd, model_dd, fmt_dd, key_dd, auto_cb, bypass_proxy_cb, voices_state, api_keys_state, proxies_state],
+        [audio_out, status_out, total_credit_txt, api_keys_state]
+    )
+    def save_voice_and_refresh(name, voice_id, current_voice, voices_state):
+        status, v_select_choices, voice_dd_choices, selected_voice, new_voices_state = save_voice(
+            name, voice_id, current_voice, voices_state
+        )
+        voice_df_data = voice_table(new_voices_state)
+        voice_dd_update = gr.update(choices=get_voice_list(new_voices_state), value=get_default_voice(new_voices_state))
+        return status, v_select_choices, voice_dd_update, selected_voice, new_voices_state, voice_df_data
+    save_voice_btn.click(
+        save_voice_and_refresh,
+        [v_name, v_id, v_select, voices_state],
+        [voice_status, v_select, voice_dd, v_select, voices_state, voice_df]
+    )
+    v_select.change(
+        load_voice_for_edit,
+        [v_select, voices_state],
+        [v_name, v_id, speed_sl, stab_sl, sim_sl, ex_sl, boost_cb]
+    )
+    def update_voice_cfg_and_refresh(name, speed, stab, sim, exag, boost, cur, voices_state):
+        status, v_select_choices, voice_dd_choices, selected_voice, new_voices_state = update_voice_cfg(
+            name, speed, stab, sim, exag, boost, cur, voices_state
+        )
+        voice_df_data = voice_table(new_voices_state)
+        return status, v_select_choices, voice_dd_choices, selected_voice, new_voices_state, voice_df_data
+    upd_cfg_btn.click(
+        update_voice_cfg_and_refresh,
+        [v_select, speed_sl, stab_sl, sim_sl, ex_sl, boost_cb, v_select, voices_state],
+        [voice_status, v_select, voice_dd, v_select, voices_state, voice_df]
+    )
+    def reset_voice_and_refresh(name, confirm, cur, voices_state):
+        status, v_select_choices, voice_dd_choices, selected_voice, new_voices_state = reset_voice(
+            name, confirm, cur, voices_state
+        )
+        voice_df_data = voice_table(new_voices_state)
+        voice_dd_update = gr.update(choices=get_voice_list(new_voices_state), value=get_default_voice(new_voices_state))
+        return status, v_select_choices, voice_dd_update, selected_voice, new_voices_state, voice_df_data
+    reset_cfg_btn.click(
+        reset_voice_and_refresh,
+        [v_select, reset_confirm_cb, v_select, voices_state],
+        [voice_status, v_select, voice_dd, v_select, voices_state, voice_df]
+    )
+    refresh_v_btn.click(
+        refresh_voices_complete,
+        voices_state,
+        [v_select, voice_dd, voice_df, voices_state]
+    )
+    def del_voice_and_refresh(name, confirm, cur, voices_state):
+        status, v_select_choices, voice_dd_choices, selected_voice, new_voices_state = delete_voice(
+            name, confirm, cur, voices_state
+        )
+        voice_df_data = voice_table(new_voices_state)
+        voice_dd_update = gr.update(choices=get_voice_list(new_voices_state), value=get_default_voice(new_voices_state))
+        return status, v_select_choices, voice_dd_update, selected_voice, new_voices_state, voice_df_data
+    del_voice_btn.click(
+        del_voice_and_refresh,
+        [v_select, delete_confirm_cb, v_select, voices_state],
+        [voice_status, v_select, voice_dd, v_select, voices_state, voice_df]
+    )
+    def add_proxy_and_refresh(text, proxies_state):
+        proxy_table, message, new_proxies_state = add_and_test_proxies(text, proxies_state)
+        proxy_sel_update = gr.update(choices=get_proxy_choices_for_display(new_proxies_state), value=None)
+        proxy_del_dd_update = gr.update(choices=get_proxy_choices_for_display(new_proxies_state), value=None)
+        return proxy_table, message, proxy_sel_update, new_proxies_state, proxy_del_dd_update
+    add_p_btn.click(
+        add_proxy_and_refresh,
+        [proxy_in, proxies_state],
+        [proxy_df, p_status, proxy_sel, proxies_state, proxy_del_dd]
+    )
+    refresh_p_btn.click(
+        refresh_proxies_complete,
+        [proxies_state, api_keys_state],
+        [proxy_df, p_status, proxy_sel, key_df, proxies_state]
+    )
+    assign_btn.click(
+        assign_manual_and_sync,
+        [proxy_sel, key_sel, proxies_state, api_keys_state],
+        [proxy_df, p_status, key_df, proxies_state, api_keys_state]
+    )
+    auto_btn.click(
+        auto_assign_and_sync,
+        [proxies_state, api_keys_state],
+        [proxy_df, p_status, proxy_sel, key_sel, key_df, proxies_state]
+    )
+    filter_bad_btn.click(
+        filter_bad_proxies,
+        proxies_state,
+        proxy_df
+    )
+    del_bad_btn.click(
+        delete_bad_and_sync,
+        proxies_state,
+        [proxy_df, p_status, proxy_sel, proxies_state]
+    )
+    demo.load(
+        voice_table,
+        voices_state,
+        voice_df
+    )
+    demo.load(
+        dataframe_with_keys,
+        [api_keys_state, proxies_state],
+        key_df
+    )
+    demo.load(
+        format_proxy_table,
+        proxies_state,
+        proxy_df
+    )
+    demo.load(
+        lambda api_keys: f"Tổng credit: {total_credit(api_keys):,}",
+        api_keys_state,
+        total_credit_txt
+    )
+
+demo.launch(ssr_mode=False)

requirements.txt

@@ -0,0 +1,6 @@
+gradio
+pandas
+requests
+python-dotenv
+elevenlabs
+aiohttp

voices.json

@@ -0,0 +1,222 @@
+{
+  "👨‍💼Josh": {
+    "voice_id": "TxGEqnHWrfWFTfGW9XjX",
+    "settings": {
+      "speed": 0.83,
+      "stability": 0.93,
+      "similarity_boost": 0.95,
+      "style_exaggeration": 0,
+      "use_speaker_boost": true
+    }
+  },
+  "👨‍💼Liam": {
+    "voice_id": "TX3LPaxmHKxFdv7VOQHJ",
+    "settings": {
+      "speed": 0.81,
+      "stability": 0.95,
+      "similarity_boost": 0.95,
+      "style_exaggeration": 0,
+      "use_speaker_boost": true
+    }
+  },
+  "👨‍💼Antoni": {
+    "voice_id": "ErXwobaYiN019PkySvjV",
+    "settings": {
+      "speed": 0.84,
+      "stability": 0.95,
+      "similarity_boost": 0.95,
+      "style_exaggeration": 0,
+      "use_speaker_boost": true
+    }
+  },
+  "👨🏻‍🦰Chris": {
+    "voice_id": "iP95p4xoKVk53GoZ742B",
+    "settings": {
+      "speed": 0.81,
+      "stability": 0.4,
+      "similarity_boost": 0.95,
+      "style_exaggeration": 0,
+      "use_speaker_boost": true
+    }
+  },
+  "👨🏻‍🦰Arnold": {
+    "voice_id": "VR6AewLTigWG4xSOukaG",
+    "settings": {
+      "speed": 0.86,
+      "stability": 0.4,
+      "similarity_boost": 0.95,
+      "style_exaggeration": 0,
+      "use_speaker_boost": true
+    }
+  },
+  "👨🏻‍🦰Adam": {
+    "voice_id": "pNInz6obpgDQGcFmaJgB",
+    "settings": {
+      "speed": 0.86,
+      "stability": 0.4,
+      "similarity_boost": 0.95,
+      "style_exaggeration": 0,
+      "use_speaker_boost": true
+    }
+  },
+  "👨🏻‍🦰Brian": {
+    "voice_id": "nPczCjzI2devNBz1zQrb",
+    "settings": {
+      "speed": 0.83,
+      "stability": 0.96,
+      "similarity_boost": 0.95,
+      "style_exaggeration": 0,
+      "use_speaker_boost": true
+    }
+  },
+  "👨🏻‍🦰Roger": {
+    "voice_id": "CwhRBWXzGAHq8TQ4Fs17",
+    "settings": {
+      "speed": 0.86,
+      "stability": 0.4,
+      "similarity_boost": 0.95,
+      "style_exaggeration": 0,
+      "use_speaker_boost": true
+    }
+  },
+  "👨🏻‍🦰Paul": {
+    "voice_id": "5Q0t7uMcjvnagumLfvZi",
+    "settings": {
+      "speed": 0.86,
+      "stability": 0.9,
+      "similarity_boost": 0.95,
+      "style_exaggeration": 0,
+      "use_speaker_boost": true
+    }
+  },
+  "👨🏻‍🦰Drew": {
+    "voice_id": "29vD33N1CtxCmqQRPOHJ",
+    "settings": {
+      "speed": 0.86,
+      "stability": 0.9,
+      "similarity_boost": 0.95,
+      "style_exaggeration": 0,
+      "use_speaker_boost": true
+    }
+  },
+  "👴🏻Michael": {
+    "voice_id": "flq6f7yk4E4fJM5XTYuZ",
+    "settings": {
+      "speed": 0.83,
+      "stability": 0.96,
+      "similarity_boost": 0.95,
+      "style_exaggeration": 0,
+      "use_speaker_boost": true
+    }
+  },
+  "👴🏻Jessie": {
+    "voice_id": "t0jbNlBVZ17f02VDIeMI",
+    "settings": {
+      "speed": 0.86,
+      "stability": 0.9,
+      "similarity_boost": 0.95,
+      "style_exaggeration": 0,
+      "use_speaker_boost": true
+    }
+  },
+  "👴🏻Bill": {
+    "voice_id": "pqHfZKP75CvOlQylNhV4",
+    "settings": {
+      "speed": 0.86,
+      "stability": 0.9,
+      "similarity_boost": 0.95,
+      "style_exaggeration": 0,
+      "use_speaker_boost": true
+    }
+  },
+  "👩‍🦳Emily": {
+    "voice_id": "LcfcDJNUP1GQjkzn1xUU",
+    "settings": {
+      "stability": 0.43,
+      "similarity_boost": 0.28,
+      "style_exaggeration": 0,
+      "use_speaker_boost": true,
+      "speed": 1.05
+    }
+  },
+  "👩‍🦳Glinda": {
+    "voice_id": "z9fAnlkpzviPz146aGWa",
+    "settings": {
+      "stability": 0.43,
+      "similarity_boost": 0.28,
+      "style_exaggeration": 0,
+      "use_speaker_boost": true,
+      "speed": 1
+    }
+  },
+  "👩‍🦳Serena": {
+    "voice_id": "pMsXgVXv3BLzUgSXRplE",
+    "settings": {
+      "stability": 0.43,
+      "similarity_boost": 0.28,
+      "style_exaggeration": 0,
+      "use_speaker_boost": true,
+      "speed": 1
+    }
+  },
+  "👩‍🦳Matilda": {
+    "voice_id": "XrExE9yKIg1WjnnlVkGX",
+    "settings": {
+      "stability": 0.43,
+      "similarity_boost": 0.28,
+      "style_exaggeration": 0,
+      "use_speaker_boost": true,
+      "speed": 1
+    }
+  },
+  "👩‍🦳River": {
+    "voice_id": "SAz9YHcvj6GT2YYXdXww",
+    "settings": {
+      "stability": 0.43,
+      "similarity_boost": 0.28,
+      "style_exaggeration": 0,
+      "use_speaker_boost": true,
+      "speed": 1
+    }
+  },
+  "👴🏻Callum": {
+    "voice_id": "N2lVS1w4EtoT3dr4eOWO",
+    "settings": {
+      "stability": 0.43,
+      "similarity_boost": 0.28,
+      "style_exaggeration": 0,
+      "use_speaker_boost": true,
+      "speed": 1
+    }
+  },
+  "👴🏻Clyde": {
+    "voice_id": "2EiwWnXFnvU5JabPnv8n",
+    "settings": {
+      "speed": 0.86,
+      "stability": 0.9,
+      "similarity_boost": 0.95,
+      "style_exaggeration": 0,
+      "use_speaker_boost": true
+    }
+  },
+  "👨B. Patrone - Peaceful & Meditative": {
+    "voice_id": "p28fY1cl6tovhD2M4WEH",
+    "settings": {
+      "speed": 1.05,
+      "stability": 0.95,
+      "similarity_boost": 0.95,
+      "style_exaggeration": 0,
+      "use_speaker_boost": true
+    }
+  },
+  "👴🏻Drstephe": {
+    "voice_id": "eC5XQ2bYx6LQHFG29bNv",
+    "settings": {
+      "speed": 1.0,
+      "stability": 0.5,
+      "similarity_boost": 0.75,
+      "style_exaggeration": 0.0,
+      "use_speaker_boost": true
+    }
+  }
+}