Components

rerun.components

AggregationPolicyArrayLike module-attribute

AggregationPolicyArrayLike = (
    AggregationPolicy
    | Literal[
        "Average",
        "Max",
        "Min",
        "MinMax",
        "MinMaxAverage",
        "Off",
        "average",
        "max",
        "min",
        "minmax",
        "minmaxaverage",
        "off",
    ]
    | int
    | Sequence[AggregationPolicyLike]
)

A type alias for any AggregationPolicy-like array object.

AggregationPolicyLike module-attribute

AggregationPolicyLike = (
    AggregationPolicy
    | Literal[
        "Average",
        "Max",
        "Min",
        "MinMax",
        "MinMaxAverage",
        "Off",
        "average",
        "max",
        "min",
        "minmax",
        "minmaxaverage",
        "off",
    ]
    | int
)

A type alias for any AggregationPolicy-like object.

AnnotationContextArrayLike module-attribute

AnnotationContextArrayLike = (
    AnnotationContext | Sequence[AnnotationContextLike]
)

A type alias for any AnnotationContext-like array object.

AnnotationContextLike module-attribute

AnnotationContextLike = (
    AnnotationContext
    | ClassDescriptionArrayLike
    | Sequence[ClassDescriptionMapElemLike]
)

A type alias for any AnnotationContext-like object.

ChannelMessageCountsArrayLike module-attribute

ChannelMessageCountsArrayLike = (
    ChannelMessageCounts
    | Sequence[ChannelMessageCountsLike]
    | dict[int, int]
    | Sequence[dict[int, int]]
)

A type alias for any ChannelMessageCounts-like array object.

ChannelMessageCountsLike module-attribute

ChannelMessageCountsLike = (
    ChannelMessageCounts | dict[int, int]
)

A type alias for any ChannelMessageCounts-like object.

ColormapArrayLike module-attribute

ColormapArrayLike = (
    Colormap
    | Literal[
        "CyanToYellow",
        "Grayscale",
        "Inferno",
        "Magma",
        "Plasma",
        "RvizCostmap",
        "RvizMap",
        "Spectral",
        "Turbo",
        "Twilight",
        "Viridis",
        "cyantoyellow",
        "grayscale",
        "inferno",
        "magma",
        "plasma",
        "rvizcostmap",
        "rvizmap",
        "spectral",
        "turbo",
        "twilight",
        "viridis",
    ]
    | int
    | Sequence[ColormapLike]
)

A type alias for any Colormap-like array object.

ColormapLike module-attribute

ColormapLike = (
    Colormap
    | Literal[
        "CyanToYellow",
        "Grayscale",
        "Inferno",
        "Magma",
        "Plasma",
        "RvizCostmap",
        "RvizMap",
        "Spectral",
        "Turbo",
        "Twilight",
        "Viridis",
        "cyantoyellow",
        "grayscale",
        "inferno",
        "magma",
        "plasma",
        "rvizcostmap",
        "rvizmap",
        "spectral",
        "turbo",
        "twilight",
        "viridis",
    ]
    | int
)

A type alias for any Colormap-like object.

FillModeArrayLike module-attribute

FillModeArrayLike = (
    FillMode
    | Literal[
        "DenseWireframe",
        "MajorWireframe",
        "Solid",
        "TransparentFillMajorWireframe",
        "densewireframe",
        "majorwireframe",
        "solid",
        "transparentfillmajorwireframe",
    ]
    | int
    | Sequence[FillModeLike]
)

A type alias for any FillMode-like array object.

FillModeLike module-attribute

FillModeLike = (
    FillMode
    | Literal[
        "DenseWireframe",
        "MajorWireframe",
        "Solid",
        "TransparentFillMajorWireframe",
        "densewireframe",
        "majorwireframe",
        "solid",
        "transparentfillmajorwireframe",
    ]
    | int
)

A type alias for any FillMode-like object.

GeoLineStringArrayLike module-attribute

GeoLineStringArrayLike = (
    GeoLineString
    | Sequence[GeoLineStringLike]
    | NDArray[float64]
)

A type alias for any GeoLineString-like array object.

GeoLineStringLike module-attribute

GeoLineStringLike = (
    GeoLineString | DVec2DArrayLike | NDArray[float64]
)

A type alias for any GeoLineString-like object.

GraphTypeArrayLike module-attribute

GraphTypeArrayLike = (
    GraphType
    | Literal[
        "Directed", "Undirected", "directed", "undirected"
    ]
    | int
    | Sequence[GraphTypeLike]
)

A type alias for any GraphType-like array object.

GraphTypeLike module-attribute

GraphTypeLike = (
    GraphType
    | Literal[
        "Directed", "Undirected", "directed", "undirected"
    ]
    | int
)

A type alias for any GraphType-like object.

InterpolationModeArrayLike module-attribute

InterpolationModeArrayLike = (
    InterpolationMode
    | Literal[
        "Linear",
        "StepAfter",
        "StepBefore",
        "StepMid",
        "linear",
        "stepafter",
        "stepbefore",
        "stepmid",
    ]
    | int
    | Sequence[InterpolationModeLike]
)

A type alias for any InterpolationMode-like array object.

InterpolationModeLike module-attribute

InterpolationModeLike = (
    InterpolationMode
    | Literal[
        "Linear",
        "StepAfter",
        "StepBefore",
        "StepMid",
        "linear",
        "stepafter",
        "stepbefore",
        "stepmid",
    ]
    | int
)

A type alias for any InterpolationMode-like object.

KeyValuePairsArrayLike module-attribute

KeyValuePairsArrayLike = (
    KeyValuePairs
    | Sequence[KeyValuePairsLike]
    | dict[str, str]
    | Sequence[dict[str, str]]
)

A type alias for any KeyValuePairs-like array object.

KeyValuePairsLike module-attribute

KeyValuePairsLike = KeyValuePairs | dict[str, str]

A type alias for any KeyValuePairs-like object.

LineStrip2DArrayLike module-attribute

LineStrip2DArrayLike = (
    LineStrip2D
    | Sequence[LineStrip2DLike]
    | NDArray[float32]
)

A type alias for any LineStrip2D-like array object.

LineStrip2DLike module-attribute

LineStrip2DLike = (
    LineStrip2D | Vec2DArrayLike | NDArray[float32]
)

A type alias for any LineStrip2D-like object.

LineStrip3DArrayLike module-attribute

LineStrip3DArrayLike = (
    LineStrip3D
    | Sequence[LineStrip3DLike]
    | NDArray[float32]
)

A type alias for any LineStrip3D-like array object.

LineStrip3DLike module-attribute

LineStrip3DLike = (
    LineStrip3D | Vec3DArrayLike | NDArray[float32]
)

A type alias for any LineStrip3D-like object.

MagnificationFilterArrayLike module-attribute

MagnificationFilterArrayLike = (
    MagnificationFilter
    | Literal[
        "Bicubic",
        "Linear",
        "Nearest",
        "bicubic",
        "linear",
        "nearest",
    ]
    | int
    | Sequence[MagnificationFilterLike]
)

A type alias for any MagnificationFilter-like array object.

MagnificationFilterLike module-attribute

MagnificationFilterLike = (
    MagnificationFilter
    | Literal[
        "Bicubic",
        "Linear",
        "Nearest",
        "bicubic",
        "linear",
        "nearest",
    ]
    | int
)

A type alias for any MagnificationFilter-like object.

MarkerShapeArrayLike module-attribute

MarkerShapeArrayLike = (
    MarkerShape
    | Literal[
        "Asterisk",
        "Circle",
        "Cross",
        "Diamond",
        "Down",
        "Left",
        "Plus",
        "Right",
        "Square",
        "Up",
        "asterisk",
        "circle",
        "cross",
        "diamond",
        "down",
        "left",
        "plus",
        "right",
        "square",
        "up",
    ]
    | int
    | Sequence[MarkerShapeLike]
)

A type alias for any MarkerShape-like array object.

MarkerShapeLike module-attribute

MarkerShapeLike = (
    MarkerShape
    | Literal[
        "Asterisk",
        "Circle",
        "Cross",
        "Diamond",
        "Down",
        "Left",
        "Plus",
        "Right",
        "Square",
        "Up",
        "asterisk",
        "circle",
        "cross",
        "diamond",
        "down",
        "left",
        "plus",
        "right",
        "square",
        "up",
    ]
    | int
)

A type alias for any MarkerShape-like object.

MeshFaceRenderingArrayLike module-attribute

MeshFaceRenderingArrayLike = (
    MeshFaceRendering
    | Literal[
        "Back",
        "DoubleSided",
        "Front",
        "back",
        "doublesided",
        "front",
    ]
    | int
    | Sequence[MeshFaceRenderingLike]
)

A type alias for any MeshFaceRendering-like array object.

MeshFaceRenderingLike module-attribute

MeshFaceRenderingLike = (
    MeshFaceRendering
    | Literal[
        "Back",
        "DoubleSided",
        "Front",
        "back",
        "doublesided",
        "front",
    ]
    | int
)

A type alias for any MeshFaceRendering-like object.

PointShadingArrayLike module-attribute

PointShadingArrayLike = (
    PointShading
    | Literal["Flat", "Gradient", "flat", "gradient"]
    | int
    | Sequence[PointShadingLike]
)

A type alias for any PointShading-like array object.

PointShadingLike module-attribute

PointShadingLike = (
    PointShading
    | Literal["Flat", "Gradient", "flat", "gradient"]
    | int
)

A type alias for any PointShading-like object.

TransformRelationArrayLike module-attribute

TransformRelationArrayLike = (
    TransformRelation
    | Literal[
        "ChildFromParent",
        "ParentFromChild",
        "childfromparent",
        "parentfromchild",
    ]
    | int
    | Sequence[TransformRelationLike]
)

A type alias for any TransformRelation-like array object.

TransformRelationLike module-attribute

TransformRelationLike = (
    TransformRelation
    | Literal[
        "ChildFromParent",
        "ParentFromChild",
        "childfromparent",
        "parentfromchild",
    ]
    | int
)

A type alias for any TransformRelation-like object.

VideoCodecArrayLike module-attribute

VideoCodecArrayLike = (
    VideoCodec
    | Literal[
        "AV1",
        "H264",
        "H265",
        "VP8",
        "VP9",
        "av1",
        "h264",
        "h265",
        "vp8",
        "vp9",
    ]
    | int
    | Sequence[VideoCodecLike]
)

A type alias for any VideoCodec-like array object.

VideoCodecLike module-attribute

VideoCodecLike = (
    VideoCodec
    | Literal[
        "AV1",
        "H264",
        "H265",
        "VP8",
        "VP9",
        "av1",
        "h264",
        "h265",
        "vp8",
        "vp9",
    ]
    | int
)

A type alias for any VideoCodec-like object.

AggregationPolicy

Bases: Enum

Component: Policy for aggregation of multiple scalar plot values.

This is used for lines in plots when the X axis distance of individual points goes below a single pixel, i.e. a single pixel covers more than one tick worth of data. It can greatly improve performance (and readability) in such situations as it prevents overdraw.

Average class-attribute instance-attribute

Average = 2

Average all points in the range together.

Max class-attribute instance-attribute

Max = 3

Keep only the maximum values in the range.

Min class-attribute instance-attribute

Min = 4

Keep only the minimum values in the range.

MinMax class-attribute instance-attribute

MinMax = 5

Keep both the minimum and maximum values in the range.

This will yield two aggregated points instead of one, effectively creating a vertical line.

MinMaxAverage class-attribute instance-attribute

MinMaxAverage = 6

Find both the minimum and maximum values in the range, then use the average of those.

Off class-attribute instance-attribute

Off = 1

No aggregation.

__str__

def __str__() -> str

Returns the variant name.

auto classmethod

def auto(
    val: str | int | AggregationPolicy,
) -> AggregationPolicy

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

AggregationPolicyBatch

Bases: BaseBatch[AggregationPolicyArrayLike], 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.

AlbedoFactor

Bases: Rgba32, ComponentMixin

Component: A color multiplier, usually applied to a whole entity, e.g. a mesh.

__init__

def __init__(rgba: Rgba32Like) -> None

Create a new instance of the Rgba32 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.

AlbedoFactorBatch

Bases: Rgba32Batch, 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.

AnnotationContext

Bases: AnnotationContextExt, ComponentMixin

Component: The annotation context provides additional information on how to display entities.

Entities can use datatypes.ClassIds and datatypes.KeypointIds to provide annotations, and the labels and colors will be looked up in the appropriate annotation context. We use the first annotation context we find in the path-hierarchy when searching up through the ancestors of a given entity path.

⚠️ This type is unstable and may change significantly in a way that the data won't be backwards compatible.

__init__

def __init__(class_map: AnnotationContextLike) -> None

Create a new instance of the AnnotationContext component.

PARAMETER	DESCRIPTION
class_map	List of class descriptions, mapping class indices to class names, colors etc. TYPE: AnnotationContextLike

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.

AnnotationContextBatch

Bases: BaseBatch[AnnotationContextArrayLike], 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.

AxisLength

Bases: Float32, ComponentMixin

Component: The length of an axis in local units of the space.

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

AxisLengthBatch

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.

Blob

Bases: Blob, ComponentMixin

Component: A binary blob of data.

__init__

def __init__(data: BlobLike) -> None

Create a new instance of the Blob 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.

BlobBatch

Bases: BlobBatch, 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.

CellSize

Bases: Float32, ComponentMixin

Component: The metric size of one grid cell in local scene units.

E.g. for 2D grid maps, this is the physical size represented by a single pixel or cell.

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

CellSizeBatch

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.

ChannelId

Bases: UInt16, ComponentMixin

Component: A 16-bit ID representing an MCAP channel.

Used to identify specific channels within an MCAP file.

__init__

def __init__(value: UInt16Like) -> None

Create a new instance of the UInt16 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.

ChannelIdBatch

Bases: UInt16Batch, 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.

ChannelMessageCounts

Bases: ComponentMixin

Component: A mapping of channel IDs to their respective message counts.

Used in MCAP statistics to track how many messages were recorded per channel.

⚠️ This type is unstable and may change significantly in a way that the data won't be backwards compatible.

__init__

def __init__(counts: ChannelMessageCountsLike) -> None

Create a new instance of the ChannelMessageCounts component.

PARAMETER	DESCRIPTION
counts	The channel ID to message count pairs. TYPE: ChannelMessageCountsLike

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.

ChannelMessageCountsBatch

Bases: BaseBatch[ChannelMessageCountsArrayLike], 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.

ClassId

Bases: ClassId, ComponentMixin

Component: A 16-bit ID representing a type of semantic class.

__init__

def __init__(id: ClassIdLike) -> None

Create a new instance of the ClassId 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.

ClassIdBatch

Bases: ClassIdBatch, 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.

ClearIsRecursive

Bases: ClearIsRecursiveExt, Bool, ComponentMixin

Component: Configures how a clear operation should behave - recursive or not.

__init__

def __init__(recursive: bool = True) -> None

Disconnect an entity from its parent.

PARAMETER	DESCRIPTION
recursive	If true, also clears all recursive children entities. TYPE: bool 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.

ClearIsRecursiveBatch

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.

Color

Bases: ColorExt, Rgba32, ComponentMixin

Component: An RGBA color with unmultiplied/separate alpha, in sRGB gamma space with linear alpha.

The color is stored as a 32-bit integer, where the most significant byte is R and the least significant byte is A.

Float colors are assumed to be in 0-1 gamma sRGB space. All other colors are assumed to be in 0-255 gamma sRGB space. If there is an alpha, we assume it is in linear space, and separate (NOT pre-multiplied).

__init__

def __init__(rgba: Rgba32Like) -> None

Create a new instance of the Rgba32 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.

from_string staticmethod

def from_string(s: str) -> Color

Generate a random yet deterministic color based on a string.

The color is guaranteed to be identical for the same input string.

ColorBatch

Bases: Rgba32Batch, 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.

Colormap

Bases: Enum

Component: Colormap for mapping scalar values within a given range to a color.

This provides a number of popular pre-defined colormaps. In the future, the Rerun Viewer will allow users to define their own colormaps, but currently the Viewer is limited to the types defined here.

CyanToYellow class-attribute instance-attribute

CyanToYellow = 7

Rasmusgo's Cyan to Yellow colormap

This is a perceptually uniform colormap which is robust to color blindness. It is especially suited for visualizing signed values. It interpolates from cyan to blue to dark gray to brass to yellow.

Grayscale class-attribute instance-attribute

Grayscale = 1

A simple black to white gradient.

This is a sRGB gray gradient which is perceptually uniform.

Inferno class-attribute instance-attribute

Inferno = 2

The Inferno colormap from Matplotlib.

This is a perceptually uniform colormap. It interpolates from black to red to bright yellow.

Magma class-attribute instance-attribute

Magma = 3

The Magma colormap from Matplotlib.

This is a perceptually uniform colormap. It interpolates from black to purple to white.

Plasma class-attribute instance-attribute

Plasma = 4

The Plasma colormap from Matplotlib.

This is a perceptually uniform colormap. It interpolates from dark blue to purple to yellow.

RvizCostmap class-attribute instance-attribute

RvizCostmap = 11

The classic RViz "Costmap" grid-map colormap for robot navigation cost maps.

Cost values are mapped to blue to red spectrum, and special cost values (e.g. lethal obstacles) have highlight colors. Zero values are fully transparent.

RvizMap class-attribute instance-attribute

RvizMap = 10

The classic RViz "Map" grid-map colormap intended for occupancy-style SLAM grid maps.

Known values are mapped to a grayscale ramp from white (free) to black (occupied), unknown values are in a green-blue color. Special / illegal values have highlight colors.

Spectral class-attribute instance-attribute

Spectral = 8

The Spectral colormap from Matplotlib.

This is a diverging colormap, often used to visualize data with a meaningful center point, where deviations from that center are important to highlight. It interpolates from red to orange to yellow to green to blue to violet.

Turbo class-attribute instance-attribute

Turbo = 5

Google's Turbo colormap map.

This is a perceptually non-uniform rainbow colormap addressing many issues of more traditional rainbow colormaps like Jet. It is more perceptually uniform without sharp transitions and is more colorblind-friendly. Details: https://research.google/blog/turbo-an-improved-rainbow-colormap-for-visualization/

Twilight class-attribute instance-attribute

Twilight = 9

The Twilight colormap from Matplotlib.

This is a perceptually uniform cyclic colormap from Matplotlib, it is useful for visualizing periodic or cyclic data.

It interpolates from white to blue to purple to red to orange and back to white.

Viridis class-attribute instance-attribute

Viridis = 6

The Viridis colormap from Matplotlib

This is a perceptually uniform colormap which is robust to color blindness. It interpolates from dark purple to green to yellow.

__str__

def __str__() -> str

Returns the variant name.

auto classmethod

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

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

ColormapBatch

Bases: BaseBatch[ColormapArrayLike], 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.

Count

Bases: UInt64, ComponentMixin

Component: A generic count value.

Used for counting various entities like messages, schemas, channels, etc.

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

CountBatch

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.

DepthMeter

Bases: Float32, ComponentMixin

Component: The world->depth map scaling factor.

This measures how many depth map units are in a world unit. For instance, if a depth map uses millimeters and the world uses meters, this value would be 1000.

Note that the only effect on 2D views is the physical depth values shown when hovering the image. In 3D views on the other hand, this affects where the points of the point cloud are placed.

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

DepthMeterBatch

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.

DrawOrder

Bases: Float32, ComponentMixin

Component: Draw order of 2D elements. Higher values are drawn on top of lower values.

An entity can have only a single draw order component. Within an entity draw order is governed by the order of the components.

Draw order for entities with the same draw order is generally undefined.

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

DrawOrderBatch

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.

EntityPath

Bases: EntityPath, ComponentMixin

Component: A path to an entity, usually to reference some data that is part of the target entity.

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

EntityPathBatch

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.

FillMode

Bases: Enum

Component: How a geometric shape is drawn and colored.

DenseWireframe class-attribute instance-attribute

DenseWireframe = 2

Many lines are drawn to represent the surface of the shape in a see-through fashion.

Examples of what this means:

• An archetypes.Ellipsoids3D will draw a wireframe triangle mesh that approximates each ellipsoid.
• For archetypes.Boxes3D, it is the edges of the box, identical to components.FillMode.MajorWireframe.

MajorWireframe class-attribute instance-attribute

MajorWireframe = 1

Lines are drawn around the parts of the shape which directly correspond to the logged data.

Examples of what this means:

• An archetypes.Ellipsoids3D will draw three axis-aligned ellipses that are cross-sections of each ellipsoid, each of which displays two out of three of the sizes of the ellipsoid.
• For archetypes.Boxes3D, it is the edges of the box, identical to components.FillMode.DenseWireframe.

Solid class-attribute instance-attribute

Solid = 3

The surface of the shape is filled in with a solid color. No lines are drawn.

TransparentFillMajorWireframe class-attribute instance-attribute

TransparentFillMajorWireframe = 4

The surface of the shape is filled in with a transparent color, with major wireframe lines on top.

This gives a good default appearance that shows both the shape's surface and its structure.

__str__

def __str__() -> str

Returns the variant name.

auto classmethod

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

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

FillModeBatch

Bases: BaseBatch[FillModeArrayLike], 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.

FillRatio

Bases: Float32, ComponentMixin

Component: How much a primitive fills out the available space.

Used for instance to scale the points of the point cloud created from archetypes.DepthImage projection in 3D views. Valid range is from 0 to max float although typically values above 1.0 are not useful.

Defaults to 1.0.

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

FillRatioBatch

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.

GammaCorrection

Bases: Float32, ComponentMixin

Component: A gamma correction value to be used with a scalar value or color.

Used to adjust the gamma of a color or scalar value between 0 and 1 before rendering. new_value = old_value ^ gamma

Must be a positive number. Defaults to 1.0 unless otherwise specified.

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

GammaCorrectionBatch

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.

GeoLineString

Bases: GeoLineStringExt, ComponentMixin

Component: A geospatial line string expressed in EPSG:4326 latitude and longitude (North/East-positive degrees).

__init__

def __init__(*, lat_lon: GeoLineStringLike) -> None

Create a new instance of the GeoLineString 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.

GeoLineStringBatch

Bases: BaseBatch[GeoLineStringArrayLike], 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.

GraphEdge

Bases: Utf8Pair, ComponentMixin

Component: An edge in a graph connecting two nodes.

__init__

def __init__(first: Utf8Like, second: Utf8Like) -> None

Create a new instance of the Utf8Pair datatype.

PARAMETER	DESCRIPTION
first	The first string. TYPE: Utf8Like
second	The second string. TYPE: 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.

GraphEdgeBatch

Bases: Utf8PairBatch, 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.

GraphNode

Bases: Utf8, ComponentMixin

Component: A string-based ID representing a node in a graph.

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

GraphNodeBatch

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.

GraphType

Bases: Enum

Component: Specifies if a graph has directed or undirected edges.

Directed class-attribute instance-attribute

Directed = 2

The graph has directed edges.

Undirected class-attribute instance-attribute

Undirected = 1

The graph has undirected edges.

__str__

def __str__() -> str

Returns the variant name.

auto classmethod

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

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

GraphTypeBatch

Bases: BaseBatch[GraphTypeArrayLike], 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.

HalfSize2D

Bases: Vec2D, ComponentMixin

Component: Half-size (radius) of a 2D box.

Measured in its local coordinate system.

The box extends both in negative and positive direction along each axis. Negative sizes indicate that the box is flipped along the respective axis, but this has no effect on how it is displayed.

__init__

def __init__(xy: Vec2DLike) -> None

Create a new instance of the Vec2D 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.

HalfSize2DBatch

Bases: Vec2DBatch, 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.

HalfSize3D

Bases: Vec3D, ComponentMixin

Component: Half-size (radius) of a 3D box.

Measured in its local coordinate system.

The box extends both in negative and positive direction along each axis. Negative sizes indicate that the box is flipped along the respective axis, but this has no effect on how it is displayed.

__init__

def __init__(xyz: Vec3DLike) -> None

Create a new instance of the Vec3D 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.

HalfSize3DBatch

Bases: Vec3DBatch, 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.

ImageBuffer

Bases: Blob, ComponentMixin

Component: A buffer that is known to store image data.

To interpret the contents of this buffer, see, components.ImageFormat.

__init__

def __init__(data: BlobLike) -> None

Create a new instance of the Blob 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.

ImageBufferBatch

Bases: BlobBatch, 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.

ImageFormat

Bases: ImageFormat, ComponentMixin

Component: The metadata describing the contents of a components.ImageBuffer.

__init__

def __init__(
    width: int,
    height: int,
    *,
    pixel_format: PixelFormatLike | None = None,
    color_model: ColorModelLike | None = None,
    channel_datatype: ChannelDatatypeLike | None = None,
) -> None

Create a new instance of the ImageFormat datatype.

PARAMETER	DESCRIPTION
width	The width of the image in pixels. TYPE: int
height	The height of the image in pixels. TYPE: int
pixel_format	Used mainly for chroma downsampled formats and differing number of bits per channel. If specified, this takes precedence over both datatypes.ColorModel and datatypes.ChannelDatatype (which are ignored). TYPE: PixelFormatLike | None DEFAULT: None
color_model	L, RGB, RGBA, … Also requires a datatypes.ChannelDatatype to fully specify the pixel format. TYPE: ColorModelLike | None DEFAULT: None
channel_datatype	The data type of each channel (e.g. the red channel) of the image data (U8, F16, …). Also requires a datatypes.ColorModel to fully specify the pixel format. TYPE: ChannelDatatypeLike | 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.

ImageFormatBatch

Bases: ImageFormatBatch, 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.

ImagePlaneDistance

Bases: Float32, ComponentMixin

Component: The distance from the camera origin to the image plane when the projection is shown in a 3D viewer.

This is only used for visualization purposes, and does not affect the projection itself.

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

ImagePlaneDistanceBatch

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.

Interactive

Bases: Bool, ComponentMixin

Component: Whether the entity can be interacted with.

Non interactive components are still visible, but mouse interactions in the view are disabled.

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

InteractiveBatch

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.

InterpolationMode

Bases: Enum

Component: Specifies how values between data points are interpolated in time series.

Linear class-attribute instance-attribute

Linear = 1

Connect data points with straight line segments.

StepAfter class-attribute instance-attribute

StepAfter = 2

Hold the previous value until the next data point, then jump.

The step occurs at the end of the interval.

StepBefore class-attribute instance-attribute

StepBefore = 3

Jump to the new value immediately, then hold until the next data point.

The step occurs at the beginning of the interval.

StepMid class-attribute instance-attribute

StepMid = 4

Hold the previous value until the midpoint between data points, then jump to the new value.

The step occurs at the midpoint of the interval.

__str__

def __str__() -> str

Returns the variant name.

auto classmethod

def auto(
    val: str | int | InterpolationMode,
) -> InterpolationMode

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

InterpolationModeBatch

Bases: BaseBatch[InterpolationModeArrayLike], 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.

IsKeyframe

Bases: Bool, ComponentMixin

Component: Whether a components.VideoSample contains a keyframe (also known as a sync sample or IDR).

A keyframe in this sense must be decoder re-entrant: a decoder must be able to start decoding the stream from this sample alone, with no prior decoder state. Not every intra-coded frame qualifies. Some codecs have intra-only frames that may still reference existing decoder state and are therefore not valid sync points. See components.VideoCodec for the codec-specific definition of a keyframe.

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

IsKeyframeBatch

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.

KeyValuePairs

Bases: KeyValuePairsExt, ComponentMixin

Component: A map of string keys to string values.

This component can be used to attach arbitrary metadata or annotations to entities. Each key-value pair is stored as a UTF-8 string mapping.

⚠️ This type is unstable and may change significantly in a way that the data won't be backwards compatible.

__init__

def __init__(pairs: KeyValuePairsLike) -> None

Create a new instance of the KeyValuePairs component.

PARAMETER	DESCRIPTION
pairs	The key-value pairs that make up this string map. TYPE: KeyValuePairsLike

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.

KeyValuePairsBatch

Bases: BaseBatch[KeyValuePairsArrayLike], 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.

KeypointId

Bases: KeypointId, ComponentMixin

Component: A 16-bit ID representing a type of semantic keypoint within a class.

KeypointIds are only meaningful within the context of a [rerun.datatypes.ClassDescription].

Used to look up an [rerun.datatypes.AnnotationInfo] for a Keypoint within the [rerun.components.AnnotationContext].

__init__

def __init__(id: KeypointIdLike) -> None

Create a new instance of the KeypointId 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.

KeypointIdBatch

Bases: KeypointIdBatch, 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.

LatLon

Bases: DVec2D, ComponentMixin

Component: A geospatial position expressed in EPSG:4326 latitude and longitude (North/East-positive degrees).

__init__

def __init__(xy: DVec2DLike) -> None

Create a new instance of the DVec2D 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.

LatLonBatch

Bases: DVec2DBatch, 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.

Length

Bases: Float32, ComponentMixin

Component: Length, or one-dimensional size.

Measured in its local coordinate system; consult the archetype in use to determine which axis or part of the entity this is the length of.

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

LengthBatch

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.

LineStrip2D

Bases: LineStrip2DExt, ComponentMixin

Component: A line strip in 2D space.

A line strip is a list of points connected by line segments. It can be used to draw approximations of smooth curves.

The points will be connected in order, like so:

       2------3     5
      /        \   /
0----1          \ /
                 4

__init__

def __init__(points: LineStrip2DLike) -> None

Create a new instance of the LineStrip2D 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.

LineStrip2DBatch

Bases: BaseBatch[LineStrip2DArrayLike], 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.

LineStrip3D

Bases: LineStrip3DExt, ComponentMixin

Component: A line strip in 3D space.

A line strip is a list of points connected by line segments. It can be used to draw approximations of smooth curves.

The points will be connected in order, like so:

       2------3     5
      /        \   /
0----1          \ /
                 4

__init__

def __init__(points: LineStrip3DLike) -> None

Create a new instance of the LineStrip3D 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.

LineStrip3DBatch

Bases: BaseBatch[LineStrip3DArrayLike], 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.

LinearSpeed

Bases: Float64, ComponentMixin

Component: Linear speed, used for translation speed for example.

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

LinearSpeedBatch

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.

MagnificationFilter

Bases: Enum

Component: Filter used when a single texel/pixel of an image is displayed larger than a single screen pixel.

This happens when zooming into an image, when displaying a low-resolution image in a large area, or when viewing an image up close in 3D space.

Bicubic class-attribute instance-attribute

Bicubic = 3

Bicubic interpolation using a Catmull-Rom spline, creating the smoothest look when the image is scaled up.

This is computationally more expensive than linear filtering but produces sharper results with less blurring. Unlike bilinear filtering, this avoids cross-shaped artifacts at texel boundaries.

Linear class-attribute instance-attribute

Linear = 2

Linearly interpolate the nearest neighbors, creating a smoother look when the image is scaled up.

Used as default for mesh rendering.

Nearest class-attribute instance-attribute

Nearest = 1

Show the nearest pixel value.

This will give a blocky appearance when the image is scaled up. Used as default when rendering 2D images.

__str__

def __str__() -> str

Returns the variant name.

auto classmethod

def auto(
    val: str | int | MagnificationFilter,
) -> MagnificationFilter

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

MagnificationFilterBatch

Bases: BaseBatch[MagnificationFilterArrayLike], 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.

MarkerShape

Bases: Enum

Component: The visual appearance of a point in e.g. a 2D plot.

Asterisk class-attribute instance-attribute

Asterisk = 10

*

Circle class-attribute instance-attribute

Circle = 1

⏺

Cross class-attribute instance-attribute

Cross = 4

x

Diamond class-attribute instance-attribute

Diamond = 2

◆

Down class-attribute instance-attribute

Down = 7

▼

Left class-attribute instance-attribute

Left = 8

◀

Plus class-attribute instance-attribute

Plus = 5

+

Right class-attribute instance-attribute

Right = 9

▶

Square class-attribute instance-attribute

Square = 3

◼️

Up class-attribute instance-attribute

Up = 6

▲

__str__

def __str__() -> str

Returns the variant name.

auto classmethod

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

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

MarkerShapeBatch

Bases: BaseBatch[MarkerShapeArrayLike], 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.

MarkerSize

Bases: Float32, ComponentMixin

Component: Radius of a marker of a point in e.g. a 2D plot, measured in UI points.

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

MarkerSizeBatch

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.

MediaType

Bases: MediaTypeExt, Utf8, ComponentMixin

Component: A standardized media type (RFC2046, formerly known as MIME types), encoded as a string.

The complete reference of officially registered media types is maintained by the IANA and can be consulted at https://www.iana.org/assignments/media-types/media-types.xhtml.

GLB class-attribute instance-attribute

GLB: MediaType = None

Binary glTF: model/gltf-binary.

https://www.iana.org/assignments/media-types/model/gltf-binary

GLTF class-attribute instance-attribute

GLTF: MediaType = None

glTF: model/gltf+json.

https://www.iana.org/assignments/media-types/model/gltf+json

JPEG class-attribute instance-attribute

JPEG: MediaType = None

JPEG image: image/jpeg.

MARKDOWN class-attribute instance-attribute

MARKDOWN: MediaType = None

Markdown: text/markdown.

https://www.iana.org/assignments/media-types/text/markdown

MP4 class-attribute instance-attribute

MP4: MediaType = None

mp4: video/mp4.

https://www.iana.org/assignments/media-types/video/mp4

OBJ class-attribute instance-attribute

OBJ: MediaType = None

Wavefront .obj: model/obj.

https://www.iana.org/assignments/media-types/model/obj

PNG class-attribute instance-attribute

PNG: MediaType = None

PNG image: image/png.

https://www.iana.org/assignments/media-types/image/png

RVL class-attribute instance-attribute

RVL: MediaType = None

RVL compressed depth: application/rvl.

Run length encoding and Variable Length encoding schemes (RVL) compressed depth data format. https://www.microsoft.com/en-us/research/wp-content/uploads/2018/09/p100-wilson.pdf

STL class-attribute instance-attribute

STL: MediaType = None

Stereolithography Model stl: model/stl. Either binary or ASCII.

https://www.iana.org/assignments/media-types/model/stl

TEXT class-attribute instance-attribute

TEXT: MediaType = None

Plain text: text/plain.

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

MediaTypeBatch

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.

MeshFaceRendering

Bases: Enum

Component: Determines which faces of a mesh are rendered.

For this purpose, we assume that the winding order of vertices in a mesh is consistent and that front faces are defined as those with vertices in counter clockwise order.

Back class-attribute instance-attribute

Back = 3

Only back faces are shown.

Back faces are assumed to have a clockwise vertex winding order on screen.

DoubleSided class-attribute instance-attribute

DoubleSided = 1

Show both back and front faces.

Front class-attribute instance-attribute

Front = 2

Only front faces are shown.

Front faces are assumed to have a counter clockwise vertex winding order on screen.

__str__

def __str__() -> str

Returns the variant name.

auto classmethod

def auto(
    val: str | int | MeshFaceRendering,
) -> MeshFaceRendering

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

MeshFaceRenderingBatch

Bases: BaseBatch[MeshFaceRenderingArrayLike], 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.

Name

Bases: Utf8, ComponentMixin

Component: A display name, typically for an entity or a item like a plot series.

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

NameBatch

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.

Opacity

Bases: Float32, ComponentMixin

Component: Degree of transparency ranging from 0.0 (fully transparent) to 1.0 (fully opaque).

The final opacity value may be a result of multiplication with alpha values as specified by other color sources. Unless otherwise specified, the default value is 1.

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

OpacityBatch

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.

PinholeProjection

Bases: Mat3x3, ComponentMixin

Component: Camera projection, from image coordinates to view coordinates.

Child from parent. Image coordinates from camera view coordinates.

Example:

1496.1     0.0  980.5
   0.0  1496.1  744.5
   0.0     0.0    1.0

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.

PinholeProjectionBatch

Bases: Mat3x3Batch, 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.

Plane3D

Bases: Plane3D, ComponentMixin

Component: An infinite 3D plane represented by a unit normal vector and a distance.

Any point P on the plane fulfills the equation dot(xyz, P) - d = 0, where xyz is the plane's normal and d the distance of the plane from the origin. This representation is also known as the Hesse normal form.

Note: although the normal will be passed through to the datastore as provided, when used in the Viewer, planes will always be normalized. I.e. the plane with xyz = (2, 0, 0), d = 1 is equivalent to xyz = (1, 0, 0), d = 0.5

__init__

def __init__(
    normal: Vec3DLike, distance: float | int | None = None
) -> None

Create a new instance of the Plane3D datatype.

Does not normalize the plane.

PARAMETER	DESCRIPTION
normal	Normal vector of the plane. TYPE: Vec3DLike
distance	Distance of the plane from the origin. Defaults to zero. TYPE: float | 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.

distance

def distance() -> float

Returns the distance of the plane from the origin.

normal

def normal() -> NDArray[float32]

Returns the normal vector of the plane.

with_distance

def with_distance(distance: float) -> Plane3D

Returns a new plane with the same normal but with the distance set to the given amount.

Plane3DBatch

Bases: Plane3DBatch, 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.

PointShading

Bases: Enum

Component: Defines how points are shaded.

Flat class-attribute instance-attribute

Flat = 2

Flat shading.

Gradient class-attribute instance-attribute

Gradient = 1

Radial gradient for a spherical shadow effect.

__str__

def __str__() -> str

Returns the variant name.

auto classmethod

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

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

PointShadingBatch

Bases: BaseBatch[PointShadingArrayLike], 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.

Position2D

Bases: Vec2D, ComponentMixin

Component: A position in 2D space.

__init__

def __init__(xy: Vec2DLike) -> None

Create a new instance of the Vec2D 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.

Position2DBatch

Bases: Vec2DBatch, 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.

Position3D

Bases: Vec3D, ComponentMixin

Component: A position in 3D space.

__init__

def __init__(xyz: Vec3DLike) -> None

Create a new instance of the Vec3D 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.

Position3DBatch

Bases: Vec3DBatch, 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.

Radius

Bases: RadiusExt, Float32, ComponentMixin

Component: The radius of something, e.g. a point.

Internally, positive values indicate scene units, whereas negative values are interpreted as UI points.

UI points are independent of zooming in Views, but are sensitive to the application UI scaling. at 100% UI scaling, UI points are equal to pixels The Viewer's UI scaling defaults to the OS scaling which typically is 100% for full HD screens and 200% for 4k screens.

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

ui_points staticmethod

def ui_points(radii: Number | ArrayLike) -> ArrayLike

Create a radius or list of radii in UI points.

By default, radii are interpreted as scene units. Ui points on the other hand are independent of zooming in Views, but are sensitive to the application UI scaling. at 100% UI scaling, UI points are equal to pixels The Viewer's UI scaling defaults to the OS scaling which typically is 100% for full HD screens and 200% for 4k screens.

Internally, ui radii are stored as negative values. Therefore, all this method does is to ensure that all returned values are negative.

RadiusBatch

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.

Range1D

Bases: Range1D, ComponentMixin

Component: A 1D range, specifying a lower and upper bound.

__init__

def __init__(range: Range1DLike) -> None

Create a new instance of the Range1D 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.

Range1DBatch

Bases: Range1DBatch, 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.

Resolution

Bases: Vec2D, ComponentMixin

Component: Pixel resolution width & height, e.g. of a camera sensor.

Typically in integer units, but for some use cases floating point may be used.

__init__

def __init__(xy: Vec2DLike) -> None

Create a new instance of the Vec2D 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.

ResolutionBatch

Bases: Vec2DBatch, 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.

RotationAxisAngle

Bases: RotationAxisAngle, ComponentMixin

Component: 3D rotation represented by a rotation around a given axis.

If normalization of the rotation axis fails the rotation is treated as an invalid transform, unless the angle is zero in which case it is treated as an identity.

__init__

def __init__(
    axis: Vec3DLike,
    angle: AngleLike | None = None,
    *,
    radians: float | None = None,
    degrees: float | None = None,
) -> None

Create a new instance of the RotationAxisAngle datatype.

PARAMETER	DESCRIPTION
axis	Axis to rotate around. This is not required to be normalized. If normalization fails (typically because the vector is length zero), the rotation is silently ignored. TYPE: Vec3DLike
angle	How much to rotate around the axis. TYPE: AngleLike | None DEFAULT: None
radians	How much to rotate around the axis, in radians. Specify this instead of degrees or angle. TYPE: float | None DEFAULT: None
degrees	How much to rotate around the axis, in degrees. Specify this instead of radians or angle. TYPE: float | 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.

RotationAxisAngleBatch

Bases: RotationAxisAngleBatch, 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.

RotationQuat

Bases: Quaternion, ComponentMixin

Component: A 3D rotation expressed as a quaternion.

Note: although the x,y,z,w components of the quaternion will be passed through to the datastore as provided, when used in the Viewer, quaternions will always be normalized. If normalization fails the rotation is treated as an invalid transform.

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.

RotationQuatBatch

Bases: QuaternionBatch, 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.

Scalar

Bases: Float64, ComponentMixin

Component: A scalar value, encoded as a 64-bit floating point.

Used for time series plots.

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

ScalarBatch

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.

Scale3D

Bases: Scale3DExt, Vec3D, ComponentMixin

Component: A 3D scale factor.

A scale of 1.0 means no scaling. A scale of 2.0 means doubling the size. Each component scales along the corresponding axis.

__init__

def __init__(
    uniform_or_per_axis: Vec3DLike
    | Float32Like
    | None = True,
) -> None

3D scaling factor.

A scale of 1.0 means no scaling. A scale of 2.0 means doubling the size. Each component scales along the corresponding axis.

PARAMETER	DESCRIPTION
uniform_or_per_axis	If a single value is given, it is applied the same to all three axis (uniform scaling). TYPE: Vec3DLike | Float32Like | None 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.

Scale3DBatch

Bases: Vec3DBatch, 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.

SchemaId

Bases: UInt16, ComponentMixin

Component: A 16-bit unique identifier for a schema within the MCAP file.

__init__

def __init__(value: UInt16Like) -> None

Create a new instance of the UInt16 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.

SchemaIdBatch

Bases: UInt16Batch, 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.

ShowLabels

Bases: Bool, ComponentMixin

Component: Whether the entity's components.Text label is shown.

The main purpose of this component existing separately from the labels themselves is to be overridden when desired, to allow hiding and showing from the viewer and blueprints.

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

ShowLabelsBatch

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.

StrokeWidth

Bases: Float32, ComponentMixin

Component: The width of a stroke specified in UI points.

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

StrokeWidthBatch

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.

TensorData

Bases: TensorData, ComponentMixin

Component: An N-dimensional array of numbers.

The number of dimensions and their respective lengths is specified by the shape field. The dimensions are ordered from outermost to innermost. For example, in the common case of a 2D RGB Image, the shape would be [height, width, channel].

These dimensions are combined with an index to look up values from the buffer field, which stores a contiguous array of typed values.

__init__

def __init__(
    *,
    shape: Sequence[int] | None = None,
    buffer: TensorBufferLike | None = None,
    array: TensorLike | None = None,
    dim_names: Sequence[str] | None = None,
) -> None

Construct a TensorData object.

The TensorData object is internally represented by three fields: shape and buffer.

This constructor provides additional arguments 'array', and 'dim_names'. When passing in a multi-dimensional array such as a np.ndarray, the shape and buffer fields will be populated automagically.

PARAMETER	DESCRIPTION
self	The TensorData object to construct. TYPE: Any
shape	The shape of the tensor. If None, and an array is provided, the shape will be inferred from the shape of the array. TYPE: Sequence[int] | None DEFAULT: None
buffer	The buffer of the tensor. If None, and an array is provided, the buffer will be generated from the array. TYPE: TensorBufferLike | None DEFAULT: None
array	A numpy array (or The array of the tensor. If None, the array will be inferred from the buffer. TYPE: TensorLike | None DEFAULT: None
dim_names	The names of the tensor dimensions. TYPE: Sequence[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.

numpy

def numpy(force: bool) -> NDArray[Any]

Convert the TensorData back to a numpy array.

TensorDataBatch

Bases: TensorDataBatch, 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.

TensorDimensionIndexSelection

Bases: TensorDimensionIndexSelection, ComponentMixin

Component: Specifies a concrete index on a tensor dimension.

__init__

def __init__(dimension: int, index: int) -> None

Create a new instance of the TensorDimensionIndexSelection datatype.

PARAMETER	DESCRIPTION
dimension	The dimension number to select. TYPE: int
index	The index along the dimension to use. TYPE: int

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.

TensorDimensionIndexSelectionBatch

Bases: TensorDimensionIndexSelectionBatch, 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.

TensorHeightDimension

Bases: TensorDimensionSelection, ComponentMixin

Component: Specifies which dimension to use for height.

__init__

def __init__(dimension: int, *, invert: bool = False) -> None

Create a new instance of the TensorDimensionSelection datatype.

PARAMETER	DESCRIPTION
dimension	The dimension number to select. TYPE: int
invert	Invert the direction of the dimension. TYPE: bool DEFAULT: False

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.

TensorHeightDimensionBatch

Bases: TensorDimensionSelectionBatch, 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.

TensorWidthDimension

Bases: TensorDimensionSelection, ComponentMixin

Component: Specifies which dimension to use for width.

__init__

def __init__(dimension: int, *, invert: bool = False) -> None

Create a new instance of the TensorDimensionSelection datatype.

PARAMETER	DESCRIPTION
dimension	The dimension number to select. TYPE: int
invert	Invert the direction of the dimension. TYPE: bool DEFAULT: False

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.

TensorWidthDimensionBatch

Bases: TensorDimensionSelectionBatch, 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.

Texcoord2D

Bases: Vec2D, ComponentMixin

Component: A 2D texture UV coordinate.

Texture coordinates specify a position on a 2D texture. A range from 0-1 covers the entire texture in the respective dimension. Unless configured otherwise, the texture repeats outside of this range. Rerun uses top-left as the origin for UV coordinates.

0 U 1 0 + --------- → | . V | . | . 1 ↓ . . . . . .

This is the same convention as in Vulkan/Metal/DX12/WebGPU, but (!) unlike OpenGL, which places the origin at the bottom-left.

__init__

def __init__(xy: Vec2DLike) -> None

Create a new instance of the Vec2D 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.

Texcoord2DBatch

Bases: Vec2DBatch, 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.

Text

Bases: Utf8, ComponentMixin

Component: A string of text, e.g. for labels and text documents.

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

TextBatch

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.

TextLogLevel

Bases: TextLogLevelExt, Utf8, ComponentMixin

Component: The severity level of a text log message.

Recommended to be one of: * "CRITICAL" * "ERROR" * "WARN" * "INFO" * "DEBUG" * "TRACE"

CRITICAL class-attribute instance-attribute

CRITICAL: TextLogLevel = None

Designates catastrophic failures.

DEBUG class-attribute instance-attribute

DEBUG: TextLogLevel = None

Designates lower priority information.

ERROR class-attribute instance-attribute

ERROR: TextLogLevel = None

Designates very serious errors.

INFO class-attribute instance-attribute

INFO: TextLogLevel = None

Designates useful information.

TRACE class-attribute instance-attribute

TRACE: TextLogLevel = None

Designates very low priority, often extremely verbose, information.

WARN class-attribute instance-attribute

WARN: TextLogLevel = None

Designates hazardous situations.

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

TextLogLevelBatch

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.

Timestamp

Bases: TimeInt, ComponentMixin

Component: When the recording started.

Should be an absolute time, i.e. relative to Unix Epoch.

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

TimestampBatch

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.

TransformFrameId

Bases: Utf8, ComponentMixin

Component: A string identifier for a transform frame.

Transform frames may be derived from entity paths to refer to Rerun's implicit entity path driven hierarchy which is defined via archetypes.Transform3D, archetypes.Pinhole etc.. These implicit transform frames look like tf#path/to/entity.

Note that any archetypes.Transform3Ds logged with both parent_frame and child_frame set describes a relationship between these parent and child transform frames, not the transform frame that the entity path may be using (defined by an archetypes.CoordinateFrame).

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

TransformFrameIdBatch

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.

TransformMat3x3

Bases: Mat3x3, ComponentMixin

Component: A 3x3 transformation matrix Matrix.

3x3 matrixes are able to represent any affine transformation in 3D space, i.e. rotation, scaling, shearing, reflection etc.

Matrices in Rerun are stored as flat list of coefficients in column-major order:

            column 0       column 1       column 2
       -------------------------------------------------
row 0 | flat_columns[0] flat_columns[3] flat_columns[6]
row 1 | flat_columns[1] flat_columns[4] flat_columns[7]
row 2 | flat_columns[2] flat_columns[5] flat_columns[8]

However, construction is done from a list of rows, which follows NumPy's convention:

np.testing.assert_array_equal(
    rr.components.TransformMat3x3([1, 2, 3, 4, 5, 6, 7, 8, 9]).flat_columns, np.array([1, 4, 7, 2, 5, 8, 3, 6, 9], dtype=np.float32)
)
np.testing.assert_array_equal(
    rr.components.TransformMat3x3([[1, 2, 3], [4, 5, 6], [7, 8, 9]]).flat_columns,
    np.array([1, 4, 7, 2, 5, 8, 3, 6, 9], dtype=np.float32),
)

If you want to construct a matrix from a list of columns instead, use the named columns parameter:

np.testing.assert_array_equal(
    rr.components.TransformMat3x3(columns=[1, 2, 3, 4, 5, 6, 7, 8, 9]).flat_columns,
    np.array([1, 2, 3, 4, 5, 6, 7, 8, 9], dtype=np.float32),
)
np.testing.assert_array_equal(
    rr.components.TransformMat3x3(columns=[[1, 2, 3], [4, 5, 6], [7, 8, 9]]).flat_columns,
    np.array([1, 2, 3, 4, 5, 6, 7, 8, 9], dtype=np.float32),
)

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.

TransformMat3x3Batch

Bases: Mat3x3Batch, 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.

TransformRelation

Bases: Enum

Component: Specifies relation a spatial transform describes.

ChildFromParent class-attribute instance-attribute

ChildFromParent = 2

The transform describes how to transform into the child entity's space.

E.g. a translation of (0, 1, 0) with this components.TransformRelation logged at parent/child means that from the point of view of parent, parent/child is translated -1 unit along parent's Y axis. From perspective of parent/child, the parent entity is translated 1 unit along parent/child's Y axis.

ParentFromChild class-attribute instance-attribute

ParentFromChild = 1

The transform describes how to transform into the parent entity's space.

E.g. a translation of (0, 1, 0) with this components.TransformRelation logged at parent/child means that from the point of view of parent, parent/child is translated 1 unit along parent's Y axis. From perspective of parent/child, the parent entity is translated -1 unit along parent/child's Y axis.

__str__

def __str__() -> str

Returns the variant name.

auto classmethod

def auto(
    val: str | int | TransformRelation,
) -> TransformRelation

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

TransformRelationBatch

Bases: BaseBatch[TransformRelationArrayLike], 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.

Translation3D

Bases: Vec3D, ComponentMixin

Component: A translation vector in 3D space.

__init__

def __init__(xyz: Vec3DLike) -> None

Create a new instance of the Vec3D 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.

Translation3DBatch

Bases: Vec3DBatch, 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.

TriangleIndices

Bases: UVec3D, ComponentMixin

Component: The three indices of a triangle in a triangle mesh.

__init__

def __init__(xyz: UVec3DLike) -> None

Create a new instance of the UVec3D 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.

TriangleIndicesBatch

Bases: UVec3DBatch, 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.

ValueRange

Bases: Range1D, ComponentMixin

Component: Range of expected or valid values, specifying a lower and upper bound.

⚠️ This type is unstable and may change significantly in a way that the data won't be backwards compatible.

__init__

def __init__(range: Range1DLike) -> None

Create a new instance of the Range1D 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.

ValueRangeBatch

Bases: Range1DBatch, 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.

Vector2D

Bases: Vec2D, ComponentMixin

Component: A vector in 2D space.

__init__

def __init__(xy: Vec2DLike) -> None

Create a new instance of the Vec2D 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.

Vector2DBatch

Bases: Vec2DBatch, 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.

Vector3D

Bases: Vec3D, ComponentMixin

Component: A vector in 3D space.

__init__

def __init__(xyz: Vec3DLike) -> None

Create a new instance of the Vec3D 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.

Vector3DBatch

Bases: Vec3DBatch, 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.

VideoCodec

Bases: Enum

Component: The codec used to encode video stored in components.VideoSample.

Support of these codecs by the Rerun Viewer is platform dependent. For more details see check the video reference.

⚠️ This type is unstable and may change significantly in a way that the data won't be backwards compatible.

AV1 class-attribute instance-attribute

AV1 = 1635135537

AOMedia Video 1 (AV1)

See https://en.wikipedia.org/wiki/AV1

components.VideoSamples using this codec should be formatted according the "Low overhead bitstream format", as specified in Section 5.2 of the AV1 specification. Each sample should be formatted as a sequence of OBUs (Open Bitstream Units) long enough to decode at least one video frame. Samples containing keyframes must include a sequence header OBU before the KEY_FRAME OBU to enable extraction of frame dimensions, bit depth, and color information. INTRA_ONLY frames are not treated as keyframes since they may reference existing decoder state.

Enum value is the fourcc for 'av01' (the WebCodec string assigned to this codec) in big endian.

H264 class-attribute instance-attribute

H264 = 1635148593

Advanced Video Coding (AVC/H.264)

See https://en.wikipedia.org/wiki/Advanced_Video_Coding

components.VideoSamples using this codec should be formatted according to Annex B specification. (Note that this is different from AVCC format found in MP4 files. To learn more about Annex B, check for instance https://membrane.stream/learn/h264/3) Key frames (IDR) require inclusion of a SPS (Sequence Parameter Set)

Enum value is the fourcc for 'avc1' (the WebCodec string assigned to this codec) in big endian.

H265 class-attribute instance-attribute

H265 = 1751479857

High Efficiency Video Coding (HEVC/H.265)

See https://en.wikipedia.org/wiki/High_Efficiency_Video_Coding

components.VideoSamples using this codec should be formatted according to Annex B specification. (Note that this is different from AVCC format found in MP4 files. To learn more about Annex B, check for instance https://membrane.stream/learn/h264/3) Key frames (IRAP) require inclusion of a SPS (Sequence Parameter Set)

Enum value is the fourcc for 'hev1' (the WebCodec string assigned to this codec) in big endian.

VP8 class-attribute instance-attribute

VP8 = 1987063864

VP8

See https://en.wikipedia.org/wiki/VP8

Enum value is the fourcc for 'vp08' (the WebCodec string assigned to this codec) in big endian.

VP9 class-attribute instance-attribute

VP9 = 1987063865

VP9

See https://en.wikipedia.org/wiki/VP9

Enum value is the fourcc for 'vp09' (the WebCodec string assigned to this codec) in big endian.

__str__

def __str__() -> str

Returns the variant name.

auto classmethod

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

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

VideoCodecBatch

Bases: BaseBatch[VideoCodecArrayLike], 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.

VideoSample

Bases: Blob, ComponentMixin

Component: Video sample data (also known as "video chunk").

Each video sample must contain enough data for exactly one video frame (this restriction may be relaxed in the future for some codecs).

Keyframes may require additional data, for details see components.VideoCodec.

__init__

def __init__(data: BlobLike) -> None

Create a new instance of the Blob 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.

VideoSampleBatch

Bases: BlobBatch, 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.

VideoTimestamp

Bases: VideoTimestampExt, VideoTimestamp, ComponentMixin

Component: Timestamp inside a archetypes.AssetVideo.

__init__

def __init__(
    *,
    nanoseconds: int | None = None,
    seconds: float | None = None,
) -> None

Create a new instance of the VideoTimestamp component.

PARAMETER	DESCRIPTION
nanoseconds	Presentation timestamp in nanoseconds. Mutually exclusive with seconds. TYPE: int | None DEFAULT: None
seconds	Presentation timestamp in seconds. Mutually exclusive with nanoseconds. TYPE: float | 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.

milliseconds staticmethod

def milliseconds(
    milliseconds: ArrayLike,
) -> VideoTimestampBatch

Create a video timestamp batch from milliseconds since video start.

PARAMETER	DESCRIPTION
milliseconds	Timestamp values in milliseconds since video start. TYPE: ArrayLike

nanoseconds staticmethod

def nanoseconds(nanoseconds: ArrayLike) -> VideoTimestampBatch

Create a video timestamp batch from nanoseconds since video start.

PARAMETER	DESCRIPTION
nanoseconds	Timestamp values in nanoseconds since video start. TYPE: ArrayLike

seconds staticmethod

def seconds(seconds: ArrayLike) -> VideoTimestampBatch

Create a video timestamp batch from seconds since video start.

PARAMETER	DESCRIPTION
seconds	Timestamp values in seconds since video start. TYPE: ArrayLike

VideoTimestampBatch

Bases: VideoTimestampBatch, 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.

ViewCoordinates

Bases: ViewCoordinatesExt, ViewCoordinates, ComponentMixin

Component: How we interpret the coordinate system of an entity/space.

For instance: What is "up"? What does the Z axis mean?

The three coordinates are always ordered as [x, y, z].

For example [Right, Down, Forward] means that the X axis points to the right, the Y axis points down, and the Z axis points forward.

⚠ Rerun does not yet support left-handed coordinate systems.

The following constants are used to represent the different directions: * Up = 1 * Down = 2 * Right = 3 * Left = 4 * Forward = 5 * Back = 6

⚠️ This type is unstable and may change significantly in a way that the data won't be backwards compatible.

BDL class-attribute instance-attribute

BDL: ViewCoordinates = None

X=Back, Y=Down, Z=Left

⚠️ This is a left-handed coordinate system, which is not yet supported by Rerun.

BDR class-attribute instance-attribute

BDR: ViewCoordinates = None

X=Back, Y=Down, Z=Right

BLD class-attribute instance-attribute

BLD: ViewCoordinates = None

X=Back, Y=Left, Z=Down

BLU class-attribute instance-attribute

BLU: ViewCoordinates = None

X=Back, Y=Left, Z=Up

⚠️ This is a left-handed coordinate system, which is not yet supported by Rerun.

BRD class-attribute instance-attribute

BRD: ViewCoordinates = None

X=Back, Y=Right, Z=Down

⚠️ This is a left-handed coordinate system, which is not yet supported by Rerun.

BRU class-attribute instance-attribute

BRU: ViewCoordinates = None

X=Back, Y=Right, Z=Up

BUL class-attribute instance-attribute

BUL: ViewCoordinates = None

X=Back, Y=Up, Z=Left

BUR class-attribute instance-attribute

BUR: ViewCoordinates = None

X=Back, Y=Up, Z=Right

⚠️ This is a left-handed coordinate system, which is not yet supported by Rerun.

DBL class-attribute instance-attribute

DBL: ViewCoordinates = None

X=Down, Y=Back, Z=Left

DBR class-attribute instance-attribute

DBR: ViewCoordinates = None

X=Down, Y=Back, Z=Right

⚠️ This is a left-handed coordinate system, which is not yet supported by Rerun.

DFL class-attribute instance-attribute

DFL: ViewCoordinates = None

X=Down, Y=Forward, Z=Left

⚠️ This is a left-handed coordinate system, which is not yet supported by Rerun.

DFR class-attribute instance-attribute

DFR: ViewCoordinates = None

X=Down, Y=Forward, Z=Right

DLB class-attribute instance-attribute

DLB: ViewCoordinates = None

X=Down, Y=Left, Z=Back

⚠️ This is a left-handed coordinate system, which is not yet supported by Rerun.

DLF class-attribute instance-attribute

DLF: ViewCoordinates = None

X=Down, Y=Left, Z=Forward

DRB class-attribute instance-attribute

DRB: ViewCoordinates = None

X=Down, Y=Right, Z=Back

DRF class-attribute instance-attribute

DRF: ViewCoordinates = None

X=Down, Y=Right, Z=Forward

⚠️ This is a left-handed coordinate system, which is not yet supported by Rerun.

FDL class-attribute instance-attribute

FDL: ViewCoordinates = None

X=Forward, Y=Down, Z=Left

FDR class-attribute instance-attribute

FDR: ViewCoordinates = None

X=Forward, Y=Down, Z=Right

⚠️ This is a left-handed coordinate system, which is not yet supported by Rerun.

FLD class-attribute instance-attribute

FLD: ViewCoordinates = None

X=Forward, Y=Left, Z=Down

⚠️ This is a left-handed coordinate system, which is not yet supported by Rerun.

FLU class-attribute instance-attribute

FLU: ViewCoordinates = None

X=Forward, Y=Left, Z=Up

FRD class-attribute instance-attribute

FRD: ViewCoordinates = None

X=Forward, Y=Right, Z=Down

FRU class-attribute instance-attribute

FRU: ViewCoordinates = None

X=Forward, Y=Right, Z=Up

⚠️ This is a left-handed coordinate system, which is not yet supported by Rerun.

FUL class-attribute instance-attribute

FUL: ViewCoordinates = None

X=Forward, Y=Up, Z=Left

⚠️ This is a left-handed coordinate system, which is not yet supported by Rerun.

FUR class-attribute instance-attribute

FUR: ViewCoordinates = None

X=Forward, Y=Up, Z=Right

LBD class-attribute instance-attribute

LBD: ViewCoordinates = None

X=Left, Y=Back, Z=Down

⚠️ This is a left-handed coordinate system, which is not yet supported by Rerun.

LBU class-attribute instance-attribute

LBU: ViewCoordinates = None

X=Left, Y=Back, Z=Up

LDB class-attribute instance-attribute

LDB: ViewCoordinates = None

X=Left, Y=Down, Z=Back

LDF class-attribute instance-attribute

LDF: ViewCoordinates = None

X=Left, Y=Down, Z=Forward

⚠️ This is a left-handed coordinate system, which is not yet supported by Rerun.

LEFT_HAND_X_DOWN class-attribute instance-attribute

LEFT_HAND_X_DOWN: ViewCoordinates = None

X=Down, Y=Right, Z=Forward

⚠️ This is a left-handed coordinate system, which is not yet supported by Rerun.

LEFT_HAND_X_UP class-attribute instance-attribute

LEFT_HAND_X_UP: ViewCoordinates = None

X=Up, Y=Right, Z=Back

⚠️ This is a left-handed coordinate system, which is not yet supported by Rerun.

LEFT_HAND_Y_DOWN class-attribute instance-attribute

LEFT_HAND_Y_DOWN: ViewCoordinates = None

X=Right, Y=Down, Z=Back

⚠️ This is a left-handed coordinate system, which is not yet supported by Rerun.

LEFT_HAND_Y_UP class-attribute instance-attribute

LEFT_HAND_Y_UP: ViewCoordinates = None

X=Right, Y=Up, Z=Forward

⚠️ This is a left-handed coordinate system, which is not yet supported by Rerun.

LEFT_HAND_Z_DOWN class-attribute instance-attribute

LEFT_HAND_Z_DOWN: ViewCoordinates = None

X=Right, Y=Forward, Z=Down

⚠️ This is a left-handed coordinate system, which is not yet supported by Rerun.

LEFT_HAND_Z_UP class-attribute instance-attribute

LEFT_HAND_Z_UP: ViewCoordinates = None

X=Right, Y=Back, Z=Up

⚠️ This is a left-handed coordinate system, which is not yet supported by Rerun.

LFD class-attribute instance-attribute

LFD: ViewCoordinates = None

X=Left, Y=Forward, Z=Down

LFU class-attribute instance-attribute

LFU: ViewCoordinates = None

X=Left, Y=Forward, Z=Up

⚠️ This is a left-handed coordinate system, which is not yet supported by Rerun.

LUB class-attribute instance-attribute

LUB: ViewCoordinates = None

X=Left, Y=Up, Z=Back

⚠️ This is a left-handed coordinate system, which is not yet supported by Rerun.

LUF class-attribute instance-attribute

LUF: ViewCoordinates = None

X=Left, Y=Up, Z=Forward

RBD class-attribute instance-attribute

RBD: ViewCoordinates = None

X=Right, Y=Back, Z=Down

RBU class-attribute instance-attribute

RBU: ViewCoordinates = None

X=Right, Y=Back, Z=Up

⚠️ This is a left-handed coordinate system, which is not yet supported by Rerun.

RDB class-attribute instance-attribute

RDB: ViewCoordinates = None

X=Right, Y=Down, Z=Back

⚠️ This is a left-handed coordinate system, which is not yet supported by Rerun.

RDF class-attribute instance-attribute

RDF: ViewCoordinates = None

X=Right, Y=Down, Z=Forward

RFD class-attribute instance-attribute

RFD: ViewCoordinates = None

X=Right, Y=Forward, Z=Down

⚠️ This is a left-handed coordinate system, which is not yet supported by Rerun.

RFU class-attribute instance-attribute

RFU: ViewCoordinates = None

X=Right, Y=Forward, Z=Up

RIGHT_HAND_X_DOWN class-attribute instance-attribute

RIGHT_HAND_X_DOWN: ViewCoordinates = None

X=Down, Y=Right, Z=Back

RIGHT_HAND_X_UP class-attribute instance-attribute

RIGHT_HAND_X_UP: ViewCoordinates = None

X=Up, Y=Right, Z=Forward

RIGHT_HAND_Y_DOWN class-attribute instance-attribute

RIGHT_HAND_Y_DOWN: ViewCoordinates = None

X=Right, Y=Down, Z=Forward

RIGHT_HAND_Y_UP class-attribute instance-attribute

RIGHT_HAND_Y_UP: ViewCoordinates = None

X=Right, Y=Up, Z=Back

RIGHT_HAND_Z_DOWN class-attribute instance-attribute

RIGHT_HAND_Z_DOWN: ViewCoordinates = None

X=Right, Y=Back, Z=Down

RIGHT_HAND_Z_UP class-attribute instance-attribute

RIGHT_HAND_Z_UP: ViewCoordinates = None

X=Right, Y=Forward, Z=Up

RUB class-attribute instance-attribute

RUB: ViewCoordinates = None

X=Right, Y=Up, Z=Back

RUF class-attribute instance-attribute

RUF: ViewCoordinates = None

X=Right, Y=Up, Z=Forward

⚠️ This is a left-handed coordinate system, which is not yet supported by Rerun.

UBL class-attribute instance-attribute

UBL: ViewCoordinates = None

X=Up, Y=Back, Z=Left

⚠️ This is a left-handed coordinate system, which is not yet supported by Rerun.

UBR class-attribute instance-attribute

UBR: ViewCoordinates = None

X=Up, Y=Back, Z=Right

UFL class-attribute instance-attribute

UFL: ViewCoordinates = None

X=Up, Y=Forward, Z=Left

UFR class-attribute instance-attribute

UFR: ViewCoordinates = None

X=Up, Y=Forward, Z=Right

⚠️ This is a left-handed coordinate system, which is not yet supported by Rerun.

ULB class-attribute instance-attribute

ULB: ViewCoordinates = None

X=Up, Y=Left, Z=Back

ULF class-attribute instance-attribute

ULF: ViewCoordinates = None

X=Up, Y=Left, Z=Forward

⚠️ This is a left-handed coordinate system, which is not yet supported by Rerun.

URB class-attribute instance-attribute

URB: ViewCoordinates = None

X=Up, Y=Right, Z=Back

⚠️ This is a left-handed coordinate system, which is not yet supported by Rerun.

URF class-attribute instance-attribute

URF: ViewCoordinates = None

X=Up, Y=Right, Z=Forward

__init__

def __init__(coordinates: ViewCoordinatesLike) -> None

Create a new instance of the ViewCoordinates datatype.

PARAMETER	DESCRIPTION
coordinates	The directions of the [x, y, z] axes. TYPE: ViewCoordinatesLike

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.

ViewCoordinatesBatch

Bases: ViewCoordinatesBatch, 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.

Visible

Bases: Bool, ComponentMixin

Component: Whether the container, view, entity or instance is currently visible.

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

VisibleBatch

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.

VoxelIndex

Bases: IVec3D, ComponentMixin

Component: Integer index of a voxel in a sparse 3D voxel grid.

The voxel center in local grid coordinates is (index + 0.5) * voxel_size.

__init__

def __init__(xyz: IVec3DLike) -> None

Create a new instance of the IVec3D 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.

VoxelIndexBatch

Bases: IVec3DBatch, 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.

VoxelSize

Bases: Vec3D, ComponentMixin

Component: The scene-unit dimensions of one voxel in a sparse 3D voxel grid.

Each component is the size of a voxel along the corresponding local grid axis. All components must be finite and positive.

__init__

def __init__(xyz: Vec3DLike) -> None

Create a new instance of the Vec3D 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.

VoxelSizeBatch

Bases: Vec3DBatch, 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.

VoxelValue

Bases: Float32, ComponentMixin

Component: Optional scalar occupancy or value associated with a voxel.

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

VoxelValueBatch

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.