Components
rerun.blueprint.components
BackgroundKindArrayLike = BackgroundKind | Literal['GradientBright', 'GradientDark', 'SolidColor', 'gradientbright', 'gradientdark', 'solidcolor'] | int | Sequence[BackgroundKindLike]
module-attribute
A type alias for any BackgroundKind-like array object.
BackgroundKindLike = BackgroundKind | Literal['GradientBright', 'GradientDark', 'SolidColor', 'gradientbright', 'gradientdark', 'solidcolor'] | int
module-attribute
A type alias for any BackgroundKind-like object.
ColumnOrderArrayLike = ColumnOrder | Sequence[ColumnOrderLike]
module-attribute
A type alias for any ColumnOrder-like array object.
ColumnOrderLike = ColumnOrder | Sequence[datatypes.EntityPathLike]
module-attribute
A type alias for any ColumnOrder-like object.
ContainerKindArrayLike = ContainerKind | Literal['Grid', 'Horizontal', 'Tabs', 'Vertical', 'grid', 'horizontal', 'tabs', 'vertical'] | int | Sequence[ContainerKindLike]
module-attribute
A type alias for any ContainerKind-like array object.
ContainerKindLike = ContainerKind | Literal['Grid', 'Horizontal', 'Tabs', 'Vertical', 'grid', 'horizontal', 'tabs', 'vertical'] | int
module-attribute
A type alias for any ContainerKind-like object.
Corner2DArrayLike = Corner2D | Literal['LeftBottom', 'LeftTop', 'RightBottom', 'RightTop', 'leftbottom', 'lefttop', 'rightbottom', 'righttop'] | int | Sequence[Corner2DLike]
module-attribute
A type alias for any Corner2D-like array object.
Corner2DLike = Corner2D | Literal['LeftBottom', 'LeftTop', 'RightBottom', 'RightTop', 'leftbottom', 'lefttop', 'rightbottom', 'righttop'] | int
module-attribute
A type alias for any Corner2D-like object.
Eye3DKindArrayLike = Eye3DKind | Literal['FirstPerson', 'Orbital', 'firstperson', 'orbital'] | int | Sequence[Eye3DKindLike]
module-attribute
A type alias for any Eye3DKind-like array object.
Eye3DKindLike = Eye3DKind | Literal['FirstPerson', 'Orbital', 'firstperson', 'orbital'] | int
module-attribute
A type alias for any Eye3DKind-like object.
LinkAxisArrayLike = LinkAxis | Literal['Independent', 'LinkToGlobal', 'independent', 'linktoglobal'] | int | Sequence[LinkAxisLike]
module-attribute
A type alias for any LinkAxis-like array object.
LinkAxisLike = LinkAxis | Literal['Independent', 'LinkToGlobal', 'independent', 'linktoglobal'] | int
module-attribute
A type alias for any LinkAxis-like object.
LoopModeArrayLike = LoopMode | Literal['All', 'Off', 'Selection', 'all', 'off', 'selection'] | int | Sequence[LoopModeLike]
module-attribute
A type alias for any LoopMode-like array object.
LoopModeLike = LoopMode | Literal['All', 'Off', 'Selection', 'all', 'off', 'selection'] | int
module-attribute
A type alias for any LoopMode-like object.
MapProviderArrayLike = MapProvider | Literal['MapboxDark', 'MapboxLight', 'MapboxSatellite', 'MapboxStreets', 'OpenStreetMap', 'mapboxdark', 'mapboxlight', 'mapboxsatellite', 'mapboxstreets', 'openstreetmap'] | int | Sequence[MapProviderLike]
module-attribute
A type alias for any MapProvider-like array object.
MapProviderLike = MapProvider | Literal['MapboxDark', 'MapboxLight', 'MapboxSatellite', 'MapboxStreets', 'OpenStreetMap', 'mapboxdark', 'mapboxlight', 'mapboxsatellite', 'mapboxstreets', 'openstreetmap'] | int
module-attribute
A type alias for any MapProvider-like object.
PanelStateArrayLike = PanelState | Literal['Collapsed', 'Expanded', 'Hidden', 'collapsed', 'expanded', 'hidden'] | int | Sequence[PanelStateLike]
module-attribute
A type alias for any PanelState-like array object.
PanelStateLike = PanelState | Literal['Collapsed', 'Expanded', 'Hidden', 'collapsed', 'expanded', 'hidden'] | int
module-attribute
A type alias for any PanelState-like object.
PlayStateArrayLike = PlayState | Literal['Following', 'Paused', 'Playing', 'following', 'paused', 'playing'] | int | Sequence[PlayStateLike]
module-attribute
A type alias for any PlayState-like array object.
PlayStateLike = PlayState | Literal['Following', 'Paused', 'Playing', 'following', 'paused', 'playing'] | int
module-attribute
A type alias for any PlayState-like object.
ViewFitArrayLike = ViewFit | Literal['Fill', 'FillKeepAspectRatio', 'Original', 'fill', 'fillkeepaspectratio', 'original'] | int | Sequence[ViewFitLike]
module-attribute
A type alias for any ViewFit-like array object.
ViewFitLike = ViewFit | Literal['Fill', 'FillKeepAspectRatio', 'Original', 'fill', 'fillkeepaspectratio', 'original'] | int
module-attribute
A type alias for any ViewFit-like object.
class AbsoluteTimeRange
Bases: AbsoluteTimeRange, ComponentMixin
Component: A reference to a range of time.
⚠️ This type is unstable and may change significantly in a way that the data won't be backwards compatible.
def __init__(min, max)
Create a new instance of the AbsoluteTimeRange datatype.
| PARAMETER | DESCRIPTION |
|---|---|
min
|
Beginning of the time range.
TYPE:
|
max
|
End of the time range.
TYPE:
|
def arrow_type()
classmethod
The pyarrow type of this batch.
Part of the rerun.ComponentBatchLike logging interface.
def as_arrow_array()
The component as an arrow batch.
Part of the rerun.ComponentBatchLike logging interface.
def component_type()
classmethod
Returns the name of the component.
Part of the rerun.ComponentBatchLike logging interface.
class AbsoluteTimeRangeBatch
Bases: AbsoluteTimeRangeBatch, ComponentBatchMixin
def __init__(data, strict=None)
Construct a new batch.
This method must flexibly accept native data (which comply with type T). Subclasses must provide a type
parameter specifying the type of the native data (this is automatically handled by the code generator).
A value of None indicates that the component should be cleared and results in the creation of an empty array.
The actual creation of the Arrow array is delegated to the _native_to_pa_array() method, which is not
implemented by default.
| PARAMETER | DESCRIPTION |
|---|---|
data
|
The data to convert into an Arrow array.
TYPE:
|
strict
|
Whether to raise an exception if the data cannot be converted into an Arrow array. If None, the value
defaults to the value of the
TYPE:
|
| RETURNS | DESCRIPTION |
|---|---|
The Arrow array encapsulating the data.
|
|
def as_arrow_array()
The component as an arrow batch.
Part of the rerun.ComponentBatchLike logging interface.
def component_type()
Returns the name of the component.
Part of the rerun.ComponentBatchLike logging interface.
def described(descriptor)
Wraps the current ComponentBatchLike in a DescribedComponentBatch with the given descriptor.
def partition(lengths=None)
Partitions the component batch into multiple sub-batches, forming a column.
This makes it possible to use rr.send_columns to send columnar data directly into Rerun.
The returned columns will be partitioned into unit-length sub-batches by default.
Use ComponentColumn.partition to repartition the data as needed.
| PARAMETER | DESCRIPTION |
|---|---|
lengths
|
The offsets to partition the component at.
If specified,
TYPE:
|
| RETURNS | DESCRIPTION |
|---|---|
The partitioned component batch as a column.
|
|
class ActiveTab
Bases: EntityPath, ComponentMixin
Component: The active tab in a tabbed container.
⚠️ This type is unstable and may change significantly in a way that the data won't be backwards compatible.
def __init__(path)
Create a new instance of the EntityPath datatype.
def arrow_type()
classmethod
The pyarrow type of this batch.
Part of the rerun.ComponentBatchLike logging interface.
def as_arrow_array()
The component as an arrow batch.
Part of the rerun.ComponentBatchLike logging interface.
def component_type()
classmethod
Returns the name of the component.
Part of the rerun.ComponentBatchLike logging interface.
class ActiveTabBatch
Bases: EntityPathBatch, ComponentBatchMixin
def __init__(data, strict=None)
Construct a new batch.
This method must flexibly accept native data (which comply with type T). Subclasses must provide a type
parameter specifying the type of the native data (this is automatically handled by the code generator).
A value of None indicates that the component should be cleared and results in the creation of an empty array.
The actual creation of the Arrow array is delegated to the _native_to_pa_array() method, which is not
implemented by default.
| PARAMETER | DESCRIPTION |
|---|---|
data
|
The data to convert into an Arrow array.
TYPE:
|
strict
|
Whether to raise an exception if the data cannot be converted into an Arrow array. If None, the value
defaults to the value of the
TYPE:
|
| RETURNS | DESCRIPTION |
|---|---|
The Arrow array encapsulating the data.
|
|
def as_arrow_array()
The component as an arrow batch.
Part of the rerun.ComponentBatchLike logging interface.
def component_type()
Returns the name of the component.
Part of the rerun.ComponentBatchLike logging interface.
def described(descriptor)
Wraps the current ComponentBatchLike in a DescribedComponentBatch with the given descriptor.
def partition(lengths=None)
Partitions the component batch into multiple sub-batches, forming a column.
This makes it possible to use rr.send_columns to send columnar data directly into Rerun.
The returned columns will be partitioned into unit-length sub-batches by default.
Use ComponentColumn.partition to repartition the data as needed.
| PARAMETER | DESCRIPTION |
|---|---|
lengths
|
The offsets to partition the component at.
If specified,
TYPE:
|
| RETURNS | DESCRIPTION |
|---|---|
The partitioned component batch as a column.
|
|
class AngularSpeed
Bases: Float64, ComponentMixin
Component: Angular speed, used for rotation speed for example.
⚠️ This type is unstable and may change significantly in a way that the data won't be backwards compatible.
def __init__(value)
Create a new instance of the Float64 datatype.
def arrow_type()
classmethod
The pyarrow type of this batch.
Part of the rerun.ComponentBatchLike logging interface.
def as_arrow_array()
The component as an arrow batch.
Part of the rerun.ComponentBatchLike logging interface.
def component_type()
classmethod
Returns the name of the component.
Part of the rerun.ComponentBatchLike logging interface.
class AngularSpeedBatch
Bases: Float64Batch, ComponentBatchMixin
def __init__(data, strict=None)
Construct a new batch.
This method must flexibly accept native data (which comply with type T). Subclasses must provide a type
parameter specifying the type of the native data (this is automatically handled by the code generator).
A value of None indicates that the component should be cleared and results in the creation of an empty array.
The actual creation of the Arrow array is delegated to the _native_to_pa_array() method, which is not
implemented by default.
| PARAMETER | DESCRIPTION |
|---|---|
data
|
The data to convert into an Arrow array.
TYPE:
|
strict
|
Whether to raise an exception if the data cannot be converted into an Arrow array. If None, the value
defaults to the value of the
TYPE:
|
| RETURNS | DESCRIPTION |
|---|---|
The Arrow array encapsulating the data.
|
|
def as_arrow_array()
The component as an arrow batch.
Part of the rerun.ComponentBatchLike logging interface.
def component_type()
Returns the name of the component.
Part of the rerun.ComponentBatchLike logging interface.
def described(descriptor)
Wraps the current ComponentBatchLike in a DescribedComponentBatch with the given descriptor.
def partition(lengths=None)
Partitions the component batch into multiple sub-batches, forming a column.
This makes it possible to use rr.send_columns to send columnar data directly into Rerun.
The returned columns will be partitioned into unit-length sub-batches by default.
Use ComponentColumn.partition to repartition the data as needed.
| PARAMETER | DESCRIPTION |
|---|---|
lengths
|
The offsets to partition the component at.
If specified,
TYPE:
|
| RETURNS | DESCRIPTION |
|---|---|
The partitioned component batch as a column.
|
|
class ApplyLatestAt
Bases: Bool, ComponentMixin
Component: Whether empty cells in a dataframe should be filled with a latest-at query.
⚠️ This type is unstable and may change significantly in a way that the data won't be backwards compatible.
def __init__(value)
Create a new instance of the Bool datatype.
def arrow_type()
classmethod
The pyarrow type of this batch.
Part of the rerun.ComponentBatchLike logging interface.
def as_arrow_array()
The component as an arrow batch.
Part of the rerun.ComponentBatchLike logging interface.
def component_type()
classmethod
Returns the name of the component.
Part of the rerun.ComponentBatchLike logging interface.
class ApplyLatestAtBatch
Bases: BoolBatch, ComponentBatchMixin
def __init__(data, strict=None)
Construct a new batch.
This method must flexibly accept native data (which comply with type T). Subclasses must provide a type
parameter specifying the type of the native data (this is automatically handled by the code generator).
A value of None indicates that the component should be cleared and results in the creation of an empty array.
The actual creation of the Arrow array is delegated to the _native_to_pa_array() method, which is not
implemented by default.
| PARAMETER | DESCRIPTION |
|---|---|
data
|
The data to convert into an Arrow array.
TYPE:
|
strict
|
Whether to raise an exception if the data cannot be converted into an Arrow array. If None, the value
defaults to the value of the
TYPE:
|
| RETURNS | DESCRIPTION |
|---|---|
The Arrow array encapsulating the data.
|
|
def as_arrow_array()
The component as an arrow batch.
Part of the rerun.ComponentBatchLike logging interface.
def component_type()
Returns the name of the component.
Part of the rerun.ComponentBatchLike logging interface.
def described(descriptor)
Wraps the current ComponentBatchLike in a DescribedComponentBatch with the given descriptor.
def partition(lengths=None)
Partitions the component batch into multiple sub-batches, forming a column.
This makes it possible to use rr.send_columns to send columnar data directly into Rerun.
The returned columns will be partitioned into unit-length sub-batches by default.
Use ComponentColumn.partition to repartition the data as needed.
| PARAMETER | DESCRIPTION |
|---|---|
lengths
|
The offsets to partition the component at.
If specified,
TYPE:
|
| RETURNS | DESCRIPTION |
|---|---|
The partitioned component batch as a column.
|
|
class AutoLayout
Bases: Bool, ComponentMixin
Component: Whether the viewport layout is determined automatically.
⚠️ This type is unstable and may change significantly in a way that the data won't be backwards compatible.
def __init__(value)
Create a new instance of the Bool datatype.
def arrow_type()
classmethod
The pyarrow type of this batch.
Part of the rerun.ComponentBatchLike logging interface.
def as_arrow_array()
The component as an arrow batch.
Part of the rerun.ComponentBatchLike logging interface.
def component_type()
classmethod
Returns the name of the component.
Part of the rerun.ComponentBatchLike logging interface.
class AutoLayoutBatch
Bases: BoolBatch, ComponentBatchMixin
def __init__(data, strict=None)
Construct a new batch.
This method must flexibly accept native data (which comply with type T). Subclasses must provide a type
parameter specifying the type of the native data (this is automatically handled by the code generator).
A value of None indicates that the component should be cleared and results in the creation of an empty array.
The actual creation of the Arrow array is delegated to the _native_to_pa_array() method, which is not
implemented by default.
| PARAMETER | DESCRIPTION |
|---|---|
data
|
The data to convert into an Arrow array.
TYPE:
|
strict
|
Whether to raise an exception if the data cannot be converted into an Arrow array. If None, the value
defaults to the value of the
TYPE:
|
| RETURNS | DESCRIPTION |
|---|---|
The Arrow array encapsulating the data.
|
|
def as_arrow_array()
The component as an arrow batch.
Part of the rerun.ComponentBatchLike logging interface.
def component_type()
Returns the name of the component.
Part of the rerun.ComponentBatchLike logging interface.
def described(descriptor)
Wraps the current ComponentBatchLike in a DescribedComponentBatch with the given descriptor.
def partition(lengths=None)
Partitions the component batch into multiple sub-batches, forming a column.
This makes it possible to use rr.send_columns to send columnar data directly into Rerun.
The returned columns will be partitioned into unit-length sub-batches by default.
Use ComponentColumn.partition to repartition the data as needed.
| PARAMETER | DESCRIPTION |
|---|---|
lengths
|
The offsets to partition the component at.
If specified,
TYPE:
|
| RETURNS | DESCRIPTION |
|---|---|
The partitioned component batch as a column.
|
|
class AutoScroll
Bases: Bool, ComponentMixin
Component: Whether the view should auto-scroll to follow the time cursor.
⚠️ This type is unstable and may change significantly in a way that the data won't be backwards compatible.
def __init__(value)
Create a new instance of the Bool datatype.
def arrow_type()
classmethod
The pyarrow type of this batch.
Part of the rerun.ComponentBatchLike logging interface.
def as_arrow_array()
The component as an arrow batch.
Part of the rerun.ComponentBatchLike logging interface.
def component_type()
classmethod
Returns the name of the component.
Part of the rerun.ComponentBatchLike logging interface.
class AutoScrollBatch
Bases: BoolBatch, ComponentBatchMixin
def __init__(data, strict=None)
Construct a new batch.
This method must flexibly accept native data (which comply with type T). Subclasses must provide a type
parameter specifying the type of the native data (this is automatically handled by the code generator).
A value of None indicates that the component should be cleared and results in the creation of an empty array.
The actual creation of the Arrow array is delegated to the _native_to_pa_array() method, which is not
implemented by default.
| PARAMETER | DESCRIPTION |
|---|---|
data
|
The data to convert into an Arrow array.
TYPE:
|
strict
|
Whether to raise an exception if the data cannot be converted into an Arrow array. If None, the value
defaults to the value of the
TYPE:
|
| RETURNS | DESCRIPTION |
|---|---|
The Arrow array encapsulating the data.
|
|
def as_arrow_array()
The component as an arrow batch.
Part of the rerun.ComponentBatchLike logging interface.
def component_type()
Returns the name of the component.
Part of the rerun.ComponentBatchLike logging interface.
def described(descriptor)
Wraps the current ComponentBatchLike in a DescribedComponentBatch with the given descriptor.
def partition(lengths=None)
Partitions the component batch into multiple sub-batches, forming a column.
This makes it possible to use rr.send_columns to send columnar data directly into Rerun.
The returned columns will be partitioned into unit-length sub-batches by default.
Use ComponentColumn.partition to repartition the data as needed.
| PARAMETER | DESCRIPTION |
|---|---|
lengths
|
The offsets to partition the component at.
If specified,
TYPE:
|
| RETURNS | DESCRIPTION |
|---|---|
The partitioned component batch as a column.
|
|
class AutoViews
Bases: Bool, ComponentMixin
Component: Whether or not views should be created automatically.
⚠️ This type is unstable and may change significantly in a way that the data won't be backwards compatible.
def __init__(value)
Create a new instance of the Bool datatype.
def arrow_type()
classmethod
The pyarrow type of this batch.
Part of the rerun.ComponentBatchLike logging interface.
def as_arrow_array()
The component as an arrow batch.
Part of the rerun.ComponentBatchLike logging interface.
def component_type()
classmethod
Returns the name of the component.
Part of the rerun.ComponentBatchLike logging interface.
class AutoViewsBatch
Bases: BoolBatch, ComponentBatchMixin
def __init__(data, strict=None)
Construct a new batch.
This method must flexibly accept native data (which comply with type T). Subclasses must provide a type
parameter specifying the type of the native data (this is automatically handled by the code generator).
A value of None indicates that the component should be cleared and results in the creation of an empty array.
The actual creation of the Arrow array is delegated to the _native_to_pa_array() method, which is not
implemented by default.
| PARAMETER | DESCRIPTION |
|---|---|
data
|
The data to convert into an Arrow array.
TYPE:
|
strict
|
Whether to raise an exception if the data cannot be converted into an Arrow array. If None, the value
defaults to the value of the
TYPE:
|
| RETURNS | DESCRIPTION |
|---|---|
The Arrow array encapsulating the data.
|
|
def as_arrow_array()
The component as an arrow batch.
Part of the rerun.ComponentBatchLike logging interface.
def component_type()
Returns the name of the component.
Part of the rerun.ComponentBatchLike logging interface.
def described(descriptor)
Wraps the current ComponentBatchLike in a DescribedComponentBatch with the given descriptor.
def partition(lengths=None)
Partitions the component batch into multiple sub-batches, forming a column.
This makes it possible to use rr.send_columns to send columnar data directly into Rerun.
The returned columns will be partitioned into unit-length sub-batches by default.
Use ComponentColumn.partition to repartition the data as needed.
| PARAMETER | DESCRIPTION |
|---|---|
lengths
|
The offsets to partition the component at.
If specified,
TYPE:
|
| RETURNS | DESCRIPTION |
|---|---|
The partitioned component batch as a column.
|
|
class BackgroundKind
Bases: Enum
Component: The type of the background in a view.
GradientBright = 2
class-attribute
instance-attribute
A bright gradient.
In 3D views it changes depending on the direction of the view.
GradientDark = 1
class-attribute
instance-attribute
A dark gradient.
In 3D views it changes depending on the direction of the view.
SolidColor = 3
class-attribute
instance-attribute
Simple uniform color.
def __str__()
Returns the variant name.
def auto(val)
classmethod
Best-effort converter, including a case-insensitive string matcher.
class BackgroundKindBatch
Bases: BaseBatch[BackgroundKindArrayLike], ComponentBatchMixin
def __init__(data, strict=None)
Construct a new batch.
This method must flexibly accept native data (which comply with type T). Subclasses must provide a type
parameter specifying the type of the native data (this is automatically handled by the code generator).
A value of None indicates that the component should be cleared and results in the creation of an empty array.
The actual creation of the Arrow array is delegated to the _native_to_pa_array() method, which is not
implemented by default.
| PARAMETER | DESCRIPTION |
|---|---|
data
|
The data to convert into an Arrow array.
TYPE:
|
strict
|
Whether to raise an exception if the data cannot be converted into an Arrow array. If None, the value
defaults to the value of the
TYPE:
|
| RETURNS | DESCRIPTION |
|---|---|
The Arrow array encapsulating the data.
|
|
def as_arrow_array()
The component as an arrow batch.
Part of the rerun.ComponentBatchLike logging interface.
def component_type()
Returns the name of the component.
Part of the rerun.ComponentBatchLike logging interface.
def described(descriptor)
Wraps the current ComponentBatchLike in a DescribedComponentBatch with the given descriptor.
def partition(lengths=None)
Partitions the component batch into multiple sub-batches, forming a column.
This makes it possible to use rr.send_columns to send columnar data directly into Rerun.
The returned columns will be partitioned into unit-length sub-batches by default.
Use ComponentColumn.partition to repartition the data as needed.
| PARAMETER | DESCRIPTION |
|---|---|
lengths
|
The offsets to partition the component at.
If specified,
TYPE:
|
| RETURNS | DESCRIPTION |
|---|---|
The partitioned component batch as a column.
|
|
class ColumnName
Bases: Utf8, ComponentMixin
Component: The name of a column in a table.
⚠️ This type is unstable and may change significantly in a way that the data won't be backwards compatible.
def __init__(value)
Create a new instance of the Utf8 datatype.
def arrow_type()
classmethod
The pyarrow type of this batch.
Part of the rerun.ComponentBatchLike logging interface.
def as_arrow_array()
The component as an arrow batch.
Part of the rerun.ComponentBatchLike logging interface.
def component_type()
classmethod
Returns the name of the component.
Part of the rerun.ComponentBatchLike logging interface.
class ColumnNameBatch
Bases: Utf8Batch, ComponentBatchMixin
def __init__(data, strict=None)
Construct a new batch.
This method must flexibly accept native data (which comply with type T). Subclasses must provide a type
parameter specifying the type of the native data (this is automatically handled by the code generator).
A value of None indicates that the component should be cleared and results in the creation of an empty array.
The actual creation of the Arrow array is delegated to the _native_to_pa_array() method, which is not
implemented by default.
| PARAMETER | DESCRIPTION |
|---|---|
data
|
The data to convert into an Arrow array.
TYPE:
|
strict
|
Whether to raise an exception if the data cannot be converted into an Arrow array. If None, the value
defaults to the value of the
TYPE:
|
| RETURNS | DESCRIPTION |
|---|---|
The Arrow array encapsulating the data.
|
|
def as_arrow_array()
The component as an arrow batch.
Part of the rerun.ComponentBatchLike logging interface.
def component_type()
Returns the name of the component.
Part of the rerun.ComponentBatchLike logging interface.
def described(descriptor)
Wraps the current ComponentBatchLike in a DescribedComponentBatch with the given descriptor.
def partition(lengths=None)
Partitions the component batch into multiple sub-batches, forming a column.
This makes it possible to use rr.send_columns to send columnar data directly into Rerun.
The returned columns will be partitioned into unit-length sub-batches by default.
Use ComponentColumn.partition to repartition the data as needed.
| PARAMETER | DESCRIPTION |
|---|---|
lengths
|
The offsets to partition the component at.
If specified,
TYPE:
|
| RETURNS | DESCRIPTION |
|---|---|
The partitioned component batch as a column.
|
|
class ColumnOrder
Bases: ColumnOrderExt, ComponentMixin
Component: The order of component columns (which remain always grouped by entity path) in the dataframe view.
Entities not in this list are appended at the end in their default order. Entities in this list that are not present in the view are ignored.
⚠️ This type is unstable and may change significantly in a way that the data won't be backwards compatible.
def __init__(entity_paths)
Create a new instance of the ColumnOrder component.
def arrow_type()
classmethod
The pyarrow type of this batch.
Part of the rerun.ComponentBatchLike logging interface.
def as_arrow_array()
The component as an arrow batch.
Part of the rerun.ComponentBatchLike logging interface.
def component_type()
classmethod
Returns the name of the component.
Part of the rerun.ComponentBatchLike logging interface.
class ColumnOrderBatch
Bases: BaseBatch[ColumnOrderArrayLike], ComponentBatchMixin
def __init__(data, strict=None)
Construct a new batch.
This method must flexibly accept native data (which comply with type T). Subclasses must provide a type
parameter specifying the type of the native data (this is automatically handled by the code generator).
A value of None indicates that the component should be cleared and results in the creation of an empty array.
The actual creation of the Arrow array is delegated to the _native_to_pa_array() method, which is not
implemented by default.
| PARAMETER | DESCRIPTION |
|---|---|
data
|
The data to convert into an Arrow array.
TYPE:
|
strict
|
Whether to raise an exception if the data cannot be converted into an Arrow array. If None, the value
defaults to the value of the
TYPE:
|
| RETURNS | DESCRIPTION |
|---|---|
The Arrow array encapsulating the data.
|
|
def as_arrow_array()
The component as an arrow batch.
Part of the rerun.ComponentBatchLike logging interface.
def component_type()
Returns the name of the component.
Part of the rerun.ComponentBatchLike logging interface.
def described(descriptor)
Wraps the current ComponentBatchLike in a DescribedComponentBatch with the given descriptor.
def partition(lengths=None)
Partitions the component batch into multiple sub-batches, forming a column.
This makes it possible to use rr.send_columns to send columnar data directly into Rerun.
The returned columns will be partitioned into unit-length sub-batches by default.
Use ComponentColumn.partition to repartition the data as needed.
| PARAMETER | DESCRIPTION |
|---|---|
lengths
|
The offsets to partition the component at.
If specified,
TYPE:
|
| RETURNS | DESCRIPTION |
|---|---|
The partitioned component batch as a column.
|
|
class ColumnShare
Bases: Float32, ComponentMixin
Component: The layout share of a column in the container.
⚠️ This type is unstable and may change significantly in a way that the data won't be backwards compatible.
def __init__(value)
Create a new instance of the Float32 datatype.
def arrow_type()
classmethod
The pyarrow type of this batch.
Part of the rerun.ComponentBatchLike logging interface.
def as_arrow_array()
The component as an arrow batch.
Part of the rerun.ComponentBatchLike logging interface.
def component_type()
classmethod
Returns the name of the component.
Part of the rerun.ComponentBatchLike logging interface.
class ColumnShareBatch
Bases: Float32Batch, ComponentBatchMixin
def __init__(data, strict=None)
Construct a new batch.
This method must flexibly accept native data (which comply with type T). Subclasses must provide a type
parameter specifying the type of the native data (this is automatically handled by the code generator).
A value of None indicates that the component should be cleared and results in the creation of an empty array.
The actual creation of the Arrow array is delegated to the _native_to_pa_array() method, which is not
implemented by default.
| PARAMETER | DESCRIPTION |
|---|---|
data
|
The data to convert into an Arrow array.
TYPE:
|
strict
|
Whether to raise an exception if the data cannot be converted into an Arrow array. If None, the value
defaults to the value of the
TYPE:
|
| RETURNS | DESCRIPTION |
|---|---|
The Arrow array encapsulating the data.
|
|
def as_arrow_array()
The component as an arrow batch.
Part of the rerun.ComponentBatchLike logging interface.
def component_type()
Returns the name of the component.
Part of the rerun.ComponentBatchLike logging interface.
def described(descriptor)
Wraps the current ComponentBatchLike in a DescribedComponentBatch with the given descriptor.
def partition(lengths=None)
Partitions the component batch into multiple sub-batches, forming a column.
This makes it possible to use rr.send_columns to send columnar data directly into Rerun.
The returned columns will be partitioned into unit-length sub-batches by default.
Use ComponentColumn.partition to repartition the data as needed.
| PARAMETER | DESCRIPTION |
|---|---|
lengths
|
The offsets to partition the component at.
If specified,
TYPE:
|
| RETURNS | DESCRIPTION |
|---|---|
The partitioned component batch as a column.
|
|
class ComponentColumnSelector
Bases: ComponentColumnSelector, ComponentMixin
Component: Describe a component column to be selected in the dataframe view.
⚠️ This type is unstable and may change significantly in a way that the data won't be backwards compatible.
def __init__(spec=None, *, entity_path=None, component=None)
Create a new instance of the ComponentColumnSelector datatype.
| PARAMETER | DESCRIPTION |
|---|---|
spec
|
A string in the format "/entity/path:Component". If used,
TYPE:
|
entity_path
|
The column's entity path. If used,
TYPE:
|
component
|
The column's component type. If used,
TYPE:
|
def arrow_type()
classmethod
The pyarrow type of this batch.
Part of the rerun.ComponentBatchLike logging interface.
def as_arrow_array()
The component as an arrow batch.
Part of the rerun.ComponentBatchLike logging interface.
def component_type()
classmethod
Returns the name of the component.
Part of the rerun.ComponentBatchLike logging interface.
class ComponentColumnSelectorBatch
Bases: ComponentColumnSelectorBatch, ComponentBatchMixin
def __init__(data, strict=None)
Construct a new batch.
This method must flexibly accept native data (which comply with type T). Subclasses must provide a type
parameter specifying the type of the native data (this is automatically handled by the code generator).
A value of None indicates that the component should be cleared and results in the creation of an empty array.
The actual creation of the Arrow array is delegated to the _native_to_pa_array() method, which is not
implemented by default.
| PARAMETER | DESCRIPTION |
|---|---|
data
|
The data to convert into an Arrow array.
TYPE:
|
strict
|
Whether to raise an exception if the data cannot be converted into an Arrow array. If None, the value
defaults to the value of the
TYPE:
|
| RETURNS | DESCRIPTION |
|---|---|
The Arrow array encapsulating the data.
|
|
def as_arrow_array()
The component as an arrow batch.
Part of the rerun.ComponentBatchLike logging interface.
def component_type()
Returns the name of the component.
Part of the rerun.ComponentBatchLike logging interface.
def described(descriptor)
Wraps the current ComponentBatchLike in a DescribedComponentBatch with the given descriptor.
def partition(lengths=None)
Partitions the component batch into multiple sub-batches, forming a column.
This makes it possible to use rr.send_columns to send columnar data directly into Rerun.
The returned columns will be partitioned into unit-length sub-batches by default.
Use ComponentColumn.partition to repartition the data as needed.
| PARAMETER | DESCRIPTION |
|---|---|
lengths
|
The offsets to partition the component at.
If specified,
TYPE:
|
| RETURNS | DESCRIPTION |
|---|---|
The partitioned component batch as a column.
|
|
class ContainerKind
Bases: Enum
Component: The kind of a blueprint container (tabs, grid, …).
Grid = 4
class-attribute
instance-attribute
Organize children in a grid layout
Horizontal = 2
class-attribute
instance-attribute
Order the children left to right
Tabs = 1
class-attribute
instance-attribute
Put children in separate tabs
Vertical = 3
class-attribute
instance-attribute
Order the children top to bottom
def __str__()
Returns the variant name.
def auto(val)
classmethod
Best-effort converter, including a case-insensitive string matcher.
class ContainerKindBatch
Bases: BaseBatch[ContainerKindArrayLike], ComponentBatchMixin
def __init__(data, strict=None)
Construct a new batch.
This method must flexibly accept native data (which comply with type T). Subclasses must provide a type
parameter specifying the type of the native data (this is automatically handled by the code generator).
A value of None indicates that the component should be cleared and results in the creation of an empty array.
The actual creation of the Arrow array is delegated to the _native_to_pa_array() method, which is not
implemented by default.
| PARAMETER | DESCRIPTION |
|---|---|
data
|
The data to convert into an Arrow array.
TYPE:
|
strict
|
Whether to raise an exception if the data cannot be converted into an Arrow array. If None, the value
defaults to the value of the
TYPE:
|
| RETURNS | DESCRIPTION |
|---|---|
The Arrow array encapsulating the data.
|
|
def as_arrow_array()
The component as an arrow batch.
Part of the rerun.ComponentBatchLike logging interface.
def component_type()
Returns the name of the component.
Part of the rerun.ComponentBatchLike logging interface.
def described(descriptor)
Wraps the current ComponentBatchLike in a DescribedComponentBatch with the given descriptor.
def partition(lengths=None)
Partitions the component batch into multiple sub-batches, forming a column.
This makes it possible to use rr.send_columns to send columnar data directly into Rerun.
The returned columns will be partitioned into unit-length sub-batches by default.
Use ComponentColumn.partition to repartition the data as needed.
| PARAMETER | DESCRIPTION |
|---|---|
lengths
|
The offsets to partition the component at.
If specified,
TYPE:
|
| RETURNS | DESCRIPTION |
|---|---|
The partitioned component batch as a column.
|
|
class Corner2D
Bases: Enum
Component: One of four 2D corners, typically used to align objects.
LeftBottom = 3
class-attribute
instance-attribute
Left bottom corner.
LeftTop = 1
class-attribute
instance-attribute
Left top corner.
RightBottom = 4
class-attribute
instance-attribute
Right bottom corner.
RightTop = 2
class-attribute
instance-attribute
Right top corner.
def __str__()
Returns the variant name.
def auto(val)
classmethod
Best-effort converter, including a case-insensitive string matcher.
class Corner2DBatch
Bases: BaseBatch[Corner2DArrayLike], ComponentBatchMixin
def __init__(data, strict=None)
Construct a new batch.
This method must flexibly accept native data (which comply with type T). Subclasses must provide a type
parameter specifying the type of the native data (this is automatically handled by the code generator).
A value of None indicates that the component should be cleared and results in the creation of an empty array.
The actual creation of the Arrow array is delegated to the _native_to_pa_array() method, which is not
implemented by default.
| PARAMETER | DESCRIPTION |
|---|---|
data
|
The data to convert into an Arrow array.
TYPE:
|
strict
|
Whether to raise an exception if the data cannot be converted into an Arrow array. If None, the value
defaults to the value of the
TYPE:
|
| RETURNS | DESCRIPTION |
|---|---|
The Arrow array encapsulating the data.
|
|
def as_arrow_array()
The component as an arrow batch.
Part of the rerun.ComponentBatchLike logging interface.
def component_type()
Returns the name of the component.
Part of the rerun.ComponentBatchLike logging interface.
def described(descriptor)
Wraps the current ComponentBatchLike in a DescribedComponentBatch with the given descriptor.
def partition(lengths=None)
Partitions the component batch into multiple sub-batches, forming a column.
This makes it possible to use rr.send_columns to send columnar data directly into Rerun.
The returned columns will be partitioned into unit-length sub-batches by default.
Use ComponentColumn.partition to repartition the data as needed.
| PARAMETER | DESCRIPTION |
|---|---|
lengths
|
The offsets to partition the component at.
If specified,
TYPE:
|
| RETURNS | DESCRIPTION |
|---|---|
The partitioned component batch as a column.
|
|
class Enabled
Bases: Bool, ComponentMixin
Component: Whether a procedure is enabled.
⚠️ This type is unstable and may change significantly in a way that the data won't be backwards compatible.
def __init__(value)
Create a new instance of the Bool datatype.
def arrow_type()
classmethod
The pyarrow type of this batch.
Part of the rerun.ComponentBatchLike logging interface.
def as_arrow_array()
The component as an arrow batch.
Part of the rerun.ComponentBatchLike logging interface.
def component_type()
classmethod
Returns the name of the component.
Part of the rerun.ComponentBatchLike logging interface.
class EnabledBatch
Bases: BoolBatch, ComponentBatchMixin
def __init__(data, strict=None)
Construct a new batch.
This method must flexibly accept native data (which comply with type T). Subclasses must provide a type
parameter specifying the type of the native data (this is automatically handled by the code generator).
A value of None indicates that the component should be cleared and results in the creation of an empty array.
The actual creation of the Arrow array is delegated to the _native_to_pa_array() method, which is not
implemented by default.
| PARAMETER | DESCRIPTION |
|---|---|
data
|
The data to convert into an Arrow array.
TYPE:
|
strict
|
Whether to raise an exception if the data cannot be converted into an Arrow array. If None, the value
defaults to the value of the
TYPE:
|
| RETURNS | DESCRIPTION |
|---|---|
The Arrow array encapsulating the data.
|
|
def as_arrow_array()
The component as an arrow batch.
Part of the rerun.ComponentBatchLike logging interface.
def component_type()
Returns the name of the component.
Part of the rerun.ComponentBatchLike logging interface.
def described(descriptor)
Wraps the current ComponentBatchLike in a DescribedComponentBatch with the given descriptor.
def partition(lengths=None)
Partitions the component batch into multiple sub-batches, forming a column.
This makes it possible to use rr.send_columns to send columnar data directly into Rerun.
The returned columns will be partitioned into unit-length sub-batches by default.
Use ComponentColumn.partition to repartition the data as needed.
| PARAMETER | DESCRIPTION |
|---|---|
lengths
|
The offsets to partition the component at.
If specified,
TYPE:
|
| RETURNS | DESCRIPTION |
|---|---|
The partitioned component batch as a column.
|
|
class Eye3DKind
Bases: Enum
Component: The kind of the 3D eye to view a scene in a views.Spatial3DView.
This is used to specify how the controls of the view react to user input (such as mouse gestures).
FirstPerson = 1
class-attribute
instance-attribute
First person point of view.
The camera perspective as if one is seeing it through the eyes of a person as popularized by first-person games. The center of rotation is the position of the eye (the camera). Dragging the mouse on the spatial 3D view, will rotation the scene as if one is moving their head around.
Orbital = 2
class-attribute
instance-attribute
Orbital eye.
The center of rotation is located to a center location in front of the eye (it is different from the eye location itself), as if the eye was orbiting around the scene.
def __str__()
Returns the variant name.
def auto(val)
classmethod
Best-effort converter, including a case-insensitive string matcher.
class Eye3DKindBatch
Bases: BaseBatch[Eye3DKindArrayLike], ComponentBatchMixin
def __init__(data, strict=None)
Construct a new batch.
This method must flexibly accept native data (which comply with type T). Subclasses must provide a type
parameter specifying the type of the native data (this is automatically handled by the code generator).
A value of None indicates that the component should be cleared and results in the creation of an empty array.
The actual creation of the Arrow array is delegated to the _native_to_pa_array() method, which is not
implemented by default.
| PARAMETER | DESCRIPTION |
|---|---|
data
|
The data to convert into an Arrow array.
TYPE:
|
strict
|
Whether to raise an exception if the data cannot be converted into an Arrow array. If None, the value
defaults to the value of the
TYPE:
|
| RETURNS | DESCRIPTION |
|---|---|
The Arrow array encapsulating the data.
|
|
def as_arrow_array()
The component as an arrow batch.
Part of the rerun.ComponentBatchLike logging interface.
def component_type()
Returns the name of the component.
Part of the rerun.ComponentBatchLike logging interface.
def described(descriptor)
Wraps the current ComponentBatchLike in a DescribedComponentBatch with the given descriptor.
def partition(lengths=None)
Partitions the component batch into multiple sub-batches, forming a column.
This makes it possible to use rr.send_columns to send columnar data directly into Rerun.
The returned columns will be partitioned into unit-length sub-batches by default.
Use ComponentColumn.partition to repartition the data as needed.
| PARAMETER | DESCRIPTION |
|---|---|
lengths
|
The offsets to partition the component at.
If specified,
TYPE:
|
| RETURNS | DESCRIPTION |
|---|---|
The partitioned component batch as a column.
|
|
class FilterByRange
Bases: FilterByRange, ComponentMixin
Component: Configuration for a filter-by-range feature of the dataframe view.
⚠️ This type is unstable and may change significantly in a way that the data won't be backwards compatible.
def __init__(start, end)
Create a new instance of the FilterByRange datatype.
| PARAMETER | DESCRIPTION |
|---|---|
start
|
Beginning of the time range.
TYPE:
|
end
|
End of the time range (inclusive).
TYPE:
|
def arrow_type()
classmethod
The pyarrow type of this batch.
Part of the rerun.ComponentBatchLike logging interface.
def as_arrow_array()
The component as an arrow batch.
Part of the rerun.ComponentBatchLike logging interface.
def component_type()
classmethod
Returns the name of the component.
Part of the rerun.ComponentBatchLike logging interface.
class FilterByRangeBatch
Bases: FilterByRangeBatch, ComponentBatchMixin
def __init__(data, strict=None)
Construct a new batch.
This method must flexibly accept native data (which comply with type T). Subclasses must provide a type
parameter specifying the type of the native data (this is automatically handled by the code generator).
A value of None indicates that the component should be cleared and results in the creation of an empty array.
The actual creation of the Arrow array is delegated to the _native_to_pa_array() method, which is not
implemented by default.
| PARAMETER | DESCRIPTION |
|---|---|
data
|
The data to convert into an Arrow array.
TYPE:
|
strict
|
Whether to raise an exception if the data cannot be converted into an Arrow array. If None, the value
defaults to the value of the
TYPE:
|
| RETURNS | DESCRIPTION |
|---|---|
The Arrow array encapsulating the data.
|
|
def as_arrow_array()
The component as an arrow batch.
Part of the rerun.ComponentBatchLike logging interface.
def component_type()
Returns the name of the component.
Part of the rerun.ComponentBatchLike logging interface.
def described(descriptor)
Wraps the current ComponentBatchLike in a DescribedComponentBatch with the given descriptor.
def partition(lengths=None)
Partitions the component batch into multiple sub-batches, forming a column.
This makes it possible to use rr.send_columns to send columnar data directly into Rerun.
The returned columns will be partitioned into unit-length sub-batches by default.
Use ComponentColumn.partition to repartition the data as needed.
| PARAMETER | DESCRIPTION |
|---|---|
lengths
|
The offsets to partition the component at.
If specified,
TYPE:
|
| RETURNS | DESCRIPTION |
|---|---|
The partitioned component batch as a column.
|
|
class FilterIsNotNull
Bases: FilterIsNotNull, ComponentMixin
Component: Configuration for the filter is not null feature of the dataframe view.
⚠️ This type is unstable and may change significantly in a way that the data won't be backwards compatible.
def __init__(active, column)
Create a new instance of the FilterIsNotNull datatype.
| PARAMETER | DESCRIPTION |
|---|---|
active
|
Whether the filter by event feature is active.
TYPE:
|
column
|
The column used when the filter by event feature is used. |
def arrow_type()
classmethod
The pyarrow type of this batch.
Part of the rerun.ComponentBatchLike logging interface.
def as_arrow_array()
The component as an arrow batch.
Part of the rerun.ComponentBatchLike logging interface.
def component_type()
classmethod
Returns the name of the component.
Part of the rerun.ComponentBatchLike logging interface.
class FilterIsNotNullBatch
Bases: FilterIsNotNullBatch, ComponentBatchMixin
def __init__(data, strict=None)
Construct a new batch.
This method must flexibly accept native data (which comply with type T). Subclasses must provide a type
parameter specifying the type of the native data (this is automatically handled by the code generator).
A value of None indicates that the component should be cleared and results in the creation of an empty array.
The actual creation of the Arrow array is delegated to the _native_to_pa_array() method, which is not
implemented by default.
| PARAMETER | DESCRIPTION |
|---|---|
data
|
The data to convert into an Arrow array.
TYPE:
|
strict
|
Whether to raise an exception if the data cannot be converted into an Arrow array. If None, the value
defaults to the value of the
TYPE:
|
| RETURNS | DESCRIPTION |
|---|---|
The Arrow array encapsulating the data.
|
|
def as_arrow_array()
The component as an arrow batch.
Part of the rerun.ComponentBatchLike logging interface.
def component_type()
Returns the name of the component.
Part of the rerun.ComponentBatchLike logging interface.
def described(descriptor)
Wraps the current ComponentBatchLike in a DescribedComponentBatch with the given descriptor.
def partition(lengths=None)
Partitions the component batch into multiple sub-batches, forming a column.
This makes it possible to use rr.send_columns to send columnar data directly into Rerun.
The returned columns will be partitioned into unit-length sub-batches by default.
Use ComponentColumn.partition to repartition the data as needed.
| PARAMETER | DESCRIPTION |
|---|---|
lengths
|
The offsets to partition the component at.
If specified,
TYPE:
|
| RETURNS | DESCRIPTION |
|---|---|
The partitioned component batch as a column.
|
|
class ForceDistance
Bases: Float64, ComponentMixin
Component: The target distance between two nodes.
This is helpful to scale the layout, for example if long labels are involved.
⚠️ This type is unstable and may change significantly in a way that the data won't be backwards compatible.
def __init__(value)
Create a new instance of the Float64 datatype.
def arrow_type()
classmethod
The pyarrow type of this batch.
Part of the rerun.ComponentBatchLike logging interface.
def as_arrow_array()
The component as an arrow batch.
Part of the rerun.ComponentBatchLike logging interface.
def component_type()
classmethod
Returns the name of the component.
Part of the rerun.ComponentBatchLike logging interface.
class ForceDistanceBatch
Bases: Float64Batch, ComponentBatchMixin
def __init__(data, strict=None)
Construct a new batch.
This method must flexibly accept native data (which comply with type T). Subclasses must provide a type
parameter specifying the type of the native data (this is automatically handled by the code generator).
A value of None indicates that the component should be cleared and results in the creation of an empty array.
The actual creation of the Arrow array is delegated to the _native_to_pa_array() method, which is not
implemented by default.
| PARAMETER | DESCRIPTION |
|---|---|
data
|
The data to convert into an Arrow array.
TYPE:
|
strict
|
Whether to raise an exception if the data cannot be converted into an Arrow array. If None, the value
defaults to the value of the
TYPE:
|
| RETURNS | DESCRIPTION |
|---|---|
The Arrow array encapsulating the data.
|
|
def as_arrow_array()
The component as an arrow batch.
Part of the rerun.ComponentBatchLike logging interface.
def component_type()
Returns the name of the component.
Part of the rerun.ComponentBatchLike logging interface.
def described(descriptor)
Wraps the current ComponentBatchLike in a DescribedComponentBatch with the given descriptor.
def partition(lengths=None)
Partitions the component batch into multiple sub-batches, forming a column.
This makes it possible to use rr.send_columns to send columnar data directly into Rerun.
The returned columns will be partitioned into unit-length sub-batches by default.
Use ComponentColumn.partition to repartition the data as needed.
| PARAMETER | DESCRIPTION |
|---|---|
lengths
|
The offsets to partition the component at.
If specified,
TYPE:
|
| RETURNS | DESCRIPTION |
|---|---|
The partitioned component batch as a column.
|
|
class ForceIterations
Bases: UInt64, ComponentMixin
Component: Specifies how often this force should be applied per iteration.
Increasing this parameter can lead to better results at the cost of longer computation time.
⚠️ This type is unstable and may change significantly in a way that the data won't be backwards compatible.
def __init__(value)
Create a new instance of the UInt64 datatype.
def arrow_type()
classmethod
The pyarrow type of this batch.
Part of the rerun.ComponentBatchLike logging interface.
def as_arrow_array()
The component as an arrow batch.
Part of the rerun.ComponentBatchLike logging interface.
def component_type()
classmethod
Returns the name of the component.
Part of the rerun.ComponentBatchLike logging interface.
class ForceIterationsBatch
Bases: UInt64Batch, ComponentBatchMixin
def __init__(data, strict=None)
Construct a new batch.
This method must flexibly accept native data (which comply with type T). Subclasses must provide a type
parameter specifying the type of the native data (this is automatically handled by the code generator).
A value of None indicates that the component should be cleared and results in the creation of an empty array.
The actual creation of the Arrow array is delegated to the _native_to_pa_array() method, which is not
implemented by default.
| PARAMETER | DESCRIPTION |
|---|---|
data
|
The data to convert into an Arrow array.
TYPE:
|
strict
|
Whether to raise an exception if the data cannot be converted into an Arrow array. If None, the value
defaults to the value of the
TYPE:
|
| RETURNS | DESCRIPTION |
|---|---|
The Arrow array encapsulating the data.
|
|
def as_arrow_array()
The component as an arrow batch.
Part of the rerun.ComponentBatchLike logging interface.
def component_type()
Returns the name of the component.
Part of the rerun.ComponentBatchLike logging interface.
def described(descriptor)
Wraps the current ComponentBatchLike in a DescribedComponentBatch with the given descriptor.
def partition(lengths=None)
Partitions the component batch into multiple sub-batches, forming a column.
This makes it possible to use rr.send_columns to send columnar data directly into Rerun.
The returned columns will be partitioned into unit-length sub-batches by default.
Use ComponentColumn.partition to repartition the data as needed.
| PARAMETER | DESCRIPTION |
|---|---|
lengths
|
The offsets to partition the component at.
If specified,
TYPE:
|
| RETURNS | DESCRIPTION |
|---|---|
The partitioned component batch as a column.
|
|
class ForceStrength
Bases: Float64, ComponentMixin
Component: The strength of a given force.
Allows to assign different weights to the individual forces, prioritizing one over the other.
⚠️ This type is unstable and may change significantly in a way that the data won't be backwards compatible.
def __init__(value)
Create a new instance of the Float64 datatype.
def arrow_type()
classmethod
The pyarrow type of this batch.
Part of the rerun.ComponentBatchLike logging interface.
def as_arrow_array()
The component as an arrow batch.
Part of the rerun.ComponentBatchLike logging interface.
def component_type()
classmethod
Returns the name of the component.
Part of the rerun.ComponentBatchLike logging interface.
class ForceStrengthBatch
Bases: Float64Batch, ComponentBatchMixin
def __init__(data, strict=None)
Construct a new batch.
This method must flexibly accept native data (which comply with type T). Subclasses must provide a type
parameter specifying the type of the native data (this is automatically handled by the code generator).
A value of None indicates that the component should be cleared and results in the creation of an empty array.
The actual creation of the Arrow array is delegated to the _native_to_pa_array() method, which is not
implemented by default.
| PARAMETER | DESCRIPTION |
|---|---|
data
|
The data to convert into an Arrow array.
TYPE:
|
strict
|
Whether to raise an exception if the data cannot be converted into an Arrow array. If None, the value
defaults to the value of the
TYPE:
|
| RETURNS | DESCRIPTION |
|---|---|
The Arrow array encapsulating the data.
|
|
def as_arrow_array()
The component as an arrow batch.
Part of the rerun.ComponentBatchLike logging interface.
def component_type()
Returns the name of the component.
Part of the rerun.ComponentBatchLike logging interface.
def described(descriptor)
Wraps the current ComponentBatchLike in a DescribedComponentBatch with the given descriptor.
def partition(lengths=None)
Partitions the component batch into multiple sub-batches, forming a column.
This makes it possible to use rr.send_columns to send columnar data directly into Rerun.
The returned columns will be partitioned into unit-length sub-batches by default.
Use ComponentColumn.partition to repartition the data as needed.
| PARAMETER | DESCRIPTION |
|---|---|
lengths
|
The offsets to partition the component at.
If specified,
TYPE:
|
| RETURNS | DESCRIPTION |
|---|---|
The partitioned component batch as a column.
|
|
class Fps
Bases: Float64, ComponentMixin
Component: Frames per second for a sequence timeline.
⚠️ This type is unstable and may change significantly in a way that the data won't be backwards compatible.
def __init__(value)
Create a new instance of the Float64 datatype.
def arrow_type()
classmethod
The pyarrow type of this batch.
Part of the rerun.ComponentBatchLike logging interface.
def as_arrow_array()
The component as an arrow batch.
Part of the rerun.ComponentBatchLike logging interface.
def component_type()
classmethod
Returns the name of the component.
Part of the rerun.ComponentBatchLike logging interface.
class FpsBatch
Bases: Float64Batch, ComponentBatchMixin
def __init__(data, strict=None)
Construct a new batch.
This method must flexibly accept native data (which comply with type T). Subclasses must provide a type
parameter specifying the type of the native data (this is automatically handled by the code generator).
A value of None indicates that the component should be cleared and results in the creation of an empty array.
The actual creation of the Arrow array is delegated to the _native_to_pa_array() method, which is not
implemented by default.
| PARAMETER | DESCRIPTION |
|---|---|
data
|
The data to convert into an Arrow array.
TYPE:
|
strict
|
Whether to raise an exception if the data cannot be converted into an Arrow array. If None, the value
defaults to the value of the
TYPE:
|
| RETURNS | DESCRIPTION |
|---|---|
The Arrow array encapsulating the data.
|
|
def as_arrow_array()
The component as an arrow batch.
Part of the rerun.ComponentBatchLike logging interface.
def component_type()
Returns the name of the component.
Part of the rerun.ComponentBatchLike logging interface.
def described(descriptor)
Wraps the current ComponentBatchLike in a DescribedComponentBatch with the given descriptor.
def partition(lengths=None)
Partitions the component batch into multiple sub-batches, forming a column.
This makes it possible to use rr.send_columns to send columnar data directly into Rerun.
The returned columns will be partitioned into unit-length sub-batches by default.
Use ComponentColumn.partition to repartition the data as needed.
| PARAMETER | DESCRIPTION |
|---|---|
lengths
|
The offsets to partition the component at.
If specified,
TYPE:
|
| RETURNS | DESCRIPTION |
|---|---|
The partitioned component batch as a column.
|
|
class GridColumns
Bases: UInt32, ComponentMixin
Component: How many columns a grid container should have.
⚠️ This type is unstable and may change significantly in a way that the data won't be backwards compatible.
def __init__(value)
Create a new instance of the UInt32 datatype.
def arrow_type()
classmethod
The pyarrow type of this batch.
Part of the rerun.ComponentBatchLike logging interface.
def as_arrow_array()
The component as an arrow batch.
Part of the rerun.ComponentBatchLike logging interface.
def component_type()
classmethod
Returns the name of the component.
Part of the rerun.ComponentBatchLike logging interface.
class GridColumnsBatch
Bases: UInt32Batch, ComponentBatchMixin
def __init__(data, strict=None)
Construct a new batch.
This method must flexibly accept native data (which comply with type T). Subclasses must provide a type
parameter specifying the type of the native data (this is automatically handled by the code generator).
A value of None indicates that the component should be cleared and results in the creation of an empty array.
The actual creation of the Arrow array is delegated to the _native_to_pa_array() method, which is not
implemented by default.
| PARAMETER | DESCRIPTION |
|---|---|
data
|
The data to convert into an Arrow array.
TYPE:
|
strict
|
Whether to raise an exception if the data cannot be converted into an Arrow array. If None, the value
defaults to the value of the
TYPE:
|
| RETURNS | DESCRIPTION |
|---|---|
The Arrow array encapsulating the data.
|
|
def as_arrow_array()
The component as an arrow batch.
Part of the rerun.ComponentBatchLike logging interface.
def component_type()
Returns the name of the component.
Part of the rerun.ComponentBatchLike logging interface.
def described(descriptor)
Wraps the current ComponentBatchLike in a DescribedComponentBatch with the given descriptor.
def partition(lengths=None)
Partitions the component batch into multiple sub-batches, forming a column.
This makes it possible to use rr.send_columns to send columnar data directly into Rerun.
The returned columns will be partitioned into unit-length sub-batches by default.
Use ComponentColumn.partition to repartition the data as needed.
| PARAMETER | DESCRIPTION |
|---|---|
lengths
|
The offsets to partition the component at.
If specified,
TYPE:
|
| RETURNS | DESCRIPTION |
|---|---|
The partitioned component batch as a column.
|
|
class GridSpacing
Bases: Float32, ComponentMixin
Component: Space between grid lines of one line to the next in scene units.
⚠️ This type is unstable and may change significantly in a way that the data won't be backwards compatible.
def __init__(value)
Create a new instance of the Float32 datatype.
def arrow_type()
classmethod
The pyarrow type of this batch.
Part of the rerun.ComponentBatchLike logging interface.
def as_arrow_array()
The component as an arrow batch.
Part of the rerun.ComponentBatchLike logging interface.
def component_type()
classmethod
Returns the name of the component.
Part of the rerun.ComponentBatchLike logging interface.
class GridSpacingBatch
Bases: Float32Batch, ComponentBatchMixin
def __init__(data, strict=None)
Construct a new batch.
This method must flexibly accept native data (which comply with type T). Subclasses must provide a type
parameter specifying the type of the native data (this is automatically handled by the code generator).
A value of None indicates that the component should be cleared and results in the creation of an empty array.
The actual creation of the Arrow array is delegated to the _native_to_pa_array() method, which is not
implemented by default.
| PARAMETER | DESCRIPTION |
|---|---|
data
|
The data to convert into an Arrow array.
TYPE:
|
strict
|
Whether to raise an exception if the data cannot be converted into an Arrow array. If None, the value
defaults to the value of the
TYPE:
|
| RETURNS | DESCRIPTION |
|---|---|
The Arrow array encapsulating the data.
|
|
def as_arrow_array()
The component as an arrow batch.
Part of the rerun.ComponentBatchLike logging interface.
def component_type()
Returns the name of the component.
Part of the rerun.ComponentBatchLike logging interface.
def described(descriptor)
Wraps the current ComponentBatchLike in a DescribedComponentBatch with the given descriptor.
def partition(lengths=None)
Partitions the component batch into multiple sub-batches, forming a column.
This makes it possible to use rr.send_columns to send columnar data directly into Rerun.
The returned columns will be partitioned into unit-length sub-batches by default.
Use ComponentColumn.partition to repartition the data as needed.
| PARAMETER | DESCRIPTION |
|---|---|
lengths
|
The offsets to partition the component at.
If specified,
TYPE:
|
| RETURNS | DESCRIPTION |
|---|---|
The partitioned component batch as a column.
|
|
class IncludedContent
Bases: EntityPath, ComponentMixin
Component: All the contents in the container.
⚠️ This type is unstable and may change significantly in a way that the data won't be backwards compatible.
def __init__(path)
Create a new instance of the EntityPath datatype.
def arrow_type()
classmethod
The pyarrow type of this batch.
Part of the rerun.ComponentBatchLike logging interface.
def as_arrow_array()
The component as an arrow batch.
Part of the rerun.ComponentBatchLike logging interface.
def component_type()
classmethod
Returns the name of the component.
Part of the rerun.ComponentBatchLike logging interface.
class IncludedContentBatch
Bases: EntityPathBatch, ComponentBatchMixin
def __init__(data, strict=None)
Construct a new batch.
This method must flexibly accept native data (which comply with type T). Subclasses must provide a type
parameter specifying the type of the native data (this is automatically handled by the code generator).
A value of None indicates that the component should be cleared and results in the creation of an empty array.
The actual creation of the Arrow array is delegated to the _native_to_pa_array() method, which is not
implemented by default.
| PARAMETER | DESCRIPTION |
|---|---|
data
|
The data to convert into an Arrow array.
TYPE:
|
strict
|
Whether to raise an exception if the data cannot be converted into an Arrow array. If None, the value
defaults to the value of the
TYPE:
|
| RETURNS | DESCRIPTION |
|---|---|
The Arrow array encapsulating the data.
|
|
def as_arrow_array()
The component as an arrow batch.
Part of the rerun.ComponentBatchLike logging interface.
def component_type()
Returns the name of the component.
Part of the rerun.ComponentBatchLike logging interface.
def described(descriptor)
Wraps the current ComponentBatchLike in a DescribedComponentBatch with the given descriptor.
def partition(lengths=None)
Partitions the component batch into multiple sub-batches, forming a column.
This makes it possible to use rr.send_columns to send columnar data directly into Rerun.
The returned columns will be partitioned into unit-length sub-batches by default.
Use ComponentColumn.partition to repartition the data as needed.
| PARAMETER | DESCRIPTION |
|---|---|
lengths
|
The offsets to partition the component at.
If specified,
TYPE:
|
| RETURNS | DESCRIPTION |
|---|---|
The partitioned component batch as a column.
|
|
class LinkAxis
Bases: Enum
Component: How should the horizontal/X/time axis be linked across multiple plots.
Independent = 1
class-attribute
instance-attribute
The axis is independent from all other plots.
LinkToGlobal = 2
class-attribute
instance-attribute
Link to all other plots that also have this options set.
def __str__()
Returns the variant name.
def auto(val)
classmethod
Best-effort converter, including a case-insensitive string matcher.
class LinkAxisBatch
Bases: BaseBatch[LinkAxisArrayLike], ComponentBatchMixin
def __init__(data, strict=None)
Construct a new batch.
This method must flexibly accept native data (which comply with type T). Subclasses must provide a type
parameter specifying the type of the native data (this is automatically handled by the code generator).
A value of None indicates that the component should be cleared and results in the creation of an empty array.
The actual creation of the Arrow array is delegated to the _native_to_pa_array() method, which is not
implemented by default.
| PARAMETER | DESCRIPTION |
|---|---|
data
|
The data to convert into an Arrow array.
TYPE:
|
strict
|
Whether to raise an exception if the data cannot be converted into an Arrow array. If None, the value
defaults to the value of the
TYPE:
|
| RETURNS | DESCRIPTION |
|---|---|
The Arrow array encapsulating the data.
|
|
def as_arrow_array()
The component as an arrow batch.
Part of the rerun.ComponentBatchLike logging interface.
def component_type()
Returns the name of the component.
Part of the rerun.ComponentBatchLike logging interface.
def described(descriptor)
Wraps the current ComponentBatchLike in a DescribedComponentBatch with the given descriptor.
def partition(lengths=None)
Partitions the component batch into multiple sub-batches, forming a column.
This makes it possible to use rr.send_columns to send columnar data directly into Rerun.
The returned columns will be partitioned into unit-length sub-batches by default.
Use ComponentColumn.partition to repartition the data as needed.
| PARAMETER | DESCRIPTION |
|---|---|
lengths
|
The offsets to partition the component at.
If specified,
TYPE:
|
| RETURNS | DESCRIPTION |
|---|---|
The partitioned component batch as a column.
|
|
class LockRangeDuringZoom
Bases: Bool, ComponentMixin
Component: Indicate whether the range should be locked when zooming in on the data.
Default is false, i.e. zoom will change the visualized range.
⚠️ This type is unstable and may change significantly in a way that the data won't be backwards compatible.
def __init__(value)
Create a new instance of the Bool datatype.
def arrow_type()
classmethod
The pyarrow type of this batch.
Part of the rerun.ComponentBatchLike logging interface.
def as_arrow_array()
The component as an arrow batch.
Part of the rerun.ComponentBatchLike logging interface.
def component_type()
classmethod
Returns the name of the component.
Part of the rerun.ComponentBatchLike logging interface.
class LockRangeDuringZoomBatch
Bases: BoolBatch, ComponentBatchMixin
def __init__(data, strict=None)
Construct a new batch.
This method must flexibly accept native data (which comply with type T). Subclasses must provide a type
parameter specifying the type of the native data (this is automatically handled by the code generator).
A value of None indicates that the component should be cleared and results in the creation of an empty array.
The actual creation of the Arrow array is delegated to the _native_to_pa_array() method, which is not
implemented by default.
| PARAMETER | DESCRIPTION |
|---|---|
data
|
The data to convert into an Arrow array.
TYPE:
|
strict
|
Whether to raise an exception if the data cannot be converted into an Arrow array. If None, the value
defaults to the value of the
TYPE:
|
| RETURNS | DESCRIPTION |
|---|---|
The Arrow array encapsulating the data.
|
|
def as_arrow_array()
The component as an arrow batch.
Part of the rerun.ComponentBatchLike logging interface.
def component_type()
Returns the name of the component.
Part of the rerun.ComponentBatchLike logging interface.
def described(descriptor)
Wraps the current ComponentBatchLike in a DescribedComponentBatch with the given descriptor.
def partition(lengths=None)
Partitions the component batch into multiple sub-batches, forming a column.
This makes it possible to use rr.send_columns to send columnar data directly into Rerun.
The returned columns will be partitioned into unit-length sub-batches by default.
Use ComponentColumn.partition to repartition the data as needed.
| PARAMETER | DESCRIPTION |
|---|---|
lengths
|
The offsets to partition the component at.
If specified,
TYPE:
|
| RETURNS | DESCRIPTION |
|---|---|
The partitioned component batch as a column.
|
|
class LoopMode
Bases: Enum
Component: If playing, whether and how the playback time should loop.
All = 3
class-attribute
instance-attribute
We are looping the entire recording.
The loop selection is ignored.
Off = 1
class-attribute
instance-attribute
Looping is off.
Selection = 2
class-attribute
instance-attribute
We are looping within the current loop selection.
def __str__()
Returns the variant name.
def auto(val)
classmethod
Best-effort converter, including a case-insensitive string matcher.
class LoopModeBatch
Bases: BaseBatch[LoopModeArrayLike], ComponentBatchMixin
def __init__(data, strict=None)
Construct a new batch.
This method must flexibly accept native data (which comply with type T). Subclasses must provide a type
parameter specifying the type of the native data (this is automatically handled by the code generator).
A value of None indicates that the component should be cleared and results in the creation of an empty array.
The actual creation of the Arrow array is delegated to the _native_to_pa_array() method, which is not
implemented by default.
| PARAMETER | DESCRIPTION |
|---|---|
data
|
The data to convert into an Arrow array.
TYPE:
|
strict
|
Whether to raise an exception if the data cannot be converted into an Arrow array. If None, the value
defaults to the value of the
TYPE:
|
| RETURNS | DESCRIPTION |
|---|---|
The Arrow array encapsulating the data.
|
|
def as_arrow_array()
The component as an arrow batch.
Part of the rerun.ComponentBatchLike logging interface.
def component_type()
Returns the name of the component.
Part of the rerun.ComponentBatchLike logging interface.
def described(descriptor)
Wraps the current ComponentBatchLike in a DescribedComponentBatch with the given descriptor.
def partition(lengths=None)
Partitions the component batch into multiple sub-batches, forming a column.
This makes it possible to use rr.send_columns to send columnar data directly into Rerun.
The returned columns will be partitioned into unit-length sub-batches by default.
Use ComponentColumn.partition to repartition the data as needed.
| PARAMETER | DESCRIPTION |
|---|---|
lengths
|
The offsets to partition the component at.
If specified,
TYPE:
|
| RETURNS | DESCRIPTION |
|---|---|
The partitioned component batch as a column.
|
|
class MapProvider
Bases: Enum
Component: Name of the map provider to be used in Map views.
MapboxDark = 3
class-attribute
instance-attribute
Mapbox Dark is a dark-themed map designed by Mapbox.
MapboxLight = 5
class-attribute
instance-attribute
Mapbox Light is a light-themed map designed by Mapbox.
MapboxSatellite = 4
class-attribute
instance-attribute
Mapbox Satellite is a satellite map designed by Mapbox.
MapboxStreets = 2
class-attribute
instance-attribute
Mapbox Streets is a minimalistic map designed by Mapbox.
OpenStreetMap = 1
class-attribute
instance-attribute
OpenStreetMap is the default map provider.
def __str__()
Returns the variant name.
def auto(val)
classmethod
Best-effort converter, including a case-insensitive string matcher.
class MapProviderBatch
Bases: BaseBatch[MapProviderArrayLike], ComponentBatchMixin
def __init__(data, strict=None)
Construct a new batch.
This method must flexibly accept native data (which comply with type T). Subclasses must provide a type
parameter specifying the type of the native data (this is automatically handled by the code generator).
A value of None indicates that the component should be cleared and results in the creation of an empty array.
The actual creation of the Arrow array is delegated to the _native_to_pa_array() method, which is not
implemented by default.
| PARAMETER | DESCRIPTION |
|---|---|
data
|
The data to convert into an Arrow array.
TYPE:
|
strict
|
Whether to raise an exception if the data cannot be converted into an Arrow array. If None, the value
defaults to the value of the
TYPE:
|
| RETURNS | DESCRIPTION |
|---|---|
The Arrow array encapsulating the data.
|
|
def as_arrow_array()
The component as an arrow batch.
Part of the rerun.ComponentBatchLike logging interface.
def component_type()
Returns the name of the component.
Part of the rerun.ComponentBatchLike logging interface.
def described(descriptor)
Wraps the current ComponentBatchLike in a DescribedComponentBatch with the given descriptor.
def partition(lengths=None)
Partitions the component batch into multiple sub-batches, forming a column.
This makes it possible to use rr.send_columns to send columnar data directly into Rerun.
The returned columns will be partitioned into unit-length sub-batches by default.
Use ComponentColumn.partition to repartition the data as needed.
| PARAMETER | DESCRIPTION |
|---|---|
lengths
|
The offsets to partition the component at.
If specified,
TYPE:
|
| RETURNS | DESCRIPTION |
|---|---|
The partitioned component batch as a column.
|
|
class NearClipPlane
Bases: Float32, ComponentMixin
Component: Distance to the near clip plane used for Spatial2DView.
⚠️ This type is unstable and may change significantly in a way that the data won't be backwards compatible.
def __init__(value)
Create a new instance of the Float32 datatype.
def arrow_type()
classmethod
The pyarrow type of this batch.
Part of the rerun.ComponentBatchLike logging interface.
def as_arrow_array()
The component as an arrow batch.
Part of the rerun.ComponentBatchLike logging interface.
def component_type()
classmethod
Returns the name of the component.
Part of the rerun.ComponentBatchLike logging interface.
class NearClipPlaneBatch
Bases: Float32Batch, ComponentBatchMixin
def __init__(data, strict=None)
Construct a new batch.
This method must flexibly accept native data (which comply with type T). Subclasses must provide a type
parameter specifying the type of the native data (this is automatically handled by the code generator).
A value of None indicates that the component should be cleared and results in the creation of an empty array.
The actual creation of the Arrow array is delegated to the _native_to_pa_array() method, which is not
implemented by default.
| PARAMETER | DESCRIPTION |
|---|---|
data
|
The data to convert into an Arrow array.
TYPE:
|
strict
|
Whether to raise an exception if the data cannot be converted into an Arrow array. If None, the value
defaults to the value of the
TYPE:
|
| RETURNS | DESCRIPTION |
|---|---|
The Arrow array encapsulating the data.
|
|
def as_arrow_array()
The component as an arrow batch.
Part of the rerun.ComponentBatchLike logging interface.
def component_type()
Returns the name of the component.
Part of the rerun.ComponentBatchLike logging interface.
def described(descriptor)
Wraps the current ComponentBatchLike in a DescribedComponentBatch with the given descriptor.
def partition(lengths=None)
Partitions the component batch into multiple sub-batches, forming a column.
This makes it possible to use rr.send_columns to send columnar data directly into Rerun.
The returned columns will be partitioned into unit-length sub-batches by default.
Use ComponentColumn.partition to repartition the data as needed.
| PARAMETER | DESCRIPTION |
|---|---|
lengths
|
The offsets to partition the component at.
If specified,
TYPE:
|
| RETURNS | DESCRIPTION |
|---|---|
The partitioned component batch as a column.
|
|
class PanelState
Bases: Enum
Component: Tri-state for panel controls.
Collapsed = 2
class-attribute
instance-attribute
Visible, but as small as possible on its shorter axis.
Expanded = 3
class-attribute
instance-attribute
Fully expanded.
Hidden = 1
class-attribute
instance-attribute
Completely hidden.
def __str__()
Returns the variant name.
def auto(val)
classmethod
Best-effort converter, including a case-insensitive string matcher.
class PanelStateBatch
Bases: BaseBatch[PanelStateArrayLike], ComponentBatchMixin
def __init__(data, strict=None)
Construct a new batch.
This method must flexibly accept native data (which comply with type T). Subclasses must provide a type
parameter specifying the type of the native data (this is automatically handled by the code generator).
A value of None indicates that the component should be cleared and results in the creation of an empty array.
The actual creation of the Arrow array is delegated to the _native_to_pa_array() method, which is not
implemented by default.
| PARAMETER | DESCRIPTION |
|---|---|
data
|
The data to convert into an Arrow array.
TYPE:
|
strict
|
Whether to raise an exception if the data cannot be converted into an Arrow array. If None, the value
defaults to the value of the
TYPE:
|
| RETURNS | DESCRIPTION |
|---|---|
The Arrow array encapsulating the data.
|
|
def as_arrow_array()
The component as an arrow batch.
Part of the rerun.ComponentBatchLike logging interface.
def component_type()
Returns the name of the component.
Part of the rerun.ComponentBatchLike logging interface.
def described(descriptor)
Wraps the current ComponentBatchLike in a DescribedComponentBatch with the given descriptor.
def partition(lengths=None)
Partitions the component batch into multiple sub-batches, forming a column.
This makes it possible to use rr.send_columns to send columnar data directly into Rerun.
The returned columns will be partitioned into unit-length sub-batches by default.
Use ComponentColumn.partition to repartition the data as needed.
| PARAMETER | DESCRIPTION |
|---|---|
lengths
|
The offsets to partition the component at.
If specified,
TYPE:
|
| RETURNS | DESCRIPTION |
|---|---|
The partitioned component batch as a column.
|
|
class PlayState
Bases: Enum
Component: The current play state.
Following = 3
class-attribute
instance-attribute
Follow the latest available data.
Paused = 1
class-attribute
instance-attribute
Time doesn't move.
Playing = 2
class-attribute
instance-attribute
Time move steadily.
def __str__()
Returns the variant name.
def auto(val)
classmethod
Best-effort converter, including a case-insensitive string matcher.
class PlayStateBatch
Bases: BaseBatch[PlayStateArrayLike], ComponentBatchMixin
def __init__(data, strict=None)
Construct a new batch.
This method must flexibly accept native data (which comply with type T). Subclasses must provide a type
parameter specifying the type of the native data (this is automatically handled by the code generator).
A value of None indicates that the component should be cleared and results in the creation of an empty array.
The actual creation of the Arrow array is delegated to the _native_to_pa_array() method, which is not
implemented by default.
| PARAMETER | DESCRIPTION |
|---|---|
data
|
The data to convert into an Arrow array.
TYPE:
|
strict
|
Whether to raise an exception if the data cannot be converted into an Arrow array. If None, the value
defaults to the value of the
TYPE:
|
| RETURNS | DESCRIPTION |
|---|---|
The Arrow array encapsulating the data.
|
|
def as_arrow_array()
The component as an arrow batch.
Part of the rerun.ComponentBatchLike logging interface.
def component_type()
Returns the name of the component.
Part of the rerun.ComponentBatchLike logging interface.
def described(descriptor)
Wraps the current ComponentBatchLike in a DescribedComponentBatch with the given descriptor.
def partition(lengths=None)
Partitions the component batch into multiple sub-batches, forming a column.
This makes it possible to use rr.send_columns to send columnar data directly into Rerun.
The returned columns will be partitioned into unit-length sub-batches by default.
Use ComponentColumn.partition to repartition the data as needed.
| PARAMETER | DESCRIPTION |
|---|---|
lengths
|
The offsets to partition the component at.
If specified,
TYPE:
|
| RETURNS | DESCRIPTION |
|---|---|
The partitioned component batch as a column.
|
|
class PlaybackSpeed
Bases: Float64, ComponentMixin
Component: A playback speed which determines how fast time progresses.
⚠️ This type is unstable and may change significantly in a way that the data won't be backwards compatible.
def __init__(value)
Create a new instance of the Float64 datatype.
def arrow_type()
classmethod
The pyarrow type of this batch.
Part of the rerun.ComponentBatchLike logging interface.
def as_arrow_array()
The component as an arrow batch.
Part of the rerun.ComponentBatchLike logging interface.
def component_type()
classmethod
Returns the name of the component.
Part of the rerun.ComponentBatchLike logging interface.
class PlaybackSpeedBatch
Bases: Float64Batch, ComponentBatchMixin
def __init__(data, strict=None)
Construct a new batch.
This method must flexibly accept native data (which comply with type T). Subclasses must provide a type
parameter specifying the type of the native data (this is automatically handled by the code generator).
A value of None indicates that the component should be cleared and results in the creation of an empty array.
The actual creation of the Arrow array is delegated to the _native_to_pa_array() method, which is not
implemented by default.
| PARAMETER | DESCRIPTION |
|---|---|
data
|
The data to convert into an Arrow array.
TYPE:
|
strict
|
Whether to raise an exception if the data cannot be converted into an Arrow array. If None, the value
defaults to the value of the
TYPE:
|
| RETURNS | DESCRIPTION |
|---|---|
The Arrow array encapsulating the data.
|
|
def as_arrow_array()
The component as an arrow batch.
Part of the rerun.ComponentBatchLike logging interface.
def component_type()
Returns the name of the component.
Part of the rerun.ComponentBatchLike logging interface.
def described(descriptor)
Wraps the current ComponentBatchLike in a DescribedComponentBatch with the given descriptor.
def partition(lengths=None)
Partitions the component batch into multiple sub-batches, forming a column.
This makes it possible to use rr.send_columns to send columnar data directly into Rerun.
The returned columns will be partitioned into unit-length sub-batches by default.
Use ComponentColumn.partition to repartition the data as needed.
| PARAMETER | DESCRIPTION |
|---|---|
lengths
|
The offsets to partition the component at.
If specified,
TYPE:
|
| RETURNS | DESCRIPTION |
|---|---|
The partitioned component batch as a column.
|
|
class QueryExpression
Bases: Utf8, ComponentMixin
Component: An individual query expression used to filter a set of datatypes.EntityPaths.
Each expression is either an inclusion or an exclusion expression.
Inclusions start with an optional + and exclusions must start with a -.
Multiple expressions are combined together as part of archetypes.ViewContents.
The /** suffix matches the whole subtree, i.e. self and any child, recursively
(/world/** matches both /world and /world/car/driver).
Other uses of * are not (yet) supported.
⚠️ This type is unstable and may change significantly in a way that the data won't be backwards compatible.
def __init__(value)
Create a new instance of the Utf8 datatype.
def arrow_type()
classmethod
The pyarrow type of this batch.
Part of the rerun.ComponentBatchLike logging interface.
def as_arrow_array()
The component as an arrow batch.
Part of the rerun.ComponentBatchLike logging interface.
def component_type()
classmethod
Returns the name of the component.
Part of the rerun.ComponentBatchLike logging interface.
class QueryExpressionBatch
Bases: Utf8Batch, ComponentBatchMixin
def __init__(data, strict=None)
Construct a new batch.
This method must flexibly accept native data (which comply with type T). Subclasses must provide a type
parameter specifying the type of the native data (this is automatically handled by the code generator).
A value of None indicates that the component should be cleared and results in the creation of an empty array.
The actual creation of the Arrow array is delegated to the _native_to_pa_array() method, which is not
implemented by default.
| PARAMETER | DESCRIPTION |
|---|---|
data
|
The data to convert into an Arrow array.
TYPE:
|
strict
|
Whether to raise an exception if the data cannot be converted into an Arrow array. If None, the value
defaults to the value of the
TYPE:
|
| RETURNS | DESCRIPTION |
|---|---|
The Arrow array encapsulating the data.
|
|
def as_arrow_array()
The component as an arrow batch.
Part of the rerun.ComponentBatchLike logging interface.
def component_type()
Returns the name of the component.
Part of the rerun.ComponentBatchLike logging interface.
def described(descriptor)
Wraps the current ComponentBatchLike in a DescribedComponentBatch with the given descriptor.
def partition(lengths=None)
Partitions the component batch into multiple sub-batches, forming a column.
This makes it possible to use rr.send_columns to send columnar data directly into Rerun.
The returned columns will be partitioned into unit-length sub-batches by default.
Use ComponentColumn.partition to repartition the data as needed.
| PARAMETER | DESCRIPTION |
|---|---|
lengths
|
The offsets to partition the component at.
If specified,
TYPE:
|
| RETURNS | DESCRIPTION |
|---|---|
The partitioned component batch as a column.
|
|
class RootContainer
Bases: Uuid, ComponentMixin
Component: The container that sits at the root of a viewport.
⚠️ This type is unstable and may change significantly in a way that the data won't be backwards compatible.
def __init__(bytes)
Create a new instance of the Uuid datatype.
| PARAMETER | DESCRIPTION |
|---|---|
bytes
|
The raw bytes representing the UUID.
TYPE:
|
def arrow_type()
classmethod
The pyarrow type of this batch.
Part of the rerun.ComponentBatchLike logging interface.
def as_arrow_array()
The component as an arrow batch.
Part of the rerun.ComponentBatchLike logging interface.
def component_type()
classmethod
Returns the name of the component.
Part of the rerun.ComponentBatchLike logging interface.
class RootContainerBatch
Bases: UuidBatch, ComponentBatchMixin
def __init__(data, strict=None)
Construct a new batch.
This method must flexibly accept native data (which comply with type T). Subclasses must provide a type
parameter specifying the type of the native data (this is automatically handled by the code generator).
A value of None indicates that the component should be cleared and results in the creation of an empty array.
The actual creation of the Arrow array is delegated to the _native_to_pa_array() method, which is not
implemented by default.
| PARAMETER | DESCRIPTION |
|---|---|
data
|
The data to convert into an Arrow array.
TYPE:
|
strict
|
Whether to raise an exception if the data cannot be converted into an Arrow array. If None, the value
defaults to the value of the
TYPE:
|
| RETURNS | DESCRIPTION |
|---|---|
The Arrow array encapsulating the data.
|
|
def as_arrow_array()
The component as an arrow batch.
Part of the rerun.ComponentBatchLike logging interface.
def component_type()
Returns the name of the component.
Part of the rerun.ComponentBatchLike logging interface.
def described(descriptor)
Wraps the current ComponentBatchLike in a DescribedComponentBatch with the given descriptor.
def partition(lengths=None)
Partitions the component batch into multiple sub-batches, forming a column.
This makes it possible to use rr.send_columns to send columnar data directly into Rerun.
The returned columns will be partitioned into unit-length sub-batches by default.
Use ComponentColumn.partition to repartition the data as needed.
| PARAMETER | DESCRIPTION |
|---|---|
lengths
|
The offsets to partition the component at.
If specified,
TYPE:
|
| RETURNS | DESCRIPTION |
|---|---|
The partitioned component batch as a column.
|
|
class RowShare
Bases: Float32, ComponentMixin
Component: The layout share of a row in the container.
⚠️ This type is unstable and may change significantly in a way that the data won't be backwards compatible.
def __init__(value)
Create a new instance of the Float32 datatype.
def arrow_type()
classmethod
The pyarrow type of this batch.
Part of the rerun.ComponentBatchLike logging interface.
def as_arrow_array()
The component as an arrow batch.
Part of the rerun.ComponentBatchLike logging interface.
def component_type()
classmethod
Returns the name of the component.
Part of the rerun.ComponentBatchLike logging interface.
class RowShareBatch
Bases: Float32Batch, ComponentBatchMixin
def __init__(data, strict=None)
Construct a new batch.
This method must flexibly accept native data (which comply with type T). Subclasses must provide a type
parameter specifying the type of the native data (this is automatically handled by the code generator).
A value of None indicates that the component should be cleared and results in the creation of an empty array.
The actual creation of the Arrow array is delegated to the _native_to_pa_array() method, which is not
implemented by default.
| PARAMETER | DESCRIPTION |
|---|---|
data
|
The data to convert into an Arrow array.
TYPE:
|
strict
|
Whether to raise an exception if the data cannot be converted into an Arrow array. If None, the value
defaults to the value of the
TYPE:
|
| RETURNS | DESCRIPTION |
|---|---|
The Arrow array encapsulating the data.
|
|
def as_arrow_array()
The component as an arrow batch.
Part of the rerun.ComponentBatchLike logging interface.
def component_type()
Returns the name of the component.
Part of the rerun.ComponentBatchLike logging interface.
def described(descriptor)
Wraps the current ComponentBatchLike in a DescribedComponentBatch with the given descriptor.
def partition(lengths=None)
Partitions the component batch into multiple sub-batches, forming a column.
This makes it possible to use rr.send_columns to send columnar data directly into Rerun.
The returned columns will be partitioned into unit-length sub-batches by default.
Use ComponentColumn.partition to repartition the data as needed.
| PARAMETER | DESCRIPTION |
|---|---|
lengths
|
The offsets to partition the component at.
If specified,
TYPE:
|
| RETURNS | DESCRIPTION |
|---|---|
The partitioned component batch as a column.
|
|
class SelectedColumns
Bases: SelectedColumns, ComponentMixin
Component: Describe a component column to be selected in the dataframe view.
⚠️ This type is unstable and may change significantly in a way that the data won't be backwards compatible.
def __init__(columns)
Create a new instance of the SelectedColumns datatype.
Example:
SelectedColumns(["timeline", "/entity/path:Component"])
| PARAMETER | DESCRIPTION |
|---|---|
columns
|
The columns to include. The column must be either of the timeline, or component kind. Timeline columns can be specified using a
TYPE:
|
def arrow_type()
classmethod
The pyarrow type of this batch.
Part of the rerun.ComponentBatchLike logging interface.
def as_arrow_array()
The component as an arrow batch.
Part of the rerun.ComponentBatchLike logging interface.
def component_type()
classmethod
Returns the name of the component.
Part of the rerun.ComponentBatchLike logging interface.
class SelectedColumnsBatch
Bases: SelectedColumnsBatch, ComponentBatchMixin
def __init__(data, strict=None)
Construct a new batch.
This method must flexibly accept native data (which comply with type T). Subclasses must provide a type
parameter specifying the type of the native data (this is automatically handled by the code generator).
A value of None indicates that the component should be cleared and results in the creation of an empty array.
The actual creation of the Arrow array is delegated to the _native_to_pa_array() method, which is not
implemented by default.
| PARAMETER | DESCRIPTION |
|---|---|
data
|
The data to convert into an Arrow array.
TYPE:
|
strict
|
Whether to raise an exception if the data cannot be converted into an Arrow array. If None, the value
defaults to the value of the
TYPE:
|
| RETURNS | DESCRIPTION |
|---|---|
The Arrow array encapsulating the data.
|
|
def as_arrow_array()
The component as an arrow batch.
Part of the rerun.ComponentBatchLike logging interface.
def component_type()
Returns the name of the component.
Part of the rerun.ComponentBatchLike logging interface.
def described(descriptor)
Wraps the current ComponentBatchLike in a DescribedComponentBatch with the given descriptor.
def partition(lengths=None)
Partitions the component batch into multiple sub-batches, forming a column.
This makes it possible to use rr.send_columns to send columnar data directly into Rerun.
The returned columns will be partitioned into unit-length sub-batches by default.
Use ComponentColumn.partition to repartition the data as needed.
| PARAMETER | DESCRIPTION |
|---|---|
lengths
|
The offsets to partition the component at.
If specified,
TYPE:
|
| RETURNS | DESCRIPTION |
|---|---|
The partitioned component batch as a column.
|
|
class TensorDimensionIndexSlider
Bases: TensorDimensionIndexSlider, ComponentMixin
Component: Show a slider for the index of some dimension of a slider.
⚠️ This type is unstable and may change significantly in a way that the data won't be backwards compatible.
def __init__(dimension)
Create a new instance of the TensorDimensionIndexSlider datatype.
| PARAMETER | DESCRIPTION |
|---|---|
dimension
|
The dimension number. |
def arrow_type()
classmethod
The pyarrow type of this batch.
Part of the rerun.ComponentBatchLike logging interface.
def as_arrow_array()
The component as an arrow batch.
Part of the rerun.ComponentBatchLike logging interface.
def component_type()
classmethod
Returns the name of the component.
Part of the rerun.ComponentBatchLike logging interface.
class TensorDimensionIndexSliderBatch
Bases: TensorDimensionIndexSliderBatch, ComponentBatchMixin
def __init__(data, strict=None)
Construct a new batch.
This method must flexibly accept native data (which comply with type T). Subclasses must provide a type
parameter specifying the type of the native data (this is automatically handled by the code generator).
A value of None indicates that the component should be cleared and results in the creation of an empty array.
The actual creation of the Arrow array is delegated to the _native_to_pa_array() method, which is not
implemented by default.
| PARAMETER | DESCRIPTION |
|---|---|
data
|
The data to convert into an Arrow array.
TYPE:
|
strict
|
Whether to raise an exception if the data cannot be converted into an Arrow array. If None, the value
defaults to the value of the
TYPE:
|
| RETURNS | DESCRIPTION |
|---|---|
The Arrow array encapsulating the data.
|
|
def as_arrow_array()
The component as an arrow batch.
Part of the rerun.ComponentBatchLike logging interface.
def component_type()
Returns the name of the component.
Part of the rerun.ComponentBatchLike logging interface.
def described(descriptor)
Wraps the current ComponentBatchLike in a DescribedComponentBatch with the given descriptor.
def partition(lengths=None)
Partitions the component batch into multiple sub-batches, forming a column.
This makes it possible to use rr.send_columns to send columnar data directly into Rerun.
The returned columns will be partitioned into unit-length sub-batches by default.
Use ComponentColumn.partition to repartition the data as needed.
| PARAMETER | DESCRIPTION |
|---|---|
lengths
|
The offsets to partition the component at.
If specified,
TYPE:
|
| RETURNS | DESCRIPTION |
|---|---|
The partitioned component batch as a column.
|
|
class TextLogColumn
Bases: TextLogColumn, ComponentMixin
Component: A text log column.
⚠️ This type is unstable and may change significantly in a way that the data won't be backwards compatible.
def __init__(kind, *, visible=True)
Create a new instance of the TextLogColumn datatype.
| PARAMETER | DESCRIPTION |
|---|---|
kind
|
What kind of column is this?
TYPE:
|
visible
|
Is this column visible?
TYPE:
|
def arrow_type()
classmethod
The pyarrow type of this batch.
Part of the rerun.ComponentBatchLike logging interface.
def as_arrow_array()
The component as an arrow batch.
Part of the rerun.ComponentBatchLike logging interface.
def component_type()
classmethod
Returns the name of the component.
Part of the rerun.ComponentBatchLike logging interface.
class TextLogColumnBatch
Bases: TextLogColumnBatch, ComponentBatchMixin
def __init__(data, strict=None)
Construct a new batch.
This method must flexibly accept native data (which comply with type T). Subclasses must provide a type
parameter specifying the type of the native data (this is automatically handled by the code generator).
A value of None indicates that the component should be cleared and results in the creation of an empty array.
The actual creation of the Arrow array is delegated to the _native_to_pa_array() method, which is not
implemented by default.
| PARAMETER | DESCRIPTION |
|---|---|
data
|
The data to convert into an Arrow array.
TYPE:
|
strict
|
Whether to raise an exception if the data cannot be converted into an Arrow array. If None, the value
defaults to the value of the
TYPE:
|
| RETURNS | DESCRIPTION |
|---|---|
The Arrow array encapsulating the data.
|
|
def as_arrow_array()
The component as an arrow batch.
Part of the rerun.ComponentBatchLike logging interface.
def component_type()
Returns the name of the component.
Part of the rerun.ComponentBatchLike logging interface.
def described(descriptor)
Wraps the current ComponentBatchLike in a DescribedComponentBatch with the given descriptor.
def partition(lengths=None)
Partitions the component batch into multiple sub-batches, forming a column.
This makes it possible to use rr.send_columns to send columnar data directly into Rerun.
The returned columns will be partitioned into unit-length sub-batches by default.
Use ComponentColumn.partition to repartition the data as needed.
| PARAMETER | DESCRIPTION |
|---|---|
lengths
|
The offsets to partition the component at.
If specified,
TYPE:
|
| RETURNS | DESCRIPTION |
|---|---|
The partitioned component batch as a column.
|
|
class TimeInt
Bases: TimeInt, ComponentMixin
Component: A reference to a time.
⚠️ This type is unstable and may change significantly in a way that the data won't be backwards compatible.
def __init__(*, seq=None, seconds=None, nanos=None)
Create a new instance of the TimeInt datatype.
Exactly one of seq, seconds, or nanos must be provided.
| PARAMETER | DESCRIPTION |
|---|---|
seq
|
Time as a sequence number.
TYPE:
|
seconds
|
Time in seconds. Interpreted either as a duration or time since unix epoch (depending on timeline type).
TYPE:
|
nanos
|
Time in nanoseconds. Interpreted either as a duration or time since unix epoch (depending on timeline type).
TYPE:
|
def arrow_type()
classmethod
The pyarrow type of this batch.
Part of the rerun.ComponentBatchLike logging interface.
def as_arrow_array()
The component as an arrow batch.
Part of the rerun.ComponentBatchLike logging interface.
def component_type()
classmethod
Returns the name of the component.
Part of the rerun.ComponentBatchLike logging interface.
class TimeIntBatch
Bases: TimeIntBatch, ComponentBatchMixin
def __init__(data, strict=None)
Construct a new batch.
This method must flexibly accept native data (which comply with type T). Subclasses must provide a type
parameter specifying the type of the native data (this is automatically handled by the code generator).
A value of None indicates that the component should be cleared and results in the creation of an empty array.
The actual creation of the Arrow array is delegated to the _native_to_pa_array() method, which is not
implemented by default.
| PARAMETER | DESCRIPTION |
|---|---|
data
|
The data to convert into an Arrow array.
TYPE:
|
strict
|
Whether to raise an exception if the data cannot be converted into an Arrow array. If None, the value
defaults to the value of the
TYPE:
|
| RETURNS | DESCRIPTION |
|---|---|
The Arrow array encapsulating the data.
|
|
def as_arrow_array()
The component as an arrow batch.
Part of the rerun.ComponentBatchLike logging interface.
def component_type()
Returns the name of the component.
Part of the rerun.ComponentBatchLike logging interface.
def described(descriptor)
Wraps the current ComponentBatchLike in a DescribedComponentBatch with the given descriptor.
def partition(lengths=None)
Partitions the component batch into multiple sub-batches, forming a column.
This makes it possible to use rr.send_columns to send columnar data directly into Rerun.
The returned columns will be partitioned into unit-length sub-batches by default.
Use ComponentColumn.partition to repartition the data as needed.
| PARAMETER | DESCRIPTION |
|---|---|
lengths
|
The offsets to partition the component at.
If specified,
TYPE:
|
| RETURNS | DESCRIPTION |
|---|---|
The partitioned component batch as a column.
|
|
class TimeRange
Bases: TimeRange, ComponentMixin
Component: A time range on an unspecified timeline using either relative or absolute boundaries.
⚠️ This type is unstable and may change significantly in a way that the data won't be backwards compatible.
def __init__(start, end)
Create a new instance of the TimeRange datatype.
| PARAMETER | DESCRIPTION |
|---|---|
start
|
Low time boundary for sequence timeline.
TYPE:
|
end
|
High time boundary for sequence timeline.
TYPE:
|
def arrow_type()
classmethod
The pyarrow type of this batch.
Part of the rerun.ComponentBatchLike logging interface.
def as_arrow_array()
The component as an arrow batch.
Part of the rerun.ComponentBatchLike logging interface.
def component_type()
classmethod
Returns the name of the component.
Part of the rerun.ComponentBatchLike logging interface.
class TimeRangeBatch
Bases: TimeRangeBatch, ComponentBatchMixin
def __init__(data, strict=None)
Construct a new batch.
This method must flexibly accept native data (which comply with type T). Subclasses must provide a type
parameter specifying the type of the native data (this is automatically handled by the code generator).
A value of None indicates that the component should be cleared and results in the creation of an empty array.
The actual creation of the Arrow array is delegated to the _native_to_pa_array() method, which is not
implemented by default.
| PARAMETER | DESCRIPTION |
|---|---|
data
|
The data to convert into an Arrow array.
TYPE:
|
strict
|
Whether to raise an exception if the data cannot be converted into an Arrow array. If None, the value
defaults to the value of the
TYPE:
|
| RETURNS | DESCRIPTION |
|---|---|
The Arrow array encapsulating the data.
|
|
def as_arrow_array()
The component as an arrow batch.
Part of the rerun.ComponentBatchLike logging interface.
def component_type()
Returns the name of the component.
Part of the rerun.ComponentBatchLike logging interface.
def described(descriptor)
Wraps the current ComponentBatchLike in a DescribedComponentBatch with the given descriptor.
def partition(lengths=None)
Partitions the component batch into multiple sub-batches, forming a column.
This makes it possible to use rr.send_columns to send columnar data directly into Rerun.
The returned columns will be partitioned into unit-length sub-batches by default.
Use ComponentColumn.partition to repartition the data as needed.
| PARAMETER | DESCRIPTION |
|---|---|
lengths
|
The offsets to partition the component at.
If specified,
TYPE:
|
| RETURNS | DESCRIPTION |
|---|---|
The partitioned component batch as a column.
|
|
class TimelineColumn
Bases: TimelineColumn, ComponentMixin
Component: A timeline column in a text log table.
⚠️ This type is unstable and may change significantly in a way that the data won't be backwards compatible.
def __init__(timeline, *, visible=True)
def arrow_type()
classmethod
The pyarrow type of this batch.
Part of the rerun.ComponentBatchLike logging interface.
def as_arrow_array()
The component as an arrow batch.
Part of the rerun.ComponentBatchLike logging interface.
def component_type()
classmethod
Returns the name of the component.
Part of the rerun.ComponentBatchLike logging interface.
class TimelineColumnBatch
Bases: TimelineColumnBatch, ComponentBatchMixin
def __init__(data, strict=None)
Construct a new batch.
This method must flexibly accept native data (which comply with type T). Subclasses must provide a type
parameter specifying the type of the native data (this is automatically handled by the code generator).
A value of None indicates that the component should be cleared and results in the creation of an empty array.
The actual creation of the Arrow array is delegated to the _native_to_pa_array() method, which is not
implemented by default.
| PARAMETER | DESCRIPTION |
|---|---|
data
|
The data to convert into an Arrow array.
TYPE:
|
strict
|
Whether to raise an exception if the data cannot be converted into an Arrow array. If None, the value
defaults to the value of the
TYPE:
|
| RETURNS | DESCRIPTION |
|---|---|
The Arrow array encapsulating the data.
|
|
def as_arrow_array()
The component as an arrow batch.
Part of the rerun.ComponentBatchLike logging interface.
def component_type()
Returns the name of the component.
Part of the rerun.ComponentBatchLike logging interface.
def described(descriptor)
Wraps the current ComponentBatchLike in a DescribedComponentBatch with the given descriptor.
def partition(lengths=None)
Partitions the component batch into multiple sub-batches, forming a column.
This makes it possible to use rr.send_columns to send columnar data directly into Rerun.
The returned columns will be partitioned into unit-length sub-batches by default.
Use ComponentColumn.partition to repartition the data as needed.
| PARAMETER | DESCRIPTION |
|---|---|
lengths
|
The offsets to partition the component at.
If specified,
TYPE:
|
| RETURNS | DESCRIPTION |
|---|---|
The partitioned component batch as a column.
|
|
class TimelineName
Bases: Utf8, ComponentMixin
Component: A timeline identified by its name.
⚠️ This type is unstable and may change significantly in a way that the data won't be backwards compatible.
def __init__(value)
Create a new instance of the Utf8 datatype.
def arrow_type()
classmethod
The pyarrow type of this batch.
Part of the rerun.ComponentBatchLike logging interface.
def as_arrow_array()
The component as an arrow batch.
Part of the rerun.ComponentBatchLike logging interface.
def component_type()
classmethod
Returns the name of the component.
Part of the rerun.ComponentBatchLike logging interface.
class TimelineNameBatch
Bases: Utf8Batch, ComponentBatchMixin
def __init__(data, strict=None)
Construct a new batch.
This method must flexibly accept native data (which comply with type T). Subclasses must provide a type
parameter specifying the type of the native data (this is automatically handled by the code generator).
A value of None indicates that the component should be cleared and results in the creation of an empty array.
The actual creation of the Arrow array is delegated to the _native_to_pa_array() method, which is not
implemented by default.
| PARAMETER | DESCRIPTION |
|---|---|
data
|
The data to convert into an Arrow array.
TYPE:
|
strict
|
Whether to raise an exception if the data cannot be converted into an Arrow array. If None, the value
defaults to the value of the
TYPE:
|
| RETURNS | DESCRIPTION |
|---|---|
The Arrow array encapsulating the data.
|
|
def as_arrow_array()
The component as an arrow batch.
Part of the rerun.ComponentBatchLike logging interface.
def component_type()
Returns the name of the component.
Part of the rerun.ComponentBatchLike logging interface.
def described(descriptor)
Wraps the current ComponentBatchLike in a DescribedComponentBatch with the given descriptor.
def partition(lengths=None)
Partitions the component batch into multiple sub-batches, forming a column.
This makes it possible to use rr.send_columns to send columnar data directly into Rerun.
The returned columns will be partitioned into unit-length sub-batches by default.
Use ComponentColumn.partition to repartition the data as needed.
| PARAMETER | DESCRIPTION |
|---|---|
lengths
|
The offsets to partition the component at.
If specified,
TYPE:
|
| RETURNS | DESCRIPTION |
|---|---|
The partitioned component batch as a column.
|
|
class ViewClass
Bases: Utf8, ComponentMixin
Component: The class identifier of view, e.g. "2D", "TextLog", ….
⚠️ This type is unstable and may change significantly in a way that the data won't be backwards compatible.
def __init__(value)
Create a new instance of the Utf8 datatype.
def arrow_type()
classmethod
The pyarrow type of this batch.
Part of the rerun.ComponentBatchLike logging interface.
def as_arrow_array()
The component as an arrow batch.
Part of the rerun.ComponentBatchLike logging interface.
def component_type()
classmethod
Returns the name of the component.
Part of the rerun.ComponentBatchLike logging interface.
class ViewClassBatch
Bases: Utf8Batch, ComponentBatchMixin
def __init__(data, strict=None)
Construct a new batch.
This method must flexibly accept native data (which comply with type T). Subclasses must provide a type
parameter specifying the type of the native data (this is automatically handled by the code generator).
A value of None indicates that the component should be cleared and results in the creation of an empty array.
The actual creation of the Arrow array is delegated to the _native_to_pa_array() method, which is not
implemented by default.
| PARAMETER | DESCRIPTION |
|---|---|
data
|
The data to convert into an Arrow array.
TYPE:
|
strict
|
Whether to raise an exception if the data cannot be converted into an Arrow array. If None, the value
defaults to the value of the
TYPE:
|
| RETURNS | DESCRIPTION |
|---|---|
The Arrow array encapsulating the data.
|
|
def as_arrow_array()
The component as an arrow batch.
Part of the rerun.ComponentBatchLike logging interface.
def component_type()
Returns the name of the component.
Part of the rerun.ComponentBatchLike logging interface.
def described(descriptor)
Wraps the current ComponentBatchLike in a DescribedComponentBatch with the given descriptor.
def partition(lengths=None)
Partitions the component batch into multiple sub-batches, forming a column.
This makes it possible to use rr.send_columns to send columnar data directly into Rerun.
The returned columns will be partitioned into unit-length sub-batches by default.
Use ComponentColumn.partition to repartition the data as needed.
| PARAMETER | DESCRIPTION |
|---|---|
lengths
|
The offsets to partition the component at.
If specified,
TYPE:
|
| RETURNS | DESCRIPTION |
|---|---|
The partitioned component batch as a column.
|
|
class ViewFit
Bases: Enum
Component: Determines whether an image or texture should be scaled to fit the viewport.
Fill = 2
class-attribute
instance-attribute
Scale the image for the largest possible fit in the view's container.
FillKeepAspectRatio = 3
class-attribute
instance-attribute
Scale the image for the largest possible fit in the view's container, but keep the original aspect ratio.
Original = 1
class-attribute
instance-attribute
No scaling, pixel size will match the image's width/height dimensions in pixels.
def __str__()
Returns the variant name.
def auto(val)
classmethod
Best-effort converter, including a case-insensitive string matcher.
class ViewFitBatch
Bases: BaseBatch[ViewFitArrayLike], ComponentBatchMixin
def __init__(data, strict=None)
Construct a new batch.
This method must flexibly accept native data (which comply with type T). Subclasses must provide a type
parameter specifying the type of the native data (this is automatically handled by the code generator).
A value of None indicates that the component should be cleared and results in the creation of an empty array.
The actual creation of the Arrow array is delegated to the _native_to_pa_array() method, which is not
implemented by default.
| PARAMETER | DESCRIPTION |
|---|---|
data
|
The data to convert into an Arrow array.
TYPE:
|
strict
|
Whether to raise an exception if the data cannot be converted into an Arrow array. If None, the value
defaults to the value of the
TYPE:
|
| RETURNS | DESCRIPTION |
|---|---|
The Arrow array encapsulating the data.
|
|
def as_arrow_array()
The component as an arrow batch.
Part of the rerun.ComponentBatchLike logging interface.
def component_type()
Returns the name of the component.
Part of the rerun.ComponentBatchLike logging interface.
def described(descriptor)
Wraps the current ComponentBatchLike in a DescribedComponentBatch with the given descriptor.
def partition(lengths=None)
Partitions the component batch into multiple sub-batches, forming a column.
This makes it possible to use rr.send_columns to send columnar data directly into Rerun.
The returned columns will be partitioned into unit-length sub-batches by default.
Use ComponentColumn.partition to repartition the data as needed.
| PARAMETER | DESCRIPTION |
|---|---|
lengths
|
The offsets to partition the component at.
If specified,
TYPE:
|
| RETURNS | DESCRIPTION |
|---|---|
The partitioned component batch as a column.
|
|
class ViewMaximized
Bases: Uuid, ComponentMixin
Component: Whether a view is maximized.
⚠️ This type is unstable and may change significantly in a way that the data won't be backwards compatible.
def __init__(bytes)
Create a new instance of the Uuid datatype.
| PARAMETER | DESCRIPTION |
|---|---|
bytes
|
The raw bytes representing the UUID.
TYPE:
|
def arrow_type()
classmethod
The pyarrow type of this batch.
Part of the rerun.ComponentBatchLike logging interface.
def as_arrow_array()
The component as an arrow batch.
Part of the rerun.ComponentBatchLike logging interface.
def component_type()
classmethod
Returns the name of the component.
Part of the rerun.ComponentBatchLike logging interface.
class ViewMaximizedBatch
Bases: UuidBatch, ComponentBatchMixin
def __init__(data, strict=None)
Construct a new batch.
This method must flexibly accept native data (which comply with type T). Subclasses must provide a type
parameter specifying the type of the native data (this is automatically handled by the code generator).
A value of None indicates that the component should be cleared and results in the creation of an empty array.
The actual creation of the Arrow array is delegated to the _native_to_pa_array() method, which is not
implemented by default.
| PARAMETER | DESCRIPTION |
|---|---|
data
|
The data to convert into an Arrow array.
TYPE:
|
strict
|
Whether to raise an exception if the data cannot be converted into an Arrow array. If None, the value
defaults to the value of the
TYPE:
|
| RETURNS | DESCRIPTION |
|---|---|
The Arrow array encapsulating the data.
|
|
def as_arrow_array()
The component as an arrow batch.
Part of the rerun.ComponentBatchLike logging interface.
def component_type()
Returns the name of the component.
Part of the rerun.ComponentBatchLike logging interface.
def described(descriptor)
Wraps the current ComponentBatchLike in a DescribedComponentBatch with the given descriptor.
def partition(lengths=None)
Partitions the component batch into multiple sub-batches, forming a column.
This makes it possible to use rr.send_columns to send columnar data directly into Rerun.
The returned columns will be partitioned into unit-length sub-batches by default.
Use ComponentColumn.partition to repartition the data as needed.
| PARAMETER | DESCRIPTION |
|---|---|
lengths
|
The offsets to partition the component at.
If specified,
TYPE:
|
| RETURNS | DESCRIPTION |
|---|---|
The partitioned component batch as a column.
|
|
class ViewOrigin
Bases: EntityPath, ComponentMixin
Component: The origin of a view.
⚠️ This type is unstable and may change significantly in a way that the data won't be backwards compatible.
def __init__(path)
Create a new instance of the EntityPath datatype.
def arrow_type()
classmethod
The pyarrow type of this batch.
Part of the rerun.ComponentBatchLike logging interface.
def as_arrow_array()
The component as an arrow batch.
Part of the rerun.ComponentBatchLike logging interface.
def component_type()
classmethod
Returns the name of the component.
Part of the rerun.ComponentBatchLike logging interface.
class ViewOriginBatch
Bases: EntityPathBatch, ComponentBatchMixin
def __init__(data, strict=None)
Construct a new batch.
This method must flexibly accept native data (which comply with type T). Subclasses must provide a type
parameter specifying the type of the native data (this is automatically handled by the code generator).
A value of None indicates that the component should be cleared and results in the creation of an empty array.
The actual creation of the Arrow array is delegated to the _native_to_pa_array() method, which is not
implemented by default.
| PARAMETER | DESCRIPTION |
|---|---|
data
|
The data to convert into an Arrow array.
TYPE:
|
strict
|
Whether to raise an exception if the data cannot be converted into an Arrow array. If None, the value
defaults to the value of the
TYPE:
|
| RETURNS | DESCRIPTION |
|---|---|
The Arrow array encapsulating the data.
|
|
def as_arrow_array()
The component as an arrow batch.
Part of the rerun.ComponentBatchLike logging interface.
def component_type()
Returns the name of the component.
Part of the rerun.ComponentBatchLike logging interface.
def described(descriptor)
Wraps the current ComponentBatchLike in a DescribedComponentBatch with the given descriptor.
def partition(lengths=None)
Partitions the component batch into multiple sub-batches, forming a column.
This makes it possible to use rr.send_columns to send columnar data directly into Rerun.
The returned columns will be partitioned into unit-length sub-batches by default.
Use ComponentColumn.partition to repartition the data as needed.
| PARAMETER | DESCRIPTION |
|---|---|
lengths
|
The offsets to partition the component at.
If specified,
TYPE:
|
| RETURNS | DESCRIPTION |
|---|---|
The partitioned component batch as a column.
|
|
class ViewerRecommendationHash
Bases: UInt64, ComponentMixin
Component: Hash of a viewer recommendation.
The formation of this hash is considered an internal implementation detail of the viewer.
⚠️ This type is unstable and may change significantly in a way that the data won't be backwards compatible.
def __init__(value)
Create a new instance of the UInt64 datatype.
def arrow_type()
classmethod
The pyarrow type of this batch.
Part of the rerun.ComponentBatchLike logging interface.
def as_arrow_array()
The component as an arrow batch.
Part of the rerun.ComponentBatchLike logging interface.
def component_type()
classmethod
Returns the name of the component.
Part of the rerun.ComponentBatchLike logging interface.
class ViewerRecommendationHashBatch
Bases: UInt64Batch, ComponentBatchMixin
def __init__(data, strict=None)
Construct a new batch.
This method must flexibly accept native data (which comply with type T). Subclasses must provide a type
parameter specifying the type of the native data (this is automatically handled by the code generator).
A value of None indicates that the component should be cleared and results in the creation of an empty array.
The actual creation of the Arrow array is delegated to the _native_to_pa_array() method, which is not
implemented by default.
| PARAMETER | DESCRIPTION |
|---|---|
data
|
The data to convert into an Arrow array.
TYPE:
|
strict
|
Whether to raise an exception if the data cannot be converted into an Arrow array. If None, the value
defaults to the value of the
TYPE:
|
| RETURNS | DESCRIPTION |
|---|---|
The Arrow array encapsulating the data.
|
|
def as_arrow_array()
The component as an arrow batch.
Part of the rerun.ComponentBatchLike logging interface.
def component_type()
Returns the name of the component.
Part of the rerun.ComponentBatchLike logging interface.
def described(descriptor)
Wraps the current ComponentBatchLike in a DescribedComponentBatch with the given descriptor.
def partition(lengths=None)
Partitions the component batch into multiple sub-batches, forming a column.
This makes it possible to use rr.send_columns to send columnar data directly into Rerun.
The returned columns will be partitioned into unit-length sub-batches by default.
Use ComponentColumn.partition to repartition the data as needed.
| PARAMETER | DESCRIPTION |
|---|---|
lengths
|
The offsets to partition the component at.
If specified,
TYPE:
|
| RETURNS | DESCRIPTION |
|---|---|
The partitioned component batch as a column.
|
|
class VisibleTimeRange
Bases: VisibleTimeRange, ComponentMixin
Component: The range of values on a given timeline that will be included in a view's query.
Refer to VisibleTimeRanges archetype for more information.
⚠️ This type is unstable and may change significantly in a way that the data won't be backwards compatible.
def __init__(timeline, range=None, *, start=None, end=None)
Create a new instance of the VisibleTimeRange datatype.
| PARAMETER | DESCRIPTION |
|---|---|
timeline
|
Name of the timeline this applies to.
TYPE:
|
range
|
Time range to use for this timeline.
TYPE:
|
start
|
Low time boundary for sequence timeline. Specify this instead of
TYPE:
|
end
|
High time boundary for sequence timeline. Specify this instead of
TYPE:
|
def arrow_type()
classmethod
The pyarrow type of this batch.
Part of the rerun.ComponentBatchLike logging interface.
def as_arrow_array()
The component as an arrow batch.
Part of the rerun.ComponentBatchLike logging interface.
def component_type()
classmethod
Returns the name of the component.
Part of the rerun.ComponentBatchLike logging interface.
class VisibleTimeRangeBatch
Bases: VisibleTimeRangeBatch, ComponentBatchMixin
def __init__(data, strict=None)
Construct a new batch.
This method must flexibly accept native data (which comply with type T). Subclasses must provide a type
parameter specifying the type of the native data (this is automatically handled by the code generator).
A value of None indicates that the component should be cleared and results in the creation of an empty array.
The actual creation of the Arrow array is delegated to the _native_to_pa_array() method, which is not
implemented by default.
| PARAMETER | DESCRIPTION |
|---|---|
data
|
The data to convert into an Arrow array.
TYPE:
|
strict
|
Whether to raise an exception if the data cannot be converted into an Arrow array. If None, the value
defaults to the value of the
TYPE:
|
| RETURNS | DESCRIPTION |
|---|---|
The Arrow array encapsulating the data.
|
|
def as_arrow_array()
The component as an arrow batch.
Part of the rerun.ComponentBatchLike logging interface.
def component_type()
Returns the name of the component.
Part of the rerun.ComponentBatchLike logging interface.
def described(descriptor)
Wraps the current ComponentBatchLike in a DescribedComponentBatch with the given descriptor.
def partition(lengths=None)
Partitions the component batch into multiple sub-batches, forming a column.
This makes it possible to use rr.send_columns to send columnar data directly into Rerun.
The returned columns will be partitioned into unit-length sub-batches by default.
Use ComponentColumn.partition to repartition the data as needed.
| PARAMETER | DESCRIPTION |
|---|---|
lengths
|
The offsets to partition the component at.
If specified,
TYPE:
|
| RETURNS | DESCRIPTION |
|---|---|
The partitioned component batch as a column.
|
|
class VisualBounds2D
Bases: VisualBounds2DExt, Range2D, ComponentMixin
Component: Visual bounds in 2D space used for Spatial2DView.
⚠️ This type is unstable and may change significantly in a way that the data won't be backwards compatible.
def __init__(*, x_range, y_range)
Create a new instance of the VisualBounds2D component.
| PARAMETER | DESCRIPTION |
|---|---|
x_range
|
The minimum visible range of the X-axis (usually left and right bounds).
TYPE:
|
y_range
|
The minimum visible range of the Y-axis (usually left and right bounds).
TYPE:
|
def arrow_type()
classmethod
The pyarrow type of this batch.
Part of the rerun.ComponentBatchLike logging interface.
def as_arrow_array()
The component as an arrow batch.
Part of the rerun.ComponentBatchLike logging interface.
def component_type()
classmethod
Returns the name of the component.
Part of the rerun.ComponentBatchLike logging interface.
class VisualBounds2DBatch
Bases: Range2DBatch, ComponentBatchMixin
def __init__(data, strict=None)
Construct a new batch.
This method must flexibly accept native data (which comply with type T). Subclasses must provide a type
parameter specifying the type of the native data (this is automatically handled by the code generator).
A value of None indicates that the component should be cleared and results in the creation of an empty array.
The actual creation of the Arrow array is delegated to the _native_to_pa_array() method, which is not
implemented by default.
| PARAMETER | DESCRIPTION |
|---|---|
data
|
The data to convert into an Arrow array.
TYPE:
|
strict
|
Whether to raise an exception if the data cannot be converted into an Arrow array. If None, the value
defaults to the value of the
TYPE:
|
| RETURNS | DESCRIPTION |
|---|---|
The Arrow array encapsulating the data.
|
|
def as_arrow_array()
The component as an arrow batch.
Part of the rerun.ComponentBatchLike logging interface.
def component_type()
Returns the name of the component.
Part of the rerun.ComponentBatchLike logging interface.
def described(descriptor)
Wraps the current ComponentBatchLike in a DescribedComponentBatch with the given descriptor.
def partition(lengths=None)
Partitions the component batch into multiple sub-batches, forming a column.
This makes it possible to use rr.send_columns to send columnar data directly into Rerun.
The returned columns will be partitioned into unit-length sub-batches by default.
Use ComponentColumn.partition to repartition the data as needed.
| PARAMETER | DESCRIPTION |
|---|---|
lengths
|
The offsets to partition the component at.
If specified,
TYPE:
|
| RETURNS | DESCRIPTION |
|---|---|
The partitioned component batch as a column.
|
|
class VisualizerComponentMapping
Bases: VisualizerComponentMapping, ComponentMixin
Component: Associates components of an entity to components of a visualizer.
⚠️ This type is unstable and may change significantly in a way that the data won't be backwards compatible.
def __init__(target, source_kind, *, source_component=None, selector=None)
Create a new instance of the VisualizerComponentMapping datatype.
| PARAMETER | DESCRIPTION |
|---|---|
target
|
Target component name which is being mapped to. This represents a "slot" on the visualizer.
TYPE:
|
source_kind
|
What kind of source to pick.
TYPE:
|
source_component
|
Component selector for mapping. Defaults to
TYPE:
|
selector
|
Optional selector string using jq-like syntax to pick a specific field on Example: ".x" picks a field called "x" from the Defaults to empty string if not specified.
TYPE:
|
def arrow_type()
classmethod
The pyarrow type of this batch.
Part of the rerun.ComponentBatchLike logging interface.
def as_arrow_array()
The component as an arrow batch.
Part of the rerun.ComponentBatchLike logging interface.
def component_type()
classmethod
Returns the name of the component.
Part of the rerun.ComponentBatchLike logging interface.
class VisualizerComponentMappingBatch
Bases: VisualizerComponentMappingBatch, ComponentBatchMixin
def __init__(data, strict=None)
Construct a new batch.
This method must flexibly accept native data (which comply with type T). Subclasses must provide a type
parameter specifying the type of the native data (this is automatically handled by the code generator).
A value of None indicates that the component should be cleared and results in the creation of an empty array.
The actual creation of the Arrow array is delegated to the _native_to_pa_array() method, which is not
implemented by default.
| PARAMETER | DESCRIPTION |
|---|---|
data
|
The data to convert into an Arrow array.
TYPE:
|
strict
|
Whether to raise an exception if the data cannot be converted into an Arrow array. If None, the value
defaults to the value of the
TYPE:
|
| RETURNS | DESCRIPTION |
|---|---|
The Arrow array encapsulating the data.
|
|
def as_arrow_array()
The component as an arrow batch.
Part of the rerun.ComponentBatchLike logging interface.
def component_type()
Returns the name of the component.
Part of the rerun.ComponentBatchLike logging interface.
def described(descriptor)
Wraps the current ComponentBatchLike in a DescribedComponentBatch with the given descriptor.
def partition(lengths=None)
Partitions the component batch into multiple sub-batches, forming a column.
This makes it possible to use rr.send_columns to send columnar data directly into Rerun.
The returned columns will be partitioned into unit-length sub-batches by default.
Use ComponentColumn.partition to repartition the data as needed.
| PARAMETER | DESCRIPTION |
|---|---|
lengths
|
The offsets to partition the component at.
If specified,
TYPE:
|
| RETURNS | DESCRIPTION |
|---|---|
The partitioned component batch as a column.
|
|
class VisualizerInstructionId
Bases: Uuid, ComponentMixin
Component: ID for a visualizer instruction.
IDs are only guaranteed to be unique in the scope of a view.
For details see archetypes.ActiveVisualizers.
⚠️ This type is unstable and may change significantly in a way that the data won't be backwards compatible.
def __init__(bytes)
Create a new instance of the Uuid datatype.
| PARAMETER | DESCRIPTION |
|---|---|
bytes
|
The raw bytes representing the UUID.
TYPE:
|
def arrow_type()
classmethod
The pyarrow type of this batch.
Part of the rerun.ComponentBatchLike logging interface.
def as_arrow_array()
The component as an arrow batch.
Part of the rerun.ComponentBatchLike logging interface.
def component_type()
classmethod
Returns the name of the component.
Part of the rerun.ComponentBatchLike logging interface.
class VisualizerInstructionIdBatch
Bases: UuidBatch, ComponentBatchMixin
def __init__(data, strict=None)
Construct a new batch.
This method must flexibly accept native data (which comply with type T). Subclasses must provide a type
parameter specifying the type of the native data (this is automatically handled by the code generator).
A value of None indicates that the component should be cleared and results in the creation of an empty array.
The actual creation of the Arrow array is delegated to the _native_to_pa_array() method, which is not
implemented by default.
| PARAMETER | DESCRIPTION |
|---|---|
data
|
The data to convert into an Arrow array.
TYPE:
|
strict
|
Whether to raise an exception if the data cannot be converted into an Arrow array. If None, the value
defaults to the value of the
TYPE:
|
| RETURNS | DESCRIPTION |
|---|---|
The Arrow array encapsulating the data.
|
|
def as_arrow_array()
The component as an arrow batch.
Part of the rerun.ComponentBatchLike logging interface.
def component_type()
Returns the name of the component.
Part of the rerun.ComponentBatchLike logging interface.
def described(descriptor)
Wraps the current ComponentBatchLike in a DescribedComponentBatch with the given descriptor.
def partition(lengths=None)
Partitions the component batch into multiple sub-batches, forming a column.
This makes it possible to use rr.send_columns to send columnar data directly into Rerun.
The returned columns will be partitioned into unit-length sub-batches by default.
Use ComponentColumn.partition to repartition the data as needed.
| PARAMETER | DESCRIPTION |
|---|---|
lengths
|
The offsets to partition the component at.
If specified,
TYPE:
|
| RETURNS | DESCRIPTION |
|---|---|
The partitioned component batch as a column.
|
|
class VisualizerType
Bases: Utf8, ComponentMixin
Component: The type of the visualizer.
⚠️ This type is unstable and may change significantly in a way that the data won't be backwards compatible.
def __init__(value)
Create a new instance of the Utf8 datatype.
def arrow_type()
classmethod
The pyarrow type of this batch.
Part of the rerun.ComponentBatchLike logging interface.
def as_arrow_array()
The component as an arrow batch.
Part of the rerun.ComponentBatchLike logging interface.
def component_type()
classmethod
Returns the name of the component.
Part of the rerun.ComponentBatchLike logging interface.
class VisualizerTypeBatch
Bases: Utf8Batch, ComponentBatchMixin
def __init__(data, strict=None)
Construct a new batch.
This method must flexibly accept native data (which comply with type T). Subclasses must provide a type
parameter specifying the type of the native data (this is automatically handled by the code generator).
A value of None indicates that the component should be cleared and results in the creation of an empty array.
The actual creation of the Arrow array is delegated to the _native_to_pa_array() method, which is not
implemented by default.
| PARAMETER | DESCRIPTION |
|---|---|
data
|
The data to convert into an Arrow array.
TYPE:
|
strict
|
Whether to raise an exception if the data cannot be converted into an Arrow array. If None, the value
defaults to the value of the
TYPE:
|
| RETURNS | DESCRIPTION |
|---|---|
The Arrow array encapsulating the data.
|
|
def as_arrow_array()
The component as an arrow batch.
Part of the rerun.ComponentBatchLike logging interface.
def component_type()
Returns the name of the component.
Part of the rerun.ComponentBatchLike logging interface.
def described(descriptor)
Wraps the current ComponentBatchLike in a DescribedComponentBatch with the given descriptor.
def partition(lengths=None)
Partitions the component batch into multiple sub-batches, forming a column.
This makes it possible to use rr.send_columns to send columnar data directly into Rerun.
The returned columns will be partitioned into unit-length sub-batches by default.
Use ComponentColumn.partition to repartition the data as needed.
| PARAMETER | DESCRIPTION |
|---|---|
lengths
|
The offsets to partition the component at.
If specified,
TYPE:
|
| RETURNS | DESCRIPTION |
|---|---|
The partitioned component batch as a column.
|
|
class ZoomLevel
Bases: Float64, ComponentMixin
Component: A zoom level determines how much of the world is visible on a map.
⚠️ This type is unstable and may change significantly in a way that the data won't be backwards compatible.
def __init__(value)
Create a new instance of the Float64 datatype.
def arrow_type()
classmethod
The pyarrow type of this batch.
Part of the rerun.ComponentBatchLike logging interface.
def as_arrow_array()
The component as an arrow batch.
Part of the rerun.ComponentBatchLike logging interface.
def component_type()
classmethod
Returns the name of the component.
Part of the rerun.ComponentBatchLike logging interface.
class ZoomLevelBatch
Bases: Float64Batch, ComponentBatchMixin
def __init__(data, strict=None)
Construct a new batch.
This method must flexibly accept native data (which comply with type T). Subclasses must provide a type
parameter specifying the type of the native data (this is automatically handled by the code generator).
A value of None indicates that the component should be cleared and results in the creation of an empty array.
The actual creation of the Arrow array is delegated to the _native_to_pa_array() method, which is not
implemented by default.
| PARAMETER | DESCRIPTION |
|---|---|
data
|
The data to convert into an Arrow array.
TYPE:
|
strict
|
Whether to raise an exception if the data cannot be converted into an Arrow array. If None, the value
defaults to the value of the
TYPE:
|
| RETURNS | DESCRIPTION |
|---|---|
The Arrow array encapsulating the data.
|
|
def as_arrow_array()
The component as an arrow batch.
Part of the rerun.ComponentBatchLike logging interface.
def component_type()
Returns the name of the component.
Part of the rerun.ComponentBatchLike logging interface.
def described(descriptor)
Wraps the current ComponentBatchLike in a DescribedComponentBatch with the given descriptor.
def partition(lengths=None)
Partitions the component batch into multiple sub-batches, forming a column.
This makes it possible to use rr.send_columns to send columnar data directly into Rerun.
The returned columns will be partitioned into unit-length sub-batches by default.
Use ComponentColumn.partition to repartition the data as needed.
| PARAMETER | DESCRIPTION |
|---|---|
lengths
|
The offsets to partition the component at.
If specified,
TYPE:
|
| RETURNS | DESCRIPTION |
|---|---|
The partitioned component batch as a column.
|
|