robot-msg-irsl 0.3.0__py3-none-any.whl

robot_msg/__init__.py

@@ -0,0 +1,39 @@
+"""Typed, transport-independent robot messages with binary-first encoding."""
+
+from ._runtime import (
+    ParseError,
+    RobotMsgError,
+    UnknownMessageError,
+    UnsupportedVersionError,
+    ValidationError,
+    decode_json,
+    encode_json,
+    validate,
+)
+from ._binary import decode, encode
+from ._catalog import MessageInfo, get_envelope_schema, get_payload_schema, message_catalog
+from .messages import *
+from .messages import __all__ as _messages_all
+from .types import *
+from .types import __all__ as _types_all
+from . import ports
+
+__all__ = [
+    "RobotMsgError",
+    "ParseError",
+    "ValidationError",
+    "UnknownMessageError",
+    "UnsupportedVersionError",
+    "encode",
+    "decode",
+    "encode_json",
+    "decode_json",
+    "validate",
+    "MessageInfo",
+    "message_catalog",
+    "get_payload_schema",
+    "get_envelope_schema",
+    "ports",
+    *_messages_all,
+    *_types_all,
+]

robot_msg/__main__.py

@@ -0,0 +1,14 @@
+import argparse
+
+from robot_msg._paths import cmake_dir
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="Locate installed robot_msg build resources")
+    parser.add_argument("--cmake-dir", action="store_true", required=True, help="print the source-package CMake config directory")
+    parser.parse_args()
+    print(cmake_dir())
+
+
+if __name__ == "__main__":
+    main()

robot_msg/_assets/VERSION

@@ -0,0 +1 @@
+0.3.0

robot_msg/_assets/internal/cpp/CMakeLists.txt

@@ -0,0 +1,38 @@
+add_library(robot_msg STATIC
+  src/runtime.cpp
+  src/generated/messages.cpp
+  src/generated/registry.cpp
+)
+add_library(robot_msg::robot_msg ALIAS robot_msg)
+
+set_target_properties(robot_msg PROPERTIES
+  CXX_EXTENSIONS OFF
+  CXX_STANDARD 14
+  CXX_STANDARD_REQUIRED ON
+  EXPORT_NAME robot_msg
+  POSITION_INDEPENDENT_CODE ON
+)
+
+target_compile_features(robot_msg PUBLIC cxx_std_14)
+target_include_directories(robot_msg
+  PUBLIC
+    "$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>"
+    "$<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>"
+)
+
+if(MSVC)
+  target_compile_options(robot_msg PRIVATE /W4 /permissive-)
+else()
+  target_compile_options(robot_msg PRIVATE -Wall -Wextra -Wpedantic)
+endif()
+
+if(NOT ROBOT_MSG_SOURCE_PACKAGE)
+  install(
+    TARGETS robot_msg
+    EXPORT robot_msgTargets
+    ARCHIVE DESTINATION "${CMAKE_INSTALL_LIBDIR}"
+    LIBRARY DESTINATION "${CMAKE_INSTALL_LIBDIR}"
+    RUNTIME DESTINATION "${CMAKE_INSTALL_BINDIR}"
+    INCLUDES DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}"
+  )
+endif()

robot_msg/_assets/internal/cpp/cmake/RobotMsgBootstrap.cmake

@@ -0,0 +1,102 @@
+function(robot_msg_bootstrap)
+  cmake_parse_arguments(RM "OFFLINE" "VERSION;PYTHON;WHEEL;UV" "" ${ARGN})
+  if(RM_UNPARSED_ARGUMENTS)
+    message(FATAL_ERROR "Unknown robot_msg_bootstrap arguments: ${RM_UNPARSED_ARGUMENTS}")
+  endif()
+  if(NOT RM_PYTHON)
+    message(FATAL_ERROR "robot_msg_bootstrap requires PYTHON pointing to an installed Python >=3.11")
+  endif()
+  if(NOT RM_VERSION AND NOT RM_WHEEL)
+    message(FATAL_ERROR "robot_msg_bootstrap requires an exact VERSION or a local WHEEL")
+  endif()
+  if(RM_VERSION AND NOT RM_VERSION MATCHES "^[0-9]+\\.[0-9]+\\.[0-9]+([a-zA-Z][a-zA-Z0-9.]*)?$")
+    message(FATAL_ERROR "robot_msg_bootstrap VERSION must be an exact release, not a requirement range")
+  endif()
+  if(NOT RM_UV)
+    find_program(RM_UV NAMES uv)
+  endif()
+  if(NOT RM_UV)
+    message(FATAL_ERROR "robot_msg_bootstrap requires uv; install it or pass UV explicitly")
+  endif()
+  execute_process(
+    COMMAND "${RM_PYTHON}" -I -c "import sys; assert sys.version_info >= (3, 11), 'Python >=3.11 required'; print(sys.executable); print(sys.version)"
+    RESULT_VARIABLE _python_result OUTPUT_VARIABLE _python_identity ERROR_VARIABLE _python_error
+    OUTPUT_STRIP_TRAILING_WHITESPACE
+  )
+  if(NOT _python_result EQUAL 0)
+    message(FATAL_ERROR "robot_msg host Python is unavailable or too old: ${_python_error}")
+  endif()
+  if(RM_WHEEL)
+    get_filename_component(_wheel "${RM_WHEEL}" ABSOLUTE BASE_DIR "${CMAKE_CURRENT_SOURCE_DIR}")
+    if(NOT EXISTS "${_wheel}")
+      message(FATAL_ERROR "robot_msg wheel does not exist: ${_wheel}")
+    endif()
+    file(SHA256 "${_wheel}" _wheel_hash)
+    set(_requirement "${_wheel}")
+  else()
+    set(_requirement "robot-msg-irsl==${RM_VERSION}")
+    set(_wheel_hash "")
+  endif()
+
+  set(_root "${CMAKE_BINARY_DIR}/_robot_msg")
+  file(MAKE_DIRECTORY "${_root}")
+  file(LOCK "${_root}/bootstrap.lock" GUARD FUNCTION TIMEOUT 120)
+  string(SHA256 _identity "${_python_identity}\n${RM_UV}\n${RM_VERSION}\n${_requirement}\n${_wheel_hash}")
+  set(_environment "${_root}/venv-${_identity}")
+  if(WIN32)
+    set(_python "${_environment}/Scripts/python.exe")
+  else()
+    set(_python "${_environment}/bin/python")
+  endif()
+  set(_stamp "${_environment}/.robot-msg-irsl-installed")
+  set(_uv "${RM_UV}" --no-config --no-python-downloads --cache-dir "${_root}/uv-cache")
+  if(RM_OFFLINE)
+    list(APPEND _uv --offline)
+  endif()
+  if(NOT EXISTS "${_stamp}" OR NOT EXISTS "${_python}")
+    execute_process(
+      COMMAND ${_uv} venv --no-project --allow-existing --python "${RM_PYTHON}" "${_environment}"
+      RESULT_VARIABLE _venv_result OUTPUT_VARIABLE _venv_output ERROR_VARIABLE _venv_error
+    )
+    if(NOT _venv_result EQUAL 0)
+      message(FATAL_ERROR "robot_msg environment creation failed:\n${_venv_output}\n${_venv_error}")
+    endif()
+    set(_install_args --python "${_python}" --no-deps --only-binary :all: --reinstall-package robot-msg-irsl)
+    if(RM_WHEEL)
+      list(APPEND _install_args --no-index)
+    endif()
+    execute_process(
+      COMMAND ${_uv} pip install ${_install_args} "${_requirement}"
+      RESULT_VARIABLE _install_result OUTPUT_VARIABLE _install_output ERROR_VARIABLE _install_error
+    )
+    if(NOT _install_result EQUAL 0)
+      message(FATAL_ERROR "robot_msg installation failed:\n${_install_output}\n${_install_error}")
+    endif()
+  endif()
+
+  execute_process(
+    COMMAND "${_python}" -I -c "from importlib.metadata import version; print(version('robot-msg-irsl'))"
+    RESULT_VARIABLE _version_result OUTPUT_VARIABLE _installed_version ERROR_VARIABLE _version_error
+    OUTPUT_STRIP_TRAILING_WHITESPACE
+  )
+  if(NOT _version_result EQUAL 0)
+    message(FATAL_ERROR "robot_msg installation verification failed: ${_version_error}")
+  endif()
+  if(RM_VERSION AND NOT _installed_version STREQUAL RM_VERSION)
+    message(FATAL_ERROR "robot_msg wheel version ${_installed_version} does not match requested ${RM_VERSION}")
+  endif()
+  execute_process(
+    COMMAND "${_python}" -I -m robot_msg --cmake-dir
+    RESULT_VARIABLE _config_result OUTPUT_VARIABLE robot_msg_DIR ERROR_VARIABLE _config_error
+    OUTPUT_STRIP_TRAILING_WHITESPACE
+  )
+  if(NOT _config_result EQUAL 0 OR NOT EXISTS "${robot_msg_DIR}/robot_msgConfig.cmake")
+    message(FATAL_ERROR "robot_msg CMake discovery failed: ${_config_error}")
+  endif()
+  if(NOT EXISTS "${_stamp}")
+    file(WRITE "${_stamp}" "${_identity}\n")
+  endif()
+  find_package(robot_msg CONFIG REQUIRED PATHS "${robot_msg_DIR}" NO_DEFAULT_PATH)
+  set(robot_msg_DIR "${robot_msg_DIR}" PARENT_SCOPE)
+  set(robot_msg_VERSION "${_installed_version}" PARENT_SCOPE)
+endfunction()

robot_msg/_assets/internal/cpp/cmake/robot_msgConfig.cmake.in

@@ -0,0 +1,4 @@
+@PACKAGE_INIT@
+
+include("${CMAKE_CURRENT_LIST_DIR}/robot_msgTargets.cmake")
+check_required_components(robot_msg)

robot_msg/_assets/internal/cpp/cmake/source/robot_msgConfig.cmake

@@ -0,0 +1,19 @@
+get_filename_component(_robot_msg_cpp_root "${CMAKE_CURRENT_LIST_DIR}/../.." ABSOLUTE)
+file(STRINGS "${_robot_msg_cpp_root}/../../VERSION" robot_msg_VERSION LIMIT_COUNT 1)
+
+if(robot_msg_FIND_COMPONENTS)
+  set(robot_msg_FOUND FALSE)
+  set(robot_msg_NOT_FOUND_MESSAGE "robot_msg does not define optional components")
+  return()
+endif()
+
+if(NOT TARGET robot_msg::robot_msg)
+  function(_robot_msg_add_source_library source)
+    set(ROBOT_MSG_SOURCE_PACKAGE ON)
+    add_subdirectory("${source}" "${CMAKE_BINARY_DIR}/_robot_msg/${robot_msg_VERSION}" EXCLUDE_FROM_ALL)
+  endfunction()
+  _robot_msg_add_source_library("${_robot_msg_cpp_root}")
+endif()
+
+set(robot_msg_FOUND TRUE)
+unset(_robot_msg_cpp_root)

robot_msg/_assets/internal/cpp/cmake/source/robot_msgConfigVersion.cmake

@@ -0,0 +1,7 @@
+file(STRINGS "${CMAKE_CURRENT_LIST_DIR}/../../../../VERSION" PACKAGE_VERSION LIMIT_COUNT 1)
+set(PACKAGE_VERSION_COMPATIBLE FALSE)
+set(PACKAGE_VERSION_EXACT FALSE)
+if(PACKAGE_FIND_VERSION VERSION_EQUAL PACKAGE_VERSION)
+  set(PACKAGE_VERSION_COMPATIBLE TRUE)
+  set(PACKAGE_VERSION_EXACT TRUE)
+endif()

robot_msg/_assets/internal/cpp/include/robot_msg/detail/compat.hpp

@@ -0,0 +1,221 @@
+#pragma once
+
+#include <cstddef>
+#include <cstring>
+#include <new>
+#include <stdexcept>
+#include <string>
+#include <type_traits>
+#include <utility>
+
+namespace robot_msg {
+
+struct nullopt_t {
+  explicit constexpr nullopt_t(int) {}
+};
+
+constexpr nullopt_t nullopt{0};
+
+template <typename T>
+class optional {
+ public:
+  optional() noexcept : engaged_(false) {}
+  optional(nullopt_t) noexcept : engaged_(false) {}
+  optional(const T& value) : engaged_(false) { construct(value); }
+  optional(T&& value) : engaged_(false) { construct(std::move(value)); }
+
+  optional(const optional& other) : engaged_(false) {
+    if (other.engaged_) {
+      construct(*other);
+    }
+  }
+
+  optional(optional&& other) noexcept(std::is_nothrow_move_constructible<T>::value)
+      : engaged_(false) {
+    if (other.engaged_) {
+      construct(std::move(*other));
+    }
+  }
+
+  ~optional() { reset(); }
+
+  optional& operator=(nullopt_t) noexcept {
+    reset();
+    return *this;
+  }
+
+  optional& operator=(const optional& other) {
+    if (engaged_ && other.engaged_) {
+      **this = *other;
+    } else if (other.engaged_) {
+      construct(*other);
+    } else {
+      reset();
+    }
+    return *this;
+  }
+
+  optional& operator=(optional&& other) noexcept(
+      std::is_nothrow_move_assignable<T>::value &&
+      std::is_nothrow_move_constructible<T>::value) {
+    if (engaged_ && other.engaged_) {
+      **this = std::move(*other);
+    } else if (other.engaged_) {
+      construct(std::move(*other));
+    } else {
+      reset();
+    }
+    return *this;
+  }
+
+  optional& operator=(const T& value) {
+    if (engaged_) {
+      **this = value;
+    } else {
+      construct(value);
+    }
+    return *this;
+  }
+
+  optional& operator=(T&& value) {
+    if (engaged_) {
+      **this = std::move(value);
+    } else {
+      construct(std::move(value));
+    }
+    return *this;
+  }
+
+  template <typename... Args>
+  T& emplace(Args&&... args) {
+    reset();
+    new (&storage_) T(std::forward<Args>(args)...);
+    engaged_ = true;
+    return **this;
+  }
+
+  void reset() noexcept {
+    if (engaged_) {
+      pointer()->~T();
+      engaged_ = false;
+    }
+  }
+
+  bool has_value() const noexcept { return engaged_; }
+  explicit operator bool() const noexcept { return engaged_; }
+
+  T& value() {
+    require_value();
+    return *pointer();
+  }
+
+  const T& value() const {
+    require_value();
+    return *pointer();
+  }
+
+  template <typename U>
+  T value_or(U&& fallback) const {
+    return engaged_ ? **this : static_cast<T>(std::forward<U>(fallback));
+  }
+
+  T& operator*() { return *pointer(); }
+  const T& operator*() const { return *pointer(); }
+  T* operator->() { return pointer(); }
+  const T* operator->() const { return pointer(); }
+
+ private:
+  using Storage = typename std::aligned_storage<sizeof(T), alignof(T)>::type;
+
+  template <typename U>
+  void construct(U&& value) {
+    new (&storage_) T(std::forward<U>(value));
+    engaged_ = true;
+  }
+
+  T* pointer() { return reinterpret_cast<T*>(&storage_); }
+  const T* pointer() const { return reinterpret_cast<const T*>(&storage_); }
+
+  void require_value() const {
+    if (!engaged_) {
+      throw std::logic_error("accessed an empty robot_msg::optional");
+    }
+  }
+
+  Storage storage_;
+  bool engaged_;
+};
+
+template <typename T>
+bool operator==(const optional<T>& left, const optional<T>& right) {
+  return left.has_value() == right.has_value() &&
+         (!left.has_value() || *left == *right);
+}
+
+template <typename T>
+bool operator!=(const optional<T>& left, const optional<T>& right) {
+  return !(left == right);
+}
+
+class string_view {
+ public:
+  using const_iterator = const char*;
+  static constexpr std::size_t npos = static_cast<std::size_t>(-1);
+
+  constexpr string_view() noexcept : data_(""), size_(0) {}
+  string_view(const char* value) : data_(value), size_(std::strlen(value)) {}
+  constexpr string_view(const char* value, std::size_t size) noexcept
+      : data_(value), size_(size) {}
+  string_view(const std::string& value) noexcept
+      : data_(value.data()), size_(value.size()) {}
+
+  constexpr const char* data() const noexcept { return data_; }
+  constexpr std::size_t size() const noexcept { return size_; }
+  constexpr bool empty() const noexcept { return size_ == 0; }
+  constexpr char operator[](std::size_t index) const { return data_[index]; }
+  constexpr const_iterator begin() const noexcept { return data_; }
+  constexpr const_iterator end() const noexcept { return data_ + size_; }
+
+  string_view substr(std::size_t position, std::size_t count = npos) const {
+    if (position > size_) {
+      throw std::out_of_range("robot_msg::string_view::substr");
+    }
+    const std::size_t remaining = size_ - position;
+    return string_view(data_ + position, count < remaining ? count : remaining);
+  }
+
+ private:
+  const char* data_;
+  std::size_t size_;
+};
+
+inline bool operator==(string_view left, string_view right) {
+  return left.size() == right.size() &&
+         (left.empty() || std::memcmp(left.data(), right.data(), left.size()) == 0);
+}
+
+inline bool operator!=(string_view left, string_view right) {
+  return !(left == right);
+}
+
+inline bool operator==(string_view left, const std::string& right) {
+  return left == string_view(right);
+}
+
+inline bool operator==(const std::string& left, string_view right) {
+  return string_view(left) == right;
+}
+
+inline bool operator!=(string_view left, const std::string& right) {
+  return !(left == right);
+}
+
+inline bool operator!=(const std::string& left, string_view right) {
+  return !(left == right);
+}
+
+inline std::string to_string(string_view value) {
+  return std::string(value.data(), value.size());
+}
+
+}  // namespace robot_msg