pymomentum-cpu 0.0.0__cp312-cp312-manylinux_2_39_x86_64.whl

include/rerun/blueprint/archetypes/visual_bounds2d.hpp

@@ -0,0 +1,109 @@
+// 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/visual_bounds2d.fbs".
+
+#pragma once
+
+#include "../../blueprint/components/visual_bounds2d.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**: Controls the visual bounds of a 2D view.
+    ///
+    /// Everything within these bounds are guaranteed to be visible.
+    /// Somethings outside of these bounds may also be visible due to letterboxing.
+    ///
+    /// If no visual bounds are set, it will be determined automatically,
+    /// based on the bounding-box of the data or other camera information present in the view.
+    ///
+    /// ⚠ **This type is _unstable_ and may change significantly in a way that the data won't be backwards compatible.**
+    ///
+    struct VisualBounds2D {
+        /// Controls the visible range of a 2D view.
+        ///
+        /// Use this to control pan & zoom of the view.
+        std::optional<ComponentBatch> range;
+
+      public:
+        static constexpr const char IndicatorComponentName[] =
+            "rerun.blueprint.components.VisualBounds2DIndicator";
+
+        /// 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.VisualBounds2D";
+
+        /// `ComponentDescriptor` for the `range` field.
+        static constexpr auto Descriptor_range = ComponentDescriptor(
+            ArchetypeName, "range",
+            Loggable<rerun::blueprint::components::VisualBounds2D>::Descriptor.component_name
+        );
+
+      public:
+        VisualBounds2D() = default;
+        VisualBounds2D(VisualBounds2D&& other) = default;
+        VisualBounds2D(const VisualBounds2D& other) = default;
+        VisualBounds2D& operator=(const VisualBounds2D& other) = default;
+        VisualBounds2D& operator=(VisualBounds2D&& other) = default;
+
+        explicit VisualBounds2D(rerun::blueprint::components::VisualBounds2D _range)
+            : range(ComponentBatch::from_loggable(std::move(_range), Descriptor_range)
+                        .value_or_throw()) {}
+
+        /// Update only some specific fields of a `VisualBounds2D`.
+        static VisualBounds2D update_fields() {
+            return VisualBounds2D();
+        }
+
+        /// Clear all the fields of a `VisualBounds2D`.
+        static VisualBounds2D clear_fields();
+
+        /// Controls the visible range of a 2D view.
+        ///
+        /// Use this to control pan & zoom of the view.
+        VisualBounds2D with_range(const rerun::blueprint::components::VisualBounds2D& _range) && {
+            range = ComponentBatch::from_loggable(_range, Descriptor_range).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::VisualBounds2D> {
+        /// Serialize all set component batches.
+        static Result<Collection<ComponentBatch>> as_batches(
+            const blueprint::archetypes::VisualBounds2D& archetype
+        );
+    };
+} // namespace rerun

include/rerun/blueprint/archetypes/visualizer_overrides.hpp

@@ -0,0 +1,113 @@
+// 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/visualizer_overrides.fbs".
+
+#pragma once
+
+#include "../../blueprint/components/visualizer_override.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**: Override the visualizers for an entity.
+    ///
+    /// This archetype is a stop-gap mechanism based on the current implementation details
+    /// of the visualizer system. It is not intended to be a long-term solution, but provides
+    /// enough utility to be useful in the short term.
+    ///
+    /// The long-term solution is likely to be based off: <https://github.com/rerun-io/rerun/issues/6626>
+    ///
+    /// This can only be used as part of blueprints. It will have no effect if used
+    /// in a regular entity.
+    ///
+    /// ⚠ **This type is _unstable_ and may change significantly in a way that the data won't be backwards compatible.**
+    ///
+    struct VisualizerOverrides {
+        /// Names of the visualizers that should be active.
+        std::optional<ComponentBatch> ranges;
+
+      public:
+        static constexpr const char IndicatorComponentName[] =
+            "rerun.blueprint.components.VisualizerOverridesIndicator";
+
+        /// 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.VisualizerOverrides";
+
+        /// `ComponentDescriptor` for the `ranges` field.
+        static constexpr auto Descriptor_ranges = ComponentDescriptor(
+            ArchetypeName, "ranges",
+            Loggable<rerun::blueprint::components::VisualizerOverride>::Descriptor.component_name
+        );
+
+      public:
+        VisualizerOverrides() = default;
+        VisualizerOverrides(VisualizerOverrides&& other) = default;
+        VisualizerOverrides(const VisualizerOverrides& other) = default;
+        VisualizerOverrides& operator=(const VisualizerOverrides& other) = default;
+        VisualizerOverrides& operator=(VisualizerOverrides&& other) = default;
+
+        explicit VisualizerOverrides(
+            Collection<rerun::blueprint::components::VisualizerOverride> _ranges
+        )
+            : ranges(ComponentBatch::from_loggable(std::move(_ranges), Descriptor_ranges)
+                         .value_or_throw()) {}
+
+        /// Update only some specific fields of a `VisualizerOverrides`.
+        static VisualizerOverrides update_fields() {
+            return VisualizerOverrides();
+        }
+
+        /// Clear all the fields of a `VisualizerOverrides`.
+        static VisualizerOverrides clear_fields();
+
+        /// Names of the visualizers that should be active.
+        VisualizerOverrides with_ranges(
+            const Collection<rerun::blueprint::components::VisualizerOverride>& _ranges
+        ) && {
+            ranges = ComponentBatch::from_loggable(_ranges, Descriptor_ranges).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::VisualizerOverrides> {
+        /// Serialize all set component batches.
+        static Result<Collection<ComponentBatch>> as_batches(
+            const blueprint::archetypes::VisualizerOverrides& archetype
+        );
+    };
+} // namespace rerun

include/rerun/blueprint/archetypes.hpp

@@ -0,0 +1,29 @@
+// DO NOT EDIT! This file was auto-generated by crates/build/re_types_builder/src/codegen/cpp/mod.rs
+
+#pragma once
+
+#include "blueprint/archetypes/background.hpp"
+#include "blueprint/archetypes/container_blueprint.hpp"
+#include "blueprint/archetypes/dataframe_query.hpp"
+#include "blueprint/archetypes/entity_behavior.hpp"
+#include "blueprint/archetypes/force_center.hpp"
+#include "blueprint/archetypes/force_collision_radius.hpp"
+#include "blueprint/archetypes/force_link.hpp"
+#include "blueprint/archetypes/force_many_body.hpp"
+#include "blueprint/archetypes/force_position.hpp"
+#include "blueprint/archetypes/line_grid3d.hpp"
+#include "blueprint/archetypes/map_background.hpp"
+#include "blueprint/archetypes/map_zoom.hpp"
+#include "blueprint/archetypes/near_clip_plane.hpp"
+#include "blueprint/archetypes/panel_blueprint.hpp"
+#include "blueprint/archetypes/plot_legend.hpp"
+#include "blueprint/archetypes/scalar_axis.hpp"
+#include "blueprint/archetypes/tensor_scalar_mapping.hpp"
+#include "blueprint/archetypes/tensor_slice_selection.hpp"
+#include "blueprint/archetypes/tensor_view_fit.hpp"
+#include "blueprint/archetypes/view_blueprint.hpp"
+#include "blueprint/archetypes/view_contents.hpp"
+#include "blueprint/archetypes/viewport_blueprint.hpp"
+#include "blueprint/archetypes/visible_time_ranges.hpp"
+#include "blueprint/archetypes/visual_bounds2d.hpp"
+#include "blueprint/archetypes/visualizer_overrides.hpp"

include/rerun/blueprint/components/active_tab.hpp

@@ -0,0 +1,82 @@
+// 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/components/active_tab.fbs".
+
+#pragma once
+
+#include "../../component_descriptor.hpp"
+#include "../../datatypes/entity_path.hpp"
+#include "../../result.hpp"
+
+#include <cstdint>
+#include <memory>
+#include <string>
+#include <utility>
+
+namespace rerun::blueprint::components {
+    /// **Component**: The active tab in a tabbed container.
+    ///
+    /// ⚠ **This type is _unstable_ and may change significantly in a way that the data won't be backwards compatible.**
+    ///
+    struct ActiveTab {
+        /// Which tab is currently active.
+        ///
+        /// This should always correspond to a tab in the container.
+        rerun::datatypes::EntityPath tab;
+
+      public:
+        ActiveTab() = default;
+
+        ActiveTab(rerun::datatypes::EntityPath tab_) : tab(std::move(tab_)) {}
+
+        ActiveTab& operator=(rerun::datatypes::EntityPath tab_) {
+            tab = std::move(tab_);
+            return *this;
+        }
+
+        ActiveTab(std::string path_) : tab(std::move(path_)) {}
+
+        ActiveTab& operator=(std::string path_) {
+            tab = std::move(path_);
+            return *this;
+        }
+
+        /// Cast to the underlying EntityPath datatype
+        operator rerun::datatypes::EntityPath() const {
+            return tab;
+        }
+    };
+} // namespace rerun::blueprint::components
+
+namespace rerun {
+    static_assert(sizeof(rerun::datatypes::EntityPath) == sizeof(blueprint::components::ActiveTab));
+
+    /// \private
+    template <>
+    struct Loggable<blueprint::components::ActiveTab> {
+        static constexpr ComponentDescriptor Descriptor = "rerun.blueprint.components.ActiveTab";
+
+        /// Returns the arrow data type this type corresponds to.
+        static const std::shared_ptr<arrow::DataType>& arrow_datatype() {
+            return Loggable<rerun::datatypes::EntityPath>::arrow_datatype();
+        }
+
+        /// Serializes an array of `rerun::blueprint:: components::ActiveTab` into an arrow array.
+        static Result<std::shared_ptr<arrow::Array>> to_arrow(
+            const blueprint::components::ActiveTab* instances, size_t num_instances
+        ) {
+            if (num_instances == 0) {
+                return Loggable<rerun::datatypes::EntityPath>::to_arrow(nullptr, 0);
+            } else if (instances == nullptr) {
+                return rerun::Error(
+                    ErrorCode::UnexpectedNullArgument,
+                    "Passed array instances is null when num_elements> 0."
+                );
+            } else {
+                return Loggable<rerun::datatypes::EntityPath>::to_arrow(
+                    &instances->tab,
+                    num_instances
+                );
+            }
+        }
+    };
+} // namespace rerun

include/rerun/blueprint/components/apply_latest_at.hpp

@@ -0,0 +1,79 @@
+// 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/components/apply_latest_at.fbs".
+
+#pragma once
+
+#include "../../component_descriptor.hpp"
+#include "../../datatypes/bool.hpp"
+#include "../../result.hpp"
+
+#include <cstdint>
+#include <memory>
+
+namespace rerun::blueprint::components {
+    /// **Component**: Whether empty cells in a dataframe should be filled with a latest-at query.
+    ///
+    /// ⚠ **This type is _unstable_ and may change significantly in a way that the data won't be backwards compatible.**
+    ///
+    struct ApplyLatestAt {
+        rerun::datatypes::Bool apply_latest_at;
+
+      public:
+        ApplyLatestAt() = default;
+
+        ApplyLatestAt(rerun::datatypes::Bool apply_latest_at_)
+            : apply_latest_at(apply_latest_at_) {}
+
+        ApplyLatestAt& operator=(rerun::datatypes::Bool apply_latest_at_) {
+            apply_latest_at = apply_latest_at_;
+            return *this;
+        }
+
+        ApplyLatestAt(bool value_) : apply_latest_at(value_) {}
+
+        ApplyLatestAt& operator=(bool value_) {
+            apply_latest_at = value_;
+            return *this;
+        }
+
+        /// Cast to the underlying Bool datatype
+        operator rerun::datatypes::Bool() const {
+            return apply_latest_at;
+        }
+    };
+} // namespace rerun::blueprint::components
+
+namespace rerun {
+    static_assert(sizeof(rerun::datatypes::Bool) == sizeof(blueprint::components::ApplyLatestAt));
+
+    /// \private
+    template <>
+    struct Loggable<blueprint::components::ApplyLatestAt> {
+        static constexpr ComponentDescriptor Descriptor =
+            "rerun.blueprint.components.ApplyLatestAt";
+
+        /// Returns the arrow data type this type corresponds to.
+        static const std::shared_ptr<arrow::DataType>& arrow_datatype() {
+            return Loggable<rerun::datatypes::Bool>::arrow_datatype();
+        }
+
+        /// Serializes an array of `rerun::blueprint:: components::ApplyLatestAt` into an arrow array.
+        static Result<std::shared_ptr<arrow::Array>> to_arrow(
+            const blueprint::components::ApplyLatestAt* instances, size_t num_instances
+        ) {
+            if (num_instances == 0) {
+                return Loggable<rerun::datatypes::Bool>::to_arrow(nullptr, 0);
+            } else if (instances == nullptr) {
+                return rerun::Error(
+                    ErrorCode::UnexpectedNullArgument,
+                    "Passed array instances is null when num_elements> 0."
+                );
+            } else {
+                return Loggable<rerun::datatypes::Bool>::to_arrow(
+                    &instances->apply_latest_at,
+                    num_instances
+                );
+            }
+        }
+    };
+} // namespace rerun

include/rerun/blueprint/components/auto_layout.hpp

@@ -0,0 +1,77 @@
+// 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/components/auto_layout.fbs".
+
+#pragma once
+
+#include "../../component_descriptor.hpp"
+#include "../../datatypes/bool.hpp"
+#include "../../result.hpp"
+
+#include <cstdint>
+#include <memory>
+
+namespace rerun::blueprint::components {
+    /// **Component**: Whether the viewport layout is determined automatically.
+    ///
+    /// ⚠ **This type is _unstable_ and may change significantly in a way that the data won't be backwards compatible.**
+    ///
+    struct AutoLayout {
+        rerun::datatypes::Bool auto_layout;
+
+      public:
+        AutoLayout() = default;
+
+        AutoLayout(rerun::datatypes::Bool auto_layout_) : auto_layout(auto_layout_) {}
+
+        AutoLayout& operator=(rerun::datatypes::Bool auto_layout_) {
+            auto_layout = auto_layout_;
+            return *this;
+        }
+
+        AutoLayout(bool value_) : auto_layout(value_) {}
+
+        AutoLayout& operator=(bool value_) {
+            auto_layout = value_;
+            return *this;
+        }
+
+        /// Cast to the underlying Bool datatype
+        operator rerun::datatypes::Bool() const {
+            return auto_layout;
+        }
+    };
+} // namespace rerun::blueprint::components
+
+namespace rerun {
+    static_assert(sizeof(rerun::datatypes::Bool) == sizeof(blueprint::components::AutoLayout));
+
+    /// \private
+    template <>
+    struct Loggable<blueprint::components::AutoLayout> {
+        static constexpr ComponentDescriptor Descriptor = "rerun.blueprint.components.AutoLayout";
+
+        /// Returns the arrow data type this type corresponds to.
+        static const std::shared_ptr<arrow::DataType>& arrow_datatype() {
+            return Loggable<rerun::datatypes::Bool>::arrow_datatype();
+        }
+
+        /// Serializes an array of `rerun::blueprint:: components::AutoLayout` into an arrow array.
+        static Result<std::shared_ptr<arrow::Array>> to_arrow(
+            const blueprint::components::AutoLayout* instances, size_t num_instances
+        ) {
+            if (num_instances == 0) {
+                return Loggable<rerun::datatypes::Bool>::to_arrow(nullptr, 0);
+            } else if (instances == nullptr) {
+                return rerun::Error(
+                    ErrorCode::UnexpectedNullArgument,
+                    "Passed array instances is null when num_elements> 0."
+                );
+            } else {
+                return Loggable<rerun::datatypes::Bool>::to_arrow(
+                    &instances->auto_layout,
+                    num_instances
+                );
+            }
+        }
+    };
+} // namespace rerun

include/rerun/blueprint/components/auto_views.hpp

@@ -0,0 +1,77 @@
+// 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/components/auto_views.fbs".
+
+#pragma once
+
+#include "../../component_descriptor.hpp"
+#include "../../datatypes/bool.hpp"
+#include "../../result.hpp"
+
+#include <cstdint>
+#include <memory>
+
+namespace rerun::blueprint::components {
+    /// **Component**: Whether or not views should be created automatically.
+    ///
+    /// ⚠ **This type is _unstable_ and may change significantly in a way that the data won't be backwards compatible.**
+    ///
+    struct AutoViews {
+        rerun::datatypes::Bool auto_views;
+
+      public:
+        AutoViews() = default;
+
+        AutoViews(rerun::datatypes::Bool auto_views_) : auto_views(auto_views_) {}
+
+        AutoViews& operator=(rerun::datatypes::Bool auto_views_) {
+            auto_views = auto_views_;
+            return *this;
+        }
+
+        AutoViews(bool value_) : auto_views(value_) {}
+
+        AutoViews& operator=(bool value_) {
+            auto_views = value_;
+            return *this;
+        }
+
+        /// Cast to the underlying Bool datatype
+        operator rerun::datatypes::Bool() const {
+            return auto_views;
+        }
+    };
+} // namespace rerun::blueprint::components
+
+namespace rerun {
+    static_assert(sizeof(rerun::datatypes::Bool) == sizeof(blueprint::components::AutoViews));
+
+    /// \private
+    template <>
+    struct Loggable<blueprint::components::AutoViews> {
+        static constexpr ComponentDescriptor Descriptor = "rerun.blueprint.components.AutoViews";
+
+        /// Returns the arrow data type this type corresponds to.
+        static const std::shared_ptr<arrow::DataType>& arrow_datatype() {
+            return Loggable<rerun::datatypes::Bool>::arrow_datatype();
+        }
+
+        /// Serializes an array of `rerun::blueprint:: components::AutoViews` into an arrow array.
+        static Result<std::shared_ptr<arrow::Array>> to_arrow(
+            const blueprint::components::AutoViews* instances, size_t num_instances
+        ) {
+            if (num_instances == 0) {
+                return Loggable<rerun::datatypes::Bool>::to_arrow(nullptr, 0);
+            } else if (instances == nullptr) {
+                return rerun::Error(
+                    ErrorCode::UnexpectedNullArgument,
+                    "Passed array instances is null when num_elements> 0."
+                );
+            } else {
+                return Loggable<rerun::datatypes::Bool>::to_arrow(
+                    &instances->auto_views,
+                    num_instances
+                );
+            }
+        }
+    };
+} // namespace rerun

include/rerun/blueprint/components/background_kind.hpp

@@ -0,0 +1,66 @@
+// 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/components/background_kind.fbs".
+
+#pragma once
+
+#include "../../component_descriptor.hpp"
+#include "../../result.hpp"
+
+#include <cstdint>
+#include <memory>
+
+namespace arrow {
+    /// \private
+    template <typename T>
+    class NumericBuilder;
+
+    class Array;
+    class DataType;
+    class UInt8Type;
+    using UInt8Builder = NumericBuilder<UInt8Type>;
+} // namespace arrow
+
+namespace rerun::blueprint::components {
+    /// **Component**: The type of the background in a view.
+    enum class BackgroundKind : uint8_t {
+
+        /// A dark gradient.
+        ///
+        /// In 3D views it changes depending on the direction of the view.
+        GradientDark = 1,
+
+        /// A bright gradient.
+        ///
+        /// In 3D views it changes depending on the direction of the view.
+        GradientBright = 2,
+
+        /// Simple uniform color.
+        SolidColor = 3,
+    };
+} // namespace rerun::blueprint::components
+
+namespace rerun {
+    template <typename T>
+    struct Loggable;
+
+    /// \private
+    template <>
+    struct Loggable<blueprint::components::BackgroundKind> {
+        static constexpr ComponentDescriptor Descriptor =
+            "rerun.blueprint.components.BackgroundKind";
+
+        /// Returns the arrow data type this type corresponds to.
+        static const std::shared_ptr<arrow::DataType>& arrow_datatype();
+
+        /// Serializes an array of `rerun::blueprint:: components::BackgroundKind` into an arrow array.
+        static Result<std::shared_ptr<arrow::Array>> to_arrow(
+            const blueprint::components::BackgroundKind* instances, size_t num_instances
+        );
+
+        /// Fills an arrow array builder with an array of this type.
+        static rerun::Error fill_arrow_array_builder(
+            arrow::UInt8Builder* builder, const blueprint::components::BackgroundKind* elements,
+            size_t num_elements
+        );
+    };
+} // namespace rerun