137 lines
5.2 KiB
Python
137 lines
5.2 KiB
Python
import uuid
|
||
from functools import partial
|
||
|
||
from fastapi import APIRouter, Depends, HTTPException
|
||
from pydantic import BaseModel
|
||
from sqlalchemy.ext.asyncio import AsyncSession
|
||
|
||
from ..auth import verify_token
|
||
from ..database import get_db, AsyncSessionLocal
|
||
from ..models import Job
|
||
from ..storage import upload_audio
|
||
from ..services import llm, tts, job_repo
|
||
from ..services.tts import VOICE_BY_LANGUAGE
|
||
from .. import worker
|
||
|
||
router = APIRouter(prefix="/generate", tags=["generation"])
|
||
|
||
SUPPORTED_LANGUAGES: dict[str, str] = {
|
||
"en": "English",
|
||
"fr": "French",
|
||
"es": "Spanish",
|
||
"it": "Italian",
|
||
"de": "German",
|
||
}
|
||
SUPPORTED_LEVELS = {"A1", "A2", "B1", "B2", "C1", "C2"}
|
||
|
||
|
||
class GenerationRequest(BaseModel):
|
||
target_language: str
|
||
complexity_level: str
|
||
input_texts: list[str]
|
||
topic: str | None = None
|
||
source_language: str = "en"
|
||
|
||
|
||
class GenerationResponse(BaseModel):
|
||
job_id: str
|
||
|
||
|
||
async def _run_generation(job_id: uuid.UUID, request: GenerationRequest) -> None:
|
||
async with AsyncSessionLocal() as db:
|
||
job = await db.get(Job, job_id)
|
||
await job_repo.mark_processing(db, job)
|
||
|
||
try:
|
||
from_language = SUPPORTED_LANGUAGES[request.source_language]
|
||
language_name = SUPPORTED_LANGUAGES[request.target_language]
|
||
|
||
topic_part = f"Topic: {request.topic}. " if request.topic else ""
|
||
combined_preview = " ".join(request.input_texts)[:300]
|
||
input_summary = (
|
||
f"{topic_part}Based on {len(request.input_texts)} input text(s): "
|
||
f"{combined_preview}..."
|
||
)
|
||
|
||
source_material = "\n\n".join(request.input_texts[:3])
|
||
topic_line = f"\nTopic focus: {request.topic}" if request.topic else ""
|
||
|
||
prompt = (
|
||
f"You are a language learning content creator. "
|
||
f"Using the input provided, you generate engaging realistic text in {language_name} "
|
||
f"at {request.complexity_level} proficiency level (CEFR scale).\n\n"
|
||
f"The text should:\n"
|
||
f"- Be appropriate for a {request.complexity_level} learner\n"
|
||
f"- Maintain a similar tone to the input text. Where appropriate, use idioms\n"
|
||
f"- Feel natural and authentic, like content a native speaker would read\n"
|
||
f"- Be formatted in markdown with paragraphs and line breaks\n"
|
||
f"- Be 200–400 words long\n"
|
||
f"- Be inspired by the following source material "
|
||
f"(but written originally in {language_name}):\n\n"
|
||
f"{source_material}"
|
||
f"{topic_line}\n\n"
|
||
f"Respond with ONLY the generated text in {language_name}, "
|
||
f"no explanations or translations.\n"
|
||
f"The 'Topic focus' should be a comma-separated list of up to three topics, in {language_name}."
|
||
)
|
||
|
||
generated_text = await llm.generate_text(prompt)
|
||
|
||
translate_prompt = (
|
||
f"You are a helpful assistant that translates text. Translate just the previous summary "
|
||
f"content in {language_name} text you generated based on the input I gave you. Translate "
|
||
f"it back into {from_language}.\n"
|
||
f"- Keep the translation as close as possible to the original meaning and tone\n"
|
||
f"- Send through only the translated text, no explanations or notes\n"
|
||
)
|
||
|
||
translated_text = await llm.translate_text(prompt, generated_text, translate_prompt)
|
||
|
||
# Save LLM results before attempting TTS so they're preserved on failure
|
||
await job_repo.save_llm_results(
|
||
db, job, generated_text, translated_text, input_summary[:500]
|
||
)
|
||
|
||
voice = VOICE_BY_LANGUAGE.get(request.target_language, "Kore")
|
||
wav_bytes = await tts.generate_audio(generated_text, voice)
|
||
audio_key = f"audio/{job_id}.wav"
|
||
upload_audio(audio_key, wav_bytes)
|
||
|
||
await job_repo.mark_succeeded(db, job, audio_key)
|
||
|
||
except Exception as exc:
|
||
await job_repo.mark_failed(db, job, str(exc))
|
||
|
||
|
||
@router.post("", response_model=GenerationResponse, status_code=202)
|
||
async def create_generation_job(
|
||
request: GenerationRequest,
|
||
db: AsyncSession = Depends(get_db),
|
||
token_data: dict = Depends(verify_token),
|
||
) -> GenerationResponse:
|
||
if request.target_language not in SUPPORTED_LANGUAGES:
|
||
raise HTTPException(
|
||
status_code=400,
|
||
detail=f"Unsupported language '{request.target_language}'. "
|
||
f"Supported: {list(SUPPORTED_LANGUAGES)}",
|
||
)
|
||
if request.complexity_level not in SUPPORTED_LEVELS:
|
||
raise HTTPException(
|
||
status_code=400,
|
||
detail=f"Unsupported level '{request.complexity_level}'. "
|
||
f"Supported: {sorted(SUPPORTED_LEVELS)}",
|
||
)
|
||
|
||
job = Job(
|
||
user_id=uuid.UUID(token_data["sub"]),
|
||
source_language=request.source_language,
|
||
target_language=request.target_language,
|
||
complexity_level=request.complexity_level,
|
||
)
|
||
db.add(job)
|
||
await db.commit()
|
||
await db.refresh(job)
|
||
|
||
await worker.enqueue(partial(_run_generation, job.id, request))
|
||
|
||
return GenerationResponse(job_id=str(job.id))
|