wip

Author: teh-cmc

crates/store/re_chunk/src/chunk.rs

@@ -284,23 +284,7 @@ impl Chunk {
                     .collect();
                 timelines == rhs_timelines
             }
-            // TODO(cmc): we cannot compare tags yet, need to support Python & C++ first
-            // && *components == rhs.components
-            && {
-                let lhs_components_no_tags: ChunkComponents = components
-                    .clone()
-                    .into_iter_flattened()
-                    .map(|(descr, list_array)| (ComponentDescriptor::new(descr.component_name), list_array))
-                    .collect();
-                let rhs_components_no_tags: ChunkComponents = rhs
-                    .components
-                    .clone()
-                    .into_iter_flattened()
-                    .map(|(descr, list_array)| (ComponentDescriptor::new(descr.component_name), list_array))
-                    .collect();
-
-                lhs_components_no_tags == rhs_components_no_tags
-            }
+            && *components == rhs.components
     }
 
     /// Check for equality while ignoring possible `Extension` type information

crates/top/rerun/src/commands/rrd/print.rs

@@ -1,5 +1,5 @@
 use anyhow::Context;
-use itertools::Itertools as _;
+use itertools::Itertools;
 
 use re_log_types::{LogMsg, SetStoreInfo};
 use re_sdk::log::Chunk;
@@ -15,8 +15,10 @@ pub struct PrintCommand {
     path_to_input_rrds: Vec<String>,
 
     /// If set, print out table contents.
-    #[clap(long, short, default_value_t = false)]
-    verbose: bool,
+    ///
+    /// This can be specified more than once to toggle more and more verbose levels (e.g. -vvv).
+    #[clap(long, short, action = clap::ArgAction::Count)]
+    verbose: u8,
 
     /// If set, will try to proceed even in the face of IO and/or decoding errors in the input data.
     #[clap(long = "continue-on-error", default_value_t = true)]
@@ -63,7 +65,7 @@ impl PrintCommand {
     }
 }
 
-fn print_msg(verbose: bool, msg: LogMsg) -> anyhow::Result<()> {
+fn print_msg(verbose: u8, msg: LogMsg) -> anyhow::Result<()> {
     match msg {
         LogMsg::SetStoreInfo(msg) => {
             let SetStoreInfo { row_id: _, info } = msg;
@@ -73,21 +75,31 @@ fn print_msg(verbose: bool, msg: LogMsg) -> anyhow::Result<()> {
         LogMsg::ArrowMsg(_row_id, arrow_msg) => {
             let chunk = Chunk::from_arrow_msg(&arrow_msg).context("skipped corrupt chunk")?;
 
-            if verbose {
-                println!("{chunk}");
-            } else {
+            print!(
+                "Chunk({}) with {} rows ({}) - {:?} - ",
+                chunk.id(),
+                chunk.num_rows(),
+                re_format::format_bytes(chunk.total_size_bytes() as _),
+                chunk.entity_path(),
+            );
+
+            if verbose == 0 {
                 let column_names = chunk
                     .component_names()
                     .map(|name| name.short_name())
                     .join(" ");
-
-                println!(
-                    "Chunk({}) with {} rows ({}) - {:?} - columns: [{column_names}]",
-                    chunk.id(),
-                    chunk.num_rows(),
-                    re_format::format_bytes(chunk.total_size_bytes() as _),
-                    chunk.entity_path(),
-                );
+                println!("columns: [{column_names}]");
+            } else if verbose == 1 {
+                let column_descriptors = chunk
+                    .component_descriptors()
+                    .map(|descr| descr.short_name())
+                    .collect_vec()
+                    .join(" ");
+                println!("columns: [{column_descriptors}]",);
+            } else if verbose == 2 {
+                println!("\n{}", chunk.emptied()); // headers only
+            } else {
+                println!("\n{chunk}");
             }
         }
 

docs/snippets/all/descriptors/descr_builtin_archetype.py

@@ -0,0 +1,12 @@
+#!/usr/bin/env python3
+
+from __future__ import annotations
+
+import rerun as rr  # pip install rerun-sdk
+
+rr.init("rerun_example_descriptors_builtin_archetype_vanilla")
+rr.spawn()
+
+rr.log("data", rr.Points3D([[1, 2, 3]], radii=[0.3, 0.2, 0.1]), static=True)
+
+# The tags are indirectly checked by the Rust version (have a look over there for more info).

docs/snippets/all/descriptors/descr_builtin_component.py

@@ -0,0 +1,12 @@
+#!/usr/bin/env python3
+
+from __future__ import annotations
+
+import rerun as rr  # pip install rerun-sdk
+
+rr.init("rerun_example_descriptors_builtin_component_vanilla")
+rr.spawn()
+
+rr.log_components("data", [rr.components.Position3DBatch([1, 2, 3])], static=True)
+
+# The tags are indirectly checked by the Rust version (have a look over there for more info).

docs/snippets/all/descriptors/descr_custom_archetype.py

@@ -0,0 +1,28 @@
+#!/usr/bin/env python3
+
+from __future__ import annotations
+
+from typing import Any
+
+import pyarrow as pa
+import rerun as rr  # pip install rerun-sdk
+
+
+class CustomPosition3DBatch(rr.ComponentBatchLike):
+    def __init__(self: Any, position: rr.components.Position3DBatch) -> None:
+        self.position = position
+
+    def component_name(self) -> str:
+        return "user.CustomPosition3D"
+
+    def as_arrow_array(self) -> pa.Array:
+        return self.position.as_arrow_array()
+
+
+rr.init("rerun_example_descriptors_custom_component_vanilla")
+rr.spawn()
+
+position = CustomPosition3DBatch(rr.components.Position3DBatch([1, 2, 3]))
+rr.log_components("data", [position], static=True)
+
+# The tags are indirectly checked by the Rust version (have a look over there for more info).

docs/snippets/all/descriptors/descr_custom_component.py

@@ -0,0 +1,28 @@
+#!/usr/bin/env python3
+
+from __future__ import annotations
+
+from typing import Any
+
+import pyarrow as pa
+import rerun as rr  # pip install rerun-sdk
+
+
+class CustomPosition3DBatch(rr.ComponentBatchLike):
+    def __init__(self: Any, position: rr.components.Position3DBatch) -> None:
+        self.position = position
+
+    def component_name(self) -> str:
+        return "user.CustomPosition3D"
+
+    def as_arrow_array(self) -> pa.Array:
+        return self.position.as_arrow_array()
+
+
+rr.init("rerun_example_descriptors_custom_component_vanilla")
+rr.spawn()
+
+position = CustomPosition3DBatch(rr.components.Position3DBatch([1, 2, 3]))
+rr.log_components("data", [position], static=True)
+
+# The tags are indirectly checked by the Rust version (have a look over there for more info).

examples/cpp/dna/main.cpp

@@ -12,7 +12,8 @@ static constexpr size_t NUM_POINTS = 100;
 
 int main() {
     const auto rec = rerun::RecordingStream("rerun_example_dna_abacus");
-    rec.spawn().exit_on_failure();
+    // rec.spawn().exit_on_failure();
+    rec.save("/tmp/dna.rrd").exit_on_failure();
 
     std::vector<rerun::Position3D> points1, points2;
     std::vector<rerun::Color> colors1, colors2;

rerun_py/rerun_sdk/rerun/_baseclasses.py

@@ -12,18 +12,98 @@
 T = TypeVar("T")
 
 
+# TODO: docs (copy from rust, probably)
+# TODO: the fact that this thing is nor interned and is recomputed/realloc'd for each
+# log call is pretty shit? then again I guess this is just as true for the arrow datatypes we
+# keep passing around... and the same is true for rust... (i think cpp caches all of this?)
+class ComponentDescriptor:
+    def __init__(
+        self,
+        component_name: str,
+        *,
+        archetype_name: str | None = None,
+        archetype_field_name: str | None = None,
+    ) -> None:
+        self.archetype_name = archetype_name
+        self.archetype_field_name = archetype_field_name
+        self.component_name = component_name
+
+    def __str__(self) -> str:
+        archetype_name = self.archetype_name
+        archetype_field_name = self.archetype_field_name
+        component_name = self.component_name
+
+        if archetype_name is not None and archetype_field_name is None:
+            return f"{archetype_name}:{component_name}"
+        elif archetype_name is None and archetype_field_name is not None:
+            return f"{component_name}#{archetype_field_name}"
+        elif archetype_name is not None and archetype_field_name is not None:
+            return f"{archetype_name}:{component_name}#{archetype_field_name}"
+
+        return component_name
+
+
+# TODO: Protocol are duck typed
 class ComponentBatchLike(Protocol):
     """Describes interface for objects that can be converted to batch of rerun Components."""
 
+    # TODO: uh... this needs to be the complete opposite
+    # def component_name(self) -> str:
+    #     """
+    #     The fully-qualified name of this component batch, e.g. `rerun.components.Position2D`.
+    #
+    #     This is a trivial but useful helper for `self.descriptor().component_name`.
+    #
+    #     The default implementation already does the right thing. Do not override unless you know
+    #     what you're doing.
+    #     `Self::name()` must exactly match the value returned by `self.descriptor().component_name`,
+    #     or undefined behavior ensues.
+    #     """
+    #     return self.component_descriptor().component_name
+    #
+    # def component_descriptor(self) -> ComponentDescriptor:
+    #     """Returns the complete descriptor of the component."""
+    #     ...
+
+    # TODO: in python we probably dont need component_name at all anymore though?
+    # TODO: for the static type checker...
     def component_name(self) -> str:
         """Returns the name of the component."""
         ...
 
+    def component_descriptor(self) -> ComponentDescriptor:
+        """Returns the complete descriptor of the component."""
+        return ComponentDescriptor(self.component_name())
+
     def as_arrow_array(self) -> pa.Array:
         """Returns a `pyarrow.Array` of the component data."""
         ...
 
 
+class DescribedComponentBatch(ComponentBatchLike):
+    """A `ComponentBatchLike` object with its associated `ComponentDescriptor`."""
+
+    # TODO: don't do this noob
+    # _descriptor: ComponentDescriptor
+    # _batch: ComponentBatchLike
+
+    def __init__(self, batch: ComponentBatchLike, descriptor: ComponentDescriptor):
+        self._batch = batch
+        self._descriptor = descriptor
+
+    def component_name(self) -> str:
+        """Returns the name of the component."""
+        return self._batch.component_name()
+
+    def component_descriptor(self) -> ComponentDescriptor:
+        """Returns the complete descriptor of the component."""
+        return self._descriptor
+
+    def as_arrow_array(self) -> pa.Array:
+        """Returns a `pyarrow.Array` of the component data."""
+        return self._batch.as_arrow_array()
+
+
 class AsComponents(Protocol):
     """
     Describes interface for interpreting an object as a bundle of Components.
@@ -43,6 +123,8 @@ def as_component_batches(self) -> Iterable[ComponentBatchLike]:
         ...
 
 
+# TODO: same as `Archetype(rr.AsComponents)`
+# TODO:
 @define
 class Archetype:
     """Base class for all archetypes."""
@@ -107,11 +189,17 @@ def as_component_batches(self) -> Iterable[ComponentBatchLike]:
                 # TODO(#3381): Depending on what we decide
                 # to do with optional components, we may need to make this instead call `_empty_pa_array`
                 if comp is not None:
-                    yield comp
+                    descr = ComponentDescriptor(
+                        comp.component_name(),
+                        archetype_name=self.archetype_name(),
+                        archetype_field_name=fld.name,
+                    )
+                    yield DescribedComponentBatch(comp, descr)
 
     __repr__ = __str__
 
 
+# TODO: basically that's the equivalent of Rust's Loggable right now
 class BaseBatch(Generic[T]):
     _ARROW_DATATYPE: pa.DataType | None = None
     """The pyarrow type of this batch."""
@@ -268,6 +356,14 @@ def component_name(self) -> str:
         """
         return self.component_batch.component_name()
 
+    def component_descriptor(self) -> ComponentDescriptor:
+        """
+        Returns the complete descriptor of the component.
+
+        Part of the `ComponentBatchLike` logging interface.
+        """
+        return self.component_batch.component_descriptor()
+
     def as_arrow_array(self) -> pa.Array:
         """
         The component as an arrow batch.
@@ -279,6 +375,7 @@ def as_arrow_array(self) -> pa.Array:
         return pa.ListArray.from_arrays(offsets, array)
 
 
+# TODO: okay what about this? does this need a descriptor?
 class ComponentBatchMixin(ComponentBatchLike):
     def component_name(self) -> str:
         """
@@ -308,6 +405,7 @@ def partition(self, lengths: npt.ArrayLike) -> ComponentColumn:
         return ComponentColumn(self, lengths)
 
 
+# TODO: okay what about this? does this need a descriptor????????????
 class ComponentMixin(ComponentBatchLike):
     """
     Makes components adhere to the ComponentBatchLike interface.