Nadeem-Shoukath115113/opensarm / tools /annotate_act_pri_ui.py
Nadeem-Shoukath115113's picture
download
raw
33.3 kB
#!/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))
@classmethod
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.