hyperdrone 0.1.0__py3-none-any.whl

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

@@ -0,0 +1,174 @@
+#include "../../version.h"
+#if (defined(RL_TOOLS_DISABLE_INCLUDE_GUARDS) || !defined(RL_TOOLS_UI_SERVER_CLIENT_OPERATIONS_CPU_H)) && (RL_TOOLS_USE_THIS_VERSION == 1)
+#pragma once
+#define RL_TOOLS_UI_SERVER_CLIENT_OPERATIONS_CPU_H
+
+#include "client.h"
+
+#include <thread>
+#include <chrono>
+
+RL_TOOLS_NAMESPACE_WRAPPER_START
+namespace rl_tools{
+    namespace ui_server::client{
+        std::string escape_json_string(const std::string& input) {
+            std::string output;
+            output.reserve(input.size());
+
+            for (char c : input) {
+                switch (c) {
+                    case '"':  output += "\\\""; break;
+                    case '\\': output += "\\\\"; break;
+                    case '\b': output += "\\b"; break;
+                    case '\f': output += "\\f"; break;
+                    case '\n': output += "\\n"; break;
+                    case '\r': output += "\\r"; break;
+                    case '\t': output += "\\t"; break;
+                    default:
+                        if ('\x00' <= c && c <= '\x1f') {
+                            // Control characters need to be escaped as \uXXXX
+                            output += "\\u";
+                            output += "0123456789abcdef"[(c >> 12) & 0xF];
+                            output += "0123456789abcdef"[(c >> 8) & 0xF];
+                            output += "0123456789abcdef"[(c >> 4) & 0xF];
+                            output += "0123456789abcdef"[c & 0xF];
+                        } else {
+                            output += c;
+                        }
+                }
+            }
+            return output;
+        }
+    }
+    template <typename DEVICE, typename ENVIRONMENT>
+    std::string parameters_message(DEVICE& dev, ENVIRONMENT& env, typename ENVIRONMENT::Parameters& parameters, ui_server::client::UIJSON<ENVIRONMENT>& ui){
+        std::string parameters_json = json(dev, env, parameters);
+        std::string parameters_message = "{";
+        parameters_message += "\"namespace\": \"" + ui.ns + "\", ";
+        parameters_message += "\"channel\": \"setParameters\", ";
+        parameters_message += "\"data\": " + parameters_json;
+        parameters_message += "}";
+        return parameters_message;
+    }
+    template <typename DEVICE, typename ENVIRONMENT>
+    std::string set_ui_message(DEVICE& dev, ENVIRONMENT& env, ui_server::client::UIJSON<ENVIRONMENT>& ui, std::string render_function){
+        std::string message = "{";
+        message += "\"namespace\": \"" + ui.ns + "\", ";
+        message += "\"channel\": \"setUI\", ";
+        message += "\"latch\": true, ";
+        std::string data = "{";
+        data += "\"type\": \"2d\", ";
+        data += "\"render_function\": \"" + ui_server::client::escape_json_string(render_function) + "\"";
+        data += "}";
+        message += "\"data\": " + data;
+        message += "}";
+        return message;
+    }
+    template <typename DEVICE, typename ENVIRONMENT>
+    std::string set_state_message(DEVICE& dev, ENVIRONMENT& env, const typename ENVIRONMENT::Parameters& parameters, ui_server::client::UIJSON<ENVIRONMENT>& ui, const typename ENVIRONMENT::State& state){
+        std::string message = "{";
+        message += "\"namespace\": \"" + ui.ns + "\", ";
+        message += "\"channel\": \"setState\", ";
+        std::string data = "{";
+        data += "\"state\": " + std::string(json(dev, env, parameters, state));
+        data += "}";
+        message += "\"data\": " + data;
+        message += "}";
+        return message;
+    }
+    template <typename DEVICE, typename ENVIRONMENT>
+    std::string set_truncated_message(DEVICE& dev, ENVIRONMENT& env, const typename ENVIRONMENT::Parameters& parameters, ui_server::client::UIJSON<ENVIRONMENT>& ui, const typename ENVIRONMENT::State& state){
+        std::string message = "{";
+        message += "\"namespace\": \"" + ui.ns + "\", ";
+        message += "\"channel\": \"setTruncated\", ";
+        std::string data = "{";
+        data += "\"state\": " + std::string(json(dev, env, parameters, state));
+        data += "}";
+        message += "\"data\": " + data;
+        message += "}";
+        return message;
+    }
+    template <typename DEVICE, typename ENVIRONMENT, typename ACTION_SPEC>
+    std::string action_data(DEVICE& dev, ENVIRONMENT& env, ui_server::client::UIJSON<ENVIRONMENT>& ui, const Matrix<ACTION_SPEC>& action){
+        static_assert(ACTION_SPEC::COLS == ENVIRONMENT::ACTION_DIM);
+//        static_assert(ACTION_SPEC::ROWS == 1);
+        using T = typename ACTION_SPEC::T;
+        using TI = typename DEVICE::index_t;
+        std::string action_data = "[";
+        for(TI row_i = 0; row_i < ACTION_SPEC::ROWS; row_i++){
+            action_data += "[";
+            for(TI action_i = 0; action_i < ACTION_SPEC::COLS; action_i++){
+                action_data += std::to_string(get(action, row_i, action_i));
+                if(action_i < ACTION_SPEC::COLS - 1){
+                    action_data += ", ";
+                }
+            }
+            action_data += "]";
+            if(row_i < ACTION_SPEC::ROWS - 1){
+                action_data += ", ";
+            }
+        }
+        action_data += "]";
+        return action_data;
+    }
+    template <typename DEVICE, typename ENVIRONMENT, typename ACTION_SPEC>
+    std::string set_state_action_message(DEVICE& dev, ENVIRONMENT& env, const typename ENVIRONMENT::Parameters& parameters, ui_server::client::UIJSON<ENVIRONMENT>& ui, const typename ENVIRONMENT::State& state, const Matrix<ACTION_SPEC>& action){
+        static_assert(ACTION_SPEC::COLS == ENVIRONMENT::ACTION_DIM);
+//        static_assert(ACTION_SPEC::ROWS == 1);
+        using T = typename ACTION_SPEC::T;
+        using TI = typename DEVICE::index_t;
+        std::string message = set_state_message(dev, env, parameters, ui, state);
+        message = message.substr(0, message.size()-2);
+        message += ", \"action\": " + action_data(dev, env, ui, action);
+        message += "}}";
+        return message;
+    }
+    template <typename DEVICE, typename ENVIRONMENT, typename ACTION_SPEC>
+    std::string set_action_message(DEVICE& dev, ENVIRONMENT& env, const typename ENVIRONMENT::Parameters& parameters, ui_server::client::UIJSON<ENVIRONMENT>& ui, const Matrix<ACTION_SPEC>& action){
+        static_assert(ACTION_SPEC::COLS == ENVIRONMENT::ACTION_DIM);
+        static_assert(ACTION_SPEC::ROWS == 1);
+        using T = typename ACTION_SPEC::T;
+        using TI = typename DEVICE::index_t;
+        std::string message = "{";
+        message += "\"namespace\": " + ui.ns + ", ";
+        message += "\"channel\": \"setState\", ";
+        std::string data = "{";
+        data += "\"action\": " + action_data(dev, env, ui, action);
+        data += "}";
+        message += "\"data\": " + data;
+        message += "}";
+        return message;
+    }
+    template <typename DEVICE, typename ENVIRONMENT>
+    void init(DEVICE& dev, ENVIRONMENT& env, typename ENVIRONMENT::Parameters& parameters, ui_server::client::UIBuffered<ENVIRONMENT>& ui, std::string name_space){
+        ui.buffer.push(parameters_message(dev, env, parameters, ui));
+        ui.ns = name_space;
+    }
+    template <typename DEVICE, typename ENVIRONMENT>
+    void init(DEVICE& dev, ENVIRONMENT& env, typename ENVIRONMENT::Parameters& parameters, ui_server::client::UIBuffered<ENVIRONMENT>& ui){
+        init(dev, env, parameters, ui, "default");
+    }
+    template <typename DEVICE, typename ENVIRONMENT>
+    void set_state(DEVICE& dev, ENVIRONMENT& env, typename ENVIRONMENT::Parameters& parameters, ui_server::client::UIBuffered<ENVIRONMENT>& ui, const typename ENVIRONMENT::State& state){
+        ui.buffer.push(set_state_message(dev, env, parameters, ui, state));
+    }
+    template <typename DEVICE, typename ENVIRONMENT>
+    void set_truncated(DEVICE& dev, ENVIRONMENT& env, typename ENVIRONMENT::Parameters& parameters, ui_server::client::UIBuffered<ENVIRONMENT>& ui, const typename ENVIRONMENT::State& state){
+        ui.buffer.push(set_truncated_message(dev, env, parameters, ui, state));
+    }
+    template <typename DEVICE, typename ENVIRONMENT, typename ACTION_SPEC>
+    void set_state(DEVICE& dev, ENVIRONMENT& env, typename ENVIRONMENT::Parameters& parameters, ui_server::client::UIBuffered<ENVIRONMENT>& ui, const typename ENVIRONMENT::State& state, const Matrix<ACTION_SPEC>& action){
+        ui.buffer.push(set_state_action_message(dev, env, parameters, ui, state, action));
+    }
+    template <typename DEVICE, typename ENVIRONMENT, typename ACTION_SPEC>
+    void set_action(DEVICE& dev, ENVIRONMENT& env, typename ENVIRONMENT::Parameters& parameters, ui_server::client::UIBuffered<ENVIRONMENT>& ui, const Matrix<ACTION_SPEC>& action){
+        ui.buffer.push(set_action_message(dev, env, parameters, ui, action));
+    }
+    template <typename DEVICE, typename ENVIRONMENT>
+    void render(DEVICE& dev, ENVIRONMENT& env, typename ENVIRONMENT::Parameters&, ui_server::client::UIBuffered<ENVIRONMENT>& ui){
+//        std::this_thread::sleep_for(std::chrono::duration<decltype(env.parameters.dt)>((env.parameters.dt)));
+    }
+}
+RL_TOOLS_NAMESPACE_WRAPPER_END
+
+#endif

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

@@ -0,0 +1,208 @@
+#include "../../version.h"
+#if (defined(RL_TOOLS_DISABLE_INCLUDE_GUARDS) || !defined(RL_TOOLS_UI_SERVER_CLIENT_OPERATIONS_WEBSOCKET_H)) && (RL_TOOLS_USE_THIS_VERSION == 1)
+#pragma once
+#define RL_TOOLS_UI_SERVER_CLIENT_OPERATIONS_WEBSOCKET_H
+
+#include "client.h"
+
+#include <thread>
+#include <chrono>
+#include <cstring>
+
+#include "operations_cpu.h"
+RL_TOOLS_NAMESPACE_WRAPPER_START
+namespace rl_tools{
+    namespace ui_server::client::websocket{
+        template <typename ENVIRONMENT>
+        void connect(ui_server::client::UIWebSocket<ENVIRONMENT>& ui){
+            ui.conn_info.context = ui.context;
+            ui.conn_info.address = ui.address.c_str();
+            ui.conn_info.port = ui.port;
+            ui.conn_info.path = "/backend";
+            ui.conn_info.host = lws_canonical_hostname(ui.context);
+            ui.conn_info.origin = "origin";
+            ui.conn_info.protocol = "ui_server";
+            ui.conn_info.ssl_connection = 0;
+            ui.conn_info.userdata = &ui;
+
+            if(ui.verbose){
+                lws_set_log_level(LLL_ERR | LLL_WARN | LLL_NOTICE | LLL_INFO | LLL_DEBUG | LLL_PARSER | LLL_HEADER | LLL_EXT | LLL_CLIENT | LLL_LATENCY, NULL);
+            }
+
+            ui.wsi = lws_client_connect_via_info(&ui.conn_info);
+        }
+        template <typename ENVIRONMENT>
+        static int callback(struct lws *wsi, enum lws_callback_reasons reason, void *user, void *in, size_t len) {
+            using UI = ui_server::client::UIWebSocket<ENVIRONMENT>;
+            UI *ui = (UI*) user;
+            switch (reason) {
+                case LWS_CALLBACK_CLIENT_ESTABLISHED:
+                    lwsl_user("Client connected\n");
+                    ui->connected = true;
+                    lws_callback_on_writable(ui->wsi);
+                    break;
+                case LWS_CALLBACK_CLIENT_WRITEABLE:
+                    {
+                        std::string message;
+                        bool messages_left = false;
+                        bool found_message = false;
+                        {
+                            std::lock_guard guard(ui->message_queue_mutex);
+                            if(!ui->message_queue.empty()){
+                                found_message = true;
+                                message = ui->message_queue.front();
+                                ui->message_queue.pop();
+                            }
+                            if(!ui->message_queue.empty()){
+                                messages_left = true;
+                            }
+                        }
+                        size_t buf_size = LWS_PRE + message.size() + 1; // +1 for null terminator
+                        std::vector<unsigned char> buf(buf_size); // Use a vector for dynamic allocation
+                        std::memcpy(buf.data() + LWS_PRE, message.c_str(), message.size() + 1);
+                        lws_write(ui->wsi, buf.data() + LWS_PRE, message.size(), LWS_WRITE_TEXT);
+                        if(ui->verbose){
+                            std::cout << std::string("Message \"") + message + "\" sent." << std::endl;
+                        }
+                        if(messages_left){
+                            lws_callback_on_writable(ui->wsi);
+                        }
+                    }
+                    break;
+                case LWS_CALLBACK_CLIENT_RECEIVE:
+                    lwsl_user("Received: %s\n", (char *)in);
+                    break;
+                case LWS_CALLBACK_CLIENT_CONNECTION_ERROR:
+                    std::cerr << "Client connection error: " << (char *)in << std::endl;
+                    ui->connected = false;
+                    ui->error = true;
+                    lws_cancel_service(ui->context);
+                    break;
+                case LWS_CALLBACK_CLIENT_CLOSED:
+                    lwsl_user("Client closed\n");
+                    ui->connected = false;
+                    lws_cancel_service(ui->context);
+                    break;
+                default:
+                    if(ui && ui->verbose){
+                        std::cout << "Unhandled callback: " << reason << std::endl;
+                    }
+                    break;
+            }
+            return 0;
+        }
+        template <typename ENVIRONMENT>
+        const struct lws_protocols protocols[] = {{"ui_server", callback<ENVIRONMENT>, sizeof(UI*), 0, 0, nullptr, 0}, LWS_PROTOCOL_LIST_TERM};
+
+        template <typename DEVICE, typename ENVIRONMENT>
+        void send_message(DEVICE& device, ui_server::client::UIWebSocket<ENVIRONMENT>& ui, std::string message){
+            utils::assert_exit(device, message.length() > 0, "Message is empty");
+            {
+                std::lock_guard guard(ui.message_queue_mutex);
+                ui.message_queue.push(message);
+            }
+            lws_cancel_service(ui.context);
+        }
+    }
+
+    template <typename DEVICE, typename ENVIRONMENT>
+    void init(DEVICE& device, ENVIRONMENT& env, typename ENVIRONMENT::Parameters& parameters, ui_server::client::UIWebSocket<ENVIRONMENT>& ui, std::string name_space = "default", bool verbose = false){
+        // note the &env needs to be alive until free is called
+        using UI = ui_server::client::UIWebSocket<ENVIRONMENT>;
+        ui.ns = name_space;
+        ui.verbose = verbose;
+        ui.connected = false;
+        ui.interrupt = false;
+        if(ui.address.empty()){
+            ui.address = "localhost";
+        }
+        if(ui.port == 0){
+            ui.port = 13337; // default is 13337 so it does not clash with other services at e.g. 8000 or 8888
+        }
+        memset(&ui.ctx_info, 0, sizeof(ui.ctx_info));
+        memset(&ui.conn_info, 0, sizeof(ui.conn_info));
+
+        ui.ctx_info.port = CONTEXT_PORT_NO_LISTEN;
+        ui.ctx_info.protocols = ui_server::client::websocket::protocols<ENVIRONMENT>;
+        ui.ctx_info.options = 0;
+        ui.context = lws_create_context(&ui.ctx_info);
+        utils::assert_exit(device, ui.context, "lws_create_context failed");
+
+        ui.thread = std::thread([&device, &env, &parameters, &ui](){
+            std::chrono::steady_clock::time_point last_sync_time;
+            bool last_sync_time_set = false;
+            while (!ui.interrupt) {
+                bool was_not_connected = false;
+                if(!ui.connected){
+                    ui.error = false;
+                    log(device, device.logger, "Not connected, wiping message buffer");
+                    {
+                        std::lock_guard guard(ui.message_queue_mutex);
+                        while(!ui.message_queue.empty()){
+                            ui.message_queue.pop();
+                        }
+                    }
+                    log(device, device.logger, "Waiting for connection to the ui_server at " + ui.address + ":" + std::to_string(ui.port) + " ...");
+                    ui_server::client::websocket::connect(ui);
+                    was_not_connected = true;
+                }
+                while (!ui.connected && !ui.error && !ui.interrupt) {
+                    lws_service(ui.context, 250);
+                }
+                if(ui.error || ui.interrupt){
+                    std::this_thread::sleep_for(std::chrono::milliseconds(2000));
+                    continue;
+                }
+                if(was_not_connected){
+                    log(device, device.logger, "UI connected.");
+                }
+                auto now = std::chrono::steady_clock::now();
+                if(was_not_connected || !last_sync_time_set || (now- last_sync_time) > std::chrono::milliseconds(ui.sync_interval)){
+                    last_sync_time_set = true;
+                    last_sync_time = now;
+                    ui_server::client::websocket::send_message(device, ui, parameters_message(device, env, parameters, ui));
+                    std::string render_function = get_ui(device, env);
+                    if(!render_function.empty()){
+                        ui_server::client::websocket::send_message(device, ui, set_ui_message(device, env, ui, render_function));
+                    }
+                }
+                lws_service(ui.context, 50);
+                bool messages_left = false;
+                {
+                    std::lock_guard guard(ui.message_queue_mutex);
+                    messages_left = !ui.message_queue.empty();
+                }
+                if(messages_left){
+                    lws_callback_on_writable(ui.wsi);
+                }
+            }
+        });
+
+
+    }
+    template <typename DEVICE, typename ENVIRONMENT>
+    void free(DEVICE& device, ENVIRONMENT& env, ui_server::client::UIWebSocket<ENVIRONMENT>& ui){
+        ui.interrupt = true;
+        lws_cancel_service(ui.context);
+        ui.thread.join();
+        lws_context_destroy(ui.context);
+    }
+    template <typename DEVICE, typename ENVIRONMENT>
+    void set_state(DEVICE& dev, ENVIRONMENT& env, const typename ENVIRONMENT::Parameters& parameters, ui_server::client::UIWebSocket<ENVIRONMENT>& ui, const typename ENVIRONMENT::State& state){
+        ui_server::client::websocket::send_message(dev, ui, set_state_message(dev, env, parameters, ui, state));
+    }
+    template <typename DEVICE, typename ENVIRONMENT, typename ACTION_SPEC>
+    void set_state(DEVICE& dev, ENVIRONMENT& env, const typename ENVIRONMENT::Parameters& parameters, ui_server::client::UIWebSocket<ENVIRONMENT>& ui, const typename ENVIRONMENT::State& state, const Matrix<ACTION_SPEC>& action){
+        ui_server::client::websocket::send_message(dev, ui, set_state_action_message(dev, env, parameters, ui, state, action));
+    }
+    template <typename DEVICE, typename ENVIRONMENT, typename ACTION_SPEC>
+    void set_action(DEVICE& dev, ENVIRONMENT& env, const typename ENVIRONMENT::Parameters& parameters, ui_server::client::UIWebSocket<ENVIRONMENT>& ui, const Matrix<ACTION_SPEC>& action){
+        ui_server::client::websocket::send_message(dev, ui, set_action_message(dev, env, ui, action));
+    }
+    template <typename DEVICE, typename ENVIRONMENT>
+    void render(DEVICE& dev, ENVIRONMENT& env, const typename ENVIRONMENT::Parameters& parameters, ui_server::client::UIWebSocket<ENVIRONMENT>& ui){
+//        std::this_thread::sleep_for(std::chrono::duration<decltype(env.parameters.dt)>((env.parameters.dt)));
+    }
+}
+RL_TOOLS_NAMESPACE_WRAPPER_END
+#endif