pymomentum-cpu 0.1.82.post0__cp313-cp313-macosx_14_0_arm64.whl

include/rerun/blueprint/components/query_expression.hpp

@@ -0,0 +1,89 @@
+// 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/query_expression.fbs".
+
+#pragma once
+
+#include "../../component_descriptor.hpp"
+#include "../../datatypes/utf8.hpp"
+#include "../../result.hpp"
+
+#include <cstdint>
+#include <memory>
+#include <string>
+#include <utility>
+
+namespace rerun::blueprint::components {
+    /// **Component**: An individual query expression used to filter a set of `datatypes::EntityPath`s.
+    ///
+    /// Each expression is either an inclusion or an exclusion expression.
+    /// Inclusions start with an optional `+` and exclusions must start with a `-`.
+    ///
+    /// Multiple expressions are combined together as part of `archetypes::ViewContents`.
+    ///
+    /// The `/**` suffix matches the whole subtree, i.e. self and any child, recursively
+    /// (`/world/**` matches both `/world` and `/world/car/driver`).
+    /// Other uses of `*` are not (yet) supported.
+    ///
+    /// ⚠ **This type is _unstable_ and may change significantly in a way that the data won't be backwards compatible.**
+    ///
+    struct QueryExpression {
+        rerun::datatypes::Utf8 filter;
+
+      public:
+        QueryExpression() = default;
+
+        QueryExpression(rerun::datatypes::Utf8 filter_) : filter(std::move(filter_)) {}
+
+        QueryExpression& operator=(rerun::datatypes::Utf8 filter_) {
+            filter = std::move(filter_);
+            return *this;
+        }
+
+        QueryExpression(std::string value_) : filter(std::move(value_)) {}
+
+        QueryExpression& operator=(std::string value_) {
+            filter = std::move(value_);
+            return *this;
+        }
+
+        /// Cast to the underlying Utf8 datatype
+        operator rerun::datatypes::Utf8() const {
+            return filter;
+        }
+    };
+} // namespace rerun::blueprint::components
+
+namespace rerun {
+    static_assert(sizeof(rerun::datatypes::Utf8) == sizeof(blueprint::components::QueryExpression));
+
+    /// \private
+    template <>
+    struct Loggable<blueprint::components::QueryExpression> {
+        static constexpr ComponentDescriptor Descriptor =
+            "rerun.blueprint.components.QueryExpression";
+
+        /// Returns the arrow data type this type corresponds to.
+        static const std::shared_ptr<arrow::DataType>& arrow_datatype() {
+            return Loggable<rerun::datatypes::Utf8>::arrow_datatype();
+        }
+
+        /// Serializes an array of `rerun::blueprint:: components::QueryExpression` into an arrow array.
+        static Result<std::shared_ptr<arrow::Array>> to_arrow(
+            const blueprint::components::QueryExpression* instances, size_t num_instances
+        ) {
+            if (num_instances == 0) {
+                return Loggable<rerun::datatypes::Utf8>::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::Utf8>::to_arrow(
+                    &instances->filter,
+                    num_instances
+                );
+            }
+        }
+    };
+} // namespace rerun

include/rerun/blueprint/components/root_container.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/root_container.fbs".
+
+#pragma once
+
+#include "../../component_descriptor.hpp"
+#include "../../datatypes/uuid.hpp"
+#include "../../result.hpp"
+
+#include <array>
+#include <cstdint>
+#include <memory>
+
+namespace rerun::blueprint::components {
+    /// **Component**: The container that sits at the root of a viewport.
+    ///
+    /// ⚠ **This type is _unstable_ and may change significantly in a way that the data won't be backwards compatible.**
+    ///
+    struct RootContainer {
+        /// `ContainerId` for the root.
+        rerun::datatypes::Uuid id;
+
+      public:
+        RootContainer() = default;
+
+        RootContainer(rerun::datatypes::Uuid id_) : id(id_) {}
+
+        RootContainer& operator=(rerun::datatypes::Uuid id_) {
+            id = id_;
+            return *this;
+        }
+
+        RootContainer(std::array<uint8_t, 16> bytes_) : id(bytes_) {}
+
+        RootContainer& operator=(std::array<uint8_t, 16> bytes_) {
+            id = bytes_;
+            return *this;
+        }
+
+        /// Cast to the underlying Uuid datatype
+        operator rerun::datatypes::Uuid() const {
+            return id;
+        }
+    };
+} // namespace rerun::blueprint::components
+
+namespace rerun {
+    static_assert(sizeof(rerun::datatypes::Uuid) == sizeof(blueprint::components::RootContainer));
+
+    /// \private
+    template <>
+    struct Loggable<blueprint::components::RootContainer> {
+        static constexpr ComponentDescriptor Descriptor =
+            "rerun.blueprint.components.RootContainer";
+
+        /// Returns the arrow data type this type corresponds to.
+        static const std::shared_ptr<arrow::DataType>& arrow_datatype() {
+            return Loggable<rerun::datatypes::Uuid>::arrow_datatype();
+        }
+
+        /// Serializes an array of `rerun::blueprint:: components::RootContainer` into an arrow array.
+        static Result<std::shared_ptr<arrow::Array>> to_arrow(
+            const blueprint::components::RootContainer* instances, size_t num_instances
+        ) {
+            if (num_instances == 0) {
+                return Loggable<rerun::datatypes::Uuid>::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::Uuid>::to_arrow(&instances->id, num_instances);
+            }
+        }
+    };
+} // namespace rerun

include/rerun/blueprint/components/row_share.hpp

@@ -0,0 +1,78 @@
+// 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/row_share.fbs".
+
+#pragma once
+
+#include "../../component_descriptor.hpp"
+#include "../../datatypes/float32.hpp"
+#include "../../result.hpp"
+
+#include <cstdint>
+#include <memory>
+
+namespace rerun::blueprint::components {
+    /// **Component**: The layout share of a row in the container.
+    ///
+    /// ⚠ **This type is _unstable_ and may change significantly in a way that the data won't be backwards compatible.**
+    ///
+    struct RowShare {
+        /// The layout share of a row in the container.
+        rerun::datatypes::Float32 share;
+
+      public:
+        RowShare() = default;
+
+        RowShare(rerun::datatypes::Float32 share_) : share(share_) {}
+
+        RowShare& operator=(rerun::datatypes::Float32 share_) {
+            share = share_;
+            return *this;
+        }
+
+        RowShare(float value_) : share(value_) {}
+
+        RowShare& operator=(float value_) {
+            share = value_;
+            return *this;
+        }
+
+        /// Cast to the underlying Float32 datatype
+        operator rerun::datatypes::Float32() const {
+            return share;
+        }
+    };
+} // namespace rerun::blueprint::components
+
+namespace rerun {
+    static_assert(sizeof(rerun::datatypes::Float32) == sizeof(blueprint::components::RowShare));
+
+    /// \private
+    template <>
+    struct Loggable<blueprint::components::RowShare> {
+        static constexpr ComponentDescriptor Descriptor = "rerun.blueprint.components.RowShare";
+
+        /// Returns the arrow data type this type corresponds to.
+        static const std::shared_ptr<arrow::DataType>& arrow_datatype() {
+            return Loggable<rerun::datatypes::Float32>::arrow_datatype();
+        }
+
+        /// Serializes an array of `rerun::blueprint:: components::RowShare` into an arrow array.
+        static Result<std::shared_ptr<arrow::Array>> to_arrow(
+            const blueprint::components::RowShare* instances, size_t num_instances
+        ) {
+            if (num_instances == 0) {
+                return Loggable<rerun::datatypes::Float32>::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::Float32>::to_arrow(
+                    &instances->share,
+                    num_instances
+                );
+            }
+        }
+    };
+} // namespace rerun

include/rerun/blueprint/components/selected_columns.hpp

@@ -0,0 +1,76 @@
+// 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/selected_columns.fbs".
+
+#pragma once
+
+#include "../../blueprint/datatypes/selected_columns.hpp"
+#include "../../component_descriptor.hpp"
+#include "../../result.hpp"
+
+#include <cstdint>
+#include <memory>
+#include <utility>
+
+namespace rerun::blueprint::components {
+    /// **Component**: Describe a component column to be selected in the dataframe view.
+    ///
+    /// ⚠ **This type is _unstable_ and may change significantly in a way that the data won't be backwards compatible.**
+    ///
+    struct SelectedColumns {
+        rerun::blueprint::datatypes::SelectedColumns selected_columns;
+
+      public:
+        SelectedColumns() = default;
+
+        SelectedColumns(rerun::blueprint::datatypes::SelectedColumns selected_columns_)
+            : selected_columns(std::move(selected_columns_)) {}
+
+        SelectedColumns& operator=(rerun::blueprint::datatypes::SelectedColumns selected_columns_) {
+            selected_columns = std::move(selected_columns_);
+            return *this;
+        }
+
+        /// Cast to the underlying SelectedColumns datatype
+        operator rerun::blueprint::datatypes::SelectedColumns() const {
+            return selected_columns;
+        }
+    };
+} // namespace rerun::blueprint::components
+
+namespace rerun {
+    static_assert(
+        sizeof(rerun::blueprint::datatypes::SelectedColumns) ==
+        sizeof(blueprint::components::SelectedColumns)
+    );
+
+    /// \private
+    template <>
+    struct Loggable<blueprint::components::SelectedColumns> {
+        static constexpr ComponentDescriptor Descriptor =
+            "rerun.blueprint.components.SelectedColumns";
+
+        /// Returns the arrow data type this type corresponds to.
+        static const std::shared_ptr<arrow::DataType>& arrow_datatype() {
+            return Loggable<rerun::blueprint::datatypes::SelectedColumns>::arrow_datatype();
+        }
+
+        /// Serializes an array of `rerun::blueprint:: components::SelectedColumns` into an arrow array.
+        static Result<std::shared_ptr<arrow::Array>> to_arrow(
+            const blueprint::components::SelectedColumns* instances, size_t num_instances
+        ) {
+            if (num_instances == 0) {
+                return Loggable<rerun::blueprint::datatypes::SelectedColumns>::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::blueprint::datatypes::SelectedColumns>::to_arrow(
+                    &instances->selected_columns,
+                    num_instances
+                );
+            }
+        }
+    };
+} // namespace rerun

include/rerun/blueprint/components/tensor_dimension_index_slider.hpp

@@ -0,0 +1,90 @@
+// 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/tensor_dimension_index_slider.fbs".
+
+#pragma once
+
+#include "../../blueprint/datatypes/tensor_dimension_index_slider.hpp"
+#include "../../component_descriptor.hpp"
+#include "../../result.hpp"
+
+#include <cstdint>
+#include <memory>
+
+namespace rerun::blueprint::components {
+    /// **Component**: Show a slider for the index of some dimension of a slider.
+    ///
+    /// ⚠ **This type is _unstable_ and may change significantly in a way that the data won't be backwards compatible.**
+    ///
+    struct TensorDimensionIndexSlider {
+        rerun::blueprint::datatypes::TensorDimensionIndexSlider selection;
+
+      public:
+        TensorDimensionIndexSlider() = default;
+
+        TensorDimensionIndexSlider(
+            rerun::blueprint::datatypes::TensorDimensionIndexSlider selection_
+        )
+            : selection(selection_) {}
+
+        TensorDimensionIndexSlider& operator=(
+            rerun::blueprint::datatypes::TensorDimensionIndexSlider selection_
+        ) {
+            selection = selection_;
+            return *this;
+        }
+
+        TensorDimensionIndexSlider(uint32_t dimension_) : selection(dimension_) {}
+
+        TensorDimensionIndexSlider& operator=(uint32_t dimension_) {
+            selection = dimension_;
+            return *this;
+        }
+
+        /// Cast to the underlying TensorDimensionIndexSlider datatype
+        operator rerun::blueprint::datatypes::TensorDimensionIndexSlider() const {
+            return selection;
+        }
+    };
+} // namespace rerun::blueprint::components
+
+namespace rerun {
+    static_assert(
+        sizeof(rerun::blueprint::datatypes::TensorDimensionIndexSlider) ==
+        sizeof(blueprint::components::TensorDimensionIndexSlider)
+    );
+
+    /// \private
+    template <>
+    struct Loggable<blueprint::components::TensorDimensionIndexSlider> {
+        static constexpr ComponentDescriptor Descriptor =
+            "rerun.blueprint.components.TensorDimensionIndexSlider";
+
+        /// Returns the arrow data type this type corresponds to.
+        static const std::shared_ptr<arrow::DataType>& arrow_datatype() {
+            return Loggable<
+                rerun::blueprint::datatypes::TensorDimensionIndexSlider>::arrow_datatype();
+        }
+
+        /// Serializes an array of `rerun::blueprint:: components::TensorDimensionIndexSlider` into an arrow array.
+        static Result<std::shared_ptr<arrow::Array>> to_arrow(
+            const blueprint::components::TensorDimensionIndexSlider* instances, size_t num_instances
+        ) {
+            if (num_instances == 0) {
+                return Loggable<rerun::blueprint::datatypes::TensorDimensionIndexSlider>::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::blueprint::datatypes::TensorDimensionIndexSlider>::to_arrow(
+                    &instances->selection,
+                    num_instances
+                );
+            }
+        }
+    };
+} // namespace rerun

include/rerun/blueprint/components/timeline_name.hpp

@@ -0,0 +1,76 @@
+// 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/timeline_name.fbs".
+
+#pragma once
+
+#include "../../component_descriptor.hpp"
+#include "../../datatypes/utf8.hpp"
+#include "../../result.hpp"
+
+#include <cstdint>
+#include <memory>
+#include <string>
+#include <utility>
+
+namespace rerun::blueprint::components {
+    /// **Component**: A timeline identified by its name.
+    ///
+    /// ⚠ **This type is _unstable_ and may change significantly in a way that the data won't be backwards compatible.**
+    ///
+    struct TimelineName {
+        rerun::datatypes::Utf8 value;
+
+      public:
+        TimelineName() = default;
+
+        TimelineName(rerun::datatypes::Utf8 value_) : value(std::move(value_)) {}
+
+        TimelineName& operator=(rerun::datatypes::Utf8 value_) {
+            value = std::move(value_);
+            return *this;
+        }
+
+        TimelineName(std::string value_) : value(std::move(value_)) {}
+
+        TimelineName& operator=(std::string value_) {
+            value = std::move(value_);
+            return *this;
+        }
+
+        /// Cast to the underlying Utf8 datatype
+        operator rerun::datatypes::Utf8() const {
+            return value;
+        }
+    };
+} // namespace rerun::blueprint::components
+
+namespace rerun {
+    static_assert(sizeof(rerun::datatypes::Utf8) == sizeof(blueprint::components::TimelineName));
+
+    /// \private
+    template <>
+    struct Loggable<blueprint::components::TimelineName> {
+        static constexpr ComponentDescriptor Descriptor = "rerun.blueprint.components.TimelineName";
+
+        /// Returns the arrow data type this type corresponds to.
+        static const std::shared_ptr<arrow::DataType>& arrow_datatype() {
+            return Loggable<rerun::datatypes::Utf8>::arrow_datatype();
+        }
+
+        /// Serializes an array of `rerun::blueprint:: components::TimelineName` into an arrow array.
+        static Result<std::shared_ptr<arrow::Array>> to_arrow(
+            const blueprint::components::TimelineName* instances, size_t num_instances
+        ) {
+            if (num_instances == 0) {
+                return Loggable<rerun::datatypes::Utf8>::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::Utf8>::to_arrow(&instances->value, num_instances);
+            }
+        }
+    };
+} // namespace rerun

include/rerun/blueprint/components/view_class.hpp

@@ -0,0 +1,76 @@
+// 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/view_class.fbs".
+
+#pragma once
+
+#include "../../component_descriptor.hpp"
+#include "../../datatypes/utf8.hpp"
+#include "../../result.hpp"
+
+#include <cstdint>
+#include <memory>
+#include <string>
+#include <utility>
+
+namespace rerun::blueprint::components {
+    /// **Component**: The class identifier of view, e.g. `"2D"`, `"TextLog"`, ….
+    ///
+    /// ⚠ **This type is _unstable_ and may change significantly in a way that the data won't be backwards compatible.**
+    ///
+    struct ViewClass {
+        rerun::datatypes::Utf8 value;
+
+      public:
+        ViewClass() = default;
+
+        ViewClass(rerun::datatypes::Utf8 value_) : value(std::move(value_)) {}
+
+        ViewClass& operator=(rerun::datatypes::Utf8 value_) {
+            value = std::move(value_);
+            return *this;
+        }
+
+        ViewClass(std::string value_) : value(std::move(value_)) {}
+
+        ViewClass& operator=(std::string value_) {
+            value = std::move(value_);
+            return *this;
+        }
+
+        /// Cast to the underlying Utf8 datatype
+        operator rerun::datatypes::Utf8() const {
+            return value;
+        }
+    };
+} // namespace rerun::blueprint::components
+
+namespace rerun {
+    static_assert(sizeof(rerun::datatypes::Utf8) == sizeof(blueprint::components::ViewClass));
+
+    /// \private
+    template <>
+    struct Loggable<blueprint::components::ViewClass> {
+        static constexpr ComponentDescriptor Descriptor = "rerun.blueprint.components.ViewClass";
+
+        /// Returns the arrow data type this type corresponds to.
+        static const std::shared_ptr<arrow::DataType>& arrow_datatype() {
+            return Loggable<rerun::datatypes::Utf8>::arrow_datatype();
+        }
+
+        /// Serializes an array of `rerun::blueprint:: components::ViewClass` into an arrow array.
+        static Result<std::shared_ptr<arrow::Array>> to_arrow(
+            const blueprint::components::ViewClass* instances, size_t num_instances
+        ) {
+            if (num_instances == 0) {
+                return Loggable<rerun::datatypes::Utf8>::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::Utf8>::to_arrow(&instances->value, num_instances);
+            }
+        }
+    };
+} // namespace rerun

include/rerun/blueprint/components/view_fit.hpp

@@ -0,0 +1,61 @@
+// 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/view_fit.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**: Determines whether an image or texture should be scaled to fit the viewport.
+    enum class ViewFit : uint8_t {
+
+        /// No scaling, pixel size will match the image's width/height dimensions in pixels.
+        Original = 1,
+
+        /// Scale the image for the largest possible fit in the view's container.
+        Fill = 2,
+
+        /// Scale the image for the largest possible fit in the view's container, but keep the original aspect ratio.
+        FillKeepAspectRatio = 3,
+    };
+} // namespace rerun::blueprint::components
+
+namespace rerun {
+    template <typename T>
+    struct Loggable;
+
+    /// \private
+    template <>
+    struct Loggable<blueprint::components::ViewFit> {
+        static constexpr ComponentDescriptor Descriptor = "rerun.blueprint.components.ViewFit";
+
+        /// 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::ViewFit` into an arrow array.
+        static Result<std::shared_ptr<arrow::Array>> to_arrow(
+            const blueprint::components::ViewFit* 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::ViewFit* elements,
+            size_t num_elements
+        );
+    };
+} // namespace rerun