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