Watch
1
0
Fork
You've already forked arc
0
forked from hesabix/arc
arc/hesabixAPI/app/services/voice/voice_catalog.py
2026-08-18 18:32:09 +00:00

441 lines
14 KiB
Python

from __future__ import annotations
import json
from datetime import datetime
from typing import Any, Dict, List, Optional
from sqlalchemy.orm import Session
from adapters.db.models.ai_voice_model import AIVoiceModel, AIVoicePolicy, BusinessAIVoiceSettings
from adapters.db.repositories.ai_voice_model_repository import (
AIVoiceModelRepository,
AIVoicePolicyRepository,
BusinessAIVoiceSettingsRepository,
)
from app.core.responses import ApiError
from app.core.settings import get_settings
from app.services.voice.contracts import (
VOICE_KIND_STT,
VOICE_KIND_TTS,
VOICE_KINDS,
provider_is_cloud,
)
_CODE_MAX = 80
def serialize_voice_model(model: AIVoiceModel) -> Dict[str, Any]:
extra = _parse_extra(model.extra_json)
return {
"id": model.id,
"code": model.code,
"kind": model.kind,
"display_name": model.display_name,
"description": model.description,
"provider": model.provider,
"model_id": model.model_id,
"language": model.language,
"voice_id": model.voice_id,
"tier": model.tier,
"reference_cost_per_minute": float(model.reference_cost_per_minute)
if model.reference_cost_per_minute is not None
else None,
"reference_cost_per_1k_chars": float(model.reference_cost_per_1k_chars)
if model.reference_cost_per_1k_chars is not None
else None,
"is_default": bool(model.is_default),
"is_active": bool(model.is_active),
"is_cloud": provider_is_cloud(model.provider),
"sort_order": model.sort_order,
"extra": extra,
"created_at": model.created_at.isoformat() if model.created_at else None,
"updated_at": model.updated_at.isoformat() if model.updated_at else None,
}
def serialize_policy(policy: AIVoicePolicy) -> Dict[str, Any]:
return {
"allow_cloud_audio": bool(policy.allow_cloud_audio),
"default_stt_code": policy.default_stt_code,
"default_tts_code": policy.default_tts_code,
"updated_at": policy.updated_at.isoformat() if policy.updated_at else None,
}
def serialize_business_voice_settings(row: BusinessAIVoiceSettings) -> Dict[str, Any]:
return {
"business_id": row.business_id,
"allow_cloud_audio": bool(row.allow_cloud_audio),
"preferred_stt_code": row.preferred_stt_code,
"preferred_tts_code": row.preferred_tts_code,
"updated_at": row.updated_at.isoformat() if row.updated_at else None,
}
def _parse_extra(raw: str | None) -> Dict[str, Any]:
if not raw:
return {}
try:
data = json.loads(raw)
except Exception:
return {}
return data if isinstance(data, dict) else {}
def cloud_audio_allowed(db: Session, business_id: Optional[int]) -> bool:
policy = AIVoicePolicyRepository(db).get_or_create()
if not policy.allow_cloud_audio:
return False
if not business_id:
return False
biz = BusinessAIVoiceSettingsRepository(db).get_by_business(int(business_id))
return bool(biz and biz.allow_cloud_audio)
def list_voice_models_for_user(
db: Session,
*,
business_id: Optional[int],
kind: Optional[str] = None,
) -> Dict[str, Any]:
repo = AIVoiceModelRepository(db)
policy = AIVoicePolicyRepository(db).get_or_create()
allow_cloud = cloud_audio_allowed(db, business_id)
rows = repo.get_active(kind=kind) if kind else repo.get_active()
stt: List[Dict[str, Any]] = []
tts: List[Dict[str, Any]] = []
for row in rows:
if provider_is_cloud(row.provider) and not allow_cloud:
continue
item = serialize_voice_model(row)
if row.kind == VOICE_KIND_STT:
stt.append(item)
elif row.kind == VOICE_KIND_TTS:
tts.append(item)
if not stt or not tts:
env_stt, env_tts = env_fallback_catalog_items()
if not stt:
stt = [env_stt]
if not tts:
tts = [env_tts]
biz = (
BusinessAIVoiceSettingsRepository(db).get_by_business(int(business_id))
if business_id
else None
)
default_stt = _pick_default_code(stt, biz.preferred_stt_code if biz else None, policy.default_stt_code)
default_tts = _pick_default_code(tts, biz.preferred_tts_code if biz else None, policy.default_tts_code)
return {
"stt": stt,
"tts": tts,
"default_stt_code": default_stt,
"default_tts_code": default_tts,
"allow_cloud_audio": allow_cloud,
"policy_allow_cloud_audio": bool(policy.allow_cloud_audio),
}
def _pick_default_code(
items: List[Dict[str, Any]],
preferred: Optional[str],
policy_default: Optional[str],
) -> Optional[str]:
codes = {str(i.get("code")) for i in items}
for candidate in (preferred, policy_default):
if candidate and candidate in codes:
return candidate
for item in items:
if item.get("is_default"):
return str(item["code"])
return str(items[0]["code"]) if items else None
def env_fallback_catalog_items() -> tuple[Dict[str, Any], Dict[str, Any]]:
settings = get_settings()
stt = {
"id": None,
"code": "stt-env-whisper",
"kind": VOICE_KIND_STT,
"display_name": "Whisper محلی (env)",
"description": "مدل Whisper از تنظیمات سرور",
"provider": "local",
"model_id": settings.voice_stt_model_size_or_path,
"language": settings.voice_stt_language,
"voice_id": None,
"tier": "basic",
"is_default": True,
"is_active": True,
"is_cloud": False,
"sort_order": 0,
"from_env": True,
}
engine = (settings.voice_tts_engine or "dummy").strip().lower()
tts = {
"id": None,
"code": "tts-env-default",
"kind": VOICE_KIND_TTS,
"display_name": f"TTS {engine} (env)",
"description": "موتور TTS از تنظیمات سرور",
"provider": "local" if engine != "dummy" else "dummy",
"model_id": settings.voice_tts_model_name or settings.voice_tts_piper_voice_fa or engine,
"language": settings.voice_tts_language,
"voice_id": settings.voice_tts_piper_voice_fa,
"tier": "basic",
"is_default": True,
"is_active": True,
"is_cloud": False,
"dummy": engine == "dummy",
"sort_order": 0,
"from_env": True,
}
return stt, tts
def seed_voice_models_from_env(db: Session, *, force: bool = False) -> Dict[str, Any]:
repo = AIVoiceModelRepository(db)
existing = db.query(AIVoiceModel).count()
settings = get_settings()
_ = force
created = 0
presets: List[Dict[str, Any]] = [
{
"code": "stt-local-whisper-small",
"kind": VOICE_KIND_STT,
"display_name": "Whisper محلی",
"description": "تبدیل گفتار به متن روی سرور خودتان (faster-whisper)",
"provider": "local",
"model_id": settings.voice_stt_model_size_or_path or "small",
"language": settings.voice_stt_language or "fa",
"tier": "basic",
"is_default": True,
"sort_order": 10,
"extra_json": json.dumps(
{
"device": settings.voice_stt_device,
"compute_type": settings.voice_stt_compute_type,
},
ensure_ascii=False,
),
},
{
"code": "stt-parspack-whisper-1",
"kind": VOICE_KIND_STT,
"display_name": "ParsPack Whisper",
"description": "گفتار به متن از درگاه پارس‌پک (openai/whisper-1). کلید در اعتبارنامه Custom ذخیره می‌شود.",
"provider": "custom",
"model_id": "openai/whisper-1",
"language": "fa",
"tier": "pro",
"sort_order": 15,
"extra_json": json.dumps(
{
"api_base_url": "https://ai.parspack.com/v1",
"credential_provider": "custom",
"audio_endpoint": "translations",
},
ensure_ascii=False,
),
},
{
"code": "stt-openai-whisper-1",
"kind": VOICE_KIND_STT,
"display_name": "OpenAI Whisper",
"description": "transcription ابری؛ نیاز به اجازهٔ ارسال صوت به ابر",
"provider": "openai",
"model_id": "whisper-1",
"language": "fa",
"tier": "pro",
"sort_order": 20,
},
{
"code": "stt-openai-gpt-4o-mini-transcribe",
"kind": VOICE_KIND_STT,
"display_name": "OpenAI GPT-4o Mini Transcribe",
"provider": "openai",
"model_id": "gpt-4o-mini-transcribe",
"language": "fa",
"tier": "pro",
"sort_order": 30,
},
{
"code": "tts-local-piper-ganji",
"kind": VOICE_KIND_TTS,
"display_name": "Piper فارسی (محلی)",
"description": "متن به گفتار ONNX روی سرور",
"provider": "local",
"model_id": settings.voice_tts_piper_voice_fa or "fa_IR-ganji-medium",
"voice_id": settings.voice_tts_piper_voice_fa or "fa_IR-ganji-medium",
"language": "fa",
"tier": "basic",
"is_default": True,
"sort_order": 10,
},
{
"code": "tts-parspack-gpt-4o-mini-tts",
"kind": VOICE_KIND_TTS,
"display_name": "ParsPack TTS",
"description": "متن به گفتار از درگاه پارس‌پک (openai/gpt-4o-mini-tts). همان کلید Custom که برای Whisper استفاده می‌شود.",
"provider": "custom",
"model_id": "openai/gpt-4o-mini-tts",
"voice_id": "alloy",
"language": "fa",
"tier": "pro",
"sort_order": 15,
"extra_json": json.dumps(
{
"api_base_url": "https://ai.parspack.com/v1",
"credential_provider": "custom",
"response_format": "wav",
},
ensure_ascii=False,
),
},
{
"code": "tts-dummy",
"kind": VOICE_KIND_TTS,
"display_name": "Dummy (سکوت / آزمایش)",
"description": "فقط برای تست؛ در تولید فعال نکنید",
"provider": "dummy",
"model_id": "dummy",
"language": "fa",
"tier": "basic",
"is_active": (settings.voice_tts_engine or "").strip().lower() == "dummy",
"is_default": False,
"sort_order": 90,
},
{
"code": "tts-openai-gpt-4o-mini-tts",
"kind": VOICE_KIND_TTS,
"display_name": "OpenAI TTS",
"provider": "openai",
"model_id": "gpt-4o-mini-tts",
"voice_id": "alloy",
"language": "fa",
"tier": "pro",
"sort_order": 20,
},
]
for fields in presets:
if repo.get_by_code(fields["code"]):
continue
db.add(
AIVoiceModel(
code=fields["code"],
kind=fields["kind"],
display_name=fields["display_name"],
description=fields.get("description"),
provider=fields["provider"],
model_id=fields["model_id"],
language=fields.get("language") or "fa",
voice_id=fields.get("voice_id"),
tier=fields.get("tier"),
is_default=bool(fields.get("is_default", False)),
is_active=bool(fields.get("is_active", True)),
sort_order=int(fields.get("sort_order") or 0),
extra_json=fields.get("extra_json"),
)
)
created += 1
policy = AIVoicePolicyRepository(db).get_or_create()
if not policy.default_stt_code:
policy.default_stt_code = "stt-local-whisper-small"
if not policy.default_tts_code:
engine = (settings.voice_tts_engine or "dummy").strip().lower()
policy.default_tts_code = "tts-dummy" if engine == "dummy" else "tts-local-piper-ganji"
db.commit()
return {"created": created, "skipped": False, "existing_count": existing}
def validate_kind(kind: str) -> str:
k = (kind or "").strip().lower()
if k not in VOICE_KINDS:
raise ApiError("INVALID_VOICE_KIND", "نوع مدل صوت باید stt یا tts باشد", http_status=400)
return k
def validate_code(code: str) -> str:
c = (code or "").strip().lower()
if not c or len(c) > _CODE_MAX:
raise ApiError("CODE_REQUIRED", "کد مدل صوت الزامی است", http_status=400)
return c
def apply_voice_model_payload(model: AIVoiceModel, payload: Dict[str, Any], *, creating: bool) -> None:
if creating:
model.code = validate_code(str(payload.get("code") or ""))
model.kind = validate_kind(str(payload.get("kind") or ""))
elif "kind" in payload:
model.kind = validate_kind(str(payload.get("kind") or model.kind))
if "display_name" in payload or creating:
model.display_name = str(payload.get("display_name") or model.code)
if "description" in payload or creating:
model.description = payload.get("description")
if "provider" in payload or creating:
model.provider = str(payload.get("provider") or "local").strip().lower()
if "model_id" in payload or creating:
model.model_id = str(payload.get("model_id") or model.code)
if "language" in payload or creating:
model.language = str(payload.get("language") or "fa")[:16]
if "voice_id" in payload or creating:
raw = payload.get("voice_id")
model.voice_id = str(raw).strip() if raw else None
if "tier" in payload or creating:
model.tier = payload.get("tier")
if "reference_cost_per_minute" in payload:
model.reference_cost_per_minute = payload.get("reference_cost_per_minute")
if "reference_cost_per_1k_chars" in payload:
model.reference_cost_per_1k_chars = payload.get("reference_cost_per_1k_chars")
if "is_default" in payload or creating:
model.is_default = bool(payload.get("is_default", False))
if "is_active" in payload or creating:
model.is_active = bool(payload.get("is_active", True))
if "sort_order" in payload or creating:
model.sort_order = int(payload.get("sort_order") or 0)
extra_in = payload.get("extra") if "extra" in payload else None
if extra_in is None and any(
k in payload for k in ("api_base_url", "audio_endpoint", "response_format")
):
extra_in = _parse_extra(model.extra_json)
if isinstance(extra_in, dict):
if payload.get("api_base_url"):
extra_in["api_base_url"] = str(payload.get("api_base_url")).strip()
if payload.get("audio_endpoint"):
extra_in["audio_endpoint"] = str(payload.get("audio_endpoint")).strip().lower()
if payload.get("response_format"):
extra_in["response_format"] = str(payload.get("response_format")).strip().lower()
if model.provider in ("custom", "openai", "groq"):
extra_in.setdefault("credential_provider", model.provider)
model.extra_json = json.dumps(extra_in, ensure_ascii=False)
elif "extra" in payload:
model.extra_json = None
model.updated_at = datetime.utcnow()
def persist_voice_gateway_credential(db: Session, payload: Dict[str, Any], model: AIVoiceModel) -> None:
"""ذخیره کلید/آدرس درگاه همراه مدل صوت — بدون گذاشتن راز داخل خود ردیف کاتالوگ."""
api_key = str(payload.get("api_key") or "").strip()
api_base = str(payload.get("api_base_url") or "").strip() or None
if not api_key and api_base is None:
return
from app.services.ai.ai_provider_service import create_or_update_credential
extra = _parse_extra(model.extra_json)
provider = str(extra.get("credential_provider") or model.provider or "custom").strip().lower()
if provider in ("local", "dummy", "piper", "whisper"):
provider = "custom"
create_or_update_credential(
db,
provider,
display_name="ParsPack / Custom Gateway" if provider == "custom" else None,
api_base_url=api_base if api_base is not None else extra.get("api_base_url"),
api_key=api_key or None,
is_active=True,
)
def clear_other_defaults(db: Session, kind: str, keep_id: Optional[int]) -> None:
q = db.query(AIVoiceModel).filter(AIVoiceModel.kind == kind, AIVoiceModel.is_default.is_(True))
if keep_id is not None:
q = q.filter(AIVoiceModel.id != keep_id)
for row in q.all():
row.is_default = False