Struct rerun_bindings::python_bridge::PyRecordingStream

source ·

struct PyRecordingStream(RecordingStream);

Tuple Fields§

§0: RecordingStream

Implementations§

source §

impl PyRecordingStream

source

fn is_forked_child(&self) -> bool

Determine if this stream is operating in the context of a forked child process.

This means the stream was created in the parent process. It now exists in the child process by way of fork, but it is effectively a zombie since its batcher and sink threads would not have been copied.

Calling operations such as flush or set_sink will result in an error.

Methods from Deref<Target = RecordingStream>§

pub fn clone_weak(&self) -> RecordingStream

Clones the [RecordingStream] without incrementing the refcount.

Useful e.g. if you want to make sure that a detached thread won’t prevent the [RecordingStream] from flushing during shutdown.

pub fn log<AS>( &self, ent_path: impl Into<EntityPath>, as_components: &AS, ) -> Result<(), RecordingStreamError>
where AS: AsComponents + ?Sized,

Log data to Rerun.

This is the main entry point for logging data to rerun. It can be used to log anything that implements the AsComponents, such as any archetype or individual component.

The data will be timestamped automatically based on the [RecordingStream]’s internal clock. See [RecordingStream::set_time_sequence] etc for more information.

The entity path can either be a string (with special characters escaped, split on unescaped slashes) or an EntityPath constructed with crate::entity_path. See https://www.rerun.io/docs/concepts/entity-path for more on entity paths.

See also: [Self::log_static] for logging static data.

Internally, the stream will automatically micro-batch multiple log calls to optimize transport. See SDK Micro Batching for more information.

§Example:

rec.log(
    "my/points",
    &rerun::Points3D::new([(0.0, 0.0, 0.0), (1.0, 1.0, 1.0)]),
)?;

pub fn send_columns( &self, ent_path: impl Into<EntityPath>, indexes: impl IntoIterator<Item = TimeColumn>, columns: impl IntoIterator<Item = SerializedComponentColumn>, ) -> Result<(), RecordingStreamError>

Lower-level logging API to provide data spanning multiple timepoints.

Unlike the regular log API, which is row-oriented, this API lets you submit the data in a columnar form. The lengths of all of the TimeColumn and the component columns must match. All data that occurs at the same index across the different time and components arrays will act as a single logical row.

Note that this API ignores any stateful time set on the log stream via the [Self::set_timepoint]/[Self::set_time_nanos]/etc. APIs. Furthermore, this will not inject the default timelines log_tick and log_time timeline columns.

pub fn log_static<AS>( &self, ent_path: impl Into<EntityPath>, as_components: &AS, ) -> Result<(), RecordingStreamError>
where AS: AsComponents + ?Sized,

Log data to Rerun.

It can be used to log anything that implements the AsComponents, such as any archetype or individual component.

Static data has no time associated with it, exists on all timelines, and unconditionally shadows any temporal data of the same type. All timestamp data associated with this message will be dropped right before sending it to Rerun.

This is most often used for rerun::ViewCoordinates and rerun::AnnotationContext.

Internally, the stream will automatically micro-batch multiple log calls to optimize transport. See SDK Micro Batching for more information.

pub fn log_with_static<AS>( &self, ent_path: impl Into<EntityPath>, static_: bool, as_components: &AS, ) -> Result<(), RecordingStreamError>
where AS: AsComponents + ?Sized,

Logs the contents of a component bundle into Rerun.

If static_ is set to true, all timestamp data associated with this message will be dropped right before sending it to Rerun. Static data has no time associated with it, exists on all timelines, and unconditionally shadows any temporal data of the same type.

Otherwise, the data will be timestamped automatically based on the [RecordingStream]’s internal clock. See RecordingStream::set_time_* family of methods for more information.

The entity path can either be a string (with special characters escaped, split on unescaped slashes) or an EntityPath constructed with crate::entity_path. See https://www.rerun.io/docs/concepts/entity-path for more on entity paths.

Internally, the stream will automatically micro-batch multiple log calls to optimize transport. See SDK Micro Batching for more information.

pub fn log_serialized_batches( &self, ent_path: impl Into<EntityPath>, static_: bool, comp_batches: impl IntoIterator<Item = SerializedComponentBatch>, ) -> Result<(), RecordingStreamError>

Logs a set of SerializedComponentBatches into Rerun.

If static_ is set to true, all timestamp data associated with this message will be dropped right before sending it to Rerun. Static data has no time associated with it, exists on all timelines, and unconditionally shadows any temporal data of the same type.

Otherwise, the data will be timestamped automatically based on the [RecordingStream]’s internal clock. See RecordingStream::set_time_* family of methods for more information.

The number of instances will be determined by the longest batch in the bundle.

The entity path can either be a string (with special characters escaped, split on unescaped slashes) or an EntityPath constructed with crate::entity_path. See https://www.rerun.io/docs/concepts/entity-path for more on entity paths.

Internally, the stream will automatically micro-batch multiple log calls to optimize transport. See SDK Micro Batching for more information.

pub fn log_file_from_path( &self, filepath: impl AsRef<Path>, entity_path_prefix: Option<EntityPath>, static_: bool, ) -> Result<(), RecordingStreamError>

Logs the file at the given path using all re_data_loader::DataLoaders available.

A single path might be handled by more than one loader.

This method blocks until either at least one re_data_loader::DataLoader starts streaming data in or all of them fail.

See https://www.rerun.io/docs/reference/data-loaders/overview for more information.

pub fn log_file_from_contents( &self, filepath: impl AsRef<Path>, contents: Cow<'_, [u8]>, entity_path_prefix: Option<EntityPath>, static_: bool, ) -> Result<(), RecordingStreamError>

Logs the given contents using all re_data_loader::DataLoaders available.

A single path might be handled by more than one loader.

This method blocks until either at least one re_data_loader::DataLoader starts streaming data in or all of them fail.

See https://www.rerun.io/docs/reference/data-loaders/overview for more information.

pub fn is_enabled(&self) -> bool

Check if logging is enabled on this RecordingStream.

If not, all recording calls will be ignored.

pub fn store_info(&self) -> Option<StoreInfo>

The StoreInfo associated with this RecordingStream.

pub fn is_forked_child(&self) -> bool

Determine whether a fork has happened since creating this RecordingStream. In general, this means our batcher/sink threads are gone and all data logged since the fork has been dropped.

It is essential that [crate::cleanup_if_forked_child] be called after forking the process. SDK-implementations should do this during their initialization phase.

pub fn record_msg(&self, msg: LogMsg)

Records an arbitrary LogMsg.

pub fn record_row( &self, entity_path: EntityPath, row: PendingRow, inject_time: bool, )

Records a single PendingRow.

If inject_time is set to true, the row’s timestamp data will be overridden using the [RecordingStream]’s internal clock.

Internally, incoming PendingRows are automatically coalesced into larger Chunks to optimize for transport.

pub fn log_chunk(&self, chunk: Chunk)

Logs a single Chunk.

Will inject log_tick and log_time timeline columns into the chunk. If you don’t want to inject these, use [Self::send_chunk] instead.

pub fn send_chunk(&self, chunk: Chunk)

Records a single Chunk.

This will not inject log_tick and log_time timeline columns into the chunk, for that use [Self::log_chunk].

pub fn set_sink(&self, sink: Box<dyn LogSink>)

Swaps the underlying sink for a new one.

This guarantees that:

all pending rows and chunks are batched, collected and sent down the current sink,
the current sink is flushed if it has pending data in its buffers,
the current sink’s backlog, if there’s any, is forwarded to the new sink.

When this function returns, the calling thread is guaranteed that all future record calls will end up in the new sink.

§Data loss

If the current sink is in a broken state (e.g. a TCP sink with a broken connection that cannot be repaired), all pending data in its buffers will be dropped.

pub fn flush_async(&self)

Initiates a flush of the pipeline and returns immediately.

This does not wait for the flush to propagate (see [Self::flush_blocking]). See [RecordingStream] docs for ordering semantics and multithreading guarantees.

pub fn flush_blocking(&self)

Initiates a flush the batching pipeline and waits for it to propagate.

See [RecordingStream] docs for ordering semantics and multithreading guarantees.

pub fn connect(&self)

Swaps the underlying sink for a [crate::log_sink::TcpSink] sink pre-configured to use the specified address.

See also [Self::connect_opts] if you wish to configure the TCP connection.