|
|
import base64
|
|
|
import json
|
|
|
import os
|
|
|
import random
|
|
|
from pathlib import Path
|
|
|
|
|
|
import requests
|
|
|
from dotenv import load_dotenv
|
|
|
|
|
|
from utils import settings
|
|
|
from utils.console import print_substep
|
|
|
|
|
|
# Load environment variables from .env file
|
|
|
load_dotenv()
|
|
|
|
|
|
CRIKK_API_URL = os.getenv("CRIKK_API_URL", "")
|
|
|
CRIKK_BASE_URL = os.getenv("CRIKK_BASE_URL", "")
|
|
|
VOICES_FILE = Path(__file__).resolve().parent.parent / "config" / "crikk_voices.json"
|
|
|
|
|
|
def _load_voices() -> list[dict]:
|
|
|
try:
|
|
|
with open(VOICES_FILE, "r", encoding="utf-8") as f:
|
|
|
return json.load(f)
|
|
|
except (FileNotFoundError, json.JSONDecodeError) as e:
|
|
|
print_substep(f"Warning: Could not load voices from {VOICES_FILE}: {e}", style="yellow")
|
|
|
return []
|
|
|
|
|
|
|
|
|
class Crikk:
|
|
|
# Load list of User‑Agent strings for random header
|
|
|
_user_agents = None
|
|
|
|
|
|
def _load_user_agents(self) -> list[str]:
|
|
|
"""Read user_agents.json and cache result.
|
|
|
Returns empty list on failure and logs warning.
|
|
|
"""
|
|
|
if self._user_agents is not None:
|
|
|
return self._user_agents
|
|
|
try:
|
|
|
agents_path = Path(__file__).resolve().parent.parent / "config" / "user_agents.json"
|
|
|
with open(agents_path, "r", encoding="utf-8") as f:
|
|
|
self._user_agents = json.load(f)
|
|
|
except Exception as e:
|
|
|
print_substep(f"Warning: Could not load user agents: {e}", style="yellow")
|
|
|
self._user_agents = []
|
|
|
return self._user_agents
|
|
|
|
|
|
def _pick_user_agent(self) -> str:
|
|
|
"""Return a random User‑Agent string from loaded list.
|
|
|
Falls back to generic UA on empty list.
|
|
|
"""
|
|
|
agents = self._load_user_agents()
|
|
|
if agents:
|
|
|
return random.choice(agents)
|
|
|
return "Mozilla/5.0"
|
|
|
|
|
|
def __init__(self):
|
|
|
self.max_chars = 1200
|
|
|
self.voices = _load_voices()
|
|
|
|
|
|
def run(self, text, filepath, random_voice: bool = False):
|
|
|
voice = self._pick_voice(random_voice)
|
|
|
audio_bytes = self._call_api(text, voice["id"])
|
|
|
with open(filepath, "wb") as f:
|
|
|
f.write(audio_bytes)
|
|
|
|
|
|
def randomvoice(self) -> dict:
|
|
|
lang = settings.config["settings"]["tts"].get("ohfreeme_lang", "vi")
|
|
|
filtered = [v for v in self.voices if v["lang"] == lang]
|
|
|
if not filtered:
|
|
|
filtered = self.voices
|
|
|
return random.choice(filtered)
|
|
|
|
|
|
def _pick_voice(self, random_voice: bool) -> dict:
|
|
|
if random_voice:
|
|
|
return self.randomvoice()
|
|
|
lang = settings.config["settings"]["tts"].get("ohfreeme_lang", "vi")
|
|
|
gender = settings.config["settings"]["tts"].get("ohfreeme_gender", "random")
|
|
|
candidates = [v for v in self.voices if v["lang"] == lang]
|
|
|
if gender != "random":
|
|
|
candidates = [v for v in candidates if v["gender"] == gender]
|
|
|
if not candidates:
|
|
|
candidates = self.voices
|
|
|
return random.choice(candidates)
|
|
|
|
|
|
def _call_api(self, text: str, voice_id: int) -> bytes:
|
|
|
payload = {
|
|
|
"text": text,
|
|
|
"voice": voice_id,
|
|
|
}
|
|
|
headers = {
|
|
|
"cache-control": "no-cache",
|
|
|
"content-type": "application/json",
|
|
|
"accept": "*/*",
|
|
|
"user-agent": self._pick_user_agent(), # important
|
|
|
"origin": CRIKK_BASE_URL, # important
|
|
|
}
|
|
|
|
|
|
resp = requests.post(CRIKK_API_URL, json=payload, headers=headers)
|
|
|
data = resp.json()
|
|
|
|
|
|
if data.get("message") == "success":
|
|
|
print_substep(f"[Crikk debug] Received")
|
|
|
return self._extract_audio(data)
|
|
|
|
|
|
raise RuntimeError(f"Crikk TTS failed")
|
|
|
|
|
|
def _extract_audio(self, data: dict) -> bytes:
|
|
|
# Expecting a dict with a "url" field containing a data URI
|
|
|
url = data.get("audio_data")
|
|
|
if not url:
|
|
|
raise RuntimeError("Missing 'url' in API response data")
|
|
|
# url format: "data:audio/mpeg;base64,<base64data>"
|
|
|
if not (url.startswith("data:") and ";base64," in url):
|
|
|
raise RuntimeError(f"Unexpected URL format in API response: {url}")
|
|
|
b64_part = url.split(";base64,", 1)[1]
|
|
|
return base64.b64decode(b64_part)
|
