hyperverse 0.0.1__py3-none-any.whl

hyperdrone/_vendor/rl-tools/include/rl_tools/rl/utils/validation.h

@@ -0,0 +1,269 @@
+#include "../../version.h"
+#if (defined(RL_TOOLS_DISABLE_INCLUDE_GUARDS) || !defined(RL_TOOLS_RL_UTILS_VALIDATION_H)) && (RL_TOOLS_USE_THIS_VERSION == 1)
+#pragma once
+#define RL_TOOLS_RL_UTILS_VALIDATION_H
+
+#include "../../math/operations_generic.h"
+#include "../../utils/generic/typing.h"
+
+RL_TOOLS_NAMESPACE_WRAPPER_START
+namespace rl_tools::rl::utils::validation{
+    template <typename T_T, typename T_TI, typename T_ENVIRONMENT>
+    struct Specification{
+        using T = T_T;
+        using TI = T_TI;
+        using ENVIRONMENT = T_ENVIRONMENT;
+    };
+
+    template <typename T_SPEC, typename T_SPEC::TI SIZE>
+    struct EpisodeBuffer{
+        using SPEC = T_SPEC;
+        MatrixDynamic<matrix::Specification<typename SPEC::ENVIRONMENT::State, typename SPEC::TI, SIZE, 1>> states;
+        MatrixDynamic<matrix::Specification<typename SPEC::T, typename SPEC::TI, SIZE, SPEC::ENVIRONMENT::ACTION_DIM>> actions;
+        MatrixDynamic<matrix::Specification<typename SPEC::ENVIRONMENT::State, typename SPEC::TI, SIZE, 1>> next_states;
+        MatrixDynamic<matrix::Specification<typename SPEC::T, typename SPEC::TI, SIZE, 1>> rewards;
+        MatrixDynamic<matrix::Specification<bool, typename SPEC::TI, SIZE, 1>> terminated;
+    };
+
+    template <typename T_SPEC, typename T_SPEC::TI T_N_EPISODES, typename T_SPEC::TI T_MAX_EPISODE_LENGTH>
+    struct TaskSpecification{
+        using SPEC = T_SPEC;
+        using T = typename SPEC::T;
+        using TI = typename SPEC::TI;
+        static constexpr auto N_EPISODES = T_N_EPISODES;
+        static constexpr auto MAX_EPISODE_LENGTH = T_MAX_EPISODE_LENGTH;
+    };
+    template <typename T_SPEC>
+    struct Task{
+        using SPEC = T_SPEC;
+        using T = typename SPEC::T;
+        using TI = typename SPEC::TI;
+        using ENVIRONMENT = typename SPEC::SPEC::ENVIRONMENT;
+        TI step = 0;
+        EpisodeBuffer<typename SPEC::SPEC, SPEC::MAX_EPISODE_LENGTH> episode_buffer[SPEC::N_EPISODES];
+        MatrixDynamic<matrix::Specification<T, TI, SPEC::N_EPISODES, ENVIRONMENT::Observation::DIM>> observation_buffer;
+        MatrixDynamic<matrix::Specification<T, TI, SPEC::N_EPISODES, ENVIRONMENT::ACTION_DIM>> action_buffer;
+        TI episode_length[SPEC::N_EPISODES];
+        bool terminated[SPEC::N_EPISODES];
+        ENVIRONMENT environment[SPEC::N_EPISODES];
+        typename ENVIRONMENT::State state[SPEC::N_EPISODES];
+        bool completed = false;
+    };
+    struct Metric{ };
+    namespace tasks{
+        template <typename T_SPEC>
+        struct Default: Task<T_SPEC>{ };
+    };
+    namespace metrics{
+        struct ReturnMean: Metric{};
+        struct ReturnStd: Metric{};
+        struct EpisodeLengthMean: Metric{};
+        struct EpisodeLengthStd: Metric{};
+        struct TerminatedFraction: Metric{};
+    };
+    namespace set{
+        template <typename T_CONTENT, typename T_NEXT_COMPONENT>
+        struct Component{
+            using CONTENT = T_CONTENT;
+            using NEXT_COMPONENT = T_NEXT_COMPONENT;
+        };
+        struct FinalComponent{};
+    };
+    template <typename NEXT_COMPONENT = set::FinalComponent>
+    using DefaultMetrics = set::Component<
+            metrics::ReturnMean,
+            set::Component<metrics::ReturnStd,
+            set::Component<metrics::EpisodeLengthMean,
+            set::Component<metrics::EpisodeLengthStd,
+            set::Component<metrics::TerminatedFraction,
+            NEXT_COMPONENT>>>>>;
+}
+namespace rl_tools{
+    template <typename DEVICE, typename SPEC, typename SPEC::TI SIZE>
+    void malloc(DEVICE& device, rl::utils::validation::EpisodeBuffer<SPEC, SIZE>& eb){
+        malloc(device, eb.states);
+        malloc(device, eb.actions);
+        malloc(device, eb.next_states);
+        malloc(device, eb.rewards);
+        malloc(device, eb.terminated);
+    }
+    template <typename DEVICE, typename SPEC, typename SPEC::TI SIZE>
+    void free(DEVICE& device, rl::utils::validation::EpisodeBuffer<SPEC, SIZE>& eb){
+        free(device, eb.states);
+        free(device, eb.actions);
+        free(device, eb.next_states);
+        free(device, eb.rewards);
+        free(device, eb.terminated);
+    }
+    template <typename DEVICE, typename SPEC, typename RNG>
+    void reset(DEVICE& device, rl::utils::validation::Task<SPEC>& task, RNG& rng){
+        using TI = typename DEVICE::index_t;
+        task.completed = false;
+        task.step = 0;
+        for(TI i = 0; i < SPEC::N_EPISODES; i++){
+            sample_initial_state(device, task.environment[i], task.state[i], rng);
+            task.episode_length[i] = 0;
+            task.terminated[i] = false;
+        }
+    }
+    template <typename DEVICE, typename SPEC, typename RNG>
+    void init(DEVICE& device, rl::utils::validation::Task<SPEC>& task, typename SPEC::SPEC::ENVIRONMENT envs[SPEC::N_EPISODES], RNG& rng){
+        using TI = typename SPEC::TI;
+        for(TI i = 0; i < SPEC::N_EPISODES; i++){
+            task.environment[i] = envs[i];
+            malloc(device, task.episode_buffer[i]);
+        }
+        malloc(device, task.observation_buffer);
+        malloc(device, task.action_buffer);
+        reset(device, task, rng);
+    }
+    template <typename DEVICE, typename SPEC, typename POLICY, typename POLICY_BUFFERS, typename RNG>
+    bool step(DEVICE& device, rl::utils::validation::Task<SPEC>& task, POLICY& policy, POLICY_BUFFERS& buffers, RNG& rng){
+        using TI = typename SPEC::TI;
+        using T = typename SPEC::T;
+        if(!task.completed){
+            for(TI episode_i = 0; episode_i < SPEC::N_EPISODES; episode_i++){
+                auto observation = row(device, task.observation_buffer, episode_i);
+                observe(device, task.environment[episode_i], task.state[episode_i], observation, rng);
+            }
+            evaluate(device, policy, task.observation_buffer, task.action_buffer, buffers);
+
+            for(TI episode_i = 0; episode_i < SPEC::N_EPISODES; episode_i++){
+                auto& eb = task.episode_buffer[episode_i];
+                bool terminated_flag = true;
+                if(task.step == 0 || !get(eb.terminated, task.step - 1, 0)){
+                    auto action = row(device, task.action_buffer, episode_i);
+                    auto action_buffer = row(device, eb.actions, task.step);
+                    copy(device, device, action, action_buffer);
+                    set(eb.states, task.step, 0, task.state[episode_i]);
+                    step(device, task.environment[episode_i], task.state[episode_i], action, get(eb.next_states, task.step, 0), rng);
+                    T step_reward = reward(device, task.environment[episode_i], task.state[episode_i], action, get(eb.next_states, task.step, 0), rng);
+                    set(eb.rewards, task.step, 0, step_reward);
+
+                    task.state[episode_i] = get(eb.next_states, task.step, 0);
+                    terminated_flag = terminated(device, task.environment[episode_i], task.state[episode_i], rng);
+                    if(!terminated_flag){
+                        task.episode_length[episode_i] = task.step + 1;
+                    }
+                }
+                task.terminated[episode_i] = terminated_flag;
+                set(eb.terminated, task.step, 0, terminated_flag);
+            }
+            if(task.step == SPEC::MAX_EPISODE_LENGTH - 1){
+                task.completed = true;
+            }
+            else{
+                task.step++;
+            }
+        }
+        return task.completed;
+    }
+    template <typename DEVICE, typename SPEC>
+    void destroy(DEVICE& device, rl::utils::validation::Task<SPEC>& task){
+        using TI = typename SPEC::TI;
+        for(TI i = 0; i < SPEC::N_EPISODES; i++){
+            free(device, task.episode_buffer[i]);
+        }
+        free(device, task.observation_buffer);
+        free(device, task.action_buffer);
+    }
+    template <typename DEVICE, typename CONTENT, typename NEXT_COMPONENT>
+    constexpr typename DEVICE::index_t length(DEVICE& device, rl::utils::validation::set::Component<CONTENT, NEXT_COMPONENT>){
+        if constexpr (utils::typing::is_same_v<NEXT_COMPONENT, rl::utils::validation::set::FinalComponent>){
+            return 0;
+        }
+        else{
+            return 1 + length(device, NEXT_COMPONENT{});
+        }
+    }
+    template <typename DEVICE, typename CONTENT, typename NEXT_COMPONENT, auto I>
+    constexpr auto get(DEVICE& device, rl::utils::validation::set::Component<CONTENT, NEXT_COMPONENT>, Constant<I>){
+        using COMPONENT = rl::utils::validation::set::Component<CONTENT, NEXT_COMPONENT>;
+        static_assert(I < length(device, COMPONENT{}), "Index out of bounds");
+        if constexpr (I == 0){
+            return CONTENT{};
+        }
+        else{
+            return get(device, NEXT_COMPONENT{}, Constant<I-1>{});
+        }
+    }
+    auto constexpr name(rl::utils::validation::metrics::ReturnMean){return "ReturnMean";}
+    auto constexpr name(rl::utils::validation::metrics::ReturnStd){return "ReturnStd";}
+    auto constexpr name(rl::utils::validation::metrics::EpisodeLengthMean){return "EpisodeLengthMean";}
+    auto constexpr name(rl::utils::validation::metrics::EpisodeLengthStd){return "EpisodeLengthStd";}
+    auto constexpr name(rl::utils::validation::metrics::TerminatedFraction){return "TerminatedFraction";}
+    template <typename DEVICE, typename SPEC>
+    typename SPEC::T evaluate(DEVICE& device, rl::utils::validation::metrics::ReturnMean, rl::utils::validation::Task<SPEC>& task){
+        utils::assert_exit(device, task.completed, "Task is not completed");
+        using TI = typename SPEC::TI;
+        using T = typename SPEC::T;
+        T return_sum = 0;
+        for(TI episode_i = 0; episode_i < SPEC::N_EPISODES; episode_i++){
+            auto& eb = task.episode_buffer[episode_i];
+            for(TI step_i = 0; step_i < task.episode_length[episode_i]; step_i++){
+                return_sum += get(eb.rewards, step_i, 0);
+                if(step_i == task.episode_length[episode_i] - 1){
+                    break;
+                }
+            }
+        }
+        return return_sum / SPEC::N_EPISODES;
+    }
+    template <typename DEVICE, typename SPEC>
+    typename SPEC::T evaluate(DEVICE& device, rl::utils::validation::metrics::ReturnStd, rl::utils::validation::Task<SPEC>& task){
+        utils::assert_exit(device, task.completed, "Task is not completed");
+        using TI = typename SPEC::TI;
+        using T = typename SPEC::T;
+        T mean = evaluate(device, rl::utils::validation::metrics::ReturnMean{}, task);
+        T variance_sum = 0;
+        for(TI episode_i = 0; episode_i < SPEC::N_EPISODES; episode_i++){
+            T return_sum = 0;
+            auto& eb = task.episode_buffer[episode_i];
+            for(TI step_i = 0; step_i < task.episode_length[episode_i]; step_i++){
+                return_sum += get(eb.rewards, step_i, 0);
+            }
+            variance_sum += (return_sum - mean)*(return_sum - mean);
+        }
+        return math::sqrt(device.math, variance_sum / SPEC::N_EPISODES);
+    }
+    template <typename DEVICE, typename SPEC>
+    typename SPEC::T evaluate(DEVICE& device, rl::utils::validation::metrics::EpisodeLengthMean, rl::utils::validation::Task<SPEC>& task){
+        utils::assert_exit(device, task.completed, "Task is not completed");
+        using TI = typename SPEC::TI;
+        using T = typename SPEC::T;
+        T return_sum = 0;
+        for(TI episode_i = 0; episode_i < SPEC::N_EPISODES; episode_i++){
+            return_sum += task.episode_length[episode_i];
+        }
+        return return_sum / SPEC::N_EPISODES;
+    }
+    template <typename DEVICE, typename SPEC>
+    typename SPEC::T evaluate(DEVICE& device, rl::utils::validation::metrics::EpisodeLengthStd, rl::utils::validation::Task<SPEC>& task){
+        utils::assert_exit(device, task.completed, "Task is not completed");
+        using TI = typename SPEC::TI;
+        using T = typename SPEC::T;
+        T mean = evaluate(device, rl::utils::validation::metrics::EpisodeLengthMean{}, task);
+        T return_sum = 0;
+        for(TI episode_i = 0; episode_i < SPEC::N_EPISODES; episode_i++){
+            T diff = task.episode_length[episode_i] - mean;
+            return_sum += diff*diff;
+        }
+        return math::sqrt(device.math, return_sum / SPEC::N_EPISODES);
+    }
+    template <typename DEVICE, typename SPEC>
+    typename SPEC::T evaluate(DEVICE& device, rl::utils::validation::metrics::TerminatedFraction, rl::utils::validation::Task<SPEC>& task){
+        utils::assert_exit(device, task.completed, "Task is not completed");
+        using TI = typename SPEC::TI;
+        using T = typename SPEC::T;
+        T terminated = 0;
+        for(TI episode_i = 0; episode_i < SPEC::N_EPISODES; episode_i++){
+            if(task.episode_length[episode_i] != SPEC::MAX_EPISODE_LENGTH){
+                terminated += 1;
+            }
+        }
+        return terminated / SPEC::N_EPISODES;
+    }
+
+};
+RL_TOOLS_NAMESPACE_WRAPPER_END
+#endif

hyperdrone/_vendor/rl-tools/include/rl_tools/rl/utils/validation_analysis.h

@@ -0,0 +1,85 @@
+#include "../../version.h"
+#if (defined(RL_TOOLS_DISABLE_INCLUDE_GUARDS) || !defined(RL_TOOLS_RL_UTILS_VALIDATION_ANALYSIS_H)) && (RL_TOOLS_USE_THIS_VERSION == 1)
+#pragma once
+#define RL_TOOLS_RL_UTILS_VALIDATION_ANALYSIS_H
+
+#include <string>
+#include <vector>
+#include <map>
+#include "../../utils/generic/typing.h"
+#ifdef RL_TOOLS_ENABLE_JSON
+#include <nlohmann/json.hpp>
+#endif
+RL_TOOLS_NAMESPACE_WRAPPER_START
+namespace rl_tools{
+    namespace rl::utils::validation{
+        template <typename DEVICE, typename SPEC, typename CONTENT, typename NEXT_COMPONENT>
+        void analyse_step_log(DEVICE& device, Task<SPEC>& task, rl::utils::validation::set::Component<CONTENT, NEXT_COMPONENT>){
+            using COMPONENT = rl::utils::validation::set::Component<CONTENT, NEXT_COMPONENT>;
+            using T = typename SPEC::T;
+            std::string n = name(CONTENT{});
+            T value = evaluate(device, CONTENT{}, task);
+            add_scalar(device, device.logger, std::string("validation/") + n, value);
+            if constexpr (!rl_tools::utils::typing::is_same_v<NEXT_COMPONENT, rl::utils::validation::set::FinalComponent>){
+                analyse_step_log(device, task, typename COMPONENT::NEXT_COMPONENT{});
+            }
+        }
+        template <typename DEVICE, typename SPEC, typename CONTENT, typename NEXT_COMPONENT>
+        void analyse_step_string(DEVICE& device, Task<SPEC>& task, std::vector<std::string>& metric_names, std::vector<typename SPEC::T>& metric_values, rl::utils::validation::set::Component<CONTENT, NEXT_COMPONENT>){
+            using COMPONENT = rl::utils::validation::set::Component<CONTENT, NEXT_COMPONENT>;
+            using T = typename SPEC::T;
+            std::string n = name(CONTENT{});
+            T value = evaluate(device, CONTENT{}, task);
+            add_scalar(device, device.logger, std::string("validation/") + n, value);
+            metric_names.push_back(n);
+            metric_values.push_back(value);
+            if constexpr (!rl_tools::utils::typing::is_same_v<NEXT_COMPONENT, rl::utils::validation::set::FinalComponent>){
+                analyse_step_string(device, task, metric_names, metric_values, typename COMPONENT::NEXT_COMPONENT{});
+            }
+        }
+    }
+    template <typename DEVICE, typename SPEC, typename METRICS>
+    void analyse_stdout(DEVICE& device, rl::utils::validation::Task<SPEC>& task, METRICS){
+        using TI = typename SPEC::TI;
+        std::vector<std::string> metric_names;
+        std::vector<typename SPEC::T> metric_values;
+        analyse_step_string(device, task, metric_names, metric_values, METRICS{});
+        for(typename SPEC::TI metric_i = 0; metric_i < metric_names.size(); metric_i++){
+            std::string name = metric_names[metric_i];
+            constexpr TI n = 40;
+            std::string padded_name = name + std::string(n > name.length() ? n - name.length() : 0, ' ');
+            std::cout << padded_name << ": " << metric_values[metric_i] << std::endl;
+        }
+    }
+    template <typename DEVICE, typename SPEC, typename METRICS>
+    void analyse_log(DEVICE& device, rl::utils::validation::Task<SPEC>& task, METRICS){
+        using TI = typename SPEC::TI;
+        analyse_step_log(device, task, METRICS{});
+    }
+    template <typename DEVICE, typename SPEC, typename METRICS>
+    std::map<std::string, typename SPEC::T> analyse_dict(DEVICE& device, rl::utils::validation::Task<SPEC>& task, METRICS){
+        using TI = typename SPEC::TI;
+        std::vector<std::string> metric_names;
+        std::vector<typename SPEC::T> metric_values;
+        analyse_step_string(device, task, metric_names, metric_values, METRICS{});
+        std::map<std::string, typename SPEC::T> metrics;
+        for(typename SPEC::TI metric_i = 0; metric_i < metric_names.size(); metric_i++){
+            std::string name = metric_names[metric_i];
+            metrics[name] = metric_values[metric_i];
+        }
+        return metrics;
+    }
+#ifdef RL_TOOLS_ENABLE_JSON
+    template <typename DEVICE, typename SPEC, typename METRICS>
+    nlohmann::json analyse_json(DEVICE& device, rl::utils::validation::Task<SPEC>& task, METRICS){
+        auto metrics = analyse_dict(device, task, METRICS{});
+        std::map<std::string, double> metrics_double;
+        for(auto& [name, value]: metrics){
+            metrics_double[name] = value;
+        }
+        return metrics_double;
+    }
+#endif
+}
+RL_TOOLS_NAMESPACE_WRAPPER_END
+#endif

hyperdrone/_vendor/rl-tools/include/rl_tools/rl_tools.h

@@ -0,0 +1,80 @@
+#include "version.h"
+#if (defined(RL_TOOLS_DISABLE_INCLUDE_GUARDS) || !defined(RL_TOOLS_RL_TOOLS_H)) && (RL_TOOLS_USE_THIS_VERSION == 1)
+#pragma once
+#define RL_TOOLS_RL_TOOLS_H
+//#define RL_TOOLS_NAMESPACE_WRAPPER test_ns
+#ifndef RL_TOOLS_NAMESPACE_WRAPPER
+#define RL_TOOLS_NAMESPACE_WRAPPER
+#define RL_TOOLS_NAMESPACE_WRAPPER_START
+#define RL_TOOLS_NAMESPACE_WRAPPER_END
+#else
+#define RL_TOOLS_NAMESPACE RL_TOOLS_NAMESPACE_WRAPPER ::rl_tools
+#define RL_TOOLS_NAMESPACE_WRAPPER_START namespace RL_TOOLS_NAMESPACE_WRAPPER {
+#define RL_TOOLS_NAMESPACE_WRAPPER_END }
+#endif
+
+// Execution-space contract: RL_TOOLS_FUNCTION_PLACEMENT promises that every callee of the function is available in every execution space the function is instantiated for.
+// Backend leaves that need host facilities (kernel launches, cuBLAS/cuDNN, memcpy, host RNG, standard I/O) keep the placement but wrap their single statement in RL_TOOLS_HOST_ONLY:
+// the statement in the host pass and a call to the undefined device sentinel in device passes, so a kernel reaching them fails at device link time instead of compiling silently.
+// Tag-device leaves mirror this with RL_TOOLS_DEVICE_ONLY and the host sentinel. This is the only place that tests the compilation pass.
+#ifndef RL_TOOLS_FUNCTION_PLACEMENT
+    #if defined(__CUDACC__)
+        #define RL_TOOLS_FUNCTION_PLACEMENT __host__ __device__
+    #else
+        #define RL_TOOLS_FUNCTION_PLACEMENT
+    #endif
+#endif
+// The sentinel is instantiated with decltype of the guarded expression: naming the expression keeps it unevaluated (no cross-execution-space call), yet forces the
+// host implementation to be instantiated when it has a deduced return type, which is what makes the device pass see the kernel template instantiations inside it.
+#if defined(__CUDA_ARCH__)
+    #define RL_TOOLS_HOST_ONLY(...) RL_TOOLS_NAMESPACE_WRAPPER ::rl_tools::detail::host_only_operation_called_from_device<decltype(__VA_ARGS__)>()
+    #define RL_TOOLS_DEVICE_ONLY(...) (__VA_ARGS__)
+#else
+    #define RL_TOOLS_HOST_ONLY(...) (__VA_ARGS__)
+    #define RL_TOOLS_DEVICE_ONLY(...) RL_TOOLS_NAMESPACE_WRAPPER ::rl_tools::detail::device_only_operation_called_from_host<decltype(__VA_ARGS__)>()
+#endif
+#if defined(__CUDACC_RDC__)
+#include <cstdio>
+#endif
+
+RL_TOOLS_NAMESPACE_WRAPPER_START
+namespace rl_tools{
+    namespace detail{
+#if defined(__CUDACC__)
+    #if defined(__CUDACC_RDC__)
+        // relocatable device code resolves undefined device symbols at module load and fails silently, so trap loudly instead
+        template <typename T>
+        [[noreturn]] __device__ inline T host_only_operation_called_from_device(){
+            printf("RLtools: host-only operation reached from device code\n");
+            while(true){
+                __trap();
+            }
+        }
+    #else
+        template <typename T>
+        [[noreturn]] __device__ T host_only_operation_called_from_device();
+    #endif
+#endif
+        template <typename T>
+        [[noreturn]] T device_only_operation_called_from_host();
+    }
+    template <auto T_C>
+    struct Constant{
+        static constexpr auto C = T_C;
+    };
+}
+RL_TOOLS_NAMESPACE_WRAPPER_END
+
+#if defined(_MSC_VER)
+    #define RL_TOOLS_RESTRICT __restrict
+#elif defined(__GNUC__) || defined(__clang__)
+    #define RL_TOOLS_RESTRICT __restrict__
+#else
+    #define RL_TOOLS_RESTRICT
+#endif
+
+
+#endif
+
+//#define RL_TOOLS_TARGET_COMMIT_HASH 111f0b82ba87ee4f1938f4d85ee2d266e70f4498
+//#define RL_TOOLS_TARGET_COMMIT_HASH_SHORT 1122059

hyperdrone/_vendor/rl-tools/include/rl_tools/ui_server/client/client.h

@@ -0,0 +1,50 @@
+#include "../../version.h"
+#if (defined(RL_TOOLS_DISABLE_INCLUDE_GUARDS) || !defined(RL_TOOLS_UI_SERVER_CLIENT_CLIENT_H)) && (RL_TOOLS_USE_THIS_VERSION == 1)
+#pragma once
+#define RL_TOOLS_UI_SERVER_CLIENT_CLIENT_H
+#include <queue>
+#ifdef RL_TOOLS_ENABLE_LIBWEBSOCKETS
+#include <libwebsockets.h>
+#include <thread>
+#include <mutex>
+#endif
+
+RL_TOOLS_NAMESPACE_WRAPPER_START
+namespace rl_tools::ui_server::client{
+    template<typename T_ENVIRONMENT>
+    struct UIJSON{
+        std::string ns = "";
+    };
+
+    template<typename T_ENVIRONMENT>
+    struct UIBuffered: UIJSON<T_ENVIRONMENT>{
+        std::queue<std::string> buffer;
+    };
+#ifdef RL_TOOLS_ENABLE_LIBWEBSOCKETS
+    template<typename T_ENVIRONMENT>
+    struct UIWebSocket: UIJSON<T_ENVIRONMENT>{
+        using TI = typename T_ENVIRONMENT::TI;
+        bool connected;
+        bool error;
+        bool interrupt;
+        bool verbose;
+        std::string address = "";
+        TI port = 0;
+        TI sync_interval = 1000;
+        std::thread thread;
+        std::queue<std::string> message_queue;
+        std::mutex message_queue_mutex;
+        struct lws_context_creation_info ctx_info;
+        struct lws_client_connect_info conn_info;
+        struct lws_context *context;
+        struct lws *wsi;
+        struct lws_protocols protocols[];
+    };
+#endif
+
+
+
+}
+RL_TOOLS_NAMESPACE_WRAPPER_END
+
+#endif

hyperdrone/_vendor/rl-tools/include/rl_tools/ui_server/client/operations_boost.h

@@ -0,0 +1,92 @@
+#include "../../version.h"
+#if (defined(RL_TOOLS_DISABLE_INCLUDE_GUARDS) || !defined(RL_TOOLS_UI_SERVER_CLIENT_OPERATIONS_BOOST_H)) && (RL_TOOLS_USE_THIS_VERSION == 1)
+#pragma once
+#define RL_TOOLS_UI_SERVER_CLIENT_OPERATIONS_BOOST_H
+
+#include "operations_cpu.h"
+
+#include <boost/beast/core.hpp>
+#include <boost/beast/websocket.hpp>
+#include <boost/asio/connect.hpp>
+#include <boost/asio/ip/tcp.hpp>
+
+#include <nlohmann/json.hpp>
+#include <thread>
+#include <chrono>
+
+RL_TOOLS_NAMESPACE_WRAPPER_START
+namespace rl_tools{
+    namespace ui_server::client{
+        namespace beast = boost::beast;
+        namespace http = beast::http;
+        namespace websocket = beast::websocket;
+        namespace net = boost::asio;
+        using tcp = boost::asio::ip::tcp;
+        template<typename T_ENVIRONMENT>
+        struct UI: UIBuffered<T_ENVIRONMENT>{
+            using ENVIRONMENT = T_ENVIRONMENT;
+            std::string host = "localhost";
+            std::string port = "8000";
+            net::io_context ioc;
+            websocket::stream <tcp::socket> ws{ioc};
+        };
+    }
+    template <typename DEVICE, typename ENVIRONMENT>
+    void _flush(DEVICE& dev, ui_server::client::UI<ENVIRONMENT>& ui){
+        if (ui.ws.is_open()) {
+            while(!ui.buffer.empty()){
+                ui.ws.write(boost::beast::net::buffer(ui.buffer.front()));
+                ui.buffer.pop();
+            }
+        }
+        else{
+            std::cerr << "Error: websocket is not open" << std::endl;
+        }
+    }
+    template <typename DEVICE, typename ENVIRONMENT>
+    void init(DEVICE& dev, ENVIRONMENT& env, ui_server::client::UI<ENVIRONMENT>& ui){
+        namespace beast = boost::beast;         // from <boost/beast.hpp>
+        namespace http = beast::http;           // from <boost/beast/http.hpp>
+        namespace websocket = beast::websocket; // from <boost/beast/websocket.hpp>
+        namespace net = boost::asio;            // from <boost/asio.hpp>
+        using tcp = boost::asio::ip::tcp;       // from <boost/asio/ip/tcp.hpp>
+        tcp::resolver resolver{ui.ioc};
+        auto const results = resolver.resolve(ui.host, ui.port);
+
+        net::connect(ui.ws.next_layer(), results.begin(), results.end());
+        ui.ws.handshake(ui.host, "/backend");
+        std::cout << "Waiting for handshake" << std::endl;
+        boost::beast::flat_buffer buffer;
+        ui.ws.read(buffer);
+        std::cout << beast::make_printable(buffer.data()) << std::endl;
+        auto message_string = beast::buffers_to_string(buffer.data());
+        std::cout << "Handshake received: " << message_string << std::endl;
+        buffer.consume(buffer.size());
+        auto message = nlohmann::json::parse(message_string);
+        ui.ns = message["data"]["namespace"];
+
+        init(dev, env, static_cast<ui_server::client::UIBuffered<ENVIRONMENT>&>(ui));
+        _flush(dev, ui);
+    }
+    template <typename DEVICE, typename ENVIRONMENT>
+    void set_state(DEVICE& dev, ENVIRONMENT& env, ui_server::client::UI<ENVIRONMENT>& ui, const typename ENVIRONMENT::State& state){
+        set_state(dev, env, static_cast<ui_server::client::UIBuffered<ENVIRONMENT>&>(ui), state);
+        _flush(dev, ui);
+    }
+    template <typename DEVICE, typename ENVIRONMENT, typename ACTION_SPEC>
+    void set_state(DEVICE& dev, ENVIRONMENT& env, ui_server::client::UI<ENVIRONMENT>& ui, const typename ENVIRONMENT::State& state, const Matrix<ACTION_SPEC>& action){
+        set_state(dev, env, static_cast<ui_server::client::UIBuffered<ENVIRONMENT>&>(ui), state, action);
+        _flush(dev, ui);
+    }
+    template <typename DEVICE, typename ENVIRONMENT, typename ACTION_SPEC>
+    void set_action(DEVICE& dev, ENVIRONMENT& env, ui_server::client::UI<ENVIRONMENT>& ui, const Matrix<ACTION_SPEC>& action){
+        set_action(dev, env, static_cast<ui_server::client::UIBuffered<ENVIRONMENT>&>(ui), action);
+        _flush(dev, ui);
+    }
+    template <typename DEVICE, typename ENVIRONMENT>
+    void render(DEVICE& dev, ENVIRONMENT& env, ui_server::client::UI<ENVIRONMENT>& ui){
+        std::this_thread::sleep_for(std::chrono::duration<decltype(env.parameters.dt)>((env.parameters.dt)));
+    }
+}
+RL_TOOLS_NAMESPACE_WRAPPER_END
+#endif