pydtype-cpp 0.1.0__tar.gz

pydtype_cpp-0.1.0/.idea/.gitignore

@@ -0,0 +1,5 @@
+# Default ignored files
+/shelf/
+/workspace.xml
+# Editor-based HTTP Client requests
+/httpRequests/

pydtype_cpp-0.1.0/.idea/inspectionProfiles/profiles_settings.xml

@@ -0,0 +1,6 @@
+<component name="InspectionProjectProfileManager">
+  <settings>
+    <option name="USE_PROJECT_PROFILE" value="false" />
+    <version value="1.0" />
+  </settings>
+</component>

pydtype_cpp-0.1.0/.idea/modules.xml

@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectModuleManager">
+    <modules>
+      <module fileurl="file://$PROJECT_DIR$/.idea/pydtype.iml" filepath="$PROJECT_DIR$/.idea/pydtype.iml" />
+      <module fileurl="file://$PROJECT_DIR$/.idea/pydtype@1.iml" filepath="$PROJECT_DIR$/.idea/pydtype@1.iml" />
+    </modules>
+  </component>
+</project>

pydtype_cpp-0.1.0/.idea/pydtype@1.iml

@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module external.system.id="pyproject.toml" type="PYTHON_MODULE" version="4">
+  <component name="NewModuleRootManager">
+    <content url="file://$MODULE_DIR$" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+</module>

pydtype_cpp-0.1.0/.idea/vcs.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="VcsDirectoryMappings">
+    <mapping directory="" vcs="Git" />
+  </component>
+</project>

pydtype_cpp-0.1.0/.idea/workspace.xml

@@ -0,0 +1,119 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="AutoImportSettings">
+    <option name="autoReloadType" value="SELECTIVE" />
+  </component>
+  <component name="ChangeListManager">
+    <list default="true" id="10280a4e-8990-4eff-94b1-57a1975929de" name="Changes" comment="">
+      <change beforePath="$PROJECT_DIR$/pyproject.toml" beforeDir="false" afterPath="$PROJECT_DIR$/pyproject.toml" afterDir="false" />
+    </list>
+    <option name="SHOW_DIALOG" value="false" />
+    <option name="HIGHLIGHT_CONFLICTS" value="true" />
+    <option name="HIGHLIGHT_NON_ACTIVE_CHANGELIST" value="false" />
+    <option name="LAST_RESOLUTION" value="IGNORE" />
+  </component>
+  <component name="Git.Settings">
+    <option name="RECENT_GIT_ROOT_PATH" value="$PROJECT_DIR$" />
+  </component>
+  <component name="NextEditCompletionFeaturesState">
+    <decayedCancelled>
+      <entry key="MS100" value="1.0" />
+      <entry key="MS500" value="1.0" />
+      <entry key="S2" value="1.0" />
+      <entry key="S5" value="1.0" />
+      <entry key="S10" value="1.0" />
+      <entry key="S30" value="1.0" />
+      <entry key="S60" value="1.0000000000332818" />
+      <entry key="M2" value="1.0000095256525936" />
+      <entry key="M5" value="1.0614427211604982" />
+      <entry key="M10" value="3.196249607874741" />
+      <entry key="M15" value="9.111399959265816" />
+      <entry key="M30" value="38.853030710943514" />
+      <entry key="H1" value="106.79374674894471" />
+      <entry key="H2" value="197.82848538401652" />
+      <entry key="H4" value="277.48231820513087" />
+      <entry key="D1" value="373.4882815964569" />
+      <entry key="W1" value="393.5397778892723" />
+    </decayedCancelled>
+    <decayedSelected>
+      <entry key="MS100" value="0.0" />
+      <entry key="MS500" value="0.0" />
+      <entry key="S2" value="0.0" />
+      <entry key="S5" value="2.8101433695149424E-208" />
+      <entry key="S10" value="1.6763482244196597E-104" />
+      <entry key="S30" value="2.5593012743645917E-35" />
+      <entry key="S60" value="5.058953720251442E-18" />
+      <entry key="M2" value="2.249211799778428E-9" />
+      <entry key="M5" value="3.4739165658842264E-4" />
+      <entry key="M10" value="0.01872307429518704" />
+      <entry key="M15" value="0.07252436535566131" />
+      <entry key="M30" value="0.32838990699427145" />
+      <entry key="H1" value="0.8653639116717755" />
+      <entry key="H2" value="1.5515966108213575" />
+      <entry key="H4" value="2.1373905494251955" />
+      <entry key="D1" value="2.8315904602678583" />
+      <entry key="W1" value="2.9752509025309806" />
+    </decayedSelected>
+    <decayedShown>
+      <entry key="MS100" value="0.668963777393056" />
+      <entry key="MS500" value="0.9227424926537983" />
+      <entry key="S2" value="0.9800994153418706" />
+      <entry key="S5" value="0.9919917311220098" />
+      <entry key="S10" value="0.9959878167538044" />
+      <entry key="S30" value="0.9986608129632579" />
+      <entry key="S60" value="0.9993301821869297" />
+      <entry key="M2" value="0.9996745616996886" />
+      <entry key="M5" value="1.0616509231534412" />
+      <entry key="M10" value="3.2147814469933187" />
+      <entry key="M15" value="9.183550690638386" />
+      <entry key="M30" value="39.18058837655255" />
+      <entry key="H1" value="107.65785069158214" />
+      <entry key="H2" value="199.3787654049646" />
+      <entry key="H4" value="279.61870403270444" />
+      <entry key="D1" value="376.3196273310186" />
+      <entry key="W1" value="396.5149913928807" />
+    </decayedShown>
+  </component>
+  <component name="ProjectColorInfo">{
+  &quot;associatedIndex&quot;: 3,
+  &quot;fromUser&quot;: false
+}</component>
+  <component name="ProjectId" id="3LgfrKlIWEvEkUgh2uBDz3vp57F" />
+  <component name="ProjectViewState">
+    <option name="hideEmptyMiddlePackages" value="true" />
+    <option name="showLibraryContents" value="true" />
+  </component>
+  <component name="PropertiesComponent"><![CDATA[{
+  "keyToString": {
+    "ModuleVcsDetector.initialDetectionPerformed": "true",
+    "RunOnceActivity.ShowReadmeOnStart": "true",
+    "RunOnceActivity.git.unshallow": "true",
+    "RunOnceActivity.typescript.service.memoryLimit.init": "true",
+    "codeWithMe.voiceChat.enabledByDefault": "false",
+    "git-widget-placeholder": "main",
+    "last_opened_file_path": "/home/paul/mp-setup",
+    "nodejs_package_manager_path": "npm",
+    "python.packages.toolwindow.project.migrated.to.right.top.v2": "true"
+  }
+}]]></component>
+  <component name="SharedIndexes">
+    <attachedChunks>
+      <set>
+        <option value="bundled-python-sdk-ebb3072d7bdf-5bd6d13a2a75-com.jetbrains.pycharm.pro.sharedIndexes.bundled-PY-262.11879.98" />
+      </set>
+    </attachedChunks>
+  </component>
+  <component name="TaskManager">
+    <task active="true" id="Default" summary="Default task">
+      <changelist id="10280a4e-8990-4eff-94b1-57a1975929de" name="Changes" comment="" />
+      <created>1793880830810</created>
+      <option name="number" value="Default" />
+      <option name="presentableId" value="Default" />
+      <updated>1793880830810</updated>
+    </task>
+    <servers />
+  </component>
+  <component name="TypeScriptGeneratedFilesManager">
+    <option name="version" value="3" />
+  </component>
+</project>

pydtype_cpp-0.1.0/PKG-INFO

@@ -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/README.md

@@ -0,0 +1,131 @@
+# 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/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/pyproject.toml

@@ -0,0 +1,27 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "pydtype-cpp"
+version = "0.1.0"
+description = "Compile time C++26 header exposing C structs to numpy dtypes"
+readme = "README.md"
+requires-python = ">=3.8"
+authors = [
+    { name = "Paul Scruby" }
+]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Programming Language :: C++",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+]
+
+[tool.hatch.build.targets.wheel]
+pure_python = false
+
+[tool.hatch.build.targets.wheel.force-include]
+"include/pydtype" = "pydtype"
+
+[tool.hatch.build.targets.wheel.shared-data]
+"include/pydtype/desc.hpp" = "include/pydtype/desc.hpp"

pydtype_cpp-0.1.0/recipes/meta.yaml

@@ -0,0 +1,27 @@
+{% set name = "pydtype" %}
+{% set version = "0.1.0" %}
+
+package:
+  name: {{ name }}
+  version: {{ version }}
+
+source:
+  git_url:  https://github.com/blackbox-tech/pydtype.git
+  git_rev:  {{ version }}
+
+build:
+  noarch: generic
+  number: 0
+  script:
+    - {{ PYTHON }} -c "import shutil, os; dst = os.path.join(os.environ['PREFIX'], 'include', 'pydtype'); os.makedirs(dst, exist_ok=True); shutil.copy('include/pydtype/desc.hpp', dst)"
+
+requirements:
+  host:
+    - python >=3.8
+  run:
+    - python >=3.8
+
+about:
+  home: https://github.com/blackbox-tech/pydtype
+  license: MIT
+  summary: 'Compile time C++26 header exposing C structs to numpy dtypes'