731 lines
37 KiB
Python
731 lines
37 KiB
Python
"""项目与资产库接口(图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)}
|