428 lines
14 KiB
Python
428 lines
14 KiB
Python
from pathlib import Path
|
|
from urllib.parse import urlparse
|
|
from uuid import uuid4
|
|
|
|
from fastapi import FastAPI, File, Form, HTTPException, UploadFile
|
|
from fastapi.responses import FileResponse
|
|
from fastapi.staticfiles import StaticFiles
|
|
|
|
from .ai_config import get_ai_status, load_deepseek_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 .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"}
|
|
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 / "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
|
|
|
|
|
|
ensure_upload_directories()
|
|
|
|
app = FastAPI(title="Speaking Lab API")
|
|
|
|
|
|
@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
|
|
|
|
|
|
@app.post("/api/videos")
|
|
async def api_create_video(
|
|
title: str = Form(...),
|
|
speaker: str = Form(""),
|
|
description: str = Form(""),
|
|
tags: str = Form(""),
|
|
video_url: str = Form(""),
|
|
video_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="视频文件格式不支持")
|
|
|
|
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}"
|
|
|
|
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,
|
|
subtitles=subtitles,
|
|
)
|
|
except Exception:
|
|
cleanup_saved_files(saved_paths)
|
|
raise
|
|
|
|
|
|
@app.patch("/api/videos/{video_id}")
|
|
async def api_update_video(
|
|
video_id: int,
|
|
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),
|
|
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="视频文件格式不支持")
|
|
|
|
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}"
|
|
|
|
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,
|
|
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) -> 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() -> dict[str, object]:
|
|
status = get_ai_status()
|
|
if not status["configured"]:
|
|
raise HTTPException(status_code=400, detail=status["message"])
|
|
return {"ok": True, "message": "DeepSeek API 配置已读取,处理字幕时会正式调用。"}
|
|
|
|
|
|
@app.post("/api/videos/{video_id}/ai/subtitles")
|
|
def api_process_video_subtitles(video_id: int) -> 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:
|
|
result = process_subtitles_with_ai(
|
|
str(english_subtitle["content"]),
|
|
DeepSeekClient(load_deepseek_config()),
|
|
)
|
|
except (DeepSeekError, ValueError) 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=str(english_subtitle.get("filePath") or ""),
|
|
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"]),
|
|
)
|
|
|
|
return {
|
|
"video": get_video(video_id),
|
|
"report": result["report"],
|
|
}
|
|
|
|
|
|
@app.get("/")
|
|
def read_index() -> FileResponse:
|
|
return FileResponse(PROJECT_DIR / "index.html")
|
|
|
|
|
|
app.mount("/", StaticFiles(directory=PROJECT_DIR), name="static")
|