Datasets:

ppak10
/

Agentic-SLS-Telemetry

#!/usr/bin/env python3
"""Render preview MP4s for each build's parquet.
Reads data/ticks/{build_id:03d}.parquet and writes:
  previews/{build_id:03d}/chamber.mp4    (optical)
  previews/{build_id:03d}/thermal.mp4
  previews/{build_id:03d}/galvo.mp4
  previews/{build_id:03d}/composite.mp4  (1x3 panel: chamber | thermal | galvo)
Playback is at 10 fps (= tick rate), so the video duration matches the build's
wall-clock duration. Null frames are forward-filled with the most recent
captured frame of that kind, so the preview keeps moving even during the
sparse stretches (heating, idle).
Source is the dataset's own parquet — no recorder repo needed. The trade-off
is that ~half of upstream-captured frames don't survive the per-tick attach,
so motion looks chunkier than playing the raw recorder frames would.
The thermal panel is rendered from the raw `bedmatrix` IR grid (inferno colormap
over a fixed absolute °C range; see _thermal.py) whenever it's present — builds
013+. The three earliest builds (001/002/012) predate the bedmatrix stream and
fall back to the legacy pre-rendered `frame_thermal` GIF.
Usage:
    uv run scripts/previews/01_render.py            # all builds in data/ticks/
    uv run scripts/previews/01_render.py 13 26      # specific build ids
"""
import io
import os
import sys
from pathlib import Path

# Point imageio-ffmpeg at the system ffmpeg (Ubuntu's build includes h264_nvenc;
# the bundled imageio-ffmpeg binary doesn't). Must be set BEFORE importing imageio.
os.environ.setdefault("IMAGEIO_FFMPEG_EXE", "/usr/bin/ffmpeg")

import imageio.v2 as iio
import numpy as np
import pyarrow.parquet as pq
from PIL import Image

sys.path.insert(0, str(Path(__file__).parent.parent))
sys.path.insert(0, str(Path(__file__).parent))
from _lib import DATA_DIR
from _thermal import bedmatrix_to_image

OUTPUT_DIR = DATA_DIR.parent / "previews"
TICKS_DIR = DATA_DIR / "ticks"
# Order here = left-to-right order in the composite panel.
FRAME_KINDS = ("chamber", "thermal", "galvo")
# The thermal panel is rendered from the raw `bedmatrix` IR grid when present
# (builds 013+), falling back to the legacy `frame_thermal` GIF for the three
# earliest builds (001/002/012) that predate the bedmatrix stream.
# Per-kind rotation applied post-decode (degrees clockwise). The chamber camera
# is mounted sideways on the printer, so its raw frames need a 90° CW correction
# before rendering. Other kinds are captured already in display orientation.
KIND_ROTATION_CW = {"chamber": 90}
FPS = 10
PANEL_HEIGHT = 480  # all panels resized to this height; widths float to preserve aspect ratio.
BATCH_ROWS = 1000   # pyarrow row-group iter chunk; bounds peak memory per build.


def _even(n: int) -> int:
    """H.264 requires even dimensions; round up if odd."""
    return n if n % 2 == 0 else n + 1


def _decode_raw(frame_struct, kind: str) -> Image.Image | None:
    """Decode an HF Image struct to a PIL Image (RGB), applying KIND_ROTATION_CW
    if the kind needs orientation correction. None when missing."""
    if frame_struct is None:
        return None
    b = frame_struct.get("bytes")
    if b is None:
        return None
    try:
        img = Image.open(io.BytesIO(b)).convert("RGB")
    except Exception:
        return None
    rot = KIND_ROTATION_CW.get(kind, 0)
    # Image.Transpose.ROTATE_N rotates N degrees CCW, so CW=N → ROTATE_(360-N).
    if rot == 90:
        img = img.transpose(Image.Transpose.ROTATE_270)
    elif rot == 180:
        img = img.transpose(Image.Transpose.ROTATE_180)
    elif rot == 270:
        img = img.transpose(Image.Transpose.ROTATE_90)
    return img


def _decode_cell(cell, kind: str) -> Image.Image | None:
    """Decode one struct cell to a PIL RGB image, dispatching on struct shape:
    a `bedmatrix` struct (has 'values') renders as an inferno heatmap; a frame
    Image struct (has 'bytes') decodes + orientation-corrects. None when missing."""
    if cell is None:
        return None
    if "values" in cell:
        return bedmatrix_to_image(cell)
    return _decode_raw(cell, kind)


def _thermal_column(parquet_path: Path) -> str:
    """Which column feeds the thermal panel for this build: 'bedmatrix' when the
    raw IR matrix has any non-null cell, else the legacy 'frame_thermal'. The
    bedmatrix stream started at build 013, so 001/002/012 fall back to the GIF."""
    pf = pq.ParquetFile(parquet_path)
    if "bedmatrix" not in {f.name for f in pf.schema_arrow}:
        return "frame_thermal"
    for batch in pf.iter_batches(columns=["bedmatrix"], batch_size=BATCH_ROWS):
        for cell in batch.column("bedmatrix").to_pylist():
            if cell is not None:
                return "bedmatrix"
    return "frame_thermal"


def _columns_for_build(parquet_path: Path) -> dict[str, str]:
    """Map each panel kind → the parquet column that feeds it for this build."""
    return {
        "chamber": "frame_chamber",
        "thermal": _thermal_column(parquet_path),
        "galvo":   "frame_galvo",
    }


def _fit_to_canvas(img: Image.Image, canvas_w: int) -> np.ndarray:
    """Letterbox `img` into a (canvas_w × PANEL_HEIGHT) gray canvas, preserving aspect.
    Locking on the canvas dims is required because some builds have frames whose
    source dimensions drift mid-build (e.g. thermal IR config changes)."""
    sw, sh = img.size
    scale = min(canvas_w / sw, PANEL_HEIGHT / sh)
    new_w = max(1, round(sw * scale))
    new_h = max(1, round(sh * scale))
    fitted = img.resize((new_w, new_h), Image.BILINEAR)
    canvas = Image.new("RGB", (canvas_w, PANEL_HEIGHT), (20, 20, 20))
    canvas.paste(fitted, ((canvas_w - new_w) // 2, (PANEL_HEIGHT - new_h) // 2))
    return np.asarray(canvas)


def _placeholder(width: int) -> np.ndarray:
    """Gray panel shown before the first frame of a kind has been seen."""
    return np.full((PANEL_HEIGHT, width, 3), 20, dtype=np.uint8)


def _iter_struct_batches(parquet_path: Path, columns: list[str]):
    """Yield (n_rows, dict[col -> list[struct|None]]) per row-group batch."""
    pf = pq.ParquetFile(parquet_path)
    for batch in pf.iter_batches(columns=columns, batch_size=BATCH_ROWS):
        cols = {c: batch.column(c).to_pylist() for c in columns}
        yield batch.num_rows, cols


def _open_writer(out_path: Path):
    """Open an MP4 writer. Uses NVENC on the K620 GPUs when available, falling
    back to libx264 if the env var RENDER_CPU=1 forces software encode."""
    out_path.parent.mkdir(parents=True, exist_ok=True)
    if os.environ.get("RENDER_CPU") == "1":
        return iio.get_writer(
            out_path, fps=FPS, codec="libx264",
            macro_block_size=1, quality=6,  # ~CRF 23-ish
        )
    # NVENC path. Quality target ~CRF 23 via constant-quality VBR. `p4` is the
    # balanced preset on the new naming; older NVENC firmware may report this
    # as "medium". yuv420p forced because rgb24 input → NVENC needs 4:2:0.
    return iio.get_writer(
        out_path, fps=FPS, codec="h264_nvenc",
        macro_block_size=1,
        ffmpeg_params=[
            "-preset", "p4",
            "-rc", "vbr",
            "-cq", "23",
            "-pix_fmt", "yuv420p",
        ],
    )


def _probe_first_frame_width(parquet_path: Path, kind: str, col: str) -> int | None:
    """Find the first non-null cell in `col`, compute the locked canvas width
    from its post-decode aspect ratio (height = PANEL_HEIGHT). Returns None if
    no frame of that kind ever appears."""
    for n_rows, cols in _iter_struct_batches(parquet_path, [col]):
        for struct in cols[col]:
            img = _decode_cell(struct, kind)
            if img is not None:
                sw, sh = img.size
                return _even(max(2, round(sw * PANEL_HEIGHT / sh)))
    return None


def render_per_kind(parquet_path: Path, kind: str, out_path: Path, col: str) -> int:
    """Write one MP4 of a single panel kind, forward-filled. Returns frame count."""
    width = _probe_first_frame_width(parquet_path, kind, col)
    if width is None:
        # No frames of this kind exist for this build; nothing meaningful to render.
        print(f"  {kind:8s}: no frames of this kind, skipping")
        return 0
    last: np.ndarray | None = None
    frames_written = 0
    with _open_writer(out_path) as writer:
        for n_rows, cols in _iter_struct_batches(parquet_path, [col]):
            for struct in cols[col]:
                img = _decode_cell(struct, kind)
                if img is not None:
                    last = _fit_to_canvas(img, width)
                writer.append_data(last if last is not None else _placeholder(width))
                frames_written += 1
    return frames_written


def render_composite(parquet_path: Path, out_path: Path, cols_map: dict[str, str]) -> int:
    """Write the 1×3 composite. All three panels share the tick timeline."""
    # Lock canvas widths up front so all subsequent frames letterbox into a fixed shape.
    widths = {k: (_probe_first_frame_width(parquet_path, k, cols_map[k]) or PANEL_HEIGHT)
              for k in FRAME_KINDS}
    cols_to_read = [cols_map[k] for k in FRAME_KINDS]
    last: dict[str, np.ndarray | None] = {k: None for k in FRAME_KINDS}
    frames_written = 0
    with _open_writer(out_path) as writer:
        for n_rows, cols in _iter_struct_batches(parquet_path, cols_to_read):
            for i in range(n_rows):
                for k in FRAME_KINDS:
                    img = _decode_cell(cols[cols_map[k]][i], k)
                    if img is not None:
                        last[k] = _fit_to_canvas(img, widths[k])
                panels = [
                    last[k] if last[k] is not None else _placeholder(widths[k])
                    for k in FRAME_KINDS
                ]
                writer.append_data(np.hstack(panels))
                frames_written += 1
    return frames_written


def process_build(build_id: int, kinds: set[str]) -> None:
    parquet_path = TICKS_DIR / f"{build_id:03d}.parquet"
    if not parquet_path.exists():
        print(f"build {build_id:03d}: no parquet, skipping")
        return
    build_dir = OUTPUT_DIR / f"{build_id:03d}"
    print(f"build {build_id:03d}: rendering → {build_dir.relative_to(Path.cwd())}/")
    cols_map = _columns_for_build(parquet_path)
    if ("thermal" in kinds or "composite" in kinds):
        print(f"  thermal source: {cols_map['thermal']}")
    for kind in FRAME_KINDS:
        if kind not in kinds:
            continue
        out = build_dir / f"{kind}.mp4"
        n = render_per_kind(parquet_path, kind, out, cols_map[kind])
        # render_per_kind skips writing entirely when no frames of this kind exist
        # (and prints its own "skipping" line). Guard stat to avoid FileNotFoundError.
        if out.exists():
            print(f"  {kind:8s}: {n:>7,} frames → {out.name} ({out.stat().st_size:,} bytes)")
    if "composite" in kinds:
        out = build_dir / "composite.mp4"
        n = render_composite(parquet_path, out, cols_map)
        if out.exists():
            print(f"  composite: {n:>7,} frames → {out.name} ({out.stat().st_size:,} bytes)")


def main():
    import argparse
    parser = argparse.ArgumentParser(description=__doc__,
                                     formatter_class=argparse.RawDescriptionHelpFormatter)
    parser.add_argument("build_ids", nargs="*", type=int,
                        help="Specific build IDs to render (default: all in data/ticks/)")
    parser.add_argument("--kinds", default="chamber,thermal,galvo,composite",
                        help="Comma-separated outputs to render. Default: all four. "
                             "Useful for re-rendering just one kind, e.g. "
                             "--kinds chamber,composite after a chamber-orientation change.")
    args = parser.parse_args()
    kinds = set(args.kinds.split(","))
    unknown = kinds - (set(FRAME_KINDS) | {"composite"})
    if unknown:
        parser.error(f"unknown --kinds values: {sorted(unknown)}; "
                     f"valid: {sorted(set(FRAME_KINDS) | {'composite'})}")
    targets = args.build_ids or sorted(int(p.stem) for p in TICKS_DIR.glob("*.parquet"))
    for bid in targets:
        process_build(bid, kinds)


if __name__ == "__main__":
    main()

	#!/usr/bin/env python3
	"""Render preview MP4s for each build's parquet.

	Reads data/ticks/{build_id:03d}.parquet and writes:
	previews/{build_id:03d}/chamber.mp4 (optical)
	previews/{build_id:03d}/thermal.mp4
	previews/{build_id:03d}/galvo.mp4
	previews/{build_id:03d}/composite.mp4 (1x3 panel: chamber \| thermal \| galvo)

	Playback is at 10 fps (= tick rate), so the video duration matches the build's
	wall-clock duration. Null frames are forward-filled with the most recent
	captured frame of that kind, so the preview keeps moving even during the
	sparse stretches (heating, idle).

	Source is the dataset's own parquet — no recorder repo needed. The trade-off
	is that ~half of upstream-captured frames don't survive the per-tick attach,
	so motion looks chunkier than playing the raw recorder frames would.

	The thermal panel is rendered from the raw `bedmatrix` IR grid (inferno colormap
	over a fixed absolute °C range; see _thermal.py) whenever it's present — builds
	013+. The three earliest builds (001/002/012) predate the bedmatrix stream and
	fall back to the legacy pre-rendered `frame_thermal` GIF.

	Usage:
	uv run scripts/previews/01_render.py # all builds in data/ticks/
	uv run scripts/previews/01_render.py 13 26 # specific build ids
	"""
	import io
	import os
	import sys
	from pathlib import Path

	# Point imageio-ffmpeg at the system ffmpeg (Ubuntu's build includes h264_nvenc;
	# the bundled imageio-ffmpeg binary doesn't). Must be set BEFORE importing imageio.
	os.environ.setdefault("IMAGEIO_FFMPEG_EXE", "/usr/bin/ffmpeg")

	import imageio.v2 as iio
	import numpy as np
	import pyarrow.parquet as pq
	from PIL import Image

	sys.path.insert(0, str(Path(__file__).parent.parent))
	sys.path.insert(0, str(Path(__file__).parent))
	from _lib import DATA_DIR
	from _thermal import bedmatrix_to_image

	OUTPUT_DIR = DATA_DIR.parent / "previews"
	TICKS_DIR = DATA_DIR / "ticks"
	# Order here = left-to-right order in the composite panel.
	FRAME_KINDS = ("chamber", "thermal", "galvo")
	# The thermal panel is rendered from the raw `bedmatrix` IR grid when present
	# (builds 013+), falling back to the legacy `frame_thermal` GIF for the three
	# earliest builds (001/002/012) that predate the bedmatrix stream.
	# Per-kind rotation applied post-decode (degrees clockwise). The chamber camera
	# is mounted sideways on the printer, so its raw frames need a 90° CW correction
	# before rendering. Other kinds are captured already in display orientation.
	KIND_ROTATION_CW = {"chamber": 90}
	FPS = 10
	PANEL_HEIGHT = 480 # all panels resized to this height; widths float to preserve aspect ratio.
	BATCH_ROWS = 1000 # pyarrow row-group iter chunk; bounds peak memory per build.


	def _even(n: int) -> int:
	"""H.264 requires even dimensions; round up if odd."""
	return n if n % 2 == 0 else n + 1


	def _decode_raw(frame_struct, kind: str) -> Image.Image \| None:
	"""Decode an HF Image struct to a PIL Image (RGB), applying KIND_ROTATION_CW
	if the kind needs orientation correction. None when missing."""
	if frame_struct is None:
	return None
	b = frame_struct.get("bytes")
	if b is None:
	return None
	try:
	img = Image.open(io.BytesIO(b)).convert("RGB")
	except Exception:
	return None
	rot = KIND_ROTATION_CW.get(kind, 0)
	# Image.Transpose.ROTATE_N rotates N degrees CCW, so CW=N → ROTATE_(360-N).
	if rot == 90:
	img = img.transpose(Image.Transpose.ROTATE_270)
	elif rot == 180:
	img = img.transpose(Image.Transpose.ROTATE_180)
	elif rot == 270:
	img = img.transpose(Image.Transpose.ROTATE_90)
	return img


	def _decode_cell(cell, kind: str) -> Image.Image \| None:
	"""Decode one struct cell to a PIL RGB image, dispatching on struct shape:
	a `bedmatrix` struct (has 'values') renders as an inferno heatmap; a frame
	Image struct (has 'bytes') decodes + orientation-corrects. None when missing."""
	if cell is None:
	return None
	if "values" in cell:
	return bedmatrix_to_image(cell)
	return _decode_raw(cell, kind)


	def _thermal_column(parquet_path: Path) -> str:
	"""Which column feeds the thermal panel for this build: 'bedmatrix' when the
	raw IR matrix has any non-null cell, else the legacy 'frame_thermal'. The
	bedmatrix stream started at build 013, so 001/002/012 fall back to the GIF."""
	pf = pq.ParquetFile(parquet_path)
	if "bedmatrix" not in {f.name for f in pf.schema_arrow}:
	return "frame_thermal"
	for batch in pf.iter_batches(columns=["bedmatrix"], batch_size=BATCH_ROWS):
	for cell in batch.column("bedmatrix").to_pylist():
	if cell is not None:
	return "bedmatrix"
	return "frame_thermal"


	def _columns_for_build(parquet_path: Path) -> dict[str, str]:
	"""Map each panel kind → the parquet column that feeds it for this build."""
	return {
	"chamber": "frame_chamber",
	"thermal": _thermal_column(parquet_path),
	"galvo": "frame_galvo",
	}


	def _fit_to_canvas(img: Image.Image, canvas_w: int) -> np.ndarray:
	"""Letterbox `img` into a (canvas_w × PANEL_HEIGHT) gray canvas, preserving aspect.
	Locking on the canvas dims is required because some builds have frames whose
	source dimensions drift mid-build (e.g. thermal IR config changes)."""
	sw, sh = img.size
	scale = min(canvas_w / sw, PANEL_HEIGHT / sh)
	new_w = max(1, round(sw * scale))
	new_h = max(1, round(sh * scale))
	fitted = img.resize((new_w, new_h), Image.BILINEAR)
	canvas = Image.new("RGB", (canvas_w, PANEL_HEIGHT), (20, 20, 20))
	canvas.paste(fitted, ((canvas_w - new_w) // 2, (PANEL_HEIGHT - new_h) // 2))
	return np.asarray(canvas)


	def _placeholder(width: int) -> np.ndarray:
	"""Gray panel shown before the first frame of a kind has been seen."""
	return np.full((PANEL_HEIGHT, width, 3), 20, dtype=np.uint8)


	def _iter_struct_batches(parquet_path: Path, columns: list[str]):
	"""Yield (n_rows, dict[col -> list[struct\|None]]) per row-group batch."""
	pf = pq.ParquetFile(parquet_path)
	for batch in pf.iter_batches(columns=columns, batch_size=BATCH_ROWS):
	cols = {c: batch.column(c).to_pylist() for c in columns}
	yield batch.num_rows, cols


	def _open_writer(out_path: Path):
	"""Open an MP4 writer. Uses NVENC on the K620 GPUs when available, falling
	back to libx264 if the env var RENDER_CPU=1 forces software encode."""
	out_path.parent.mkdir(parents=True, exist_ok=True)
	if os.environ.get("RENDER_CPU") == "1":
	return iio.get_writer(
	out_path, fps=FPS, codec="libx264",
	macro_block_size=1, quality=6, # ~CRF 23-ish
	)
	# NVENC path. Quality target ~CRF 23 via constant-quality VBR. `p4` is the
	# balanced preset on the new naming; older NVENC firmware may report this
	# as "medium". yuv420p forced because rgb24 input → NVENC needs 4:2:0.
	return iio.get_writer(
	out_path, fps=FPS, codec="h264_nvenc",
	macro_block_size=1,
	ffmpeg_params=[
	"-preset", "p4",
	"-rc", "vbr",
	"-cq", "23",
	"-pix_fmt", "yuv420p",
	],
	)


	def _probe_first_frame_width(parquet_path: Path, kind: str, col: str) -> int \| None:
	"""Find the first non-null cell in `col`, compute the locked canvas width
	from its post-decode aspect ratio (height = PANEL_HEIGHT). Returns None if
	no frame of that kind ever appears."""
	for n_rows, cols in _iter_struct_batches(parquet_path, [col]):
	for struct in cols[col]:
	img = _decode_cell(struct, kind)
	if img is not None:
	sw, sh = img.size
	return _even(max(2, round(sw * PANEL_HEIGHT / sh)))
	return None


	def render_per_kind(parquet_path: Path, kind: str, out_path: Path, col: str) -> int:
	"""Write one MP4 of a single panel kind, forward-filled. Returns frame count."""
	width = _probe_first_frame_width(parquet_path, kind, col)
	if width is None:
	# No frames of this kind exist for this build; nothing meaningful to render.
	print(f" {kind:8s}: no frames of this kind, skipping")
	return 0
	last: np.ndarray \| None = None
	frames_written = 0
	with _open_writer(out_path) as writer:
	for n_rows, cols in _iter_struct_batches(parquet_path, [col]):
	for struct in cols[col]:
	img = _decode_cell(struct, kind)
	if img is not None:
	last = _fit_to_canvas(img, width)
	writer.append_data(last if last is not None else _placeholder(width))
	frames_written += 1
	return frames_written


	def render_composite(parquet_path: Path, out_path: Path, cols_map: dict[str, str]) -> int:
	"""Write the 1×3 composite. All three panels share the tick timeline."""
	# Lock canvas widths up front so all subsequent frames letterbox into a fixed shape.
	widths = {k: (_probe_first_frame_width(parquet_path, k, cols_map[k]) or PANEL_HEIGHT)
	for k in FRAME_KINDS}
	cols_to_read = [cols_map[k] for k in FRAME_KINDS]
	last: dict[str, np.ndarray \| None] = {k: None for k in FRAME_KINDS}
	frames_written = 0
	with _open_writer(out_path) as writer:
	for n_rows, cols in _iter_struct_batches(parquet_path, cols_to_read):
	for i in range(n_rows):
	for k in FRAME_KINDS:
	img = _decode_cell(cols[cols_map[k]][i], k)
	if img is not None:
	last[k] = _fit_to_canvas(img, widths[k])
	panels = [
	last[k] if last[k] is not None else _placeholder(widths[k])
	for k in FRAME_KINDS
	]
	writer.append_data(np.hstack(panels))
	frames_written += 1
	return frames_written


	def process_build(build_id: int, kinds: set[str]) -> None:
	parquet_path = TICKS_DIR / f"{build_id:03d}.parquet"
	if not parquet_path.exists():
	print(f"build {build_id:03d}: no parquet, skipping")
	return
	build_dir = OUTPUT_DIR / f"{build_id:03d}"
	print(f"build {build_id:03d}: rendering → {build_dir.relative_to(Path.cwd())}/")
	cols_map = _columns_for_build(parquet_path)
	if ("thermal" in kinds or "composite" in kinds):
	print(f" thermal source: {cols_map['thermal']}")
	for kind in FRAME_KINDS:
	if kind not in kinds:
	continue
	out = build_dir / f"{kind}.mp4"
	n = render_per_kind(parquet_path, kind, out, cols_map[kind])
	# render_per_kind skips writing entirely when no frames of this kind exist
	# (and prints its own "skipping" line). Guard stat to avoid FileNotFoundError.
	if out.exists():
	print(f" {kind:8s}: {n:>7,} frames → {out.name} ({out.stat().st_size:,} bytes)")
	if "composite" in kinds:
	out = build_dir / "composite.mp4"
	n = render_composite(parquet_path, out, cols_map)
	if out.exists():
	print(f" composite: {n:>7,} frames → {out.name} ({out.stat().st_size:,} bytes)")


	def main():
	import argparse
	parser = argparse.ArgumentParser(description=__doc__,
	formatter_class=argparse.RawDescriptionHelpFormatter)
	parser.add_argument("build_ids", nargs="*", type=int,
	help="Specific build IDs to render (default: all in data/ticks/)")
	parser.add_argument("--kinds", default="chamber,thermal,galvo,composite",
	help="Comma-separated outputs to render. Default: all four. "
	"Useful for re-rendering just one kind, e.g. "
	"--kinds chamber,composite after a chamber-orientation change.")
	args = parser.parse_args()
	kinds = set(args.kinds.split(","))
	unknown = kinds - (set(FRAME_KINDS) \| {"composite"})
	if unknown:
	parser.error(f"unknown --kinds values: {sorted(unknown)}; "
	f"valid: {sorted(set(FRAME_KINDS) \| {'composite'})}")
	targets = args.build_ids or sorted(int(p.stem) for p in TICKS_DIR.glob("*.parquet"))
	for bid in targets:
	process_build(bid, kinds)


	if __name__ == "__main__":
	main()