572 lines
20 KiB
Python
572 lines
20 KiB
Python
from pathlib import Path
|
||
import secrets
|
||
from urllib.parse import urlparse
|
||
from uuid import uuid4
|
||
|
||
from fastapi import Depends, FastAPI, File, Form, HTTPException, UploadFile
|
||
from fastapi.responses import FileResponse
|
||
from fastapi.security import HTTPBasic, HTTPBasicCredentials
|
||
from fastapi.staticfiles import StaticFiles
|
||
|
||
from .ai_config import get_ai_status, get_config_value, load_local_whisper_config, load_text_ai_config
|
||
from .db import (
|
||
DATABASE_PATH,
|
||
create_video,
|
||
delete_video,
|
||
initialize_database,
|
||
list_videos,
|
||
parse_tags,
|
||
table_names,
|
||
get_video,
|
||
update_video,
|
||
upsert_video_subtitle,
|
||
)
|
||
from .deepseek_client import DeepSeekClient, DeepSeekError
|
||
from .local_whisper import LocalWhisperError, transcribe_video_to_vtt
|
||
from .subtitle_ai import process_subtitles_with_ai
|
||
|
||
|
||
PROJECT_DIR = Path(__file__).resolve().parent.parent
|
||
UPLOADS_DIR = PROJECT_DIR / "uploads"
|
||
VIDEO_EXTENSIONS = {".mp4", ".webm", ".mov", ".m4v"}
|
||
SUBTITLE_EXTENSIONS = {".srt", ".vtt"}
|
||
IMAGE_EXTENSIONS = {".jpg", ".jpeg", ".png", ".webp", ".gif"}
|
||
UPLOAD_CHUNK_SIZE = 1024 * 1024
|
||
|
||
|
||
def ensure_upload_directories() -> None:
|
||
UPLOADS_DIR.mkdir(parents=True, exist_ok=True)
|
||
(UPLOADS_DIR / "videos").mkdir(parents=True, exist_ok=True)
|
||
(UPLOADS_DIR / "images").mkdir(parents=True, exist_ok=True)
|
||
(UPLOADS_DIR / "subtitles").mkdir(parents=True, exist_ok=True)
|
||
|
||
|
||
def extension_for_upload(upload: UploadFile) -> str:
|
||
return Path(upload.filename or "").suffix.lower()
|
||
|
||
|
||
def safe_upload_name(upload: UploadFile) -> str:
|
||
extension = extension_for_upload(upload)
|
||
return f"{uuid4().hex}{extension}"
|
||
|
||
|
||
async def save_upload(upload: UploadFile, target_dir: Path) -> tuple[str, str]:
|
||
target_dir.mkdir(parents=True, exist_ok=True)
|
||
filename = safe_upload_name(upload)
|
||
target_path = target_dir / filename
|
||
content = await upload.read()
|
||
try:
|
||
target_path.write_bytes(content)
|
||
except OSError as exc:
|
||
target_path.unlink(missing_ok=True)
|
||
raise HTTPException(status_code=500, detail="保存文件失败,请重试") from exc
|
||
return filename, content.decode("utf-8-sig", errors="replace")
|
||
|
||
|
||
async def save_binary_upload(upload: UploadFile, target_dir: Path) -> str:
|
||
target_dir.mkdir(parents=True, exist_ok=True)
|
||
filename = safe_upload_name(upload)
|
||
target_path = target_dir / filename
|
||
try:
|
||
with target_path.open("wb") as target_file:
|
||
while chunk := await upload.read(UPLOAD_CHUNK_SIZE):
|
||
target_file.write(chunk)
|
||
except OSError as exc:
|
||
target_path.unlink(missing_ok=True)
|
||
raise HTTPException(status_code=500, detail="保存文件失败,请重试") from exc
|
||
return filename
|
||
|
||
|
||
def cleanup_saved_files(paths: list[Path]) -> None:
|
||
for path in paths:
|
||
try:
|
||
path.unlink(missing_ok=True)
|
||
except OSError:
|
||
pass
|
||
|
||
|
||
def upload_url_to_path(value: str) -> Path | None:
|
||
if not value.startswith("/uploads/"):
|
||
return None
|
||
|
||
relative_parts = value.removeprefix("/uploads/").split("/")
|
||
if any(part in {"", ".", ".."} for part in relative_parts):
|
||
return None
|
||
|
||
candidate = (UPLOADS_DIR / Path(*relative_parts)).resolve()
|
||
uploads_root = UPLOADS_DIR.resolve()
|
||
|
||
try:
|
||
candidate.relative_to(uploads_root)
|
||
except ValueError:
|
||
return None
|
||
|
||
return candidate
|
||
|
||
|
||
def is_supported_video_url(value: str) -> bool:
|
||
parsed = urlparse(value)
|
||
return parsed.scheme in {"http", "https"} and bool(parsed.netloc)
|
||
|
||
|
||
def cleanup_upload_urls(upload_urls: list[str]) -> list[str]:
|
||
warnings: list[str] = []
|
||
for upload_url in upload_urls:
|
||
path = upload_url_to_path(str(upload_url))
|
||
if path is None:
|
||
continue
|
||
try:
|
||
path.unlink(missing_ok=True)
|
||
except OSError:
|
||
warnings.append(f"无法删除文件: {path}")
|
||
return warnings
|
||
|
||
|
||
def save_generated_subtitle_file(content: str, language_code: str) -> str:
|
||
subtitles_dir = UPLOADS_DIR / "subtitles"
|
||
subtitles_dir.mkdir(parents=True, exist_ok=True)
|
||
filename = f"{uuid4().hex}.ai.{language_code}.vtt"
|
||
(subtitles_dir / filename).write_text(content, encoding="utf-8")
|
||
return f"/uploads/subtitles/{filename}"
|
||
|
||
|
||
ensure_upload_directories()
|
||
|
||
app = FastAPI(title="Speaking Lab API")
|
||
admin_security = HTTPBasic(auto_error=False)
|
||
|
||
|
||
@app.on_event("startup")
|
||
def on_startup() -> None:
|
||
initialize_database()
|
||
ensure_upload_directories()
|
||
|
||
|
||
app.mount("/uploads", StaticFiles(directory=UPLOADS_DIR), name="uploads")
|
||
|
||
|
||
@app.get("/api/health")
|
||
def health_check() -> dict[str, object]:
|
||
return {
|
||
"ok": True,
|
||
"database": str(DATABASE_PATH),
|
||
"tables": table_names(),
|
||
}
|
||
|
||
|
||
@app.get("/api/videos")
|
||
def api_list_videos() -> list[dict[str, object]]:
|
||
return list_videos()
|
||
|
||
|
||
@app.get("/api/videos/{video_id}")
|
||
def api_get_video(video_id: int) -> dict[str, object]:
|
||
video = get_video(video_id)
|
||
if video is None:
|
||
raise HTTPException(status_code=404, detail="视频不存在")
|
||
return video
|
||
|
||
|
||
def require_admin(credentials: HTTPBasicCredentials | None = Depends(admin_security)) -> dict[str, str]:
|
||
admin_username = get_config_value("ADMIN_USERNAME")
|
||
admin_password = get_config_value("ADMIN_PASSWORD")
|
||
|
||
if not admin_username or not admin_password:
|
||
raise HTTPException(
|
||
status_code=503,
|
||
detail="未配置 ADMIN_USERNAME / ADMIN_PASSWORD,请先在 .env 中填写管理员账号密码。",
|
||
)
|
||
|
||
if credentials is None:
|
||
raise HTTPException(
|
||
status_code=401,
|
||
detail="需要管理员账号密码。",
|
||
)
|
||
|
||
username_ok = secrets.compare_digest(credentials.username, admin_username)
|
||
password_ok = secrets.compare_digest(credentials.password, admin_password)
|
||
if not username_ok or not password_ok:
|
||
raise HTTPException(
|
||
status_code=401,
|
||
detail="管理员账号或密码错误。",
|
||
)
|
||
|
||
return {"username": admin_username}
|
||
|
||
|
||
@app.get("/api/admin/session")
|
||
def api_admin_session(admin: dict[str, str] = Depends(require_admin)) -> dict[str, object]:
|
||
return {"ok": True, "username": admin["username"]}
|
||
|
||
|
||
@app.post("/api/videos")
|
||
async def api_create_video(
|
||
admin: dict[str, str] = Depends(require_admin),
|
||
title: str = Form(...),
|
||
speaker: str = Form(""),
|
||
description: str = Form(""),
|
||
tags: str = Form(""),
|
||
video_url: str = Form(""),
|
||
video_file: UploadFile | None = File(None),
|
||
cover_file: UploadFile | None = File(None),
|
||
subtitle_en: UploadFile | None = File(None),
|
||
subtitle_zh: UploadFile | None = File(None),
|
||
) -> dict[str, object]:
|
||
clean_title = title.strip()
|
||
if not clean_title:
|
||
raise HTTPException(status_code=400, detail="标题不能为空")
|
||
|
||
clean_video_url = video_url.strip()
|
||
if video_file is None and not clean_video_url:
|
||
raise HTTPException(status_code=400, detail="请上传视频文件或填写视频地址")
|
||
|
||
if video_file is None and not is_supported_video_url(clean_video_url):
|
||
raise HTTPException(status_code=400, detail="视频地址必须以 http:// 或 https:// 开头")
|
||
|
||
if video_file is not None:
|
||
if extension_for_upload(video_file) not in VIDEO_EXTENSIONS:
|
||
raise HTTPException(status_code=400, detail="视频文件格式不支持")
|
||
|
||
if cover_file is not None and extension_for_upload(cover_file) not in IMAGE_EXTENSIONS:
|
||
raise HTTPException(status_code=400, detail="封面图片格式不支持")
|
||
|
||
subtitle_uploads: list[tuple[UploadFile, str, str, str]] = []
|
||
for upload, language_code, language_name in (
|
||
(subtitle_en, "en", "English"),
|
||
(subtitle_zh, "zh", "中文"),
|
||
):
|
||
if upload is None:
|
||
continue
|
||
extension = extension_for_upload(upload)
|
||
if extension not in SUBTITLE_EXTENSIONS:
|
||
raise HTTPException(status_code=400, detail="字幕只支持 .srt 或 .vtt")
|
||
subtitle_uploads.append((upload, language_code, language_name, extension))
|
||
|
||
saved_paths: list[Path] = []
|
||
try:
|
||
final_video_url = clean_video_url
|
||
if video_file is not None:
|
||
video_filename = await save_binary_upload(video_file, UPLOADS_DIR / "videos")
|
||
saved_paths.append(UPLOADS_DIR / "videos" / video_filename)
|
||
final_video_url = f"/uploads/videos/{video_filename}"
|
||
|
||
final_cover_url = ""
|
||
if cover_file is not None:
|
||
cover_filename = await save_binary_upload(cover_file, UPLOADS_DIR / "images")
|
||
saved_paths.append(UPLOADS_DIR / "images" / cover_filename)
|
||
final_cover_url = f"/uploads/images/{cover_filename}"
|
||
|
||
subtitles: list[dict[str, str]] = []
|
||
for upload, language_code, language_name, extension in subtitle_uploads:
|
||
subtitle_filename, subtitle_text = await save_upload(upload, UPLOADS_DIR / "subtitles")
|
||
saved_paths.append(UPLOADS_DIR / "subtitles" / subtitle_filename)
|
||
subtitles.append(
|
||
{
|
||
"language_code": language_code,
|
||
"language_name": language_name,
|
||
"format": extension.removeprefix("."),
|
||
"file_path": f"/uploads/subtitles/{subtitle_filename}",
|
||
"content": subtitle_text,
|
||
}
|
||
)
|
||
|
||
return create_video(
|
||
title=clean_title,
|
||
speaker=speaker.strip(),
|
||
description=description.strip(),
|
||
tags=parse_tags(tags),
|
||
video_url=final_video_url,
|
||
cover_url=final_cover_url,
|
||
subtitles=subtitles,
|
||
)
|
||
except Exception:
|
||
cleanup_saved_files(saved_paths)
|
||
raise
|
||
|
||
|
||
@app.patch("/api/videos/{video_id}")
|
||
async def api_update_video(
|
||
video_id: int,
|
||
admin: dict[str, str] = Depends(require_admin),
|
||
title: str = Form(...),
|
||
speaker: str = Form(""),
|
||
description: str = Form(""),
|
||
tags: str = Form(""),
|
||
video_url: str = Form(""),
|
||
subtitle_en_content: str | None = Form(None),
|
||
subtitle_zh_content: str | None = Form(None),
|
||
video_file: UploadFile | None = File(None),
|
||
cover_file: UploadFile | None = File(None),
|
||
subtitle_en: UploadFile | None = File(None),
|
||
subtitle_zh: UploadFile | None = File(None),
|
||
) -> dict[str, object]:
|
||
existing = get_video(video_id)
|
||
if existing is None:
|
||
raise HTTPException(status_code=404, detail="视频不存在")
|
||
|
||
clean_title = title.strip()
|
||
if not clean_title:
|
||
raise HTTPException(status_code=400, detail="标题不能为空")
|
||
|
||
clean_video_url = video_url.strip()
|
||
final_video_url: str | None = None
|
||
if video_file is None and clean_video_url:
|
||
if not is_supported_video_url(clean_video_url) and not clean_video_url.startswith("/uploads/"):
|
||
raise HTTPException(status_code=400, detail="视频地址必须以 http:// 或 https:// 开头")
|
||
final_video_url = clean_video_url
|
||
|
||
if video_file is not None and extension_for_upload(video_file) not in VIDEO_EXTENSIONS:
|
||
raise HTTPException(status_code=400, detail="视频文件格式不支持")
|
||
|
||
if cover_file is not None and extension_for_upload(cover_file) not in IMAGE_EXTENSIONS:
|
||
raise HTTPException(status_code=400, detail="封面图片格式不支持")
|
||
|
||
subtitle_uploads: list[tuple[UploadFile, str, str, str]] = []
|
||
for upload, language_code, language_name in (
|
||
(subtitle_en, "en", "English"),
|
||
(subtitle_zh, "zh", "中文"),
|
||
):
|
||
if upload is None:
|
||
continue
|
||
extension = extension_for_upload(upload)
|
||
if extension not in SUBTITLE_EXTENSIONS:
|
||
raise HTTPException(status_code=400, detail="字幕只支持 .srt 或 .vtt")
|
||
subtitle_uploads.append((upload, language_code, language_name, extension))
|
||
|
||
saved_paths: list[Path] = []
|
||
try:
|
||
if video_file is not None:
|
||
video_filename = await save_binary_upload(video_file, UPLOADS_DIR / "videos")
|
||
saved_paths.append(UPLOADS_DIR / "videos" / video_filename)
|
||
final_video_url = f"/uploads/videos/{video_filename}"
|
||
|
||
final_cover_url: str | None = None
|
||
if cover_file is not None:
|
||
cover_filename = await save_binary_upload(cover_file, UPLOADS_DIR / "images")
|
||
saved_paths.append(UPLOADS_DIR / "images" / cover_filename)
|
||
final_cover_url = f"/uploads/images/{cover_filename}"
|
||
|
||
subtitles: list[dict[str, str]] = []
|
||
for upload, language_code, language_name, extension in subtitle_uploads:
|
||
subtitle_filename, subtitle_text = await save_upload(upload, UPLOADS_DIR / "subtitles")
|
||
saved_paths.append(UPLOADS_DIR / "subtitles" / subtitle_filename)
|
||
subtitles.append(
|
||
{
|
||
"language_code": language_code,
|
||
"language_name": language_name,
|
||
"format": extension.removeprefix("."),
|
||
"file_path": f"/uploads/subtitles/{subtitle_filename}",
|
||
"content": subtitle_text,
|
||
}
|
||
)
|
||
|
||
uploaded_language_codes = {language_code for _, language_code, _, _ in subtitle_uploads}
|
||
existing_subtitles = existing.get("subtitles", {})
|
||
for language_code, language_name, content in (
|
||
("en", "English", subtitle_en_content),
|
||
("zh", "中文", subtitle_zh_content),
|
||
):
|
||
if content is None or language_code in uploaded_language_codes:
|
||
continue
|
||
existing_subtitle = existing_subtitles.get(language_code, {})
|
||
subtitles.append(
|
||
{
|
||
"language_code": language_code,
|
||
"language_name": existing_subtitle.get("languageName") or language_name,
|
||
"format": existing_subtitle.get("format") or "vtt",
|
||
"file_path": existing_subtitle.get("filePath") or "",
|
||
"content": content,
|
||
}
|
||
)
|
||
|
||
updated = update_video(
|
||
video_id,
|
||
title=clean_title,
|
||
speaker=speaker.strip(),
|
||
description=description.strip(),
|
||
tags=parse_tags(tags),
|
||
video_url=final_video_url,
|
||
cover_url=final_cover_url,
|
||
subtitles=subtitles,
|
||
)
|
||
if updated is None:
|
||
cleanup_saved_files(saved_paths)
|
||
raise HTTPException(status_code=404, detail="视频不存在")
|
||
|
||
warnings = cleanup_upload_urls([str(path) for path in updated["oldUploadPaths"]])
|
||
return {
|
||
"ok": True,
|
||
"video": updated["video"],
|
||
"warnings": warnings,
|
||
}
|
||
except HTTPException:
|
||
cleanup_saved_files(saved_paths)
|
||
raise
|
||
except Exception:
|
||
cleanup_saved_files(saved_paths)
|
||
raise
|
||
|
||
|
||
@app.delete("/api/videos/{video_id}")
|
||
def api_delete_video(video_id: int, admin: dict[str, str] = Depends(require_admin)) -> dict[str, object]:
|
||
deleted = delete_video(video_id)
|
||
if deleted is None:
|
||
raise HTTPException(status_code=404, detail="视频不存在")
|
||
|
||
warnings = cleanup_upload_urls([str(path) for path in deleted["uploadPaths"]])
|
||
|
||
return {
|
||
"ok": True,
|
||
"deletedVideoId": deleted["deletedVideoId"],
|
||
"warnings": warnings,
|
||
}
|
||
|
||
|
||
@app.get("/api/ai/status")
|
||
def api_ai_status() -> dict[str, object]:
|
||
return get_ai_status()
|
||
|
||
|
||
@app.post("/api/ai/test")
|
||
def api_ai_test(admin: dict[str, str] = Depends(require_admin)) -> dict[str, object]:
|
||
status = get_ai_status()
|
||
if not status["configured"]:
|
||
raise HTTPException(status_code=400, detail=status["message"])
|
||
|
||
try:
|
||
text_ai_config = load_text_ai_config()
|
||
client = DeepSeekClient(text_ai_config, timeout_seconds=text_ai_config.timeout_seconds)
|
||
client.chat_json(
|
||
"请只返回 JSON:{\"ok\":true}",
|
||
{"task": "ping", "expected": {"ok": True}},
|
||
)
|
||
except DeepSeekError as error:
|
||
raise HTTPException(status_code=400, detail=str(error)) from error
|
||
|
||
return {"ok": True, "message": "AI API 连接正常。"}
|
||
|
||
|
||
@app.post("/api/videos/{video_id}/ai/subtitles")
|
||
def api_process_video_subtitles(video_id: int, admin: dict[str, str] = Depends(require_admin)) -> dict[str, object]:
|
||
status = get_ai_status()
|
||
if not status["configured"]:
|
||
raise HTTPException(status_code=400, detail=status["message"])
|
||
|
||
video = get_video(video_id)
|
||
if video is None:
|
||
raise HTTPException(status_code=404, detail="视频不存在")
|
||
|
||
subtitles = video.get("subtitles", {})
|
||
if not isinstance(subtitles, dict):
|
||
raise HTTPException(status_code=400, detail="字幕数据异常。")
|
||
|
||
english_subtitle = subtitles.get("en", {})
|
||
if not isinstance(english_subtitle, dict) or not english_subtitle.get("content"):
|
||
raise HTTPException(status_code=400, detail="请先上传英文字幕。")
|
||
|
||
try:
|
||
text_ai_config = load_text_ai_config()
|
||
client = DeepSeekClient(text_ai_config, timeout_seconds=text_ai_config.timeout_seconds)
|
||
result = process_subtitles_with_ai(
|
||
str(english_subtitle["content"]),
|
||
client,
|
||
batch_size=text_ai_config.translation_batch_size,
|
||
)
|
||
except (DeepSeekError, ValueError) as error:
|
||
raise HTTPException(status_code=400, detail=str(error)) from error
|
||
|
||
english_file_path = save_generated_subtitle_file(str(result["subtitle_en_content"]), "en")
|
||
upsert_video_subtitle(
|
||
video_id,
|
||
language_code="en",
|
||
language_name="English",
|
||
format="vtt",
|
||
file_path=english_file_path,
|
||
content=str(result["subtitle_en_content"]),
|
||
)
|
||
|
||
chinese_file_path = save_generated_subtitle_file(str(result["subtitle_zh_content"]), "zh")
|
||
upsert_video_subtitle(
|
||
video_id,
|
||
language_code="zh",
|
||
language_name="中文",
|
||
format="vtt",
|
||
file_path=chinese_file_path,
|
||
content=str(result["subtitle_zh_content"]),
|
||
)
|
||
|
||
return {
|
||
"video": get_video(video_id),
|
||
"report": result["report"],
|
||
}
|
||
|
||
|
||
|
||
|
||
def save_processed_subtitles(video_id: int, subtitles: dict[str, object], result: dict[str, object]) -> None:
|
||
english_subtitle = subtitles.get("en", {})
|
||
english_file_path = ""
|
||
if isinstance(english_subtitle, dict):
|
||
english_file_path = str(english_subtitle.get("filePath") or "")
|
||
upsert_video_subtitle(
|
||
video_id,
|
||
language_code="en",
|
||
language_name="English",
|
||
format="vtt",
|
||
file_path=english_file_path,
|
||
content=str(result["subtitle_en_content"]),
|
||
)
|
||
|
||
chinese_subtitle = subtitles.get("zh", {})
|
||
chinese_file_path = ""
|
||
if isinstance(chinese_subtitle, dict):
|
||
chinese_file_path = str(chinese_subtitle.get("filePath") or "")
|
||
upsert_video_subtitle(
|
||
video_id,
|
||
language_code="zh",
|
||
language_name="中文",
|
||
format="vtt",
|
||
file_path=chinese_file_path,
|
||
content=str(result["subtitle_zh_content"]),
|
||
)
|
||
|
||
|
||
@app.post("/api/videos/{video_id}/local-whisper/subtitles")
|
||
def api_generate_local_whisper_subtitles(video_id: int, admin: dict[str, str] = Depends(require_admin)) -> dict[str, object]:
|
||
video = get_video(video_id)
|
||
if video is None:
|
||
raise HTTPException(status_code=404, detail="视频不存在")
|
||
|
||
video_path = upload_url_to_path(str(video.get("videoUrl") or ""))
|
||
if not video_path:
|
||
raise HTTPException(status_code=400, detail="本地 Whisper 只能处理本地上传的视频文件。")
|
||
|
||
try:
|
||
whisper_config = load_local_whisper_config()
|
||
english_vtt = transcribe_video_to_vtt(video_path, whisper_config)
|
||
except LocalWhisperError as error:
|
||
raise HTTPException(status_code=400, detail=str(error)) from error
|
||
|
||
upsert_video_subtitle(
|
||
video_id,
|
||
language_code="en",
|
||
language_name="English",
|
||
format="vtt",
|
||
file_path="",
|
||
content=english_vtt,
|
||
)
|
||
return {
|
||
"video": get_video(video_id),
|
||
"report": {
|
||
"local_whisper_generated": True,
|
||
"english_count": english_vtt.count("-->"),
|
||
},
|
||
}
|
||
|
||
@app.get("/")
|
||
def read_index() -> FileResponse:
|
||
return FileResponse(PROJECT_DIR / "index.html")
|
||
|
||
|
||
app.mount("/", StaticFiles(directory=PROJECT_DIR), name="static")
|