amulet-pybind11-extensions 1.0.0a0__tar.gz

amulet_pybind11_extensions-1.0.0a0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 gentlegiantJGC
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

amulet_pybind11_extensions-1.0.0a0/MANIFEST.in

@@ -0,0 +1,3 @@
+recursive-include src/pybind11_extensions *.hpp *Config.cmake
+
+prune tests

amulet_pybind11_extensions-1.0.0a0/PKG-INFO

@@ -0,0 +1,28 @@
+Metadata-Version: 2.4
+Name: amulet-pybind11-extensions
+Version: 1.0.0a0
+Summary: An extension library for pybind11.
+Author: James Clare
+Project-URL: Homepage, https://www.amuletmc.com
+Project-URL: Repository, https://github.com/Amulet-Team/Amulet-pybind11-extensions
+Project-URL: Issues, https://github.com/Amulet-Team/Amulet-pybind11-extensions
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: dev
+Requires-Dist: setuptools>=42; extra == "dev"
+Requires-Dist: versioneer; extra == "dev"
+Requires-Dist: wheel; extra == "dev"
+Requires-Dist: pybind11[global]==2.13.6; extra == "dev"
+Requires-Dist: black>=22.3; extra == "dev"
+Dynamic: license-file
+
+# Amulet-pybind11-extensions
+
+This library is an extension to pybind11 to fix some simple issues and add some useful extension classes.
+
+This code is subject to change.
+
+If you want to use it, target a specific commit so that changes don't break your code.

amulet_pybind11_extensions-1.0.0a0/README.md

@@ -0,0 +1,7 @@
+# Amulet-pybind11-extensions
+
+This library is an extension to pybind11 to fix some simple issues and add some useful extension classes.
+
+This code is subject to change.
+
+If you want to use it, target a specific commit so that changes don't break your code.

amulet_pybind11_extensions-1.0.0a0/pyproject.toml

@@ -0,0 +1,54 @@
+[build-system]
+requires = [
+    "setuptools >= 42",
+    "wheel",
+    "versioneer",
+]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "amulet-pybind11-extensions"
+authors = [
+    {name = "James Clare"},
+]
+description = "An extension library for pybind11."
+dynamic = ["version", "readme"]
+requires-python = ">=3.11"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Operating System :: OS Independent",
+]
+
+[project.optional-dependencies]
+dev = [
+    "setuptools>=42",
+    "versioneer",
+    "wheel",
+    "pybind11[global]==2.13.6",
+    "black>=22.3",
+]
+
+[project.urls]
+Homepage = "https://www.amuletmc.com"
+Repository = "https://github.com/Amulet-Team/Amulet-pybind11-extensions"
+Issues = "https://github.com/Amulet-Team/Amulet-pybind11-extensions"
+
+[tool.setuptools]
+include-package-data = false
+
+[tool.setuptools.package-data]
+"*" = [
+    "*Config.cmake",
+    "**/*.hpp",
+]
+
+[tool.setuptools.dynamic]
+readme = {file = ["README.md"], content-type = "text/markdown"}
+
+[tool.versioneer]
+VCS = "git"
+style = "pep440"
+versionfile_source = "src/pybind11_extensions/_version.py"
+versionfile_build = "pybind11_extensions/_version.py"
+tag_prefix = ""
+parentdir_prefix = "pybind11_extensions-"

amulet_pybind11_extensions-1.0.0a0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

amulet_pybind11_extensions-1.0.0a0/setup.py

@@ -0,0 +1,8 @@
+from setuptools import setup
+
+import versioneer
+
+setup(
+    version=versioneer.get_version(),
+    cmdclass=versioneer.get_cmdclass(),
+)

amulet_pybind11_extensions-1.0.0a0/src/amulet_pybind11_extensions.egg-info/PKG-INFO

@@ -0,0 +1,28 @@
+Metadata-Version: 2.4
+Name: amulet-pybind11-extensions
+Version: 1.0.0a0
+Summary: An extension library for pybind11.
+Author: James Clare
+Project-URL: Homepage, https://www.amuletmc.com
+Project-URL: Repository, https://github.com/Amulet-Team/Amulet-pybind11-extensions
+Project-URL: Issues, https://github.com/Amulet-Team/Amulet-pybind11-extensions
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: dev
+Requires-Dist: setuptools>=42; extra == "dev"
+Requires-Dist: versioneer; extra == "dev"
+Requires-Dist: wheel; extra == "dev"
+Requires-Dist: pybind11[global]==2.13.6; extra == "dev"
+Requires-Dist: black>=22.3; extra == "dev"
+Dynamic: license-file
+
+# Amulet-pybind11-extensions
+
+This library is an extension to pybind11 to fix some simple issues and add some useful extension classes.
+
+This code is subject to change.
+
+If you want to use it, target a specific commit so that changes don't break your code.

amulet_pybind11_extensions-1.0.0a0/src/amulet_pybind11_extensions.egg-info/SOURCES.txt

@@ -0,0 +1,21 @@
+LICENSE
+MANIFEST.in
+README.md
+pyproject.toml
+setup.py
+src/amulet_pybind11_extensions.egg-info/PKG-INFO
+src/amulet_pybind11_extensions.egg-info/SOURCES.txt
+src/amulet_pybind11_extensions.egg-info/dependency_links.txt
+src/amulet_pybind11_extensions.egg-info/requires.txt
+src/amulet_pybind11_extensions.egg-info/top_level.txt
+src/pybind11_extensions/__init__.py
+src/pybind11_extensions/_version.py
+src/pybind11_extensions/pybind11_extensionsConfig.cmake
+src/pybind11_extensions/include/pybind11_extensions/builtins.hpp
+src/pybind11_extensions/include/pybind11_extensions/collections.hpp
+src/pybind11_extensions/include/pybind11_extensions/compatibility.hpp
+src/pybind11_extensions/include/pybind11_extensions/contextlib.hpp
+src/pybind11_extensions/include/pybind11_extensions/numpy.hpp
+src/pybind11_extensions/include/pybind11_extensions/py_module.hpp
+src/pybind11_extensions/include/pybind11_extensions/pybind11.hpp
+src/pybind11_extensions/include/pybind11_extensions/types.hpp

amulet_pybind11_extensions-1.0.0a0/src/amulet_pybind11_extensions.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

amulet_pybind11_extensions-1.0.0a0/src/amulet_pybind11_extensions.egg-info/requires.txt

@@ -0,0 +1,7 @@
+
+[dev]
+setuptools>=42
+versioneer
+wheel
+pybind11[global]==2.13.6
+black>=22.3

amulet_pybind11_extensions-1.0.0a0/src/amulet_pybind11_extensions.egg-info/top_level.txt

@@ -0,0 +1 @@
+pybind11_extensions

amulet_pybind11_extensions-1.0.0a0/src/pybind11_extensions/__init__.py

@@ -0,0 +1,3 @@
+from . import _version
+
+__version__ = _version.get_versions()["version"]

amulet_pybind11_extensions-1.0.0a0/src/pybind11_extensions/_version.py

@@ -0,0 +1,21 @@
+
+# This file was generated by 'versioneer.py' (0.29) from
+# revision-control system data, or from the parent directory name of an
+# unpacked source archive. Distribution tarballs contain a pre-generated copy
+# of this file.
+
+import json
+
+version_json = '''
+{
+ "date": "2025-04-14T09:19:50+0100",
+ "dirty": false,
+ "error": null,
+ "full-revisionid": "67aea294a9f9ed7de7b9ee82bcc7dc78fb885d50",
+ "version": "1.0.0a0"
+}
+'''  # END VERSION_JSON
+
+
+def get_versions():
+    return json.loads(version_json)

amulet_pybind11_extensions-1.0.0a0/src/pybind11_extensions/include/pybind11_extensions/builtins.hpp

@@ -0,0 +1,72 @@
+#pragma once
+#include <pybind11/pybind11.h>
+#include <pybind11/detail/descr.h>
+
+// Type hints for builtin types.
+
+
+namespace pybind11_extensions {
+    // Type hint for a native python object.
+    namespace detail {
+        template<size_t N>
+        struct FixedString {
+            char buf[N + 1]{};
+            constexpr FixedString(char const* s) {
+                for (unsigned i = 0; i != N; ++i) buf[i] = s[i];
+            }
+        };
+        template<unsigned N>
+        FixedString(char const (&)[N])->FixedString<N - 1>;
+    }
+
+    // A python object with a user defined string type hint for an arbitrary python object.
+    // This is useful if a C++ function needs to interact with a native python object.
+    template <detail::FixedString T>
+    class PyObjectStr : public pybind11::object {
+        PYBIND11_OBJECT_DEFAULT(PyObjectStr, object, PyObject_Type)
+            using object::object;
+    };
+
+    // A python object with a type hint from a C++ object.
+    // This is useful if you don't want to cast the python object to the C++ object and want to keep the type hint.
+    template <typename cppT>
+    class PyObjectCpp : public pybind11::object {
+        PYBIND11_OBJECT_DEFAULT(PyObjectCpp, object, PyObject_Type)
+            using object::object;
+    };
+
+    template <typename T>
+    class Args : public pybind11::args {
+        using args::args;
+    };
+
+    template <typename T>
+    class KWArgs : public pybind11::kwargs {
+        using kwargs::kwargs;
+    };
+}
+
+
+namespace pybind11 {
+	namespace detail {
+		template <pybind11_extensions::detail::FixedString T>
+		struct handle_type_name<pybind11_extensions::PyObjectStr<T>> {
+			static constexpr auto name = pybind11::detail::const_name(T.buf);
+		};
+
+		template <typename cppT>
+		struct handle_type_name<pybind11_extensions::PyObjectCpp<cppT>> {
+			static constexpr auto name = make_caster<cppT>::name;
+		};
+
+        template <typename T>
+        struct handle_type_name<pybind11_extensions::Args<T>> {
+            static constexpr auto name = const_name("*args: ") + make_caster<T>::name;
+        };
+
+        template <typename T>
+        struct handle_type_name<pybind11_extensions::KWArgs<T>> {
+            static constexpr auto name = const_name("**kwargs: ") + make_caster<T>::name;
+        };
+	}
+}

amulet_pybind11_extensions-1.0.0a0/src/pybind11_extensions/include/pybind11_extensions/collections.hpp

@@ -0,0 +1,209 @@
+#pragma once
+#include <iterator>
+#include <ranges>
+
+#include <pybind11/pybind11.h>
+
+// I have found cases where I want to accept or return a python object matching a collections.abc class.
+// This extension adds subclasses of py::object with type hints for the collections.abc classes.
+// This allows C++ functions to accept or return python objects that match the collection.abc classes.
+// Note that these are handled in the same way as py::object thus there is no type validation.
+
+namespace pybind11_extensions {
+
+template <typename T>
+class Iterator : public pybind11::object {
+public:
+    using iterator_category = std::input_iterator_tag;
+    using difference_type = pybind11::ssize_t;
+    using value_type = T;
+
+    PYBIND11_OBJECT_DEFAULT(Iterator, object, PyIter_Check)
+
+    Iterator& operator++()
+    {
+        advance();
+        return *this;
+    }
+
+    Iterator operator++(int)
+    {
+        auto rv = *this;
+        advance();
+        return rv;
+    }
+
+    T operator*() const
+    {
+        return obj().template cast<T>();
+    }
+
+    std::unique_ptr<T> operator->() const
+    {
+        return std::make_unique<T>(obj().template cast<T>());
+    }
+
+    static Iterator sentinel() { return {}; }
+
+    friend bool operator==(const Iterator& a, const Iterator& b) { return a.obj().ptr() == b.obj().ptr(); }
+    friend bool operator!=(const Iterator& a, const Iterator& b) { return a.obj().ptr() != b.obj().ptr(); }
+
+private:
+    void advance()
+    {
+        value = pybind11::reinterpret_steal<pybind11::object>(PyIter_Next(m_ptr));
+        if (value.ptr() == nullptr && PyErr_Occurred()) {
+            throw pybind11::error_already_set();
+        }
+    }
+
+    const pybind11::object& obj() const
+    {
+        if (m_ptr && !value.ptr()) {
+            auto& self = const_cast<Iterator&>(*this);
+            self.advance();
+        }
+        return value;
+    }
+
+private:
+    pybind11::object value = {};
+};
+static_assert(std::input_iterator<Iterator<int>>);
+
+
+template <typename T>
+class Iterable : public pybind11::object {
+    PYBIND11_OBJECT_DEFAULT(Iterable, object, pybind11::detail::PyIterable_Check)
+    
+    Iterator<T> begin() const
+    {
+        return Iterator<T>(pybind11::object::begin());
+    }
+    Iterator<T> end() const
+    {
+        return Iterator<T>(pybind11::object::end());
+    }
+
+};
+static_assert(std::ranges::input_range<Iterable<int>>);
+static_assert(std::convertible_to<std::ranges::range_value_t<Iterable<int>>, const int&>);
+
+namespace collections {
+    namespace abc {
+        template <typename T>
+        class Iterator : public pybind11::object {
+            PYBIND11_OBJECT_DEFAULT(Iterator, object, PyObject_Type)
+            using object::object;
+        };
+
+        template <typename T>
+        class Iterable : public pybind11::object {
+            PYBIND11_OBJECT_DEFAULT(Iterable, object, PyObject_Type)
+            using object::object;
+        };
+
+        template <typename T>
+        class Sequence : public pybind11::object {
+            PYBIND11_OBJECT_DEFAULT(Sequence, object, PyObject_Type)
+            using object::object;
+        };
+
+        template <typename K, typename V>
+        class Mapping : public pybind11::object {
+            PYBIND11_OBJECT_DEFAULT(Mapping, object, PyObject_Type)
+            using object::object;
+        };
+
+        template <typename K, typename V>
+        class MutableMapping : public pybind11::object {
+            PYBIND11_OBJECT_DEFAULT(MutableMapping, object, PyObject_Type)
+            using object::object;
+        };
+
+        template <typename K>
+        class KeysView : public pybind11::object {
+            PYBIND11_OBJECT_DEFAULT(KeysView, object, PyObject_Type)
+            using object::object;
+        };
+
+        template <typename V>
+        class ValuesView : public pybind11::object {
+            PYBIND11_OBJECT_DEFAULT(ValuesView, object, PyObject_Type)
+            using object::object;
+        };
+
+        template <typename K, typename V>
+        class ItemsView : public pybind11::object {
+            PYBIND11_OBJECT_DEFAULT(ItemsView, object, PyObject_Type)
+            using object::object;
+        };
+    }
+}
+}
+
+namespace pybind11 {
+namespace detail {
+    template <typename T>
+    struct handle_type_name<pybind11_extensions::collections::abc::Iterator<T>> {
+        static constexpr auto name = const_name("collections.abc.Iterator[") + make_caster<T>::name + const_name("]");
+    };
+
+    template <>
+    struct handle_type_name<pybind11_extensions::Iterator<pybind11::object>> {
+        static constexpr auto name = const_name("collections.abc.Iterator");
+    };
+
+    template <typename T>
+    struct handle_type_name<pybind11_extensions::Iterator<T>> {
+        static constexpr auto name = const_name("collections.abc.Iterator[") + make_caster<T>::name + const_name("]");
+    };
+
+    template <typename T>
+    struct handle_type_name<pybind11_extensions::collections::abc::Iterable<T>> {
+        static constexpr auto name = const_name("collections.abc.Iterable[") + make_caster<T>::name + const_name("]");
+    };
+
+    template <>
+    struct handle_type_name<pybind11_extensions::Iterable<pybind11::object>> {
+        static constexpr auto name = const_name("collections.abc.Iterable");
+    };
+
+    template <typename T>
+    struct handle_type_name<pybind11_extensions::Iterable<T>> {
+        static constexpr auto name = const_name("collections.abc.Iterable[") + make_caster<T>::name + const_name("]");
+    };
+
+    template <typename T>
+    struct handle_type_name<pybind11_extensions::collections::abc::Sequence<T>> {
+        static constexpr auto name = const_name("collections.abc.Sequence[") + make_caster<T>::name + const_name("]");
+    };
+
+    template <typename K, typename V>
+    struct handle_type_name<pybind11_extensions::collections::abc::Mapping<K, V>> {
+        static constexpr auto name = const_name("collections.abc.Mapping[") + make_caster<K>::name + const_name(", ") + make_caster<V>::name + const_name("]");
+    };
+
+    template <typename K, typename V>
+    struct handle_type_name<pybind11_extensions::collections::abc::MutableMapping<K, V>> {
+        static constexpr auto name = const_name("collections.abc.MutableMapping[") + make_caster<K>::name + const_name(", ")
+            + make_caster<V>::name + const_name("]");
+    };
+
+    template <typename K>
+    struct handle_type_name<pybind11_extensions::collections::abc::KeysView<K>> {
+        static constexpr auto name = const_name("collections.abc.KeysView[") + make_caster<K>::name + const_name("]");
+    };
+
+    template <typename V>
+    struct handle_type_name<pybind11_extensions::collections::abc::ValuesView<V>> {
+        static constexpr auto name = const_name("collections.abc.ValuesView[") + make_caster<V>::name + const_name("]");
+    };
+
+    template <typename K, typename V>
+    struct handle_type_name<pybind11_extensions::collections::abc::ItemsView<K, V>> {
+        static constexpr auto name = const_name("collections.abc.ItemsView[") + make_caster<K>::name + const_name(", ")
+            + make_caster<V>::name + const_name("]");
+    };
+}
+}

amulet_pybind11_extensions-1.0.0a0/src/pybind11_extensions/include/pybind11_extensions/compatibility.hpp

@@ -0,0 +1,53 @@
+#pragma once
+
+#include <filesystem>
+#include <string>
+
+#include <pybind11/pybind11.h>
+
+static std::string get_version_top(std::string version)
+{
+    return version.substr(0, version.find('.', version.find('.') + 1));
+}
+
+namespace pybind11_extensions {
+
+void init_compiler_config(pybind11::module m)
+{
+    pybind11::dict compiler_config;
+    compiler_config["pybind11_version"] = PYBIND11_VERSION;
+    compiler_config["compiler_id"] = COMPILER_ID;
+    compiler_config["compiler_version"] = COMPILER_VERSION;
+    m.attr("compiler_config") = compiler_config;
+}
+
+void check_compatibility(pybind11::module a, pybind11::module b)
+{
+    std::string a_name = a.attr("__name__").cast<std::string>();
+    std::string b_name = b.attr("__name__").cast<std::string>();
+    pybind11::dict a_config = a.attr("compiler_config");
+    pybind11::dict b_config = b.attr("compiler_config");
+
+    std::string a_pybind11_version = a_config["pybind11_version"].cast<std::string>();
+    std::string b_pybind11_version = b_config["pybind11_version"].cast<std::string>();
+    if (a_pybind11_version != b_pybind11_version) {
+        throw std::runtime_error(
+            "pybind11 version mismatch. " + a_name + " is compiled for pybind11==" + a_pybind11_version + " and " + b_name + " is compiled for pybind11==" + b_pybind11_version);
+    }
+
+    std::string a_compiler_id = a_config["compiler_id"].cast<std::string>();
+    std::string b_compiler_id = b_config["compiler_id"].cast<std::string>();
+    if (a_compiler_id != b_compiler_id) {
+        throw std::runtime_error(
+            "compiler mismatch. " + a_name + " is compiled by " + a_compiler_id + " and " + b_name + " is compiled by " + b_compiler_id);
+    }
+
+    std::string a_compiler_version = a_config["compiler_version"].cast<std::string>();
+    std::string b_compiler_version = b_config["compiler_version"].cast<std::string>();
+    if (get_version_top(a_compiler_version) != get_version_top(b_compiler_version)) {
+        throw std::runtime_error(
+            "compiler version mismatch. " + a_name + " is compiled by " + a_compiler_id + " " + a_compiler_version + " and " + b_name + " is compiled by " + b_compiler_id + " " + b_compiler_version);
+    }
+}
+
+}

amulet_pybind11_extensions-1.0.0a0/src/pybind11_extensions/include/pybind11_extensions/contextlib.hpp

@@ -0,0 +1,69 @@
+#pragma once
+
+#include <pybind11/pybind11.h>
+#include <pybind11/stl.h>
+
+#include <functional>
+#include <optional>
+#include <type_traits>
+
+namespace pybind11_extensions {
+
+namespace contextlib {
+    template <typename T, typename ExitT = std::optional<bool>>
+    class ContextManager : public pybind11::object {
+        PYBIND11_OBJECT_DEFAULT(ContextManager, object, PyObject_Type)
+        using object::object;
+    };
+
+    namespace detail {
+        template <typename T, typename ExitT = std::optional<bool>>
+        class ContextManager {
+        public:
+            std::function<T()> enter;
+            std::function<ExitT(pybind11::object, pybind11::object, pybind11::object)> exit;
+            ContextManager(
+                std::function<T()> enter,
+                std::function<ExitT(pybind11::object, pybind11::object, pybind11::object)> exit)
+                : enter(enter)
+                , exit(exit)
+            {
+            }
+        };
+    }
+
+    template <typename T, typename ExitT = std::optional<bool>>
+    auto make_context_manager(
+        std::function<T()> enter,
+        std::function<ExitT(pybind11::object, pybind11::object, pybind11::object)> exit) -> ContextManager<T, ExitT>
+    {
+        using ContextManagerT = detail::ContextManager<T, ExitT>;
+        if (!pybind11::detail::get_type_info(typeid(ContextManagerT), false)) {
+            pybind11::class_<ContextManagerT>(pybind11::handle(), "ContextManager", pybind11::module_local())
+                .def(
+                    "__enter__",
+                    [](const ContextManagerT& self) -> T {
+                        return self.enter();
+                    })
+                .def(
+                    "__exit__",
+                    [](const ContextManagerT& self, pybind11::object exc_type, pybind11::object exc_val, pybind11::object exc_tb) -> ExitT {
+                        return self.exit(exc_type, exc_val, exc_tb);
+                    });
+        }
+        return pybind11::cast(ContextManagerT(enter, exit));
+    }
+}
+
+}
+
+namespace pybind11 {
+namespace detail {
+    template <typename T, typename ExitT>
+    struct handle_type_name<pybind11_extensions::contextlib::ContextManager<T, ExitT>> {
+        static constexpr auto name = const_name("contextlib.AbstractContextManager[")
+            + make_caster<std::conditional_t<std::is_same_v<void, T>, pybind11::none, T>>::name
+            + const_name(", ") + make_caster<ExitT>::name + const_name("]");
+    };
+}
+}

amulet_pybind11_extensions-1.0.0a0/src/pybind11_extensions/include/pybind11_extensions/numpy.hpp

@@ -0,0 +1,29 @@
+#pragma once
+#include <pybind11/pybind11.h>
+#include <pybind11/numpy.h>
+
+
+// The pybind11 type hint for array_t is incorrect
+// This extension adds a subclass of array_t with the correct type hint.
+// See pybind/pybind11/pull/5212
+
+
+namespace pybind11_extensions {
+    namespace numpy {
+        template <typename T, int ExtraFlags = pybind11::array::forcecast>
+        class array_t : public pybind11::array_t<T, ExtraFlags> {
+            using pybind11::array_t<T, ExtraFlags>::array_t;
+        };
+    }
+}
+
+
+namespace pybind11 {
+	namespace detail {
+		template <typename T, int Flags>
+		struct handle_type_name<pybind11_extensions::numpy::array_t<T, Flags>> {
+			static constexpr auto name
+				= const_name("numpy.typing.NDArray[") + npy_format_descriptor<T>::name + const_name("]");
+		};
+	}
+}

amulet_pybind11_extensions-1.0.0a0/src/pybind11_extensions/include/pybind11_extensions/py_module.hpp

@@ -0,0 +1,40 @@
+#pragma once
+
+#include <string>
+#include <filesystem>
+
+#include <pybind11/pybind11.h>
+
+
+namespace pybind11_extensions {
+    namespace detail {
+        inline void def_package_path(pybind11::module m_parent, pybind11::module m, std::string name) {
+            pybind11::list paths;
+            pybind11::list parent_paths = m_parent.attr("__path__").cast<pybind11::list>();
+            for (auto py_path : parent_paths) {
+                if (pybind11::isinstance<pybind11::str>(py_path)) {
+                    std::string path = py_path.cast<std::string>();
+                    path.push_back(std::filesystem::path::preferred_separator);
+                    path.append(name);
+                    paths.append(pybind11::cast(path));
+                }
+            }
+            m.attr("__path__") = paths;
+        }
+    }
+
+    // pybind11 enables creation of sub-modules but not sub-packages.
+    // This function creates a sub-module and defines __path__ to make it a package.
+    // This enables importing from python modules within the package.
+    inline pybind11::module def_subpackage(pybind11::module m_parent, std::string name) {
+        auto m = m_parent.def_submodule(name.c_str());
+        detail::def_package_path(m_parent, m, name);
+        return m;
+    }
+
+    // __path__ is not defined on the root module until after the pybind11 module constructor finishes.
+    // This function patches in the root __path__ to enable def_subpackage to access it.
+    inline void set_package_path(pybind11::module m, std::string module_name) {
+        m.attr("__path__") = pybind11::module::import("importlib.util").attr("find_spec")(module_name).attr("submodule_search_locations");
+    }
+}

amulet_pybind11_extensions-1.0.0a0/src/pybind11_extensions/include/pybind11_extensions/pybind11.hpp

@@ -0,0 +1,34 @@
+#pragma once
+#include <pybind11/pybind11.h>
+
+#include "builtins.hpp"
+#include "collections.hpp"
+
+namespace pybind11_extensions {
+
+// Create a python iterator around a C++ class that implements method next()
+// Next should throw py::stop_iteration() to signal the end of the iterator.
+template <
+    typename T,
+    pybind11::return_value_policy Policy = pybind11::return_value_policy::automatic,
+    typename... Extra>
+auto make_iterator(T&& obj, Extra&&... extra) -> pybind11_extensions::collections::abc::Iterator<decltype(obj.next())>
+{
+    if (!pybind11::detail::get_type_info(typeid(T), false)) {
+        pybind11::class_<T>(pybind11::handle(), "iterator", pybind11::module_local())
+            .def(
+                "__iter__",
+                [](
+                    pybind11_extensions::PyObjectCpp<T>& s) -> pybind11_extensions::PyObjectCpp<T>& { return s; })
+            .def(
+                "__next__",
+                [](T& s) -> decltype(obj.next()) {
+                    return s.next();
+                },
+                std::forward<Extra>(extra)...,
+                Policy);
+    }
+    return pybind11::cast(std::move(obj));
+}
+
+} // namespace pybind11_extensions

amulet_pybind11_extensions-1.0.0a0/src/pybind11_extensions/include/pybind11_extensions/types.hpp

@@ -0,0 +1,13 @@
+#pragma once
+#include <pybind11/pybind11.h>
+#include "builtins.hpp"
+
+// This extension adds a py::object subclass for types.NotImplementedType.
+// This is used as a return in comparison operators.
+
+
+namespace pybind11_extensions {
+    namespace types {
+        using NotImplementedType = pybind11_extensions::PyObjectStr<"types.NotImplementedType">;
+    }
+}

amulet_pybind11_extensions-1.0.0a0/src/pybind11_extensions/pybind11_extensionsConfig.cmake

@@ -0,0 +1,8 @@
+if (NOT TARGET pybind11_extensions)
+    set(pybind11_extensions_INCLUDE_DIR "${CMAKE_CURRENT_LIST_DIR}/include")
+
+    add_library(pybind11_extensions IMPORTED INTERFACE)
+    set_target_properties(pybind11_extensions PROPERTIES
+        INTERFACE_INCLUDE_DIRECTORIES "${pybind11_extensions_INCLUDE_DIR}"
+    )
+endif()