Generate Celeritas I/O C++ structs from the pydantic JSON schema

[sethrj]

Possibly in the future we could use our Pydantic models to generate the C++ input/output structs in our apps/library. See for example Quicktype which will turn JSON schema into structs:

[sethrj]

So far I can use:

import subprocess
from celerpy import model
inp_schema = model.ImageInput.model_json_schema()
subprocess.run([
    "quicktype",
    "-o", "model.hh",
    "--lang", "c++",
    "--src-lang", "schema",
    "--telemetry", "disable",
    "--code-format", "with-struct",
    "--const-style", "east-const",
    "--type-style", "pascal-case",
    "--member-style", "underscore-case",
    "--namespace", "celeritas",
    "--enumerator-style", "underscore-case",
    "--no-boost",
], input=json.dumps(inp_schema).encode())

to generate:

    struct Model {
        /**
         * Increase the horizontal window to be divisible by this number
         */
        std::optional<int64_t> horizontal_divisor;
        /**
         * Spatial coordinate of the image's lower left point
         */
        std::optional<std::vector<nlohmann::json>> lower_left;
        /**
         * Ray trace direction which points to the right in the image
         */
        std::optional<std::vector<nlohmann::json>> rightward;
        /**
         * Spatial coordinate of the images' upper right point
         */
        std::vector<nlohmann::json> upper_right;
        /**
         * Number of pixels along the y axis
         */
        int64_t vertical_pixels;
    };
}

namespace celeritas {
    void from_json(json const & j, Model & x);
    void to_json(json & j, Model const & x);

    inline void from_json(json const & j, Model& x) {
        x.horizontal_divisor = get_stack_optional<int64_t>(j, "horizontal_divisor");
        x.lower_left = get_stack_optional<std::vector<nlohmann::json>>(j, "lower_left");
        x.rightward = get_stack_optional<std::vector<nlohmann::json>>(j, "rightward");
        x.upper_right = j.at("upper_right").get<std::vector<nlohmann::json>>();
        x.vertical_pixels = j.at("vertical_pixels").get<int64_t>();
    }

    inline void to_json(json & j, Model const & x) {
        j = json::object();
        j["horizontal_divisor"] = x.horizontal_divisor;
        j["lower_left"] = x.lower_left;
        j["rightward"] = x.rightward;
        j["upper_right"] = x.upper_right;
        j["vertical_pixels"] = x.vertical_pixels;
    }
}

It might be better to generate the c++ using a custom script that knows about our types...