pymomentum-cpu 0.1.78.post11__cp313-cp313-win_amd64.whl

include/rerun/blueprint/archetypes/container_blueprint.hpp

@@ -0,0 +1,259 @@
+// DO NOT EDIT! This file was auto-generated by crates/build/re_types_builder/src/codegen/cpp/mod.rs
+// Based on "crates/store/re_types/definitions/rerun/blueprint/archetypes/container_blueprint.fbs".
+
+#pragma once
+
+#include "../../blueprint/components/active_tab.hpp"
+#include "../../blueprint/components/column_share.hpp"
+#include "../../blueprint/components/container_kind.hpp"
+#include "../../blueprint/components/grid_columns.hpp"
+#include "../../blueprint/components/included_content.hpp"
+#include "../../blueprint/components/row_share.hpp"
+#include "../../collection.hpp"
+#include "../../component_batch.hpp"
+#include "../../component_column.hpp"
+#include "../../components/name.hpp"
+#include "../../components/visible.hpp"
+#include "../../indicator_component.hpp"
+#include "../../result.hpp"
+
+#include <cstdint>
+#include <optional>
+#include <utility>
+#include <vector>
+
+namespace rerun::blueprint::archetypes {
+    /// **Archetype**: The description of a container.
+    ///
+    /// ⚠ **This type is _unstable_ and may change significantly in a way that the data won't be backwards compatible.**
+    ///
+    struct ContainerBlueprint {
+        /// The class of the view.
+        std::optional<ComponentBatch> container_kind;
+
+        /// The name of the container.
+        std::optional<ComponentBatch> display_name;
+
+        /// `ContainerId`s or `ViewId`s that are children of this container.
+        std::optional<ComponentBatch> contents;
+
+        /// The layout shares of each column in the container.
+        ///
+        /// For `components::ContainerKind::Horizontal` containers, the length of this list should always match the number of contents.
+        ///
+        /// Ignored for `components::ContainerKind::Vertical` containers.
+        std::optional<ComponentBatch> col_shares;
+
+        /// The layout shares of each row of the container.
+        ///
+        /// For `components::ContainerKind::Vertical` containers, the length of this list should always match the number of contents.
+        ///
+        /// Ignored for `components::ContainerKind::Horizontal` containers.
+        std::optional<ComponentBatch> row_shares;
+
+        /// Which tab is active.
+        ///
+        /// Only applies to `Tabs` containers.
+        std::optional<ComponentBatch> active_tab;
+
+        /// Whether this container is visible.
+        ///
+        /// Defaults to true if not specified.
+        std::optional<ComponentBatch> visible;
+
+        /// How many columns this grid should have.
+        ///
+        /// If unset, the grid layout will be auto.
+        ///
+        /// Ignored for `components::ContainerKind::Horizontal`/`components::ContainerKind::Vertical` containers.
+        std::optional<ComponentBatch> grid_columns;
+
+      public:
+        static constexpr const char IndicatorComponentName[] =
+            "rerun.blueprint.components.ContainerBlueprintIndicator";
+
+        /// Indicator component, used to identify the archetype when converting to a list of components.
+        using IndicatorComponent = rerun::components::IndicatorComponent<IndicatorComponentName>;
+        /// The name of the archetype as used in `ComponentDescriptor`s.
+        static constexpr const char ArchetypeName[] =
+            "rerun.blueprint.archetypes.ContainerBlueprint";
+
+        /// `ComponentDescriptor` for the `container_kind` field.
+        static constexpr auto Descriptor_container_kind = ComponentDescriptor(
+            ArchetypeName, "container_kind",
+            Loggable<rerun::blueprint::components::ContainerKind>::Descriptor.component_name
+        );
+        /// `ComponentDescriptor` for the `display_name` field.
+        static constexpr auto Descriptor_display_name = ComponentDescriptor(
+            ArchetypeName, "display_name",
+            Loggable<rerun::components::Name>::Descriptor.component_name
+        );
+        /// `ComponentDescriptor` for the `contents` field.
+        static constexpr auto Descriptor_contents = ComponentDescriptor(
+            ArchetypeName, "contents",
+            Loggable<rerun::blueprint::components::IncludedContent>::Descriptor.component_name
+        );
+        /// `ComponentDescriptor` for the `col_shares` field.
+        static constexpr auto Descriptor_col_shares = ComponentDescriptor(
+            ArchetypeName, "col_shares",
+            Loggable<rerun::blueprint::components::ColumnShare>::Descriptor.component_name
+        );
+        /// `ComponentDescriptor` for the `row_shares` field.
+        static constexpr auto Descriptor_row_shares = ComponentDescriptor(
+            ArchetypeName, "row_shares",
+            Loggable<rerun::blueprint::components::RowShare>::Descriptor.component_name
+        );
+        /// `ComponentDescriptor` for the `active_tab` field.
+        static constexpr auto Descriptor_active_tab = ComponentDescriptor(
+            ArchetypeName, "active_tab",
+            Loggable<rerun::blueprint::components::ActiveTab>::Descriptor.component_name
+        );
+        /// `ComponentDescriptor` for the `visible` field.
+        static constexpr auto Descriptor_visible = ComponentDescriptor(
+            ArchetypeName, "visible",
+            Loggable<rerun::components::Visible>::Descriptor.component_name
+        );
+        /// `ComponentDescriptor` for the `grid_columns` field.
+        static constexpr auto Descriptor_grid_columns = ComponentDescriptor(
+            ArchetypeName, "grid_columns",
+            Loggable<rerun::blueprint::components::GridColumns>::Descriptor.component_name
+        );
+
+      public:
+        ContainerBlueprint() = default;
+        ContainerBlueprint(ContainerBlueprint&& other) = default;
+        ContainerBlueprint(const ContainerBlueprint& other) = default;
+        ContainerBlueprint& operator=(const ContainerBlueprint& other) = default;
+        ContainerBlueprint& operator=(ContainerBlueprint&& other) = default;
+
+        explicit ContainerBlueprint(rerun::blueprint::components::ContainerKind _container_kind)
+            : container_kind(ComponentBatch::from_loggable(
+                                 std::move(_container_kind), Descriptor_container_kind
+              )
+                                 .value_or_throw()) {}
+
+        /// Update only some specific fields of a `ContainerBlueprint`.
+        static ContainerBlueprint update_fields() {
+            return ContainerBlueprint();
+        }
+
+        /// Clear all the fields of a `ContainerBlueprint`.
+        static ContainerBlueprint clear_fields();
+
+        /// The class of the view.
+        ContainerBlueprint with_container_kind(
+            const rerun::blueprint::components::ContainerKind& _container_kind
+        ) && {
+            container_kind =
+                ComponentBatch::from_loggable(_container_kind, Descriptor_container_kind)
+                    .value_or_throw();
+            return std::move(*this);
+        }
+
+        /// The name of the container.
+        ContainerBlueprint with_display_name(const rerun::components::Name& _display_name) && {
+            display_name = ComponentBatch::from_loggable(_display_name, Descriptor_display_name)
+                               .value_or_throw();
+            return std::move(*this);
+        }
+
+        /// `ContainerId`s or `ViewId`s that are children of this container.
+        ContainerBlueprint with_contents(
+            const Collection<rerun::blueprint::components::IncludedContent>& _contents
+        ) && {
+            contents =
+                ComponentBatch::from_loggable(_contents, Descriptor_contents).value_or_throw();
+            return std::move(*this);
+        }
+
+        /// The layout shares of each column in the container.
+        ///
+        /// For `components::ContainerKind::Horizontal` containers, the length of this list should always match the number of contents.
+        ///
+        /// Ignored for `components::ContainerKind::Vertical` containers.
+        ContainerBlueprint with_col_shares(
+            const Collection<rerun::blueprint::components::ColumnShare>& _col_shares
+        ) && {
+            col_shares =
+                ComponentBatch::from_loggable(_col_shares, Descriptor_col_shares).value_or_throw();
+            return std::move(*this);
+        }
+
+        /// The layout shares of each row of the container.
+        ///
+        /// For `components::ContainerKind::Vertical` containers, the length of this list should always match the number of contents.
+        ///
+        /// Ignored for `components::ContainerKind::Horizontal` containers.
+        ContainerBlueprint with_row_shares(
+            const Collection<rerun::blueprint::components::RowShare>& _row_shares
+        ) && {
+            row_shares =
+                ComponentBatch::from_loggable(_row_shares, Descriptor_row_shares).value_or_throw();
+            return std::move(*this);
+        }
+
+        /// Which tab is active.
+        ///
+        /// Only applies to `Tabs` containers.
+        ContainerBlueprint with_active_tab(
+            const rerun::blueprint::components::ActiveTab& _active_tab
+        ) && {
+            active_tab =
+                ComponentBatch::from_loggable(_active_tab, Descriptor_active_tab).value_or_throw();
+            return std::move(*this);
+        }
+
+        /// Whether this container is visible.
+        ///
+        /// Defaults to true if not specified.
+        ContainerBlueprint with_visible(const rerun::components::Visible& _visible) && {
+            visible = ComponentBatch::from_loggable(_visible, Descriptor_visible).value_or_throw();
+            return std::move(*this);
+        }
+
+        /// How many columns this grid should have.
+        ///
+        /// If unset, the grid layout will be auto.
+        ///
+        /// Ignored for `components::ContainerKind::Horizontal`/`components::ContainerKind::Vertical` containers.
+        ContainerBlueprint with_grid_columns(
+            const rerun::blueprint::components::GridColumns& _grid_columns
+        ) && {
+            grid_columns = ComponentBatch::from_loggable(_grid_columns, Descriptor_grid_columns)
+                               .value_or_throw();
+            return std::move(*this);
+        }
+
+        /// Partitions the component data into multiple sub-batches.
+        ///
+        /// Specifically, this transforms the existing `ComponentBatch` data into `ComponentColumn`s
+        /// instead, via `ComponentBatch::partitioned`.
+        ///
+        /// This makes it possible to use `RecordingStream::send_columns` to send columnar data directly into Rerun.
+        ///
+        /// The specified `lengths` must sum to the total length of the component batch.
+        Collection<ComponentColumn> columns(const Collection<uint32_t>& lengths_);
+
+        /// Partitions the component data into unit-length sub-batches.
+        ///
+        /// This is semantically similar to calling `columns` with `std::vector<uint32_t>(n, 1)`,
+        /// where `n` is automatically guessed.
+        Collection<ComponentColumn> columns();
+    };
+
+} // namespace rerun::blueprint::archetypes
+
+namespace rerun {
+    /// \private
+    template <typename T>
+    struct AsComponents;
+
+    /// \private
+    template <>
+    struct AsComponents<blueprint::archetypes::ContainerBlueprint> {
+        /// Serialize all set component batches.
+        static Result<Collection<ComponentBatch>> as_batches(
+            const blueprint::archetypes::ContainerBlueprint& archetype
+        );
+    };
+} // namespace rerun

include/rerun/blueprint/archetypes/dataframe_query.hpp

@@ -0,0 +1,178 @@
+// DO NOT EDIT! This file was auto-generated by crates/build/re_types_builder/src/codegen/cpp/mod.rs
+// Based on "crates/store/re_types/definitions/rerun/blueprint/archetypes/dataframe_query.fbs".
+
+#pragma once
+
+#include "../../blueprint/components/apply_latest_at.hpp"
+#include "../../blueprint/components/filter_by_range.hpp"
+#include "../../blueprint/components/filter_is_not_null.hpp"
+#include "../../blueprint/components/selected_columns.hpp"
+#include "../../blueprint/components/timeline_name.hpp"
+#include "../../collection.hpp"
+#include "../../component_batch.hpp"
+#include "../../component_column.hpp"
+#include "../../indicator_component.hpp"
+#include "../../result.hpp"
+
+#include <cstdint>
+#include <optional>
+#include <utility>
+#include <vector>
+
+namespace rerun::blueprint::archetypes {
+    /// **Archetype**: The query for the dataframe view.
+    ///
+    /// ⚠ **This type is _unstable_ and may change significantly in a way that the data won't be backwards compatible.**
+    ///
+    struct DataframeQuery {
+        /// The timeline for this query.
+        ///
+        /// If unset, the timeline currently active on the time panel is used.
+        std::optional<ComponentBatch> timeline;
+
+        /// If provided, only rows whose timestamp is within this range will be shown.
+        ///
+        /// Note: will be unset as soon as `timeline` is changed.
+        std::optional<ComponentBatch> filter_by_range;
+
+        /// If provided, only show rows which contains a logged event for the specified component.
+        std::optional<ComponentBatch> filter_is_not_null;
+
+        /// Should empty cells be filled with latest-at queries?
+        std::optional<ComponentBatch> apply_latest_at;
+
+        /// Selected columns. If unset, all columns are selected.
+        std::optional<ComponentBatch> select;
+
+      public:
+        static constexpr const char IndicatorComponentName[] =
+            "rerun.blueprint.components.DataframeQueryIndicator";
+
+        /// Indicator component, used to identify the archetype when converting to a list of components.
+        using IndicatorComponent = rerun::components::IndicatorComponent<IndicatorComponentName>;
+        /// The name of the archetype as used in `ComponentDescriptor`s.
+        static constexpr const char ArchetypeName[] = "rerun.blueprint.archetypes.DataframeQuery";
+
+        /// `ComponentDescriptor` for the `timeline` field.
+        static constexpr auto Descriptor_timeline = ComponentDescriptor(
+            ArchetypeName, "timeline",
+            Loggable<rerun::blueprint::components::TimelineName>::Descriptor.component_name
+        );
+        /// `ComponentDescriptor` for the `filter_by_range` field.
+        static constexpr auto Descriptor_filter_by_range = ComponentDescriptor(
+            ArchetypeName, "filter_by_range",
+            Loggable<rerun::blueprint::components::FilterByRange>::Descriptor.component_name
+        );
+        /// `ComponentDescriptor` for the `filter_is_not_null` field.
+        static constexpr auto Descriptor_filter_is_not_null = ComponentDescriptor(
+            ArchetypeName, "filter_is_not_null",
+            Loggable<rerun::blueprint::components::FilterIsNotNull>::Descriptor.component_name
+        );
+        /// `ComponentDescriptor` for the `apply_latest_at` field.
+        static constexpr auto Descriptor_apply_latest_at = ComponentDescriptor(
+            ArchetypeName, "apply_latest_at",
+            Loggable<rerun::blueprint::components::ApplyLatestAt>::Descriptor.component_name
+        );
+        /// `ComponentDescriptor` for the `select` field.
+        static constexpr auto Descriptor_select = ComponentDescriptor(
+            ArchetypeName, "select",
+            Loggable<rerun::blueprint::components::SelectedColumns>::Descriptor.component_name
+        );
+
+      public:
+        DataframeQuery() = default;
+        DataframeQuery(DataframeQuery&& other) = default;
+        DataframeQuery(const DataframeQuery& other) = default;
+        DataframeQuery& operator=(const DataframeQuery& other) = default;
+        DataframeQuery& operator=(DataframeQuery&& other) = default;
+
+        /// Update only some specific fields of a `DataframeQuery`.
+        static DataframeQuery update_fields() {
+            return DataframeQuery();
+        }
+
+        /// Clear all the fields of a `DataframeQuery`.
+        static DataframeQuery clear_fields();
+
+        /// The timeline for this query.
+        ///
+        /// If unset, the timeline currently active on the time panel is used.
+        DataframeQuery with_timeline(const rerun::blueprint::components::TimelineName& _timeline
+        ) && {
+            timeline =
+                ComponentBatch::from_loggable(_timeline, Descriptor_timeline).value_or_throw();
+            return std::move(*this);
+        }
+
+        /// If provided, only rows whose timestamp is within this range will be shown.
+        ///
+        /// Note: will be unset as soon as `timeline` is changed.
+        DataframeQuery with_filter_by_range(
+            const rerun::blueprint::components::FilterByRange& _filter_by_range
+        ) && {
+            filter_by_range =
+                ComponentBatch::from_loggable(_filter_by_range, Descriptor_filter_by_range)
+                    .value_or_throw();
+            return std::move(*this);
+        }
+
+        /// If provided, only show rows which contains a logged event for the specified component.
+        DataframeQuery with_filter_is_not_null(
+            const rerun::blueprint::components::FilterIsNotNull& _filter_is_not_null
+        ) && {
+            filter_is_not_null =
+                ComponentBatch::from_loggable(_filter_is_not_null, Descriptor_filter_is_not_null)
+                    .value_or_throw();
+            return std::move(*this);
+        }
+
+        /// Should empty cells be filled with latest-at queries?
+        DataframeQuery with_apply_latest_at(
+            const rerun::blueprint::components::ApplyLatestAt& _apply_latest_at
+        ) && {
+            apply_latest_at =
+                ComponentBatch::from_loggable(_apply_latest_at, Descriptor_apply_latest_at)
+                    .value_or_throw();
+            return std::move(*this);
+        }
+
+        /// Selected columns. If unset, all columns are selected.
+        DataframeQuery with_select(const rerun::blueprint::components::SelectedColumns& _select
+        ) && {
+            select = ComponentBatch::from_loggable(_select, Descriptor_select).value_or_throw();
+            return std::move(*this);
+        }
+
+        /// Partitions the component data into multiple sub-batches.
+        ///
+        /// Specifically, this transforms the existing `ComponentBatch` data into `ComponentColumn`s
+        /// instead, via `ComponentBatch::partitioned`.
+        ///
+        /// This makes it possible to use `RecordingStream::send_columns` to send columnar data directly into Rerun.
+        ///
+        /// The specified `lengths` must sum to the total length of the component batch.
+        Collection<ComponentColumn> columns(const Collection<uint32_t>& lengths_);
+
+        /// Partitions the component data into unit-length sub-batches.
+        ///
+        /// This is semantically similar to calling `columns` with `std::vector<uint32_t>(n, 1)`,
+        /// where `n` is automatically guessed.
+        Collection<ComponentColumn> columns();
+    };
+
+} // namespace rerun::blueprint::archetypes
+
+namespace rerun {
+    /// \private
+    template <typename T>
+    struct AsComponents;
+
+    /// \private
+    template <>
+    struct AsComponents<blueprint::archetypes::DataframeQuery> {
+        /// Serialize all set component batches.
+        static Result<Collection<ComponentBatch>> as_batches(
+            const blueprint::archetypes::DataframeQuery& archetype
+        );
+    };
+} // namespace rerun

include/rerun/blueprint/archetypes/entity_behavior.hpp

@@ -0,0 +1,130 @@
+// DO NOT EDIT! This file was auto-generated by crates/build/re_types_builder/src/codegen/cpp/mod.rs
+// Based on "crates/store/re_types/definitions/rerun/blueprint/archetypes/entity_behavior.fbs".
+
+#pragma once
+
+#include "../../collection.hpp"
+#include "../../component_batch.hpp"
+#include "../../component_column.hpp"
+#include "../../components/interactive.hpp"
+#include "../../components/visible.hpp"
+#include "../../indicator_component.hpp"
+#include "../../result.hpp"
+
+#include <cstdint>
+#include <optional>
+#include <utility>
+#include <vector>
+
+namespace rerun::blueprint::archetypes {
+    /// **Archetype**: General visualization behavior of an entity.
+    ///
+    /// TODO(#6541): Fields of this archetype currently only have an effect when logged in the blueprint store.
+    struct EntityBehavior {
+        /// Whether the entity can be interacted with.
+        ///
+        /// This property is propagated down the entity hierarchy until another child entity
+        /// sets `interactive` to a different value at which point propagation continues with that value instead.
+        ///
+        /// Defaults to parent's `interactive` value or true if there is no parent.
+        std::optional<ComponentBatch> interactive;
+
+        /// Whether the entity is visible.
+        ///
+        /// This property is propagated down the entity hierarchy until another child entity
+        /// sets `visible` to a different value at which point propagation continues with that value instead.
+        ///
+        /// Defaults to parent's `visible` value or true if there is no parent.
+        std::optional<ComponentBatch> visible;
+
+      public:
+        static constexpr const char IndicatorComponentName[] =
+            "rerun.blueprint.components.EntityBehaviorIndicator";
+
+        /// Indicator component, used to identify the archetype when converting to a list of components.
+        using IndicatorComponent = rerun::components::IndicatorComponent<IndicatorComponentName>;
+        /// The name of the archetype as used in `ComponentDescriptor`s.
+        static constexpr const char ArchetypeName[] = "rerun.blueprint.archetypes.EntityBehavior";
+
+        /// `ComponentDescriptor` for the `interactive` field.
+        static constexpr auto Descriptor_interactive = ComponentDescriptor(
+            ArchetypeName, "interactive",
+            Loggable<rerun::components::Interactive>::Descriptor.component_name
+        );
+        /// `ComponentDescriptor` for the `visible` field.
+        static constexpr auto Descriptor_visible = ComponentDescriptor(
+            ArchetypeName, "visible",
+            Loggable<rerun::components::Visible>::Descriptor.component_name
+        );
+
+      public:
+        EntityBehavior() = default;
+        EntityBehavior(EntityBehavior&& other) = default;
+        EntityBehavior(const EntityBehavior& other) = default;
+        EntityBehavior& operator=(const EntityBehavior& other) = default;
+        EntityBehavior& operator=(EntityBehavior&& other) = default;
+
+        /// Update only some specific fields of a `EntityBehavior`.
+        static EntityBehavior update_fields() {
+            return EntityBehavior();
+        }
+
+        /// Clear all the fields of a `EntityBehavior`.
+        static EntityBehavior clear_fields();
+
+        /// Whether the entity can be interacted with.
+        ///
+        /// This property is propagated down the entity hierarchy until another child entity
+        /// sets `interactive` to a different value at which point propagation continues with that value instead.
+        ///
+        /// Defaults to parent's `interactive` value or true if there is no parent.
+        EntityBehavior with_interactive(const rerun::components::Interactive& _interactive) && {
+            interactive = ComponentBatch::from_loggable(_interactive, Descriptor_interactive)
+                              .value_or_throw();
+            return std::move(*this);
+        }
+
+        /// Whether the entity is visible.
+        ///
+        /// This property is propagated down the entity hierarchy until another child entity
+        /// sets `visible` to a different value at which point propagation continues with that value instead.
+        ///
+        /// Defaults to parent's `visible` value or true if there is no parent.
+        EntityBehavior with_visible(const rerun::components::Visible& _visible) && {
+            visible = ComponentBatch::from_loggable(_visible, Descriptor_visible).value_or_throw();
+            return std::move(*this);
+        }
+
+        /// Partitions the component data into multiple sub-batches.
+        ///
+        /// Specifically, this transforms the existing `ComponentBatch` data into `ComponentColumn`s
+        /// instead, via `ComponentBatch::partitioned`.
+        ///
+        /// This makes it possible to use `RecordingStream::send_columns` to send columnar data directly into Rerun.
+        ///
+        /// The specified `lengths` must sum to the total length of the component batch.
+        Collection<ComponentColumn> columns(const Collection<uint32_t>& lengths_);
+
+        /// Partitions the component data into unit-length sub-batches.
+        ///
+        /// This is semantically similar to calling `columns` with `std::vector<uint32_t>(n, 1)`,
+        /// where `n` is automatically guessed.
+        Collection<ComponentColumn> columns();
+    };
+
+} // namespace rerun::blueprint::archetypes
+
+namespace rerun {
+    /// \private
+    template <typename T>
+    struct AsComponents;
+
+    /// \private
+    template <>
+    struct AsComponents<blueprint::archetypes::EntityBehavior> {
+        /// Serialize all set component batches.
+        static Result<Collection<ComponentBatch>> as_batches(
+            const blueprint::archetypes::EntityBehavior& archetype
+        );
+    };
+} // namespace rerun