Struct rerun_bindings::dataframe::PyRecordingView

pub struct PyRecordingView {
    pub(crate) recording: PyRecordingHandle,
    pub(crate) query_expression: QueryExpression,
}

A view of a recording restricted to a given index, containing a specific set of entities and components.

See [Recording.view(…)][rerun.dataframe.Recording.view] for details on how to create a RecordingView.

Note: RecordingView APIs never mutate the underlying view. Instead, they always return new views with the requested modifications applied.

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.

Fields

recording: PyRecordingHandle

query_expression: QueryExpression

Implementations

impl PyRecordingView

fn select_args( args: &Bound<'_, PyTuple>, columns: Option<Vec<AnyColumn>>, ) -> PyResult<Option<Vec<ColumnSelector>>>

impl PyRecordingView

A view of a recording restricted to a given index, containing a specific set of entities and components.

Can only be created by calling view(...) on a Recording.

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. 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.

fn schema(&self, py: Python<'_>) -> PyResult<PySchema>

The schema describing all the columns available in the view.

This schema will only contain the columns that are included in the view via the view contents.

fn select( &self, py: Python<'_>, args: &Bound<'_, PyTuple>, columns: Option<Vec<AnyColumn>>, ) -> PyResult<PyArrowType<Box<dyn RecordBatchReader + Send>>>

Select the columns from the view.

If no columns are provided, all available columns will be included in the output.

The selected columns do not change the rows that are included in the view. The rows are determined by the index values and the components that were included in the view contents, or can be overridden with [.using_index_values()][rerun.dataframe.RecordingView.using_index_values].

If a column was not provided with data for a given row, it will be null in the output.

The output is a [pyarrow.RecordBatchReader][] that can be used to read out the data.

Parameters

*args : AnyColumn The columns to select. columns : Optional[SequenceAnyColumn], optional Alternatively the columns to select can be provided as a sequence.

Returns

pa.RecordBatchReader A reader that can be used to read out the selected data.

fn select_static( &self, py: Python<'_>, args: &Bound<'_, PyTuple>, columns: Option<Vec<AnyColumn>>, ) -> PyResult<PyArrowType<Box<dyn RecordBatchReader + Send>>>

Select only the static columns from the view.

Because static data has no associated index values it does not cause a row to be generated in the output. If your view only contains static data this method allows you to select it without needing to provide index values.

This method will always return a single row.

Any non-static columns that are included in the selection will generate a warning and produce empty columns.

Parameters

*args : AnyColumn The columns to select. columns : Optional[SequenceAnyColumn], optional Alternatively the columns to select can be provided as a sequence.

Returns

pa.RecordBatchReader A reader that can be used to read out the selected data.

fn filter_range_sequence(&self, start: i64, end: i64) -> PyResult<Self>

Filter the view to only include data between the given index sequence numbers.

This range is inclusive and will contain both the value at the start and the value at the end.

The view must be of a sequential index type to use this method.

Parameters

start : int The inclusive start of the range. end : int The inclusive end of the range.

Returns

RecordingView A new view containing only the data within the specified range.

The original view will not be modified.

fn filter_range_seconds(&self, start: f64, end: f64) -> PyResult<Self>

Filter the view to only include data between the given index values expressed as seconds.

This range is inclusive and will contain both the value at the start and the value at the end.

The view must be of a temporal index type to use this method.

Parameters

start : int The inclusive start of the range. end : int The inclusive end of the range.

Returns

RecordingView A new view containing only the data within the specified range.

The original view will not be modified.

fn filter_range_nanos(&self, start: i64, end: i64) -> PyResult<Self>

Filter the view to only include data between the given index values expressed as seconds.

This range is inclusive and will contain both the value at the start and the value at the end.

The view must be of a temporal index type to use this method.

Parameters

start : int The inclusive start of the range. end : int The inclusive end of the range.

Returns

RecordingView A new view containing only the data within the specified range.

The original view will not be modified.

fn filter_index_values(&self, values: IndexValuesLike<'_>) -> PyResult<Self>

Filter the view to only include data at the provided index values.

The index values returned will be the intersection between the provided values and the original index values.

This requires index values to be a precise match. Index values in Rerun are represented as i64 sequence counts or nanoseconds. This API does not expose an interface in floating point seconds, as the numerical conversion would risk false mismatches.

Parameters

values : IndexValuesLike The index values to filter by.

Returns

RecordingView A new view containing only the data at the specified index values.

The original view will not be modified.

fn filter_is_not_null(&self, column: AnyComponentColumn) -> PyResult<Self>

Filter the view to only include rows where the given component column is not null.

This corresponds to rows for index values where this component was provided to Rerun explicitly via .log() or .send_columns().

Parameters

column : AnyComponentColumn The component column to filter by.

Returns

RecordingView A new view containing only the data where the specified component column is not null.

The original view will not be modified.

fn using_index_values(&self, values: IndexValuesLike<'_>) -> PyResult<Self>

Replace the index in the view with the provided values.

The output view will always have the same number of rows as the provided values, even if those rows are empty. Use with [.fill_latest_at()][rerun.dataframe.RecordingView.fill_latest_at] to populate these rows with the most recent data.

This requires index values to be a precise match. Index values in Rerun are represented as i64 sequence counts or nanoseconds. This API does not expose an interface in floating point seconds, as the numerical conversion would risk false mismatches.

Parameters

values : IndexValuesLike The index values to use.

Returns

RecordingView A new view containing the provided index values.

The original view will not be modified.

fn fill_latest_at(&self) -> Self

Populate any null values in a row with the latest valid data according to the index.

Returns

RecordingView A new view with the null values filled in.

The original view will not be modified.

Trait Implementations

impl Clone for PyRecordingView

fn clone(&self) -> PyRecordingView

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl IntoPy<Py<PyAny>> for PyRecordingView

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

Performs the conversion.

impl PyClass for PyRecordingView

type Frozen = False

Whether the pyclass is frozen.

impl PyClassImpl for PyRecordingView

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<PyRecordingView>

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 PyRecordingView

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

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

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

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

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

impl PyMethods<PyRecordingView> for PyClassImplCollector<PyRecordingView>

fn py_methods(self) -> &'static PyClassItems

impl PyTypeInfo for PyRecordingView

const NAME: &'static str = "RecordingView"

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 PyRecordingView