Merge pull request #55 from apple1417/master

swap configuration to be toml based

Author: apple1417

Readme.md

@@ -35,9 +35,13 @@ accept arguments into `sys.argv`.
 
 ## Initialization Script
 If you want to make more permanent mods, you'll want to use the initialization script. By default
-this is `__main__.py` in the game's cwd, though you can overwrite this with the
-`PYUNREALSDK_INIT_SCRIPT` environment variable. The initialization script is automatically run after
-sdk initialization, so you can use it to import other files and generally perform all your setup.
+this is `__main__.py` in the game's cwd. The initialization script is automatically run after sdk
+initialization, so you can use it to import other files and generally perform all your setup.
+
+You can swap to a different initialization script by using setting `pyunrealsdk.init_script` in the
+[unrealsdk configuration file](https://github.com/bl-sdk/unrealsdk/#configuration). If you do this
+you may also want to set `pyunrealsdk.pyexec_root`, so that `pyexec` commands work from the same
+folder.
 
 ## Using SDK bindings
 Once you've got code running, you probably want to setup some hooks - the sdk can run callbacks
@@ -87,7 +91,7 @@ To use it:
    debugpy.listen(("localhost", 5678), in_process_debug_adapter=True)
    ```
 
-3. Define the environment variable `PYUNREALSDK_DEBUGPY`.
+3. Set `pyunrealsdk.debugpy = True` in the [unrealsdk configuration file](https://github.com/bl-sdk/unrealsdk/#configuration).
 
 4. Attach using remote debugging with the debugger of your choice.
 

changelog.md

@@ -7,6 +7,17 @@
 
   [59f474fe](https://github.com/bl-sdk/pyunrealsdk/commit/59f474fe)
 
+- The `WeakPointer` constructor can now be called with no args, to create a null pointer.
+
+  [59f474fe](https://github.com/bl-sdk/pyunrealsdk/commit/59f474fe)
+
+- As with unrealsdk, reworked the configuration system to no longer rely on environment variables.
+  All sdk configuration is now also done through the `unrealsdk.toml`.
+
+  The full contents of the unrealsdk config are parsed and exposed to Python in `unrealsdk.config`.
+
+  [ecde0a83](https://github.com/bl-sdk/pyunrealsdk/commit/ecde0a83)
+
 ## v1.4.0
 
 - Fixed weak pointer type hinting to allow for null pointers. This always worked at runtime.

libs/unrealsdk

@@ -1,7 +1,9 @@
 #include "pyunrealsdk/pch.h"
 #include "pyunrealsdk/base_bindings.h"
+#include "pyunrealsdk/logging.h"
 #include "pyunrealsdk/unreal_bindings/uenum.h"
 #include "pyunrealsdk/unreal_bindings/wrapped_struct.h"
+#include "unrealsdk/config.h"
 #include "unrealsdk/unreal/classes/uclass.h"
 #include "unrealsdk/unreal/classes/uenum.h"
 #include "unrealsdk/unreal/classes/uobject.h"
@@ -85,6 +87,87 @@ UClass* evaluate_class_arg(const std::variant<UClass*, std::wstring>& cls_arg) {
     return cls_ptr;
 }
 
+/**
+ * @brief Recursively merges two toml tables.
+ *
+ * @param base The base table. Modified in place.
+ * @param overrides The overrides tables.
+ */
+void recursive_merge_table(py::dict& base, const py::dict& overrides) {
+    for (auto [key, value] : overrides) {
+        if (py::isinstance<py::dict>(value)) {
+            if (base.contains(key)) {
+                auto base_value = base[key];
+                if (py::isinstance<py::dict>(base_value)) {
+                    auto base_dict = base_value.cast<py::dict>();
+                    auto overrides_dict = value.cast<py::dict>();
+                    recursive_merge_table(base_dict, overrides_dict);
+                    continue;
+                }
+            }
+        }
+        base[key] = value;
+    }
+}
+
+/**
+ * @brief Creates the config dict, and adds it to the given module.
+ *
+ * @param mod The module to add the config dict to.
+ */
+void create_and_add_config_dict(py::module_& mod) {
+    // We want to copy the full, merged, unrealsdk config into Python.
+    // Only a few basic accessors into the config dict are exposed, since we can't safely expose
+    // the toml objects across dlls.
+    // Properly converting toml from the C++ side into Python is also a bit awkward, with all the
+    // different types.
+
+    // Instead, to get everything in Python more easily, we'll just load the config files directly
+    // in Python to begin with.
+
+    auto load_config_file = [](const std::filesystem::path&& path) -> py::object {
+        try {
+            const py::dict globals{"path"_a = path};
+            py::exec(
+                "import tomllib\n"
+                "with path.open(\"rb\") as file:\n"
+                "    config = tomllib.load(file)\n",
+                globals);
+            return globals["config"];
+
+        } catch (const std::exception& ex) {
+            LOG(ERROR, "Failed to load {}", path.string());
+            logging::log_python_exception(ex);
+            return py::none{};
+        }
+    };
+
+    auto base_config = load_config_file(unrealsdk::config::get_base_config_file_path());
+    auto user_config = load_config_file(unrealsdk::config::get_user_config_file_path());
+
+    if (!py::isinstance<py::dict>(base_config)) {
+        if (py::isinstance<py::dict>(user_config)) {
+            // Only user config got loaded
+            mod.attr("config") = user_config;
+            return;
+        }
+        // No config files got loaded, just create a default dict
+        mod.attr("config") = py::dict{};
+        return;
+    }
+    if (!py::isinstance<py::dict>(user_config)) {
+        // Only base config got loaded
+        mod.attr("config") = base_config;
+        return;
+    }
+
+    // Both configs were loaded, we need to merge them
+    auto base_dict = base_config.cast<py::dict>();
+    auto user_dict = user_config.cast<py::dict>();
+    recursive_merge_table(base_dict, user_dict);
+    mod.attr("config") = base_dict;
+}
+
 }  // namespace
 
 void register_base_bindings(py::module_& mod) {
@@ -251,6 +334,8 @@ void register_base_bindings(py::module_& mod) {
         "Returns:\n"
         "    The loaded `Package` object.",
         "name"_a, "flags"_a = 0);
+
+    create_and_add_config_dict(mod);
 }
 
 }  // namespace pyunrealsdk

src/pyunrealsdk/base_bindings.cpp

@@ -1,9 +1,9 @@
 #include "pyunrealsdk/pch.h"
 #include "pyunrealsdk/commands.h"
 #include "pyunrealsdk/debugging.h"
-#include "pyunrealsdk/env.h"
 #include "pyunrealsdk/logging.h"
 #include "unrealsdk/commands.h"
+#include "unrealsdk/config.h"
 #include "unrealsdk/utils.h"
 
 #ifdef PYUNREALSDK_INTERNAL
@@ -13,7 +13,8 @@ namespace pyunrealsdk::commands {
 namespace {
 
 void pyexec_cmd_handler(const wchar_t* line, size_t size, size_t cmd_len) {
-    static const std::filesystem::path root = env::get(env::PYEXEC_ROOT);
+    static const std::filesystem::path root =
+        unrealsdk::config::get_str("pyunrealsdk.pyexec_root").value_or("");
 
     auto file_start = std::find_if_not(line + cmd_len, line + size, &std::iswspace);
     const size_t file_len = (line + size) - file_start;

src/pyunrealsdk/commands.cpp

@@ -1,8 +1,8 @@
 #include "pyunrealsdk/pch.h"
 #include "pyunrealsdk/debugging.h"
-#include "pyunrealsdk/env.h"
 #include "pyunrealsdk/exports.h"
 #include "pyunrealsdk/static_py_object.h"
+#include "unrealsdk/config.h"
 
 namespace pyunrealsdk {
 
@@ -32,7 +32,7 @@ PYUNREALSDK_CAPI(void, debug_this_thread) {
     auto& debugpy_debug_this_thread =
         storage
             .call_once_and_store_result([]() -> py::object {
-                if (env::defined(env::DEBUGPY)) {
+                if (unrealsdk::config::get_bool("pyunrealsdk.debugpy").value_or(false)) {
                     try {
                         return py::module_::import("debugpy").attr("debug_this_thread");
                     } catch (const py::error_already_set&) {}

src/pyunrealsdk/debugging.cpp

@@ -25,6 +25,7 @@
 #include <pybind11/embed.h>
 #include <pybind11/pybind11.h>
 #include <pybind11/stl.h>
+#include <pybind11/stl/filesystem.h>
 
 // NOLINTNEXTLINE(misc-unused-alias-decls)
 namespace py = pybind11;

src/pyunrealsdk/env.h

@@ -2,11 +2,11 @@
 #include "pyunrealsdk/pyunrealsdk.h"
 #include "pyunrealsdk/base_bindings.h"
 #include "pyunrealsdk/commands.h"
-#include "pyunrealsdk/env.h"
 #include "pyunrealsdk/hooks.h"
 #include "pyunrealsdk/logging.h"
 #include "pyunrealsdk/unreal_bindings/bindings.h"
 #include "pyunrealsdk/version.h"
+#include "unrealsdk/config.h"
 #include "unrealsdk/unrealsdk.h"
 #include "unrealsdk/version.h"
 
@@ -73,7 +73,8 @@ void init(void) {
     try {
         // Use a custom globals to make sure we don't contaminate `py`/`pyexec` commands
         // This also ensures `__file__` gets redefined properly
-        py::eval_file(env::get(env::INIT_SCRIPT, env::defaults::INIT_SCRIPT), py::dict{});
+        py::eval_file(unrealsdk::config::get_str("pyunrealsdk.init_script").value_or("__main__.py"),
+                      py::dict{});
     } catch (const std::exception& ex) {
         LOG(ERROR, "Error running python initialization script:");
         logging::log_python_exception(ex);

src/pyunrealsdk/pch.h

@@ -21,7 +21,7 @@ void register_weak_pointer(py::module_& mod) {
             "\n"
             "Args:\n"
             "    obj: The object to create a weak reference to.",
-            "obj"_a)
+            "obj"_a = nullptr)
         .def(
             "__call__",
             // Take a mutable reference, since the mutable dereference can do some optimizations