Components

rerun.blueprint.components

BackgroundKindArrayLike `module-attribute`

BackgroundKindArrayLike = (
    BackgroundKind
    | Literal[
        "GradientBright",
        "GradientDark",
        "SolidColor",
        "gradientbright",
        "gradientdark",
        "solidcolor",
    ]
    | int
    | Sequence[BackgroundKindLike]
)

A type alias for any BackgroundKind-like array object.

BackgroundKindLike `module-attribute`

BackgroundKindLike = (
    BackgroundKind
    | Literal[
        "GradientBright",
        "GradientDark",
        "SolidColor",
        "gradientbright",
        "gradientdark",
        "solidcolor",
    ]
    | int
)

A type alias for any BackgroundKind-like object.

ColumnOrderArrayLike `module-attribute`

ColumnOrderArrayLike = (
    ColumnOrder | Sequence[ColumnOrderLike]
)

A type alias for any ColumnOrder-like array object.

ColumnOrderLike `module-attribute`

ColumnOrderLike = ColumnOrder | Sequence[EntityPathLike]

A type alias for any ColumnOrder-like object.

ContainerKindArrayLike `module-attribute`

ContainerKindArrayLike = (
    ContainerKind
    | Literal[
        "Grid",
        "Horizontal",
        "Tabs",
        "Vertical",
        "grid",
        "horizontal",
        "tabs",
        "vertical",
    ]
    | int
    | Sequence[ContainerKindLike]
)

A type alias for any ContainerKind-like array object.

ContainerKindLike `module-attribute`

ContainerKindLike = (
    ContainerKind
    | Literal[
        "Grid",
        "Horizontal",
        "Tabs",
        "Vertical",
        "grid",
        "horizontal",
        "tabs",
        "vertical",
    ]
    | int
)

A type alias for any ContainerKind-like object.

Corner2DArrayLike `module-attribute`

Corner2DArrayLike = (
    Corner2D
    | Literal[
        "LeftBottom",
        "LeftTop",
        "RightBottom",
        "RightTop",
        "leftbottom",
        "lefttop",
        "rightbottom",
        "righttop",
    ]
    | int
    | Sequence[Corner2DLike]
)

A type alias for any Corner2D-like array object.

Corner2DLike `module-attribute`

Corner2DLike = (
    Corner2D
    | Literal[
        "LeftBottom",
        "LeftTop",
        "RightBottom",
        "RightTop",
        "leftbottom",
        "lefttop",
        "rightbottom",
        "righttop",
    ]
    | int
)

A type alias for any Corner2D-like object.

Eye3DKindArrayLike `module-attribute`

Eye3DKindArrayLike = (
    Eye3DKind
    | Literal[
        "FirstPerson", "Orbital", "firstperson", "orbital"
    ]
    | int
    | Sequence[Eye3DKindLike]
)

A type alias for any Eye3DKind-like array object.

Eye3DKindLike `module-attribute`

Eye3DKindLike = (
    Eye3DKind
    | Literal[
        "FirstPerson", "Orbital", "firstperson", "orbital"
    ]
    | int
)

A type alias for any Eye3DKind-like object.

LinkAxisArrayLike `module-attribute`

LinkAxisArrayLike = (
    LinkAxis
    | Literal[
        "Independent",
        "LinkToGlobal",
        "independent",
        "linktoglobal",
    ]
    | int
    | Sequence[LinkAxisLike]
)

A type alias for any LinkAxis-like array object.

LinkAxisLike `module-attribute`

LinkAxisLike = (
    LinkAxis
    | Literal[
        "Independent",
        "LinkToGlobal",
        "independent",
        "linktoglobal",
    ]
    | int
)

A type alias for any LinkAxis-like object.

LoopModeArrayLike `module-attribute`

LoopModeArrayLike = (
    LoopMode
    | Literal[
        "All", "Off", "Selection", "all", "off", "selection"
    ]
    | int
    | Sequence[LoopModeLike]
)

A type alias for any LoopMode-like array object.

LoopModeLike `module-attribute`

LoopModeLike = (
    LoopMode
    | Literal[
        "All", "Off", "Selection", "all", "off", "selection"
    ]
    | int
)

A type alias for any LoopMode-like object.

MapProviderArrayLike `module-attribute`

MapProviderArrayLike = (
    MapProvider
    | Literal[
        "MapboxDark",
        "MapboxLight",
        "MapboxSatellite",
        "MapboxStreets",
        "OpenStreetMap",
        "mapboxdark",
        "mapboxlight",
        "mapboxsatellite",
        "mapboxstreets",
        "openstreetmap",
    ]
    | int
    | Sequence[MapProviderLike]
)

A type alias for any MapProvider-like array object.

MapProviderLike `module-attribute`

MapProviderLike = (
    MapProvider
    | Literal[
        "MapboxDark",
        "MapboxLight",
        "MapboxSatellite",
        "MapboxStreets",
        "OpenStreetMap",
        "mapboxdark",
        "mapboxlight",
        "mapboxsatellite",
        "mapboxstreets",
        "openstreetmap",
    ]
    | int
)

A type alias for any MapProvider-like object.

PanelStateArrayLike `module-attribute`

PanelStateArrayLike = (
    PanelState
    | Literal[
        "Collapsed",
        "Expanded",
        "Hidden",
        "collapsed",
        "expanded",
        "hidden",
    ]
    | int
    | Sequence[PanelStateLike]
)

A type alias for any PanelState-like array object.

PanelStateLike `module-attribute`

PanelStateLike = (
    PanelState
    | Literal[
        "Collapsed",
        "Expanded",
        "Hidden",
        "collapsed",
        "expanded",
        "hidden",
    ]
    | int
)

A type alias for any PanelState-like object.

PlayStateArrayLike `module-attribute`

PlayStateArrayLike = (
    PlayState
    | Literal[
        "Following",
        "Paused",
        "Playing",
        "following",
        "paused",
        "playing",
    ]
    | int
    | Sequence[PlayStateLike]
)

A type alias for any PlayState-like array object.

PlayStateLike `module-attribute`

PlayStateLike = (
    PlayState
    | Literal[
        "Following",
        "Paused",
        "Playing",
        "following",
        "paused",
        "playing",
    ]
    | int
)

A type alias for any PlayState-like object.

ViewFitArrayLike `module-attribute`

ViewFitArrayLike = (
    ViewFit
    | Literal[
        "Fill",
        "FillKeepAspectRatio",
        "Original",
        "fill",
        "fillkeepaspectratio",
        "original",
    ]
    | int
    | Sequence[ViewFitLike]
)

A type alias for any ViewFit-like array object.

ViewFitLike `module-attribute`

ViewFitLike = (
    ViewFit
    | Literal[
        "Fill",
        "FillKeepAspectRatio",
        "Original",
        "fill",
        "fillkeepaspectratio",
        "original",
    ]
    | int
)

A type alias for any ViewFit-like object.

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.

init

def __init__(min: TimeIntLike, max: TimeIntLike) -> None

Create a new instance of the AbsoluteTimeRange datatype.

PARAMETER	DESCRIPTION
`min`	Beginning of the time range. TYPE: `TimeIntLike`
`max`	End of the time range. TYPE: `TimeIntLike`

arrow_type `classmethod`

def arrow_type() -> DataType

The pyarrow type of this batch.

Part of the rerun.ComponentBatchLike logging interface.

as_arrow_array

def as_arrow_array() -> Array

The component as an arrow batch.

Part of the rerun.ComponentBatchLike logging interface.

component_type `classmethod`

def component_type() -> str

Returns the name of the component.

Part of the rerun.ComponentBatchLike logging interface.

AbsoluteTimeRangeBatch

Bases: AbsoluteTimeRangeBatch, ComponentBatchMixin

init

def __init__(
    data: T | None, strict: bool | None = None
) -> 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: `T \| None`
`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 `rerun.strict` global setting. TYPE: `bool \| None` DEFAULT: `None`

RETURNS	DESCRIPTION
`The Arrow array encapsulating the data.`

as_arrow_array

def as_arrow_array() -> Array

The component as an arrow batch.

Part of the rerun.ComponentBatchLike logging interface.

component_type

def component_type() -> str

Returns the name of the component.

Part of the rerun.ComponentBatchLike logging interface.

described

def described(
    descriptor: ComponentDescriptor,
) -> DescribedComponentBatch

Wraps the current ComponentBatchLike in a DescribedComponentBatch with the given descriptor.

partition

def partition(
    lengths: ArrayLike | None = None,
) -> ComponentColumn

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, `lengths` must sum to the total length of the component batch. If left unspecified, it will default to unit-length batches. TYPE: `ArrayLike \| None` DEFAULT: `None`

RETURNS	DESCRIPTION
`The partitioned component batch as a column.`

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.

init

def __init__(path: EntityPathLike) -> None

Create a new instance of the EntityPath datatype.

arrow_type `classmethod`

def arrow_type() -> DataType

The pyarrow type of this batch.

Part of the rerun.ComponentBatchLike logging interface.

as_arrow_array

def as_arrow_array() -> Array

The component as an arrow batch.

Part of the rerun.ComponentBatchLike logging interface.

component_type `classmethod`

def component_type() -> str

Returns the name of the component.

Part of the rerun.ComponentBatchLike logging interface.

ActiveTabBatch

Bases: EntityPathBatch, ComponentBatchMixin

init

def __init__(
    data: T | None, strict: bool | None = None
) -> 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: `T \| None`
`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 `rerun.strict` global setting. TYPE: `bool \| None` DEFAULT: `None`

RETURNS	DESCRIPTION
`The Arrow array encapsulating the data.`

as_arrow_array

def as_arrow_array() -> Array

The component as an arrow batch.

Part of the rerun.ComponentBatchLike logging interface.

component_type

def component_type() -> str

Returns the name of the component.

Part of the rerun.ComponentBatchLike logging interface.

described

def described(
    descriptor: ComponentDescriptor,
) -> DescribedComponentBatch

Wraps the current ComponentBatchLike in a DescribedComponentBatch with the given descriptor.

partition

def partition(
    lengths: ArrayLike | None = None,
) -> ComponentColumn

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, `lengths` must sum to the total length of the component batch. If left unspecified, it will default to unit-length batches. TYPE: `ArrayLike \| None` DEFAULT: `None`

RETURNS	DESCRIPTION
`The partitioned component batch as a column.`

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.

init

def __init__(value: Float64Like) -> None

Create a new instance of the Float64 datatype.

arrow_type `classmethod`

def arrow_type() -> DataType

The pyarrow type of this batch.

Part of the rerun.ComponentBatchLike logging interface.

as_arrow_array

def as_arrow_array() -> Array

The component as an arrow batch.

Part of the rerun.ComponentBatchLike logging interface.

component_type `classmethod`

def component_type() -> str

Returns the name of the component.

Part of the rerun.ComponentBatchLike logging interface.

AngularSpeedBatch

Bases: Float64Batch, ComponentBatchMixin

init

def __init__(
    data: T | None, strict: bool | None = None
) -> 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: `T \| None`
`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 `rerun.strict` global setting. TYPE: `bool \| None` DEFAULT: `None`

RETURNS	DESCRIPTION
`The Arrow array encapsulating the data.`

as_arrow_array

def as_arrow_array() -> Array

The component as an arrow batch.

Part of the rerun.ComponentBatchLike logging interface.

component_type

def component_type() -> str

Returns the name of the component.

Part of the rerun.ComponentBatchLike logging interface.

described

def described(
    descriptor: ComponentDescriptor,
) -> DescribedComponentBatch

Wraps the current ComponentBatchLike in a DescribedComponentBatch with the given descriptor.

partition

def partition(
    lengths: ArrayLike | None = None,
) -> ComponentColumn

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, `lengths` must sum to the total length of the component batch. If left unspecified, it will default to unit-length batches. TYPE: `ArrayLike \| None` DEFAULT: `None`

RETURNS	DESCRIPTION
`The partitioned component batch as a column.`

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.

init

def __init__(value: BoolLike) -> None

Create a new instance of the Bool datatype.

arrow_type `classmethod`

def arrow_type() -> DataType

The pyarrow type of this batch.

Part of the rerun.ComponentBatchLike logging interface.

as_arrow_array

def as_arrow_array() -> Array

The component as an arrow batch.

Part of the rerun.ComponentBatchLike logging interface.

component_type `classmethod`

def component_type() -> str

Returns the name of the component.

Part of the rerun.ComponentBatchLike logging interface.

ApplyLatestAtBatch

Bases: BoolBatch, ComponentBatchMixin

init

def __init__(
    data: T | None, strict: bool | None = None
) -> 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: `T \| None`
`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 `rerun.strict` global setting. TYPE: `bool \| None` DEFAULT: `None`

RETURNS	DESCRIPTION
`The Arrow array encapsulating the data.`

as_arrow_array

def as_arrow_array() -> Array

The component as an arrow batch.

Part of the rerun.ComponentBatchLike logging interface.

component_type

def component_type() -> str

Returns the name of the component.

Part of the rerun.ComponentBatchLike logging interface.

described

def described(
    descriptor: ComponentDescriptor,
) -> DescribedComponentBatch

Wraps the current ComponentBatchLike in a DescribedComponentBatch with the given descriptor.

partition

def partition(
    lengths: ArrayLike | None = None,
) -> ComponentColumn

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, `lengths` must sum to the total length of the component batch. If left unspecified, it will default to unit-length batches. TYPE: `ArrayLike \| None` DEFAULT: `None`

RETURNS	DESCRIPTION
`The partitioned component batch as a column.`

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.

init

def __init__(value: BoolLike) -> None

Create a new instance of the Bool datatype.

arrow_type `classmethod`

def arrow_type() -> DataType

The pyarrow type of this batch.

Part of the rerun.ComponentBatchLike logging interface.

as_arrow_array

def as_arrow_array() -> Array

The component as an arrow batch.

Part of the rerun.ComponentBatchLike logging interface.

component_type `classmethod`

def component_type() -> str

Returns the name of the component.

Part of the rerun.ComponentBatchLike logging interface.

AutoLayoutBatch

Bases: BoolBatch, ComponentBatchMixin

init

def __init__(
    data: T | None, strict: bool | None = None
) -> 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: `T \| None`
`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 `rerun.strict` global setting. TYPE: `bool \| None` DEFAULT: `None`

RETURNS	DESCRIPTION
`The Arrow array encapsulating the data.`

as_arrow_array

def as_arrow_array() -> Array

The component as an arrow batch.

Part of the rerun.ComponentBatchLike logging interface.

component_type

def component_type() -> str

Returns the name of the component.

Part of the rerun.ComponentBatchLike logging interface.

described

def described(
    descriptor: ComponentDescriptor,
) -> DescribedComponentBatch

Wraps the current ComponentBatchLike in a DescribedComponentBatch with the given descriptor.

partition

def partition(
    lengths: ArrayLike | None = None,
) -> ComponentColumn

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, `lengths` must sum to the total length of the component batch. If left unspecified, it will default to unit-length batches. TYPE: `ArrayLike \| None` DEFAULT: `None`

RETURNS	DESCRIPTION
`The partitioned component batch as a column.`

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.

init

def __init__(value: BoolLike) -> None

Create a new instance of the Bool datatype.

arrow_type `classmethod`

def arrow_type() -> DataType

The pyarrow type of this batch.

Part of the rerun.ComponentBatchLike logging interface.

as_arrow_array

def as_arrow_array() -> Array

The component as an arrow batch.

Part of the rerun.ComponentBatchLike logging interface.

component_type `classmethod`

def component_type() -> str

Returns the name of the component.

Part of the rerun.ComponentBatchLike logging interface.

AutoScrollBatch

Bases: BoolBatch, ComponentBatchMixin

init

def __init__(
    data: T | None, strict: bool | None = None
) -> 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: `T \| None`
`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 `rerun.strict` global setting. TYPE: `bool \| None` DEFAULT: `None`

RETURNS	DESCRIPTION
`The Arrow array encapsulating the data.`

as_arrow_array

def as_arrow_array() -> Array

The component as an arrow batch.

Part of the rerun.ComponentBatchLike logging interface.

component_type

def component_type() -> str

Returns the name of the component.

Part of the rerun.ComponentBatchLike logging interface.

described

def described(
    descriptor: ComponentDescriptor,
) -> DescribedComponentBatch

Wraps the current ComponentBatchLike in a DescribedComponentBatch with the given descriptor.

partition

def partition(
    lengths: ArrayLike | None = None,
) -> ComponentColumn

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, `lengths` must sum to the total length of the component batch. If left unspecified, it will default to unit-length batches. TYPE: `ArrayLike \| None` DEFAULT: `None`

RETURNS	DESCRIPTION
`The partitioned component batch as a column.`

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.

init

def __init__(value: BoolLike) -> None

Create a new instance of the Bool datatype.

arrow_type `classmethod`

def arrow_type() -> DataType

The pyarrow type of this batch.

Part of the rerun.ComponentBatchLike logging interface.

as_arrow_array

def as_arrow_array() -> Array

The component as an arrow batch.

Part of the rerun.ComponentBatchLike logging interface.

component_type `classmethod`

def component_type() -> str

Returns the name of the component.

Part of the rerun.ComponentBatchLike logging interface.

AutoViewsBatch

Bases: BoolBatch, ComponentBatchMixin

init

def __init__(
    data: T | None, strict: bool | None = None
) -> 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: `T \| None`
`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 `rerun.strict` global setting. TYPE: `bool \| None` DEFAULT: `None`

RETURNS	DESCRIPTION
`The Arrow array encapsulating the data.`

as_arrow_array

def as_arrow_array() -> Array

The component as an arrow batch.

Part of the rerun.ComponentBatchLike logging interface.

component_type

def component_type() -> str

Returns the name of the component.

Part of the rerun.ComponentBatchLike logging interface.

described

def described(
    descriptor: ComponentDescriptor,
) -> DescribedComponentBatch

Wraps the current ComponentBatchLike in a DescribedComponentBatch with the given descriptor.

partition

def partition(
    lengths: ArrayLike | None = None,
) -> ComponentColumn

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, `lengths` must sum to the total length of the component batch. If left unspecified, it will default to unit-length batches. TYPE: `ArrayLike \| None` DEFAULT: `None`

RETURNS	DESCRIPTION
`The partitioned component batch as a column.`

BackgroundKind

Bases: Enum

Component: The type of the background in a view.

GradientBright `class-attribute` `instance-attribute`

GradientBright = 2

A bright gradient.

In 3D views it changes depending on the direction of the view.

GradientDark `class-attribute` `instance-attribute`

GradientDark = 1

A dark gradient.

In 3D views it changes depending on the direction of the view.

SolidColor `class-attribute` `instance-attribute`

SolidColor = 3

Simple uniform color.

str

def __str__() -> str

Returns the variant name.

auto `classmethod`

def auto(val: str | int | BackgroundKind) -> BackgroundKind

Best-effort converter, including a case-insensitive string matcher.

BackgroundKindBatch

Bases: BaseBatch[BackgroundKindArrayLike], ComponentBatchMixin

init

def __init__(
    data: T | None, strict: bool | None = None
) -> 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: `T \| None`
`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 `rerun.strict` global setting. TYPE: `bool \| None` DEFAULT: `None`

RETURNS	DESCRIPTION
`The Arrow array encapsulating the data.`

as_arrow_array

def as_arrow_array() -> Array

The component as an arrow batch.

Part of the rerun.ComponentBatchLike logging interface.

component_type

def component_type() -> str

Returns the name of the component.

Part of the rerun.ComponentBatchLike logging interface.

described

def described(
    descriptor: ComponentDescriptor,
) -> DescribedComponentBatch

Wraps the current ComponentBatchLike in a DescribedComponentBatch with the given descriptor.

partition

def partition(
    lengths: ArrayLike | None = None,
) -> ComponentColumn

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, `lengths` must sum to the total length of the component batch. If left unspecified, it will default to unit-length batches. TYPE: `ArrayLike \| None` DEFAULT: `None`

RETURNS	DESCRIPTION
`The partitioned component batch as a column.`

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.

init

def __init__(value: Utf8Like) -> None

Create a new instance of the Utf8 datatype.

arrow_type `classmethod`

def arrow_type() -> DataType

The pyarrow type of this batch.

Part of the rerun.ComponentBatchLike logging interface.

as_arrow_array

def as_arrow_array() -> Array

The component as an arrow batch.

Part of the rerun.ComponentBatchLike logging interface.

component_type `classmethod`

def component_type() -> str

Returns the name of the component.

Part of the rerun.ComponentBatchLike logging interface.

ColumnNameBatch

Bases: Utf8Batch, ComponentBatchMixin

init

def __init__(
    data: T | None, strict: bool | None = None
) -> 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: `T \| None`
`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 `rerun.strict` global setting. TYPE: `bool \| None` DEFAULT: `None`

RETURNS	DESCRIPTION
`The Arrow array encapsulating the data.`

as_arrow_array

def as_arrow_array() -> Array

The component as an arrow batch.

Part of the rerun.ComponentBatchLike logging interface.

component_type

def component_type() -> str

Returns the name of the component.

Part of the rerun.ComponentBatchLike logging interface.

described

def described(
    descriptor: ComponentDescriptor,
) -> DescribedComponentBatch

Wraps the current ComponentBatchLike in a DescribedComponentBatch with the given descriptor.

partition

def partition(
    lengths: ArrayLike | None = None,
) -> ComponentColumn

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, `lengths` must sum to the total length of the component batch. If left unspecified, it will default to unit-length batches. TYPE: `ArrayLike \| None` DEFAULT: `None`

RETURNS	DESCRIPTION
`The partitioned component batch as a column.`

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.

init

def __init__(entity_paths: ColumnOrderLike) -> None

Create a new instance of the ColumnOrder component.

arrow_type `classmethod`

def arrow_type() -> DataType

The pyarrow type of this batch.

Part of the rerun.ComponentBatchLike logging interface.

as_arrow_array

def as_arrow_array() -> Array

The component as an arrow batch.

Part of the rerun.ComponentBatchLike logging interface.

component_type `classmethod`

def component_type() -> str

Returns the name of the component.

Part of the rerun.ComponentBatchLike logging interface.

ColumnOrderBatch

Bases: BaseBatch[ColumnOrderArrayLike], ComponentBatchMixin

init

def __init__(
    data: T | None, strict: bool | None = None
) -> 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: `T \| None`
`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 `rerun.strict` global setting. TYPE: `bool \| None` DEFAULT: `None`

RETURNS	DESCRIPTION
`The Arrow array encapsulating the data.`

as_arrow_array

def as_arrow_array() -> Array

The component as an arrow batch.

Part of the rerun.ComponentBatchLike logging interface.

component_type

def component_type() -> str

Returns the name of the component.

Part of the rerun.ComponentBatchLike logging interface.

described

def described(
    descriptor: ComponentDescriptor,
) -> DescribedComponentBatch

Wraps the current ComponentBatchLike in a DescribedComponentBatch with the given descriptor.

partition

def partition(
    lengths: ArrayLike | None = None,
) -> ComponentColumn

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, `lengths` must sum to the total length of the component batch. If left unspecified, it will default to unit-length batches. TYPE: `ArrayLike \| None` DEFAULT: `None`

RETURNS	DESCRIPTION
`The partitioned component batch as a column.`

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.

init

def __init__(value: Float32Like) -> None

Create a new instance of the Float32 datatype.

arrow_type `classmethod`

def arrow_type() -> DataType

The pyarrow type of this batch.

Part of the rerun.ComponentBatchLike logging interface.

as_arrow_array

def as_arrow_array() -> Array

The component as an arrow batch.

Part of the rerun.ComponentBatchLike logging interface.

component_type `classmethod`

def component_type() -> str

Returns the name of the component.

Part of the rerun.ComponentBatchLike logging interface.

ColumnShareBatch

Bases: Float32Batch, ComponentBatchMixin

init

def __init__(
    data: T | None, strict: bool | None = None
) -> 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: `T \| None`
`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 `rerun.strict` global setting. TYPE: `bool \| None` DEFAULT: `None`

RETURNS	DESCRIPTION
`The Arrow array encapsulating the data.`

as_arrow_array

def as_arrow_array() -> Array

The component as an arrow batch.

Part of the rerun.ComponentBatchLike logging interface.

component_type

def component_type() -> str

Returns the name of the component.

Part of the rerun.ComponentBatchLike logging interface.

described

def described(
    descriptor: ComponentDescriptor,
) -> DescribedComponentBatch

Wraps the current ComponentBatchLike in a DescribedComponentBatch with the given descriptor.

partition

def partition(
    lengths: ArrayLike | None = None,
) -> ComponentColumn

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, `lengths` must sum to the total length of the component batch. If left unspecified, it will default to unit-length batches. TYPE: `ArrayLike \| None` DEFAULT: `None`

RETURNS	DESCRIPTION
`The partitioned component batch as a column.`

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.

init

def __init__(
    spec: str | None = None,
    *,
    entity_path: EntityPathLike | None = None,
    component: Utf8Like | None = None,
) -> None

Create a new instance of the ComponentColumnSelector datatype.

PARAMETER	DESCRIPTION
`spec`	A string in the format "/entity/path:Component". If used, `entity_path` and `component` must be `None`. TYPE: `str \| None` DEFAULT: `None`
`entity_path`	The column's entity path. If used, `spec` must be `None` and `component` must be provided. TYPE: `EntityPathLike \| None` DEFAULT: `None`
`component`	The column's component type. If used, `spec` must be `None` and `entity_path` must be provided. TYPE: `Utf8Like \| None` DEFAULT: `None`

arrow_type `classmethod`

def arrow_type() -> DataType

The pyarrow type of this batch.

Part of the rerun.ComponentBatchLike logging interface.

as_arrow_array

def as_arrow_array() -> Array

The component as an arrow batch.

Part of the rerun.ComponentBatchLike logging interface.

component_type `classmethod`

def component_type() -> str

Returns the name of the component.

Part of the rerun.ComponentBatchLike logging interface.

ComponentColumnSelectorBatch

Bases: ComponentColumnSelectorBatch, ComponentBatchMixin

init

def __init__(
    data: T | None, strict: bool | None = None
) -> 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: `T \| None`
`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 `rerun.strict` global setting. TYPE: `bool \| None` DEFAULT: `None`

RETURNS	DESCRIPTION
`The Arrow array encapsulating the data.`

as_arrow_array

def as_arrow_array() -> Array

The component as an arrow batch.

Part of the rerun.ComponentBatchLike logging interface.

component_type

def component_type() -> str

Returns the name of the component.

Part of the rerun.ComponentBatchLike logging interface.

described

def described(
    descriptor: ComponentDescriptor,
) -> DescribedComponentBatch

Wraps the current ComponentBatchLike in a DescribedComponentBatch with the given descriptor.

partition

def partition(
    lengths: ArrayLike | None = None,
) -> ComponentColumn

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, `lengths` must sum to the total length of the component batch. If left unspecified, it will default to unit-length batches. TYPE: `ArrayLike \| None` DEFAULT: `None`

RETURNS	DESCRIPTION
`The partitioned component batch as a column.`

ContainerKind

Bases: Enum

Component: The kind of a blueprint container (tabs, grid, …).

Grid `class-attribute` `instance-attribute`

Grid = 4

Organize children in a grid layout

Horizontal `class-attribute` `instance-attribute`

Horizontal = 2

Order the children left to right

Tabs `class-attribute` `instance-attribute`

Tabs = 1

Put children in separate tabs

Vertical `class-attribute` `instance-attribute`

Vertical = 3

Order the children top to bottom

str

def __str__() -> str

Returns the variant name.

auto `classmethod`

def auto(val: str | int | ContainerKind) -> ContainerKind

Best-effort converter, including a case-insensitive string matcher.

ContainerKindBatch

Bases: BaseBatch[ContainerKindArrayLike], ComponentBatchMixin

init

def __init__(
    data: T | None, strict: bool | None = None
) -> 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: `T \| None`
`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 `rerun.strict` global setting. TYPE: `bool \| None` DEFAULT: `None`

RETURNS	DESCRIPTION
`The Arrow array encapsulating the data.`

as_arrow_array

def as_arrow_array() -> Array

The component as an arrow batch.

Part of the rerun.ComponentBatchLike logging interface.

component_type

def component_type() -> str

Returns the name of the component.

Part of the rerun.ComponentBatchLike logging interface.

described

def described(
    descriptor: ComponentDescriptor,
) -> DescribedComponentBatch

Wraps the current ComponentBatchLike in a DescribedComponentBatch with the given descriptor.

partition

def partition(
    lengths: ArrayLike | None = None,
) -> ComponentColumn

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, `lengths` must sum to the total length of the component batch. If left unspecified, it will default to unit-length batches. TYPE: `ArrayLike \| None` DEFAULT: `None`

RETURNS	DESCRIPTION
`The partitioned component batch as a column.`

Corner2D

Bases: Enum

Component: One of four 2D corners, typically used to align objects.

LeftBottom `class-attribute` `instance-attribute`

LeftBottom = 3

Left bottom corner.

LeftTop `class-attribute` `instance-attribute`

LeftTop = 1

Left top corner.

RightBottom `class-attribute` `instance-attribute`

RightBottom = 4

Right bottom corner.

RightTop `class-attribute` `instance-attribute`

RightTop = 2

Right top corner.

str

def __str__() -> str

Returns the variant name.

auto `classmethod`

def auto(val: str | int | Corner2D) -> Corner2D

Best-effort converter, including a case-insensitive string matcher.

Corner2DBatch

Bases: BaseBatch[Corner2DArrayLike], ComponentBatchMixin

init

def __init__(
    data: T | None, strict: bool | None = None
) -> 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: `T \| None`
`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 `rerun.strict` global setting. TYPE: `bool \| None` DEFAULT: `None`

RETURNS	DESCRIPTION
`The Arrow array encapsulating the data.`

as_arrow_array

def as_arrow_array() -> Array

The component as an arrow batch.

Part of the rerun.ComponentBatchLike logging interface.

component_type

def component_type() -> str

Returns the name of the component.

Part of the rerun.ComponentBatchLike logging interface.

described

def described(
    descriptor: ComponentDescriptor,
) -> DescribedComponentBatch

Wraps the current ComponentBatchLike in a DescribedComponentBatch with the given descriptor.

partition

def partition(
    lengths: ArrayLike | None = None,
) -> ComponentColumn

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, `lengths` must sum to the total length of the component batch. If left unspecified, it will default to unit-length batches. TYPE: `ArrayLike \| None` DEFAULT: `None`

RETURNS	DESCRIPTION
`The partitioned component batch as a column.`

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.

init

def __init__(value: BoolLike) -> None

Create a new instance of the Bool datatype.

arrow_type `classmethod`

def arrow_type() -> DataType

The pyarrow type of this batch.

Part of the rerun.ComponentBatchLike logging interface.

as_arrow_array

def as_arrow_array() -> Array

The component as an arrow batch.

Part of the rerun.ComponentBatchLike logging interface.

component_type `classmethod`

def component_type() -> str

Returns the name of the component.

Part of the rerun.ComponentBatchLike logging interface.

EnabledBatch

Bases: BoolBatch, ComponentBatchMixin

init

def __init__(
    data: T | None, strict: bool | None = None
) -> 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: `T \| None`
`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 `rerun.strict` global setting. TYPE: `bool \| None` DEFAULT: `None`

RETURNS	DESCRIPTION
`The Arrow array encapsulating the data.`

as_arrow_array

def as_arrow_array() -> Array

The component as an arrow batch.

Part of the rerun.ComponentBatchLike logging interface.

component_type

def component_type() -> str

Returns the name of the component.

Part of the rerun.ComponentBatchLike logging interface.

described

def described(
    descriptor: ComponentDescriptor,
) -> DescribedComponentBatch

Wraps the current ComponentBatchLike in a DescribedComponentBatch with the given descriptor.

partition

def partition(
    lengths: ArrayLike | None = None,
) -> ComponentColumn

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, `lengths` must sum to the total length of the component batch. If left unspecified, it will default to unit-length batches. TYPE: `ArrayLike \| None` DEFAULT: `None`

RETURNS	DESCRIPTION
`The partitioned component batch as a column.`

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 `class-attribute` `instance-attribute`

FirstPerson = 1

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 `class-attribute` `instance-attribute`

Orbital = 2

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.

str

def __str__() -> str

Returns the variant name.

auto `classmethod`

def auto(val: str | int | Eye3DKind) -> Eye3DKind

Best-effort converter, including a case-insensitive string matcher.

Eye3DKindBatch

Bases: BaseBatch[Eye3DKindArrayLike], ComponentBatchMixin

init

def __init__(
    data: T | None, strict: bool | None = None
) -> 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: `T \| None`
`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 `rerun.strict` global setting. TYPE: `bool \| None` DEFAULT: `None`

RETURNS	DESCRIPTION
`The Arrow array encapsulating the data.`

as_arrow_array

def as_arrow_array() -> Array

The component as an arrow batch.

Part of the rerun.ComponentBatchLike logging interface.

component_type

def component_type() -> str

Returns the name of the component.

Part of the rerun.ComponentBatchLike logging interface.

described

def described(
    descriptor: ComponentDescriptor,
) -> DescribedComponentBatch

Wraps the current ComponentBatchLike in a DescribedComponentBatch with the given descriptor.

partition

def partition(
    lengths: ArrayLike | None = None,
) -> ComponentColumn

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, `lengths` must sum to the total length of the component batch. If left unspecified, it will default to unit-length batches. TYPE: `ArrayLike \| None` DEFAULT: `None`

RETURNS	DESCRIPTION
`The partitioned component batch as a column.`

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.

init

def __init__(start: TimeIntLike, end: TimeIntLike) -> None

Create a new instance of the FilterByRange datatype.

PARAMETER	DESCRIPTION
`start`	Beginning of the time range. TYPE: `TimeIntLike`
`end`	End of the time range (inclusive). TYPE: `TimeIntLike`

arrow_type `classmethod`

def arrow_type() -> DataType

The pyarrow type of this batch.

Part of the rerun.ComponentBatchLike logging interface.

as_arrow_array

def as_arrow_array() -> Array

The component as an arrow batch.

Part of the rerun.ComponentBatchLike logging interface.

component_type `classmethod`

def component_type() -> str

Returns the name of the component.

Part of the rerun.ComponentBatchLike logging interface.

FilterByRangeBatch

Bases: FilterByRangeBatch, ComponentBatchMixin

init

def __init__(
    data: T | None, strict: bool | None = None
) -> 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: `T \| None`
`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 `rerun.strict` global setting. TYPE: `bool \| None` DEFAULT: `None`

RETURNS	DESCRIPTION
`The Arrow array encapsulating the data.`

as_arrow_array

def as_arrow_array() -> Array

The component as an arrow batch.

Part of the rerun.ComponentBatchLike logging interface.

component_type

def component_type() -> str

Returns the name of the component.

Part of the rerun.ComponentBatchLike logging interface.

described

def described(
    descriptor: ComponentDescriptor,
) -> DescribedComponentBatch

Wraps the current ComponentBatchLike in a DescribedComponentBatch with the given descriptor.

partition

def partition(
    lengths: ArrayLike | None = None,
) -> ComponentColumn

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, `lengths` must sum to the total length of the component batch. If left unspecified, it will default to unit-length batches. TYPE: `ArrayLike \| None` DEFAULT: `None`

RETURNS	DESCRIPTION
`The partitioned component batch as a column.`

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.

init

def __init__(
    active: BoolLike, column: ComponentColumnSelectorLike
) -> None

Create a new instance of the FilterIsNotNull datatype.

PARAMETER	DESCRIPTION
`active`	Whether the filter by event feature is active. TYPE: `BoolLike`
`column`	The column used when the filter by event feature is used. TYPE: `ComponentColumnSelectorLike`

arrow_type `classmethod`

def arrow_type() -> DataType

The pyarrow type of this batch.

Part of the rerun.ComponentBatchLike logging interface.

as_arrow_array

def as_arrow_array() -> Array

The component as an arrow batch.

Part of the rerun.ComponentBatchLike logging interface.

component_type `classmethod`

def component_type() -> str

Returns the name of the component.

Part of the rerun.ComponentBatchLike logging interface.

FilterIsNotNullBatch

Bases: FilterIsNotNullBatch, ComponentBatchMixin

init

def __init__(
    data: T | None, strict: bool | None = None
) -> 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: `T \| None`
`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 `rerun.strict` global setting. TYPE: `bool \| None` DEFAULT: `None`

RETURNS	DESCRIPTION
`The Arrow array encapsulating the data.`

as_arrow_array

def as_arrow_array() -> Array

The component as an arrow batch.

Part of the rerun.ComponentBatchLike logging interface.

component_type

def component_type() -> str

Returns the name of the component.

Part of the rerun.ComponentBatchLike logging interface.

described

def described(
    descriptor: ComponentDescriptor,
) -> DescribedComponentBatch

Wraps the current ComponentBatchLike in a DescribedComponentBatch with the given descriptor.

partition

def partition(
    lengths: ArrayLike | None = None,
) -> ComponentColumn

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, `lengths` must sum to the total length of the component batch. If left unspecified, it will default to unit-length batches. TYPE: `ArrayLike \| None` DEFAULT: `None`

RETURNS	DESCRIPTION
`The partitioned component batch as a column.`

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.

init

def __init__(value: Float64Like) -> None

Create a new instance of the Float64 datatype.

arrow_type `classmethod`

def arrow_type() -> DataType

The pyarrow type of this batch.

Part of the rerun.ComponentBatchLike logging interface.

as_arrow_array

def as_arrow_array() -> Array

The component as an arrow batch.

Part of the rerun.ComponentBatchLike logging interface.

component_type `classmethod`

def component_type() -> str

Returns the name of the component.

Part of the rerun.ComponentBatchLike logging interface.

ForceDistanceBatch

Bases: Float64Batch, ComponentBatchMixin

init

def __init__(
    data: T | None, strict: bool | None = None
) -> 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: `T \| None`
`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 `rerun.strict` global setting. TYPE: `bool \| None` DEFAULT: `None`

RETURNS	DESCRIPTION
`The Arrow array encapsulating the data.`

as_arrow_array

def as_arrow_array() -> Array

The component as an arrow batch.

Part of the rerun.ComponentBatchLike logging interface.

component_type

def component_type() -> str

Returns the name of the component.

Part of the rerun.ComponentBatchLike logging interface.

described

def described(
    descriptor: ComponentDescriptor,
) -> DescribedComponentBatch

Wraps the current ComponentBatchLike in a DescribedComponentBatch with the given descriptor.

partition

def partition(
    lengths: ArrayLike | None = None,
) -> ComponentColumn

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, `lengths` must sum to the total length of the component batch. If left unspecified, it will default to unit-length batches. TYPE: `ArrayLike \| None` DEFAULT: `None`

RETURNS	DESCRIPTION
`The partitioned component batch as a column.`

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.

init

def __init__(value: UInt64Like) -> None

Create a new instance of the UInt64 datatype.

arrow_type `classmethod`

def arrow_type() -> DataType

The pyarrow type of this batch.

Part of the rerun.ComponentBatchLike logging interface.

as_arrow_array

def as_arrow_array() -> Array

The component as an arrow batch.

Part of the rerun.ComponentBatchLike logging interface.

component_type `classmethod`

def component_type() -> str

Returns the name of the component.

Part of the rerun.ComponentBatchLike logging interface.

ForceIterationsBatch

Bases: UInt64Batch, ComponentBatchMixin

init

def __init__(
    data: T | None, strict: bool | None = None
) -> 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: `T \| None`
`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 `rerun.strict` global setting. TYPE: `bool \| None` DEFAULT: `None`

RETURNS	DESCRIPTION
`The Arrow array encapsulating the data.`

as_arrow_array

def as_arrow_array() -> Array

The component as an arrow batch.

Part of the rerun.ComponentBatchLike logging interface.

component_type

def component_type() -> str

Returns the name of the component.

Part of the rerun.ComponentBatchLike logging interface.

described

def described(
    descriptor: ComponentDescriptor,
) -> DescribedComponentBatch

Wraps the current ComponentBatchLike in a DescribedComponentBatch with the given descriptor.

partition

def partition(
    lengths: ArrayLike | None = None,
) -> ComponentColumn

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, `lengths` must sum to the total length of the component batch. If left unspecified, it will default to unit-length batches. TYPE: `ArrayLike \| None` DEFAULT: `None`

RETURNS	DESCRIPTION
`The partitioned component batch as a column.`

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.

init

def __init__(value: Float64Like) -> None

Create a new instance of the Float64 datatype.

arrow_type `classmethod`

def arrow_type() -> DataType

The pyarrow type of this batch.

Part of the rerun.ComponentBatchLike logging interface.

as_arrow_array

def as_arrow_array() -> Array

The component as an arrow batch.

Part of the rerun.ComponentBatchLike logging interface.

component_type `classmethod`

def component_type() -> str

Returns the name of the component.

Part of the rerun.ComponentBatchLike logging interface.

ForceStrengthBatch

Bases: Float64Batch, ComponentBatchMixin

init

def __init__(
    data: T | None, strict: bool | None = None
) -> 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: `T \| None`
`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 `rerun.strict` global setting. TYPE: `bool \| None` DEFAULT: `None`

RETURNS	DESCRIPTION
`The Arrow array encapsulating the data.`

as_arrow_array

def as_arrow_array() -> Array

The component as an arrow batch.

Part of the rerun.ComponentBatchLike logging interface.

component_type

def component_type() -> str

Returns the name of the component.

Part of the rerun.ComponentBatchLike logging interface.

described

def described(
    descriptor: ComponentDescriptor,
) -> DescribedComponentBatch

Wraps the current ComponentBatchLike in a DescribedComponentBatch with the given descriptor.

partition

def partition(
    lengths: ArrayLike | None = None,
) -> ComponentColumn

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, `lengths` must sum to the total length of the component batch. If left unspecified, it will default to unit-length batches. TYPE: `ArrayLike \| None` DEFAULT: `None`

RETURNS	DESCRIPTION
`The partitioned component batch as a column.`

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.

init

def __init__(value: Float64Like) -> None

Create a new instance of the Float64 datatype.

arrow_type `classmethod`

def arrow_type() -> DataType

The pyarrow type of this batch.

Part of the rerun.ComponentBatchLike logging interface.

as_arrow_array

def as_arrow_array() -> Array

The component as an arrow batch.

Part of the rerun.ComponentBatchLike logging interface.

component_type `classmethod`

def component_type() -> str

Returns the name of the component.

Part of the rerun.ComponentBatchLike logging interface.

FpsBatch

Bases: Float64Batch, ComponentBatchMixin

init

def __init__(
    data: T | None, strict: bool | None = None
) -> 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: `T \| None`
`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 `rerun.strict` global setting. TYPE: `bool \| None` DEFAULT: `None`

RETURNS	DESCRIPTION
`The Arrow array encapsulating the data.`

as_arrow_array

def as_arrow_array() -> Array

The component as an arrow batch.

Part of the rerun.ComponentBatchLike logging interface.

component_type

def component_type() -> str

Returns the name of the component.

Part of the rerun.ComponentBatchLike logging interface.

described

def described(
    descriptor: ComponentDescriptor,
) -> DescribedComponentBatch

Wraps the current ComponentBatchLike in a DescribedComponentBatch with the given descriptor.

partition

def partition(
    lengths: ArrayLike | None = None,
) -> ComponentColumn

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, `lengths` must sum to the total length of the component batch. If left unspecified, it will default to unit-length batches. TYPE: `ArrayLike \| None` DEFAULT: `None`

RETURNS	DESCRIPTION
`The partitioned component batch as a column.`

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.

init

def __init__(value: UInt32Like) -> None

Create a new instance of the UInt32 datatype.

arrow_type `classmethod`

def arrow_type() -> DataType

The pyarrow type of this batch.

Part of the rerun.ComponentBatchLike logging interface.

as_arrow_array

def as_arrow_array() -> Array

The component as an arrow batch.

Part of the rerun.ComponentBatchLike logging interface.

component_type `classmethod`

def component_type() -> str

Returns the name of the component.

Part of the rerun.ComponentBatchLike logging interface.

GridColumnsBatch

Bases: UInt32Batch, ComponentBatchMixin

init

def __init__(
    data: T | None, strict: bool | None = None
) -> 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: `T \| None`
`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 `rerun.strict` global setting. TYPE: `bool \| None` DEFAULT: `None`

RETURNS	DESCRIPTION
`The Arrow array encapsulating the data.`

as_arrow_array

def as_arrow_array() -> Array

The component as an arrow batch.

Part of the rerun.ComponentBatchLike logging interface.

component_type

def component_type() -> str

Returns the name of the component.

Part of the rerun.ComponentBatchLike logging interface.

described

def described(
    descriptor: ComponentDescriptor,
) -> DescribedComponentBatch

Wraps the current ComponentBatchLike in a DescribedComponentBatch with the given descriptor.

partition

def partition(
    lengths: ArrayLike | None = None,
) -> ComponentColumn

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, `lengths` must sum to the total length of the component batch. If left unspecified, it will default to unit-length batches. TYPE: `ArrayLike \| None` DEFAULT: `None`

RETURNS	DESCRIPTION
`The partitioned component batch as a column.`

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.

init

def __init__(value: Float32Like) -> None

Create a new instance of the Float32 datatype.

arrow_type `classmethod`

def arrow_type() -> DataType

The pyarrow type of this batch.

Part of the rerun.ComponentBatchLike logging interface.

as_arrow_array

def as_arrow_array() -> Array

The component as an arrow batch.

Part of the rerun.ComponentBatchLike logging interface.

component_type `classmethod`

def component_type() -> str

Returns the name of the component.

Part of the rerun.ComponentBatchLike logging interface.

GridSpacingBatch

Bases: Float32Batch, ComponentBatchMixin

init

def __init__(
    data: T | None, strict: bool | None = None
) -> 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: `T \| None`
`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 `rerun.strict` global setting. TYPE: `bool \| None` DEFAULT: `None`

RETURNS	DESCRIPTION
`The Arrow array encapsulating the data.`

as_arrow_array

def as_arrow_array() -> Array

The component as an arrow batch.

Part of the rerun.ComponentBatchLike logging interface.

component_type

def component_type() -> str

Returns the name of the component.

Part of the rerun.ComponentBatchLike logging interface.

described

def described(
    descriptor: ComponentDescriptor,
) -> DescribedComponentBatch

Wraps the current ComponentBatchLike in a DescribedComponentBatch with the given descriptor.

partition

def partition(
    lengths: ArrayLike | None = None,
) -> ComponentColumn

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, `lengths` must sum to the total length of the component batch. If left unspecified, it will default to unit-length batches. TYPE: `ArrayLike \| None` DEFAULT: `None`

RETURNS	DESCRIPTION
`The partitioned component batch as a column.`

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.

init

def __init__(path: EntityPathLike) -> None

Create a new instance of the EntityPath datatype.

arrow_type `classmethod`

def arrow_type() -> DataType

The pyarrow type of this batch.

Part of the rerun.ComponentBatchLike logging interface.

as_arrow_array

def as_arrow_array() -> Array

The component as an arrow batch.

Part of the rerun.ComponentBatchLike logging interface.

component_type `classmethod`

def component_type() -> str

Returns the name of the component.

Part of the rerun.ComponentBatchLike logging interface.

IncludedContentBatch

Bases: EntityPathBatch, ComponentBatchMixin

init

def __init__(
    data: T | None, strict: bool | None = None
) -> 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: `T \| None`
`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 `rerun.strict` global setting. TYPE: `bool \| None` DEFAULT: `None`

RETURNS	DESCRIPTION
`The Arrow array encapsulating the data.`

as_arrow_array

def as_arrow_array() -> Array

The component as an arrow batch.

Part of the rerun.ComponentBatchLike logging interface.

component_type

def component_type() -> str

Returns the name of the component.

Part of the rerun.ComponentBatchLike logging interface.

described

def described(
    descriptor: ComponentDescriptor,
) -> DescribedComponentBatch

Wraps the current ComponentBatchLike in a DescribedComponentBatch with the given descriptor.

partition

def partition(
    lengths: ArrayLike | None = None,
) -> ComponentColumn

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, `lengths` must sum to the total length of the component batch. If left unspecified, it will default to unit-length batches. TYPE: `ArrayLike \| None` DEFAULT: `None`

RETURNS	DESCRIPTION
`The partitioned component batch as a column.`

LinkAxis

Bases: Enum

Component: How should the horizontal/X/time axis be linked across multiple plots.

Independent `class-attribute` `instance-attribute`

Independent = 1

The axis is independent from all other plots.

LinkToGlobal `class-attribute` `instance-attribute`

LinkToGlobal = 2

Link to all other plots that also have this options set.

str

def __str__() -> str

Returns the variant name.

auto `classmethod`

def auto(val: str | int | LinkAxis) -> LinkAxis

Best-effort converter, including a case-insensitive string matcher.

LinkAxisBatch

Bases: BaseBatch[LinkAxisArrayLike], ComponentBatchMixin

init

def __init__(
    data: T | None, strict: bool | None = None
) -> 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: `T \| None`
`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 `rerun.strict` global setting. TYPE: `bool \| None` DEFAULT: `None`

RETURNS	DESCRIPTION
`The Arrow array encapsulating the data.`

as_arrow_array

def as_arrow_array() -> Array

The component as an arrow batch.

Part of the rerun.ComponentBatchLike logging interface.

component_type

def component_type() -> str

Returns the name of the component.

Part of the rerun.ComponentBatchLike logging interface.

described

def described(
    descriptor: ComponentDescriptor,
) -> DescribedComponentBatch

Wraps the current ComponentBatchLike in a DescribedComponentBatch with the given descriptor.

partition

def partition(
    lengths: ArrayLike | None = None,
) -> ComponentColumn

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, `lengths` must sum to the total length of the component batch. If left unspecified, it will default to unit-length batches. TYPE: `ArrayLike \| None` DEFAULT: `None`

RETURNS	DESCRIPTION
`The partitioned component batch as a column.`

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.

init

def __init__(value: BoolLike) -> None

Create a new instance of the Bool datatype.

arrow_type `classmethod`

def arrow_type() -> DataType

The pyarrow type of this batch.

Part of the rerun.ComponentBatchLike logging interface.

as_arrow_array

def as_arrow_array() -> Array

The component as an arrow batch.

Part of the rerun.ComponentBatchLike logging interface.

component_type `classmethod`

def component_type() -> str

Returns the name of the component.

Part of the rerun.ComponentBatchLike logging interface.

LockRangeDuringZoomBatch

Bases: BoolBatch, ComponentBatchMixin

init

def __init__(
    data: T | None, strict: bool | None = None
) -> 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: `T \| None`
`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 `rerun.strict` global setting. TYPE: `bool \| None` DEFAULT: `None`

RETURNS	DESCRIPTION
`The Arrow array encapsulating the data.`

as_arrow_array

def as_arrow_array() -> Array

The component as an arrow batch.

Part of the rerun.ComponentBatchLike logging interface.

component_type

def component_type() -> str

Returns the name of the component.

Part of the rerun.ComponentBatchLike logging interface.

described

def described(
    descriptor: ComponentDescriptor,
) -> DescribedComponentBatch

Wraps the current ComponentBatchLike in a DescribedComponentBatch with the given descriptor.

partition

def partition(
    lengths: ArrayLike | None = None,
) -> ComponentColumn

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, `lengths` must sum to the total length of the component batch. If left unspecified, it will default to unit-length batches. TYPE: `ArrayLike \| None` DEFAULT: `None`

RETURNS	DESCRIPTION
`The partitioned component batch as a column.`

LoopMode

Bases: Enum

Component: If playing, whether and how the playback time should loop.

All `class-attribute` `instance-attribute`

All = 3

We are looping the entire recording.

The loop selection is ignored.

Off `class-attribute` `instance-attribute`

Off = 1

Looping is off.

Selection `class-attribute` `instance-attribute`

Selection = 2

We are looping within the current loop selection.

str

def __str__() -> str

Returns the variant name.

auto `classmethod`

def auto(val: str | int | LoopMode) -> LoopMode

Best-effort converter, including a case-insensitive string matcher.

LoopModeBatch

Bases: BaseBatch[LoopModeArrayLike], ComponentBatchMixin

init

def __init__(
    data: T | None, strict: bool | None = None
) -> 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: `T \| None`
`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 `rerun.strict` global setting. TYPE: `bool \| None` DEFAULT: `None`

RETURNS	DESCRIPTION
`The Arrow array encapsulating the data.`

as_arrow_array

def as_arrow_array() -> Array

The component as an arrow batch.

Part of the rerun.ComponentBatchLike logging interface.

component_type

def component_type() -> str

Returns the name of the component.

Part of the rerun.ComponentBatchLike logging interface.

described

def described(
    descriptor: ComponentDescriptor,
) -> DescribedComponentBatch

Wraps the current ComponentBatchLike in a DescribedComponentBatch with the given descriptor.

partition

def partition(
    lengths: ArrayLike | None = None,
) -> ComponentColumn

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, `lengths` must sum to the total length of the component batch. If left unspecified, it will default to unit-length batches. TYPE: `ArrayLike \| None` DEFAULT: `None`

RETURNS	DESCRIPTION
`The partitioned component batch as a column.`

MapProvider

Bases: Enum

Component: Name of the map provider to be used in Map views.

MapboxDark `class-attribute` `instance-attribute`

MapboxDark = 3

Mapbox Dark is a dark-themed map designed by Mapbox.

MapboxLight `class-attribute` `instance-attribute`

MapboxLight = 5

Mapbox Light is a light-themed map designed by Mapbox.

MapboxSatellite `class-attribute` `instance-attribute`

MapboxSatellite = 4

Mapbox Satellite is a satellite map designed by Mapbox.

MapboxStreets `class-attribute` `instance-attribute`

MapboxStreets = 2

Mapbox Streets is a minimalistic map designed by Mapbox.

OpenStreetMap `class-attribute` `instance-attribute`

OpenStreetMap = 1

OpenStreetMap is the default map provider.

str

def __str__() -> str

Returns the variant name.

auto `classmethod`

def auto(val: str | int | MapProvider) -> MapProvider

Best-effort converter, including a case-insensitive string matcher.

MapProviderBatch

Bases: BaseBatch[MapProviderArrayLike], ComponentBatchMixin

init

def __init__(
    data: T | None, strict: bool | None = None
) -> 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: `T \| None`
`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 `rerun.strict` global setting. TYPE: `bool \| None` DEFAULT: `None`

RETURNS	DESCRIPTION
`The Arrow array encapsulating the data.`

as_arrow_array

def as_arrow_array() -> Array

The component as an arrow batch.

Part of the rerun.ComponentBatchLike logging interface.

component_type

def component_type() -> str

Returns the name of the component.

Part of the rerun.ComponentBatchLike logging interface.

described

def described(
    descriptor: ComponentDescriptor,
) -> DescribedComponentBatch

Wraps the current ComponentBatchLike in a DescribedComponentBatch with the given descriptor.

partition

def partition(
    lengths: ArrayLike | None = None,
) -> ComponentColumn

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, `lengths` must sum to the total length of the component batch. If left unspecified, it will default to unit-length batches. TYPE: `ArrayLike \| None` DEFAULT: `None`

RETURNS	DESCRIPTION
`The partitioned component batch as a column.`

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.

init

def __init__(value: Float32Like) -> None

Create a new instance of the Float32 datatype.

arrow_type `classmethod`

def arrow_type() -> DataType

The pyarrow type of this batch.

Part of the rerun.ComponentBatchLike logging interface.

as_arrow_array

def as_arrow_array() -> Array

The component as an arrow batch.

Part of the rerun.ComponentBatchLike logging interface.

component_type `classmethod`

def component_type() -> str

Returns the name of the component.

Part of the rerun.ComponentBatchLike logging interface.

NearClipPlaneBatch

Bases: Float32Batch, ComponentBatchMixin

init

def __init__(
    data: T | None, strict: bool | None = None
) -> 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: `T \| None`
`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 `rerun.strict` global setting. TYPE: `bool \| None` DEFAULT: `None`

RETURNS	DESCRIPTION
`The Arrow array encapsulating the data.`

as_arrow_array

def as_arrow_array() -> Array

The component as an arrow batch.

Part of the rerun.ComponentBatchLike logging interface.

component_type

def component_type() -> str

Returns the name of the component.

Part of the rerun.ComponentBatchLike logging interface.

described

def described(
    descriptor: ComponentDescriptor,
) -> DescribedComponentBatch

Wraps the current ComponentBatchLike in a DescribedComponentBatch with the given descriptor.

partition

def partition(
    lengths: ArrayLike | None = None,
) -> ComponentColumn

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, `lengths` must sum to the total length of the component batch. If left unspecified, it will default to unit-length batches. TYPE: `ArrayLike \| None` DEFAULT: `None`

RETURNS	DESCRIPTION
`The partitioned component batch as a column.`

PanelState

Bases: Enum

Component: Tri-state for panel controls.

Collapsed `class-attribute` `instance-attribute`

Collapsed = 2

Visible, but as small as possible on its shorter axis.

Expanded `class-attribute` `instance-attribute`

Expanded = 3

Fully expanded.

Hidden `class-attribute` `instance-attribute`

Hidden = 1

Completely hidden.

str

def __str__() -> str

Returns the variant name.

auto `classmethod`

def auto(val: str | int | PanelState) -> PanelState

Best-effort converter, including a case-insensitive string matcher.

PanelStateBatch

Bases: BaseBatch[PanelStateArrayLike], ComponentBatchMixin

init

def __init__(
    data: T | None, strict: bool | None = None
) -> 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: `T \| None`
`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 `rerun.strict` global setting. TYPE: `bool \| None` DEFAULT: `None`

RETURNS	DESCRIPTION
`The Arrow array encapsulating the data.`

as_arrow_array

def as_arrow_array() -> Array

The component as an arrow batch.

Part of the rerun.ComponentBatchLike logging interface.

component_type

def component_type() -> str

Returns the name of the component.

Part of the rerun.ComponentBatchLike logging interface.

described

def described(
    descriptor: ComponentDescriptor,
) -> DescribedComponentBatch

Wraps the current ComponentBatchLike in a DescribedComponentBatch with the given descriptor.

partition

def partition(
    lengths: ArrayLike | None = None,
) -> ComponentColumn

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, `lengths` must sum to the total length of the component batch. If left unspecified, it will default to unit-length batches. TYPE: `ArrayLike \| None` DEFAULT: `None`

RETURNS	DESCRIPTION
`The partitioned component batch as a column.`

PlayState

Bases: Enum

Component: The current play state.

Following `class-attribute` `instance-attribute`

Following = 3

Follow the latest available data.

Paused `class-attribute` `instance-attribute`

Paused = 1

Time doesn't move.

Playing `class-attribute` `instance-attribute`

Playing = 2

Time move steadily.

str

def __str__() -> str

Returns the variant name.

auto `classmethod`

def auto(val: str | int | PlayState) -> PlayState

Best-effort converter, including a case-insensitive string matcher.

PlayStateBatch

Bases: BaseBatch[PlayStateArrayLike], ComponentBatchMixin

init

def __init__(
    data: T | None, strict: bool | None = None
) -> 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: `T \| None`
`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 `rerun.strict` global setting. TYPE: `bool \| None` DEFAULT: `None`

RETURNS	DESCRIPTION
`The Arrow array encapsulating the data.`

as_arrow_array

def as_arrow_array() -> Array

The component as an arrow batch.

Part of the rerun.ComponentBatchLike logging interface.

component_type

def component_type() -> str

Returns the name of the component.

Part of the rerun.ComponentBatchLike logging interface.

described

def described(
    descriptor: ComponentDescriptor,
) -> DescribedComponentBatch

Wraps the current ComponentBatchLike in a DescribedComponentBatch with the given descriptor.

partition

def partition(
    lengths: ArrayLike | None = None,
) -> ComponentColumn

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, `lengths` must sum to the total length of the component batch. If left unspecified, it will default to unit-length batches. TYPE: `ArrayLike \| None` DEFAULT: `None`

RETURNS	DESCRIPTION
`The partitioned component batch as a column.`

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.

init

def __init__(value: Float64Like) -> None

Create a new instance of the Float64 datatype.

arrow_type `classmethod`

def arrow_type() -> DataType

The pyarrow type of this batch.

Part of the rerun.ComponentBatchLike logging interface.

as_arrow_array

def as_arrow_array() -> Array

The component as an arrow batch.

Part of the rerun.ComponentBatchLike logging interface.

component_type `classmethod`

def component_type() -> str

Returns the name of the component.

Part of the rerun.ComponentBatchLike logging interface.

PlaybackSpeedBatch

Bases: Float64Batch, ComponentBatchMixin

init

def __init__(
    data: T | None, strict: bool | None = None
) -> 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: `T \| None`
`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 `rerun.strict` global setting. TYPE: `bool \| None` DEFAULT: `None`

RETURNS	DESCRIPTION
`The Arrow array encapsulating the data.`

as_arrow_array

def as_arrow_array() -> Array

The component as an arrow batch.

Part of the rerun.ComponentBatchLike logging interface.

component_type

def component_type() -> str

Returns the name of the component.

Part of the rerun.ComponentBatchLike logging interface.

described

def described(
    descriptor: ComponentDescriptor,
) -> DescribedComponentBatch

Wraps the current ComponentBatchLike in a DescribedComponentBatch with the given descriptor.

partition

def partition(
    lengths: ArrayLike | None = None,
) -> ComponentColumn

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, `lengths` must sum to the total length of the component batch. If left unspecified, it will default to unit-length batches. TYPE: `ArrayLike \| None` DEFAULT: `None`

RETURNS	DESCRIPTION
`The partitioned component batch as a column.`

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.

init

def __init__(value: Utf8Like) -> None

Create a new instance of the Utf8 datatype.

arrow_type `classmethod`

def arrow_type() -> DataType

The pyarrow type of this batch.

Part of the rerun.ComponentBatchLike logging interface.

as_arrow_array

def as_arrow_array() -> Array

The component as an arrow batch.

Part of the rerun.ComponentBatchLike logging interface.

component_type `classmethod`

def component_type() -> str

Returns the name of the component.

Part of the rerun.ComponentBatchLike logging interface.

QueryExpressionBatch

Bases: Utf8Batch, ComponentBatchMixin

init

def __init__(
    data: T | None, strict: bool | None = None
) -> 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: `T \| None`
`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 `rerun.strict` global setting. TYPE: `bool \| None` DEFAULT: `None`

RETURNS	DESCRIPTION
`The Arrow array encapsulating the data.`

as_arrow_array

def as_arrow_array() -> Array

The component as an arrow batch.

Part of the rerun.ComponentBatchLike logging interface.

component_type

def component_type() -> str

Returns the name of the component.

Part of the rerun.ComponentBatchLike logging interface.

described

def described(
    descriptor: ComponentDescriptor,
) -> DescribedComponentBatch

Wraps the current ComponentBatchLike in a DescribedComponentBatch with the given descriptor.

partition

def partition(
    lengths: ArrayLike | None = None,
) -> ComponentColumn

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, `lengths` must sum to the total length of the component batch. If left unspecified, it will default to unit-length batches. TYPE: `ArrayLike \| None` DEFAULT: `None`

RETURNS	DESCRIPTION
`The partitioned component batch as a column.`

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.

init

def __init__(bytes: UuidLike) -> None

Create a new instance of the Uuid datatype.

PARAMETER	DESCRIPTION
`bytes`	The raw bytes representing the UUID. TYPE: `UuidLike`

arrow_type `classmethod`

def arrow_type() -> DataType

The pyarrow type of this batch.

Part of the rerun.ComponentBatchLike logging interface.

as_arrow_array

def as_arrow_array() -> Array

The component as an arrow batch.

Part of the rerun.ComponentBatchLike logging interface.

component_type `classmethod`

def component_type() -> str

Returns the name of the component.

Part of the rerun.ComponentBatchLike logging interface.

RootContainerBatch

Bases: UuidBatch, ComponentBatchMixin

init

def __init__(
    data: T | None, strict: bool | None = None
) -> 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: `T \| None`
`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 `rerun.strict` global setting. TYPE: `bool \| None` DEFAULT: `None`

RETURNS	DESCRIPTION
`The Arrow array encapsulating the data.`

as_arrow_array

def as_arrow_array() -> Array

The component as an arrow batch.

Part of the rerun.ComponentBatchLike logging interface.

component_type

def component_type() -> str

Returns the name of the component.

Part of the rerun.ComponentBatchLike logging interface.

described

def described(
    descriptor: ComponentDescriptor,
) -> DescribedComponentBatch

Wraps the current ComponentBatchLike in a DescribedComponentBatch with the given descriptor.

partition

def partition(
    lengths: ArrayLike | None = None,
) -> ComponentColumn

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, `lengths` must sum to the total length of the component batch. If left unspecified, it will default to unit-length batches. TYPE: `ArrayLike \| None` DEFAULT: `None`

RETURNS	DESCRIPTION
`The partitioned component batch as a column.`

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.

init

def __init__(value: Float32Like) -> None

Create a new instance of the Float32 datatype.

arrow_type `classmethod`

def arrow_type() -> DataType

The pyarrow type of this batch.

Part of the rerun.ComponentBatchLike logging interface.

as_arrow_array

def as_arrow_array() -> Array

The component as an arrow batch.

Part of the rerun.ComponentBatchLike logging interface.

component_type `classmethod`

def component_type() -> str

Returns the name of the component.

Part of the rerun.ComponentBatchLike logging interface.

RowShareBatch

Bases: Float32Batch, ComponentBatchMixin

init

def __init__(
    data: T | None, strict: bool | None = None
) -> 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: `T \| None`
`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 `rerun.strict` global setting. TYPE: `bool \| None` DEFAULT: `None`

RETURNS	DESCRIPTION
`The Arrow array encapsulating the data.`

as_arrow_array

def as_arrow_array() -> Array

The component as an arrow batch.

Part of the rerun.ComponentBatchLike logging interface.

component_type

def component_type() -> str

Returns the name of the component.

Part of the rerun.ComponentBatchLike logging interface.

described

def described(
    descriptor: ComponentDescriptor,
) -> DescribedComponentBatch

Wraps the current ComponentBatchLike in a DescribedComponentBatch with the given descriptor.

partition

def partition(
    lengths: ArrayLike | None = None,
) -> ComponentColumn

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, `lengths` must sum to the total length of the component batch. If left unspecified, it will default to unit-length batches. TYPE: `ArrayLike \| None` DEFAULT: `None`

RETURNS	DESCRIPTION
`The partitioned component batch as a column.`

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.

init

def __init__(
    columns: Sequence[
        ComponentColumnSelectorLike | Utf8Like
    ],
) -> None

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 `str` without any `:`, or an `Utf8`. Component columns can be specified using either a `str` in the form of `"/entity/path:Component"`, or a `ComponentColumnSelector`. TYPE: `Sequence[ComponentColumnSelectorLike \| Utf8Like]`

arrow_type `classmethod`

def arrow_type() -> DataType

The pyarrow type of this batch.

Part of the rerun.ComponentBatchLike logging interface.

as_arrow_array

def as_arrow_array() -> Array

The component as an arrow batch.

Part of the rerun.ComponentBatchLike logging interface.

component_type `classmethod`

def component_type() -> str

Returns the name of the component.

Part of the rerun.ComponentBatchLike logging interface.

SelectedColumnsBatch

Bases: SelectedColumnsBatch, ComponentBatchMixin

init

def __init__(
    data: T | None, strict: bool | None = None
) -> 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: `T \| None`
`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 `rerun.strict` global setting. TYPE: `bool \| None` DEFAULT: `None`

RETURNS	DESCRIPTION
`The Arrow array encapsulating the data.`

as_arrow_array

def as_arrow_array() -> Array

The component as an arrow batch.

Part of the rerun.ComponentBatchLike logging interface.

component_type

def component_type() -> str

Returns the name of the component.

Part of the rerun.ComponentBatchLike logging interface.

described

def described(
    descriptor: ComponentDescriptor,
) -> DescribedComponentBatch

Wraps the current ComponentBatchLike in a DescribedComponentBatch with the given descriptor.

partition

def partition(
    lengths: ArrayLike | None = None,
) -> ComponentColumn

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, `lengths` must sum to the total length of the component batch. If left unspecified, it will default to unit-length batches. TYPE: `ArrayLike \| None` DEFAULT: `None`

RETURNS	DESCRIPTION
`The partitioned component batch as a column.`

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.

init

def __init__(dimension: TensorDimensionIndexSliderLike) -> None

Create a new instance of the TensorDimensionIndexSlider datatype.

PARAMETER	DESCRIPTION
`dimension`	The dimension number. TYPE: `TensorDimensionIndexSliderLike`

arrow_type `classmethod`

def arrow_type() -> DataType

The pyarrow type of this batch.

Part of the rerun.ComponentBatchLike logging interface.

as_arrow_array

def as_arrow_array() -> Array

The component as an arrow batch.

Part of the rerun.ComponentBatchLike logging interface.

component_type `classmethod`

def component_type() -> str

Returns the name of the component.

Part of the rerun.ComponentBatchLike logging interface.

TensorDimensionIndexSliderBatch

Bases: TensorDimensionIndexSliderBatch, ComponentBatchMixin

init

def __init__(
    data: T | None, strict: bool | None = None
) -> 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: `T \| None`
`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 `rerun.strict` global setting. TYPE: `bool \| None` DEFAULT: `None`

RETURNS	DESCRIPTION
`The Arrow array encapsulating the data.`

as_arrow_array

def as_arrow_array() -> Array

The component as an arrow batch.

Part of the rerun.ComponentBatchLike logging interface.

component_type

def component_type() -> str

Returns the name of the component.

Part of the rerun.ComponentBatchLike logging interface.

described

def described(
    descriptor: ComponentDescriptor,
) -> DescribedComponentBatch

Wraps the current ComponentBatchLike in a DescribedComponentBatch with the given descriptor.

partition

def partition(
    lengths: ArrayLike | None = None,
) -> ComponentColumn

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, `lengths` must sum to the total length of the component batch. If left unspecified, it will default to unit-length batches. TYPE: `ArrayLike \| None` DEFAULT: `None`

RETURNS	DESCRIPTION
`The partitioned component batch as a column.`

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.

init

def __init__(
    kind: TextLogColumnKindLike, *, visible: BoolLike = True
) -> None

Create a new instance of the TextLogColumn datatype.

PARAMETER	DESCRIPTION
`kind`	What kind of column is this? TYPE: `TextLogColumnKindLike`
`visible`	Is this column visible? TYPE: `BoolLike` DEFAULT: `True`

arrow_type `classmethod`

def arrow_type() -> DataType

The pyarrow type of this batch.

Part of the rerun.ComponentBatchLike logging interface.

as_arrow_array

def as_arrow_array() -> Array

The component as an arrow batch.

Part of the rerun.ComponentBatchLike logging interface.

component_type `classmethod`

def component_type() -> str

Returns the name of the component.

Part of the rerun.ComponentBatchLike logging interface.

TextLogColumnBatch

Bases: TextLogColumnBatch, ComponentBatchMixin

init

def __init__(
    data: T | None, strict: bool | None = None
) -> 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: `T \| None`
`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 `rerun.strict` global setting. TYPE: `bool \| None` DEFAULT: `None`

RETURNS	DESCRIPTION
`The Arrow array encapsulating the data.`

as_arrow_array

def as_arrow_array() -> Array

The component as an arrow batch.

Part of the rerun.ComponentBatchLike logging interface.

component_type

def component_type() -> str

Returns the name of the component.

Part of the rerun.ComponentBatchLike logging interface.

described

def described(
    descriptor: ComponentDescriptor,
) -> DescribedComponentBatch

Wraps the current ComponentBatchLike in a DescribedComponentBatch with the given descriptor.

partition

def partition(
    lengths: ArrayLike | None = None,
) -> ComponentColumn

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, `lengths` must sum to the total length of the component batch. If left unspecified, it will default to unit-length batches. TYPE: `ArrayLike \| None` DEFAULT: `None`

RETURNS	DESCRIPTION
`The partitioned component batch as a column.`

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.

init

def __init__(*, seq: int) -> None

def __init__(*, seconds: float) -> None

def __init__(*, nanos: int) -> None

def __init__(
    *,
    seq: int | None = None,
    seconds: float | None = None,
    nanos: int | None = None,
) -> 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: `int \| None` DEFAULT: `None`
`seconds`	Time in seconds. Interpreted either as a duration or time since unix epoch (depending on timeline type). TYPE: `float \| None` DEFAULT: `None`
`nanos`	Time in nanoseconds. Interpreted either as a duration or time since unix epoch (depending on timeline type). TYPE: `int \| None` DEFAULT: `None`

arrow_type `classmethod`

def arrow_type() -> DataType

The pyarrow type of this batch.

Part of the rerun.ComponentBatchLike logging interface.

as_arrow_array

def as_arrow_array() -> Array

The component as an arrow batch.

Part of the rerun.ComponentBatchLike logging interface.

component_type `classmethod`

def component_type() -> str

Returns the name of the component.

Part of the rerun.ComponentBatchLike logging interface.

TimeIntBatch

Bases: TimeIntBatch, ComponentBatchMixin

init

def __init__(
    data: T | None, strict: bool | None = None
) -> 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: `T \| None`
`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 `rerun.strict` global setting. TYPE: `bool \| None` DEFAULT: `None`

RETURNS	DESCRIPTION
`The Arrow array encapsulating the data.`

as_arrow_array

def as_arrow_array() -> Array

The component as an arrow batch.

Part of the rerun.ComponentBatchLike logging interface.

component_type

def component_type() -> str

Returns the name of the component.

Part of the rerun.ComponentBatchLike logging interface.

described

def described(
    descriptor: ComponentDescriptor,
) -> DescribedComponentBatch

Wraps the current ComponentBatchLike in a DescribedComponentBatch with the given descriptor.

partition

def partition(
    lengths: ArrayLike | None = None,
) -> ComponentColumn

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, `lengths` must sum to the total length of the component batch. If left unspecified, it will default to unit-length batches. TYPE: `ArrayLike \| None` DEFAULT: `None`

RETURNS	DESCRIPTION
`The partitioned component batch as a column.`

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.

init

def __init__(
    start: TimeRangeBoundaryLike, end: TimeRangeBoundaryLike
) -> None

Create a new instance of the TimeRange datatype.

PARAMETER	DESCRIPTION
`start`	Low time boundary for sequence timeline. TYPE: `TimeRangeBoundaryLike`
`end`	High time boundary for sequence timeline. TYPE: `TimeRangeBoundaryLike`

arrow_type `classmethod`

def arrow_type() -> DataType

The pyarrow type of this batch.

Part of the rerun.ComponentBatchLike logging interface.

as_arrow_array

def as_arrow_array() -> Array

The component as an arrow batch.

Part of the rerun.ComponentBatchLike logging interface.

component_type `classmethod`

def component_type() -> str

Returns the name of the component.

Part of the rerun.ComponentBatchLike logging interface.

TimeRangeBatch

Bases: TimeRangeBatch, ComponentBatchMixin

init

def __init__(
    data: T | None, strict: bool | None = None
) -> 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: `T \| None`
`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 `rerun.strict` global setting. TYPE: `bool \| None` DEFAULT: `None`

RETURNS	DESCRIPTION
`The Arrow array encapsulating the data.`

as_arrow_array

def as_arrow_array() -> Array

The component as an arrow batch.

Part of the rerun.ComponentBatchLike logging interface.

component_type

def component_type() -> str

Returns the name of the component.

Part of the rerun.ComponentBatchLike logging interface.

described

def described(
    descriptor: ComponentDescriptor,
) -> DescribedComponentBatch

Wraps the current ComponentBatchLike in a DescribedComponentBatch with the given descriptor.

partition

def partition(
    lengths: ArrayLike | None = None,
) -> ComponentColumn

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, `lengths` must sum to the total length of the component batch. If left unspecified, it will default to unit-length batches. TYPE: `ArrayLike \| None` DEFAULT: `None`

RETURNS	DESCRIPTION
`The partitioned component batch as a column.`

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.

init

def __init__(
    timeline: Utf8Like, *, visible: BoolLike = True
) -> None

Create a new instance of the TextLogColumn datatype.

PARAMETER	DESCRIPTION
`timeline`	What timeline is this? TYPE: `Utf8Like`
`visible`	Is this column visible? TYPE: `BoolLike` DEFAULT: `True`

arrow_type `classmethod`

def arrow_type() -> DataType

The pyarrow type of this batch.

Part of the rerun.ComponentBatchLike logging interface.

as_arrow_array

def as_arrow_array() -> Array

The component as an arrow batch.

Part of the rerun.ComponentBatchLike logging interface.

component_type `classmethod`

def component_type() -> str

Returns the name of the component.

Part of the rerun.ComponentBatchLike logging interface.

TimelineColumnBatch

Bases: TimelineColumnBatch, ComponentBatchMixin

init

def __init__(
    data: T | None, strict: bool | None = None
) -> 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: `T \| None`
`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 `rerun.strict` global setting. TYPE: `bool \| None` DEFAULT: `None`

RETURNS	DESCRIPTION
`The Arrow array encapsulating the data.`

as_arrow_array

def as_arrow_array() -> Array

The component as an arrow batch.

Part of the rerun.ComponentBatchLike logging interface.

component_type

def component_type() -> str

Returns the name of the component.

Part of the rerun.ComponentBatchLike logging interface.

described

def described(
    descriptor: ComponentDescriptor,
) -> DescribedComponentBatch

Wraps the current ComponentBatchLike in a DescribedComponentBatch with the given descriptor.

partition

def partition(
    lengths: ArrayLike | None = None,
) -> ComponentColumn

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, `lengths` must sum to the total length of the component batch. If left unspecified, it will default to unit-length batches. TYPE: `ArrayLike \| None` DEFAULT: `None`

RETURNS	DESCRIPTION
`The partitioned component batch as a column.`

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.

init

def __init__(value: Utf8Like) -> None

Create a new instance of the Utf8 datatype.

arrow_type `classmethod`

def arrow_type() -> DataType

The pyarrow type of this batch.

Part of the rerun.ComponentBatchLike logging interface.

as_arrow_array

def as_arrow_array() -> Array

The component as an arrow batch.

Part of the rerun.ComponentBatchLike logging interface.

component_type `classmethod`

def component_type() -> str

Returns the name of the component.

Part of the rerun.ComponentBatchLike logging interface.

TimelineNameBatch

Bases: Utf8Batch, ComponentBatchMixin

init

def __init__(
    data: T | None, strict: bool | None = None
) -> 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: `T \| None`
`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 `rerun.strict` global setting. TYPE: `bool \| None` DEFAULT: `None`

RETURNS	DESCRIPTION
`The Arrow array encapsulating the data.`

as_arrow_array

def as_arrow_array() -> Array

The component as an arrow batch.

Part of the rerun.ComponentBatchLike logging interface.

component_type

def component_type() -> str

Returns the name of the component.

Part of the rerun.ComponentBatchLike logging interface.

described

def described(
    descriptor: ComponentDescriptor,
) -> DescribedComponentBatch

Wraps the current ComponentBatchLike in a DescribedComponentBatch with the given descriptor.

partition

def partition(
    lengths: ArrayLike | None = None,
) -> ComponentColumn

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, `lengths` must sum to the total length of the component batch. If left unspecified, it will default to unit-length batches. TYPE: `ArrayLike \| None` DEFAULT: `None`

RETURNS	DESCRIPTION
`The partitioned component batch as a column.`

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.

init

def __init__(value: Utf8Like) -> None

Create a new instance of the Utf8 datatype.

arrow_type `classmethod`

def arrow_type() -> DataType

The pyarrow type of this batch.

Part of the rerun.ComponentBatchLike logging interface.

as_arrow_array

def as_arrow_array() -> Array

The component as an arrow batch.

Part of the rerun.ComponentBatchLike logging interface.

component_type `classmethod`

def component_type() -> str

Returns the name of the component.

Part of the rerun.ComponentBatchLike logging interface.

ViewClassBatch

Bases: Utf8Batch, ComponentBatchMixin

init

def __init__(
    data: T | None, strict: bool | None = None
) -> 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: `T \| None`
`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 `rerun.strict` global setting. TYPE: `bool \| None` DEFAULT: `None`

RETURNS	DESCRIPTION
`The Arrow array encapsulating the data.`

as_arrow_array

def as_arrow_array() -> Array

The component as an arrow batch.

Part of the rerun.ComponentBatchLike logging interface.

component_type

def component_type() -> str

Returns the name of the component.

Part of the rerun.ComponentBatchLike logging interface.

described

def described(
    descriptor: ComponentDescriptor,
) -> DescribedComponentBatch

Wraps the current ComponentBatchLike in a DescribedComponentBatch with the given descriptor.

partition

def partition(
    lengths: ArrayLike | None = None,
) -> ComponentColumn

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, `lengths` must sum to the total length of the component batch. If left unspecified, it will default to unit-length batches. TYPE: `ArrayLike \| None` DEFAULT: `None`

RETURNS	DESCRIPTION
`The partitioned component batch as a column.`

ViewFit

Bases: Enum

Component: Determines whether an image or texture should be scaled to fit the viewport.

Fill `class-attribute` `instance-attribute`

Fill = 2

Scale the image for the largest possible fit in the view's container.

FillKeepAspectRatio `class-attribute` `instance-attribute`

FillKeepAspectRatio = 3

Scale the image for the largest possible fit in the view's container, but keep the original aspect ratio.

Original `class-attribute` `instance-attribute`

Original = 1

No scaling, pixel size will match the image's width/height dimensions in pixels.

str

def __str__() -> str

Returns the variant name.

auto `classmethod`

def auto(val: str | int | ViewFit) -> ViewFit

Best-effort converter, including a case-insensitive string matcher.

ViewFitBatch

Bases: BaseBatch[ViewFitArrayLike], ComponentBatchMixin

init

def __init__(
    data: T | None, strict: bool | None = None
) -> 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: `T \| None`
`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 `rerun.strict` global setting. TYPE: `bool \| None` DEFAULT: `None`

RETURNS	DESCRIPTION
`The Arrow array encapsulating the data.`

as_arrow_array

def as_arrow_array() -> Array

The component as an arrow batch.

Part of the rerun.ComponentBatchLike logging interface.

component_type

def component_type() -> str

Returns the name of the component.

Part of the rerun.ComponentBatchLike logging interface.

described

def described(
    descriptor: ComponentDescriptor,
) -> DescribedComponentBatch

Wraps the current ComponentBatchLike in a DescribedComponentBatch with the given descriptor.

partition

def partition(
    lengths: ArrayLike | None = None,
) -> ComponentColumn

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, `lengths` must sum to the total length of the component batch. If left unspecified, it will default to unit-length batches. TYPE: `ArrayLike \| None` DEFAULT: `None`

RETURNS	DESCRIPTION
`The partitioned component batch as a column.`

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.

init

def __init__(bytes: UuidLike) -> None

Create a new instance of the Uuid datatype.

PARAMETER	DESCRIPTION
`bytes`	The raw bytes representing the UUID. TYPE: `UuidLike`

arrow_type `classmethod`

def arrow_type() -> DataType

The pyarrow type of this batch.

Part of the rerun.ComponentBatchLike logging interface.

as_arrow_array

def as_arrow_array() -> Array

The component as an arrow batch.

Part of the rerun.ComponentBatchLike logging interface.

component_type `classmethod`

def component_type() -> str

Returns the name of the component.

Part of the rerun.ComponentBatchLike logging interface.

ViewMaximizedBatch

Bases: UuidBatch, ComponentBatchMixin

init

def __init__(
    data: T | None, strict: bool | None = None
) -> 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: `T \| None`
`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 `rerun.strict` global setting. TYPE: `bool \| None` DEFAULT: `None`

RETURNS	DESCRIPTION
`The Arrow array encapsulating the data.`

as_arrow_array

def as_arrow_array() -> Array

The component as an arrow batch.

Part of the rerun.ComponentBatchLike logging interface.

component_type

def component_type() -> str

Returns the name of the component.

Part of the rerun.ComponentBatchLike logging interface.

described

def described(
    descriptor: ComponentDescriptor,
) -> DescribedComponentBatch

Wraps the current ComponentBatchLike in a DescribedComponentBatch with the given descriptor.

partition

def partition(
    lengths: ArrayLike | None = None,
) -> ComponentColumn

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, `lengths` must sum to the total length of the component batch. If left unspecified, it will default to unit-length batches. TYPE: `ArrayLike \| None` DEFAULT: `None`

RETURNS	DESCRIPTION
`The partitioned component batch as a column.`

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.

init

def __init__(path: EntityPathLike) -> None

Create a new instance of the EntityPath datatype.

arrow_type `classmethod`

def arrow_type() -> DataType

The pyarrow type of this batch.

Part of the rerun.ComponentBatchLike logging interface.

as_arrow_array

def as_arrow_array() -> Array

The component as an arrow batch.

Part of the rerun.ComponentBatchLike logging interface.

component_type `classmethod`

def component_type() -> str

Returns the name of the component.

Part of the rerun.ComponentBatchLike logging interface.

ViewOriginBatch

Bases: EntityPathBatch, ComponentBatchMixin

init

def __init__(
    data: T | None, strict: bool | None = None
) -> 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: `T \| None`
`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 `rerun.strict` global setting. TYPE: `bool \| None` DEFAULT: `None`

RETURNS	DESCRIPTION
`The Arrow array encapsulating the data.`

as_arrow_array

def as_arrow_array() -> Array

The component as an arrow batch.

Part of the rerun.ComponentBatchLike logging interface.

component_type

def component_type() -> str

Returns the name of the component.

Part of the rerun.ComponentBatchLike logging interface.

described

def described(
    descriptor: ComponentDescriptor,
) -> DescribedComponentBatch

Wraps the current ComponentBatchLike in a DescribedComponentBatch with the given descriptor.

partition

def partition(
    lengths: ArrayLike | None = None,
) -> ComponentColumn

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, `lengths` must sum to the total length of the component batch. If left unspecified, it will default to unit-length batches. TYPE: `ArrayLike \| None` DEFAULT: `None`

RETURNS	DESCRIPTION
`The partitioned component batch as a column.`

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.

init

def __init__(value: UInt64Like) -> None

Create a new instance of the UInt64 datatype.

arrow_type `classmethod`

def arrow_type() -> DataType

The pyarrow type of this batch.

Part of the rerun.ComponentBatchLike logging interface.

as_arrow_array

def as_arrow_array() -> Array

The component as an arrow batch.

Part of the rerun.ComponentBatchLike logging interface.

component_type `classmethod`

def component_type() -> str

Returns the name of the component.

Part of the rerun.ComponentBatchLike logging interface.

ViewerRecommendationHashBatch

Bases: UInt64Batch, ComponentBatchMixin

init

def __init__(
    data: T | None, strict: bool | None = None
) -> 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: `T \| None`
`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 `rerun.strict` global setting. TYPE: `bool \| None` DEFAULT: `None`

RETURNS	DESCRIPTION
`The Arrow array encapsulating the data.`

as_arrow_array

def as_arrow_array() -> Array

The component as an arrow batch.

Part of the rerun.ComponentBatchLike logging interface.

component_type

def component_type() -> str

Returns the name of the component.

Part of the rerun.ComponentBatchLike logging interface.

described

def described(
    descriptor: ComponentDescriptor,
) -> DescribedComponentBatch

Wraps the current ComponentBatchLike in a DescribedComponentBatch with the given descriptor.

partition

def partition(
    lengths: ArrayLike | None = None,
) -> ComponentColumn

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, `lengths` must sum to the total length of the component batch. If left unspecified, it will default to unit-length batches. TYPE: `ArrayLike \| None` DEFAULT: `None`

RETURNS	DESCRIPTION
`The partitioned component batch as a column.`

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.

init

def __init__(
    timeline: Utf8Like,
    range: TimeRangeLike | None = None,
    *,
    start: TimeRangeBoundary | None = None,
    end: TimeRangeBoundary | None = None,
) -> None

Create a new instance of the VisibleTimeRange datatype.

PARAMETER	DESCRIPTION
`timeline`	Name of the timeline this applies to. TYPE: `Utf8Like`
`range`	Time range to use for this timeline. TYPE: `TimeRangeLike \| None` DEFAULT: `None`
`start`	Low time boundary for sequence timeline. Specify this instead of `range`. TYPE: `TimeRangeBoundary \| None` DEFAULT: `None`
`end`	High time boundary for sequence timeline. Specify this instead of `range`. TYPE: `TimeRangeBoundary \| None` DEFAULT: `None`

arrow_type `classmethod`

def arrow_type() -> DataType

The pyarrow type of this batch.

Part of the rerun.ComponentBatchLike logging interface.

as_arrow_array

def as_arrow_array() -> Array

The component as an arrow batch.

Part of the rerun.ComponentBatchLike logging interface.

component_type `classmethod`

def component_type() -> str

Returns the name of the component.

Part of the rerun.ComponentBatchLike logging interface.

VisibleTimeRangeBatch

Bases: VisibleTimeRangeBatch, ComponentBatchMixin

init

def __init__(
    data: T | None, strict: bool | None = None
) -> 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: `T \| None`
`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 `rerun.strict` global setting. TYPE: `bool \| None` DEFAULT: `None`

RETURNS	DESCRIPTION
`The Arrow array encapsulating the data.`

as_arrow_array

def as_arrow_array() -> Array

The component as an arrow batch.

Part of the rerun.ComponentBatchLike logging interface.

component_type

def component_type() -> str

Returns the name of the component.

Part of the rerun.ComponentBatchLike logging interface.

described

def described(
    descriptor: ComponentDescriptor,
) -> DescribedComponentBatch

Wraps the current ComponentBatchLike in a DescribedComponentBatch with the given descriptor.

partition

def partition(
    lengths: ArrayLike | None = None,
) -> ComponentColumn

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, `lengths` must sum to the total length of the component batch. If left unspecified, it will default to unit-length batches. TYPE: `ArrayLike \| None` DEFAULT: `None`

RETURNS	DESCRIPTION
`The partitioned component batch as a column.`

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.

init

def __init__(
    *, x_range: Range1DLike, y_range: Range1DLike
) -> None

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: `Range1DLike`
`y_range`	The minimum visible range of the Y-axis (usually left and right bounds). TYPE: `Range1DLike`

arrow_type `classmethod`

def arrow_type() -> DataType

The pyarrow type of this batch.

Part of the rerun.ComponentBatchLike logging interface.

as_arrow_array

def as_arrow_array() -> Array

The component as an arrow batch.

Part of the rerun.ComponentBatchLike logging interface.

component_type `classmethod`

def component_type() -> str

Returns the name of the component.

Part of the rerun.ComponentBatchLike logging interface.

VisualBounds2DBatch

Bases: Range2DBatch, ComponentBatchMixin

init

def __init__(
    data: T | None, strict: bool | None = None
) -> 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: `T \| None`
`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 `rerun.strict` global setting. TYPE: `bool \| None` DEFAULT: `None`

RETURNS	DESCRIPTION
`The Arrow array encapsulating the data.`

as_arrow_array

def as_arrow_array() -> Array

The component as an arrow batch.

Part of the rerun.ComponentBatchLike logging interface.

component_type

def component_type() -> str

Returns the name of the component.

Part of the rerun.ComponentBatchLike logging interface.

described

def described(
    descriptor: ComponentDescriptor,
) -> DescribedComponentBatch

Wraps the current ComponentBatchLike in a DescribedComponentBatch with the given descriptor.

partition

def partition(
    lengths: ArrayLike | None = None,
) -> ComponentColumn

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, `lengths` must sum to the total length of the component batch. If left unspecified, it will default to unit-length batches. TYPE: `ArrayLike \| None` DEFAULT: `None`

RETURNS	DESCRIPTION
`The partitioned component batch as a column.`

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.

init

def __init__(
    target: Utf8Like,
    source_kind: ComponentSourceKindLike,
    *,
    source_component: str | None = None,
    selector: str | None = None,
) -> 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: `Utf8Like`
`source_kind`	What kind of source to pick. TYPE: `ComponentSourceKindLike`
`source_component`	Component selector for mapping. Defaults to `target` if not specified. TYPE: `str \| None` DEFAULT: `None`
`selector`	Optional selector string using jq-like syntax to pick a specific field on `source_component`. Example: ".x" picks a field called "x" from the `source_component` if present. Defaults to empty string if not specified. TYPE: `str \| None` DEFAULT: `None`

arrow_type `classmethod`

def arrow_type() -> DataType

The pyarrow type of this batch.

Part of the rerun.ComponentBatchLike logging interface.

as_arrow_array

def as_arrow_array() -> Array

The component as an arrow batch.

Part of the rerun.ComponentBatchLike logging interface.

component_type `classmethod`

def component_type() -> str

Returns the name of the component.

Part of the rerun.ComponentBatchLike logging interface.

VisualizerComponentMappingBatch

Bases: VisualizerComponentMappingBatch, ComponentBatchMixin

init

def __init__(
    data: T | None, strict: bool | None = None
) -> 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: `T \| None`
`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 `rerun.strict` global setting. TYPE: `bool \| None` DEFAULT: `None`

RETURNS	DESCRIPTION
`The Arrow array encapsulating the data.`

as_arrow_array

def as_arrow_array() -> Array

The component as an arrow batch.

Part of the rerun.ComponentBatchLike logging interface.

component_type

def component_type() -> str

Returns the name of the component.

Part of the rerun.ComponentBatchLike logging interface.

described

def described(
    descriptor: ComponentDescriptor,
) -> DescribedComponentBatch

Wraps the current ComponentBatchLike in a DescribedComponentBatch with the given descriptor.

partition

def partition(
    lengths: ArrayLike | None = None,
) -> ComponentColumn

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, `lengths` must sum to the total length of the component batch. If left unspecified, it will default to unit-length batches. TYPE: `ArrayLike \| None` DEFAULT: `None`

RETURNS	DESCRIPTION
`The partitioned component batch as a column.`

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.

init

def __init__(bytes: UuidLike) -> None

Create a new instance of the Uuid datatype.

PARAMETER	DESCRIPTION
`bytes`	The raw bytes representing the UUID. TYPE: `UuidLike`

arrow_type `classmethod`

def arrow_type() -> DataType

The pyarrow type of this batch.

Part of the rerun.ComponentBatchLike logging interface.

as_arrow_array

def as_arrow_array() -> Array

The component as an arrow batch.

Part of the rerun.ComponentBatchLike logging interface.

component_type `classmethod`

def component_type() -> str

Returns the name of the component.

Part of the rerun.ComponentBatchLike logging interface.

VisualizerInstructionIdBatch

Bases: UuidBatch, ComponentBatchMixin

init

def __init__(
    data: T | None, strict: bool | None = None
) -> 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: `T \| None`
`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 `rerun.strict` global setting. TYPE: `bool \| None` DEFAULT: `None`

RETURNS	DESCRIPTION
`The Arrow array encapsulating the data.`

as_arrow_array

def as_arrow_array() -> Array

The component as an arrow batch.

Part of the rerun.ComponentBatchLike logging interface.

component_type

def component_type() -> str

Returns the name of the component.

Part of the rerun.ComponentBatchLike logging interface.

described

def described(
    descriptor: ComponentDescriptor,
) -> DescribedComponentBatch

Wraps the current ComponentBatchLike in a DescribedComponentBatch with the given descriptor.

partition

def partition(
    lengths: ArrayLike | None = None,
) -> ComponentColumn

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, `lengths` must sum to the total length of the component batch. If left unspecified, it will default to unit-length batches. TYPE: `ArrayLike \| None` DEFAULT: `None`

RETURNS	DESCRIPTION
`The partitioned component batch as a column.`

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.

init

def __init__(value: Utf8Like) -> None

Create a new instance of the Utf8 datatype.

arrow_type `classmethod`

def arrow_type() -> DataType

The pyarrow type of this batch.

Part of the rerun.ComponentBatchLike logging interface.

as_arrow_array

def as_arrow_array() -> Array

The component as an arrow batch.

Part of the rerun.ComponentBatchLike logging interface.

component_type `classmethod`

def component_type() -> str

Returns the name of the component.

Part of the rerun.ComponentBatchLike logging interface.

VisualizerTypeBatch

Bases: Utf8Batch, ComponentBatchMixin

init

def __init__(
    data: T | None, strict: bool | None = None
) -> 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: `T \| None`
`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 `rerun.strict` global setting. TYPE: `bool \| None` DEFAULT: `None`

RETURNS	DESCRIPTION
`The Arrow array encapsulating the data.`

as_arrow_array

def as_arrow_array() -> Array

The component as an arrow batch.

Part of the rerun.ComponentBatchLike logging interface.

component_type

def component_type() -> str

Returns the name of the component.

Part of the rerun.ComponentBatchLike logging interface.

described

def described(
    descriptor: ComponentDescriptor,
) -> DescribedComponentBatch

Wraps the current ComponentBatchLike in a DescribedComponentBatch with the given descriptor.

partition

def partition(
    lengths: ArrayLike | None = None,
) -> ComponentColumn

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, `lengths` must sum to the total length of the component batch. If left unspecified, it will default to unit-length batches. TYPE: `ArrayLike \| None` DEFAULT: `None`

RETURNS	DESCRIPTION
`The partitioned component batch as a column.`

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.

init

def __init__(value: Float64Like) -> None

Create a new instance of the Float64 datatype.

arrow_type `classmethod`

def arrow_type() -> DataType

The pyarrow type of this batch.

Part of the rerun.ComponentBatchLike logging interface.

as_arrow_array

def as_arrow_array() -> Array

The component as an arrow batch.

Part of the rerun.ComponentBatchLike logging interface.

component_type `classmethod`

def component_type() -> str

Returns the name of the component.

Part of the rerun.ComponentBatchLike logging interface.

ZoomLevelBatch

Bases: Float64Batch, ComponentBatchMixin

init

def __init__(
    data: T | None, strict: bool | None = None
) -> 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: `T \| None`
`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 `rerun.strict` global setting. TYPE: `bool \| None` DEFAULT: `None`

RETURNS	DESCRIPTION
`The Arrow array encapsulating the data.`

as_arrow_array

def as_arrow_array() -> Array

The component as an arrow batch.

Part of the rerun.ComponentBatchLike logging interface.

component_type

def component_type() -> str

Returns the name of the component.

Part of the rerun.ComponentBatchLike logging interface.

described

def described(
    descriptor: ComponentDescriptor,
) -> DescribedComponentBatch

Wraps the current ComponentBatchLike in a DescribedComponentBatch with the given descriptor.

partition

def partition(
    lengths: ArrayLike | None = None,
) -> ComponentColumn

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, `lengths` must sum to the total length of the component batch. If left unspecified, it will default to unit-length batches. TYPE: `ArrayLike \| None` DEFAULT: `None`

RETURNS	DESCRIPTION
`The partitioned component batch as a column.`

Components

rerun.blueprint.components

BackgroundKindArrayLike module-attribute

BackgroundKindLike module-attribute

ColumnOrderArrayLike module-attribute

ColumnOrderLike module-attribute

ContainerKindArrayLike module-attribute

ContainerKindLike module-attribute

Corner2DArrayLike module-attribute

Corner2DLike module-attribute

Eye3DKindArrayLike module-attribute

Eye3DKindLike module-attribute

LinkAxisArrayLike module-attribute

LinkAxisLike module-attribute

LoopModeArrayLike module-attribute

LoopModeLike module-attribute

MapProviderArrayLike module-attribute

MapProviderLike module-attribute

PanelStateArrayLike module-attribute

PanelStateLike module-attribute

PlayStateArrayLike module-attribute

PlayStateLike module-attribute

ViewFitArrayLike module-attribute

ViewFitLike module-attribute

AbsoluteTimeRange

__init__

arrow_type classmethod

as_arrow_array

component_type classmethod

AbsoluteTimeRangeBatch

__init__

as_arrow_array

component_type

described

partition

ActiveTab

__init__

arrow_type classmethod

as_arrow_array

component_type classmethod

ActiveTabBatch

__init__

as_arrow_array

component_type

described

partition

AngularSpeed

__init__

arrow_type classmethod

as_arrow_array

component_type classmethod

AngularSpeedBatch

__init__

as_arrow_array

component_type

described

partition

ApplyLatestAt

__init__

arrow_type classmethod

as_arrow_array

component_type classmethod

ApplyLatestAtBatch

__init__

as_arrow_array

component_type

described

partition

AutoLayout

__init__

arrow_type classmethod

as_arrow_array

component_type classmethod

AutoLayoutBatch

__init__

as_arrow_array

component_type

described

partition

AutoScroll

BackgroundKindArrayLike `module-attribute`

BackgroundKindLike `module-attribute`

ColumnOrderArrayLike `module-attribute`

ColumnOrderLike `module-attribute`

ContainerKindArrayLike `module-attribute`

ContainerKindLike `module-attribute`

Corner2DArrayLike `module-attribute`

Corner2DLike `module-attribute`

Eye3DKindArrayLike `module-attribute`

Eye3DKindLike `module-attribute`

LinkAxisArrayLike `module-attribute`

LinkAxisLike `module-attribute`

LoopModeArrayLike `module-attribute`

LoopModeLike `module-attribute`

MapProviderArrayLike `module-attribute`

MapProviderLike `module-attribute`

PanelStateArrayLike `module-attribute`

PanelStateLike `module-attribute`

PlayStateArrayLike `module-attribute`

PlayStateLike `module-attribute`

ViewFitArrayLike `module-attribute`

ViewFitLike `module-attribute`

init

arrow_type `classmethod`

component_type `classmethod`

init

init

arrow_type `classmethod`

component_type `classmethod`

init

init

arrow_type `classmethod`

component_type `classmethod`

init

init

arrow_type `classmethod`

component_type `classmethod`

init

init

arrow_type `classmethod`

component_type `classmethod`

init

init

arrow_type `classmethod`

component_type `classmethod`

init

init

arrow_type `classmethod`

component_type `classmethod`

init

GradientBright `class-attribute` `instance-attribute`

GradientDark `class-attribute` `instance-attribute`

SolidColor `class-attribute` `instance-attribute`

str

auto `classmethod`

init

init

arrow_type `classmethod`

component_type `classmethod`

init

init

arrow_type `classmethod`

component_type `classmethod`

init

init

arrow_type `classmethod`

component_type `classmethod`

init

init

arrow_type `classmethod`