nex_animation/backend/app/api/library.py

731 lines
37 KiB
Python
Raw Permalink Blame History

This file contains ambiguous Unicode characters!

This file contains ambiguous Unicode characters that may be confused with others in your current locale. If your use case is intentional and legitimate, you can safely ignore this warning. Use the Escape button to highlight these characters.

"""项目与资产库接口(图1 模块①:人物与声音资产库 + 项目数据库)。"""
from __future__ import annotations
from pathlib import Path
from fastapi import APIRouter, Depends, File, Form, HTTPException, Query, UploadFile
from sqlalchemy import func, or_, select
from sqlalchemy.orm import Session
from app import schemas
from app.api import deps
from app.constants import AssetKind, TaskKind
from app.db import get_db
from app.api.auth import require_user
from app.models import Asset, Character, Project, Scene, Shot, Task, User, VoiceAsset, now_utc
from app.providers import registry as model_registry
from app.providers.base import AssetGenRequest
from app.services import (costing, daemon, dispatch, events, prompt as prompt_service, storage, status,
timbre, versions)
router = APIRouter(tags=["library"])
# ---------------------------------------------------------------- 项目
# 总览封面优先用首镜关键帧:一眼能看出「这个项目长什么样」;
# 还没出关键帧的项目退回场景图 / 定妆图,全都没有才让前端显示占位。
COVER_KINDS = (AssetKind.KEYFRAME, AssetKind.LAST_FRAME, AssetKind.SCENE_IMAGE, AssetKind.PORTRAIT)
def project_covers(db: Session, project_ids: list[int]) -> dict[int, dict]:
"""批量取项目封面,避免总览页逐项目查素材(N+1)。"""
if not project_ids:
return {}
rows = db.execute(
select(Asset.project_id, Asset.kind, Asset.path)
.where(Asset.project_id.in_(project_ids), Asset.kind.in_(COVER_KINDS))
.order_by(Asset.project_id, Asset.id)
).all()
preferred = {kind: rank for rank, kind in enumerate(COVER_KINDS)}
best: dict[int, dict] = {}
for project_id, kind, path in rows:
rank = preferred.get(str(kind), 99)
current = best.get(int(project_id))
if current is not None and current["rank"] <= rank:
continue
if not storage.exists(path):
continue
best[int(project_id)] = {"url": storage.url_for(path), "kind": str(kind), "rank": rank}
return best
@router.get("/api/projects")
def list_projects(status_filter: str = Query("", alias="status"), q: str = "",
brief: bool = Query(False), db: Session = Depends(get_db)):
"""项目列表。
`brief=1` 只回选择器需要的字段(id / 名称 / 阶段 / 封面 / 镜头数):
全量列表每个项目都带 characters + scenes + voices + 素材版本 + stats,
6 个项目就有 170KB+,而「引入到哪个项目」这类下拉只需要 id 和名字。
"""
stmt = select(Project).order_by(Project.id.desc())
if status_filter:
stmt = stmt.where(Project.status == status_filter)
rows = db.scalars(stmt).all()
if q:
rows = [p for p in rows if q.lower() in f"{p.name}{p.description}{p.genre}".lower()]
ids = [int(p.id) for p in rows]
covers = project_covers(db, ids)
if brief:
shot_counts = dict(db.execute(
select(Shot.project_id, func.count(Shot.id)).where(Shot.project_id.in_(ids or [-1]))
.group_by(Shot.project_id)).all())
payload = [{
"id": int(p.id), "name": p.name, "status": p.status, "current_stage": p.current_stage,
"stage_label": status.STAGE_LABELS.get(p.current_stage, ""), "genre": p.genre,
"aspect_ratio": p.aspect_ratio, "updated_at": p.updated_at,
"cover_url": (covers.get(int(p.id)) or {}).get("url", ""),
"cover_kind": (covers.get(int(p.id)) or {}).get("kind", ""),
"shot_count": int(shot_counts.get(int(p.id)) or 0),
} for p in rows]
return {"projects": payload, "count": len(payload), "brief": True}
asset_map = status.preload_assets(db, ids)
payload = []
for project in rows:
item = status.project_dict(db, project, asset_map=asset_map)
cover = covers.get(int(project.id)) or {}
item["cover_url"] = cover.get("url", "")
item["cover_kind"] = cover.get("kind", "")
item["shot_count"] = int((item.get("stats") or {}).get("shots") or 0)
payload.append(item)
return {"projects": payload, "count": len(payload)}
def import_platform_assets(db: Session, project: Project,
refs: list[schemas.PlatformRef]) -> tuple[list[dict], list[dict]]:
"""建项目时顺带把平台资源库的母版引进来(人物会连默认声线与母版素材一起复制)。
逐条独立提交:一个母版坏了(素材文件被删、母版不存在)不能连累整批,
失败原因回吐给前端显示,用户仍然拿到一个建好的项目。
"""
from app.api import platform as platform_api # 局部导入,避免 api 包内的加载顺序耦合
imported: list[dict] = []
failures: list[dict] = []
seen: set[tuple[str, int]] = set()
for ref in refs:
key = (str(ref.owner_type), int(ref.asset_id))
if key in seen:
continue
seen.add(key)
try:
result = platform_api.import_into_project(schemas.PlatformImport(
project_id=int(project.id), asset_type=key[0], asset_id=key[1]), db=db)
imported.append(result.get("result") or {})
except HTTPException as exc:
failures.append({"owner_type": key[0], "asset_id": key[1], "detail": exc.detail})
except Exception as exc: # noqa: BLE001 - 建项目不该被引入拖垮
db.rollback()
failures.append({"owner_type": key[0], "asset_id": key[1],
"detail": f"{type(exc).__name__}: {exc}"})
if imported or failures:
events.log_event(db, "project.assets_imported", project_id=project.id,
message=f"创建项目时引入资源库母版 {len(imported)} 个"
+ (f",失败 {len(failures)} 个" if failures else ""),
entity_type="project", entity_id=project.id,
data={"imported": imported, "failures": failures})
db.commit()
return imported, failures
@router.post("/api/projects")
def create_project(data: schemas.ProjectCreate, db: Session = Depends(get_db),
actor: User = Depends(require_user)):
project = Project(**data.model_dump(exclude={"settings", "platform_assets"}),
settings_json=data.settings or {})
project.current_stage = "create_project"
if actor.id: # AUTH_ENABLED=false 的虚拟账号不落库,不占外键
project.created_by_id, project.created_by = actor.id, actor.username
project.updated_by_id, project.updated_by = actor.id, actor.username
db.add(project)
db.flush()
events.log_event(db, "project.created", project_id=project.id, message=f"创建项目《{project.name}》",
entity_type="project", entity_id=project.id,
data={"resolution": project.resolution, "aspect_ratio": project.aspect_ratio,
"fps": project.fps, "provider": project.default_provider})
db.commit()
imported, failures = import_platform_assets(db, project, data.platform_assets)
payload = status.project_dict(db, project)
payload["imported_assets"], payload["import_failures"] = imported, failures
return {"ok": True, "result": payload, "summary": deps.summary(db, project)}
@router.get("/api/projects/{project_id}")
def get_project(project_id: int, db: Session = Depends(get_db)):
project = deps.get_project(db, project_id)
return {"ok": True, "result": status.project_dict(db, project), "summary": deps.summary(db, project)}
@router.get("/api/projects/{project_id}/summary")
def project_summary(project_id: int, db: Session = Depends(get_db)):
project = deps.get_project(db, project_id)
return {"ok": True, "result": {"workflow": status.workflow_of(db, project),
"stats": status.stats_of(db, project)},
"summary": deps.summary(db, project)}
@router.patch("/api/projects/{project_id}")
def update_project(project_id: int, data: schemas.ProjectUpdate, db: Session = Depends(get_db),
actor: User = Depends(require_user)):
project = deps.get_project(db, project_id)
patch = data.model_dump(exclude_unset=True)
if actor.id:
project.updated_by_id, project.updated_by = actor.id, actor.username
if not (project.created_by_id or 0): # 补上用户体系之前建的项目
project.created_by_id, project.created_by = actor.id, actor.username
settings_patch = patch.pop("settings", None)
if settings_patch is not None:
project.settings_json = {**(project.settings_json or {}), **settings_patch}
for key, value in patch.items():
setattr(project, key, value)
db.flush()
if {"style_guide", "global_negative_prompt"} & set(patch):
# 项目级提示词会参与每个镜头的组装;只改项目行会让已有分镜继续使用旧文本。
for shot in project.shots or []:
prompt_service.sync_prompt(
db, project, shot,
reason="项目风格或负面提示词更新后重算分镜提示词",
actor="studio",
)
deps.recheck(db, project)
events.log_event(db, "project.updated", project_id=project.id, message="更新项目设定",
entity_type="project", entity_id=project.id, data=patch)
return deps.done(db, project, {"project_id": project.id})
@router.delete("/api/projects/{project_id}")
def delete_project(project_id: int, purge_files: bool = False, db: Session = Depends(get_db)):
project = deps.get_project(db, project_id)
active = db.query(Task).filter(Task.project_id == project_id,
Task.status.in_(["queued", "running", "retrying"])).count()
if active:
raise HTTPException(409, f"仍有 {active} 个任务在执行,请先取消任务")
name = project.name
db.delete(project)
db.commit()
if purge_files:
storage.cleanup_project_files(project_id)
events.log_event(db, "project.deleted", message=f"删除项目《{name}》", data={"project_id": project_id})
return {"ok": True, "deleted": project_id}
# ---------------------------------------------------------------- 角色
@router.post("/api/projects/{project_id}/characters")
def create_character(project_id: int, data: schemas.CharacterCreate, db: Session = Depends(get_db)):
project = deps.get_project(db, project_id)
char = Character(project_id=project.id, **data.model_dump())
db.add(char)
db.flush()
events.log_event(db, "character.created", project_id=project.id, message=f"新增角色「{char.name}」",
entity_type="character", entity_id=char.id)
deps.recheck(db, project)
return deps.done(db, project, {"id": char.id, "name": char.name})
@router.patch("/api/projects/{project_id}/characters/{character_id}")
def update_character(project_id: int, character_id: int, data: schemas.CharacterUpdate,
db: Session = Depends(get_db)):
project = deps.get_project(db, project_id)
char = deps.get_character(db, project_id, character_id)
patch = data.model_dump(exclude_unset=True)
for key, value in patch.items():
setattr(char, key, value)
db.flush()
for shot in project.shots or []:
if char in (shot.characters or []) or shot.speaker_character_id == char.id:
from app.services import prompt as prompt_service
prompt_service.sync_prompt(db, project, shot, reason=f"角色「{char.name}」设定更新后重算提示词",
record=True)
deps.recheck(db, project)
return deps.done(db, project, {"id": char.id, **patch})
@router.delete("/api/projects/{project_id}/characters/{character_id}")
def delete_character(project_id: int, character_id: int, db: Session = Depends(get_db)):
project = deps.get_project(db, project_id)
char = deps.get_character(db, project_id, character_id)
for shot in project.shots or []:
if char in (shot.characters or []):
shot.characters = [c for c in shot.characters if c.id != char.id]
if shot.speaker_character_id == char.id:
shot.speaker_character_id = None
storage.purge_owner_assets(db, "human", character_id)
db.delete(char)
db.flush()
deps.recheck(db, project)
return deps.done(db, project, {"deleted": character_id})
# ---------------------------------------------------------------- 场景
@router.post("/api/projects/{project_id}/scenes")
def create_scene(project_id: int, data: schemas.SceneCreate, db: Session = Depends(get_db)):
project = deps.get_project(db, project_id)
scene = Scene(project_id=project.id, **data.model_dump())
db.add(scene)
db.flush()
events.log_event(db, "scene.created", project_id=project.id, message=f"新增场景「{scene.name}」",
entity_type="scene", entity_id=scene.id)
deps.recheck(db, project)
return deps.done(db, project, {"id": scene.id, "name": scene.name})
@router.patch("/api/projects/{project_id}/scenes/{scene_id}")
def update_scene(project_id: int, scene_id: int, data: schemas.SceneUpdate, db: Session = Depends(get_db)):
project = deps.get_project(db, project_id)
scene = deps.get_scene(db, project_id, scene_id)
patch = data.model_dump(exclude_unset=True)
for key, value in patch.items():
setattr(scene, key, value)
db.flush()
deps.recheck(db, project)
return deps.done(db, project, {"id": scene.id, **patch})
@router.delete("/api/projects/{project_id}/scenes/{scene_id}")
def delete_scene(project_id: int, scene_id: int, db: Session = Depends(get_db)):
project = deps.get_project(db, project_id)
scene = deps.get_scene(db, project_id, scene_id)
for shot in project.shots or []:
if scene in (shot.scenes or []):
shot.scenes = [s for s in shot.scenes if s.id != scene.id]
storage.purge_owner_assets(db, "scene", scene_id)
db.delete(scene)
db.flush()
deps.recheck(db, project)
return deps.done(db, project, {"deleted": scene_id})
# ---------------------------------------------------------------- 声线
@router.post("/api/projects/{project_id}/voices")
def create_voice(project_id: int, data: schemas.VoiceCreate, db: Session = Depends(get_db)):
project = deps.get_project(db, project_id)
if data.is_default:
db.query(VoiceAsset).filter(VoiceAsset.project_id == project.id,
VoiceAsset.is_default.is_(True)).update({"is_default": False})
voice = VoiceAsset(project_id=project.id, **data.model_dump())
db.add(voice)
db.flush()
events.log_event(db, "voice.created", project_id=project.id, message=f"新增声线「{voice.name}」",
entity_type="voice", entity_id=voice.id)
deps.recheck(db, project)
return deps.done(db, project, {"id": voice.id, "name": voice.name})
@router.patch("/api/projects/{project_id}/voices/{voice_id}")
def update_voice(project_id: int, voice_id: int, data: schemas.VoiceUpdate, db: Session = Depends(get_db)):
project = deps.get_project(db, project_id)
voice = deps.get_voice(db, project_id, voice_id)
patch = data.model_dump(exclude_unset=True)
if patch.get("is_default"):
db.query(VoiceAsset).filter(VoiceAsset.project_id == project.id, VoiceAsset.id != voice_id,
VoiceAsset.is_default.is_(True)).update({"is_default": False})
for key, value in patch.items():
setattr(voice, key, value)
db.flush()
deps.recheck(db, project)
return deps.done(db, project, {"id": voice.id, **patch})
@router.get("/api/projects/{project_id}/voices/{voice_id}/reference-status")
def voice_reference_status(project_id: int, voice_id: int, db: Session = Depends(get_db)):
"""打开项目侧「生成试听」前先预告:这次会拿到谁的嗓子。
和平台侧同一个理由——音色由参考音频决定,声线表单里的性别对 zero-shot
克隆模型只是元数据,所以「会不会男声出成女声」必须在点生成之前说清楚。
"""
deps.get_project(db, project_id)
voice = deps.get_voice(db, project_id, voice_id)
spec, _adapter = model_registry.resolve_voice(db, None, None)
return {"ok": True, "result": timbre.reference_status(
db, voice, clone=timbre.clone_model(spec), instruct=timbre.instruct_model(spec))}
@router.delete("/api/projects/{project_id}/voices/{voice_id}")
def delete_voice(project_id: int, voice_id: int, db: Session = Depends(get_db)):
project = deps.get_project(db, project_id)
voice = deps.get_voice(db, project_id, voice_id)
for shot in project.shots or []:
if shot.voice_asset_id == voice_id:
shot.voice_asset_id = None
for char in project.characters or []:
if char.default_voice_id == voice_id:
char.default_voice_id = None
storage.purge_owner_assets(db, "voice", voice_id)
db.delete(voice)
db.flush()
deps.recheck(db, project)
return deps.done(db, project, {"deleted": voice_id})
# ---------------------------------------------------------------- 资产
@router.get("/api/projects/{project_id}/assets")
def list_assets(project_id: int, owner_type: str = "", owner_id: int | None = None, kind: str = "",
db: Session = Depends(get_db)):
deps.get_project(db, project_id)
stmt = db.query(Asset).filter(Asset.project_id == project_id)
if owner_type:
stmt = stmt.filter(Asset.owner_type == owner_type)
if owner_id is not None:
stmt = stmt.filter(Asset.owner_id == owner_id)
if kind:
stmt = stmt.filter(Asset.kind == kind)
rows = [row for row in stmt.order_by(Asset.id).all()
if storage.belongs_to_owner(db, row.owner_type, row.owner_id, row)]
return {"assets": [storage.asset_dict(a) for a in rows], "count": len(rows)}
@router.get("/api/projects/{project_id}/assets/usage")
def asset_usage(project_id: int, db: Session = Depends(get_db)):
"""返回人物 / 场景 / 声线分别被哪些镜头使用,支持资产页直达分镜。"""
project = deps.get_project(db, project_id)
usage: dict[str, dict[str, dict]] = {"human": {}, "scene": {}, "voice": {}}
def add(owner_type: str, owner_id: int, shot) -> None:
bucket = usage[owner_type].setdefault(str(owner_id), {"target_type": owner_type, "target_id": owner_id,
"count": 0, "shots": []})
if any(row["id"] == shot.id for row in bucket["shots"]):
return
bucket["count"] += 1
bucket["shots"].append({"id": shot.id, "order_index": shot.order_index,
"title": shot.title or f"镜头 {shot.order_index}"})
for shot in project.shots or []:
seen_humans: set[int] = set()
for character in shot.characters or []:
seen_humans.add(character.id)
add("human", character.id, shot)
if shot.speaker_character_id and shot.speaker_character_id not in seen_humans:
add("human", shot.speaker_character_id, shot)
for scene in shot.scenes or []:
add("scene", scene.id, shot)
voices: set[int] = set()
if shot.voice_asset_id:
voices.add(shot.voice_asset_id)
if shot.speaker_character_id:
speaker = db.get(Character, shot.speaker_character_id)
if speaker and speaker.default_voice_id:
voices.add(speaker.default_voice_id)
for character in shot.characters or []:
if character.default_voice_id:
voices.add(character.default_voice_id)
for voice_id in voices:
add("voice", voice_id, shot)
items = [row for group in usage.values() for row in group.values()]
items.sort(key=lambda row: (row["target_type"], row["target_id"]))
return {"usage": usage, "items": items, "count": len(items)}
def _generation_references(db: Session, project_id: int, target_type: str, target_id: int,
ids: list[int], *, media_type: str) -> list[Asset]:
rows: list[Asset] = []
seen: set[int] = set()
image_suffixes = {".png", ".jpg", ".jpeg", ".webp", ".bmp", ".tif", ".tiff"}
audio_suffixes = {".wav", ".mp3", ".m4a", ".aac", ".flac", ".ogg", ".opus"}
for asset_id in ids:
if asset_id in seen:
continue
seen.add(asset_id)
row = db.get(Asset, asset_id)
if row is None or row.project_id != project_id:
raise HTTPException(400, "参考素材不属于当前项目资产")
# 图像生成需要跨资产组合参考图,例如「场景母图 + 人物定妆图」。
# 音色克隆仍必须来自当前声线,避免把别的角色声音静默克隆进来。
if media_type != "image" and (row.owner_type != target_type or row.owner_id != target_id):
raise HTTPException(400, "声音参考素材不属于当前声线资产")
if not storage.exists(row.path):
raise HTTPException(400, "参考素材文件不存在,请重新上传")
suffix = Path(row.path).suffix.lower()
if media_type == "image" and suffix not in image_suffixes:
raise HTTPException(400, "图像参考素材必须是图片文件")
if media_type == "tts" and suffix not in audio_suffixes:
raise HTTPException(400, "音色参考素材必须是音频文件")
rows.append(row)
return rows
@router.post("/api/projects/{project_id}/assets/generate")
def generate_asset(project_id: int, data: schemas.AssetGenerate, db: Session = Depends(get_db)):
"""调用已配置图像/TTS 模型生成角色、场景、分镜关键帧或声线资产。"""
project = deps.get_project(db, project_id)
target_type = data.target_type
if target_type == "human":
owner = deps.get_character(db, project_id, data.target_id)
allowed = {AssetKind.PORTRAIT, AssetKind.TURNAROUND, AssetKind.COSTUME, AssetKind.EXPRESSION}
media_type, operation = "image", "generate_image"
elif target_type == "scene":
owner = deps.get_scene(db, project_id, data.target_id)
allowed = {AssetKind.SCENE_IMAGE}
media_type, operation = "image", "generate_image"
elif target_type == "voice":
owner = deps.get_voice(db, project_id, data.target_id)
allowed = {AssetKind.VOICE_SAMPLE}
media_type, operation = "tts", "generate_voice_sample"
else:
owner = deps.get_shot(db, project_id, data.target_id)
allowed = {AssetKind.KEYFRAME, AssetKind.LAST_FRAME, AssetKind.REFERENCE_IMAGE}
media_type, operation = "image", "generate_image"
if data.kind not in allowed:
raise HTTPException(400, f"{target_type} 不支持资产生成类型 {data.kind};"
f"可用:{', '.join(sorted(allowed))}")
if media_type == "tts":
spec, adapter = model_registry.resolve_voice(db, data.provider or owner.provider or None,
data.model or None)
else:
spec, adapter = model_registry.resolve_asset(db, media_type, data.provider or None,
data.model or None)
if not spec.enabled:
raise HTTPException(409, f"模型 {spec.provider}/{spec.model} 已停用")
references = _generation_references(
db, project.id, target_type, owner.id, data.reference_asset_ids, media_type=media_type,
)
owner_name = ((owner.title or owner.code or f"镜头 {owner.order_index:02d}")
if isinstance(owner, Shot) else owner.name)
generated_name = f"{owner_name} · AI {AssetKind.LABELS.get(data.kind, data.kind)}"
if isinstance(owner, Shot):
existing = storage.assets_of(db, "shot", owner.id, data.kind)
# 关键帧/尾帧是镜头上的单值槽位。沿用已有素材名可原地递增版本,
# 确保 first_asset_path 立即命中新图,而不是继续使用旧的关键帧。
if existing:
generated_name = existing[-1].name
payload = data.model_dump(exclude={"drain"})
if isinstance(owner, Shot) and not payload.get("prompt"):
# 关键帧与镜头提示词共用同一份版本化文本。生成前先同步,避免页面
# 刚改完景别/运镜却仍用上一次缓存的提示词出图。
prompt_service.sync_prompt(db, project, owner, reason="生成分镜关键帧前同步提示词",
actor="studio", record=True)
payload["prompt"] = owner.prompt or owner.description
payload["negative_prompt"] = payload.get("negative_prompt") or owner.negative_prompt
payload.update({"operation": operation, "name": generated_name,
"reference_paths": [str(storage.to_absolute(row.path)) for row in references]})
task = Task(project_id=project.id, kind=TaskKind.ASSET,
name=f"资产生成:{payload['name']}", stage="asset", status="queued",
priority=3, provider=spec.provider, model=spec.model,
mode=media_type, max_attempts=2,
idempotency_key=f"asset-gen:{target_type}:{owner.id}:{data.kind}:{int(now_utc().timestamp())}",
payload_json=payload, cost_currency=spec.currency, queued_at=now_utc())
db.add(task)
db.flush()
events.log_event(db, "asset.queued", project_id=project.id, task_id=task.id,
message=f"{payload['name']} 已进入资产任务队列({spec.provider}/{spec.model})",
entity_type="asset", entity_id=None,
data={"target_type": target_type, "target_id": owner.id,
"kind": data.kind, "provider": spec.provider, "model": spec.model})
db.commit()
drained = None
if data.drain:
dispatch.dispatch_due(db, limit=1, project_id=project.id)
drained = daemon.drain_queue(db, project_id=project.id, timeout=300)
db.expire_all()
task = db.get(Task, task.id)
return {"ok": True, "result": {"task": status.task_dict(task), "drained": drained},
"summary": deps.summary(db, project)}
@router.post("/api/projects/{project_id}/assets/text-assist")
def text_assist(project_id: int, data: schemas.TextAssist, db: Session = Depends(get_db)):
"""调用大模型补全角色/场景一致性提示词,并把建议返回给资产编辑器。"""
project = deps.get_project(db, project_id)
if data.target_type == "character":
if data.target_id is None:
raise HTTPException(400, "角色文本补全缺少 target_id")
owner = deps.get_character(db, project_id, data.target_id)
subject = ",".join(part for part in [
owner.name, owner.role, owner.appearance, owner.personality, project.style_guide
] if part)
asset_type = "character"
elif data.target_type == "scene":
if data.target_id is None:
raise HTTPException(400, "场景文本补全缺少 target_id")
owner = deps.get_scene(db, project_id, data.target_id)
subject = ",".join(part for part in [
owner.name, owner.description, owner.prompt, owner.lighting,
owner.time_of_day, owner.palette, project.style_guide
] if part)
asset_type = "scene"
else:
owner = deps.get_shot(db, project_id, data.target_id) if data.target_id else None
if owner is None:
raise HTTPException(400, "分镜文本补全缺少 target_id")
subject = ",".join(part for part in [
owner.title, owner.description, owner.prompt, project.style_guide
] if part)
asset_type = "storyboard"
spec, _adapter = model_registry.resolve_llm(db, data.provider or None, data.model or None)
if not spec.enabled:
raise HTTPException(409, f"大模型 {spec.provider}/{spec.model} 已停用")
prompt = (
f"请补全以下{asset_type}的一致性提示词。保留已有事实,不新增与设定冲突的内容。"
f"输出一段可直接送入图像/视频模型的中文提示词。\n"
f"当前设定:{subject or '尚未填写'}\n"
f"补充要求:{data.instruction or '强化外观、材质、光线和跨镜头一致性'}"
)
request = AssetGenRequest(kind="text", prompt=prompt, seed=None,
params={"subject": subject, "asset_type": asset_type,
"model": spec.model},
idempotency_key=f"text-assist:{data.target_type}:{data.target_id}",
label=f"TEXT-{data.target_type.upper()}-{data.target_id}")
result = model_registry.generate_asset(db, request, "llm", spec.provider, spec.model)
if not result.text.strip():
raise HTTPException(502, "大模型未返回有效内容")
cost = float(result.cost or 0.0)
if not cost:
cost = len(prompt) / 1000.0 * float(spec.price_per_1k_chars or 0.0)
if cost:
costing.record_cost(db, project_id=project.id, kind="text_assist",
provider=spec.provider, model=spec.model, quantity=len(prompt) / 1000.0,
unit="1k_chars", unit_price=float(spec.price_per_1k_chars or 0.0),
cost=cost, currency=spec.currency, note="一致性提示词补全")
costing.record_generation(db, project_id=project.id, provider=spec.provider, model=spec.model,
kind="asset_text", prompt=prompt,
output_path="", cost=cost, currency=spec.currency,
metadata_json={"target_type": data.target_type,
"target_id": data.target_id})
events.log_event(db, "asset.text_assist", project_id=project.id,
message=f"使用 {spec.provider}/{spec.model} 补全了 {asset_type} 一致性提示词",
entity_type=data.target_type, entity_id=data.target_id,
data={"chars": len(result.text), "cost": round(cost, 6)})
db.commit()
return {"ok": True, "result": {"text": result.text.strip(), "provider": spec.provider,
"model": spec.model, "cost": round(cost, 6),
"currency": spec.currency}}
async def _upload(db: Session, project: Project, file: UploadFile, *, owner_type: str, owner_id: int,
kind: str, name: str, note: str, stem: str) -> Asset:
return await deps.save_asset_file(db, file, project=project, owner_type=owner_type, owner_id=owner_id,
kind=kind, name=name, note=note, stem=stem)
@router.post("/api/projects/{project_id}/characters/{character_id}/assets")
async def upload_character_asset(project_id: int, character_id: int, kind: str = Form(...),
name: str = Form(""), note: str = Form(""),
file: UploadFile = File(...), db: Session = Depends(get_db)):
project = deps.get_project(db, project_id)
char = deps.get_character(db, project_id, character_id)
asset = await _upload(db, project, file, owner_type="human", owner_id=char.id, kind=kind, name=name,
note=note, stem=f"char-{char.id}-{kind}")
for shot in project.shots or []:
if char in (shot.characters or []):
from app.services import prompt as prompt_service
prompt_service.sync_prompt(db, project, shot, reason="角色资产更新后重算提示词", record=False)
deps.recheck(db, project)
return deps.done(db, project, storage.asset_dict(asset))
@router.post("/api/projects/{project_id}/scenes/{scene_id}/assets")
async def upload_scene_asset(project_id: int, scene_id: int, kind: str = Form("scene_image"),
name: str = Form(""), note: str = Form(""),
file: UploadFile = File(...), db: Session = Depends(get_db)):
project = deps.get_project(db, project_id)
scene = deps.get_scene(db, project_id, scene_id)
asset = await _upload(db, project, file, owner_type="scene", owner_id=scene.id, kind=kind, name=name,
note=note, stem=f"scene-{scene.id}-{kind}")
deps.recheck(db, project)
return deps.done(db, project, storage.asset_dict(asset))
@router.post("/api/projects/{project_id}/voices/{voice_id}/assets")
async def upload_voice_asset_file(project_id: int, voice_id: int, kind: str = Form("voice_sample"),
name: str = Form(""), note: str = Form(""),
file: UploadFile = File(...), db: Session = Depends(get_db)):
project = deps.get_project(db, project_id)
voice = deps.get_voice(db, project_id, voice_id)
asset = await _upload(db, project, file, owner_type="voice", owner_id=voice.id, kind=kind, name=name,
note=note, stem=f"voice-{voice.id}-{kind}")
deps.recheck(db, project)
return deps.done(db, project, storage.asset_dict(asset))
@router.post("/api/projects/{project_id}/assets")
async def upload_project_asset(project_id: int, kind: str = Form(...), name: str = Form(""),
note: str = Form(""), file: UploadFile = File(...),
db: Session = Depends(get_db)):
"""项目级素材:配乐 / 音效 / 通用参考。"""
project = deps.get_project(db, project_id)
asset = await _upload(db, project, file, owner_type="project", owner_id=project.id, kind=kind, name=name,
note=note, stem=f"project-{kind}")
return deps.done(db, project, storage.asset_dict(asset))
@router.post("/api/assets/{asset_id}/refresh")
def refresh_asset(asset_id: int, db: Session = Depends(get_db)):
asset = db.get(Asset, asset_id)
if asset is None:
raise HTTPException(404, "资产不存在")
task = Task(project_id=asset.project_id, kind=TaskKind.ASSET, name=f"资产校验:{asset.name}",
stage="asset", status="queued", max_attempts=1,
idempotency_key=f"asset:{asset.id}:{asset.checksum}",
payload_json={"asset_id": asset.id}, queued_at=now_utc())
db.add(task)
db.commit()
return {"ok": True, "task_id": task.id}
@router.delete("/api/assets/{asset_id}")
def delete_asset(asset_id: int, db: Session = Depends(get_db)):
asset = db.get(Asset, asset_id)
if asset is None:
raise HTTPException(404, "资产不存在")
project = deps.get_project(db, asset.project_id)
owner_type, owner_id, kind = asset.owner_type, asset.owner_id, asset.kind
db.delete(asset)
db.flush()
deps.recheck(db, project)
events.log_event(db, "asset.deleted", project_id=project.id, message=f"删除资产:{asset.name}",
data={"kind": kind, "owner_type": owner_type, "owner_id": owner_id})
return deps.done(db, project, {"deleted": asset_id})
@router.post("/api/assets/{asset_id}/versions/{version_no}/current")
def set_asset_current_version(asset_id: int, version_no: int, data: schemas.VersionAction | None = None,
db: Session = Depends(get_db)):
"""把项目资产的某个历史版本设为当前版本。"""
try:
result = versions.set_current(db, versions.PROJECT_ASSET, asset_id, version_no,
actor=(data.actor if data else "ui"))
except versions.VersionError as exc:
raise HTTPException(exc.status_code, exc.detail)
return {"ok": True, "result": result}
@router.delete("/api/assets/{asset_id}/versions/{version_no}")
def delete_asset_version(asset_id: int, version_no: int, data: schemas.VersionAction | None = None,
db: Session = Depends(get_db)):
"""删除项目资产的某个版本;删的正是当前版本时自动回落到剩余最新版本。"""
try:
result = versions.delete_version(db, versions.PROJECT_ASSET, asset_id, version_no,
actor=(data.actor if data else "ui"))
except versions.VersionError as exc:
raise HTTPException(exc.status_code, exc.detail)
return {"ok": True, "result": result}
# ---------------------------------------------------------------- 观测
@router.get("/api/projects/{project_id}/events")
def project_events(project_id: int, limit: int = 120, level: str = "", db: Session = Depends(get_db)):
deps.get_project(db, project_id)
return {"events": events.recent_events(db, project_id=project_id, limit=min(500, max(1, limit)),
level=level or None)}
@router.get("/api/projects/{project_id}/costs")
def project_costs(project_id: int, db: Session = Depends(get_db)):
deps.get_project(db, project_id)
return {"cost": costing.summarize(db, project_id), "items": costing.detailed_costs(db, project_id)}
@router.get("/api/projects/{project_id}/generations")
def project_generations(project_id: int, limit: int = 200, db: Session = Depends(get_db)):
deps.get_project(db, project_id)
rows = costing.generation_records(db, project_id, limit=min(500, max(1, limit)))
return {"generations": rows, "count": len(rows)}