#!/usr/bin/env python3 """Build the `ticks` config: one row per 10 Hz telemetry tick per build. Reads upstream flat exports from the containing recorder repo: builds.jsonl, telemetry/{build_id}.parquet, frames.jsonl, position_hf/{build_id}.parquet For each build with telemetry, emits `data/ticks/{build_id:03d}.parquet` (zero-padded so lexical sort matches numeric build_id): - One row per unique telemetry timestamp (the 10 Hz tick from /state/snapshot) - Wide-format sensor columns named "{sensor_id}.{kind}" (~64 columns) - Denormalized build context (build_id, job_name, ..., print_profile_name) - frame_chamber / frame_galvo / frame_thermal: nearest frame path in [tick_ts - 100ms, tick_ts], null when no frame fell in that window (frame_thermal is the legacy bedmatrix GIF heatmap; recorder stopped producing it after 2026-07-12, so it is null for builds captured since) - bedmatrix: nearest IR temperature matrix in the same 100ms window, as a struct {width, height, values (row-major °C), path}; null when none. This is the raw 32x24 bed-surface temperature grid the recorder now streams as JSON in place of the old rendered frame_thermal heatmap. - position_hf_burst: list of {ts_offset_ms, x, y, z1, z2, r, has_homed} for all position_hf events in the same 100ms window Usage: uv run scripts/ticks/01_extract.py # all builds with telemetry uv run scripts/ticks/01_extract.py 13 26 # specific build ids """ import json import sys from datetime import timedelta from pathlib import Path import polars as pl import pyarrow as pa import pyarrow.parquet as pq sys.path.insert(0, str(Path(__file__).parent.parent)) from _lib import (EXPORTS_DIR, DATA_DIR, TELEMETRY_DIR, POSITION_DIR, FRAMES_BUFFER, iter_jsonl, load_build_to_profile_name) OUTPUT_DIR = DATA_DIR / "ticks" WINDOW = timedelta(milliseconds=100) # 10 Hz tick interval FRAME_KINDS = ("chamber", "galvo", "thermal") # The IR temperature matrix. Same underlying sensor the legacy frame_thermal GIF # was rendered from, but streamed as a raw {width, height, values} JSON grid. # Attached like a frame (nearest-before-tick), embedded as a numeric struct. BEDMATRIX_KIND = "bedmatrix" # frame_* path strings are relative to this directory in the upstream recorder repo. FRAMES_DIR = FRAMES_BUFFER # loose frames for builds not yet zip-delivered # HF Image feature wire format. Both fields nullable; the struct itself is null when no frame. IMAGE_STRUCT_TYPE = pa.struct([ pa.field("bytes", pa.binary()), pa.field("path", pa.string()), ]) # Bedmatrix numeric struct. `values` is row-major, length width*height (32*24=768), # temperatures in °C as float32 (firmware sends ~0.01°C resolution; f32 is ample). # The whole struct is null when no matrix fell in the tick window. BEDMATRIX_STRUCT_TYPE = pa.struct([ pa.field("width", pa.int32()), pa.field("height", pa.int32()), pa.field("values", pa.list_(pa.float32())), pa.field("path", pa.string()), ]) # Streaming chunk size in rows. Tuned so peak embedded payload per chunk stays # under ~1 GB (thermal frames dominate at ~315 KB each). CHUNK_ROWS = 2_000 def load_builds_index() -> dict[int, dict]: rows = list(iter_jsonl(EXPORTS_DIR / "builds.jsonl")) return {r["id"]: r for r in rows} def load_frames_for_build(build_id: int) -> pl.DataFrame: """Read just the frame rows for one build out of the upstream frames.jsonl.""" rows = [r for r in iter_jsonl(EXPORTS_DIR / "frames.jsonl") if r.get("build_id") == build_id] if not rows: return pl.DataFrame(schema={"ts": pl.Datetime("us", "UTC"), "kind": pl.String, "path": pl.String}) df = pl.DataFrame(rows).select( pl.col("ts").str.to_datetime(time_unit="us", time_zone="UTC"), pl.col("kind"), pl.col("path"), ) return df def pivot_telemetry(tel: pl.DataFrame) -> pl.DataFrame: """Wide-pivot (ts, sensor_id, kind, value) → one row per ts with {sensor_id}.{kind} columns. Duplicate samples within a tick collapse via first.""" tel = tel.with_columns( col_name=pl.col("sensor_id") + "." + pl.col("kind") ) return tel.pivot( on="col_name", index="ts", values="value", aggregate_function="first" ).sort("ts") def attach_frames(wide: pl.DataFrame, frames: pl.DataFrame) -> pl.DataFrame: """For each frame kind, attach the nearest path within WINDOW prior to tick_ts.""" for kind in FRAME_KINDS: f = ( frames.filter(pl.col("kind") == kind) .select(pl.col("ts"), pl.col("path").alias(f"frame_{kind}")) .sort("ts") ) if f.height == 0: wide = wide.with_columns(pl.lit(None, dtype=pl.String).alias(f"frame_{kind}")) continue wide = wide.sort("ts").join_asof( f, on="ts", strategy="backward", tolerance=WINDOW ) return wide def attach_bedmatrix(wide: pl.DataFrame, frames: pl.DataFrame) -> pl.DataFrame: """Attach the nearest bedmatrix path within WINDOW prior to tick_ts as a string column `bedmatrix` (parsed into a numeric struct at write time, exactly like the frame_* path columns).""" f = ( frames.filter(pl.col("kind") == BEDMATRIX_KIND) .select(pl.col("ts"), pl.col("path").alias("bedmatrix")) .sort("ts") ) if f.height == 0: return wide.with_columns(pl.lit(None, dtype=pl.String).alias("bedmatrix")) return wide.sort("ts").join_asof( f, on="ts", strategy="backward", tolerance=WINDOW ) def attach_position_hf(wide: pl.DataFrame, build_id: int) -> pl.DataFrame: """Append a `position_hf_burst` column: list of structs of position_hf events in (tick_ts - WINDOW, tick_ts]. Empty list when no events in window or no parquet.""" pos_path = POSITION_DIR / f"{build_id:03d}.parquet" burst_dtype = pl.List( pl.Struct({ "ts_offset_ms": pl.Float64, "x": pl.Float64, "y": pl.Float64, "z1": pl.Float64, "z2": pl.Float64, "r": pl.Float64, "has_homed": pl.Boolean, }) ) if not pos_path.exists(): return wide.with_columns(pl.lit([], dtype=burst_dtype).alias("position_hf_burst")) pos = pl.read_parquet(pos_path).sort("ts") pos_records = pos.to_dicts() ticks = wide["ts"].to_list() bursts: list[list[dict]] = [] pos_lo = 0 for tick_ts in ticks: t_start = tick_ts - WINDOW while pos_lo < len(pos_records) and pos_records[pos_lo]["ts"] <= t_start: pos_lo += 1 j = pos_lo burst: list[dict] = [] while j < len(pos_records) and pos_records[j]["ts"] <= tick_ts: rec = pos_records[j] burst.append({ "ts_offset_ms": (rec["ts"] - tick_ts).total_seconds() * 1000.0, "x": rec.get("x"), "y": rec.get("y"), "z1": rec.get("z1"), "z2": rec.get("z2"), "r": rec.get("r"), "has_homed": rec.get("has_homed"), }) j += 1 bursts.append(burst) return wide.with_columns(pl.Series("position_hf_burst", bursts, dtype=burst_dtype)) def denormalize_build(wide: pl.DataFrame, build_row: dict, profile_name_lookup: dict[int, str]) -> pl.DataFrame: """Prepend build-context columns to every row. Cheap in parquet thanks to dictionary encoding (every row in this file has the same value).""" bid = build_row["id"] return wide.with_columns( pl.lit(bid).alias("build_id"), pl.lit(build_row.get("job_name")).alias("job_name"), pl.lit(build_row.get("started_at")).alias("started_at"), pl.lit(build_row.get("ended_at")).alias("ended_at"), pl.lit(build_row.get("phase")).alias("phase"), pl.lit(profile_name_lookup.get(bid)).alias("print_profile_name"), pl.lit(None, dtype=pl.String).alias("inova_session_id"), ) def _embed_frame_column(paths: list[str | None]) -> pa.Array: """For one chunk's worth of paths, read the image bytes from disk and return a StructArray with HF Image shape. Missing path → null struct; missing-on-disk → null struct (warn-and-continue).""" raw_bytes: list[bytes | None] = [] for p in paths: if p is None: raw_bytes.append(None) continue try: raw_bytes.append((FRAMES_DIR / p).read_bytes()) except FileNotFoundError: raw_bytes.append(None) bytes_array = pa.array(raw_bytes, type=pa.binary()) path_array = pa.array(paths, type=pa.string()) # Mask the whole struct as null when there is no path. Children stay null too. mask = pa.array([p is None for p in paths], type=pa.bool_()) return pa.StructArray.from_arrays( [bytes_array, path_array], fields=[pa.field("bytes", pa.binary()), pa.field("path", pa.string())], mask=mask, ) def _embed_bedmatrix_column(paths: list[str | None]) -> pa.Array: """For one chunk's paths, read each bedmatrix JSON from disk and return a StructArray of {width, height, values, path}. Missing path, missing-on-disk, or unparseable JSON → null struct (warn-free continue, same as frames).""" widths: list[int | None] = [] heights: list[int | None] = [] values: list[list[float] | None] = [] kept: list[str | None] = [] for p in paths: if p is None: widths.append(None); heights.append(None); values.append(None); kept.append(None) continue try: d = json.loads((FRAMES_DIR / p).read_bytes()) widths.append(d.get("width")) heights.append(d.get("height")) values.append([float(v) for v in d["values"]]) kept.append(p) except (FileNotFoundError, KeyError, ValueError, TypeError): widths.append(None); heights.append(None); values.append(None); kept.append(None) mask = pa.array([p is None for p in kept], type=pa.bool_()) return pa.StructArray.from_arrays( [ pa.array(widths, type=pa.int32()), pa.array(heights, type=pa.int32()), pa.array(values, type=pa.list_(pa.float32())), pa.array(kept, type=pa.string()), ], fields=list(BEDMATRIX_STRUCT_TYPE), mask=mask, ) def _make_output_schema(wide_arrow_schema: pa.Schema) -> pa.Schema: """Replace frame_* string fields with HF Image structs and the bedmatrix path string with its numeric struct.""" new_fields = [] image_field_names = {f"frame_{k}" for k in FRAME_KINDS} for field in wide_arrow_schema: if field.name in image_field_names: new_fields.append(pa.field(field.name, IMAGE_STRUCT_TYPE)) elif field.name == "bedmatrix": new_fields.append(pa.field("bedmatrix", BEDMATRIX_STRUCT_TYPE)) else: new_fields.append(field) return pa.schema(new_fields) def _embed_chunk(chunk: pa.Table, output_schema: pa.Schema) -> pa.Table: """Swap frame_* and bedmatrix string columns for embedded structs in this chunk.""" image_names = {f"frame_{k}" for k in FRAME_KINDS} arrays = [] for field in output_schema: if field.name in image_names: arrays.append(_embed_frame_column(chunk[field.name].to_pylist())) elif field.name == "bedmatrix": arrays.append(_embed_bedmatrix_column(chunk[field.name].to_pylist())) else: arrays.append(chunk[field.name].combine_chunks()) return pa.Table.from_arrays(arrays, schema=output_schema) def process_build(build_id: int, builds_index: dict[int, dict], profile_name_lookup: dict[int, str]) -> Path | None: tel_path = TELEMETRY_DIR / f"{build_id:03d}.parquet" if not tel_path.exists(): return None tel = pl.read_parquet(tel_path) if tel.is_empty(): return None wide = pivot_telemetry(tel) frames = load_frames_for_build(build_id) wide = attach_frames(wide, frames) wide = attach_bedmatrix(wide, frames) wide = attach_position_hf(wide, build_id) wide = denormalize_build(wide, builds_index[build_id], profile_name_lookup) # Put build context + ts first, then sensors, then frames + bedmatrix + burst. leading = ["build_id", "ts", "job_name", "started_at", "ended_at", "phase", "print_profile_name", "inova_session_id"] frame_cols = [f"frame_{k}" for k in FRAME_KINDS] trailing = frame_cols + ["bedmatrix", "position_hf_burst"] middle = [c for c in wide.columns if c not in leading and c not in trailing] wide = wide.select(leading + middle + trailing) # Stream-write: build target schema (with image structs), then iterate # CHUNK_ROWS-sized slices, embedding bytes per chunk to bound memory. base_table = wide.to_arrow() output_schema = _make_output_schema(base_table.schema) out_path = OUTPUT_DIR / f"{build_id:03d}.parquet" with pq.ParquetWriter(out_path, output_schema, compression="zstd") as writer: for i in range(0, base_table.num_rows, CHUNK_ROWS): chunk = base_table.slice(i, CHUNK_ROWS) writer.write_table(_embed_chunk(chunk, output_schema)) return out_path def main(): OUTPUT_DIR.mkdir(parents=True, exist_ok=True) builds_index = load_builds_index() profile_name_lookup = load_build_to_profile_name() args = [int(a) for a in sys.argv[1:]] targets = args or sorted(int(p.stem) for p in TELEMETRY_DIR.glob("*.parquet")) for bid in targets: if bid not in builds_index: print(f"build {bid}: not in builds.jsonl, skipping") continue out = process_build(bid, builds_index, profile_name_lookup) if out is None: print(f"build {bid}: no telemetry parquet, skipping") continue rows = pl.scan_parquet(out).select(pl.len()).collect().item() size = out.stat().st_size print(f"build {bid}: wrote {rows:,} ticks → {out.relative_to(Path.cwd())} ({size:,} bytes)") if __name__ == "__main__": main()