PyPartMC 2.1.2__cp315-cp315-win_amd64.whl

PyPartMC/include/nanobind_json/nanobind_json.h

@@ -0,0 +1,226 @@
+/***************************************************************************
+* Copyright (c) 2019, Martin Renou, Ian Bell, Gracjan Adamus               *
+*                                                                          *
+* Distributed under the terms of the BSD 3-Clause License.                 *
+*                                                                          *
+* The full license is in the file LICENSE, distributed with this software. *
+****************************************************************************/
+
+#pragma once
+
+#include <string>
+#include <set>
+
+#undef snprintf // required to fix an issue with std::snprintf in nlohmann::json
+#include <nlohmann/json.hpp>
+#include <nanobind/nanobind.h>
+#include <nanobind/stl/string.h>
+
+namespace nb = nanobind;
+namespace nl = nlohmann;
+
+namespace nbjson {
+    class CircularReferenceError : public std::runtime_error {
+    public:
+        CircularReferenceError(const char *msg) : std::runtime_error{msg} {}
+    };
+
+    template <typename JSONType>
+    inline nb::object from_json(const JSONType &j) {
+        if (j.is_null()) {
+            return nb::none();
+        }
+        else if (j.is_boolean()) {
+            return nb::bool_(j.template get<bool>());
+        }
+        else if (j.is_number_integer()) {
+            return nb::int_(j.template get<long long>());
+        }
+        else if (j.is_number_float()) {
+            return nb::float_(j.template get<double>());
+        }
+        else if (j.is_string()) {
+            return nb::str(j.template get<std::string>().c_str());
+        }
+        else if (j.is_array()) {
+            nb::list obj;
+            for (const auto &el : j) {
+                obj.append(from_json<JSONType>(el));
+            }
+            return obj;
+        }
+        else {
+            nb::dict obj;
+            for (typename JSONType::const_iterator it = j.cbegin(); it != j.cend(); ++it) {
+                obj[nb::str(it.key().c_str())] = from_json<JSONType>(it.value());
+            }
+            return obj;
+        }
+    }
+
+    template <typename JSONType>
+    inline JSONType to_json(const nb::handle &obj, std::set<const PyObject *> &refs) {
+        if (obj.ptr() == nullptr || obj.is_none()) {
+            return nullptr;
+        }
+        else if (nb::isinstance<nb::bool_>(obj)) {
+            return nb::cast<bool>(obj);
+        }
+        else if (nb::isinstance<nb::int_>(obj)) {
+            return nb::cast<long long>(obj);
+        }
+        else if (nb::isinstance<nb::float_>(obj)) {
+            return nb::cast<double>(obj);
+        }
+        else if (nb::isinstance<nb::bytes>(obj)) {
+            nb::module_ base64 = nb::module_::import_("base64");
+            return nb::cast<std::string>(base64.attr("b64encode")(obj).attr("decode")("utf-8"));
+        }
+        else if (nb::isinstance<nb::str>(obj)) {
+            return nb::cast<std::string>(obj);
+        }
+        else if (nb::isinstance<nb::tuple>(obj) || nb::isinstance<nb::list>(obj)) {
+            auto insert_ret = refs.insert(obj.ptr());
+            if (!insert_ret.second) {
+                throw CircularReferenceError("Circular reference detected");
+            }
+
+            auto out = JSONType::array();
+            for (const nb::handle value : obj) {
+                out.push_back(to_json<JSONType>(value, refs));
+            }
+
+            refs.erase(insert_ret.first);
+
+            return out;
+        }
+        else if (nb::isinstance<nb::dict>(obj)) {
+            auto insert_ret = refs.insert(obj.ptr());
+            if (!insert_ret.second) {
+                throw CircularReferenceError("Circular reference detected");
+            }
+
+            auto out = JSONType::object();
+            for (const nb::handle key : obj) {
+                out[nb::cast<std::string>(nb::str(key))] = to_json<JSONType>(obj[key], refs);
+            }
+
+            refs.erase(insert_ret.first);
+
+            return out;
+        }
+        else {
+            throw std::runtime_error("to_json not implemented for this type of object: " + nb::cast<std::string>(nb::repr(obj)));
+        }
+    }
+
+    template <typename JSONType>
+    inline JSONType to_json(const nb::handle &obj) {
+        std::set<const PyObject *> refs;
+        return to_json<JSONType>(obj, refs);
+    }
+} // nbjson
+
+// nlohmann_json serializers
+namespace nlohmann {
+    #define MAKE_NLJSON_SERIALIZER_DESERIALIZER(T)                  \
+    template <>                                                     \
+    struct adl_serializer<T> {                                      \
+        inline static void to_json(json &j, const T &obj) {         \
+            j = nbjson::to_json<json>(obj);                         \
+        }                                                           \
+                                                                    \
+        inline static T from_json(const json &j) {                  \
+            return nb::cast<T>(nbjson::from_json<json>(j));         \
+        }                                                           \
+                                                                    \
+        inline static void to_json(ordered_json &j, const T &obj) { \
+            j = nbjson::to_json<ordered_json>(obj);                 \
+        }                                                           \
+                                                                    \
+        inline static T from_json(const ordered_json &j) {          \
+            return nb::cast<T>(nbjson::from_json<ordered_json>(j)); \
+        }                                                           \
+    }
+
+    #define MAKE_NLJSON_SERIALIZER_ONLY(T)                          \
+    template <>                                                     \
+    struct adl_serializer<T> {                                      \
+        inline static void to_json(json &j, const T &obj) {         \
+            j = nbjson::to_json<json>(obj);                         \
+        }                                                           \
+                                                                    \
+        inline static void to_json(ordered_json &j, const T &obj) { \
+            j = nbjson::to_json<ordered_json>(obj);                 \
+        }                                                           \
+    }
+
+    MAKE_NLJSON_SERIALIZER_DESERIALIZER(nb::object);
+
+    MAKE_NLJSON_SERIALIZER_DESERIALIZER(nb::bool_);
+    MAKE_NLJSON_SERIALIZER_DESERIALIZER(nb::int_);
+    MAKE_NLJSON_SERIALIZER_DESERIALIZER(nb::float_);
+    MAKE_NLJSON_SERIALIZER_DESERIALIZER(nb::str);
+
+    MAKE_NLJSON_SERIALIZER_DESERIALIZER(nb::list);
+    MAKE_NLJSON_SERIALIZER_DESERIALIZER(nb::tuple);
+    MAKE_NLJSON_SERIALIZER_DESERIALIZER(nb::dict);
+
+    MAKE_NLJSON_SERIALIZER_ONLY(nb::handle);
+
+    #undef MAKE_NLJSON_SERIALIZER_DESERIALIZER
+    #undef MAKE_NLJSON_SERIALIZER_ONLY
+} // nlohmann
+
+NAMESPACE_BEGIN(NB_NAMESPACE)
+NAMESPACE_BEGIN(detail)
+
+// nanobind caster
+template <> struct type_caster<nl::json> {
+public:
+    NB_TYPE_CASTER(nl::json, const_name("JSON"))
+
+    bool from_python(handle src, uint8_t flags, cleanup_list *cleanup) {
+        try {
+            value = nbjson::to_json<nl::json>(src);
+            return true;
+        }
+        catch (nbjson::CircularReferenceError &e) {
+            throw e;
+        }
+        catch (...) {
+            return false;
+        }
+    }
+
+    static handle from_cpp(const nl::json &src, rv_policy policy, cleanup_list *cleanup) noexcept {
+        object obj = nbjson::from_json<nl::json>(src);
+        return obj.release();
+    }
+};
+
+template <> struct type_caster<nl::ordered_json> {
+public:
+    NB_TYPE_CASTER(nl::ordered_json, const_name("OrderedJSON"))
+
+    bool from_python(handle src, uint8_t flags, cleanup_list *cleanup) {
+        try {
+            value = nbjson::to_json<nl::ordered_json>(src);
+            return true;
+        }
+        catch (nbjson::CircularReferenceError &e) {
+            throw e;
+        }
+        catch (...) {
+            return false;
+        }
+    }
+
+    static handle from_cpp(const nl::ordered_json &src, rv_policy policy, cleanup_list *cleanup) noexcept {
+        object obj = nbjson::from_json<nl::ordered_json>(src);
+        return obj.release();
+    }
+};
+
+NAMESPACE_END(detail)
+NAMESPACE_END(NB_NAMESPACE)

PyPartMC/include/nlohmann/adl_serializer.hpp

@@ -0,0 +1,55 @@
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+#pragma once
+
+#include <utility>
+
+#include <nlohmann/detail/abi_macros.hpp>
+#include <nlohmann/detail/conversions/from_json.hpp>
+#include <nlohmann/detail/conversions/to_json.hpp>
+#include <nlohmann/detail/meta/identity_tag.hpp>
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+
+/// @sa https://json.nlohmann.me/api/adl_serializer/
+template<typename ValueType, typename>
+struct adl_serializer
+{
+    /// @brief convert a JSON value to any value type
+    /// @sa https://json.nlohmann.me/api/adl_serializer/from_json/
+    template<typename BasicJsonType, typename TargetType = ValueType>
+    static auto from_json(BasicJsonType && j, TargetType& val) noexcept(
+        noexcept(::nlohmann::from_json(std::forward<BasicJsonType>(j), val)))
+    -> decltype(::nlohmann::from_json(std::forward<BasicJsonType>(j), val), void())
+    {
+        ::nlohmann::from_json(std::forward<BasicJsonType>(j), val);
+    }
+
+    /// @brief convert a JSON value to any value type
+    /// @sa https://json.nlohmann.me/api/adl_serializer/from_json/
+    template<typename BasicJsonType, typename TargetType = ValueType>
+    static auto from_json(BasicJsonType && j) noexcept(
+    noexcept(::nlohmann::from_json(std::forward<BasicJsonType>(j), detail::identity_tag<TargetType> {})))
+    -> decltype(::nlohmann::from_json(std::forward<BasicJsonType>(j), detail::identity_tag<TargetType> {}))
+    {
+        return ::nlohmann::from_json(std::forward<BasicJsonType>(j), detail::identity_tag<TargetType> {});
+    }
+
+    /// @brief convert any value type to a JSON value
+    /// @sa https://json.nlohmann.me/api/adl_serializer/to_json/
+    template<typename BasicJsonType, typename TargetType = ValueType>
+    static auto to_json(BasicJsonType& j, TargetType && val) noexcept(
+        noexcept(::nlohmann::to_json(j, std::forward<TargetType>(val))))
+    -> decltype(::nlohmann::to_json(j, std::forward<TargetType>(val)), void())
+    {
+        ::nlohmann::to_json(j, std::forward<TargetType>(val));
+    }
+};
+
+NLOHMANN_JSON_NAMESPACE_END

PyPartMC/include/nlohmann/byte_container_with_subtype.hpp

@@ -0,0 +1,103 @@
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+#pragma once
+
+#include <cstdint> // uint8_t, uint64_t
+#include <tuple> // tie
+#include <utility> // move
+
+#include <nlohmann/detail/abi_macros.hpp>
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+
+/// @brief an internal type for a backed binary type
+/// @sa https://json.nlohmann.me/api/byte_container_with_subtype/
+template<typename BinaryType>
+class byte_container_with_subtype : public BinaryType
+{
+  public:
+    using container_type = BinaryType;
+    using subtype_type = std::uint64_t;
+
+    /// @sa https://json.nlohmann.me/api/byte_container_with_subtype/byte_container_with_subtype/
+    byte_container_with_subtype() noexcept(noexcept(container_type()))
+        : container_type()
+    {}
+
+    /// @sa https://json.nlohmann.me/api/byte_container_with_subtype/byte_container_with_subtype/
+    byte_container_with_subtype(const container_type& b) noexcept(noexcept(container_type(b)))
+        : container_type(b)
+    {}
+
+    /// @sa https://json.nlohmann.me/api/byte_container_with_subtype/byte_container_with_subtype/
+    byte_container_with_subtype(container_type&& b) noexcept(noexcept(container_type(std::move(b))))
+        : container_type(std::move(b))
+    {}
+
+    /// @sa https://json.nlohmann.me/api/byte_container_with_subtype/byte_container_with_subtype/
+    byte_container_with_subtype(const container_type& b, subtype_type subtype_) noexcept(noexcept(container_type(b)))
+        : container_type(b)
+        , m_subtype(subtype_)
+        , m_has_subtype(true)
+    {}
+
+    /// @sa https://json.nlohmann.me/api/byte_container_with_subtype/byte_container_with_subtype/
+    byte_container_with_subtype(container_type&& b, subtype_type subtype_) noexcept(noexcept(container_type(std::move(b))))
+        : container_type(std::move(b))
+        , m_subtype(subtype_)
+        , m_has_subtype(true)
+    {}
+
+    bool operator==(const byte_container_with_subtype& rhs) const
+    {
+        return std::tie(static_cast<const BinaryType&>(*this), m_subtype, m_has_subtype) ==
+               std::tie(static_cast<const BinaryType&>(rhs), rhs.m_subtype, rhs.m_has_subtype);
+    }
+
+    bool operator!=(const byte_container_with_subtype& rhs) const
+    {
+        return !(rhs == *this);
+    }
+
+    /// @brief sets the binary subtype
+    /// @sa https://json.nlohmann.me/api/byte_container_with_subtype/set_subtype/
+    void set_subtype(subtype_type subtype_) noexcept
+    {
+        m_subtype = subtype_;
+        m_has_subtype = true;
+    }
+
+    /// @brief return the binary subtype
+    /// @sa https://json.nlohmann.me/api/byte_container_with_subtype/subtype/
+    constexpr subtype_type subtype() const noexcept
+    {
+        return m_has_subtype ? m_subtype : static_cast<subtype_type>(-1);
+    }
+
+    /// @brief return whether the value has a subtype
+    /// @sa https://json.nlohmann.me/api/byte_container_with_subtype/has_subtype/
+    constexpr bool has_subtype() const noexcept
+    {
+        return m_has_subtype;
+    }
+
+    /// @brief clears the binary subtype
+    /// @sa https://json.nlohmann.me/api/byte_container_with_subtype/clear_subtype/
+    void clear_subtype() noexcept
+    {
+        m_subtype = 0;
+        m_has_subtype = false;
+    }
+
+  private:
+    subtype_type m_subtype = 0;
+    bool m_has_subtype = false;
+};
+
+NLOHMANN_JSON_NAMESPACE_END

PyPartMC/include/nlohmann/detail/abi_macros.hpp

@@ -0,0 +1,100 @@
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+#pragma once
+
+// This file contains all macro definitions affecting or depending on the ABI
+
+#ifndef JSON_SKIP_LIBRARY_VERSION_CHECK
+    #if defined(NLOHMANN_JSON_VERSION_MAJOR) && defined(NLOHMANN_JSON_VERSION_MINOR) && defined(NLOHMANN_JSON_VERSION_PATCH)
+        #if NLOHMANN_JSON_VERSION_MAJOR != 3 || NLOHMANN_JSON_VERSION_MINOR != 11 || NLOHMANN_JSON_VERSION_PATCH != 3
+            #warning "Already included a different version of the library!"
+        #endif
+    #endif
+#endif
+
+#define NLOHMANN_JSON_VERSION_MAJOR 3   // NOLINT(modernize-macro-to-enum)
+#define NLOHMANN_JSON_VERSION_MINOR 11  // NOLINT(modernize-macro-to-enum)
+#define NLOHMANN_JSON_VERSION_PATCH 3   // NOLINT(modernize-macro-to-enum)
+
+#ifndef JSON_DIAGNOSTICS
+    #define JSON_DIAGNOSTICS 0
+#endif
+
+#ifndef JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON
+    #define JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON 0
+#endif
+
+#if JSON_DIAGNOSTICS
+    #define NLOHMANN_JSON_ABI_TAG_DIAGNOSTICS _diag
+#else
+    #define NLOHMANN_JSON_ABI_TAG_DIAGNOSTICS
+#endif
+
+#if JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON
+    #define NLOHMANN_JSON_ABI_TAG_LEGACY_DISCARDED_VALUE_COMPARISON _ldvcmp
+#else
+    #define NLOHMANN_JSON_ABI_TAG_LEGACY_DISCARDED_VALUE_COMPARISON
+#endif
+
+#ifndef NLOHMANN_JSON_NAMESPACE_NO_VERSION
+    #define NLOHMANN_JSON_NAMESPACE_NO_VERSION 0
+#endif
+
+// Construct the namespace ABI tags component
+#define NLOHMANN_JSON_ABI_TAGS_CONCAT_EX(a, b) json_abi ## a ## b
+#define NLOHMANN_JSON_ABI_TAGS_CONCAT(a, b) \
+    NLOHMANN_JSON_ABI_TAGS_CONCAT_EX(a, b)
+
+#define NLOHMANN_JSON_ABI_TAGS                                       \
+    NLOHMANN_JSON_ABI_TAGS_CONCAT(                                   \
+            NLOHMANN_JSON_ABI_TAG_DIAGNOSTICS,                       \
+            NLOHMANN_JSON_ABI_TAG_LEGACY_DISCARDED_VALUE_COMPARISON)
+
+// Construct the namespace version component
+#define NLOHMANN_JSON_NAMESPACE_VERSION_CONCAT_EX(major, minor, patch) \
+    _v ## major ## _ ## minor ## _ ## patch
+#define NLOHMANN_JSON_NAMESPACE_VERSION_CONCAT(major, minor, patch) \
+    NLOHMANN_JSON_NAMESPACE_VERSION_CONCAT_EX(major, minor, patch)
+
+#if NLOHMANN_JSON_NAMESPACE_NO_VERSION
+#define NLOHMANN_JSON_NAMESPACE_VERSION
+#else
+#define NLOHMANN_JSON_NAMESPACE_VERSION                                 \
+    NLOHMANN_JSON_NAMESPACE_VERSION_CONCAT(NLOHMANN_JSON_VERSION_MAJOR, \
+                                           NLOHMANN_JSON_VERSION_MINOR, \
+                                           NLOHMANN_JSON_VERSION_PATCH)
+#endif
+
+// Combine namespace components
+#define NLOHMANN_JSON_NAMESPACE_CONCAT_EX(a, b) a ## b
+#define NLOHMANN_JSON_NAMESPACE_CONCAT(a, b) \
+    NLOHMANN_JSON_NAMESPACE_CONCAT_EX(a, b)
+
+#ifndef NLOHMANN_JSON_NAMESPACE
+#define NLOHMANN_JSON_NAMESPACE               \
+    nlohmann::NLOHMANN_JSON_NAMESPACE_CONCAT( \
+            NLOHMANN_JSON_ABI_TAGS,           \
+            NLOHMANN_JSON_NAMESPACE_VERSION)
+#endif
+
+#ifndef NLOHMANN_JSON_NAMESPACE_BEGIN
+#define NLOHMANN_JSON_NAMESPACE_BEGIN                \
+    namespace nlohmann                               \
+    {                                                \
+    inline namespace NLOHMANN_JSON_NAMESPACE_CONCAT( \
+                NLOHMANN_JSON_ABI_TAGS,              \
+                NLOHMANN_JSON_NAMESPACE_VERSION)     \
+    {
+#endif
+
+#ifndef NLOHMANN_JSON_NAMESPACE_END
+#define NLOHMANN_JSON_NAMESPACE_END                                     \
+    }  /* namespace (inline namespace) NOLINT(readability/namespace) */ \
+    }  // namespace nlohmann
+#endif