Remove completed playback backfill tooling

Dockerfile

@@ -17,7 +17,7 @@ COPY requirements.txt ./
 RUN pip install --no-cache-dir -r requirements.txt
 COPY --from=node-build --chown=appuser:appuser /app/dist ./dist
 COPY --from=node-build --chown=appuser:appuser /app/node_modules ./node_modules
-COPY --chown=appuser:appuser package.json app.py start.py storage_listing.py playback_timing.py backfill_playback_times.py ./
+COPY --chown=appuser:appuser package.json app.py start.py storage_listing.py playback_timing.py ./
 USER appuser
 EXPOSE 7860
 CMD ["python", "start.py"]

README.md

@@ -108,8 +108,6 @@ Brevo credentials stay in Supabase SMTP settings and are not added to the browse
 
 Run `Database/add_action_playback_times.sql` in the Supabase SQL Editor before relying on saved action playback times. New completed actions store the presentation timestamps of their first frame and the frame after their last frame from the finalized camera video. Older actions remain playable using the FPS calculation until backfilled.
 
-To fill older completed sessions, run `python backfill_playback_times.py` from this directory with `SUPABASE_URL`, `SUPABASE_SERVICE_ROLE_KEY`, `STORAGE_REPO_ID`, and `HF_TOKEN` set in `Backend/.env` or the environment. Add `--session-id UUID` to process one session. The script downloads one camera video per session and updates only actions whose playback times are missing, so the first run can take time for large videos. Re-running it is safe.
-
 ## Routes
 
 - `POST /api/auth/signup` — `{ fname, lname, email, password, academy? }`; sends Supabase's confirmation email when confirmation is enabled.

app.py

@@ -17,7 +17,7 @@ from datetime import datetime, timezone
 from functools import lru_cache
 from pathlib import Path
 from urllib.request import urlretrieve
-from uuid import UUID, uuid4, uuid5
+from uuid import UUID, uuid5
 from zipfile import ZipFile
 
 import httpx
@@ -37,8 +37,6 @@ load_dotenv(Path(__file__).with_name(".env"))
 jobs = {}
 executor = ThreadPoolExecutor(max_workers=1)
 logger = logging.getLogger("sporalize")
-playback_backfill_lock = threading.Lock()
-playback_backfill_job = None
 POSE_MODEL_FILE = "Weights/rtmpose-x-halpe26.onnx"
 POSE_MODEL_REPO_ID = ""
 POSE_MODEL_HUB_FILE = "rtmpose-x-halpe26.onnx"
@@ -250,28 +248,6 @@ async def lifespan(app):
 app = FastAPI(title="Sporalize AI", lifespan=lifespan)
 
 
-def run_playback_backfill_job(job_id):
-    global playback_backfill_job
-    from backfill_playback_times import run_backfill
-
-    def update(progress):
-        global playback_backfill_job
-        with playback_backfill_lock:
-            if playback_backfill_job and playback_backfill_job.get("job_id") == job_id:
-                playback_backfill_job.update(progress)
-
-    try:
-        result = run_backfill(progress=update)
-        with playback_backfill_lock:
-            if playback_backfill_job and playback_backfill_job.get("job_id") == job_id:
-                playback_backfill_job.update(result, status="completed")
-    except Exception as error:
-        logger.exception("Server-side action playback timestamp backfill failed")
-        with playback_backfill_lock:
-            if playback_backfill_job and playback_backfill_job.get("job_id") == job_id:
-                playback_backfill_job.update(status="failed", error=str(error)[:500])
-
-
 @app.exception_handler(httpx.HTTPStatusError)
 async def backend_error(request: Request, error: httpx.HTTPStatusError):
     status = error.response.status_code
@@ -588,34 +564,6 @@ def health():
     return {"ok": True}
 
 
-@app.post("/internal/playback-backfill")
-def start_playback_backfill(request: Request, background_tasks: BackgroundTasks):
-    global playback_backfill_job
-    if not request.state.is_admin:
-        raise HTTPException(403, "Administrator access is required")
-    with playback_backfill_lock:
-        if playback_backfill_job and playback_backfill_job.get("status") == "running":
-            return {"job_id": playback_backfill_job["job_id"], "status": "running"}
-        job_id = str(uuid4())
-        playback_backfill_job = {
-            "job_id": job_id, "status": "running", "stage": "starting",
-            "sessions_total": 0, "sessions_completed": 0, "actions_total": 0,
-            "actions_updated": 0, "errors": [],
-        }
-    background_tasks.add_task(run_playback_backfill_job, job_id)
-    return {"job_id": job_id, "status": "running"}
-
-
-@app.get("/internal/playback-backfill/{job_id}")
-def playback_backfill_status(job_id: UUID, request: Request):
-    if not request.state.is_admin:
-        raise HTTPException(403, "Administrator access is required")
-    with playback_backfill_lock:
-        if not playback_backfill_job or playback_backfill_job.get("job_id") != str(job_id):
-            raise HTTPException(404, "Backfill job not found")
-        return dict(playback_backfill_job)
-
-
 @app.post("/api/drive/probe")
 def probe_drive(payload: dict):
     links = payload.get("links") or ([payload["link"]] if payload.get("link") else [])

backfill_playback_times.py

@@ -1,100 +0,0 @@
-"""Fill action playback times from the stored final MP4 videos.
-
-Run after Database/add_action_playback_times.sql:
-    python backfill_playback_times.py [--session-id UUID]
-"""
-
-import argparse
-import os
-from collections import defaultdict
-from pathlib import Path
-from tempfile import TemporaryDirectory
-
-import httpx
-from dotenv import load_dotenv
-from huggingface_hub import HfApi, hf_hub_download
-
-from playback_timing import action_times, frame_times
-from storage_listing import session_files
-
-
-def run_backfill(session_id=None, progress=None):
-    url = os.environ["SUPABASE_URL"].rstrip("/") + "/rest/v1"
-    key = os.environ["SUPABASE_SERVICE_ROLE_KEY"]
-    repo = os.environ["STORAGE_REPO_ID"]
-    token = os.environ["HF_TOKEN"]
-    hub = HfApi(token=token)
-    headers = {"apikey": key, "Authorization": f"Bearer {key}"}
-    actions = []
-    with httpx.Client(headers=headers, timeout=60) as client:
-        offset = 0
-        while True:
-            params = {"select": "action_id,session_id,start_frame,end_frame", "start_time_seconds": "is.null",
-                      "order": "action_id", "limit": "1000", "offset": str(offset)}
-            if session_id:
-                params["session_id"] = f"eq.{session_id}"
-            response = client.get(f"{url}/actions", params=params)
-            response.raise_for_status()
-            page = response.json()
-            actions.extend(page)
-            if len(page) < 1000:
-                break
-            offset += len(page)
-
-        grouped = defaultdict(list)
-        for action in actions:
-            grouped[action["session_id"]].append(action)
-        saved = 0
-        errors = []
-        sessions = list(grouped.items())
-        if progress:
-            progress({"stage": "processing", "actions_total": len(actions), "sessions_total": len(sessions),
-                      "sessions_completed": 0, "actions_updated": 0, "errors": []})
-        for index, (current_session_id, session_actions) in enumerate(sessions, start=1):
-            try:
-                response = client.get(f"{url}/sessions", params={"select": "path,status", "session_id": f"eq.{current_session_id}"})
-                response.raise_for_status()
-                session_rows = response.json()
-                if len(session_rows) != 1 or session_rows[0]["status"] != "completed" or session_rows[0]["path"] != f"sessions/{current_session_id}":
-                    raise RuntimeError("Completed session storage unavailable")
-                video_dir = f"sessions/{current_session_id}/videos"
-                files = sorted(file for file in session_files(hub, repo, video_dir)
-                               if Path(file).name.startswith("camera_") and Path(file).suffix.lower() == ".mp4")
-                if not files:
-                    raise RuntimeError("No MP4 video found")
-                with TemporaryDirectory(prefix="playback-backfill-") as cache_dir:
-                    video = hf_hub_download(repo_id=repo, repo_type="dataset", filename=files[0], token=token,
-                                            cache_dir=cache_dir)
-                    boundaries = frame_times(video)
-                    session_saved = 0
-                    for action in session_actions:
-                        times = action_times(boundaries, action["start_frame"], action["end_frame"])
-                        response = client.patch(f"{url}/actions", params={"action_id": f'eq.{action["action_id"]}',
-                                                                    "start_time_seconds": "is.null"}, json=times)
-                        response.raise_for_status()
-                        session_saved += 1
-                    saved += session_saved
-                print(f"Playback timestamp backfill: session {index}/{len(grouped)} {current_session_id} saved={session_saved}", flush=True)
-            except Exception as error:
-                errors.append({"session_id": current_session_id, "error": str(error)[:500]})
-                print(f"Playback timestamp backfill: session {index}/{len(grouped)} {current_session_id} failed={error}", flush=True)
-            if progress:
-                progress({"stage": "processing", "actions_total": len(actions), "sessions_total": len(grouped),
-                          "sessions_completed": index, "actions_updated": saved, "errors": errors.copy(),
-                          "last_session_id": current_session_id})
-        print(f"Playback timestamp backfill complete: {saved}/{len(actions)} action rows updated", flush=True)
-        return {"actions_total": len(actions), "actions_updated": saved, "sessions_total": len(grouped),
-                "sessions_completed": len(grouped), "errors": errors}
-
-
-def main():
-    load_dotenv(Path(__file__).with_name(".env"))
-    parser = argparse.ArgumentParser(description=__doc__)
-    parser.add_argument("--session-id", help="Backfill one session only")
-    args = parser.parse_args()
-    result = run_backfill(args.session_id)
-    print(f"Done: {result['actions_updated']}/{result['actions_total']} action rows updated")
-
-
-if __name__ == "__main__":
-    main()

src/analysis.ts

@@ -50,35 +50,6 @@ export function analysisRouter(db: SupabaseClient, secret: string, onCompleted?:
     next();
   });
   router.use(express.json({ limit: "2mb" }));
-  router.post("/operations/playback-backfill", async (_req, res, next) => {
-    try {
-      if (res.locals.isAdmin !== true) return res.sendStatus(403);
-      const response = await fetch(new URL("/internal/playback-backfill", env.ANALYSIS_API_URL), {
-        method: "POST", headers: {
-          "x-sporalize-proxy-secret": secret,
-          "x-sporalize-user-id": res.locals.userId as string,
-          "x-sporalize-admin": "true",
-        }, signal: AbortSignal.timeout(15_000),
-      });
-      const body = await response.json().catch(() => ({}));
-      return res.status(response.status).json(body);
-    } catch (error) { next(error); }
-  });
-  router.get("/operations/playback-backfill/:jobId", async (req, res, next) => {
-    try {
-      if (res.locals.isAdmin !== true) return res.sendStatus(403);
-      const jobId = z.uuid().parse(req.params.jobId);
-      const response = await fetch(new URL(`/internal/playback-backfill/${jobId}`, env.ANALYSIS_API_URL), {
-        headers: {
-          "x-sporalize-proxy-secret": secret,
-          "x-sporalize-user-id": res.locals.userId as string,
-          "x-sporalize-admin": "true",
-        }, signal: AbortSignal.timeout(15_000),
-      });
-      const body = await response.json().catch(() => ({}));
-      return res.status(response.status).json(body);
-    } catch (error) { next(error); }
-  });
   router.post("/", async (req, res, next) => {
     try {
       const input = beginSchema.parse(req.body);