Struct rerun_bindings::remote::PyRemoteRecording

pub struct PyRemoteRecording {
    pub(crate) client: Arc<Py<PyStorageNodeClient>>,
    pub(crate) store_info: StoreInfo,
}

A single Rerun recording.

This can be loaded from an RRD file using [load_recording()][rerun.dataframe.load_recording].

A recording is a collection of data that was logged to Rerun. This data is organized as a column for each index (timeline) and each entity/component pair that was logged.

You can examine the [.schema()][rerun.dataframe.Recording.schema] of the recording to see what data is available, or create a [RecordingView][rerun.dataframe.RecordingView] to to retrieve the data.

Fields

client: Arc<Py<PyStorageNodeClient>>

store_info: StoreInfo

Implementations

impl PyRemoteRecording

fn extract_contents_expr( expr: &Bound<'_, PyAny>, ) -> PyResult<ViewContentsSelector>

Convert a ViewContentsLike into a ViewContentsSelector.

ViewContentsLike = Union[str, Dict[str, Union[ComponentLike, Sequence[ComponentLike]]]]

impl PyRemoteRecording

fn view( slf: Bound<'_, Self>, index: &str, contents: &Bound<'_, PyAny>, include_semantically_empty_columns: bool, include_indicator_columns: bool, include_tombstone_columns: bool, ) -> PyResult<PyRecordingView>

Create a [RecordingView][rerun.dataframe.RecordingView] of the recording according to a particular index and content specification.

The only type of index currently supported is the name of a timeline.

The view will only contain a single row for each unique value of the index that is associated with a component column that was included in the view. Component columns that are not included via the view contents will not impact the rows that make up the view. If the same entity / component pair was logged to a given index multiple times, only the most recent row will be included in the view, as determined by the row_id column. This will generally be the last value logged, as row_ids are guaranteed to be monotonically increasing when data is sent from a single process.

Parameters

index : str The index to use for the view. This is typically a timeline name. contents : ViewContentsLike The content specification for the view.

This can be a single string content-expression such as: `"world/cameras/**"`, or a dictionary
specifying multiple content-expressions and a respective list of components to select within
that expression such as `{"world/cameras/**": ["ImageBuffer", "PinholeProjection"]}`.

include_semantically_empty_columns : bool, optional Whether to include columns that are semantically empty, by default False.

Semantically empty columns are components that are `null` or empty `[]` for every row in the recording.

include_indicator_columns : bool, optional Whether to include indicator columns, by default False.

Indicator columns are components used to represent the presence of an archetype within an entity.

include_tombstone_columns : bool, optional Whether to include tombstone columns, by default False.

Tombstone columns are components used to represent clears. However, even without the clear
tombstone columns, the view will still apply the clear semantics when resolving row contents.

Returns

RecordingView The view of the recording.

Examples

All the data in the recording on the timeline “my_index”:

recording.view(index="my_index", contents="/**")

Just the Position3D components in the “points” entity:

recording.view(index="my_index", contents={"points": "Position3D"})

fn recording_id(&self) -> String

The recording ID of the recording.

fn application_id(&self) -> String

The application ID of the recording.

Trait Implementations

impl IntoPy<Py<PyAny>> for PyRemoteRecording

fn into_py(self, py: Python<'_>) -> PyObject

Performs the conversion.

impl PyClass for PyRemoteRecording

type Frozen = False

Whether the pyclass is frozen.

impl PyClassImpl for PyRemoteRecording

const IS_BASETYPE: bool = false

#[pyclass(subclass)]

const IS_SUBCLASS: bool = false

#[pyclass(extends=…)]

const IS_MAPPING: bool = false

#[pyclass(mapping)]

const IS_SEQUENCE: bool = false

#[pyclass(sequence)]

type BaseType = PyAny

Base class

type ThreadChecker = SendablePyClass<PyRemoteRecording>

This handles following two situations:

type PyClassMutability = <<PyAny as PyClassBaseType>::PyClassMutability as PyClassMutability>::MutableChild

Immutable or mutable

type Dict = PyClassDummySlot

Specify this class has #[pyclass(dict)] or not.

type WeakRef = PyClassDummySlot

Specify this class has #[pyclass(weakref)] or not.

type BaseNativeType = PyAny

The closest native ancestor. This is PyAny by default, and when you declare #[pyclass(extends=PyDict)], it’s PyDict.

fn items_iter() -> PyClassItemsIter

fn doc(py: Python<'_>) -> PyResult<&'static CStr>

Rendered class doc

fn lazy_type_object() -> &'static LazyTypeObject<Self>

fn dict_offset() -> Option<isize>

fn weaklist_offset() -> Option<isize>

impl<'a, 'py> PyFunctionArgument<'a, 'py> for &'a PyRemoteRecording

type Holder = Option<PyRef<'py, PyRemoteRecording>>

fn extract( obj: &'a Bound<'py, PyAny>, holder: &'a mut Self::Holder, ) -> PyResult<Self>

impl<'a, 'py> PyFunctionArgument<'a, 'py> for &'a mut PyRemoteRecording

type Holder = Option<PyRefMut<'py, PyRemoteRecording>>

fn extract( obj: &'a Bound<'py, PyAny>, holder: &'a mut Self::Holder, ) -> PyResult<Self>

impl PyMethods<PyRemoteRecording> for PyClassImplCollector<PyRemoteRecording>

fn py_methods(self) -> &'static PyClassItems

impl PyTypeInfo for PyRemoteRecording

const NAME: &'static str = "RemoteRecording"

Class name.

const MODULE: Option<&'static str> = ::core::option::Option::None

Module name, if any.

fn type_object_raw(py: Python<'_>) -> *mut PyTypeObject

Returns the PyTypeObject instance for this type.

fn type_object_bound(py: Python<'_>) -> Bound<'_, PyType>

Returns the safe abstraction over the type object.

fn is_type_of_bound(object: &Bound<'_, PyAny>) -> bool

Checks if object is an instance of this type or a subclass of this type.

fn is_exact_type_of_bound(object: &Bound<'_, PyAny>) -> bool

Checks if object is an instance of this type.

impl DerefToPyAny for PyRemoteRecording