pymomentum-cpu 0.1.82.post0__cp312-cp312-macosx_14_0_arm64.whl

include/rerun/rerun_sdk_export.hpp

@@ -0,0 +1,25 @@
+#pragma once
+
+// If the library is not compiled on Windows, RERUN_SDK_EXPORT is defined as empty macro.
+#ifndef _MSC_VER
+#define RERUN_SDK_EXPORT
+#else
+// If rerun_sdk is compiled as shared on Windows, RERUN_SDK_EXPORT
+// is __declspec(dllexport) for the compilation unit that are part
+// of the library, and __declspec(dllimport) for compilation units
+// that link to the library.
+#ifdef RERUN_SDK_COMPILED_AS_SHARED_LIBRARY
+// rerun_sdk_EXPORTS is defined by CMake itself when compiling a shared
+// library, see https://cmake.org/cmake/help/latest/prop_tgt/DEFINE_SYMBOL.html
+#ifdef rerun_sdk_EXPORTS
+// We are building this library.
+#define RERUN_SDK_EXPORT __declspec(dllexport)
+#else
+// We are using this library.
+#define RERUN_SDK_EXPORT __declspec(dllimport)
+#endif
+#else
+// If rerun_sdk is compiled as static on Windows, RERUN_SDK_EXPORT is defined as an empty macro.
+#define RERUN_SDK_EXPORT
+#endif
+#endif

include/rerun/result.hpp

@@ -0,0 +1,86 @@
+#pragma once
+
+#include <type_traits>
+#include <utility>
+
+#include "error.hpp"
+
+namespace rerun {
+    /// A class for representing either a usable value, or an error.
+    ///
+    /// In essence a simplified version of rust's Result or arrow's arrow::Result, always using
+    /// rerun::Status. For simplicity, the wrapped type must be default constructible.
+    template <typename T>
+    class [[nodiscard]] Result {
+        static_assert(
+            std::is_default_constructible<T>::value,
+            "Result can only wrap default constructible types."
+        );
+
+      public:
+        /// Don't allow uninitialized results.
+        Result() = delete;
+
+        /// Construct a result from a value, setting error to ok.
+        Result(T _value) : value(std::move(_value)), error() {}
+
+        /// Construct a result from an error, default constructing the value.
+        Result(rerun::Error _error) : value(), error(std::move(_error)) {}
+
+        /// Construct a result from an arrow status, default constructing the value.
+        Result(const arrow::Status& status) : value(), error(status) {}
+
+        /// Construct a result from an arrow status, default constructing the value.
+        Result(arrow::Status&& status) : value(), error(std::move(status)) {}
+
+        /// Returns true if error is set to rerun::ErrorCode::Ok, implying that a value is
+        /// contained, false otherwise.
+        bool is_ok() const {
+            return error.is_ok();
+        }
+
+        /// Returns true if error is not set to rerun::ErrorCode::Ok, implying that no value is
+        /// contained, false otherwise.
+        bool is_err() const {
+            return error.is_err();
+        }
+
+        /// Returns the value if status is ok, throws otherwise.
+        ///
+        /// If exceptions are disabled, this will exit the application instead.
+        /// @see error::value_or_exit
+        const T& value_or_throw() const& {
+            error.throw_on_failure();
+            return value;
+        }
+
+        /// Returns the value if status is ok, throws otherwise.
+        ///
+        /// If exceptions are disabled, this will exit the application instead.
+        /// @see error::value_or_exit
+        T value_or_throw() && {
+            error.throw_on_failure();
+            // Do an explicit move in order to guarantee that we give up ownership of `value`.
+            return std::move(value);
+        }
+
+        /// Returns the value if status is ok, exits the application otherwise.
+        /// @see error::value_or_throw
+        const T& value_or_exit() const& {
+            error.exit_on_failure();
+            return value;
+        }
+
+        /// Returns the value if status is ok, exits the application otherwise.
+        /// @see error::value_or_throw
+        T value_or_exit() && {
+            error.exit_on_failure();
+            // Do an explicit move in order to guarantee that we give up ownership of `value`.
+            return std::move(value);
+        }
+
+      public:
+        T value;
+        rerun::Error error;
+    };
+} // namespace rerun

include/rerun/rotation3d.hpp

@@ -0,0 +1,33 @@
+#pragma once
+
+#include <optional>
+
+#include "components/rotation_axis_angle.hpp"
+#include "components/rotation_quat.hpp"
+#include "datatypes/quaternion.hpp"
+#include "datatypes/rotation_axis_angle.hpp"
+
+namespace rerun {
+    /// Utility for representing a single 3D rotation, agnostic to the underlying representation.
+    ///
+    /// This is not a component, but a utility for building `rerun::Transform3D`.
+    struct Rotation3D {
+        std::optional<rerun::components::RotationAxisAngle> axis_angle;
+        std::optional<rerun::components::RotationQuat> quaternion;
+
+      public:
+        Rotation3D() : axis_angle(std::nullopt), quaternion(std::nullopt) {}
+
+        /// Construct a `Rotation3D` from a rotation axis and angle component.
+        Rotation3D(rerun::components::RotationAxisAngle axis_angle_) : axis_angle(axis_angle_) {}
+
+        /// Construct a `Rotation3D` from a quaternion component.
+        Rotation3D(rerun::components::RotationQuat quaternion_) : quaternion(quaternion_) {}
+
+        /// Construct a `Rotation3D` from a rotation axis and angle datatype.
+        Rotation3D(rerun::datatypes::RotationAxisAngle axis_angle_) : axis_angle(axis_angle_) {}
+
+        /// Construct a `Rotation3D` from a quaternion datatype.
+        Rotation3D(rerun::datatypes::Quaternion quaternion_) : quaternion(quaternion_) {}
+    };
+} // namespace rerun

include/rerun/sdk_info.hpp

@@ -0,0 +1,20 @@
+// General information about the SDK.
+#pragma once
+
+#include "c/sdk_info.h"
+#include "error.hpp"
+
+namespace rerun {
+    /// Returns a human-readable version string of the Rerun C SDK.
+    ///
+    /// This should match the string in `RERUN_SDK_HEADER_VERSION`.
+    /// If not, the SDK's binary and the C++ headers are out of sync.
+    const char* version_string();
+
+    /// Internal check whether the version reported by the rerun_c binary matches `sdk_version_string`.
+    ///
+    /// This method is called on various C++ API entry points, calling `Error::handle` on the return value.
+    /// There is no need to call this method yourself unless you want to ensure that rerun_c binary and
+    /// rerun_c header versions match ahead of time.
+    Error check_binary_and_header_version_match();
+} // namespace rerun

include/rerun/spawn.hpp

@@ -0,0 +1,21 @@
+// General information about the SDK.
+#pragma once
+
+#include <cstdint> // uint32_t etc.
+#include <optional>
+#include <string_view>
+
+#include "error.hpp"
+#include "spawn_options.hpp"
+
+namespace rerun {
+    /// Spawns a new Rerun Viewer process from an executable available in PATH, ready to
+    /// listen for incoming gRPC connections.
+    ///
+    /// If a Rerun Viewer is already listening on this gRPC port, the stream will be redirected to
+    /// that viewer instead of starting a new one.
+    ///
+    /// options:
+    /// See `rerun::SpawnOptions` for more information.
+    Error spawn(const SpawnOptions& options = {});
+} // namespace rerun

include/rerun/spawn_options.hpp

@@ -0,0 +1,57 @@
+#pragma once
+
+#include <cstdint>
+#include <string_view>
+
+extern "C" struct rr_spawn_options;
+
+namespace rerun {
+
+    /// Options to control the behavior of `spawn`.
+    ///
+    /// Refer to the field-level documentation for more information about each individual options.
+    ///
+    /// The defaults are ok for most use cases.
+    ///
+    /// Keep this in sync with rerun.h's `rr_spawn_options`.
+    struct SpawnOptions {
+        /// The port to listen on.
+        uint16_t port = 9876;
+
+        /// An upper limit on how much memory the Rerun Viewer should use.
+        ///
+        /// When this limit is reached, Rerun will drop the oldest data.
+        /// Example: `16GB` or `50%` (of system total).
+        ///
+        /// Defaults to `75%` if unset.
+        std::string_view memory_limit = "75%";
+
+        /// Hide the normal Rerun welcome screen.
+        ///
+        /// Defaults to `false` if unset.
+        bool hide_welcome_screen = false;
+
+        /// Detach Rerun Viewer process from the application process.
+        ///
+        /// Defaults to `true` if unset.
+        bool detach_process = true;
+
+        /// Specifies the name of the Rerun executable.
+        ///
+        /// You can omit the `.exe` suffix on Windows.
+        ///
+        /// Defaults to `rerun` if unset.
+        std::string_view executable_name = "rerun";
+
+        /// Enforce a specific executable to use instead of searching though PATH
+        /// for `SpawnOptions::executable_name`.
+        std::string_view executable_path;
+
+        /// Convert to the corresponding rerun_c struct for internal use.
+        ///
+        /// _Implementation note:_
+        /// By not returning it we avoid including the C header in this header.
+        /// \private
+        void fill_rerun_c_struct(rr_spawn_options& spawn_opts) const;
+    };
+} // namespace rerun

include/rerun/string_utils.hpp

@@ -0,0 +1,16 @@
+
+#pragma once
+
+#include <optional>
+#include <string>
+#include <string_view>
+
+struct rr_string;
+
+namespace rerun {
+    namespace detail {
+        rr_string to_rr_string(const std::string& str);
+        rr_string to_rr_string(std::string_view str);
+        rr_string to_rr_string(std::optional<std::string_view> str);
+    } // namespace detail
+} // namespace rerun