Spaces:
Sleeping
Sleeping
File size: 6,433 Bytes
b2300e2 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 | from __future__ import annotations
from pathlib import Path
from fastapi import APIRouter, BackgroundTasks, Depends, HTTPException, UploadFile, status
from iris.api.dependencies import get_database, get_file_store, get_settings, get_video_processor
from iris.config import Settings, device_info
from iris.models.schemas import (
SearchRequest,
SearchResponse,
SearchResultResponse,
TranscriptChunkResponse,
TranscriptResponse,
UploadVideoResponse,
VideoStatusResponse,
)
from iris.pipeline.chunk import window_transcript_chunks
from iris.pipeline.embed import LocalEmbedder
from iris.pipeline.search import detail_window_settings, format_timestamp, rank_speech_chunks
from iris.pipeline.visual import VisualSearcher, sample_video_frames
from iris.storage.database import Database
from iris.storage.files import FileStore
from iris.pipeline.orchestrator import VideoProcessor
router = APIRouter()
@router.get("/health")
def health(settings: Settings = Depends(get_settings)) -> dict:
return {"status": "ok", "device": device_info(settings.device, settings.torch_dtype)}
@router.post("/videos", response_model=UploadVideoResponse, status_code=status.HTTP_202_ACCEPTED)
def upload_video(
file: UploadFile,
background_tasks: BackgroundTasks,
database: Database = Depends(get_database),
file_store: FileStore = Depends(get_file_store),
processor: VideoProcessor = Depends(get_video_processor),
) -> UploadVideoResponse:
try:
video_id, path = file_store.save_upload(file)
except ValueError as exc:
raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail=str(exc)) from exc
database.create_video(video_id, file.filename or path.name, path)
if getattr(processor, "process_video", None) and processor is not None:
background_tasks.add_task(processor.process_video, video_id)
return UploadVideoResponse(video_id=video_id, status="queued")
@router.post("/videos/{video_id}/process", response_model=UploadVideoResponse, status_code=status.HTTP_202_ACCEPTED)
def process_video_again(
video_id: str,
background_tasks: BackgroundTasks,
database: Database = Depends(get_database),
processor: VideoProcessor = Depends(get_video_processor),
) -> UploadVideoResponse:
_get_video_or_404(database, video_id)
database.update_video_status(video_id, "queued")
background_tasks.add_task(processor.process_video, video_id)
return UploadVideoResponse(video_id=video_id, status="queued")
@router.get("/videos/{video_id}/status", response_model=VideoStatusResponse)
def get_video_status(
video_id: str,
database: Database = Depends(get_database),
) -> VideoStatusResponse:
record = _get_video_or_404(database, video_id)
return VideoStatusResponse(video_id=video_id, status=record["status"], error=record["error"])
@router.get("/videos/{video_id}/transcript", response_model=TranscriptResponse)
def get_transcript(
video_id: str,
database: Database = Depends(get_database),
) -> TranscriptResponse:
_get_video_or_404(database, video_id)
chunks = database.list_transcript_chunks(video_id)
return TranscriptResponse(
video_id=video_id,
chunks=[TranscriptChunkResponse(start=chunk.start, end=chunk.end, text=chunk.text) for chunk in chunks],
)
@router.post("/videos/{video_id}/search", response_model=SearchResponse)
def search_video(
video_id: str,
request: SearchRequest,
database: Database = Depends(get_database),
file_store: FileStore = Depends(get_file_store),
settings: Settings = Depends(get_settings),
) -> SearchResponse:
record = _get_video_or_404(database, video_id)
if record["status"] != "completed":
raise HTTPException(
status_code=status.HTTP_409_CONFLICT,
detail=f"Video is not ready for search. Current status: {record['status']}.",
)
atomic_chunks = database.list_transcript_chunks(video_id)
default_window, default_overlap, default_merge_gap = detail_window_settings(request.detail)
window_seconds = request.window_seconds or default_window
overlap_seconds = min(default_overlap, max(0.0, window_seconds - 0.1))
merge_gap_seconds = request.merge_gap_seconds if request.merge_gap_seconds is not None else default_merge_gap
chunks = window_transcript_chunks(
atomic_chunks,
window_seconds=window_seconds,
overlap_seconds=overlap_seconds,
)
embedder = LocalEmbedder(settings)
chunk_embeddings = embedder.encode([chunk.text for chunk in chunks])
query_embedding = embedder.encode([request.query])[0]
speech_results = rank_speech_chunks(
query=request.query,
chunks=chunks,
chunk_embeddings=chunk_embeddings,
query_embedding=query_embedding,
settings=settings,
limit=request.limit,
merge_gap_seconds=merge_gap_seconds,
)
results = list(speech_results)
if request.include_visual:
if not settings.visual_search_enabled:
raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail="Visual search is disabled.")
frames = sample_video_frames(
Path(record["video_path"]),
file_store.frames_dir(video_id),
settings.frame_sample_interval_seconds,
)
visual_results = VisualSearcher(settings).search(request.query, frames, request.limit)
results.extend(visual_results)
database.record_search(video_id, request.query, request.include_visual)
ranked = sorted(results, key=lambda item: (-item.score, item.start))[: request.limit]
return SearchResponse(
video_id=video_id,
query=request.query,
results=[
SearchResultResponse(
start=item.start,
end=item.end,
start_time=format_timestamp(item.start),
end_time=format_timestamp(item.end),
timestamp=f"{format_timestamp(item.start)}-{format_timestamp(item.end)}",
text=item.text,
score=item.score,
source=item.source,
)
for item in ranked
],
)
def _get_video_or_404(database: Database, video_id: str) -> dict:
record = database.get_video(video_id)
if record is None:
raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Video not found.")
return record
|