Buckets:
| #!/usr/bin/env python | |
| """Minimal web UI for semantic act_pri annotation over LeRobot episodes. | |
| This editor keeps the existing label-store schema: | |
| - groups/episode_XXXXXX.json | |
| - per_frame/episode_XXXXXX.npy | |
| - act_pri.parquet | |
| The UI is intentionally minimal: | |
| - one episode at a time | |
| - large video player | |
| - one semantic timeline with draggable boundaries | |
| - one label dropdown for the selected segment | |
| Edits are saved immediately. Approval only marks the episode reviewed. | |
| """ | |
| from __future__ import annotations | |
| import argparse | |
| import json | |
| import mimetypes | |
| import subprocess | |
| import sys | |
| import threading | |
| import time | |
| from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer | |
| from pathlib import Path | |
| from typing import Optional | |
| from urllib.parse import parse_qs, unquote, urlparse | |
| sys.path.insert(0, str(Path(__file__).resolve().parents[1])) | |
| from tools.act_pri_common import ( # noqa: E402 | |
| TASK_TO_INDEX, | |
| canonical_primitive, | |
| clip_qwen_segments, | |
| export_act_pri_parquet, | |
| list_episode_files, | |
| load_dataset_meta, | |
| load_episode_labels, | |
| qwen_segments_for, | |
| save_episode_labels, | |
| summarize_qwen_segments, | |
| write_per_frame, | |
| ) | |
| LABELS = ["pick_grab", "fold_flatten", "dummy"] | |
| LOCK = threading.Lock() | |
| INDEX_HTML = """<!doctype html> | |
| <html> | |
| <head> | |
| <meta charset=\"utf-8\"> | |
| <meta name=\"viewport\" content=\"width=device-width,initial-scale=1\"> | |
| <title>act_pri annotator</title> | |
| <style> | |
| :root { --bg:#f4efe5; --ink:#181b1f; --muted:#67707c; --line:#d7cbbb; --card:#fffdf8; --pick:#d95d39; --fold:#2f7ea1; --place:#3f9d5b; --dummy:#858585; --sel:#111; } | |
| * { box-sizing:border-box; } | |
| body { margin:0; background:linear-gradient(180deg,#f7f4ee 0%,#efe8dc 100%); color:var(--ink); font:14px/1.4 ui-sans-serif,system-ui,-apple-system,sans-serif; } | |
| header { padding:10px 14px; display:flex; gap:10px; align-items:center; border-bottom:1px solid var(--line); background:rgba(255,253,248,0.94); } | |
| select { font:inherit; border:1px solid var(--line); border-radius:10px; background:#fff; padding:8px 10px; } | |
| button { font:inherit; border:1px solid var(--line); border-radius:10px; background:#fff; padding:8px 10px; cursor:pointer; } | |
| .status { min-width:220px; color:var(--muted); } | |
| main { max-width:1180px; margin:0 auto; padding:18px 16px 24px; } | |
| .stage { background:var(--card); border:1px solid var(--line); border-radius:18px; padding:16px; box-shadow:0 10px 30px rgba(0,0,0,0.04); } | |
| video { width:100%; max-height:72vh; background:#000; border-radius:14px; display:block; } | |
| .meta { display:grid; grid-template-columns:1fr 1fr; gap:10px; margin:12px 0 10px; } | |
| .panel { background:#fff; border:1px solid var(--line); border-radius:14px; padding:10px 12px; } | |
| .big { font-size:20px; font-weight:700; } | |
| .muted { color:var(--muted); } | |
| .timelineWrap { position:relative; margin-top:6px; padding:10px 0 4px; } | |
| .timeline { position:relative; height:82px; background:#ece4d6; border:1px solid var(--line); border-radius:16px; overflow:hidden; user-select:none; touch-action:none; } | |
| .timelineTrack { position:absolute; inset:0; } | |
| .seg { position:absolute; top:0; bottom:0; border-right:1px solid rgba(255,255,255,0.7); display:flex; align-items:flex-end; justify-content:flex-start; padding:8px 10px; font-weight:700; color:#fff; letter-spacing:0.01em; cursor:pointer; } | |
| .seg.pick_grab { background:var(--pick); } | |
| .seg.fold_flatten { background:var(--fold); } | |
| .seg.place { background:var(--place); } | |
| .seg.dummy { background:var(--dummy); } | |
| .seg.selected { box-shadow:inset 0 0 0 3px var(--sel); z-index:2; } | |
| .seg span { pointer-events:none; text-shadow:0 1px 2px rgba(0,0,0,0.22); white-space:nowrap; overflow:hidden; text-overflow:ellipsis; max-width:100%; } | |
| .handle { position:absolute; top:-2px; bottom:-2px; width:18px; margin-left:-9px; border-radius:9px; background:#fff; border:2px solid #111; box-shadow:0 2px 12px rgba(0,0,0,0.18); cursor:ew-resize; z-index:4; } | |
| .handle::after { content:''; position:absolute; top:14px; bottom:14px; left:50%; width:2px; transform:translateX(-50%); background:#111; } | |
| .playhead { position:absolute; top:1px; bottom:1px; width:3px; margin-left:-1px; background:#111; z-index:6; pointer-events:none; box-shadow:0 0 0 1px rgba(255,255,255,0.35); } | |
| .ticks { display:flex; justify-content:space-between; margin-top:8px; font-size:12px; color:var(--muted); } | |
| .controls { margin-top:10px; display:flex; gap:10px; align-items:center; flex-wrap:wrap; } | |
| @media (max-width: 860px) { | |
| .meta { grid-template-columns:1fr; } | |
| .big { font-size:18px; } | |
| } | |
| </style> | |
| </head> | |
| <body> | |
| <header> | |
| <strong>act_pri</strong> | |
| <span id=\"status\" class=\"status\"></span> | |
| </header> | |
| <main> | |
| <section class=\"stage\"> | |
| <video id=\"video\" controls preload=\"metadata\"></video> | |
| <div class=\"meta\"> | |
| <div class=\"panel\"> | |
| <div class=\"big\" id=\"frameNow\">frame 0 / 0</div> | |
| <div class=\"muted\" id=\"timeNow\">0.00s / 0.00s</div> | |
| </div> | |
| <div class=\"panel\" id=\"selectionInfo\">No segment selected.</div> | |
| </div> | |
| <div class=\"timelineWrap\"> | |
| <div class="timeline" id="timeline"> | |
| <div class="timelineTrack" id="timelineTrack"></div> | |
| <div class="playhead" id="playhead"></div> | |
| </div> | |
| <div class=\"ticks\"><span>start</span><span>episode progress</span><span>end</span></div> | |
| </div> | |
| <div class="controls"> | |
| <select id="episode"></select> | |
| <select id="label"></select> | |
| <button id="splitHere" type="button" title="Split at playhead using selected label">Add section</button> | |
| </div> | |
| </section> | |
| </main> | |
| <script> | |
| const $ = (id) => document.getElementById(id); | |
| const LABELS = ['pick_grab', 'fold_flatten', 'dummy']; | |
| let STORE = ''; | |
| let STATE = null; | |
| let EP = null; | |
| let CUR = 0; | |
| let DRAG = null; | |
| let LOAD_SEQ = 0; | |
| function say(msg){ $('status').textContent = msg; } | |
| function clamp(v, lo, hi){ | |
| if(!Number.isFinite(v)) return lo; | |
| return Math.max(lo, Math.min(hi, v)); | |
| } | |
| async function api(path, method='GET', body=null){ | |
| const res = await fetch(path, { | |
| method, | |
| headers: {'Content-Type':'application/json'}, | |
| body: body ? JSON.stringify(body) : null, | |
| }); | |
| if(!res.ok){ throw new Error(await res.text()); } | |
| return await res.json(); | |
| } | |
| function selectedSegment(){ | |
| return EP && EP.groups.length ? EP.groups[CUR] : null; | |
| } | |
| function frameToVideoTime(frame){ | |
| const start = Number(EP && EP.video_start_time); | |
| return (Number.isFinite(start) ? start : 0) + (frame / EP.fps); | |
| } | |
| function currentFrame(){ | |
| if(!EP) return 0; | |
| const t = Number($('video').currentTime); | |
| if(!Number.isFinite(t)) return 0; | |
| const start = Number(EP.video_start_time); | |
| const safeStart = Number.isFinite(start) ? start : 0; | |
| const raw = Math.round((t - safeStart) * EP.fps); | |
| return clamp(raw, 0, EP.num_frames - 1); | |
| } | |
| function refreshReadout(){ | |
| if(!EP){ | |
| $('frameNow').textContent = 'frame 0 / 0'; | |
| $('timeNow').textContent = '0.00s / 0.00s'; | |
| $('playhead').style.left = '0%'; | |
| return; | |
| } | |
| const frame = currentFrame(); | |
| $('frameNow').textContent = `frame ${frame} / ${EP.num_frames - 1}`; | |
| $('timeNow').textContent = `${(frame / EP.fps).toFixed(2)}s / ${(EP.num_frames / EP.fps).toFixed(2)}s`; | |
| $('playhead').style.left = `${100 * frame / Math.max(1, EP.num_frames - 1)}%`; | |
| } | |
| function renderHeader(){ | |
| if(!STATE || !STATE.episodes.length){ | |
| $('episode').innerHTML = ''; | |
| $('label').innerHTML = LABELS.map((label) => `<option value=\"${label}\">${label}</option>`).join(''); | |
| $('splitHere').disabled = true; | |
| return; | |
| } | |
| $('episode').innerHTML = STATE.episodes | |
| .map((item) => `<option value="${item.episode_index}" ${EP && item.episode_index===EP.episode_index?'selected':''}>ep ${String(item.episode_index).padStart(6,'0')}</option>`) | |
| .join(''); | |
| $('label').innerHTML = LABELS.map((label) => `<option value=\"${label}\">${label}</option>`).join(''); | |
| $('splitHere').disabled = !EP; | |
| const seg = selectedSegment(); | |
| if(seg){ | |
| $('label').value = seg.label; | |
| } | |
| } | |
| function renderInfo(){ | |
| if(!EP){ | |
| $('selectionInfo').innerHTML = 'No segment selected.'; | |
| return; | |
| } | |
| const seg = selectedSegment(); | |
| if(!seg){ | |
| $('selectionInfo').innerHTML = `Episode ${EP.episode_index} · ${EP.num_frames} frames`; | |
| return; | |
| } | |
| $('selectionInfo').innerHTML = `<strong>${seg.label}</strong><br><span class=\"muted\">segment ${CUR + 1}/${EP.groups.length} · frames ${seg.start_frame}-${seg.end_frame}</span>`; | |
| } | |
| function boundaryFrame(leftIndex){ | |
| if(DRAG && DRAG.leftIndex === leftIndex) return DRAG.frame; | |
| return EP.groups[leftIndex].end_frame; | |
| } | |
| function renderTimeline(){ | |
| if(!EP){ | |
| $('timelineTrack').innerHTML = ''; | |
| return; | |
| } | |
| const n = Math.max(1, EP.num_frames); | |
| const html = []; | |
| for(let i = 0; i < EP.groups.length; i++){ | |
| const g = EP.groups[i]; | |
| const left = 100 * g.start_frame / n; | |
| const width = 100 * (g.end_frame - g.start_frame + 1) / n; | |
| html.push(`<div class=\"seg ${g.label} ${i===CUR?'selected':''}\" data-i=\"${i}\" style=\"left:${left}%;width:${Math.max(width, 0.45)}%\"><span>${g.label}</span></div>`); | |
| } | |
| for(let i = 0; i < EP.groups.length - 1; i++){ | |
| const left = 100 * boundaryFrame(i) / n; | |
| html.push(`<div class=\"handle\" data-left=\"${i}\" style=\"left:${left}%\"></div>`); | |
| } | |
| $('timelineTrack').innerHTML = html.join(''); | |
| for(const segEl of $('timelineTrack').querySelectorAll('.seg')){ | |
| segEl.onclick = () => { | |
| CUR = Number(segEl.dataset.i); | |
| renderHeader(); | |
| renderInfo(); | |
| renderTimeline(); | |
| refreshReadout(); | |
| }; | |
| } | |
| for(const handle of $('timelineTrack').querySelectorAll('.handle')){ | |
| handle.onpointerdown = (event) => { | |
| event.preventDefault(); | |
| DRAG = { leftIndex: Number(handle.dataset.left), frame: boundaryFrame(Number(handle.dataset.left)) }; | |
| handle.setPointerCapture(event.pointerId); | |
| }; | |
| } | |
| refreshReadout(); | |
| } | |
| function render(){ | |
| renderHeader(); | |
| renderInfo(); | |
| renderTimeline(); | |
| refreshReadout(); | |
| } | |
| function hydrateEpisodeFromPost(nextEpisode, prevEpisode){ | |
| const out = nextEpisode || {}; | |
| if(prevEpisode){ | |
| if(!out.camera) out.camera = prevEpisode.camera; | |
| if(!Array.isArray(out.cameras)) out.cameras = prevEpisode.cameras; | |
| if(!out.video_path) out.video_path = prevEpisode.video_path; | |
| if(!Number.isFinite(Number(out.video_start_time))) out.video_start_time = prevEpisode.video_start_time; | |
| if(!out.store) out.store = prevEpisode.store; | |
| } | |
| return out; | |
| } | |
| async function loadState(){ | |
| STATE = await api('/api/state'); | |
| STORE = STATE.store; | |
| if(!STATE.episodes.length){ | |
| EP = null; | |
| render(); | |
| say('No labeled episodes in this store'); | |
| return; | |
| } | |
| const keep = EP ? Number(EP.episode_index) : Number(STATE.episodes[0].episode_index); | |
| const exists = STATE.episodes.some((item) => Number(item.episode_index) === keep); | |
| const pick = exists ? keep : Number(STATE.episodes[0].episode_index); | |
| await loadEpisode(pick); | |
| } | |
| async function loadEpisode(epIndex){ | |
| const seq = ++LOAD_SEQ; | |
| const video = $('video'); | |
| video.pause(); | |
| video.removeAttribute('src'); | |
| video.load(); | |
| EP = null; | |
| CUR = 0; | |
| DRAG = null; | |
| render(); | |
| const episode = await api(`/api/episode/${epIndex}?store=${encodeURIComponent(STORE)}`); | |
| if(seq !== LOAD_SEQ){ | |
| return; | |
| } | |
| EP = episode; | |
| CUR = 0; | |
| DRAG = null; | |
| render(); | |
| video.dataset.loadSeq = String(seq); | |
| video.src = `/video/${EP.episode_index}?store=${encodeURIComponent(STORE)}&camera=${encodeURIComponent(EP.camera)}&ts=${Date.now()}`; | |
| say(`Episode ${EP.episode_index} loaded`); | |
| } | |
| async function updateEpisodeFrom(path, body, message){ | |
| const targetEpisode = Number(body.episode); | |
| const targetStore = String(body.store || STORE); | |
| const prevEpisode = EP ? {...EP} : null; | |
| const out = await api(path, 'POST', body); | |
| if(!EP || Number(EP.episode_index) !== targetEpisode || STORE !== targetStore){ | |
| return; | |
| } | |
| EP = hydrateEpisodeFromPost(out.episode, prevEpisode); | |
| CUR = clamp(out.selected_segment_id ?? CUR, 0, Math.max(0, EP.groups.length - 1)); | |
| DRAG = null; | |
| render(); | |
| say(message); | |
| } | |
| async function addSectionAtFrame(frame, label){ | |
| if(!EP || !label) return; | |
| const segIndex = EP.groups.findIndex((g) => frame >= g.start_frame && frame <= g.end_frame); | |
| if(segIndex < 0){ | |
| say('Move playhead inside a section before adding'); | |
| return; | |
| } | |
| CUR = segIndex; | |
| const seg = selectedSegment(); | |
| if(!seg) return; | |
| if(frame <= seg.start_frame || frame > seg.end_frame){ | |
| say('Move playhead inside selected section before adding'); | |
| return; | |
| } | |
| const targetEpisode = Number(EP.episode_index); | |
| const targetStore = String(STORE); | |
| const prevEpisode = EP ? {...EP} : null; | |
| const splitOut = await api('/api/segment/split', 'POST', { | |
| store: STORE, | |
| episode: EP.episode_index, | |
| segment_id: CUR, | |
| split_frame: frame, | |
| }); | |
| if(!EP || Number(EP.episode_index) !== targetEpisode || STORE !== targetStore){ | |
| return; | |
| } | |
| EP = hydrateEpisodeFromPost(splitOut.episode, prevEpisode); | |
| CUR = clamp((splitOut.selected_segment_id ?? CUR) + 1, 0, Math.max(0, EP.groups.length - 1)); | |
| DRAG = null; | |
| render(); | |
| await updateEpisodeFrom('/api/segment/label', { | |
| store: STORE, | |
| episode: EP.episode_index, | |
| segment_id: CUR, | |
| label, | |
| }, `Section added: ${label}`); | |
| } | |
| async function setLabel(label){ | |
| if(!EP || !selectedSegment()) return; | |
| await updateEpisodeFrom('/api/segment/label', { | |
| store: STORE, | |
| episode: EP.episode_index, | |
| segment_id: CUR, | |
| label, | |
| }, 'Label updated'); | |
| } | |
| async function moveBoundary(leftIndex, frame){ | |
| if(!EP) return; | |
| await updateEpisodeFrom('/api/segment/boundary', { | |
| store: STORE, | |
| episode: EP.episode_index, | |
| left_segment_id: leftIndex, | |
| boundary_frame: frame, | |
| }, 'Boundary updated'); | |
| } | |
| function frameFromPointer(clientX, leftIndex){ | |
| const rect = $('timeline').getBoundingClientRect(); | |
| const ratio = clamp((clientX - rect.left) / rect.width, 0, 1); | |
| const g0 = EP.groups[leftIndex]; | |
| const g1 = EP.groups[leftIndex + 1]; | |
| const guess = Math.round(ratio * (EP.num_frames - 1)); | |
| return clamp(guess, g0.start_frame, g1.end_frame - 1); | |
| } | |
| window.addEventListener('pointermove', (event) => { | |
| if(!DRAG || !EP) return; | |
| DRAG.frame = frameFromPointer(event.clientX, DRAG.leftIndex); | |
| renderTimeline(); | |
| refreshReadout(); | |
| }); | |
| window.addEventListener('pointerup', async (event) => { | |
| if(!DRAG || !EP) return; | |
| const drag = DRAG; | |
| DRAG = null; | |
| renderTimeline(); | |
| try { | |
| await moveBoundary(drag.leftIndex, frameFromPointer(event.clientX, drag.leftIndex)); | |
| } catch (err) { | |
| say('Error: ' + err.message); | |
| } | |
| }); | |
| $('episode').onchange = () => loadEpisode(Number($('episode').value)).catch((err) => say('Error: ' + err.message)); | |
| $('label').onchange = () => setLabel($('label').value).catch((err) => say('Error: ' + err.message)); | |
| $('splitHere').onclick = async () => { | |
| if(!EP) return; | |
| const label = $('label').value; | |
| await addSectionAtFrame(currentFrame(), label).catch((err) => say('Error: ' + err.message)); | |
| }; | |
| $('video').addEventListener('loadedmetadata', () => { | |
| if(!EP) return; | |
| if(Number($('video').dataset.loadSeq || '0') !== LOAD_SEQ) return; | |
| $('video').currentTime = EP.video_start_time; | |
| refreshReadout(); | |
| }); | |
| $('video').addEventListener('timeupdate', refreshReadout); | |
| $('video').addEventListener('seeked', refreshReadout); | |
| document.addEventListener('keydown', (event) => { | |
| if(!EP) return; | |
| if(event.target.tagName === 'SELECT') return; | |
| if(event.code === 'Space'){ | |
| event.preventDefault(); | |
| if($('video').paused) $('video').play(); else $('video').pause(); | |
| return; | |
| } | |
| if(event.code === 'ArrowLeft'){ | |
| event.preventDefault(); | |
| $('video').pause(); | |
| $('video').currentTime = frameToVideoTime(clamp(currentFrame() - 1, 0, EP.num_frames - 1)); | |
| return; | |
| } | |
| if(event.code === 'ArrowRight'){ | |
| event.preventDefault(); | |
| $('video').pause(); | |
| $('video').currentTime = frameToVideoTime(clamp(currentFrame() + 1, 0, EP.num_frames - 1)); | |
| } | |
| }); | |
| loadState().catch((err) => say('Error: ' + err.message)); | |
| </script> | |
| </body> | |
| </html> | |
| """ | |
| def _normalize_group(group: dict, fps: float, segment_id: int) -> dict: | |
| label = canonical_primitive(group.get("label")) or "dummy" | |
| start_frame = int(group["start_frame"]) | |
| end_frame = int(group["end_frame"]) | |
| qwen_spans = clip_qwen_segments(qwen_segments_for(group), start_frame, end_frame) | |
| qwen_label, qwen_conf = summarize_qwen_segments(qwen_spans) | |
| source = group.get("source") | |
| modified = bool(group.get("modified", label != qwen_label)) | |
| if source not in ("qwen", "human"): | |
| source = "human" if modified or label != qwen_label else "qwen" | |
| reviewed = bool(group.get("reviewed", source == "human")) | |
| out = dict(group) | |
| out.update( | |
| { | |
| "segment_id": segment_id, | |
| "group_index": segment_id, | |
| "start_frame": start_frame, | |
| "end_frame": end_frame, | |
| "num_frames": max(0, end_frame - start_frame + 1), | |
| "start_time": round(start_frame / fps, 3), | |
| "end_time": round(end_frame / fps, 3), | |
| "label": label, | |
| "label_index": TASK_TO_INDEX[label], | |
| "qwen_label": qwen_label, | |
| "qwen_label_index": TASK_TO_INDEX[qwen_label], | |
| "qwen_confidence": qwen_conf, | |
| "pred": qwen_label, | |
| "pred_index": TASK_TO_INDEX[qwen_label], | |
| "qwen_segments": qwen_spans, | |
| "source": source, | |
| "modified": modified or label != qwen_label, | |
| "reviewed": reviewed, | |
| } | |
| ) | |
| return out | |
| def _normalize_payload(payload: dict) -> dict: | |
| fps = float(payload.get("fps", 15.0)) | |
| groups = sorted(payload.get("groups") or [], key=lambda g: int(g["start_frame"])) | |
| normalized = [_normalize_group(g, fps, i) for i, g in enumerate(groups)] | |
| payload["groups"] = normalized | |
| return payload | |
| def _episode_summary(payload: dict) -> dict: | |
| return { | |
| "episode_index": int(payload["episode_index"]), | |
| "num_groups": len(payload["groups"]), | |
| "num_frames": int(payload["num_frames"]), | |
| "modified": sum(1 for g in payload["groups"] if g.get("modified")), | |
| "approved": bool(payload.get("approved", False)), | |
| } | |
| def _set_group_bounds(group: dict, start_frame: int, end_frame: int) -> None: | |
| group["start_frame"] = int(start_frame) | |
| group["end_frame"] = int(end_frame) | |
| group["qwen_segments"] = clip_qwen_segments(qwen_segments_for(group), int(start_frame), int(end_frame)) | |
| class AnnotateHandler(BaseHTTPRequestHandler): | |
| labels_dir: Path = Path("act_pri_labels") | |
| dataset_root: Optional[Path] = None | |
| default_camera: Optional[str] = None | |
| def log_message(self, fmt, *args): | |
| if self.path.startswith("/api"): | |
| sys.stderr.write("%s - %s\n" % (self.address_string(), fmt % args)) | |
| def stores(cls) -> dict[str, Path]: | |
| root = cls.labels_dir | |
| if (root / "groups").is_dir(): | |
| return {root.name: root} | |
| return { | |
| child.name: child | |
| for child in sorted(root.iterdir()) | |
| if child.is_dir() and (child / "groups").is_dir() | |
| } | |
| def _store(self, name: Optional[str]) -> Path: | |
| stores = self.stores() | |
| if name and name in stores: | |
| return stores[name] | |
| return next(iter(stores.values())) | |
| def _json(self, payload: dict, code: int = 200): | |
| body = json.dumps(payload).encode("utf-8") | |
| self.send_response(code) | |
| self.send_header("Content-Type", "application/json") | |
| self.send_header("Content-Length", str(len(body))) | |
| self.end_headers() | |
| self.wfile.write(body) | |
| def _error(self, code: int, msg: str): | |
| body = msg.encode("utf-8") | |
| self.send_response(code) | |
| self.send_header("Content-Type", "text/plain; charset=utf-8") | |
| self.send_header("Content-Length", str(len(body))) | |
| self.end_headers() | |
| self.wfile.write(body) | |
| def _meta_for_store(self, store: Path): | |
| root = self.dataset_root | |
| if root is None: | |
| first = next(iter(list_episode_files(store)), None) | |
| if first is not None: | |
| payload = json.loads(first.read_text()) | |
| root_path = payload.get("dataset_root") | |
| if root_path: | |
| root = Path(root_path) | |
| if root is None: | |
| return None | |
| return load_dataset_meta(root) | |
| def _read_episode(self, store: Path, ep: int) -> dict: | |
| return _normalize_payload(load_episode_labels(store, ep)) | |
| def _save_episode(self, store: Path, payload: dict): | |
| payload = _normalize_payload(payload) | |
| save_episode_labels(store, payload) | |
| write_per_frame(store, payload) | |
| export_act_pri_parquet(store, self.dataset_root) | |
| def _episode_clip_path(self, store: Path, meta, ep: int, cam: str) -> Path: | |
| """Return a local per-episode mp4 clip for stable 0-based playback.""" | |
| clip_dir = store / ".video_cache" / cam | |
| clip_dir.mkdir(parents=True, exist_ok=True) | |
| out_path = clip_dir / f"episode_{ep:06d}.mp4" | |
| if out_path.is_file() and out_path.stat().st_size > 0: | |
| return out_path | |
| episode = meta.episode(ep) | |
| ref = episode.videos[cam] | |
| duration = max(0.001, float(episode.length) / float(meta.fps)) | |
| tmp_path = out_path.with_suffix(".tmp.mp4") | |
| cmd = [ | |
| "ffmpeg", | |
| "-hide_banner", | |
| "-loglevel", | |
| "error", | |
| "-y", | |
| "-ss", | |
| f"{float(ref.start_time):.6f}", | |
| "-i", | |
| str(ref.path), | |
| "-t", | |
| f"{duration:.6f}", | |
| "-an", | |
| "-c:v", | |
| "libx264", | |
| "-preset", | |
| "ultrafast", | |
| "-crf", | |
| "22", | |
| "-movflags", | |
| "+faststart", | |
| str(tmp_path), | |
| ] | |
| try: | |
| subprocess.run(cmd, check=True, capture_output=True, text=True) | |
| except FileNotFoundError as exc: | |
| raise RuntimeError("ffmpeg not found; cannot prepare episode clip") from exc | |
| except subprocess.CalledProcessError as exc: | |
| stderr = (exc.stderr or "").strip() | |
| raise RuntimeError(f"ffmpeg clip failed: {stderr[-400:]}") from exc | |
| tmp_path.replace(out_path) | |
| return out_path | |
| def _serve_file(self, path: Path): | |
| if not path.exists(): | |
| self._error(404, "file not found") | |
| return | |
| size = path.stat().st_size | |
| start = 0 | |
| end = size - 1 | |
| status = 200 | |
| range_header = self.headers.get("Range") | |
| if range_header and range_header.startswith("bytes="): | |
| raw = range_header.split("=", 1)[1].split(",", 1)[0] | |
| start_s, end_s = raw.split("-", 1) | |
| if start_s: | |
| start = int(start_s) | |
| if end_s: | |
| end = min(int(end_s), size - 1) | |
| status = 206 | |
| length = max(0, end - start + 1) | |
| ctype = mimetypes.guess_type(path.name)[0] or "application/octet-stream" | |
| self.send_response(status) | |
| self.send_header("Content-Type", ctype) | |
| self.send_header("Accept-Ranges", "bytes") | |
| self.send_header("Content-Length", str(length)) | |
| self.send_header("Cache-Control", "no-cache") | |
| if status == 206: | |
| self.send_header("Content-Range", f"bytes {start}-{end}/{size}") | |
| self.end_headers() | |
| with path.open("rb") as handle: | |
| handle.seek(start) | |
| remaining = length | |
| while remaining > 0: | |
| chunk = handle.read(min(1024 * 1024, remaining)) | |
| if not chunk: | |
| break | |
| self.wfile.write(chunk) | |
| remaining -= len(chunk) | |
| def do_GET(self): # noqa: N802 | |
| path = unquote(urlparse(self.path).path) | |
| query = parse_qs(urlparse(self.path).query) | |
| store = self._store((query.get("store") or [None])[0]) | |
| if path in ("/", "/index.html"): | |
| body = INDEX_HTML.encode("utf-8") | |
| self.send_response(200) | |
| self.send_header("Content-Type", "text/html; charset=utf-8") | |
| self.send_header("Content-Length", str(len(body))) | |
| self.end_headers() | |
| self.wfile.write(body) | |
| return | |
| if path == "/api/state": | |
| episodes = [] | |
| for file_path in list_episode_files(store): | |
| episodes.append(_episode_summary(_normalize_payload(json.loads(file_path.read_text())))) | |
| episodes.sort(key=lambda item: item["episode_index"]) | |
| self._json( | |
| { | |
| "store": store.name, | |
| "stores": list(self.stores().keys()), | |
| "labels": LABELS, | |
| "episodes": episodes, | |
| } | |
| ) | |
| return | |
| if path.startswith("/api/episode/"): | |
| try: | |
| ep = int(path.rsplit("/", 1)[1]) | |
| payload = self._read_episode(store, ep) | |
| meta = self._meta_for_store(store) | |
| camera = (query.get("camera") or [None])[0] | |
| if meta is not None: | |
| cams = list(meta.camera_keys) | |
| if camera not in cams: | |
| camera = self.default_camera if self.default_camera in cams else cams[0] | |
| ref = meta.episode(ep).videos[camera] | |
| payload["camera"] = camera | |
| payload["cameras"] = cams | |
| payload["video_path"] = str(ref.path) | |
| payload["video_start_time"] = 0.0 | |
| else: | |
| payload["camera"] = "" | |
| payload["cameras"] = [] | |
| payload["video_path"] = "" | |
| payload["video_start_time"] = 0.0 | |
| payload["store"] = store.name | |
| self._json(payload) | |
| except Exception as exc: | |
| self._error(404, f"episode not found: {exc}") | |
| return | |
| if path.startswith("/video/"): | |
| try: | |
| ep = int(path.rsplit("/", 1)[1]) | |
| meta = self._meta_for_store(store) | |
| if meta is None: | |
| self._error(404, "dataset metadata unavailable") | |
| return | |
| cam = (query.get("camera") or [None])[0] or meta.camera_keys[0] | |
| clip_path = self._episode_clip_path(store, meta, ep, cam) | |
| self._serve_file(clip_path) | |
| except Exception as exc: | |
| self._error(404, f"video error: {exc}") | |
| return | |
| self._error(404, "not found") | |
| def do_POST(self): # noqa: N802 | |
| path = unquote(urlparse(self.path).path) | |
| length = int(self.headers.get("Content-Length") or 0) | |
| body = json.loads(self.rfile.read(length) or b"{}") if length else {} | |
| store = self._store(body.get("store")) | |
| try: | |
| if path == "/api/segment/label": | |
| self._label(store, body) | |
| return | |
| if path == "/api/segment/boundary": | |
| self._boundary(store, body) | |
| return | |
| if path == "/api/segment/split": | |
| self._split(store, body) | |
| return | |
| if path == "/api/episode/save": | |
| self._save(store, body) | |
| return | |
| if path == "/api/episode/approve": | |
| self._approve(store, body) | |
| return | |
| except Exception as exc: | |
| self._error(400, str(exc)) | |
| return | |
| self._error(404, "not found") | |
| def _label(self, store: Path, body: dict): | |
| ep = int(body["episode"]) | |
| seg = int(body["segment_id"]) | |
| label = canonical_primitive(body.get("label")) | |
| if label not in LABELS: | |
| raise ValueError(f"label must be one of {LABELS}") | |
| with LOCK: | |
| payload = self._read_episode(store, ep) | |
| group = payload["groups"][seg] | |
| group["label"] = label | |
| group["source"] = "qwen" if label == group["qwen_label"] and len(group.get("qwen_segments") or []) == 1 else "human" | |
| group["reviewed"] = True | |
| self._save_episode(store, payload) | |
| payload = self._read_episode(store, ep) | |
| selected = min(seg, len(payload["groups"]) - 1) | |
| self._json({"episode": payload, "selected_segment_id": selected}) | |
| def _boundary(self, store: Path, body: dict): | |
| ep = int(body["episode"]) | |
| left = int(body["left_segment_id"]) | |
| boundary = int(body["boundary_frame"]) | |
| with LOCK: | |
| payload = self._read_episode(store, ep) | |
| groups = payload["groups"] | |
| if left < 0 or left >= len(groups) - 1: | |
| raise ValueError("left_segment_id must have a right neighbor") | |
| g0 = groups[left] | |
| g1 = groups[left + 1] | |
| lo = int(g0["start_frame"]) | |
| hi = int(g1["end_frame"]) - 1 | |
| if not (lo <= boundary <= hi): | |
| raise ValueError(f"boundary must be in [{lo}, {hi}]") | |
| _set_group_bounds(g0, int(g0["start_frame"]), boundary) | |
| _set_group_bounds(g1, boundary + 1, int(g1["end_frame"])) | |
| g0["source"] = "human" | |
| g1["source"] = "human" | |
| g0["reviewed"] = True | |
| g1["reviewed"] = True | |
| self._save_episode(store, payload) | |
| payload = self._read_episode(store, ep) | |
| selected = min(left, len(payload["groups"]) - 1) | |
| self._json({"episode": payload, "selected_segment_id": selected}) | |
| def _split(self, store: Path, body: dict): | |
| ep = int(body["episode"]) | |
| seg = int(body["segment_id"]) | |
| split_frame = int(body["split_frame"]) | |
| with LOCK: | |
| payload = self._read_episode(store, ep) | |
| groups = payload["groups"] | |
| group = groups[seg] | |
| start_frame = int(group["start_frame"]) | |
| end_frame = int(group["end_frame"]) | |
| if split_frame <= start_frame or split_frame > end_frame: | |
| raise ValueError(f"split_frame must be in ({start_frame}, {end_frame}]") | |
| left = dict(group) | |
| right = dict(group) | |
| _set_group_bounds(left, start_frame, split_frame - 1) | |
| _set_group_bounds(right, split_frame, end_frame) | |
| left["source"] = "human" | |
| right["source"] = "human" | |
| left["reviewed"] = True | |
| right["reviewed"] = True | |
| groups[seg : seg + 1] = [left, right] | |
| self._save_episode(store, payload) | |
| payload = self._read_episode(store, ep) | |
| selected = min(seg, len(payload["groups"]) - 1) | |
| self._json({"episode": payload, "selected_segment_id": selected}) | |
| def _approve(self, store: Path, body: dict): | |
| ep = int(body["episode"]) | |
| with LOCK: | |
| payload = self._read_episode(store, ep) | |
| payload["approved"] = True | |
| payload["approved_at"] = time.strftime("%Y-%m-%dT%H:%M:%S") | |
| for group in payload["groups"]: | |
| group["reviewed"] = True | |
| if group["label"] != group["qwen_label"] or len(group.get("qwen_segments") or []) > 1: | |
| group["source"] = "human" | |
| self._save_episode(store, payload) | |
| payload = self._read_episode(store, ep) | |
| self._json({"episode": payload, "selected_segment_id": 0}) | |
| def _save(self, store: Path, body: dict): | |
| ep = int(body["episode"]) | |
| with LOCK: | |
| payload = self._read_episode(store, ep) | |
| payload["saved_at"] = time.strftime("%Y-%m-%dT%H:%M:%S") | |
| self._save_episode(store, payload) | |
| payload = self._read_episode(store, ep) | |
| self._json({"episode": payload, "selected_segment_id": 0}) | |
| def main() -> None: | |
| ap = argparse.ArgumentParser( | |
| description="Minimal timeline editor for act_pri semantic segments.", | |
| formatter_class=argparse.ArgumentDefaultsHelpFormatter, | |
| ) | |
| ap.add_argument("--labels-dir", default="act_pri_labels") | |
| ap.add_argument("--dataset-root", default=None, help="LeRobot dataset root for video playback") | |
| ap.add_argument("--camera", default=None, help="default camera key") | |
| ap.add_argument("--host", default="127.0.0.1") | |
| ap.add_argument("--port", type=int, default=8000) | |
| args = ap.parse_args() | |
| labels_dir = Path(args.labels_dir).expanduser().resolve() | |
| AnnotateHandler.labels_dir = labels_dir | |
| AnnotateHandler.default_camera = args.camera | |
| if args.dataset_root: | |
| AnnotateHandler.dataset_root = Path(args.dataset_root).expanduser().resolve() | |
| stores = AnnotateHandler.stores() | |
| if not stores: | |
| raise SystemExit(f"{labels_dir} has no groups/*.json label store") | |
| total_eps = sum(len(list_episode_files(store)) for store in stores.values()) | |
| print(f"[ui] labels : {labels_dir}") | |
| print(f"[ui] total : {total_eps} episodes") | |
| if AnnotateHandler.dataset_root is not None: | |
| print(f"[ui] dataset: {AnnotateHandler.dataset_root}") | |
| print(f"[ui] open : http://{args.host}:{args.port}") | |
| ThreadingHTTPServer((args.host, args.port), AnnotateHandler).serve_forever() | |
| if __name__ == "__main__": | |
| main() | |
Xet Storage Details
- Size:
- 33.3 kB
- Xet hash:
- 5b9dc3f1f21b2277146b559cd96cf77a0c1196fa271f56f8b997545ebd78ecdf
·
Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.