pydtype-cpp 0.1.0__py3-none-any.whl

pydtype/desc.hpp

@@ -0,0 +1,363 @@
+//----------------------------------------------------------------------------------------------------------------------
+// C++26 reflection to numpy dtypes
+//
+// For this code to compile with gcc16 include the following flags: -std=c++26 -freflection
+//
+// Author: Paul Scruby
+// Copyright: Paul Scruby
+// License: MIT
+//
+
+#pragma once
+
+#include <bit>
+#include <chrono>
+#include <concepts>
+#include <meta>
+#include <string>
+#include <string_view>
+#include <type_traits>
+#include <cmath>
+
+
+namespace pydtype {
+
+enum class Endian {
+    NONE,
+    LITTLE,
+    BIG,
+    NATIVE,
+};
+
+namespace detail {
+
+template <std::size_t N>
+struct FixedString {
+    char data[N]{};
+
+    constexpr operator std::string_view() const {
+        return std::string_view(data, N);
+    }
+};
+
+template <std::size_t N> consteval auto const_to_string() {
+    if constexpr (N == 0) {
+        return FixedString<1>{{'0'}};
+    } else {
+        constexpr auto num_digits = [](std::size_t val) {
+            if (val == 0) {
+                return std::size_t{1};
+            }
+            return static_cast<std::size_t>(std::log10(val)) + 1;
+        };
+
+        constexpr std::size_t len = num_digits(N);
+        FixedString<len> buffer;
+        std::size_t tmp = N;
+
+        for (std::size_t i = 0; i < len; i++) {
+            buffer.data[len - 1 - i] = static_cast<char>('0' + (tmp % 10));
+            tmp /= 10;
+        }
+        return buffer;
+    }
+}
+
+template <typename T> consteval std::string_view array_dims() {
+    if constexpr (std::is_array_v<T>) {
+        static constexpr std::size_t ext = std::extent_v<T>;
+        static constexpr auto num_str = const_to_string<ext>();
+        static constexpr auto next_view = array_dims<std::remove_extent_t<T>>();
+
+        constexpr std::size_t total_size = 2 + sizeof(num_str.data) + next_view.size();
+
+        static constexpr auto assembled = []() {
+            FixedString<total_size> buffer;
+            buffer.data[0] = ',';
+            buffer.data[1] = ' ';
+            std::size_t idx = 2;
+
+            for (std::size_t i = 0; i < sizeof(num_str.data); i++) {
+                buffer.data[idx++] = num_str.data[i];
+            }
+
+            for (std::size_t i = 0; i < next_view.size(); i++) {
+                buffer.data[idx++] = next_view[i];
+            }
+
+            return buffer;
+        }();
+
+        return std::string_view(assembled.data, sizeof(assembled.data));
+    } else {
+        return "";
+    }
+}
+
+template<typename T> struct always_false : std::false_type {};
+template<typename T> struct is_chrono_time_point : std::false_type {};
+template<typename C, typename D> struct is_chrono_time_point<std::chrono::time_point<C, D>> : std::true_type {};
+template<typename T> struct is_chrono_duration : std::false_type {};
+template<typename R, typename P> struct is_chrono_duration<std::chrono::duration<R, P>> : std::true_type {};
+template<typename T> struct underlying_type { using type = T; };
+template<typename T> requires std::is_enum_v<T> struct underlying_type<T> { using type = std::underlying_type_t<T>; };
+template<typename T> using underlying_type_t = typename underlying_type<T>::type;
+
+template<Endian E> consteval std::string_view endian_prefix();
+template<> consteval std::string_view endian_prefix<Endian::NONE>() { return ""; }
+template<> consteval std::string_view endian_prefix<Endian::LITTLE>() { return "<"; }
+template<> consteval std::string_view endian_prefix<Endian::BIG>() { return ">"; }
+template<> consteval std::string_view endian_prefix<Endian::NATIVE>() { return std::endian::native == std::endian::little ? "<" : ">"; }
+
+template<typename T> consteval std::string_view np_scalar_type() {
+    if constexpr (is_chrono_time_point<T>::value) {
+        using duration_t = typename T::duration;
+        if constexpr (std::same_as<duration_t, std::chrono::nanoseconds>) {
+            return "M8[ns]";
+        } else if constexpr (std::same_as<duration_t, std::chrono::microseconds>) {
+            return "M8[us]";
+        } else if constexpr (std::same_as<duration_t, std::chrono::milliseconds>) {
+            return "M8[ms]";
+        } else if constexpr (std::same_as<duration_t, std::chrono::seconds>) {
+            return "M8[s]";
+        } else if constexpr (std::same_as<duration_t, std::chrono::minutes>) {
+            return "M8[m]";
+        } else if constexpr (std::same_as<duration_t, std::chrono::hours>) {
+            return "M8[h]";
+        } else {
+            static_assert(always_false<T>::value, "Unsupported std::chrono::time_point resolution");
+        }
+    } else if constexpr (is_chrono_duration<T>::value) {
+        if constexpr (std::same_as<T, std::chrono::nanoseconds>) {
+            return "m8[ns]";
+        } else if constexpr (std::same_as<T, std::chrono::microseconds>) {
+            return "m8[us]";
+        } else if constexpr (std::same_as<T, std::chrono::milliseconds>) {
+            return "m8[ms]";
+        } else if constexpr (std::same_as<T, std::chrono::seconds>) {
+            return "m8[s]";
+        } else if constexpr (std::same_as<T, std::chrono::minutes>) {
+            return "m8[m]";
+        } else if constexpr (std::same_as<T, std::chrono::hours>) {
+            return "m8[h]";
+        } else {
+            static_assert(always_false<T>::value, "Unsupported std::chrono::duration resolution");
+        }
+    } else if constexpr (std::same_as<T, bool>) {
+        return "b1";
+    } else if constexpr (std::same_as<T, char>) {
+        return "S1";
+    } else if constexpr (std::same_as<T, signed char> or std::same_as<T, int8_t>) {
+        return "i1";
+    } else if constexpr (std::same_as<T, unsigned char> or std::same_as<T, uint8_t> or std::same_as<T, std::byte>) {
+        return "u1";
+    } else if constexpr (std::same_as<T, short> or std::same_as<T, int16_t>) {
+        return "i2";
+    } else if constexpr (std::same_as<T, unsigned short> or std::same_as<T, uint16_t>) {
+        return "u2";
+    } else if constexpr (std::same_as<T, char16_t>) {
+        return "U2";
+    } else if constexpr (std::same_as<T, int32_t>) {
+        return "i4";
+    } else if constexpr (std::same_as<T, uint32_t>) {
+        return "u4";
+    } else if constexpr (std::same_as<T, char32_t>) {
+        return "U4";
+    } else if constexpr (std::same_as<T, long long> or std::same_as<T, int64_t>) {
+        return "i8";
+    } else if constexpr (std::same_as<T, unsigned long long> or std::same_as<T, uint64_t>) {
+        return "u8";
+    } else if constexpr (std::same_as<T, float>) {
+        return "f4";
+    } else if constexpr (std::same_as<T, double>) {
+        return "f8";
+    } else if constexpr (std::same_as<T, long double>) {
+        if constexpr (sizeof(long double) == 8) {
+            return "f8";
+        } else if constexpr (sizeof(long double) == 12) {
+            return "f12";
+        } else if constexpr (sizeof(long double) == 16) {
+            return "f16";
+        } else {
+            return "g";
+        }
+    }
+    return "";
+}
+
+template<typename T> consteval bool explicit_layout() {
+    using CleanT = std::remove_cvref_t<T>;
+    using UncvR = typename underlying_type<CleanT>::type;
+
+    if constexpr (std::is_union_v<UncvR>) {
+        return true;
+    } else if constexpr (not std::is_class_v<UncvR>) {
+        return false;
+    }
+
+    constexpr auto ctx = std::meta::access_context::unchecked();
+
+    if constexpr (not std::meta::bases_of(^^UncvR, ctx).empty()) {
+        return true;
+    } else {
+        static constexpr auto members = std::define_static_array(std::meta::nonstatic_data_members_of(^^UncvR, ctx));
+        std::size_t expected_offset = 0;
+        bool is_explicit = false;
+
+        template for (constexpr std::meta::info member : members) {
+            using FieldType = typename[:std::meta::type_of(member):];
+            constexpr std::string_view field_name = std::meta::identifier_of(member);
+
+            if constexpr (std::is_union_v<FieldType> and field_name.empty()) {
+                is_explicit = true;
+            } else {
+                constexpr std::size_t actual_offset = std::is_union_v<UncvR> ? 0 : std::meta::offset_of(member).bytes;
+
+                if (actual_offset != expected_offset) {
+                    is_explicit = true;
+                }
+
+                expected_offset = actual_offset + sizeof(FieldType);
+            }
+        }
+
+        if (sizeof(UncvR) != expected_offset) {
+            is_explicit = true;
+        }
+
+        return is_explicit;
+    }
+}
+
+} // namespace detail
+
+
+//----------------------------------------------------------------------------------------------------------------------
+// This function generates a numpy dtype description for a C structure using reflection. It supports nested types,
+// multi-dimensional arrays, enums, named and anonymous unions, and chrono to datetime64 and timedelta64 conversion.
+// Where the numpy default alignment differs from C it will update the dtype to match.
+//
+template <typename T, Endian E = Endian::NONE> std::string desc() {
+    using RawT = std::remove_cvref_t<T>;
+    using UncvR = typename detail::underlying_type<RawT>::type;
+
+    if constexpr (std::is_array_v<UncvR>) {
+        using ElementType = std::remove_all_extents_t<UncvR>;
+
+        if constexpr (std::same_as<ElementType, char>) {
+            return "'S" + std::to_string(sizeof(UncvR)) + "'";
+        } else if constexpr (std::same_as<ElementType, char16_t>) {
+            return "'" + std::string(detail::endian_prefix<E>()) + "U" + std::to_string(sizeof(UncvR) / 2) + "'";
+        } else if constexpr (std::same_as<ElementType, char32_t>) {
+            return "'" + std::string(detail::endian_prefix<E>()) + "U" + std::to_string(sizeof(UncvR) / 4) + "'";
+        } else {
+            return "(" + desc<ElementType, E>() + std::string(detail::array_dims<UncvR>()) + ")";
+        }
+    } else if constexpr (constexpr std::string_view scalar = detail::np_scalar_type<UncvR>(); not scalar.empty()) {
+        if (scalar == "b1" or scalar == "S1" or scalar == "i1" or scalar == "u1") {
+            return "'" + std::string(scalar) + "'";
+        } else {
+            return "'" + std::string(detail::endian_prefix<E>()) + std::string(scalar) + "'";
+        }
+    } else if constexpr (std::is_union_v<UncvR> or std::is_class_v<UncvR>) {
+        constexpr auto ctx = std::meta::access_context::unchecked();
+        constexpr bool has_bases = not std::meta::bases_of(^^UncvR, ctx).empty();
+
+        if constexpr (not has_bases and not detail::explicit_layout<UncvR>()) {  // default numpy layout
+            static constexpr auto members = std::define_static_array(std::meta::nonstatic_data_members_of(^^UncvR, ctx));
+            std::string list = "[";
+            bool is_first = true;
+
+            template for (constexpr std::meta::info member : members) {
+                constexpr std::string_view field_name = std::meta::identifier_of(member);
+                using FieldType = typename[:std::meta::type_of(member):];
+
+                if (not is_first) {
+                    list += ", ";
+                }
+
+                is_first = false;
+                list += "('" + std::string(field_name) + "', " + desc<FieldType, E>() + ")";
+            }
+
+            list += "]";
+            return list;
+        } else {  // explicit dict layout due to base classes, padding, or unions
+            std::string names = "'names': [";
+            std::string formats = "'formats': [";
+            std::string offsets = "'offsets': [";
+            bool is_first = true;
+
+            if constexpr (has_bases) {
+                static constexpr auto bases = std::define_static_array(std::meta::bases_of(^^UncvR, ctx));
+
+                template for (constexpr std::meta::info base : bases) {
+                    using BaseType = typename[:std::meta::type_of(base):];
+                    constexpr std::size_t base_offset = std::meta::offset_of(base).bytes;
+                    static constexpr auto base_members = std::define_static_array(std::meta::nonstatic_data_members_of(^^BaseType, ctx));
+
+                    template for (constexpr std::meta::info bm : base_members) {
+                        if (not is_first) {
+                            names += ", ";
+                            formats += ", ";
+                            offsets += ", ";
+                        }
+
+                        is_first = false;
+                        names += "'" + std::string(std::meta::identifier_of(bm)) + "'";
+                        formats += desc<typename[:std::meta::type_of(bm):], E>();
+                        offsets += std::to_string(base_offset + (std::is_union_v<BaseType> ? 0 : std::meta::offset_of(bm).bytes));
+                    }
+                }
+            }
+
+            static constexpr auto local_members = std::define_static_array(std::meta::nonstatic_data_members_of(^^UncvR, ctx));
+
+            template for (constexpr std::meta::info member : local_members) {
+                constexpr std::string_view field_name = std::meta::identifier_of(member);
+                using FieldType = typename[:std::meta::type_of(member):];
+                constexpr std::size_t offset = std::is_union_v<UncvR> ? 0 : std::meta::offset_of(member).bytes;
+
+                if constexpr (std::is_union_v<FieldType> and field_name.empty()) {   // flatten anonymous unions
+                    static constexpr auto union_members = std::define_static_array(std::meta::nonstatic_data_members_of(^^FieldType, ctx));
+
+                    template for (constexpr std::meta::info u_member : union_members) {
+                        constexpr std::string_view u_name = std::meta::identifier_of(u_member);
+                        using UFieldType = typename[:std::meta::type_of(u_member):];
+
+                        if (not is_first) {
+                            names += ", ";
+                            formats += ", ";
+                            offsets += ", ";
+                        }
+
+                        is_first = false;
+                        names += "'" + std::string(u_name) + "'";
+                        formats += desc<UFieldType, E>();
+                        offsets += std::to_string(offset);
+                    }
+                } else {
+                    if (not is_first) {
+                        names += ", ";
+                        formats += ", ";
+                        offsets += ", ";
+                    }
+
+                    is_first = false;
+                    names += "'" + std::string(field_name) + "'";
+                    formats += desc<FieldType, E>();
+                    offsets += std::to_string(offset);
+                }
+            }
+
+            names += "]";
+            formats += "]";
+            offsets += "]";
+            return "{" + names + ", " + formats + ", " + offsets + ", 'itemsize': " + std::to_string(sizeof(UncvR)) + "}";
+        }
+    } else {
+        static_assert(detail::always_false<UncvR>::value, "Unsupported member type found during dtype conversion");
+    }
+}
+
+}  // namespace pydtype

pydtype_cpp-0.1.0.data/data/include/pydtype/desc.hpp

@@ -0,0 +1,363 @@
+//----------------------------------------------------------------------------------------------------------------------
+// C++26 reflection to numpy dtypes
+//
+// For this code to compile with gcc16 include the following flags: -std=c++26 -freflection
+//
+// Author: Paul Scruby
+// Copyright: Paul Scruby
+// License: MIT
+//
+
+#pragma once
+
+#include <bit>
+#include <chrono>
+#include <concepts>
+#include <meta>
+#include <string>
+#include <string_view>
+#include <type_traits>
+#include <cmath>
+
+
+namespace pydtype {
+
+enum class Endian {
+    NONE,
+    LITTLE,
+    BIG,
+    NATIVE,
+};
+
+namespace detail {
+
+template <std::size_t N>
+struct FixedString {
+    char data[N]{};
+
+    constexpr operator std::string_view() const {
+        return std::string_view(data, N);
+    }
+};
+
+template <std::size_t N> consteval auto const_to_string() {
+    if constexpr (N == 0) {
+        return FixedString<1>{{'0'}};
+    } else {
+        constexpr auto num_digits = [](std::size_t val) {
+            if (val == 0) {
+                return std::size_t{1};
+            }
+            return static_cast<std::size_t>(std::log10(val)) + 1;
+        };
+
+        constexpr std::size_t len = num_digits(N);
+        FixedString<len> buffer;
+        std::size_t tmp = N;
+
+        for (std::size_t i = 0; i < len; i++) {
+            buffer.data[len - 1 - i] = static_cast<char>('0' + (tmp % 10));
+            tmp /= 10;
+        }
+        return buffer;
+    }
+}
+
+template <typename T> consteval std::string_view array_dims() {
+    if constexpr (std::is_array_v<T>) {
+        static constexpr std::size_t ext = std::extent_v<T>;
+        static constexpr auto num_str = const_to_string<ext>();
+        static constexpr auto next_view = array_dims<std::remove_extent_t<T>>();
+
+        constexpr std::size_t total_size = 2 + sizeof(num_str.data) + next_view.size();
+
+        static constexpr auto assembled = []() {
+            FixedString<total_size> buffer;
+            buffer.data[0] = ',';
+            buffer.data[1] = ' ';
+            std::size_t idx = 2;
+
+            for (std::size_t i = 0; i < sizeof(num_str.data); i++) {
+                buffer.data[idx++] = num_str.data[i];
+            }
+
+            for (std::size_t i = 0; i < next_view.size(); i++) {
+                buffer.data[idx++] = next_view[i];
+            }
+
+            return buffer;
+        }();
+
+        return std::string_view(assembled.data, sizeof(assembled.data));
+    } else {
+        return "";
+    }
+}
+
+template<typename T> struct always_false : std::false_type {};
+template<typename T> struct is_chrono_time_point : std::false_type {};
+template<typename C, typename D> struct is_chrono_time_point<std::chrono::time_point<C, D>> : std::true_type {};
+template<typename T> struct is_chrono_duration : std::false_type {};
+template<typename R, typename P> struct is_chrono_duration<std::chrono::duration<R, P>> : std::true_type {};
+template<typename T> struct underlying_type { using type = T; };
+template<typename T> requires std::is_enum_v<T> struct underlying_type<T> { using type = std::underlying_type_t<T>; };
+template<typename T> using underlying_type_t = typename underlying_type<T>::type;
+
+template<Endian E> consteval std::string_view endian_prefix();
+template<> consteval std::string_view endian_prefix<Endian::NONE>() { return ""; }
+template<> consteval std::string_view endian_prefix<Endian::LITTLE>() { return "<"; }
+template<> consteval std::string_view endian_prefix<Endian::BIG>() { return ">"; }
+template<> consteval std::string_view endian_prefix<Endian::NATIVE>() { return std::endian::native == std::endian::little ? "<" : ">"; }
+
+template<typename T> consteval std::string_view np_scalar_type() {
+    if constexpr (is_chrono_time_point<T>::value) {
+        using duration_t = typename T::duration;
+        if constexpr (std::same_as<duration_t, std::chrono::nanoseconds>) {
+            return "M8[ns]";
+        } else if constexpr (std::same_as<duration_t, std::chrono::microseconds>) {
+            return "M8[us]";
+        } else if constexpr (std::same_as<duration_t, std::chrono::milliseconds>) {
+            return "M8[ms]";
+        } else if constexpr (std::same_as<duration_t, std::chrono::seconds>) {
+            return "M8[s]";
+        } else if constexpr (std::same_as<duration_t, std::chrono::minutes>) {
+            return "M8[m]";
+        } else if constexpr (std::same_as<duration_t, std::chrono::hours>) {
+            return "M8[h]";
+        } else {
+            static_assert(always_false<T>::value, "Unsupported std::chrono::time_point resolution");
+        }
+    } else if constexpr (is_chrono_duration<T>::value) {
+        if constexpr (std::same_as<T, std::chrono::nanoseconds>) {
+            return "m8[ns]";
+        } else if constexpr (std::same_as<T, std::chrono::microseconds>) {
+            return "m8[us]";
+        } else if constexpr (std::same_as<T, std::chrono::milliseconds>) {
+            return "m8[ms]";
+        } else if constexpr (std::same_as<T, std::chrono::seconds>) {
+            return "m8[s]";
+        } else if constexpr (std::same_as<T, std::chrono::minutes>) {
+            return "m8[m]";
+        } else if constexpr (std::same_as<T, std::chrono::hours>) {
+            return "m8[h]";
+        } else {
+            static_assert(always_false<T>::value, "Unsupported std::chrono::duration resolution");
+        }
+    } else if constexpr (std::same_as<T, bool>) {
+        return "b1";
+    } else if constexpr (std::same_as<T, char>) {
+        return "S1";
+    } else if constexpr (std::same_as<T, signed char> or std::same_as<T, int8_t>) {
+        return "i1";
+    } else if constexpr (std::same_as<T, unsigned char> or std::same_as<T, uint8_t> or std::same_as<T, std::byte>) {
+        return "u1";
+    } else if constexpr (std::same_as<T, short> or std::same_as<T, int16_t>) {
+        return "i2";
+    } else if constexpr (std::same_as<T, unsigned short> or std::same_as<T, uint16_t>) {
+        return "u2";
+    } else if constexpr (std::same_as<T, char16_t>) {
+        return "U2";
+    } else if constexpr (std::same_as<T, int32_t>) {
+        return "i4";
+    } else if constexpr (std::same_as<T, uint32_t>) {
+        return "u4";
+    } else if constexpr (std::same_as<T, char32_t>) {
+        return "U4";
+    } else if constexpr (std::same_as<T, long long> or std::same_as<T, int64_t>) {
+        return "i8";
+    } else if constexpr (std::same_as<T, unsigned long long> or std::same_as<T, uint64_t>) {
+        return "u8";
+    } else if constexpr (std::same_as<T, float>) {
+        return "f4";
+    } else if constexpr (std::same_as<T, double>) {
+        return "f8";
+    } else if constexpr (std::same_as<T, long double>) {
+        if constexpr (sizeof(long double) == 8) {
+            return "f8";
+        } else if constexpr (sizeof(long double) == 12) {
+            return "f12";
+        } else if constexpr (sizeof(long double) == 16) {
+            return "f16";
+        } else {
+            return "g";
+        }
+    }
+    return "";
+}
+
+template<typename T> consteval bool explicit_layout() {
+    using CleanT = std::remove_cvref_t<T>;
+    using UncvR = typename underlying_type<CleanT>::type;
+
+    if constexpr (std::is_union_v<UncvR>) {
+        return true;
+    } else if constexpr (not std::is_class_v<UncvR>) {
+        return false;
+    }
+
+    constexpr auto ctx = std::meta::access_context::unchecked();
+
+    if constexpr (not std::meta::bases_of(^^UncvR, ctx).empty()) {
+        return true;
+    } else {
+        static constexpr auto members = std::define_static_array(std::meta::nonstatic_data_members_of(^^UncvR, ctx));
+        std::size_t expected_offset = 0;
+        bool is_explicit = false;
+
+        template for (constexpr std::meta::info member : members) {
+            using FieldType = typename[:std::meta::type_of(member):];
+            constexpr std::string_view field_name = std::meta::identifier_of(member);
+
+            if constexpr (std::is_union_v<FieldType> and field_name.empty()) {
+                is_explicit = true;
+            } else {
+                constexpr std::size_t actual_offset = std::is_union_v<UncvR> ? 0 : std::meta::offset_of(member).bytes;
+
+                if (actual_offset != expected_offset) {
+                    is_explicit = true;
+                }
+
+                expected_offset = actual_offset + sizeof(FieldType);
+            }
+        }
+
+        if (sizeof(UncvR) != expected_offset) {
+            is_explicit = true;
+        }
+
+        return is_explicit;
+    }
+}
+
+} // namespace detail
+
+
+//----------------------------------------------------------------------------------------------------------------------
+// This function generates a numpy dtype description for a C structure using reflection. It supports nested types,
+// multi-dimensional arrays, enums, named and anonymous unions, and chrono to datetime64 and timedelta64 conversion.
+// Where the numpy default alignment differs from C it will update the dtype to match.
+//
+template <typename T, Endian E = Endian::NONE> std::string desc() {
+    using RawT = std::remove_cvref_t<T>;
+    using UncvR = typename detail::underlying_type<RawT>::type;
+
+    if constexpr (std::is_array_v<UncvR>) {
+        using ElementType = std::remove_all_extents_t<UncvR>;
+
+        if constexpr (std::same_as<ElementType, char>) {
+            return "'S" + std::to_string(sizeof(UncvR)) + "'";
+        } else if constexpr (std::same_as<ElementType, char16_t>) {
+            return "'" + std::string(detail::endian_prefix<E>()) + "U" + std::to_string(sizeof(UncvR) / 2) + "'";
+        } else if constexpr (std::same_as<ElementType, char32_t>) {
+            return "'" + std::string(detail::endian_prefix<E>()) + "U" + std::to_string(sizeof(UncvR) / 4) + "'";
+        } else {
+            return "(" + desc<ElementType, E>() + std::string(detail::array_dims<UncvR>()) + ")";
+        }
+    } else if constexpr (constexpr std::string_view scalar = detail::np_scalar_type<UncvR>(); not scalar.empty()) {
+        if (scalar == "b1" or scalar == "S1" or scalar == "i1" or scalar == "u1") {
+            return "'" + std::string(scalar) + "'";
+        } else {
+            return "'" + std::string(detail::endian_prefix<E>()) + std::string(scalar) + "'";
+        }
+    } else if constexpr (std::is_union_v<UncvR> or std::is_class_v<UncvR>) {
+        constexpr auto ctx = std::meta::access_context::unchecked();
+        constexpr bool has_bases = not std::meta::bases_of(^^UncvR, ctx).empty();
+
+        if constexpr (not has_bases and not detail::explicit_layout<UncvR>()) {  // default numpy layout
+            static constexpr auto members = std::define_static_array(std::meta::nonstatic_data_members_of(^^UncvR, ctx));
+            std::string list = "[";
+            bool is_first = true;
+
+            template for (constexpr std::meta::info member : members) {
+                constexpr std::string_view field_name = std::meta::identifier_of(member);
+                using FieldType = typename[:std::meta::type_of(member):];
+
+                if (not is_first) {
+                    list += ", ";
+                }
+
+                is_first = false;
+                list += "('" + std::string(field_name) + "', " + desc<FieldType, E>() + ")";
+            }
+
+            list += "]";
+            return list;
+        } else {  // explicit dict layout due to base classes, padding, or unions
+            std::string names = "'names': [";
+            std::string formats = "'formats': [";
+            std::string offsets = "'offsets': [";
+            bool is_first = true;
+
+            if constexpr (has_bases) {
+                static constexpr auto bases = std::define_static_array(std::meta::bases_of(^^UncvR, ctx));
+
+                template for (constexpr std::meta::info base : bases) {
+                    using BaseType = typename[:std::meta::type_of(base):];
+                    constexpr std::size_t base_offset = std::meta::offset_of(base).bytes;
+                    static constexpr auto base_members = std::define_static_array(std::meta::nonstatic_data_members_of(^^BaseType, ctx));
+
+                    template for (constexpr std::meta::info bm : base_members) {
+                        if (not is_first) {
+                            names += ", ";
+                            formats += ", ";
+                            offsets += ", ";
+                        }
+
+                        is_first = false;
+                        names += "'" + std::string(std::meta::identifier_of(bm)) + "'";
+                        formats += desc<typename[:std::meta::type_of(bm):], E>();
+                        offsets += std::to_string(base_offset + (std::is_union_v<BaseType> ? 0 : std::meta::offset_of(bm).bytes));
+                    }
+                }
+            }
+
+            static constexpr auto local_members = std::define_static_array(std::meta::nonstatic_data_members_of(^^UncvR, ctx));
+
+            template for (constexpr std::meta::info member : local_members) {
+                constexpr std::string_view field_name = std::meta::identifier_of(member);
+                using FieldType = typename[:std::meta::type_of(member):];
+                constexpr std::size_t offset = std::is_union_v<UncvR> ? 0 : std::meta::offset_of(member).bytes;
+
+                if constexpr (std::is_union_v<FieldType> and field_name.empty()) {   // flatten anonymous unions
+                    static constexpr auto union_members = std::define_static_array(std::meta::nonstatic_data_members_of(^^FieldType, ctx));
+
+                    template for (constexpr std::meta::info u_member : union_members) {
+                        constexpr std::string_view u_name = std::meta::identifier_of(u_member);
+                        using UFieldType = typename[:std::meta::type_of(u_member):];
+
+                        if (not is_first) {
+                            names += ", ";
+                            formats += ", ";
+                            offsets += ", ";
+                        }
+
+                        is_first = false;
+                        names += "'" + std::string(u_name) + "'";
+                        formats += desc<UFieldType, E>();
+                        offsets += std::to_string(offset);
+                    }
+                } else {
+                    if (not is_first) {
+                        names += ", ";
+                        formats += ", ";
+                        offsets += ", ";
+                    }
+
+                    is_first = false;
+                    names += "'" + std::string(field_name) + "'";
+                    formats += desc<FieldType, E>();
+                    offsets += std::to_string(offset);
+                }
+            }
+
+            names += "]";
+            formats += "]";
+            offsets += "]";
+            return "{" + names + ", " + formats + ", " + offsets + ", 'itemsize': " + std::to_string(sizeof(UncvR)) + "}";
+        }
+    } else {
+        static_assert(detail::always_false<UncvR>::value, "Unsupported member type found during dtype conversion");
+    }
+}
+
+}  // namespace pydtype

pydtype_cpp-0.1.0.dist-info/METADATA

@@ -0,0 +1,142 @@
+Metadata-Version: 2.5
+Name: pydtype-cpp
+Version: 0.1.0
+Summary: Compile time C++26 header exposing C structs to numpy dtypes
+Author: Paul Scruby
+Classifier: Programming Language :: C++
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+
+# pydtype
+
+Compile time C++26 exposing C structs to numpy dtypes.  Supports inheritance, nested types, multi-dimensional arrays, 
+enums, named and anonymous unions, and chrono to datetime64 and timedelta64 conversion. Where the numpy default 
+alignment differs from C it will update the dtype to match.
+
+This is currrently an early version that wrote during my day job as a quant which I've released because it maybe useful 
+to the wider numpy community. I've only had time to test it with gcc16.2 on linux. To compile it I had to include the 
+`-std=c++26 -freflection` flags.
+
+I welcome contributions, especially to get it work on other compilers and platforms.
+
+Thanks,
+
+Paul
+
+## Examples
+
+```c++
+#include <pydtype/desc.hpp>
+
+
+struct Simple {
+    std::uint32_t len;
+    float coords[3];
+    double value;
+};
+
+```
+
+`pydtype::desc<Simple>()` will produce:
+```
+[('len', 'u4'), ('coords', ('f4', 3)), ('value', 'f8')]
+```
+
+Here is a more complex example:
+
+```c++
+
+#include <pydtype/desc.hpp>
+
+enum class Type
+    :   std::uint8_t {
+    LINE = 0,
+    TRANSFORM,
+};
+
+#pragma pack(push, 1)
+
+struct Point {
+    double x;
+    double y;
+    double z;
+};
+
+
+class Base {
+public:
+    std::chrono::time_point<std::int64_t, std::chrono::nanoseconds> time;
+    char label[12];
+};
+
+
+class Complex 
+    : public Base {
+public:
+    Type type;
+
+    union {
+        Point line[2];
+        float transform[4][4];
+    } data;
+};
+
+#pragma pack(pop) 
+```
+
+`pydtype::desc<Complex. pydtype::Endian::LITTLE>()` will produce:
+
+```
+{'names': ['time', 'label', 'type', 'data'], 'formats': ['<M8[ns]', 'S12', 'u1', {
+    'names': ['line', 'transform'], 'formats': [([('x', '<f8'), ('y', '<f8'),('z', '<f8')], 2), ('<f4', 4, 4)], 
+        'offsets': [0, 0],'itemsize': 64}], 
+ 'offsets': [0, 8, 20, 21], 'itemsize': 85}
+
+```
+
+Here is another example combining pydtype with the [pybind11](https://github.com/pybind/pybind11) library, returning raw 
+C struct data from C++ to python so it can be accessed directly by numpy.
+
+```c++
+#include <pybind11/pybind11.h>
+#include <pybind11/eval.h>
+#include <pybind11/numpy.h>
+#include <pydtype/desc.hpp>
+
+namespace py = pybind11;
+
+auto ptr = new Simple[10];
+auto cap = py::capsule(ptr, [](void *v) { delete[] reinterpret_cast<Simple*>(v); });
+auto dtype = py::dtype::from_args(py::eval(pydtype::desc<Simple>()));
+return py::array(dtype, {10}, ptr, cap);
+```
+
+## Installation
+
+You can use pip, uv and conda to install the pydtype header file into your current python environment.
+
+### Installing from a local repos (development)
+
+### pip
+```commandline
+git clone https://github.com/blackbox-tech/pydtype.git
+cd pydtype
+python -m pip install .
+```
+
+### uv
+```commandline
+git clone https://github.com/blackbox-tech/pydtype.git
+cd pydtype
+uv pip install .
+```
+
+### conda
+```commandline
+git clone https://github.com/blackbox-tech/pydtype.git
+cd pydtype/conda
+conda build .
+conda install --use-local pydtype
+```

pydtype_cpp-0.1.0.dist-info/RECORD

@@ -0,0 +1,5 @@
+pydtype/desc.hpp,sha256=MyJdiaGjjED3fGeNliXHqnyMTh86JnnumzHNR-fhkHE,14967
+pydtype_cpp-0.1.0.data/data/include/pydtype/desc.hpp,sha256=MyJdiaGjjED3fGeNliXHqnyMTh86JnnumzHNR-fhkHE,14967
+pydtype_cpp-0.1.0.dist-info/METADATA,sha256=vub40yuyAp9N9CFentz1rvnTdX5KP1ZH5phd9T7z0uw,3285
+pydtype_cpp-0.1.0.dist-info/WHEEL,sha256=2iZrJkDIkeDh0k9SikKMqFuRP-ua6mb4Ir1AsER4BEw,87
+pydtype_cpp-0.1.0.dist-info/RECORD,,

pydtype_cpp-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.33.0
+Root-Is-Purelib: true
+Tag: py3-none-any