File size: 10,190 Bytes
f98dc3e
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
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
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
from __future__ import annotations

import errno
import os
import tempfile
from typing import List, Optional

from fastapi import APIRouter, File, Form, HTTPException, Query, Request, UploadFile
from pydantic import BaseModel

from vam.config import get_settings
from vam.retrieval.frame_store import get_store
from vam.video import (
    parse_absolute_time,
    format_absolute_time,
    index_video_async as core_index_video_async,
)

router = APIRouter(prefix="/api/frames", tags=["Frames"])

class FrameIn(BaseModel):
    t: float
    absolute_t: Optional[float] = None
    image_base64: str
    frame_id: Optional[str] = None

class AddFramesRequest(BaseModel):
    frames: List[FrameIn]

class IndexVideoPathRequest(BaseModel):
    video_path: str
    fps: Optional[float] = None
    max_frames: Optional[int] = None
    laplacian_min: Optional[float] = None
    diff_threshold: Optional[float] = None
    ssim_threshold: Optional[float] = None
    hist_threshold: Optional[float] = None
    similarity_threshold: Optional[float] = None
    frame_id_prefix: str = "v"
    store_path: Optional[str] = None
    video_start_time: Optional[str] = None
    debug: bool = False

async def _save_upload_to_temp(video: UploadFile, *, suffix: str = "") -> str:
    tmp_path = ""
    try:
        with tempfile.NamedTemporaryFile(delete=False, suffix=suffix) as tmp:
            tmp_path = tmp.name
            while True:
                chunk = await video.read(8 * 1024 * 1024)
                if not chunk:
                    break
                tmp.write(chunk)
        return tmp_path
    except OSError as e:
        if tmp_path:
            try:
                os.unlink(tmp_path)
            except Exception:
                pass
        if int(getattr(e, "errno", -1)) == int(errno.ENOSPC):
            raise HTTPException(status_code=507, detail="insufficient storage: temp disk is full")
        raise HTTPException(status_code=500, detail=f"failed to save upload: {type(e).__name__}: {e}")


def _query_string(request: Request, name: str) -> Optional[str]:
    raw = request.query_params.get(name)
    if raw is None:
        return None
    text = str(raw).strip()
    return text if text else None


def _query_float(request: Request, name: str) -> Optional[float]:
    raw = _query_string(request, name)
    if raw is None:
        return None
    try:
        return float(raw)
    except ValueError as exc:
        raise HTTPException(status_code=422, detail=f"invalid float for {name}: {raw}") from exc


def _query_int(request: Request, name: str) -> Optional[int]:
    raw = _query_string(request, name)
    if raw is None:
        return None
    try:
        return int(raw)
    except ValueError as exc:
        raise HTTPException(status_code=422, detail=f"invalid integer for {name}: {raw}") from exc


def _query_bool(request: Request, name: str) -> Optional[bool]:
    raw = _query_string(request, name)
    if raw is None:
        return None
    lowered = raw.lower()
    if lowered in {"1", "true", "yes", "on"}:
        return True
    if lowered in {"0", "false", "no", "off"}:
        return False
    raise HTTPException(status_code=422, detail=f"invalid boolean for {name}: {raw}")

@router.post("/index_video_async")
async def index_video_async(
    request: Request,
    video: UploadFile = File(...),
    fps: Optional[float] = Form(default=None),
    max_frames: Optional[int] = Form(default=None),
    laplacian_min: Optional[float] = Form(default=None),
    diff_threshold: Optional[float] = Form(default=None),
    ssim_threshold: Optional[float] = Form(default=None),
    hist_threshold: Optional[float] = Form(default=None),
    similarity_threshold: Optional[float] = Form(default=None),
    frame_id_prefix: Optional[str] = Form(default="v"),
    store_path: Optional[str] = Form(default=None),
    video_start_time: Optional[str] = Form(default=None),
    debug: Optional[bool] = Form(default=None),
):
    fps = fps if fps is not None else _query_float(request, "fps")
    max_frames = max_frames if max_frames is not None else _query_int(request, "max_frames")
    laplacian_min = laplacian_min if laplacian_min is not None else _query_float(request, "laplacian_min")
    diff_threshold = diff_threshold if diff_threshold is not None else _query_float(request, "diff_threshold")
    ssim_threshold = ssim_threshold if ssim_threshold is not None else _query_float(request, "ssim_threshold")
    hist_threshold = hist_threshold if hist_threshold is not None else _query_float(request, "hist_threshold")
    similarity_threshold = similarity_threshold if similarity_threshold is not None else _query_float(request, "similarity_threshold")
    frame_id_prefix = (frame_id_prefix or _query_string(request, "frame_id_prefix") or "v").strip() or "v"
    store_path = store_path if store_path is not None else _query_string(request, "store_path")
    video_start_time = video_start_time if video_start_time is not None else _query_string(request, "video_start_time")
    debug = debug if debug is not None else _query_bool(request, "debug")

    settings = get_settings()
    fps = fps if fps is not None else settings.video_fps
    max_frames = max_frames if max_frames is not None else settings.video_max_frames
    laplacian_min = laplacian_min if laplacian_min is not None else settings.video_laplacian_min
    diff_threshold = diff_threshold if diff_threshold is not None else settings.video_diff_threshold
    ssim_threshold = ssim_threshold if ssim_threshold is not None else settings.video_ssim_threshold
    hist_threshold = hist_threshold if hist_threshold is not None else settings.video_hist_threshold

    video_absolute_start_time = parse_absolute_time(video_start_time)
    
    suffix = ""
    if video.filename and "." in video.filename:
        suffix = "." + video.filename.rsplit(".", 1)[-1]

    tmp_path = await _save_upload_to_temp(video, suffix=suffix)
    
    job_id = await core_index_video_async(
        tmp_path=tmp_path,
        cleanup_temp=True,
        fps=fps,
        max_frames=max_frames,
        laplacian_min=laplacian_min,
        diff_threshold=diff_threshold,
        ssim_threshold=ssim_threshold,
        hist_threshold=hist_threshold,
        similarity_threshold=similarity_threshold,
        frame_id_prefix=frame_id_prefix,
        video_absolute_start_time=video_absolute_start_time,
        debug=bool(debug),
        store_path=store_path,
    )
    return {"job_id": job_id}

@router.post("/index_video_async_by_path")
async def index_video_async_by_path(req: IndexVideoPathRequest):
    settings = get_settings()
    fps = req.fps if req.fps is not None else settings.video_fps
    max_frames = req.max_frames if req.max_frames is not None else settings.video_max_frames
    laplacian_min = req.laplacian_min if req.laplacian_min is not None else settings.video_laplacian_min
    diff_threshold = req.diff_threshold if req.diff_threshold is not None else settings.video_diff_threshold
    ssim_threshold = req.ssim_threshold if req.ssim_threshold is not None else settings.video_ssim_threshold
    hist_threshold = req.hist_threshold if req.hist_threshold is not None else settings.video_hist_threshold
    
    video_path = str(req.video_path or "").strip()
    if not video_path:
        raise HTTPException(status_code=400, detail="video_path is required")
    if not os.path.isfile(video_path):
        raise HTTPException(status_code=404, detail=f"video not found: {video_path}")
    
    video_absolute_start_time = parse_absolute_time(req.video_start_time)
    
    job_id = await core_index_video_async(
        tmp_path=video_path,
        cleanup_temp=False,
        fps=float(fps),
        max_frames=max_frames,
        laplacian_min=float(laplacian_min),
        diff_threshold=float(diff_threshold),
        ssim_threshold=float(ssim_threshold),
        hist_threshold=float(hist_threshold),
        similarity_threshold=req.similarity_threshold,
        frame_id_prefix=req.frame_id_prefix or "v",
        video_absolute_start_time=video_absolute_start_time,
        debug=bool(req.debug),
        store_path=req.store_path,
    )
    return {"job_id": job_id}

@router.post("/add")
async def add_frames(req: AddFramesRequest, store_path: Optional[str] = Query(default=None)):
    if not req.frames:
        raise HTTPException(status_code=400, detail="frames is empty")
    store = get_store(persist_path=store_path)
    ts = [float(f.t) for f in req.frames]
    absolute_ts = [float(f.absolute_t) if f.absolute_t is not None else None for f in req.frames]
    imgs = [f.image_base64 for f in req.frames]
    fids = [f.frame_id for f in req.frames]
    recs = await store.add_frames(ts=ts, images_base64=imgs, frame_ids=fids, absolute_ts=absolute_ts)
    await store.apply_retention_policy()
    kept_ids = {f.frame_id for f in await store.list_frames()}
    recs = [r for r in recs if r.frame_id in kept_ids]
    out = [{"frame_id": r.frame_id, "t": r.t, "absolute_t": r.absolute_t, "absolute_time_str": format_absolute_time(r.absolute_t)} for r in recs]
    return {"added": out, "count": len(out)}

@router.get("/count")
async def count_frames(store_path: Optional[str] = Query(default=None)):
    store = get_store(persist_path=store_path)
    frames = await store.list_frames()
    return {"count": len(frames)}

async def _reset_store_payload(*, store_path: Optional[str]) -> dict:
    store = get_store(persist_path=store_path)
    stats = await store.clear_with_stats()
    return {
        "cleared": int(stats["frames"]),
        "cleared_frames": int(stats["frames"]),
        "cleared_documents": int(stats["documents"]),
        "cleared_events": int(stats["events"]),
        "cleared_summaries": int(stats["summaries"]),
        "scope": "store",
        "message": "Cleared the full store, including frames and memory documents.",
    }


@router.post("/clear")
async def clear_frames(store_path: Optional[str] = Query(default=None)):
    return await _reset_store_payload(store_path=store_path)


@router.post("/reset_store")
async def reset_store(store_path: Optional[str] = Query(default=None)):
    return await _reset_store_payload(store_path=store_path)