amulet-core 2.0a5__cp311-cp311-win_amd64.whl → 2.0a6__cp311-cp311-win_amd64.whl

amulet/palette/block_palette.cpp

@@ -0,0 +1,32 @@
+#include "block_palette.hpp"
+
+namespace Amulet {
+	void BlockPalette::serialise(BinaryWriter& writer) const {
+		writer.writeNumeric<std::uint8_t>(1);
+		get_version_range()->serialise(writer);
+		const auto& blocks = get_blocks();
+		writer.writeNumeric<std::uint64_t>(blocks.size());
+		for (const auto& block : blocks) {
+			block->serialise(writer);
+		}
+	}
+	std::shared_ptr<BlockPalette> BlockPalette::deserialise(BinaryReader& reader) {
+		auto version = reader.readNumeric<std::uint8_t>();
+		switch (version) {
+		case 1:
+		{
+			auto version_range = VersionRange::deserialise(reader);
+			auto count = reader.readNumeric<std::uint64_t>();
+			auto palette = std::make_shared<BlockPalette>(version_range);
+			for (auto i = 0; i < count; i++) {
+				if (palette->size() != palette->block_stack_to_index(BlockStack::deserialise(reader))) {
+					throw std::runtime_error("Error deserialising BlockPalette");
+				}
+			}
+			return palette;
+		}
+		default:
+			throw std::invalid_argument("Unsupported BlockComponentData version " + std::to_string(version));
+		}
+	}
+}

amulet/palette/block_palette.hpp

@@ -0,0 +1,93 @@
+#pragma once
+
+#include <map>
+#include <memory>
+#include <stdexcept>
+
+#include <amulet/version.hpp>
+#include <amulet/block.hpp>
+
+#include <amulet/io/binary_reader.hpp>
+#include <amulet/io/binary_writer.hpp>
+
+
+namespace Amulet {
+
+	struct PtrLess {
+		bool operator()(std::shared_ptr<BlockStack> lhs, std::shared_ptr<BlockStack> rhs) const {
+			return *lhs < *rhs;
+		}
+	};
+
+	class BlockPalette : public VersionRangeContainer {
+	private:
+		std::vector<std::shared_ptr<BlockStack>> _index_to_block;
+		std::map<
+			const std::shared_ptr<BlockStack>, 
+			size_t,
+			PtrLess
+		> _block_to_index;
+	public:
+		const std::vector<std::shared_ptr<BlockStack>>& get_blocks() const { return _index_to_block; }
+
+		BlockPalette(std::shared_ptr<VersionRange> version_range) :
+			VersionRangeContainer(version_range),
+			_index_to_block(),
+			_block_to_index() {}
+
+		void serialise(BinaryWriter&) const;
+		static std::shared_ptr<BlockPalette> deserialise(BinaryReader&);
+
+		bool operator==(const BlockPalette& other) const {
+			if (size() != other.size()) {
+				return false;
+			}
+			for (size_t i = 0; i < size(); i++) {
+				if (*_index_to_block[i] != *other._index_to_block[i]) {
+					return false;
+				}
+			}
+			return true;
+		};
+
+		size_t size() const { return _index_to_block.size(); }
+		
+		std::shared_ptr<BlockStack> index_to_block_stack(size_t index) const {
+			return _index_to_block[index];
+		};
+
+		size_t block_stack_to_index(std::shared_ptr<BlockStack> block) {
+			auto it = _block_to_index.find(block);
+			if (it != _block_to_index.end()) {
+				return it->second;
+			}
+			auto version_range = get_version_range();
+			for (const auto& block : block->get_blocks()) {
+				if (!version_range->contains(block->get_platform(), *block->get_version())) {
+					throw std::invalid_argument(
+						"BlockStack(\"" + 
+						block->get_platform() +
+						"\", " +
+						block->get_version()->toString() +
+						") is incompatible with VersionRange(\"" +
+						version_range->get_platform() +
+						"\", " +
+						version_range->get_min_version()->toString() +
+						", " +
+						version_range->get_max_version()->toString() +
+						")."
+					);
+				}
+			}
+			size_t index = _index_to_block.size();
+			_index_to_block.push_back(block);
+			_block_to_index[block] = index;
+			return index;
+		};
+
+		bool contains_block(std::shared_ptr<BlockStack> block) const {
+			return _block_to_index.contains(block);
+		}
+	};
+
+}

amulet/pybind11/collections.hpp

@@ -0,0 +1,76 @@
+#pragma once
+#include <pybind11/pybind11.h>
+
+namespace pybind11 {
+	namespace collections {
+		template <typename T>
+		class Iterator : public object {
+			PYBIND11_OBJECT_DEFAULT(Iterator, object, PyObject_Type)
+				using object::object;
+		};
+	}
+	namespace detail {
+		template <typename T>
+		struct handle_type_name<collections::Iterator<T>> {
+			static constexpr auto name =
+				const_name("collections.abc.Iterator[") +
+				make_caster<T>::name +
+				const_name("]");
+		};
+	}
+	
+	namespace collections {
+		template <typename T>
+		class Sequence : public object {
+			PYBIND11_OBJECT_DEFAULT(Sequence, object, PyObject_Type)
+				using object::object;
+		};
+	}
+	namespace detail {
+		template <typename T>
+		struct handle_type_name<collections::Sequence<T>> {
+			static constexpr auto name =
+				const_name("collections.abc.Sequence[") +
+				make_caster<T>::name +
+				const_name("]");
+		};
+	}
+	
+	namespace collections {
+		template <typename K, typename V>
+		class Mapping : public object {
+			PYBIND11_OBJECT_DEFAULT(Mapping, object, PyObject_Type)
+				using object::object;
+		};
+	}
+	namespace detail {
+		template <typename K, typename V>
+		struct handle_type_name<collections::Mapping<K, V>> {
+			static constexpr auto name =
+				const_name("collections.abc.Mapping[") +
+				make_caster<K>::name +
+				const_name(", ") +
+				make_caster<V>::name +
+				const_name("]");
+		};
+	}
+
+	namespace collections {
+		template <typename K, typename V>
+		class MutableMapping : public object {
+			PYBIND11_OBJECT_DEFAULT(MutableMapping, object, PyObject_Type)
+			using object::object;
+		};
+	}
+	namespace detail {
+		template <typename K, typename V>
+		struct handle_type_name<collections::MutableMapping<K, V>> {
+			static constexpr auto name =
+				const_name("collections.abc.MutableMapping[") +
+				make_caster<K>::name +
+				const_name(", ")
+				+ make_caster<V>::name +
+				const_name("]");
+		};
+	}
+}

amulet/pybind11/py_module.hpp

@@ -0,0 +1,69 @@
+#pragma once
+
+#include <string>
+#include <functional>
+#include <filesystem>
+#include <map>
+#include <utility>
+
+#include <pybind11/pybind11.h>
+
+namespace py = pybind11;
+
+namespace pybind11 {
+	// Define deferred variables
+	inline void def_deferred(
+		py::module m,
+		std::map<std::string, std::function<py::object()>> attrs
+	){
+		m.def(
+			"__getattr__",
+			[attrs](py::object attr) -> py::object {
+				if (py::isinstance<py::str>(attr)) {
+					std::string attr_str = attr.cast<std::string>();
+					auto it = attrs.find(attr_str);
+					if (it != attrs.end()) {
+						return it->second();
+					}
+				}
+				throw py::attribute_error(py::repr(attr));
+			}
+		);
+		m.def(
+			"__dir__",
+			[attrs, m]() {
+				py::set names;
+				// Add the variables defined in the module
+				py::object dict = m.attr("__dict__");
+				for (auto it = dict.begin(); it != dict.end(); it++) {
+					names.add(*it);
+				}
+				// Add the deferred variables
+				for (const auto& [name, _] : attrs) {
+					names.add(py::str(name));
+				}
+				// Return as list
+				return py::module::import("builtins").attr("list")(names);
+			}
+		);
+	}
+
+	inline std::pair<std::string, std::function<py::object()>> deferred_package_path(py::module m_parent, py::module m, std::string name) {
+		auto getter = [m_parent, m, name]() {
+			std::string path = m_parent.attr("__path__").attr("__getitem__")(0).cast<std::string>();
+			path.push_back(std::filesystem::path::preferred_separator);
+			path.append(name);
+			py::list __path__;
+			__path__.append(py::cast(path));
+			return __path__;
+		};
+		return std::make_pair("__path__", getter);
+	}
+
+	inline std::pair<std::string, std::function<py::object()>> deferred_import(std::string module_name, std::string name) {
+		auto getter = [module_name, name]() {
+			return py::module::import(module_name.c_str()).attr(name.c_str());
+		};
+		return std::make_pair(name, getter);
+	}
+}

amulet/pybind11/python.hpp

@@ -0,0 +1,14 @@
+#pragma once
+
+#include <pybind11/pybind11.h>
+
+namespace py = pybind11;
+
+namespace pybind11 {
+	inline bool equals(
+	    const py::handle l,
+	    const py::handle r
+	){
+		return PyObject_RichCompare(l.ptr(), r.ptr(), Py_EQ);
+	}
+}

amulet/pybind11/types.hpp

@@ -0,0 +1,17 @@
+#pragma once
+#include <pybind11/pybind11.h>
+
+namespace pybind11 {
+	namespace types {
+		class NotImplementedType : public object {
+			PYBIND11_OBJECT_DEFAULT(NotImplementedType, object, PyObject_Type)
+				using object::object;
+		};
+	}
+	namespace detail {
+		template <>
+		struct handle_type_name<types::NotImplementedType> {
+			static constexpr auto name = const_name("types.NotImplementedType");
+		};
+	}
+}

amulet/utils/numpy.hpp

@@ -0,0 +1,36 @@
+#pragma once
+
+#include <cstdint>
+#include <vector>
+#include <utility>
+#include <span>
+#include <unordered_map>
+
+
+namespace Amulet {
+    // dtypeT can be any numerical type.
+    // inverseT must be large enough to store the length of arr.
+    template <typename dtypeT, typename inverseT>
+    void unique_inverse(const std::span<dtypeT> arr, std::vector<dtypeT>& unique, std::span<inverseT>& inverse){
+        if (arr.size() != inverse.size()){
+            throw std::invalid_argument("arr and inverse must have the same size.");
+        }
+        if (unique.size()){
+            throw std::invalid_argument("unique must be empty.");
+        }
+        // Map from found values to their index in unique
+        std::unordered_map<dtypeT, inverseT> value_to_index;
+
+        for (inverseT i = 0; i < arr.size(); i++){
+            dtypeT value = arr[i];
+            auto it = value_to_index.find(value);
+            if (it == value_to_index.end()){
+                inverse[i] = unique.size();
+                value_to_index[value] = unique.size();
+                unique.push_back(value);
+            } else {
+                inverse[i] = it->second;
+            }
+        }
+    }
+}

amulet/version.py.cpp

@@ -0,0 +1,281 @@
+#include <sstream>
+
+#include <pybind11/pybind11.h>
+#include <pybind11/stl.h>
+#include <pybind11/operators.h>
+
+#include <amulet/collections/eq.py.hpp>
+#include <amulet/version.hpp>
+
+namespace py = pybind11;
+
+void init_version(py::module m_parent) {
+    auto m = m_parent.def_submodule("version");
+    py::options options;
+
+    m.attr("PlatformType") = py::module::import("builtins").attr("str");
+
+    py::class_<Amulet::VersionNumber, std::shared_ptr<Amulet::VersionNumber>> VersionNumber(m, "VersionNumber",
+        "This class is designed to store semantic versions and data versions and allow comparisons between them.\n"
+        "\n"
+        ">>> v1 = VersionNumber(1, 0, 0)\n"
+        ">>> v2 = VersionNumber(1, 0)\n"
+        ">>> assert v2 == v1\n"
+        "\n"
+        "This class should also be used to store single number data versions.\n"
+        ">>> v3 = VersionNumber(3578)"
+    );
+        options.disable_function_signatures();
+        VersionNumber.def(
+            py::init(
+                [](py::args v){
+                    return std::make_shared<Amulet::VersionNumber>(
+                        v.cast<std::vector<std::int64_t>>()
+                    );
+                }
+            ),
+            py::doc("__init__(self: amulet.version.VersionNumber, *args: typing.SupportsInt) -> None")
+        );
+
+        // Start collections.abc.Sequence
+        VersionNumber.def(
+            "__getitem__",
+            &Amulet::VersionNumber::operator[],
+            py::doc(
+                "__getitem__(*args, **kwargs)\n"
+                "Overloaded function.\n"
+                "1. __getitem__(self: amulet.version.VersionNumber, item: typing.SupportsInt) -> int\n"
+                "2. __getitem__(self: amulet.version.VersionNumber, item: slice) -> list[int]"
+            )
+        );
+        VersionNumber.def(
+            "__getitem__",
+            [](const Amulet::VersionNumber& self, const py::slice &slice) -> std::vector<std::int64_t> {
+                size_t start = 0, stop = 0, step = 0, slicelength = 0;
+                if (!slice.compute(self.size(), &start, &stop, &step, &slicelength)) {
+                    throw py::error_already_set();
+                }
+                std::vector<std::int64_t> out(slicelength);
+                for (size_t i = 0; i < slicelength; ++i) {
+                    out[i] = self[start];
+                    start += step;
+                }
+                return out;
+            }
+        );
+        options.enable_function_signatures();
+
+        VersionNumber.def(
+            "__repr__",
+            [](const Amulet::VersionNumber& self){
+                std::ostringstream oss;
+                auto& vec = self.get_vector();
+                oss << "VersionNumber(";
+                for (size_t i = 0; i < vec.size(); i++){
+                    if (i != 0){
+                        oss << ", ";
+                    }
+                    oss << vec[i];
+                }
+                oss << ")";
+                return oss.str();
+            }
+        );
+        VersionNumber.def(
+            py::pickle(
+                [](const Amulet::VersionNumber& self) {
+                    return py::bytes(Amulet::serialise(self));
+                },
+                [](py::bytes state){
+                    return Amulet::deserialise<Amulet::VersionNumber>(state.cast<std::string>());
+                }
+            )
+        );
+
+        VersionNumber.def(
+            "__len__",
+            &Amulet::VersionNumber::size
+        );
+
+        VersionNumber.def(
+            "__contains__",
+            [](const Amulet::VersionNumber& self, std::int64_t value) {
+                for (auto it = self.begin(); it != self.end(); it++){
+                    if (*it == value) return true;
+                }
+                return false;
+            }
+        );
+
+        VersionNumber.def(
+            "__iter__",
+            [](const Amulet::VersionNumber& self) {return py::make_iterator(self.begin(), self.end());},
+            py::keep_alive<0, 1>() /* Essential: keep object alive while iterator exists */
+        );
+
+        VersionNumber.def(
+            "__reversed__",
+            [](const Amulet::VersionNumber& self) {return py::make_iterator(self.rbegin(), self.rend());},
+            py::keep_alive<0, 1>() /* Essential: keep object alive while iterator exists */
+        );
+
+        VersionNumber.def(
+            "index",
+            [](const Amulet::VersionNumber& self, std::int64_t value, size_t start, size_t stop) {
+                start = std::min(start, self.size());
+                stop = std::min(stop, self.size());
+                for (size_t i = start; i < stop; i++){
+                    if (self[i] == value) return i;
+                }
+                throw py::value_error(std::to_string(value) + " is not in VersionNumber.");
+            },
+            py::arg("value"), py::arg("start") = 0, py::arg("stop") = std::numeric_limits<size_t>::max()
+        );
+
+        VersionNumber.def(
+            "count",
+            [](const Amulet::VersionNumber& self, std::int64_t value) {
+                size_t count = 0;
+                for (size_t i = 0; i < self.size(); i++){
+                    if (self[i] == value) ++count;
+                }
+                return count;
+            },
+            py::arg("value")
+        );
+
+        // End collections.abc.Sequence
+
+        VersionNumber.def(
+            "__str__",
+            &Amulet::VersionNumber::toString
+        );
+
+        Eq(VersionNumber);
+        Eq_default(VersionNumber);
+        VersionNumber.def(pybind11::self < pybind11::self);
+        VersionNumber.def(pybind11::self > pybind11::self);
+        VersionNumber.def(pybind11::self <= pybind11::self);
+        VersionNumber.def(pybind11::self >= pybind11::self);
+
+        VersionNumber.def(
+            "cropped_version",
+            [](const Amulet::VersionNumber& self) -> py::tuple {return py::cast(self.cropped_version());},
+            py::doc("The version number with trailing zeros cut off.")
+        );
+
+        VersionNumber.def(
+            "padded_version",
+            [](const Amulet::VersionNumber& self, size_t len) -> py::tuple {return py::cast(self.padded_version(len));},
+            py::doc("Get the version number padded with zeros to the given length."),
+            py::arg("len")
+        );
+
+        VersionNumber.def(
+            "__hash__",
+            [](const Amulet::VersionNumber& self) {
+                py::tuple py_tuple = py::cast(self.cropped_version());
+                return py::hash(py_tuple);
+            }
+        );
+
+    py::module::import("collections.abc").attr("Sequence").attr("register")(VersionNumber);
+
+
+    py::class_<Amulet::PlatformVersionContainer, std::shared_ptr<Amulet::PlatformVersionContainer>> PlatformVersionContainer(m, "PlatformVersionContainer");
+        PlatformVersionContainer.def(
+            py::init<
+                const Amulet::PlatformType&,
+                std::shared_ptr<Amulet::VersionNumber>
+            >(),
+            py::arg("platform"),
+            py::arg("version")
+        );
+        PlatformVersionContainer.def_property_readonly("platform", &Amulet::PlatformVersionContainer::get_platform);
+        PlatformVersionContainer.def_property_readonly("version", &Amulet::PlatformVersionContainer::get_version);
+        PlatformVersionContainer.def(
+            "__repr__",
+            [](const Amulet::PlatformVersionContainer& self){
+                return "PlatformVersionContainer(" +
+                    py::repr(py::cast(self.get_platform())).cast<std::string>() + ", " +
+                    py::repr(py::cast(self.get_version())).cast<std::string>() +
+                ")";
+            }
+        );
+        PlatformVersionContainer.def(
+            py::pickle(
+                [](const Amulet::PlatformVersionContainer& self) -> py::bytes {
+                    return py::bytes(Amulet::serialise(self));
+                },
+                [](py::bytes state){
+                    return Amulet::deserialise<Amulet::PlatformVersionContainer>(state.cast<std::string>());
+                }
+            )
+        );
+
+
+    py::class_<Amulet::VersionRange, std::shared_ptr<Amulet::VersionRange>> VersionRange(m, "VersionRange");
+        VersionRange.def(
+            py::init<
+                const Amulet::PlatformType&,
+                std::shared_ptr<Amulet::VersionNumber>,
+                std::shared_ptr<Amulet::VersionNumber>
+            >(),
+            py::arg("platform"),
+            py::arg("min_version"),
+            py::arg("max_version")
+        );
+        VersionRange.def_property_readonly("platform", &Amulet::VersionRange::get_platform);
+        VersionRange.def_property_readonly("min_version", &Amulet::VersionRange::get_min_version);
+        VersionRange.def_property_readonly("max_version", &Amulet::VersionRange::get_max_version);
+        VersionRange.def(
+            "contains",
+            &Amulet::VersionRange::contains
+        );
+        VersionRange.def(
+            "__repr__",
+            [](const Amulet::VersionRange& self){
+                return "VersionRange(" +
+                    py::repr(py::cast(self.get_platform())).cast<std::string>() + ", " +
+                    py::repr(py::cast(self.get_min_version())).cast<std::string>() + ", " +
+                    py::repr(py::cast(self.get_max_version())).cast<std::string>() +
+                ")";
+            }
+        );
+        VersionRange.def(
+            py::pickle(
+                [](const Amulet::VersionRange& self) -> py::bytes {
+                    return py::bytes(Amulet::serialise(self));
+                },
+                [](py::bytes state){
+                    return Amulet::deserialise<Amulet::VersionRange>(state.cast<std::string>());
+                }
+            )
+        );
+
+
+    py::class_<Amulet::VersionRangeContainer, std::shared_ptr<Amulet::VersionRangeContainer>> VersionRangeContainer(m, "VersionRangeContainer");
+        VersionRangeContainer.def(
+            py::init<
+                std::shared_ptr<Amulet::VersionRange>
+            >(),
+            py::arg("version_range")
+        );
+        VersionRangeContainer.def_property_readonly("version_range", &Amulet::VersionRangeContainer::get_version_range);
+        VersionRangeContainer.def(
+            "__repr__",
+            [](const Amulet::VersionRangeContainer& self){
+                return "VersionRangeContainer(" + py::repr(py::cast(self.get_version_range())).cast<std::string>() + ")";
+            }
+        );
+        VersionRangeContainer.def(
+            py::pickle(
+                [](const Amulet::VersionRangeContainer& self) -> py::bytes {
+                    return py::bytes(Amulet::serialise(self));
+                },
+                [](py::bytes state){
+                    return Amulet::deserialise<Amulet::VersionRangeContainer>(state.cast<std::string>());
+                }
+            )
+        );
+}

{amulet_core-2.0a5.dist-info → amulet_core-2.0a6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: amulet-core
-Version: 2.0a5
+Version: 2.0a6
 Summary: A Python library for reading/writing Minecraft's various save formats.
 Home-page: https://www.amuletmc.com
 Author: James Clare, Ben Gothard et al.
@@ -10,7 +10,7 @@ Classifier: Programming Language :: Python :: 3
 Classifier: Operating System :: OS Independent
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown
-Requires-Dist: numpy~=1.21
+Requires-Dist: numpy~=2.0
 Requires-Dist: amulet-nbt~=4.0a2
 Requires-Dist: portalocker~=2.4
 Requires-Dist: amulet-leveldb~=1.0b0