302 lines
11 KiB
Python
302 lines
11 KiB
Python
"""GET /api/history; GET /api/history/{prompt_id}/images; GET /api/history/{prompt_id}/file/{filename};
|
|
POST /api/history/{prompt_id}/share; DELETE /api/history/{prompt_id}/share"""
|
|
from __future__ import annotations
|
|
|
|
import base64
|
|
from datetime import datetime, timedelta, timezone
|
|
from typing import Optional
|
|
|
|
from fastapi import APIRouter, Body, Depends, HTTPException, Query, Request
|
|
from fastapi.responses import Response
|
|
from pydantic import BaseModel
|
|
|
|
from web.auth import require_admin, require_auth
|
|
|
|
router = APIRouter()
|
|
|
|
|
|
def _assert_owns(prompt_id: str, user: dict) -> None:
|
|
"""Raise 404 if the generation doesn't exist or doesn't belong to the user.
|
|
|
|
Returning the same 404 for both cases prevents leaking whether a
|
|
prompt_id exists to users who don't own it. Admins bypass this check.
|
|
"""
|
|
if user.get("admin"):
|
|
return
|
|
from generation_db import get_generation
|
|
gen = get_generation(prompt_id)
|
|
if gen is None or gen["user_label"] != user["sub"]:
|
|
raise HTTPException(404, "Not found")
|
|
|
|
|
|
@router.get("")
|
|
async def get_history(
|
|
user: dict = Depends(require_auth),
|
|
q: Optional[str] = Query(None, description="Keyword to search in overrides JSON"),
|
|
persons: list[str] = Query(default=[], alias="persons", description="Filter by person name/alias substring (repeatable)"),
|
|
):
|
|
"""Return generation history. Admins see all; regular users see only their own.
|
|
Pass ?q=keyword to filter by prompt text or any override field.
|
|
Pass ?persons=name (repeatable) to filter by persons detected in output images."""
|
|
import face_db as face_db_mod
|
|
from generation_db import (
|
|
get_history as db_get_history,
|
|
get_history_for_user,
|
|
search_history,
|
|
search_history_for_user,
|
|
get_generation_ids_for_file_ids,
|
|
get_file_ids_for_generation_ids,
|
|
)
|
|
|
|
# Person filter: OR union across all named persons, then filter rows
|
|
gen_id_filter: list[int] | None = None
|
|
all_file_ids: set[int] = set()
|
|
active_persons = [p.strip() for p in persons if p.strip()]
|
|
if active_persons:
|
|
for p in active_persons:
|
|
ids = face_db_mod.get_source_ids_for_person_query(p, "output")
|
|
all_file_ids.update(ids)
|
|
if not all_file_ids:
|
|
return {"history": []}
|
|
gen_ids = get_generation_ids_for_file_ids(list(all_file_ids))
|
|
if not gen_ids:
|
|
return {"history": []}
|
|
gen_id_filter = gen_ids
|
|
|
|
if q and q.strip():
|
|
if user.get("admin"):
|
|
rows = search_history(q.strip(), limit=50)
|
|
else:
|
|
rows = search_history_for_user(user["sub"], q.strip(), limit=50)
|
|
else:
|
|
if user.get("admin"):
|
|
rows = db_get_history(limit=50)
|
|
else:
|
|
rows = get_history_for_user(user["sub"], limit=50)
|
|
|
|
if gen_id_filter is not None:
|
|
gen_id_set = set(gen_id_filter)
|
|
rows = [r for r in rows if r["id"] in gen_id_set]
|
|
|
|
# Annotate each row with detected_persons when person filtering is active
|
|
if active_persons and rows:
|
|
row_ids = [r["id"] for r in rows]
|
|
file_ids_per_gen = get_file_ids_for_generation_ids(row_ids)
|
|
all_annotate_ids = [fid for fids in file_ids_per_gen.values() for fid in fids]
|
|
person_map = face_db_mod.get_persons_for_source_id_map(all_annotate_ids, "output") if all_annotate_ids else {}
|
|
for row in rows:
|
|
row["detected_persons"] = list({
|
|
name
|
|
for fid in file_ids_per_gen.get(row["id"], [])
|
|
for name in person_map.get(fid, [])
|
|
})
|
|
|
|
return {"history": rows}
|
|
|
|
|
|
@router.get("/{prompt_id}/persons")
|
|
async def get_generation_persons(prompt_id: str, user: dict = Depends(require_auth)):
|
|
"""Return persons detected in the output images of a generation."""
|
|
_assert_owns(prompt_id, user)
|
|
import generation_db as gen_db
|
|
import face_db as face_db_mod
|
|
file_ids = gen_db.get_file_ids_for_prompt(prompt_id)
|
|
persons = face_db_mod.get_persons_for_source_ids(file_ids, "output")
|
|
return {"persons": persons}
|
|
|
|
|
|
class _AddPersonRequest(BaseModel):
|
|
name: str
|
|
|
|
|
|
@router.post("/{prompt_id}/persons")
|
|
async def add_generation_person(
|
|
prompt_id: str,
|
|
body: _AddPersonRequest,
|
|
_: dict = Depends(require_admin),
|
|
):
|
|
"""Manually tag a person to a generation's output files."""
|
|
import generation_db as gen_db
|
|
import face_db as face_db_mod
|
|
|
|
file_ids = gen_db.get_file_ids_for_prompt(prompt_id)
|
|
if not file_ids:
|
|
raise HTTPException(404, f"Generation {prompt_id!r} not found")
|
|
|
|
name = body.name.strip()
|
|
if not name:
|
|
raise HTTPException(400, "Name cannot be empty")
|
|
if len(name) > 100:
|
|
raise HTTPException(400, "Name too long (max 100 chars)")
|
|
|
|
person_id, _ = face_db_mod.get_or_create_person(name)
|
|
|
|
# Only add if not already tagged on any file of this generation
|
|
existing = face_db_mod.get_persons_for_source_ids(file_ids, "output")
|
|
if not any(p["id"] == person_id for p in existing):
|
|
face_db_mod.insert_detection(
|
|
source_type="output",
|
|
source_id=file_ids[0],
|
|
embedding=None,
|
|
bbox={},
|
|
face_index=0,
|
|
person_id=person_id,
|
|
)
|
|
|
|
return {"person_id": person_id, "name": name}
|
|
|
|
|
|
@router.delete("/{prompt_id}/persons/{person_id}")
|
|
async def remove_generation_person(
|
|
prompt_id: str,
|
|
person_id: int,
|
|
_: dict = Depends(require_admin),
|
|
):
|
|
"""Remove all face detections linking a person to this generation's output files."""
|
|
import generation_db as gen_db
|
|
import face_db as face_db_mod
|
|
|
|
file_ids = gen_db.get_file_ids_for_prompt(prompt_id)
|
|
if not file_ids:
|
|
raise HTTPException(404, f"Generation {prompt_id!r} not found")
|
|
|
|
face_db_mod.remove_person_from_source_ids(file_ids, person_id, "output")
|
|
return {"ok": True}
|
|
|
|
|
|
@router.get("/{prompt_id}/images")
|
|
async def get_history_images(prompt_id: str, user: dict = Depends(require_auth)):
|
|
"""
|
|
Fetch output files for a past generation.
|
|
|
|
Returns base64-encoded blobs from the local SQLite DB — works even after
|
|
``flush_pending`` has deleted the files from disk.
|
|
"""
|
|
_assert_owns(prompt_id, user)
|
|
from generation_db import get_files
|
|
files = get_files(prompt_id)
|
|
if not files:
|
|
raise HTTPException(404, f"No files found for prompt_id {prompt_id!r}")
|
|
return {
|
|
"prompt_id": prompt_id,
|
|
"images": [
|
|
{
|
|
"filename": f["filename"],
|
|
"data": base64.b64encode(f["data"]).decode() if not f["mime_type"].startswith("video/") else None,
|
|
"mime_type": f["mime_type"],
|
|
}
|
|
for f in files
|
|
],
|
|
}
|
|
|
|
|
|
@router.get("/{prompt_id}/file/{filename}")
|
|
async def get_history_file(
|
|
prompt_id: str,
|
|
filename: str,
|
|
request: Request,
|
|
user: dict = Depends(require_auth),
|
|
):
|
|
"""Stream a single output file, with HTTP range request support for video seeking."""
|
|
_assert_owns(prompt_id, user)
|
|
from generation_db import get_files
|
|
files = get_files(prompt_id)
|
|
matched = next((f for f in files if f["filename"] == filename), None)
|
|
if matched is None:
|
|
raise HTTPException(404, f"File {filename!r} not found for prompt_id {prompt_id!r}")
|
|
|
|
data: bytes = matched["data"]
|
|
mime: str = matched["mime_type"]
|
|
total = len(data)
|
|
|
|
range_header = request.headers.get("range")
|
|
if range_header:
|
|
range_val = range_header.replace("bytes=", "")
|
|
start_str, _, end_str = range_val.partition("-")
|
|
start = int(start_str) if start_str else 0
|
|
end = int(end_str) if end_str else total - 1
|
|
end = min(end, total - 1)
|
|
if start < 0 or start > end:
|
|
return Response(
|
|
status_code=416,
|
|
headers={"Content-Range": f"bytes */{total}"},
|
|
)
|
|
chunk = data[start : end + 1]
|
|
return Response(
|
|
content=chunk,
|
|
status_code=206,
|
|
media_type=mime,
|
|
headers={
|
|
"Content-Range": f"bytes {start}-{end}/{total}",
|
|
"Accept-Ranges": "bytes",
|
|
"Content-Length": str(len(chunk)),
|
|
"Cache-Control": "private",
|
|
},
|
|
)
|
|
|
|
return Response(
|
|
content=data,
|
|
media_type=mime,
|
|
headers={
|
|
"Accept-Ranges": "bytes",
|
|
"Content-Length": str(total),
|
|
"Cache-Control": "private",
|
|
},
|
|
)
|
|
|
|
|
|
class _ShareRequest(BaseModel):
|
|
is_public: bool = False
|
|
expires_in_hours: Optional[float] = None
|
|
max_views: Optional[int] = None
|
|
|
|
|
|
@router.post("/{prompt_id}/share")
|
|
async def create_generation_share(
|
|
prompt_id: str,
|
|
body: _ShareRequest = Body(default_factory=_ShareRequest),
|
|
user: dict = Depends(require_auth),
|
|
):
|
|
"""Create a share token for a generation. Only the owner may share."""
|
|
_assert_owns(prompt_id, user)
|
|
from generation_db import (
|
|
create_share as db_create_share,
|
|
get_active_share_for_prompt as db_get_active_share,
|
|
)
|
|
existing = db_get_active_share(prompt_id, user["sub"])
|
|
if existing:
|
|
raise HTTPException(409, "A share already exists — revoke it first")
|
|
if body.is_public and body.expires_in_hours is None and body.max_views is None:
|
|
raise HTTPException(400, "Public shares must have at least one expiry condition (time or view limit)")
|
|
if body.max_views is not None and body.max_views < 1:
|
|
raise HTTPException(400, "max_views must be >= 1")
|
|
if body.expires_in_hours is not None and body.expires_in_hours <= 0:
|
|
raise HTTPException(400, "expires_in_hours must be > 0")
|
|
expires_at = None
|
|
if body.expires_in_hours is not None:
|
|
expires_at = (datetime.now(timezone.utc) + timedelta(hours=body.expires_in_hours)).isoformat()
|
|
share = db_create_share(
|
|
prompt_id, user["sub"],
|
|
is_public=body.is_public,
|
|
expires_at=expires_at,
|
|
max_views=body.max_views,
|
|
)
|
|
return {
|
|
"share_token": share["share_token"],
|
|
"is_public": bool(share["is_public"]),
|
|
"expires_at": share["expires_at"],
|
|
"max_views": share["max_views"],
|
|
}
|
|
|
|
|
|
@router.delete("/{prompt_id}/share")
|
|
async def revoke_generation_share(prompt_id: str, user: dict = Depends(require_auth)):
|
|
"""Revoke a share token for a generation. Admins can revoke any share."""
|
|
from generation_db import revoke_share as db_revoke_share
|
|
# Admins pass None for owner_label to delete by prompt_id alone
|
|
owner_label = None if user.get("admin") else user["sub"]
|
|
deleted = db_revoke_share(prompt_id, owner_label)
|
|
if not deleted:
|
|
raise HTTPException(404, "No active share found for this generation")
|
|
return {"ok": True}
|