| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| import os |
| import sys |
| import json |
| import time |
| import secrets |
| import threading |
| import subprocess |
|
|
| import gradio as gr |
|
|
| APP_DIR = os.path.dirname(os.path.abspath(__file__)) |
|
|
| |
| |
| VOICE_API_NAME = "predict_voice_conversion" |
| VOICE_STATUS_API_NAME = "voice_status" |
| VOICE_CONCURRENCY_ID = "voice_clone" |
| |
| VOICE_CONCURRENCY_LIMIT = max(1, min(4, int(os.environ.get("VOICE_CONCURRENCY_LIMIT", "2") or 2))) |
|
|
| |
| |
| VOICE_ENGINE_WAIT_SECONDS = float(os.environ.get("VOICE_ENGINE_WAIT_SECONDS", "900")) |
| |
| VOICE_JOB_TIMEOUT_SECONDS = float(os.environ.get("VOICE_JOB_TIMEOUT_SECONDS", "3600")) |
|
|
|
|
| class RequesterGone(RuntimeError): |
| """درخواست‌دهنده دیگر منتظر نیست (اتصالش قطع شد)؛ تبدیل لغو شد. خطای واقعی نیست.""" |
|
|
|
|
| class VoiceEngine: |
| """مدیرِ پروسه‌ی جداگانه‌ی موتورِ صدا (روشن‌کردن، نظارت، ارسالِ کار).""" |
|
|
| def __init__(self): |
| tag = f"{os.getpid()}" |
| self.sock_path = f"/tmp/alpha_voice_engine_{tag}.sock" |
| self.state_path = f"/tmp/alpha_voice_engine_{tag}.json" |
| self.authkey = secrets.token_bytes(32) |
| self.proc = None |
| self.lock = threading.Lock() |
| self.started = False |
| self.restarts = 0 |
| self.last_exit_code = None |
| self.active_jobs = 0 |
| self.jobs_lock = threading.Lock() |
| self._stop = False |
|
|
| |
| def _spawn(self): |
| env = dict(os.environ) |
| env["VOICE_ENGINE_AUTHKEY"] = self.authkey.hex() |
| env["PYTHONUNBUFFERED"] = "1" |
| env["VOICE_CONCURRENT_JOBS"] = str(VOICE_CONCURRENCY_LIMIT) |
| for path in (self.sock_path, self.state_path): |
| try: |
| os.remove(path) |
| except FileNotFoundError: |
| pass |
| |
| script = os.environ.get("VOICE_ENGINE_SCRIPT") or os.path.join(APP_DIR, "voice_engine.py") |
| self.proc = subprocess.Popen( |
| [sys.executable, "-u", script, "--serve", self.sock_path, "--state", self.state_path], |
| cwd=APP_DIR, env=env, |
| ) |
| print(f"🎙️ [کلون صدا] موتورِ صدا روی CPU در حالِ بالا آمدن است (pid={self.proc.pid})...", flush=True) |
|
|
| def start(self): |
| with self.lock: |
| if self.started: |
| return |
| self.started = True |
| self._spawn() |
| threading.Thread(target=self._watch, daemon=True, name="voice-engine-watch").start() |
|
|
| def _watch(self): |
| fails = 0 |
| while not self._stop: |
| proc = self.proc |
| code = proc.wait() |
| if self._stop: |
| return |
| self.last_exit_code = code |
| fails += 1 |
| self.restarts += 1 |
| wait_s = min(60, 2 ** min(fails, 6)) |
| print(f"⚠️ [کلون صدا] موتورِ صدا بسته شد (کد {code})؛ {wait_s} ثانیه دیگر دوباره روشن می‌شود.", |
| flush=True) |
| time.sleep(wait_s) |
| with self.lock: |
| self._spawn() |
| |
| for _ in range(300): |
| if self._stop or self.proc.poll() is not None: |
| break |
| time.sleep(1) |
| else: |
| fails = 0 |
|
|
| |
| def _state(self): |
| try: |
| with open(self.state_path, "r", encoding="utf-8") as f: |
| return json.load(f) |
| except Exception: |
| return {} |
|
|
| def is_ready(self): |
| proc = self.proc |
| if proc is None or proc.poll() is not None: |
| return False |
| st = self._state() |
| return bool(st.get("ready")) and st.get("pid") == proc.pid and os.path.exists(self.sock_path) |
|
|
| def is_warm(self): |
| return bool(self._state().get("warm")) and self.is_ready() |
|
|
| def wait_ready(self, timeout, progress=None): |
| deadline = time.time() + max(0.0, timeout) |
| shown = False |
| while time.time() < deadline: |
| if self.is_ready(): |
| return True |
| if progress is not None and not shown: |
| shown = True |
| try: |
| progress(0.0, desc="در حال آماده‌سازی مدل صدا روی CPU...") |
| except Exception: |
| pass |
| time.sleep(1.0) |
| return self.is_ready() |
|
|
| def slots(self): |
| """چند تبدیلِ هم‌زمان (۲ = «کارِ دوم هم‌زمان»)؛ کمترینِ تنظیمِ این‌جا و موتور.""" |
| try: |
| engine = int(self._state().get("concurrency") or VOICE_CONCURRENCY_LIMIT) |
| except Exception: |
| engine = VOICE_CONCURRENCY_LIMIT |
| return max(1, min(VOICE_CONCURRENCY_LIMIT, engine)) |
|
|
| |
| def convert(self, source_path, ref_path, progress=None, alive=None): |
| """یک تبدیل: مسیرِ فایلِ خروجی را برمی‌گرداند یا خطا (با متنِ خودِ موتور). |
| alive: تابعی که می‌گوید درخواست‌دهنده هنوز منتظر است یا نه (اگر نه، کار لغو می‌شود).""" |
| return self._request({"op": "convert", "source": source_path, "ref": ref_path}, progress, alive) |
|
|
| def _request(self, payload, progress=None, alive=None): |
| from multiprocessing.connection import Client |
|
|
| if not self.wait_ready(VOICE_ENGINE_WAIT_SECONDS, progress=progress): |
| raise RuntimeError("موتور تبدیل صدا هنوز آماده نشده است؛ چند دقیقه‌ی دیگر دوباره تلاش کنید.") |
| try: |
| conn = Client(self.sock_path, family="AF_UNIX", authkey=self.authkey) |
| except Exception as e: |
| raise RuntimeError(f"اتصال به موتور تبدیل صدا ناموفق بود ({type(e).__name__}).") |
| try: |
| conn.send(payload) |
| deadline = time.time() + VOICE_JOB_TIMEOUT_SECONDS |
| while True: |
| remaining = deadline - time.time() |
| if remaining <= 0: |
| raise RuntimeError("تبدیل صدا بیش از حد طول کشید.") |
| if alive is not None and not _safe_alive(alive): |
| |
| try: |
| conn.send({"op": "cancel"}) |
| except Exception: |
| pass |
| raise RequesterGone("درخواست‌دهنده دیگر منتظر نبود؛ تبدیل لغو شد.") |
| if not conn.poll(min(remaining, 1.0)): |
| if self.proc is None or self.proc.poll() is not None: |
| raise RuntimeError("موتور تبدیل صدا وسطِ کار بسته شد؛ دوباره تلاش کنید.") |
| continue |
| msg = conn.recv() |
| op = (msg or {}).get("op") |
| if op == "progress": |
| if progress is not None: |
| try: |
| progress(float(msg.get("value") or 0.0), desc=str(msg.get("desc") or "")) |
| except Exception: |
| pass |
| continue |
| if op == "done": |
| return msg.get("path") |
| if op == "error": |
| raise RuntimeError(str(msg.get("message") or "خطای نامشخص")) |
| except EOFError: |
| raise RuntimeError("موتور تبدیل صدا وسطِ کار بسته شد؛ دوباره تلاش کنید.") |
| finally: |
| try: |
| conn.close() |
| except Exception: |
| pass |
|
|
|
|
| ENGINE = VoiceEngine() |
|
|
|
|
| def _safe_alive(alive): |
| try: |
| return bool(alive()) |
| except Exception: |
| return True |
|
|
|
|
| def _request_alive(request): |
| """آیا کسی هنوز منتظرِ همین درخواست است؟ وقتی اتصالِ درخواست‌دهنده (اکشن پرو یا صفحه) |
| قطع شود، Gradio رویدادش را «مرده» علامت می‌زند و دیگر هیچ نتیجه‌ای به او نمی‌رسد؛ پس |
| ادامه‌ی تبدیل فقط CPU و جای کارِ بعدی را هدر می‌داد. اگر معلوم نشد، «زنده» فرض می‌شود.""" |
| session_hash = getattr(request, "session_hash", None) |
| queue = getattr(_VOICE.get("demo"), "_queue", None) |
| if not session_hash or queue is None: |
| return lambda: True |
|
|
| def _alive(): |
| found = False |
| for job_set in list(getattr(queue, "active_jobs", None) or []): |
| for event in list(job_set or []): |
| if getattr(event, "session_hash", None) != session_hash: |
| continue |
| cid = getattr(event, "concurrency_id", None) or getattr(getattr(event, "fn", None), "concurrency_id", None) |
| if cid is not None and cid != VOICE_CONCURRENCY_ID: |
| continue |
| found = True |
| if getattr(event, "alive", True): |
| return True |
| return not found |
| return _alive |
|
|
|
|
| def start_engine(): |
| """در ابتدای برنامه صدا زده می‌شود تا مدلِ صدا هم‌زمان با مدل‌های آهنگ بالا بیاید.""" |
| ENGINE.start() |
|
|
|
|
| |
| |
| |
| |
| def predict_voice_conversion(source_audio_path, ref_audio_path, request: gr.Request = None, progress=gr.Progress()): |
| if source_audio_path is None or ref_audio_path is None: |
| raise gr.Error("لطفاً هر دو فایل صوتی (اصلی و مرجع) را وارد کنید.") |
|
|
| with ENGINE.jobs_lock: |
| ENGINE.active_jobs += 1 |
| try: |
| return ENGINE.convert(source_audio_path, ref_audio_path, progress=progress, alive=_request_alive(request)) |
| except gr.Error: |
| raise |
| except RequesterGone as e: |
| |
| print("⏹️ [کلون صدا] درخواست‌دهنده رفت؛ تبدیل لغو و CPU برای کارِ بعدی آزاد شد.", flush=True) |
| raise gr.Error(str(e), print_exception=False) |
| except Exception as e: |
| raise gr.Error(f"خطایی در حین پردازش رخ داد: {str(e)}") |
| finally: |
| with ENGINE.jobs_lock: |
| ENGINE.active_jobs = max(0, ENGINE.active_jobs - 1) |
|
|
|
|
| |
| |
| |
| _VOICE = {"demo": None, "fn_index": None} |
|
|
|
|
| def _voice_queue_counts(): |
| """(منتظر، در حال اجرا) فقط برای تابعِ صدا، از صفِ خودِ گرادیو.""" |
| demo = _VOICE.get("demo") |
| try: |
| queue = getattr(demo, "_queue", None) |
| event_queue = queue.event_queue_per_concurrency_id.get(VOICE_CONCURRENCY_ID) if queue else None |
| if event_queue is not None: |
| return len(event_queue.queue), int(event_queue.current_concurrency) |
| except Exception: |
| pass |
| running = min(ENGINE.active_jobs, VOICE_CONCURRENCY_LIMIT) |
| return max(0, ENGINE.active_jobs - running), running |
|
|
|
|
| def voice_status() -> dict: |
| """وضعیتِ لحظه‌ایِ بخشِ کلونِ صدا. بدونِ صف و فوری؛ هیچ کاری اجرا نمی‌کند.""" |
| waiting, running = _voice_queue_counts() |
| return { |
| "service": "voice", |
| "api_name": VOICE_API_NAME, |
| "fn_index": _VOICE.get("fn_index"), |
| "ready": ENGINE.is_ready(), |
| "warm": ENGINE.is_warm(), |
| "running": running, |
| "waiting": waiting, |
| "concurrency": VOICE_CONCURRENCY_LIMIT, |
| |
| "slots": ENGINE.slots(), |
| "music": True, |
| "avatar": True, |
| "version": 3, |
| } |
|
|
|
|
| |
| |
| |
| def build_voice_tab(demo): |
| gr.Markdown("# سامانه تبدیل صدا (Vevo Voice Conversion) - نسخه CPU") |
|
|
| with gr.Row(): |
| with gr.Column(): |
| source_input = gr.Audio(type="filepath", label="فایل صوتی اصلی (Source Audio)") |
| ref_input = gr.Audio(type="filepath", label="فایل صوتی مرجع/هدف (Reference Timbre)") |
| submit_btn = gr.Button("شروع فرآیند تبدیل صدا", variant="primary") |
|
|
| with gr.Column(): |
| audio_output = gr.Audio(label="خروجی صدای شبیه‌سازی شده", type="filepath") |
|
|
| dep = submit_btn.click( |
| fn=predict_voice_conversion, |
| inputs=[source_input, ref_input], |
| outputs=audio_output, |
| api_name=VOICE_API_NAME, |
| concurrency_limit=VOICE_CONCURRENCY_LIMIT, |
| concurrency_id=VOICE_CONCURRENCY_ID, |
| ) |
|
|
| def _fn_index_of(event): |
| try: |
| idx = getattr(getattr(event, "fn", None), "_id", None) |
| if idx is None and isinstance(event, dict): |
| idx = event.get("id") |
| return idx |
| except Exception: |
| return None |
|
|
| _VOICE["demo"] = demo |
| _VOICE["fn_index"] = _fn_index_of(dep) |
|
|
| |
| gr.api(voice_status, api_name=VOICE_STATUS_API_NAME, queue=False) |
| return {"source_input": source_input, "ref_input": ref_input, |
| "submit_btn": submit_btn, "audio_output": audio_output} |
|
|
