Rerun chunk processing
The pipeline layer between raw data and an RRD: readers produce Chunks,
streams transform them, terminal calls execute. This skill is the generic
mechanics only. Decide the data model first (rerun-data-model), then pick the
importer skill for each source:
| Source |
Reader |
Skill |
| MCAP file (ROS2, protobuf, Foxglove) |
McapReader(path).stream() |
rerun-mcap |
| URDF robot model (+ joint states → FK) |
UrdfTree.from_file_path(...).stream() |
rerun-urdf |
| Parquet table (trajectories, sensor logs) |
ParquetReader(path).stream() |
rerun-parquet |
| LeRobot dataset directory |
built-in importer, then RrdReader |
rerun-lerobot |
| Existing RRD |
RrdReader(path) |
here, below |
| Sidecar files (JSON calib, metadata) |
Chunk.from_columns + from_iter |
here, below |
The API is rerun.experimental; when
behavior matters, check the installed surface:
python -c "from rerun.experimental import LazyChunkStream; help(LazyChunkStream)".
Decision rule: where does each component come from?
Default: a reader produces the chunks; lenses shape them. Walk this before
writing any conversion code — most "build it by hand" instincts are wrong here:
- Source a reader supports? Use the reader's
.stream(); never hand-parse
and re-log. MCAP→McapReader, URDF→UrdfTree, parquet→ParquetReader,
RRD→RrdReader, LeRobot dir→log_file_from_path.
- A decoder already emits the archetype? Foxglove gives
Transform3D,
Pinhole, VideoStream (real sample bytes) ready-made — pass it through,
do not re-derive. Only custom-protobuf topics arrive as <Name>:message and
need a lens (see rerun-mcap).
- Fix an existing component in place (swapped resolution, recolor, unit
convert)?
MutateLens, output_mode="forward_unmatched".
- Derive a new component/entity (FK→
/tf, scalars from a message)?
DeriveLens. To scatter one row into N (a joint batch → per-joint /tf),
use the two-lens pair: derive the batch with output_mode="forward_all"
(keeps the originals, e.g. the joint states), then a second
DeriveLens with scatter=True and output_mode="drop_unmatched" (emits
only the scattered rows). See the robot_data_preprocessing example.
- Genuine sidecar no reader or lens can produce (JSON calibration offsets,
hand-measured extrinsics, external metadata)?
Chunk.from_columns + from_iter.
- Finish with
LazyChunkStream.merge(...) →
.collect(optimize=OptimizationProfile.OBJECT_STORE) →
write_rrd(application_id, recording_id).
Why this order: the pipeline stays lazy, columnar, multithreaded, and
OBJECT_STORE-optimizable. A hand-built row loop or an out-of-lens pa.array
throws all of that away — that is the path we are deliberately avoiding.
Anti-patterns (use a reader + lens instead)
If you are writing the left, stop and use the right:
for-loop building rows/components → a lens with a Selector(...).pipe(...)
PyArrow-compute callback.
rr.init + rr.log per message for conversion → that is live logging;
for ingestion, read with a reader and write_rrd.
chunk.to_record_batch() + pc.filter then rebuilding via
Chunk.from_columns (row-thinning by hand) → stream.drop(content=...),
.split(...), or a MutateLens returning a filtered pa.array.
pa.array / pa.RecordBatch / np.frombuffer assembled OUTSIDE a lens →
move the transform inside a MutateLens/DeriveLens selector callback.
rr.send_columns hand-assembled from a custom parser → use the matching
reader; it produces chunks directly.
- Parsing MCAP/URDF with a non-Rerun library then re-logging →
McapReader
/ UrdfTree.
Chunk.from_columns for data a reader already decodes (Pinhole
intrinsics, VideoStream, Transform3D from a transforms topic) → keep it in
the reader stream; fix with a MutateLens if needed.
A wall of pyarrow.compute "missing-attribute" type errors (pc.filter,
pc.list_element) usually means pc.* calls sit in module-level helpers instead
of inside Selector.pipe lens callbacks. Refactor into a lens before suppressing
the checker — the errors are a smell that the hand-building should not exist.
Porting an existing converter? Hand-built converters predate decoder
improvements and are not ground truth. Re-verify the decoder output (step 2) and
check every Chunk.from_columns / for-loop against this list before copying.
Core model
LazyChunkStream is a lazy pipeline DAG, not a collection. Building
filters, lenses, maps, splits, and merges reads no source data.
- Execution starts at terminal calls:
write_rrd(...), collect(),
to_chunks(), or iterating the stream.
- Execution is streaming, multithreaded, and mostly GIL-free. Prefer
stream/lens operations and PyArrow compute over Python row loops.
- Move semantics: builder calls (
filter, drop, lenses, map,
flat_map) consume the input stream; reusing a consumed stream raises.
Reassign after each step. Terminal calls do not consume, but each terminal
call re-executes the whole pipeline; collect() once if that is too costly.
ChunkStore is materialized in memory (stream.collect(),
ChunkStore.from_chunks). LazyStore is manifest-indexed, loads chunks on
demand (RrdReader(path).store(), catalog segment stores). Both have
schema(), summary(), stream(), and write_rrd(...).
Stream composition
from rerun.experimental import Chunk, LazyChunkStream, OptimizationProfile
stream.filter(content=, has_timeline=, is_static=, components=) keeps the
matching portion of each chunk; stream.drop(...) is its complement, same
keyword filters. content takes an entity-path glob or a list of them.
stream.map(fn) applies Chunk -> Chunk; stream.flat_map(fn) applies
Chunk -> Iterable[Chunk]. Escape hatches for chunk-level Python logic;
prefer lenses for columnar work.
stream.split(content=, ...) returns (matching, non_matching); both
branches share the same upstream.
LazyChunkStream.merge(*streams) fans in any number of sources.
LazyChunkStream.from_iter(chunks) wraps hand-built chunks.
stream = source_stream() # any importer skill
stream = stream.drop(content="/video_raw/**")
stream = stream.lenses(fix_lens, content="/cam/**", output_mode="forward_unmatched")
merged = LazyChunkStream.merge(stream, sidecar_stream)
merged.write_rrd(out_path, application_id="my_app", recording_id=recording_id)
Hand-built chunks — sidecar only
Use Chunk.from_columns ONLY for data no reader or lens can emit — JSON/CSV
calibration, frame offsets, external metadata. If a reader
(McapReader/UrdfTree/ParquetReader) decodes the topic or a lens can derive
it, that is the idiomatic path; do not hand-assemble it here. In the
robot_data_preprocessing example the only hand-built chunk is the JSON
offsets sidecar; the camera fix, FK→/tf, meshes, and recolor are all
readers + lenses.
Chunk.from_columns(entity_path, indexes, columns) mirrors
rr.send_columns(...) and accepts the same archetype .columns(...) helpers.
Empty indexes means static.
chunk = Chunk.from_columns(
"/tf_static/robot_offsets",
indexes=[], # static
columns=rr.Transform3D.columns(
translation=translations,
quaternion=quaternions_xyzw,
parent_frame=parents,
child_frame=children,
),
)
sidecar_stream = LazyChunkStream.from_iter([chunk])
rr.AnyValues.columns(...) covers non-standard metadata fields. For
inspection, a Chunk exposes entity_path, num_rows, is_static,
timeline_names, to_record_batch(), and format() (human-readable table).
Lenses
Lenses reshape, fix, or derive components without iterating rows. Apply with
stream.lenses(lenses, output_mode=..., content=...).
MutateLens(component, selector, keep_row_ids=False) modifies an existing
component in place.
DeriveLens(component, output_entity=None, scatter=False) creates new
columns, optionally at another entity. Chain .to_component(descriptor, selector) per output; .to_timeline(name, "sequence" | "duration_ns" | "timestamp_ns", selector) extracts a time column from the data itself.
scatter=True explodes one input row into N output rows (one per list
element).
- Scope with
content= whenever the same component name exists under multiple
entities.
Output modes, and the default is drop_unmatched:
drop_unmatched (default): only lens outputs survive. Right for derive-only
intermediate streams; silently discards everything else if applied broadly.
forward_unmatched: lens outputs plus the original components no lens
consumed. Right for targeted fixes that preserve the rest of the stream.
forward_all: lens outputs plus all originals, including consumed ones. Can
duplicate data.
In-place fix (keep Arrow type and length intact):
stream = stream.lenses(
MutateLens(
"Pinhole:resolution",
Selector(".").pipe(
lambda res: pa.array(
[(h, w) for w, h in res.to_pylist()],
type=res.type,
)
),
),
content=["/external/cam_low", "/external/cam_high"],
output_mode="forward_unmatched",
)
Derive with unit conversion (PyArrow compute, no Python loop):
DeriveLens("schemas.proto.JointState:message", output_entity="/joints_deg/waist").to_component(
rr.Scalars.descriptor_scalars(),
Selector(".joint_positions").pipe(lambda arr: pc.multiply(pc.list_element(arr, 0), 180.0 / math.pi)),
)
Selector grammar
Selector("<query>") navigates nested Arrow data, jq-style:
. current value; .field struct field
[] iterate list elements; [N] index a list
? suppress errors / skip missing optionals; ! assert non-null
| pipe one expression into another
.pipe(fn) chains a Python/PyArrow transform (or another Selector).
.execute(array) runs it eagerly; .execute_per_row(array) guarantees the
output row count matches the input (use inside lens callbacks that must stay
row-aligned).
Writing RRDs
stream.write_rrd(path, application_id=..., recording_id=...) executes and
writes in one streaming pass.
stream.collect(optimize=OptimizationProfile.OBJECT_STORE).write_rrd(...)
materializes, optimizes chunk layout, then writes. Memory scales with the
materialized chunks.
- Profiles:
OBJECT_STORE (large chunks, for storage/query/catalog) and
LIVE (small chunks, low-latency viewer).
- Multiple physical RRDs form one logical recording when they share a
recording_id; use this to separate base data, model/URDF data, and layers.
Always use OptimizationProfile.OBJECT_STORE when the RRD is headed for a
Rerun catalog or Hub, unless explicitly asked otherwise.
Chunk API vs logging API
- Logging (
rr.log, rr.send_columns, RecordingStream) is for live logging
from user code; chunk processing is for ingestion, conversion, and
postprocessing existing recordings.
- Logging → chunks: write an RRD, read it back with
RrdReader.
RrdReader(path) lists recordings() / blueprints() (each a StoreEntry
with kind, application_id, recording_id); .stream(store=entry) for
sequential passes, .store(store=entry) for indexed access.
- Chunks → logging:
rerun.experimental.send_chunks(chunks, recording=...)
accepts a Chunk, LazyChunkStream, LazyStore, ChunkStore, or any
iterable of chunks. The source store's application_id/recording_id are
not preserved; the active recording's identity wins.
Common gotchas
- The default lens
output_mode is drop_unmatched; forgetting to set
forward_unmatched on a targeted fix silently drops the rest of the stream.
- Do not reuse a consumed
LazyChunkStream; reassign or split deliberately.
- Scope lenses with
content=; the same component name often exists under
many entities.
- Preserve Arrow array type and length in
MutateLens transforms.
- For catalog layers, the layer
recording_id must equal the segment id.
- This is
rerun.experimental; pin-check signatures when upgrading.
References
- End-to-end example (MCAP + URDF + JSON sidecar, lenses, merge, optimize):
https://github.com/rerun-io/rerun/tree/main/examples/python/robot_data_preprocessing
- Docs:
https://rerun.io/docs/concepts/logging-and-ingestion/chunk-processing-api,
https://rerun.io/docs/concepts/query-and-transform/lenses
1---2name: rerun-chunk-processing-33description: "Core mechanics of the Rerun Chunk Processing API (rerun.experimental) — LazyChunkStream pipelines, Chunk, lenses (MutateLens/DeriveLens/Selector), RrdReader, writing optimized RRDs. Read BEFORE writing any ingestion/conversion/preprocessing code (convert an MCAP, build a recording from a dataset, preprocess an .rrd, port an old converter): it mandates reader+lens pipelines and steers away from hand-built chunks — no Chunk.from_columns for data a reader/lens can produce, no per-message rr.log, no manual pa.array assembly. Source-specific knowledge lives in the importer skills (rerun-mcap, rerun-urdf, rerun-parquet, rerun-lerobot); read rerun-data-model first to decide what the data should become."4user_invocable: true5allowed-tools: Read, Grep, Bash, WebFetch6metadata:7 source: https://skillmd.com/skills/rerun-io/rerun-chunk-processing-38---910# Rerun chunk processing1112The pipeline layer between raw data and an RRD: readers produce `Chunk`s,13streams transform them, terminal calls execute. This skill is the generic14mechanics only. Decide the data model first (`rerun-data-model`), then pick the15importer skill for each source:1617| Source | Reader | Skill |18| ----------------------------------------- | --------------------------------------- | --------------- |19| MCAP file (ROS2, protobuf, Foxglove) | `McapReader(path).stream()` | `rerun-mcap` |20| URDF robot model (+ joint states → FK) | `UrdfTree.from_file_path(...).stream()` | `rerun-urdf` |21| Parquet table (trajectories, sensor logs) | `ParquetReader(path).stream()` | `rerun-parquet` |22| LeRobot dataset directory | built-in importer, then `RrdReader` | `rerun-lerobot` |23| Existing RRD | `RrdReader(path)` | here, below |24| Sidecar files (JSON calib, metadata) | `Chunk.from_columns` + `from_iter` | here, below |2526The API is `rerun.experimental`; when27behavior matters, check the installed surface:28`python -c "from rerun.experimental import LazyChunkStream; help(LazyChunkStream)"`.2930## Decision rule: where does each component come from?3132Default: **a reader produces the chunks; lenses shape them.** Walk this before33writing any conversion code — most "build it by hand" instincts are wrong here:34351. **Source a reader supports?** Use the reader's `.stream()`; never hand-parse36 and re-log. MCAP→`McapReader`, URDF→`UrdfTree`, parquet→`ParquetReader`,37 RRD→`RrdReader`, LeRobot dir→`log_file_from_path`.382. **A decoder already emits the archetype?** Foxglove gives `Transform3D`,39 `Pinhole`, `VideoStream` (real sample bytes) ready-made — **pass it through**,40 do not re-derive. Only custom-protobuf topics arrive as `<Name>:message` and41 need a lens (see `rerun-mcap`).423. **Fix an existing component in place** (swapped resolution, recolor, unit43 convert)? `MutateLens`, `output_mode="forward_unmatched"`.444. **Derive a new component/entity** (FK→`/tf`, scalars from a message)?45 `DeriveLens`. To scatter one row into N (a joint batch → per-joint `/tf`),46 use the **two-lens pair**: derive the batch with `output_mode="forward_all"`47 (keeps the originals, e.g. the joint states), then a second48 `DeriveLens` with `scatter=True` and `output_mode="drop_unmatched"` (emits49 only the scattered rows). See the `robot_data_preprocessing` example.505. **Genuine sidecar** no reader or lens can produce (JSON calibration offsets,51 hand-measured extrinsics, external metadata)? `Chunk.from_columns` + `from_iter`.526. Finish with `LazyChunkStream.merge(...)` →53 `.collect(optimize=OptimizationProfile.OBJECT_STORE)` →54 `write_rrd(application_id, recording_id)`.5556Why this order: the pipeline stays lazy, columnar, multithreaded, and57`OBJECT_STORE`-optimizable. A hand-built row loop or an out-of-lens `pa.array`58throws all of that away — that is the path we are deliberately avoiding.5960## Anti-patterns (use a reader + lens instead)6162If you are writing the left, stop and use the right:6364- **`for`-loop building rows/components** → a lens with a `Selector(...).pipe(...)`65 PyArrow-compute callback.66- **`rr.init` + `rr.log` per message for conversion** → that is _live_ logging;67 for ingestion, read with a reader and `write_rrd`.68- **`chunk.to_record_batch()` + `pc.filter` then rebuilding via69 `Chunk.from_columns`** (row-thinning by hand) → `stream.drop(content=...)`,70 `.split(...)`, or a `MutateLens` returning a filtered `pa.array`.71- **`pa.array` / `pa.RecordBatch` / `np.frombuffer` assembled OUTSIDE a lens** →72 move the transform inside a `MutateLens`/`DeriveLens` selector callback.73- **`rr.send_columns` hand-assembled from a custom parser** → use the matching74 reader; it produces chunks directly.75- **Parsing MCAP/URDF with a non-Rerun library then re-logging** → `McapReader`76 / `UrdfTree`.77- **`Chunk.from_columns` for data a reader already decodes** (`Pinhole`78 intrinsics, `VideoStream`, `Transform3D` from a transforms topic) → keep it in79 the reader stream; fix with a `MutateLens` if needed.8081A wall of `pyarrow.compute` "missing-attribute" type errors (`pc.filter`,82`pc.list_element`) usually means `pc.*` calls sit in module-level helpers instead83of inside `Selector.pipe` lens callbacks. Refactor into a lens before suppressing84the checker — the errors are a smell that the hand-building should not exist.8586**Porting an existing converter?** Hand-built converters predate decoder87improvements and are not ground truth. Re-verify the decoder output (step 2) and88check every `Chunk.from_columns` / for-loop against this list before copying.8990## Core model9192- `LazyChunkStream` is a lazy pipeline DAG, not a collection. Building93 filters, lenses, maps, splits, and merges reads no source data.94- Execution starts at terminal calls: `write_rrd(...)`, `collect()`,95 `to_chunks()`, or iterating the stream.96- Execution is streaming, multithreaded, and mostly GIL-free. Prefer97 stream/lens operations and PyArrow compute over Python row loops.98- **Move semantics**: builder calls (`filter`, `drop`, `lenses`, `map`,99 `flat_map`) consume the input stream; reusing a consumed stream raises.100 Reassign after each step. Terminal calls do not consume, but each terminal101 call re-executes the whole pipeline; `collect()` once if that is too costly.102- `ChunkStore` is materialized in memory (`stream.collect()`,103 `ChunkStore.from_chunks`). `LazyStore` is manifest-indexed, loads chunks on104 demand (`RrdReader(path).store()`, catalog segment stores). Both have105 `schema()`, `summary()`, `stream()`, and `write_rrd(...)`.106107## Stream composition108109```python110from rerun.experimental import Chunk, LazyChunkStream, OptimizationProfile111```112113- `stream.filter(content=, has_timeline=, is_static=, components=)` keeps the114 matching portion of each chunk; `stream.drop(...)` is its complement, same115 keyword filters. `content` takes an entity-path glob or a list of them.116- `stream.map(fn)` applies `Chunk -> Chunk`; `stream.flat_map(fn)` applies117 `Chunk -> Iterable[Chunk]`. Escape hatches for chunk-level Python logic;118 prefer lenses for columnar work.119- `stream.split(content=, ...)` returns `(matching, non_matching)`; both120 branches share the same upstream.121- `LazyChunkStream.merge(*streams)` fans in any number of sources.122- `LazyChunkStream.from_iter(chunks)` wraps hand-built chunks.123124```python125stream = source_stream() # any importer skill126stream = stream.drop(content="/video_raw/**")127stream = stream.lenses(fix_lens, content="/cam/**", output_mode="forward_unmatched")128merged = LazyChunkStream.merge(stream, sidecar_stream)129merged.write_rrd(out_path, application_id="my_app", recording_id=recording_id)130```131132## Hand-built chunks — sidecar only133134Use `Chunk.from_columns` ONLY for data no reader or lens can emit — JSON/CSV135calibration, frame offsets, external metadata. If a reader136(`McapReader`/`UrdfTree`/`ParquetReader`) decodes the topic or a lens can derive137it, that is the idiomatic path; do not hand-assemble it here. In the138`robot_data_preprocessing` example the _only_ hand-built chunk is the JSON139offsets sidecar; the camera fix, FK→`/tf`, meshes, and recolor are all140readers + lenses.141142`Chunk.from_columns(entity_path, indexes, columns)` mirrors143`rr.send_columns(...)` and accepts the same archetype `.columns(...)` helpers.144Empty `indexes` means static.145146```python147chunk = Chunk.from_columns(148 "/tf_static/robot_offsets",149 indexes=[], # static150 columns=rr.Transform3D.columns(151 translation=translations,152 quaternion=quaternions_xyzw,153 parent_frame=parents,154 child_frame=children,155 ),156)157sidecar_stream = LazyChunkStream.from_iter([chunk])158```159160`rr.AnyValues.columns(...)` covers non-standard metadata fields. For161inspection, a `Chunk` exposes `entity_path`, `num_rows`, `is_static`,162`timeline_names`, `to_record_batch()`, and `format()` (human-readable table).163164## Lenses165166Lenses reshape, fix, or derive components without iterating rows. Apply with167`stream.lenses(lenses, output_mode=..., content=...)`.168169- `MutateLens(component, selector, keep_row_ids=False)` modifies an existing170 component in place.171- `DeriveLens(component, output_entity=None, scatter=False)` creates new172 columns, optionally at another entity. Chain `.to_component(descriptor,173selector)` per output; `.to_timeline(name, "sequence" | "duration_ns" |174"timestamp_ns", selector)` extracts a time column from the data itself.175 `scatter=True` explodes one input row into N output rows (one per list176 element).177- Scope with `content=` whenever the same component name exists under multiple178 entities.179180Output modes, and **the default is `drop_unmatched`**:181182- `drop_unmatched` (default): only lens outputs survive. Right for derive-only183 intermediate streams; silently discards everything else if applied broadly.184- `forward_unmatched`: lens outputs plus the original components no lens185 consumed. Right for targeted fixes that preserve the rest of the stream.186- `forward_all`: lens outputs plus all originals, including consumed ones. Can187 duplicate data.188189In-place fix (keep Arrow type and length intact):190191```python192stream = stream.lenses(193 MutateLens(194 "Pinhole:resolution",195 Selector(".").pipe(196 lambda res: pa.array(197 [(h, w) for w, h in res.to_pylist()],198 type=res.type,199 )200 ),201 ),202 content=["/external/cam_low", "/external/cam_high"],203 output_mode="forward_unmatched",204)205```206207Derive with unit conversion (PyArrow compute, no Python loop):208209```python210DeriveLens("schemas.proto.JointState:message", output_entity="/joints_deg/waist").to_component(211 rr.Scalars.descriptor_scalars(),212 Selector(".joint_positions").pipe(lambda arr: pc.multiply(pc.list_element(arr, 0), 180.0 / math.pi)),213)214```215216## Selector grammar217218`Selector("<query>")` navigates nested Arrow data, jq-style:219220- `.` current value; `.field` struct field221- `[]` iterate list elements; `[N]` index a list222- `?` suppress errors / skip missing optionals; `!` assert non-null223- `|` pipe one expression into another224225`.pipe(fn)` chains a Python/PyArrow transform (or another Selector).226`.execute(array)` runs it eagerly; `.execute_per_row(array)` guarantees the227output row count matches the input (use inside lens callbacks that must stay228row-aligned).229230## Writing RRDs231232- `stream.write_rrd(path, application_id=..., recording_id=...)` executes and233 writes in one streaming pass.234- `stream.collect(optimize=OptimizationProfile.OBJECT_STORE).write_rrd(...)`235 materializes, optimizes chunk layout, then writes. Memory scales with the236 materialized chunks.237- Profiles: `OBJECT_STORE` (large chunks, for storage/query/catalog) and238 `LIVE` (small chunks, low-latency viewer).239- Multiple physical RRDs form one logical recording when they share a240 `recording_id`; use this to separate base data, model/URDF data, and layers.241242**Always use `OptimizationProfile.OBJECT_STORE`** when the RRD is headed for a243Rerun catalog or Hub, unless explicitly asked otherwise.244245## Chunk API vs logging API246247- Logging (`rr.log`, `rr.send_columns`, `RecordingStream`) is for live logging248 from user code; chunk processing is for ingestion, conversion, and249 postprocessing existing recordings.250- Logging → chunks: write an RRD, read it back with `RrdReader`.251 `RrdReader(path)` lists `recordings()` / `blueprints()` (each a `StoreEntry`252 with `kind`, `application_id`, `recording_id`); `.stream(store=entry)` for253 sequential passes, `.store(store=entry)` for indexed access.254- Chunks → logging: `rerun.experimental.send_chunks(chunks, recording=...)`255 accepts a `Chunk`, `LazyChunkStream`, `LazyStore`, `ChunkStore`, or any256 iterable of chunks. The source store's `application_id`/`recording_id` are257 **not** preserved; the active recording's identity wins.258259## Common gotchas260261- The default lens `output_mode` is `drop_unmatched`; forgetting to set262 `forward_unmatched` on a targeted fix silently drops the rest of the stream.263- Do not reuse a consumed `LazyChunkStream`; reassign or `split` deliberately.264- Scope lenses with `content=`; the same component name often exists under265 many entities.266- Preserve Arrow array type and length in `MutateLens` transforms.267- For catalog layers, the layer `recording_id` must equal the segment id.268- This is `rerun.experimental`; pin-check signatures when upgrading.269270## References271272- End-to-end example (MCAP + URDF + JSON sidecar, lenses, merge, optimize):273 `https://github.com/rerun-io/rerun/tree/main/examples/python/robot_data_preprocessing`274- Docs: `https://rerun.io/docs/concepts/logging-and-ingestion/chunk-processing-api`,275 `https://rerun.io/docs/concepts/query-and-transform/lenses`